gbp_contract::event_handler gbp_contract::m_evh;
-gbp_contract::gbp_contract(epg_id_t src_epg_id,
- epg_id_t dst_epg_id,
+gbp_contract::gbp_contract(sclass_t sclass,
+ sclass_t dclass,
const ACL::l3_list& acl,
const gbp_rules_t& rules,
const ethertype_set_t& allowed_ethertypes)
: m_hw(false)
- , m_src_epg_id(src_epg_id)
- , m_dst_epg_id(dst_epg_id)
+ , m_sclass(sclass)
+ , m_dclass(dclass)
, m_acl(acl.singular())
, m_gbp_rules(rules)
, m_allowed_ethertypes(allowed_ethertypes)
gbp_contract::gbp_contract(const gbp_contract& gbpc)
: m_hw(gbpc.m_hw)
- , m_src_epg_id(gbpc.m_src_epg_id)
- , m_dst_epg_id(gbpc.m_dst_epg_id)
+ , m_sclass(gbpc.m_sclass)
+ , m_dclass(gbpc.m_dclass)
, m_acl(gbpc.m_acl)
, m_gbp_rules(gbpc.m_gbp_rules)
, m_allowed_ethertypes(gbpc.m_allowed_ethertypes)
const gbp_contract::key_t
gbp_contract::key() const
{
- return (std::make_pair(m_src_epg_id, m_dst_epg_id));
+ return (std::make_pair(m_sclass, m_dclass));
}
bool
gbp_contract::sweep()
{
if (m_hw) {
- HW::enqueue(
- new gbp_contract_cmds::delete_cmd(m_hw, m_src_epg_id, m_dst_epg_id));
+ HW::enqueue(new gbp_contract_cmds::delete_cmd(m_hw, m_sclass, m_dclass));
}
HW::write();
}
gbp_contract::replay()
{
if (m_hw) {
- HW::enqueue(new gbp_contract_cmds::create_cmd(
- m_hw, m_src_epg_id, m_dst_epg_id, m_acl->handle(), m_gbp_rules,
- m_allowed_ethertypes));
+ HW::enqueue(new gbp_contract_cmds::create_cmd(m_hw, m_sclass, m_dclass,
+ m_acl->handle(), m_gbp_rules,
+ m_allowed_ethertypes));
}
}
gbp_contract::to_string() const
{
std::ostringstream s;
- s << "gbp-contract:[{" << m_src_epg_id << ", " << m_dst_epg_id << "}, "
+ s << "gbp-contract:[{" << m_sclass << ", " << m_dclass << "}, "
<< m_acl->to_string();
if (m_gbp_rules.size()) {
auto it = m_gbp_rules.cbegin();
* create the table if it is not yet created
*/
if (rc_t::OK != m_hw.rc()) {
- HW::enqueue(new gbp_contract_cmds::create_cmd(
- m_hw, m_src_epg_id, m_dst_epg_id, m_acl->handle(), m_gbp_rules,
- m_allowed_ethertypes));
+ HW::enqueue(new gbp_contract_cmds::create_cmd(m_hw, m_sclass, m_dclass,
+ m_acl->handle(), m_gbp_rules,
+ m_allowed_ethertypes));
}
}
allowed_ethertypes.insert(ethertype_t::from_numeric_val(et[i]));
}
- gbp_contract gbpc(payload.contract.src_epg, payload.contract.dst_epg,
- *acl, rules, allowed_ethertypes);
+ gbp_contract gbpc(payload.contract.sclass, payload.contract.dclass, *acl,
+ rules, allowed_ethertypes);
OM::commit(key, gbpc);
VOM_LOG(log_level_t::DEBUG) << "read: " << gbpc.to_string();
/**
* The key for a contract is the pari of EPG-IDs
*/
- typedef std::pair<epg_id_t, epg_id_t> key_t;
+ typedef std::pair<sclass_t, sclass_t> key_t;
/**
* A set of allowed ethertypes
/**
* Construct a GBP contract
*/
- gbp_contract(epg_id_t src_epg_id,
- epg_id_t dst_epg_id,
+ gbp_contract(sclass_t sclass,
+ sclass_t dclass,
const ACL::l3_list& acl,
const gbp_rules_t& gpb_rules,
const ethertype_set_t& allowed_ethertypes);
/**
* The source EPG ID
*/
- epg_id_t m_src_epg_id;
+ sclass_t m_sclass;
/**
* The destination EPG ID
*/
- epg_id_t m_dst_epg_id;
+ sclass_t m_dclass;
/**
* The ACL applied to traffic between the gourps
namespace gbp_contract_cmds {
create_cmd::create_cmd(HW::item<bool>& item,
- epg_id_t src_epg_id,
- epg_id_t dst_epg_id,
+ sclass_t sclass,
+ sclass_t dclass,
const handle_t& acl,
const gbp_contract::gbp_rules_t& gbp_rules,
const gbp_contract::ethertype_set_t& allowed_ethertypes)
: rpc_cmd(item)
- , m_src_epg_id(src_epg_id)
- , m_dst_epg_id(dst_epg_id)
+ , m_sclass(sclass)
+ , m_dclass(dclass)
, m_acl(acl)
, m_gbp_rules(gbp_rules)
, m_allowed_ethertypes(allowed_ethertypes)
bool
create_cmd::operator==(const create_cmd& other) const
{
- return ((m_acl == other.m_acl) && (m_src_epg_id == other.m_src_epg_id) &&
- (m_dst_epg_id == other.m_dst_epg_id) &&
- (m_gbp_rules == other.m_gbp_rules) &&
+ return ((m_acl == other.m_acl) && (m_sclass == other.m_sclass) &&
+ (m_dclass == other.m_dclass) && (m_gbp_rules == other.m_gbp_rules) &&
(m_allowed_ethertypes == other.m_allowed_ethertypes));
}
auto& payload = req.get_request().get_payload();
payload.is_add = 1;
payload.contract.acl_index = m_acl.value();
- payload.contract.src_epg = m_src_epg_id;
- payload.contract.dst_epg = m_dst_epg_id;
+ payload.contract.sclass = m_sclass;
+ payload.contract.dclass = m_dclass;
uint32_t ii = 0;
payload.contract.n_rules = n_rules;
{
std::ostringstream s;
s << "gbp-contract-create: " << m_hw_item.to_string()
- << " src-epg-id:" << m_src_epg_id << " dst-epg-id:" << m_dst_epg_id
- << " acl:" << m_acl;
+ << " sclass:" << m_sclass << " dclass:" << m_dclass << " acl:" << m_acl;
s << "[ethertype:";
for (auto e : m_allowed_ethertypes)
s << " " << e;
return (s.str());
}
-delete_cmd::delete_cmd(HW::item<bool>& item,
- epg_id_t src_epg_id,
- epg_id_t dst_epg_id)
+delete_cmd::delete_cmd(HW::item<bool>& item, sclass_t sclass, sclass_t dclass)
: rpc_cmd(item)
- , m_src_epg_id(src_epg_id)
- , m_dst_epg_id(dst_epg_id)
+ , m_sclass(sclass)
+ , m_dclass(dclass)
{
}
bool
delete_cmd::operator==(const delete_cmd& other) const
{
- return ((m_src_epg_id == other.m_src_epg_id) &&
- (m_dst_epg_id == other.m_dst_epg_id));
+ return ((m_sclass == other.m_sclass) && (m_dclass == other.m_dclass));
}
rc_t
auto& payload = req.get_request().get_payload();
payload.is_add = 0;
payload.contract.acl_index = ~0;
- payload.contract.src_epg = m_src_epg_id;
- payload.contract.dst_epg = m_dst_epg_id;
+ payload.contract.sclass = m_sclass;
+ payload.contract.dclass = m_dclass;
VAPI_CALL(req.execute());
{
std::ostringstream s;
s << "gbp-contract-delete: " << m_hw_item.to_string()
- << " src-epg-id:" << m_src_epg_id << " dst-epg-id:" << m_dst_epg_id;
+ << " src-epg-id:" << m_sclass << " dst-epg-id:" << m_dclass;
return (s.str());
}
* Constructor
*/
create_cmd(HW::item<bool>& item,
- epg_id_t src_epg_id,
- epg_id_t dst_epg_id,
+ sclass_t sclass,
+ sclass_t dclass,
const handle_t& acl,
const gbp_contract::gbp_rules_t& gbp_rules,
const gbp_contract::ethertype_set_t& allowed_ethertypes);
bool operator==(const create_cmd& i) const;
private:
- const epg_id_t m_src_epg_id;
- const epg_id_t m_dst_epg_id;
+ const sclass_t m_sclass;
+ const sclass_t m_dclass;
const handle_t m_acl;
const gbp_contract::gbp_rules_t& m_gbp_rules;
const gbp_contract::ethertype_set_t& m_allowed_ethertypes;
/**
* Constructor
*/
- delete_cmd(HW::item<bool>& item, epg_id_t src_epg_id, epg_id_t dst_epg_id);
+ delete_cmd(HW::item<bool>& item, sclass_t sclass, sclass_t dclass);
/**
* Issue the command to VPP/HW
bool operator==(const delete_cmd& i) const;
private:
- const epg_id_t m_src_epg_id;
- const epg_id_t m_dst_epg_id;
+ const sclass_t m_sclass;
+ const sclass_t m_dclass;
};
/**
{
if (m_hdl) {
HW::enqueue(new gbp_endpoint_cmds::create_cmd(m_hdl, m_itf->handle(), m_ips,
- m_mac, m_epg->id()));
+ m_mac, m_epg->sclass()));
}
}
{
if (rc_t::OK != m_hdl.rc()) {
HW::enqueue(new gbp_endpoint_cmds::create_cmd(m_hdl, m_itf->handle(), m_ips,
- m_mac, m_epg->id()));
+ m_mac, m_epg->sclass()));
}
}
std::shared_ptr<interface> itf =
interface::find(payload.endpoint.sw_if_index);
std::shared_ptr<gbp_endpoint_group> epg =
- gbp_endpoint_group::find(payload.endpoint.epg_id);
+ gbp_endpoint_group::find(payload.endpoint.sclass);
mac_address_t mac = from_api(payload.endpoint.mac);
VOM_LOG(log_level_t::DEBUG) << "data: " << payload.endpoint.sw_if_index;
} else {
VOM_LOG(log_level_t::ERROR)
<< "no interface:" << payload.endpoint.sw_if_index
- << "or epg:" << payload.endpoint.epg_id;
+ << "or sclass:" << payload.endpoint.sclass;
}
}
}
const handle_t& itf,
const std::vector<boost::asio::ip::address>& ip_addrs,
const mac_address_t& mac,
- epg_id_t epg_id)
+ sclass_t sclass)
: rpc_cmd(item)
, m_itf(itf)
, m_ip_addrs(ip_addrs)
, m_mac(mac)
- , m_epg_id(epg_id)
+ , m_sclass(sclass)
{
}
create_cmd::operator==(const create_cmd& other) const
{
return ((m_itf == other.m_itf) && (m_ip_addrs == other.m_ip_addrs) &&
- (m_mac == other.m_mac) && (m_epg_id == other.m_epg_id));
+ (m_mac == other.m_mac) && (m_sclass == other.m_sclass));
}
rc_t
auto& payload = req.get_request().get_payload();
payload.endpoint.sw_if_index = m_itf.value();
- payload.endpoint.epg_id = m_epg_id;
+ payload.endpoint.sclass = m_sclass;
payload.endpoint.n_ips = m_ip_addrs.size();
for (n = 0; n < payload.endpoint.n_ips; n++) {
s << ip.to_string();
s << "] mac:" << m_mac;
- s << " epg-id:" << m_epg_id;
+ s << " slcass:" << m_sclass;
return (s.str());
}
namespace gbp_endpoint_cmds {
/**
-* A command class that creates or updates the GBP endpoint
-*/
+ * A command class that creates or updates the GBP endpoint
+ */
class create_cmd : public rpc_cmd<HW::item<handle_t>, vapi::Gbp_endpoint_add>
{
public:
const handle_t& itf,
const std::vector<boost::asio::ip::address>& ip_addrs,
const mac_address_t& mac,
- epg_id_t epg_id);
+ sclass_t sclass);
/**
* Issue the command to VPP/HW
const handle_t m_itf;
const std::vector<boost::asio::ip::address> m_ip_addrs;
const mac_address_t m_mac;
- const epg_id_t m_epg_id;
+ const sclass_t m_sclass;
};
/**
return std::to_string(remote_ep_timeout);
}
-gbp_endpoint_group::gbp_endpoint_group(epg_id_t epg_id,
+gbp_endpoint_group::gbp_endpoint_group(vnid_t vnid,
+ sclass_t sclass,
const interface& itf,
const gbp_route_domain& rd,
const gbp_bridge_domain& bd)
: m_hw(false)
- , m_epg_id(epg_id)
- , m_sclass(0xffff)
+ , m_vnid(vnid)
+ , m_sclass(sclass)
, m_itf(itf.singular())
, m_rd(rd.singular())
, m_bd(bd.singular())
{
}
-gbp_endpoint_group::gbp_endpoint_group(epg_id_t epg_id,
+gbp_endpoint_group::gbp_endpoint_group(vnid_t vnid,
+ sclass_t sclass,
const gbp_route_domain& rd,
const gbp_bridge_domain& bd)
: m_hw(false)
- , m_epg_id(epg_id)
- , m_sclass(0xffff)
- , m_itf()
- , m_rd(rd.singular())
- , m_bd(bd.singular())
- , m_retention()
-{
-}
-
-gbp_endpoint_group::gbp_endpoint_group(epg_id_t epg_id,
- uint16_t sclass,
- const interface& itf,
- const gbp_route_domain& rd,
- const gbp_bridge_domain& bd)
- : m_hw(false)
- , m_epg_id(epg_id)
+ , m_vnid(vnid)
, m_sclass(sclass)
- , m_itf(itf.singular())
+ , m_itf()
, m_rd(rd.singular())
, m_bd(bd.singular())
, m_retention()
{
}
-gbp_endpoint_group::gbp_endpoint_group(epg_id_t epg_id,
- uint16_t sclass,
+gbp_endpoint_group::gbp_endpoint_group(sclass_t sclass,
const gbp_route_domain& rd,
const gbp_bridge_domain& bd)
: m_hw(false)
- , m_epg_id(epg_id)
+ , m_vnid(~0)
, m_sclass(sclass)
, m_itf()
, m_rd(rd.singular())
gbp_endpoint_group::gbp_endpoint_group(const gbp_endpoint_group& epg)
: m_hw(epg.m_hw)
- , m_epg_id(epg.m_epg_id)
+ , m_vnid(epg.m_vnid)
, m_sclass(epg.m_sclass)
, m_itf(epg.m_itf)
, m_rd(epg.m_rd)
const gbp_endpoint_group::key_t
gbp_endpoint_group::key() const
{
- return (m_epg_id);
+ return (m_sclass);
}
-epg_id_t
-gbp_endpoint_group::id() const
+vnid_t
+gbp_endpoint_group::vnid() const
{
- return (m_epg_id);
+ return (m_vnid);
}
void
m_retention = retention;
}
+sclass_t
+gbp_endpoint_group::sclass() const
+{
+ return (m_sclass);
+}
+
bool
gbp_endpoint_group::operator==(const gbp_endpoint_group& gg) const
{
- return (key() == gg.key() && (m_sclass == gg.m_sclass) &&
+ return (key() == gg.key() && (m_vnid == gg.m_vnid) &&
(m_retention == gg.m_retention) && (m_itf == gg.m_itf) &&
(m_rd == gg.m_rd) && (m_bd == gg.m_bd));
}
gbp_endpoint_group::sweep()
{
if (m_hw) {
- HW::enqueue(new gbp_endpoint_group_cmds::delete_cmd(m_hw, m_epg_id));
+ HW::enqueue(new gbp_endpoint_group_cmds::delete_cmd(m_hw, m_vnid));
}
HW::write();
}
{
if (m_hw) {
HW::enqueue(new gbp_endpoint_group_cmds::create_cmd(
- m_hw, m_epg_id, m_sclass, m_bd->id(), m_rd->id(), m_retention,
+ m_hw, m_vnid, m_sclass, m_bd->id(), m_rd->id(), m_retention,
(m_itf ? m_itf->handle() : handle_t::INVALID)));
}
}
{
std::ostringstream s;
s << "gbp-endpoint-group:["
- << "epg:" << m_epg_id << ", sclass:" << m_sclass << ", "
+ << "vnid:" << m_vnid << ", sclass:" << m_sclass << ", "
<< "retention:[" << m_retention.to_string() << "], "
<< (m_itf ? m_itf->to_string() : "NULL") << ", " << m_bd->to_string()
<< ", " << m_rd->to_string() << "]";
{
if (rc_t::OK != m_hw.rc()) {
HW::enqueue(new gbp_endpoint_group_cmds::create_cmd(
- m_hw, m_epg_id, m_sclass, m_bd->id(), m_rd->id(), m_retention,
+ m_hw, m_vnid, m_sclass, m_bd->id(), m_rd->id(), m_retention,
(m_itf ? m_itf->handle() : handle_t::INVALID)));
}
}
<< payload.epg.bd_id << "]";
if (itf && bd && rd) {
- gbp_endpoint_group gbpe(payload.epg.epg_id, payload.epg.sclass, *itf, *rd,
+ gbp_endpoint_group gbpe(payload.epg.vnid, payload.epg.sclass, *itf, *rd,
*bd);
OM::commit(key, gbpe);
VOM_LOG(log_level_t::DEBUG) << "read: " << gbpe.to_string();
} else if (bd && rd) {
- gbp_endpoint_group gbpe(payload.epg.epg_id, payload.epg.sclass, *rd, *bd);
+ gbp_endpoint_group gbpe(payload.epg.sclass, *rd, *bd);
OM::commit(key, gbpe);
VOM_LOG(log_level_t::DEBUG) << "read: " << gbpe.to_string();
/**
* EPG IDs are 32 bit integers
*/
-typedef uint32_t epg_id_t;
+typedef uint32_t vnid_t;
+typedef uint16_t sclass_t;
/**
* A entry in the ARP termination table of a Bridge Domain
/**
* The key for a GBP endpoint group is its ID
*/
- typedef epg_id_t key_t;
+ typedef sclass_t key_t;
/**
* Construct a GBP endpoint_group
*/
- gbp_endpoint_group(epg_id_t epg_id,
+ gbp_endpoint_group(vnid_t vnid,
+ sclass_t sclass,
const interface& itf,
const gbp_route_domain& rd,
const gbp_bridge_domain& bd);
- gbp_endpoint_group(epg_id_t epg_id,
+ gbp_endpoint_group(vnid_t vnid,
+ sclass_t sclass,
const gbp_route_domain& rd,
const gbp_bridge_domain& bd);
- gbp_endpoint_group(epg_id_t epg_id,
- uint16_t sclass,
- const interface& itf,
- const gbp_route_domain& rd,
- const gbp_bridge_domain& bd);
- gbp_endpoint_group(epg_id_t epg_id,
- uint16_t sclass,
+ gbp_endpoint_group(sclass_t sclass,
const gbp_route_domain& rd,
const gbp_bridge_domain& bd);
/**
* Get the ID of the EPG
*/
- epg_id_t id() const;
+ vnid_t vnid() const;
+ sclass_t sclass() const;
const std::shared_ptr<gbp_route_domain> get_route_domain() const;
const std::shared_ptr<gbp_bridge_domain> get_bridge_domain() const;
/**
* The EPG ID
*/
- epg_id_t m_epg_id;
+ vnid_t m_vnid;
/**
* The SClass on the wire
namespace gbp_endpoint_group_cmds {
create_cmd::create_cmd(HW::item<bool>& item,
- epg_id_t epg_id,
+ vnid_t vnid,
uint16_t sclass,
uint32_t bd_id,
route::table_id_t rd_id,
const gbp_endpoint_group::retention_t& retention,
const handle_t& itf)
: rpc_cmd(item)
- , m_epg_id(epg_id)
+ , m_vnid(vnid)
, m_sclass(sclass)
, m_bd_id(bd_id)
, m_rd_id(rd_id)
create_cmd::operator==(const create_cmd& other) const
{
return ((m_itf == other.m_itf) && (m_bd_id == other.m_bd_id) &&
- (m_rd_id == other.m_rd_id) && (m_epg_id == other.m_epg_id) &&
+ (m_rd_id == other.m_rd_id) && (m_vnid == other.m_vnid) &&
(m_retention == other.m_retention));
}
auto& payload = req.get_request().get_payload();
payload.epg.uplink_sw_if_index = m_itf.value();
- payload.epg.epg_id = m_epg_id;
+ payload.epg.vnid = m_vnid;
payload.epg.sclass = m_sclass;
payload.epg.bd_id = m_bd_id;
payload.epg.rd_id = m_rd_id;
{
std::ostringstream s;
s << "gbp-endpoint-group-create: " << m_hw_item.to_string()
- << " epg-id:" << m_epg_id << " bd-id:" << m_bd_id << " rd-id:" << m_rd_id
+ << " vnid:" << m_vnid << " bd-id:" << m_bd_id << " rd-id:" << m_rd_id
<< " itf:" << m_itf;
return (s.str());
}
-delete_cmd::delete_cmd(HW::item<bool>& item, epg_id_t epg_id)
+delete_cmd::delete_cmd(HW::item<bool>& item, sclass_t sclass)
: rpc_cmd(item)
- , m_epg_id(epg_id)
+ , m_sclass(sclass)
{
}
bool
delete_cmd::operator==(const delete_cmd& other) const
{
- return (m_epg_id == other.m_epg_id);
+ return (m_sclass == other.m_sclass);
}
rc_t
msg_t req(con.ctx(), std::ref(*this));
auto& payload = req.get_request().get_payload();
- payload.epg_id = m_epg_id;
+ payload.sclass = m_sclass;
VAPI_CALL(req.execute());
{
std::ostringstream s;
s << "gbp-endpoint-group-delete: " << m_hw_item.to_string()
- << " epg:" << m_epg_id;
+ << " sclass:" << m_sclass;
return (s.str());
}
* Constructor
*/
create_cmd(HW::item<bool>& item,
- epg_id_t epg_id,
+ vnid_t vnid,
uint16_t sclass,
uint32_t bd_id,
route::table_id_t rd_id,
bool operator==(const create_cmd& i) const;
private:
- const epg_id_t m_epg_id;
+ const vnid_t m_vnid;
const uint16_t m_sclass;
const uint32_t m_bd_id;
const route::table_id_t m_rd_id;
/**
* Constructor
*/
- delete_cmd(HW::item<bool>& item, epg_id_t epg_id);
+ delete_cmd(HW::item<bool>& item, sclass_t sclass);
/**
* Issue the command to VPP/HW
bool operator==(const delete_cmd& i) const;
private:
- const epg_id_t m_epg_id;
+ const sclass_t m_sclass;
};
/**
{
if (m_hw) {
HW::enqueue(new gbp_recirc_cmds::create_cmd(
- m_hw, m_itf->handle(), (m_type == type_t::EXTERNAL), m_epg->id()));
+ m_hw, m_itf->handle(), (m_type == type_t::EXTERNAL), m_epg->sclass()));
}
}
{
if (rc_t::OK != m_hw.rc()) {
HW::enqueue(new gbp_recirc_cmds::create_cmd(
- m_hw, m_itf->handle(), (m_type == type_t::EXTERNAL), m_epg->id()));
+ m_hw, m_itf->handle(), (m_type == type_t::EXTERNAL), m_epg->sclass()));
}
}
std::shared_ptr<interface> itf =
interface::find(payload.recirc.sw_if_index);
std::shared_ptr<gbp_endpoint_group> epg =
- gbp_endpoint_group::find(payload.recirc.epg_id);
+ gbp_endpoint_group::find(payload.recirc.sclass);
VOM_LOG(log_level_t::DEBUG) << "data: [" << payload.recirc.sw_if_index
- << ", " << payload.recirc.epg_id << "]";
+ << ", " << payload.recirc.sclass << "]";
if (itf && epg) {
gbp_recirc recirc(
create_cmd::create_cmd(HW::item<bool>& item,
const handle_t& itf,
bool is_ext,
- epg_id_t epg_id)
+ sclass_t sclass)
: rpc_cmd(item)
, m_itf(itf)
, m_is_ext(is_ext)
- , m_epg_id(epg_id)
+ , m_sclass(sclass)
{
}
create_cmd::operator==(const create_cmd& other) const
{
return ((m_itf == other.m_itf) && (m_is_ext == other.m_is_ext) &&
- (m_epg_id == other.m_epg_id));
+ (m_sclass == other.m_sclass));
}
rc_t
auto& payload = req.get_request().get_payload();
payload.is_add = 1;
payload.recirc.sw_if_index = m_itf.value();
- payload.recirc.epg_id = m_epg_id;
+ payload.recirc.sclass = m_sclass;
payload.recirc.is_ext = m_is_ext;
VAPI_CALL(req.execute());
{
std::ostringstream s;
s << "gbp-recirc-create: " << m_hw_item.to_string() << " itf:" << m_itf
- << " ext:" << m_is_ext << " epg-id:" << m_epg_id;
+ << " ext:" << m_is_ext << " sclass:" << m_sclass;
return (s.str());
}
auto& payload = req.get_request().get_payload();
payload.is_add = 0;
payload.recirc.sw_if_index = m_itf.value();
- payload.recirc.epg_id = ~0;
+ payload.recirc.sclass = ~0;
VAPI_CALL(req.execute());
create_cmd(HW::item<bool>& item,
const handle_t& itf,
bool is_ext,
- epg_id_t epg_id);
+ sclass_t sclass);
/**
* Issue the command to VPP/HW
private:
const handle_t m_itf;
bool m_is_ext;
- const epg_id_t m_epg_id;
+ const sclass_t m_sclass;
};
/**
HW::enqueue(new gbp_subnet_cmds::create_cmd(
m_hw, m_rd->id(), m_prefix, m_type,
(m_recirc ? m_recirc->handle() : handle_t::INVALID),
- (m_epg ? m_epg->id() : ~0)));
+ (m_epg ? m_epg->sclass() : ~0)));
}
}
HW::enqueue(new gbp_subnet_cmds::create_cmd(
m_hw, m_rd->id(), m_prefix, m_type,
(m_recirc ? m_recirc->handle() : handle_t::INVALID),
- (m_epg ? m_epg->id() : ~0)));
+ (m_epg ? m_epg->sclass() : ~0)));
} else {
if (m_type != r.m_type) {
m_epg = r.m_epg;
HW::enqueue(new gbp_subnet_cmds::create_cmd(
m_hw, m_rd->id(), m_prefix, m_type,
(m_recirc ? m_recirc->handle() : handle_t::INVALID),
- (m_epg ? m_epg->id() : ~0)));
+ (m_epg ? m_epg->sclass() : ~0)));
}
}
}
}
case GBP_API_SUBNET_L3_OUT: {
std::shared_ptr<gbp_endpoint_group> epg =
- gbp_endpoint_group::find(payload.subnet.epg_id);
+ gbp_endpoint_group::find(payload.subnet.sclass);
gbp_subnet gs(*rd, pfx, *epg);
OM::commit(key, gs);
std::shared_ptr<interface> itf =
interface::find(payload.subnet.sw_if_index);
std::shared_ptr<gbp_endpoint_group> epg =
- gbp_endpoint_group::find(payload.subnet.epg_id);
+ gbp_endpoint_group::find(payload.subnet.sclass);
if (itf && epg) {
std::shared_ptr<gbp_recirc> recirc = gbp_recirc::find(itf->key());
const route::prefix_t& prefix,
const gbp_subnet::type_t& type,
const handle_t& itf,
- epg_id_t epg_id)
+ sclass_t sclass)
: rpc_cmd(item)
, m_rd(rd)
, m_prefix(prefix)
, m_type(type)
, m_itf(itf)
- , m_epg_id(epg_id)
+ , m_sclass(sclass)
{
}
{
return ((m_itf == other.m_itf) && (m_rd == other.m_rd) &&
(m_prefix == other.m_prefix) && (m_type == other.m_type) &&
- (m_itf == other.m_itf) && (m_epg_id == other.m_epg_id));
+ (m_itf == other.m_itf) && (m_sclass == other.m_sclass));
}
static vapi_enum_gbp_subnet_type
payload.subnet.type = gbp_subnet_type_to_api(m_type);
payload.subnet.rd_id = m_rd;
payload.subnet.sw_if_index = m_itf.value();
- payload.subnet.epg_id = m_epg_id;
+ payload.subnet.sclass = m_sclass;
payload.subnet.prefix = to_api(m_prefix);
VAPI_CALL(req.execute());
std::ostringstream s;
s << "gbp-subnet-create: " << m_hw_item.to_string() << "type:" << m_type
<< ", " << m_rd << ":" << m_prefix.to_string() << " itf:" << m_itf
- << " epg-id:" << m_epg_id;
+ << " sclass:" << m_sclass;
return (s.str());
}
namespace gbp_subnet_cmds {
/**
-* A command class that creates or updates the GBP subnet
-*/
+ * A command class that creates or updates the GBP subnet
+ */
class create_cmd : public rpc_cmd<HW::item<bool>, vapi::Gbp_subnet_add_del>
{
public:
const route::prefix_t& prefix,
const gbp_subnet::type_t& type,
const handle_t& itf,
- epg_id_t epg_id);
+ sclass_t sclass);
/**
* Issue the command to VPP/HW
const route::prefix_t m_prefix;
const gbp_subnet::type_t& m_type;
const handle_t m_itf;
- const epg_id_t m_epg_id;
+ const sclass_t m_sclass;
};
/**
gbp_recirc.c
gbp_route_domain.c
gbp_scanner.c
- gbp_sclass.c
- gbp_sclass_node.c
gbp_subnet.c
gbp_vxlan.c
gbp_vxlan_node.c
gbp_policy_dpo.c
gbp_policy_node.c
gbp_vxlan_node.c
- gbp_sclass_node.c
API_FILES
gbp.api
typedef gbp_endpoint
{
u32 sw_if_index;
- u16 epg_id;
+ u16 sclass;
vl_api_gbp_endpoint_flags_t flags;
vl_api_mac_address_t mac;
vl_api_gbp_endpoint_tun_t tun;
typeonly define gbp_endpoint_group
{
- u16 epg_id;
+ u32 vnid;
u16 sclass;
u32 bd_id;
u32 rd_id;
{
u32 client_index;
u32 context;
- u16 epg_id;
+ u16 sclass;
};
define gbp_endpoint_group_dump
typeonly define gbp_recirc
{
u32 sw_if_index;
- u16 epg_id;
+ u16 sclass;
u8 is_ext;
};
{
u32 rd_id;
u32 sw_if_index;
- u16 epg_id;
+ u16 sclass;
vl_api_gbp_subnet_type_t type;
vl_api_prefix_t prefix;
};
typedef gbp_contract
{
- u16 src_epg;
- u16 dst_epg;
+ u16 sclass;
+ u16 dclass;
u32 acl_index;
u8 n_rules;
vl_api_gbp_rule_t rules[n_rules];
rv = gbp_endpoint_update_and_lock (GBP_ENDPOINT_SRC_CP,
sw_if_index, ips, &mac,
INDEX_INVALID, INDEX_INVALID,
- ntohs (mp->endpoint.epg_id),
+ ntohs (mp->endpoint.sclass),
gef, &tun_src, &tun_dst, &handle);
}
else
rv = gbp_endpoint_update_and_lock (GBP_ENDPOINT_SRC_CP,
sw_if_index, ips, &mac,
INDEX_INVALID, INDEX_INVALID,
- ntohs (mp->endpoint.epg_id),
+ ntohs (mp->endpoint.sclass),
gef, NULL, NULL, &handle);
}
vec_free (ips);
{
mp->endpoint.sw_if_index = ntohl (gef->gef_itf);
}
- mp->endpoint.epg_id = ntohs (ge->ge_fwd.gef_epg_id);
+ mp->endpoint.sclass = ntohs (ge->ge_fwd.gef_sclass);
mp->endpoint.n_ips = n_ips;
mp->endpoint.flags = gbp_endpoint_flags_encode (gef->gef_flags);
mp->handle = htonl (gei);
gbp_retention_decode (&mp->epg.retention, &retention);
- rv = gbp_endpoint_group_add_and_lock (ntohs (mp->epg.epg_id),
+ rv = gbp_endpoint_group_add_and_lock (ntohl (mp->epg.vnid),
ntohs (mp->epg.sclass),
ntohl (mp->epg.bd_id),
ntohl (mp->epg.rd_id),
vl_api_gbp_endpoint_group_del_reply_t *rmp;
int rv = 0;
- rv = gbp_endpoint_group_delete (ntohs (mp->epg_id));
+ rv = gbp_endpoint_group_delete (ntohs (mp->sclass));
REPLY_MACRO (VL_API_GBP_ENDPOINT_GROUP_DEL_REPLY + GBP_MSG_BASE);
}
rv = gbp_subnet_add (ntohl (mp->subnet.rd_id),
&pfx, type,
ntohl (mp->subnet.sw_if_index),
- ntohs (mp->subnet.epg_id));
+ ntohs (mp->subnet.sclass));
else
rv = gbp_subnet_del (ntohl (mp->subnet.rd_id), &pfx);
gbp_subnet_send_details (u32 rd_id,
const fib_prefix_t * pfx,
gbp_subnet_type_t type,
- u32 sw_if_index, epg_id_t epg, void *args)
+ u32 sw_if_index, sclass_t sclass, void *args)
{
vl_api_gbp_subnet_details_t *mp;
gbp_walk_ctx_t *ctx;
mp->subnet.type = gub_subnet_type_to_api (type);
mp->subnet.sw_if_index = ntohl (sw_if_index);
- mp->subnet.epg_id = ntohs (epg);
+ mp->subnet.sclass = ntohs (sclass);
mp->subnet.rd_id = ntohl (rd_id);
ip_prefix_encode (pfx, &mp->subnet.prefix);
mp->context = ctx->context;
mp->epg.uplink_sw_if_index = ntohl (gg->gg_uplink_sw_if_index);
- mp->epg.epg_id = ntohs (gg->gg_id);
+ mp->epg.vnid = ntohl (gg->gg_vnid);
mp->epg.sclass = ntohs (gg->gg_sclass);
mp->epg.bd_id = ntohl (gbp_endpoint_group_get_bd_id (gg));
mp->epg.rd_id = ntohl (gbp_route_domain_get_rd_id (gg->gg_rd));
if (mp->is_add)
rv = gbp_recirc_add (sw_if_index,
- ntohs (mp->recirc.epg_id), mp->recirc.is_ext);
+ ntohs (mp->recirc.sclass), mp->recirc.is_ext);
else
rv = gbp_recirc_delete (sw_if_index);
mp->_vl_msg_id = ntohs (VL_API_GBP_RECIRC_DETAILS + GBP_MSG_BASE);
mp->context = ctx->context;
- mp->recirc.epg_id = ntohs (gr->gr_epg);
+ mp->recirc.sclass = ntohs (gr->gr_sclass);
mp->recirc.sw_if_index = ntohl (gr->gr_sw_if_index);
mp->recirc.is_ext = gr->gr_is_ext;
allowed_ethertypes[ii] = et[ii];
}
- rv = gbp_contract_update (ntohs (mp->contract.src_epg),
- ntohs (mp->contract.dst_epg),
+ rv = gbp_contract_update (ntohs (mp->contract.sclass),
+ ntohs (mp->contract.dclass),
ntohl (mp->contract.acl_index),
rules, allowed_ethertypes);
}
else
- rv = gbp_contract_delete (ntohs (mp->contract.src_epg),
- ntohs (mp->contract.dst_epg));
+ rv = gbp_contract_delete (ntohs (mp->contract.sclass),
+ ntohs (mp->contract.dclass));
out:
REPLY_MACRO (VL_API_GBP_CONTRACT_ADD_DEL_REPLY + GBP_MSG_BASE);
mp->_vl_msg_id = ntohs (VL_API_GBP_CONTRACT_DETAILS + GBP_MSG_BASE);
mp->context = ctx->context;
- mp->contract.src_epg = ntohs (gbpc->gc_key.gck_src);
- mp->contract.dst_epg = ntohs (gbpc->gc_key.gck_dst);
- // mp->contract.acl_index = ntohl (gbpc->gc_value.gc_acl_index);
+ mp->contract.sclass = ntohs (gbpc->gc_key.gck_src);
+ mp->contract.dclass = ntohs (gbpc->gc_key.gck_dst);
+ mp->contract.acl_index = ntohl (gbpc->gc_acl_index);
vl_api_send_msg (ctx->reg, (u8 *) mp);
#include <plugins/gbp/gbp_bridge_domain.h>
#include <plugins/gbp/gbp_endpoint.h>
-#include <plugins/gbp/gbp_sclass.h>
#include <plugins/gbp/gbp_learn.h>
#include <vnet/dpo/dvr_dpo.h>
set_int_l2_mode (vlib_get_main (), vnet_get_main (),
MODE_L2_BRIDGE, gb->gb_uu_fwd_sw_if_index,
bd_index, L2_BD_PORT_TYPE_UU_FWD, 0, 0);
- gbp_sclass_enable_l2 (gb->gb_uu_fwd_sw_if_index);
}
if (~0 != gb->gb_bm_flood_sw_if_index)
{
set_int_l2_mode (vlib_get_main (), vnet_get_main (),
MODE_L2_BRIDGE, gb->gb_bm_flood_sw_if_index,
bd_index, L2_BD_PORT_TYPE_NORMAL, 0, 0);
- gbp_sclass_enable_l2 (gb->gb_bm_flood_sw_if_index);
gbp_learn_enable (gb->gb_bm_flood_sw_if_index, GBP_LEARN_MODE_L2);
}
set_int_l2_mode (vlib_get_main (), vnet_get_main (),
MODE_L3, gb->gb_uu_fwd_sw_if_index,
gb->gb_bd_index, L2_BD_PORT_TYPE_UU_FWD, 0, 0);
- gbp_sclass_disable_l2 (gb->gb_uu_fwd_sw_if_index);
}
if (~0 != gb->gb_bm_flood_sw_if_index)
{
set_int_l2_mode (vlib_get_main (), vnet_get_main (),
MODE_L3, gb->gb_bm_flood_sw_if_index,
gb->gb_bd_index, L2_BD_PORT_TYPE_NORMAL, 0, 0);
- gbp_sclass_disable_l2 (gb->gb_bm_flood_sw_if_index);
gbp_learn_enable (gb->gb_bm_flood_sw_if_index, GBP_LEARN_MODE_L2);
}
typedef struct gbp_classify_trace_t_
{
/* per-pkt trace data */
- epg_id_t src_epg;
+ sclass_t sclass;
} gbp_classify_trace_t;
/*
while (n_left_from > 0 && n_left_to_next > 0)
{
- u32 next0, bi0, src_epg, sw_if_index0;
+ u32 next0, bi0, sw_if_index0;
const gbp_endpoint_t *ge0;
vlib_buffer_t *b0;
+ sclass_t sclass0;
bi0 = from[0];
to_next[0] = bi0;
if (GBP_SRC_CLASSIFY_NULL == type)
{
- src_epg = EPG_INVALID;
+ sclass0 = SCLASS_INVALID;
next0 =
vnet_l2_feature_next (b0, gscm->l2_input_feat_next[type],
L2INPUT_FEAT_GBP_NULL_CLASSIFY);
}
if (PREDICT_TRUE (NULL != ge0))
- src_epg = ge0->ge_fwd.gef_epg_id;
+ sclass0 = ge0->ge_fwd.gef_sclass;
else
- src_epg = EPG_INVALID;
+ sclass0 = SCLASS_INVALID;
}
- vnet_buffer2 (b0)->gbp.src_epg = src_epg;
+ vnet_buffer2 (b0)->gbp.sclass = sclass0;
if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
{
gbp_classify_trace_t *t =
vlib_add_trace (vm, node, b0, sizeof (*t));
- t->src_epg = src_epg;
+ t->sclass = sclass0;
}
vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
gbp_classify_trace_t *t = va_arg (*args, gbp_classify_trace_t *);
- s = format (s, "src-epg:%d", t->src_epg);
+ s = format (s, "sclass:%d", t->sclass);
return s;
}
ip4_header_t *ip4_0;
ip6_header_t *ip6_0;
vlib_buffer_t *b0;
- epg_id_t src_epg0;
+ sclass_t sclass0;
bi0 = from[0];
to_next[0] = bi0;
break;
default:
/* not IP so no LPM classify possible */
- src_epg0 = EPG_INVALID;
+ sclass0 = SCLASS_INVALID;
goto trace;
}
}
else
{
/* not IP so no LPM classify possible */
- src_epg0 = EPG_INVALID;
+ sclass0 = SCLASS_INVALID;
goto trace;
}
lb0 = load_balance_get (lbi0);
if (gbp_policy_dpo_type == dpo0->dpoi_type)
{
gpd0 = gbp_policy_dpo_get (dpo0->dpoi_index);
- src_epg0 = gpd0->gpd_epg;
+ sclass0 = gpd0->gpd_sclass;
}
else
{
/* could not classify => drop */
- src_epg0 = EPG_INVALID;
+ sclass0 = SCLASS_INVALID;
next0 = GPB_LPM_CLASSIFY_DROP;
}
trace:
- vnet_buffer2 (b0)->gbp.src_epg = src_epg0;
+ vnet_buffer2 (b0)->gbp.sclass = sclass0;
if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
{
gbp_classify_trace_t *t =
vlib_add_trace (vm, node, b0, sizeof (*t));
- t->src_epg = src_epg0;
+ t->sclass = sclass0;
}
vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
gbd->gb_uu_fwd_sw_if_index,
ips,
&gnh->gnh_mac,
- gnh->gnh_bd, gnh->gnh_rd, EPG_INVALID,
+ gnh->gnh_bd, gnh->gnh_rd, SCLASS_INVALID,
GBP_ENDPOINT_FLAG_NONE, NULL, NULL,
&gnh->gnh_ge);
}
int
-gbp_contract_update (epg_id_t src_epg,
- epg_id_t dst_epg,
+gbp_contract_update (sclass_t sclass,
+ sclass_t dclass,
u32 acl_index, index_t * rules, u16 * allowed_ethertypes)
{
gbp_main_t *gm = &gbp_main;
uword *p;
gbp_contract_key_t key = {
- .gck_src = src_epg,
- .gck_dst = dst_epg,
+ .gck_src = sclass,
+ .gck_dst = dclass,
};
if (~0 == gm->gbp_acl_user_id)
gc->gc_acl_index = acl_index;
gc->gc_lc_index =
gm->acl_plugin.get_lookup_context_index (gm->gbp_acl_user_id,
- src_epg, dst_epg);
+ sclass, dclass);
vec_add1 (acl_vec, gc->gc_acl_index);
gm->acl_plugin.set_acl_vec_for_context (gc->gc_lc_index, acl_vec);
}
int
-gbp_contract_delete (epg_id_t src_epg, epg_id_t dst_epg)
+gbp_contract_delete (sclass_t sclass, sclass_t dclass)
{
gbp_contract_key_t key = {
- .gck_src = src_epg,
- .gck_dst = dst_epg,
+ .gck_src = sclass,
+ .gck_dst = dclass,
};
gbp_contract_t *gc;
uword *p;
gbp_contract_cli (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
- epg_id_t src_epg_id = EPG_INVALID, dst_epg_id = EPG_INVALID;
+ sclass_t sclass = SCLASS_INVALID, dclass = SCLASS_INVALID;
u32 acl_index = ~0;
u8 add = 1;
add = 1;
else if (unformat (input, "del"))
add = 0;
- else if (unformat (input, "src-epg %d", &src_epg_id))
+ else if (unformat (input, "src-epg %d", &sclass))
;
- else if (unformat (input, "dst-epg %d", &dst_epg_id))
+ else if (unformat (input, "dst-epg %d", &dclass))
;
else if (unformat (input, "acl-index %d", &acl_index))
;
break;
}
- if (EPG_INVALID == src_epg_id)
+ if (SCLASS_INVALID == sclass)
return clib_error_return (0, "Source EPG-ID must be specified");
- if (EPG_INVALID == dst_epg_id)
+ if (SCLASS_INVALID == dclass)
return clib_error_return (0, "Destination EPG-ID must be specified");
if (add)
{
- gbp_contract_update (src_epg_id, dst_epg_id, acl_index, NULL, NULL);
+ gbp_contract_update (sclass, dclass, acl_index, NULL, NULL);
}
else
{
- gbp_contract_delete (src_epg_id, dst_epg_id);
+ gbp_contract_delete (sclass, dclass);
}
return (NULL);
/**
* source and destination EPGs for which the ACL applies
*/
- epg_id_t gck_src;
- epg_id_t gck_dst;
+ sclass_t gck_src;
+ sclass_t gck_dst;
};
u32 as_u32;
};
uword *gc_hash;
} gbp_contract_db_t;
-extern int gbp_contract_update (epg_id_t src_epg,
- epg_id_t dst_epg,
+extern int gbp_contract_update (sclass_t sclass,
+ sclass_t dclass,
u32 acl_index,
index_t * rules, u16 * allowed_ethertypes);
-extern int gbp_contract_delete (epg_id_t src_epg, epg_id_t dst_epg);
+extern int gbp_contract_delete (sclass_t sclass, sclass_t dclass);
extern index_t gbp_rule_alloc (gbp_rule_action_t action,
gbp_hash_mode_t hash_mode, index_t * nhs);
if (INDEX_INVALID != gel->gel_epg)
{
gg = gbp_endpoint_group_get (gel->gel_epg);
- gef->gef_epg_id = gg->gg_id;
+ gef->gef_sclass = gg->gg_sclass;
}
else
{
* is applied
*/
gbp_policy_dpo_add_or_lock (fib_proto_to_dpo (pfx->fp_proto),
- gg->gg_id, ~0, &policy_dpo);
+ gg->gg_sclass, ~0, &policy_dpo);
fib_table_entry_special_dpo_add (fib_index, pfx,
FIB_SOURCE_PLUGIN_HI,
u32 sw_if_index,
const ip46_address_t * ips,
const mac_address_t * mac,
- index_t gbdi, index_t grdi, epg_id_t epg_id,
+ index_t gbdi, index_t grdi,
+ sclass_t sclass,
gbp_endpoint_flags_t flags,
const ip46_address_t * tun_src,
const ip46_address_t * tun_dst, u32 * handle)
* we need to determine the bridge-domain, either from the EPG or
* the BD passed
*/
- if (EPG_INVALID != epg_id)
+ if (SCLASS_INVALID != sclass)
{
- ggi = gbp_endpoint_group_find (epg_id);
+ ggi = gbp_endpoint_group_find (sclass);
if (INDEX_INVALID == ggi)
return (VNET_API_ERROR_NO_SUCH_ENTRY);
ip46_address_t ip = ip46_address_initializer, *ips = NULL;
mac_address_t mac = ZERO_MAC_ADDRESS;
vnet_main_t *vnm = vnet_get_main ();
- u32 epg_id = EPG_INVALID;
+ u32 sclass = SCLASS_INVALID;
u32 handle = INDEX_INVALID;
u32 sw_if_index = ~0;
u8 add = 1;
add = 1;
else if (unformat (input, "del"))
add = 0;
- else if (unformat (input, "epg %d", &epg_id))
+ else if (unformat (input, "sclass %d", &sclass))
;
else if (unformat (input, "handle %d", &handle))
;
{
if (~0 == sw_if_index)
return clib_error_return (0, "interface must be specified");
- if (EPG_INVALID == epg_id)
- return clib_error_return (0, "EPG-ID must be specified");
+ if (SCLASS_INVALID == sclass)
+ return clib_error_return (0, "SCLASS must be specified");
rv =
gbp_endpoint_update_and_lock (GBP_ENDPOINT_SRC_CP,
sw_if_index, ips, &mac,
INDEX_INVALID, INDEX_INVALID,
- epg_id,
+ sclass,
GBP_ENDPOINT_FLAG_NONE,
NULL, NULL, &handle);
index_t *gef_adjs;
/**
- * Endpoint Group's ID. cached for fast DP access.
+ * Endpoint Group's sclass. cached for fast DP access.
*/
- epg_id_t gef_epg_id;
+ sclass_t gef_sclass;
gbp_endpoint_flags_t gef_flags;
} gbp_endpoint_fwd_t;
const ip46_address_t * ip,
const mac_address_t * mac,
index_t gbd, index_t grd,
- epg_id_t epg_id,
+ sclass_t sclass,
gbp_endpoint_flags_t flags,
const ip46_address_t * tun_src,
const ip46_address_t * tun_dst,
}
index_t
-gbp_endpoint_group_find (epg_id_t epg_id)
+gbp_endpoint_group_find (sclass_t sclass)
{
uword *p;
- p = hash_get (gbp_endpoint_group_db.gg_hash, epg_id);
+ p = hash_get (gbp_endpoint_group_db.gg_hash_sclass, sclass);
if (NULL != p)
return p[0];
}
int
-gbp_endpoint_group_add_and_lock (epg_id_t epg_id,
+gbp_endpoint_group_add_and_lock (vnid_t vnid,
u16 sclass,
u32 bd_id,
u32 rd_id,
gbp_endpoint_group_t *gg;
index_t ggi;
- ggi = gbp_endpoint_group_find (epg_id);
+ ggi = gbp_endpoint_group_find (sclass);
if (INDEX_INVALID == ggi)
{
pool_get_zero (gbp_endpoint_group_pool, gg);
- gg->gg_id = epg_id;
+ gg->gg_vnid = vnid;
gg->gg_rd = grdi;
gg->gg_gbd = gbi;
gg->gg_bd_index = gb->gb_bd_index;
gg->gg_retention = *retention;
if (SCLASS_INVALID != gg->gg_sclass)
- hash_set (gbp_epg_sclass_db, gg->gg_sclass, gg->gg_id);
+ hash_set (gbp_epg_sclass_db, gg->gg_sclass, gg->gg_vnid);
/*
* an egress DVR dpo for internal subnets to use when sending
L2INPUT_FEAT_GBP_NULL_CLASSIFY, 1);
}
- hash_set (gbp_endpoint_group_db.gg_hash,
- gg->gg_id, gg - gbp_endpoint_group_pool);
-
+ hash_set (gbp_endpoint_group_db.gg_hash_sclass,
+ gg->gg_sclass, gg - gbp_endpoint_group_pool);
}
else
{
if (SCLASS_INVALID != gg->gg_sclass)
hash_unset (gbp_epg_sclass_db, gg->gg_sclass);
- hash_unset (gbp_endpoint_group_db.gg_hash, gg->gg_id);
+ hash_unset (gbp_endpoint_group_db.gg_hash_sclass, gg->gg_sclass);
pool_put (gbp_endpoint_group_pool, gg);
}
}
int
-gbp_endpoint_group_delete (epg_id_t epg_id)
+gbp_endpoint_group_delete (sclass_t sclass)
{
index_t ggi;
- ggi = gbp_endpoint_group_find (epg_id);
+ ggi = gbp_endpoint_group_find (sclass);
if (INDEX_INVALID != ggi)
{
unformat_input_t * input, vlib_cli_command_t * cmd)
{
gbp_endpoint_retention_t retention = { 0 };
- epg_id_t epg_id = EPG_INVALID, sclass;
+ vnid_t vnid = VNID_INVALID, sclass;
vnet_main_t *vnm = vnet_get_main ();
u32 uplink_sw_if_index = ~0;
u32 bd_id = ~0;
add = 1;
else if (unformat (input, "del"))
add = 0;
- else if (unformat (input, "epg %d", &epg_id))
+ else if (unformat (input, "epg %d", &vnid))
;
else if (unformat (input, "sclass %d", &sclass))
;
break;
}
- if (EPG_INVALID == epg_id)
+ if (VNID_INVALID == vnid)
return clib_error_return (0, "EPG-ID must be specified");
if (add)
if (~0 == rd_id)
return clib_error_return (0, "route-domain must be specified");
- gbp_endpoint_group_add_and_lock (epg_id, sclass, bd_id, rd_id,
+ gbp_endpoint_group_add_and_lock (vnid, sclass, bd_id, rd_id,
uplink_sw_if_index, &retention);
}
else
- gbp_endpoint_group_delete (epg_id);
+ gbp_endpoint_group_delete (vnid);
return (NULL);
}
if (NULL != gg)
s = format (s, "[%d] %d, sclass:%d bd:[%d,%d] rd:[%d] uplink:%U retnetion:%U locks:%d",
gg - gbp_endpoint_group_pool,
- gg->gg_id,
+ gg->gg_vnid,
gg->gg_sclass,
gbp_endpoint_group_get_bd_id(gg), gg->gg_bd_index,
gg->gg_rd,
/**
* ID
*/
- epg_id_t gg_id;
+ vnid_t gg_vnid;
/**
* Sclass. Could be unset => ~0
*/
typedef struct gbp_endpoint_group_db_t_
{
- uword *gg_hash;
+ uword *gg_hash_sclass;
} gbp_endpoint_group_db_t;
-extern int gbp_endpoint_group_add_and_lock (epg_id_t epg_id,
+extern int gbp_endpoint_group_add_and_lock (vnid_t vnid,
u16 sclass,
u32 bd_id,
u32 rd_id,
u32 uplink_sw_if_index,
const gbp_endpoint_retention_t *
retention);
-extern index_t gbp_endpoint_group_find (epg_id_t epg_id);
-extern int gbp_endpoint_group_delete (epg_id_t epg_id);
+extern index_t gbp_endpoint_group_find (sclass_t sclass);
+extern int gbp_endpoint_group_delete (sclass_t sclass);
extern void gbp_endpoint_group_unlock (index_t index);
extern void gbp_endpoint_group_lock (index_t index);
extern u32 gbp_endpoint_group_get_bd_id (const gbp_endpoint_group_t *);
extern gbp_endpoint_group_t *gbp_endpoint_group_pool;
extern uword *gbp_epg_sclass_db;
-always_inline gbp_endpoint_group_t *
-gbp_epg_get (epg_id_t epg)
-{
- uword *p;
-
- p = hash_get (gbp_endpoint_group_db.gg_hash, epg);
-
- if (NULL != p)
- return (pool_elt_at_index (gbp_endpoint_group_pool, p[0]));
- return (NULL);
-}
-
always_inline u32
-gbp_epg_itf_lookup (epg_id_t epg)
+gbp_epg_itf_lookup_sclass (sclass_t sclass)
{
uword *p;
- p = hash_get (gbp_endpoint_group_db.gg_hash, epg);
+ p = hash_get (gbp_endpoint_group_db.gg_hash_sclass, sclass);
if (NULL != p)
{
return (~0);
}
-always_inline epg_id_t
-gbp_epg_sclass_2_id (u16 sclass)
-{
- uword *p;
-
- p = hash_get (gbp_epg_sclass_db, sclass);
-
- if (NULL != p)
- {
- return (p[0]);
- }
- return (EPG_INVALID);
-}
-
always_inline const dpo_id_t *
-gbp_epg_dpo_lookup (epg_id_t epg, fib_protocol_t fproto)
+gbp_epg_dpo_lookup (sclass_t sclass, fib_protocol_t fproto)
{
uword *p;
- p = hash_get (gbp_endpoint_group_db.gg_hash, epg);
+ p = hash_get (gbp_endpoint_group_db.gg_hash_sclass, sclass);
if (NULL != p)
{
u32 l2_input_feat_next[32];
} gbp_fwd_main_t;
-static gbp_fwd_main_t gbp_fwd_main;
+gbp_fwd_main_t gbp_fwd_main;
static clib_error_t *
gbp_fwd_init (vlib_main_t * vm)
typedef struct gbp_fwd_dpo_trace_t_
{
- u32 src_epg;
+ u32 sclass;
u32 dpo_index;
} gbp_fwd_dpo_trace_t;
{
const dpo_id_t *next_dpo0;
vlib_buffer_t *b0;
- epg_id_t src_epg0;
+ sclass_t sclass0;
u32 bi0, next0;
bi0 = from[0];
b0 = vlib_get_buffer (vm, bi0);
- src_epg0 = vnet_buffer2 (b0)->gbp.src_epg;
- next_dpo0 = gbp_epg_dpo_lookup (src_epg0, fproto);
+ sclass0 = vnet_buffer2 (b0)->gbp.sclass;
+ next_dpo0 = gbp_epg_dpo_lookup (sclass0, fproto);
if (PREDICT_TRUE (NULL != next_dpo0))
{
gbp_fwd_dpo_trace_t *tr;
tr = vlib_add_trace (vm, node, b0, sizeof (*tr));
- tr->src_epg = src_epg0;
+ tr->sclass = sclass0;
tr->dpo_index = (NULL != next_dpo0 ?
next_dpo0->dpoi_index : ~0);
}
CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
gbp_fwd_dpo_trace_t *t = va_arg (*args, gbp_fwd_dpo_trace_t *);
- s = format (s, " epg:%d dpo:%d", t->src_epg, t->dpo_index);
+ s = format (s, " sclass:%d dpo:%d", t->sclass, t->dpo_index);
return s;
}
typedef struct gbp_fwd_trace_t_
{
/* per-pkt trace data */
- epg_id_t src_epg;
+ sclass_t sclass;
u32 sw_if_index;
} gbp_fwd_trace_t;
while (n_left_from > 0 && n_left_to_next > 0)
{
- u32 bi0, sw_if_index0, src_epg;
+ u32 bi0, sw_if_index0;
gbp_fwd_next_t next0;
vlib_buffer_t *b0;
+ sclass_t sclass0;
next0 = GBP_FWD_NEXT_DROP;
bi0 = from[0];
/*
* lookup the uplink based on src EPG
*/
- src_epg = vnet_buffer2 (b0)->gbp.src_epg;
+ sclass0 = vnet_buffer2 (b0)->gbp.sclass;
- sw_if_index0 = gbp_epg_itf_lookup (src_epg);
+ sw_if_index0 = gbp_epg_itf_lookup_sclass (sclass0);
if (~0 != sw_if_index0)
{
if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
{
gbp_fwd_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
- t->src_epg = src_epg;
+ t->sclass = sclass0;
t->sw_if_index = sw_if_index0;
}
CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
gbp_fwd_trace_t *t = va_arg (*args, gbp_fwd_trace_t *);
- s = format (s, "src-epg:%d", t->src_epg);
+ s = format (s, "sclass:%d", t->sclass);
return s;
}
mac_address_t mac;
u32 sw_if_index;
u32 bd_index;
- epg_id_t epg;
+ sclass_t sclass;
ip46_address_t outer_src;
ip46_address_t outer_dst;
} gbp_learn_l2_t;
GBP_LEARN_DBG ("L2 EP: %U %U, %d",
format_mac_address_t, &gl2->mac,
- format_ip46_address, &gl2->ip, IP46_TYPE_ANY, gl2->epg);
+ format_ip46_address, &gl2->ip, IP46_TYPE_ANY, gl2->sclass);
if (!ip46_address_is_zero (&gl2->ip))
vec_add1 (ips, gl2->ip);
gbp_endpoint_update_and_lock (GBP_ENDPOINT_SRC_DP,
gl2->sw_if_index, ips,
&gl2->mac, INDEX_INVALID,
- INDEX_INVALID, gl2->epg,
+ INDEX_INVALID, gl2->sclass,
(GBP_ENDPOINT_FLAG_LEARNT |
GBP_ENDPOINT_FLAG_REMOTE),
&gl2->outer_dst, &gl2->outer_src, NULL);
static void
gbp_learn_l2_ip4_dp (const u8 * mac, const ip4_address_t * ip,
- u32 bd_index, u32 sw_if_index, epg_id_t epg,
+ u32 bd_index, u32 sw_if_index, sclass_t sclass,
const ip4_address_t * outer_src,
const ip4_address_t * outer_dst)
{
gbp_learn_l2_t gl2 = {
.sw_if_index = sw_if_index,
.bd_index = bd_index,
- .epg = epg,
+ .sclass = sclass,
.ip.ip4 = *ip,
.outer_src.ip4 = *outer_src,
.outer_dst.ip4 = *outer_dst,
static void
gbp_learn_l2_ip6_dp (const u8 * mac, const ip6_address_t * ip,
- u32 bd_index, u32 sw_if_index, epg_id_t epg,
+ u32 bd_index, u32 sw_if_index, sclass_t sclass,
const ip4_address_t * outer_src,
const ip4_address_t * outer_dst)
{
gbp_learn_l2_t gl2 = {
.sw_if_index = sw_if_index,
.bd_index = bd_index,
- .epg = epg,
+ .sclass = sclass,
.ip.ip6 = *ip,
.outer_src.ip4 = *outer_src,
.outer_dst.ip4 = *outer_dst,
static void
gbp_learn_l2_dp (const u8 * mac, u32 bd_index, u32 sw_if_index,
- epg_id_t epg,
+ sclass_t sclass,
const ip4_address_t * outer_src,
const ip4_address_t * outer_dst)
{
gbp_learn_l2_t gl2 = {
.sw_if_index = sw_if_index,
.bd_index = bd_index,
- .epg = epg,
+ .sclass = sclass,
.outer_src.ip4 = *outer_src,
.outer_dst.ip4 = *outer_dst,
};
u32 sw_if_index;
u32 new;
u32 throttled;
- u32 epg;
+ u32 sclass;
u32 d_bit;
gbp_bridge_domain_flags_t gb_flags;
} gbp_learn_l2_trace_t;
while (n_left_from > 0 && n_left_to_next > 0)
{
ip4_address_t outer_src, outer_dst;
- u32 bi0, sw_if_index0, t0, epg0;
const ethernet_header_t *eh0;
+ u32 bi0, sw_if_index0, t0;
gbp_bridge_domain_t *gb0;
gbp_learn_next_t next0;
gbp_endpoint_t *ge0;
vlib_buffer_t *b0;
+ sclass_t sclass0;
next0 = GBP_LEARN_NEXT_DROP;
bi0 = from[0];
sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
eh0 = vlib_buffer_get_current (b0);
- epg0 = vnet_buffer2 (b0)->gbp.src_epg;
+ sclass0 = vnet_buffer2 (b0)->gbp.sclass;
next0 = vnet_l2_feature_next (b0, glm->gl_l2_input_feat_next,
L2INPUT_FEAT_GBP_LEARN);
gbp_learn_l2_ip4_dp (eh0->src_address,
&ip0->src_address,
vnet_buffer (b0)->l2.bd_index,
- sw_if_index0, epg0,
+ sw_if_index0, sclass0,
&outer_src, &outer_dst);
break;
gbp_learn_l2_ip6_dp (eh0->src_address,
&ip0->src_address,
vnet_buffer (b0)->l2.bd_index,
- sw_if_index0, epg0,
+ sw_if_index0, sclass0,
&outer_src, &outer_dst);
break;
gbp_learn_l2_ip4_dp (eh0->src_address,
&arp0->ip4_over_ethernet[0].ip4,
vnet_buffer (b0)->l2.bd_index,
- sw_if_index0, epg0,
+ sw_if_index0, sclass0,
&outer_src, &outer_dst);
break;
}
default:
gbp_learn_l2_dp (eh0->src_address,
vnet_buffer (b0)->l2.bd_index,
- sw_if_index0, epg0,
+ sw_if_index0, sclass0,
&outer_src, &outer_dst);
break;
}
t->new = (NULL == ge0);
t->throttled = t0;
t->sw_if_index = sw_if_index0;
- t->epg = epg0;
+ t->sclass = sclass0;
t->gb_flags = gb0->gb_flags;
t->d_bit = ! !(vnet_buffer2 (b0)->gbp.flags &
VXLAN_GBP_GPFLAGS_D);
CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
gbp_learn_l2_trace_t *t = va_arg (*args, gbp_learn_l2_trace_t *);
- s = format (s, "new:%d throttled:%d d-bit:%d mac:%U itf:%d epg:%d"
+ s = format (s, "new:%d throttled:%d d-bit:%d mac:%U itf:%d sclass:%d"
" gb-flags:%U",
t->new, t->throttled, t->d_bit,
- format_mac_address_t, &t->mac, t->sw_if_index, t->epg,
+ format_mac_address_t, &t->mac, t->sw_if_index, t->sclass,
format_gbp_bridge_domain_flags, t->gb_flags);
return s;
ip46_address_t ip;
u32 fib_index;
u32 sw_if_index;
- epg_id_t epg;
+ sclass_t sclass;
ip46_address_t outer_src;
ip46_address_t outer_dst;
} gbp_learn_l3_t;
ip46_address_t *ips = NULL;
GBP_LEARN_DBG ("L3 EP: %U, %d", format_ip46_address, &gl3->ip,
- IP46_TYPE_ANY, gl3->epg);
+ IP46_TYPE_ANY, gl3->sclass);
vec_add1 (ips, gl3->ip);
gbp_endpoint_update_and_lock (GBP_ENDPOINT_SRC_DP,
gl3->sw_if_index, ips, NULL,
- INDEX_INVALID, INDEX_INVALID, gl3->epg,
+ INDEX_INVALID, INDEX_INVALID, gl3->sclass,
(GBP_ENDPOINT_FLAG_REMOTE |
GBP_ENDPOINT_FLAG_LEARNT),
&gl3->outer_dst, &gl3->outer_src, NULL);
static void
gbp_learn_ip4_dp (const ip4_address_t * ip,
- u32 fib_index, u32 sw_if_index, epg_id_t epg,
+ u32 fib_index, u32 sw_if_index, sclass_t sclass,
const ip4_address_t * outer_src,
const ip4_address_t * outer_dst)
{
},
.sw_if_index = sw_if_index,
.fib_index = fib_index,
- .epg = epg,
+ .sclass = sclass,
.outer_src.ip4 = *outer_src,
.outer_dst.ip4 = *outer_dst,
};
static void
gbp_learn_ip6_dp (const ip6_address_t * ip,
- u32 fib_index, u32 sw_if_index, epg_id_t epg,
+ u32 fib_index, u32 sw_if_index, sclass_t sclass,
const ip4_address_t * outer_src,
const ip4_address_t * outer_dst)
{
},
.sw_if_index = sw_if_index,
.fib_index = fib_index,
- .epg = epg,
+ .sclass = sclass,
.outer_src.ip4 = *outer_src,
.outer_dst.ip4 = *outer_dst,
};
u32 sw_if_index;
u32 new;
u32 throttled;
- u32 epg;
+ u32 sclass;
} gbp_learn_l3_trace_t;
static uword
while (n_left_from > 0 && n_left_to_next > 0)
{
- u32 bi0, sw_if_index0, t0, epg0, fib_index0;
CLIB_UNUSED (const ip4_header_t *) ip4_0;
CLIB_UNUSED (const ip6_header_t *) ip6_0;
+ u32 bi0, sw_if_index0, t0, fib_index0;
ip4_address_t outer_src, outer_dst;
ethernet_header_t *eth0;
gbp_learn_next_t next0;
gbp_endpoint_t *ge0;
vlib_buffer_t *b0;
+ sclass_t sclass0;
next0 = GBP_LEARN_NEXT_DROP;
bi0 = from[0];
b0 = vlib_get_buffer (vm, bi0);
sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
- epg0 = vnet_buffer2 (b0)->gbp.src_epg;
+ sclass0 = vnet_buffer2 (b0)->gbp.sclass;
ip6_0 = NULL;
ip4_0 = NULL;
if (!t0)
{
gbp_learn_ip6_dp (&ip6_0->src_address,
- fib_index0, sw_if_index0, epg0,
+ fib_index0, sw_if_index0, sclass0,
&outer_src, &outer_dst);
}
}
if (!t0)
{
gbp_learn_ip4_dp (&ip4_0->src_address,
- fib_index0, sw_if_index0, epg0,
+ fib_index0, sw_if_index0, sclass0,
&outer_src, &outer_dst);
}
}
t->new = (NULL == ge0);
t->throttled = t0;
t->sw_if_index = sw_if_index0;
- t->epg = epg0;
+ t->sclass = sclass0;
}
vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
gbp_learn_l3_trace_t *t = va_arg (*args, gbp_learn_l3_trace_t *);
- s = format (s, "new:%d throttled:%d ip:%U itf:%d epg:%d",
+ s = format (s, "new:%d throttled:%d ip:%U itf:%d sclass:%d",
t->new, t->throttled,
format_ip46_address, &t->ip, IP46_TYPE_ANY, t->sw_if_index,
- t->epg);
+ t->sclass);
return s;
}
void
gbp_policy_dpo_add_or_lock (dpo_proto_t dproto,
- epg_id_t epg, u32 sw_if_index, dpo_id_t * dpo)
+ sclass_t sclass, u32 sw_if_index, dpo_id_t * dpo)
{
gbp_policy_dpo_t *gpd;
dpo_id_t parent = DPO_INVALID;
gpd->gpd_proto = dproto;
gpd->gpd_sw_if_index = sw_if_index;
- gpd->gpd_epg = epg;
+ gpd->gpd_sclass = sclass;
if (~0 != sw_if_index)
{
gbp_policy_dpo_t *gpd = gbp_policy_dpo_get (index);
vnet_main_t *vnm = vnet_get_main ();
- s = format (s, "gbp-policy-dpo: %U, epg:%d out:%U",
+ s = format (s, "gbp-policy-dpo: %U, sclass:%d out:%U",
format_dpo_proto, gpd->gpd_proto,
- gpd->gpd_epg,
+ (int) gpd->gpd_sclass,
format_vnet_sw_if_index_name, vnm, gpd->gpd_sw_if_index);
s = format (s, "\n%U", format_white_space, indent + 2);
s = format (s, "%U", format_dpo_id, &gpd->gpd_dpo, indent + 4);
gpd = gbp_policy_dpo_get (original->dpoi_index);
gpd_clone->gpd_proto = gpd->gpd_proto;
- gpd_clone->gpd_epg = gpd->gpd_epg;
+ gpd_clone->gpd_sclass = gpd->gpd_sclass;
gpd_clone->gpd_sw_if_index = gpd->gpd_sw_if_index;
dpo_stack (gbp_policy_dpo_type,
goto trace;
}
- key0.gck_src = vnet_buffer2 (b0)->gbp.src_epg;
- key0.gck_dst = gpd0->gpd_epg;
+ key0.gck_src = vnet_buffer2 (b0)->gbp.sclass;
+ key0.gck_dst = gpd0->gpd_sclass;
- if (EPG_INVALID != key0.gck_src)
+ if (SCLASS_INVALID != key0.gck_src)
{
if (PREDICT_FALSE (key0.gck_src == key0.gck_dst))
{
dpo_proto_t gpd_proto;
/**
- * EPG
+ * SClass
*/
- epg_id_t gpd_epg;
+ sclass_t gpd_sclass;
/**
* output sw_if_index
} gbp_policy_dpo_t;
extern void gbp_policy_dpo_add_or_lock (dpo_proto_t dproto,
- epg_id_t epg,
+ sclass_t sclass,
u32 sw_if_index, dpo_id_t * dpo);
extern dpo_type_t gbp_policy_dpo_get_type (void);
typedef struct gbp_policy_trace_t_
{
/* per-pkt trace data */
- u32 src_epg;
+ u32 sclass;
u32 dst_epg;
u32 acl_index;
u32 allowed;
vnet_buffer (b0)->l2.bd_index);
if (NULL != ge0)
- key0.gck_dst = ge0->ge_fwd.gef_epg_id;
+ key0.gck_dst = ge0->ge_fwd.gef_sclass;
else
/* If you cannot determine the destination EP then drop */
goto trace;
- key0.gck_src = vnet_buffer2 (b0)->gbp.src_epg;
+ key0.gck_src = vnet_buffer2 (b0)->gbp.sclass;
- if (EPG_INVALID != key0.gck_src)
+ if (SCLASS_INVALID != key0.gck_src)
{
if (PREDICT_FALSE (key0.gck_src == key0.gck_dst))
{
{
gbp_policy_trace_t *t =
vlib_add_trace (vm, node, b0, sizeof (*t));
- t->src_epg = key0.gck_src;
+ t->sclass = key0.gck_src;
t->dst_epg = key0.gck_dst;
t->acl_index = (gc0 ? gc0->gc_acl_index : ~0),
t->allowed = (next0 != GBP_POLICY_NEXT_DENY);
gbp_policy_trace_t *t = va_arg (*args, gbp_policy_trace_t *);
s =
- format (s, "src:%d, dst:%d, acl:%d allowed:%d",
- t->src_epg, t->dst_epg, t->acl_index, t->allowed);
+ format (s, "sclass:%d, dst:%d, acl:%d allowed:%d",
+ t->sclass, t->dst_epg, t->acl_index, t->allowed);
return s;
}
gbp_recirc_t *gr = va_arg (*args, gbp_recirc_t *);
vnet_main_t *vnm = vnet_get_main ();
- return format (s, " %U, epg:%d, ext:%d",
+ return format (s, " %U, sclass:%d, ext:%d",
format_vnet_sw_if_index_name, vnm,
- gr->gr_sw_if_index, gr->gr_epg, gr->gr_is_ext);
+ gr->gr_sw_if_index, gr->gr_sclass, gr->gr_is_ext);
}
int
-gbp_recirc_add (u32 sw_if_index, epg_id_t epg_id, u8 is_ext)
+gbp_recirc_add (u32 sw_if_index, sclass_t sclass, u8 is_ext)
{
gbp_recirc_t *gr;
index_t gri;
fib_protocol_t fproto;
index_t ggi;
- ggi = gbp_endpoint_group_find (epg_id);
+ ggi = gbp_endpoint_group_find (sclass);
if (INDEX_INVALID == ggi)
return (VNET_API_ERROR_NO_SUCH_ENTRY);
pool_get_zero (gbp_recirc_pool, gr);
gri = gr - gbp_recirc_pool;
- gr->gr_epg = epg_id;
+ gr->gr_sclass = sclass;
gr->gr_is_ext = is_ext;
gr->gr_sw_if_index = sw_if_index;
gbp_endpoint_update_and_lock (GBP_ENDPOINT_SRC_CP,
gr->gr_sw_if_index,
NULL, &mac, INDEX_INVALID,
- INDEX_INVALID, gr->gr_epg,
+ INDEX_INVALID, gr->gr_sclass,
GBP_ENDPOINT_FLAG_NONE,
NULL, NULL, &gr->gr_ep);
vnet_feature_enable_disable ("ip4-unicast",
/**
* EPG ID that packets will classify to when they arrive on this recirc
*/
- epg_id_t gr_epg;
+ sclass_t gr_sclass;
/**
* The index of the EPG
index_t gr_ep;
} gbp_recirc_t;
-extern int gbp_recirc_add (u32 sw_if_index, epg_id_t epg_id, u8 is_ext);
+extern int gbp_recirc_add (u32 sw_if_index, sclass_t sclass, u8 is_ext);
extern int gbp_recirc_delete (u32 sw_if_index);
typedef walk_rc_t (*gbp_recirc_cb_t) (gbp_recirc_t * gbpe, void *ctx);
#include <plugins/gbp/gbp_route_domain.h>
#include <plugins/gbp/gbp_endpoint.h>
-#include <plugins/gbp/gbp_sclass.h>
#include <vnet/dpo/dvr_dpo.h>
#include <vnet/fib/fib_table.h>
&ADJ_BCAST_ADDR,
grd->grd_uu_sw_if_index[fproto],
rewrite);
-
- gbp_sclass_enable_ip (grd->grd_uu_sw_if_index[fproto]);
}
else
{
fproto, FIB_SOURCE_PLUGIN_HI);
if (INDEX_INVALID != grd->grd_adj[fproto])
adj_unlock (grd->grd_adj[fproto]);
- if (~0 != grd->grd_uu_sw_if_index[fproto])
- gbp_sclass_disable_ip (grd->grd_uu_sw_if_index[fproto]);
}
gbp_route_domain_db_remove (grd);
+++ /dev/null
-/*
- * Copyright (c) 2018 Cisco and/or its affiliates.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <plugins/gbp/gbp_sclass.h>
-#include <vnet/l2/l2_input.h>
-#include <vnet/l2/l2_output.h>
-
-gbp_sclass_main_t gbp_sclass_main;
-
-void
-gbp_sclass_enable_l2 (u32 sw_if_index)
-{
- l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_GBP_SCLASS_2_ID, 1);
- l2output_intf_bitmap_enable (sw_if_index, L2OUTPUT_FEAT_GBP_ID_2_SCLASS, 1);
-}
-
-void
-gbp_sclass_disable_l2 (u32 sw_if_index)
-{
- l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_GBP_SCLASS_2_ID, 0);
- l2output_intf_bitmap_enable (sw_if_index, L2OUTPUT_FEAT_GBP_ID_2_SCLASS, 0);
-}
-
-void
-gbp_sclass_enable_ip (u32 sw_if_index)
-{
- vnet_feature_enable_disable ("ip4-unicast",
- "ip4-gbp-sclass-2-id", sw_if_index, 1, 0, 0);
- vnet_feature_enable_disable ("ip6-unicast",
- "ip6-gbp-sclass-2-id", sw_if_index, 1, 0, 0);
- vnet_feature_enable_disable ("ip4-output",
- "ip4-gbp-id-2-sclass", sw_if_index, 1, 0, 0);
- vnet_feature_enable_disable ("ip6-output",
- "ip6-gbp-id-2-sclass", sw_if_index, 1, 0, 0);
-}
-
-void
-gbp_sclass_disable_ip (u32 sw_if_index)
-{
- vnet_feature_enable_disable ("ip4-unicast",
- "ip4-gbp-sclass-2-id", sw_if_index, 0, 0, 0);
- vnet_feature_enable_disable ("ip6-unicast",
- "ip6-gbp-sclass-2-id", sw_if_index, 0, 0, 0);
- vnet_feature_enable_disable ("ip4-output",
- "ip4-gbp-id-2-sclass", sw_if_index, 0, 0, 0);
- vnet_feature_enable_disable ("ip6-output",
- "ip6-gbp-id-2-sclass", sw_if_index, 0, 0, 0);
-}
-
-static clib_error_t *
-gbp_sclass_init (vlib_main_t * vm)
-{
- gbp_sclass_main_t *glm = &gbp_sclass_main;
- vlib_node_t *node = vlib_get_node_by_name (vm, (u8 *) "l2-gbp-sclass-2-id");
-
- /* Initialize the feature next-node indices */
- feat_bitmap_init_next_nodes (vm,
- node->index,
- L2INPUT_N_FEAT,
- l2input_get_feat_names (),
- glm->gel_l2_input_feat_next);
-
- node = vlib_get_node_by_name (vm, (u8 *) "l2-gbp-id-2-sclass");
- feat_bitmap_init_next_nodes (vm,
- node->index,
- L2OUTPUT_N_FEAT,
- l2output_get_feat_names (),
- glm->gel_l2_output_feat_next);
-
- return (NULL);
-}
-
-VLIB_INIT_FUNCTION (gbp_sclass_init);
-
-
-/*
- * fd.io coding-style-patch-verification: ON
- *
- * Local Variables:
- * eval: (c-set-style "gnu")
- * End:
- */
+++ /dev/null
-/*
- * Copyright (c) 2018 Cisco and/or its affiliates.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __GBP_SCLASS_H__
-#define __GBP_SCLASS_H__
-
-#include <plugins/gbp/gbp.h>
-
-/**
- * Grouping of global data for the GBP source EPG classification feature
- */
-typedef struct gbp_sclass_main_t_
-{
- /**
- * Next nodes for L2 output features
- */
- u32 gel_l2_input_feat_next[32];
- u32 gel_l2_output_feat_next[32];
-} gbp_sclass_main_t;
-
-extern gbp_sclass_main_t gbp_sclass_main;
-
-extern void gbp_sclass_enable_l2 (u32 sw_if_index);
-extern void gbp_sclass_disable_l2 (u32 sw_if_index);
-extern void gbp_sclass_enable_ip (u32 sw_if_index);
-extern void gbp_sclass_disable_ip (u32 sw_if_index);
-
-#endif
-
-/*
- * fd.io coding-style-patch-verification: ON
- *
- * Local Variables:
- * eval: (c-set-style "gnu")
- * End:
- */
+++ /dev/null
-/*
- * Copyright (c) 2018 Cisco and/or its affiliates.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <plugins/gbp/gbp_sclass.h>
-#include <vnet/l2/l2_input.h>
-#include <vnet/l2/l2_output.h>
-
-#define foreach_gbp_sclass \
- _(DROP, "drop")
-
-typedef enum
-{
-#define _(sym,str) GBP_SCLASS_NEXT_##sym,
- foreach_gbp_sclass
-#undef _
- GBP_SCLASS_N_NEXT,
-} gbp_sclass_next_t;
-
-typedef struct gbp_sclass_trace_t_
-{
- /* per-pkt trace data */
- u32 epg;
- u32 sclass;
-} gbp_sclass_trace_t;
-
-static_always_inline uword
-gbp_sclass_inline (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame, int is_id_2_sclass, int is_l2)
-{
- u32 n_left_from, *from, *to_next, next_index;
- gbp_sclass_main_t *glm;
-
- glm = &gbp_sclass_main;
- next_index = 0;
- n_left_from = frame->n_vectors;
- from = vlib_frame_vector_args (frame);
-
- while (n_left_from > 0)
- {
- u32 n_left_to_next;
-
- vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
-
- while (n_left_from > 0 && n_left_to_next > 0)
- {
- gbp_sclass_next_t next0;
- vlib_buffer_t *b0;
- epg_id_t epg0;
- u16 sclass0;
- u32 bi0;
-
- next0 = GBP_SCLASS_NEXT_DROP;
- bi0 = from[0];
- to_next[0] = bi0;
- from += 1;
- to_next += 1;
- n_left_from -= 1;
- n_left_to_next -= 1;
-
- b0 = vlib_get_buffer (vm, bi0);
-
- if (is_id_2_sclass)
- {
- // output direction - convert from the SRC-EPD to the sclass
- gbp_endpoint_group_t *gg;
-
- epg0 = vnet_buffer2 (b0)->gbp.src_epg;
- gg = gbp_epg_get (epg0);
-
- if (NULL != gg)
- {
- sclass0 = vnet_buffer2 (b0)->gbp.sclass = gg->gg_sclass;
- if (is_l2)
- next0 =
- vnet_l2_feature_next (b0, glm->gel_l2_output_feat_next,
- L2OUTPUT_FEAT_GBP_ID_2_SCLASS);
- else
- vnet_feature_next (&next0, b0);
- }
- else
- sclass0 = 0;
- }
- else
- {
- /* input direction - convert from the sclass to the SRC-EGD */
- sclass0 = vnet_buffer2 (b0)->gbp.sclass;
- vnet_buffer2 (b0)->gbp.src_epg =
- gbp_epg_sclass_2_id (vnet_buffer2 (b0)->gbp.sclass);
- epg0 = vnet_buffer2 (b0)->gbp.src_epg;
-
- if (EPG_INVALID != epg0)
- {
- if (is_l2)
- next0 =
- vnet_l2_feature_next (b0, glm->gel_l2_input_feat_next,
- L2INPUT_FEAT_GBP_SCLASS_2_ID);
- else
- vnet_feature_next (&next0, b0);
- }
- }
-
- if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
- {
- gbp_sclass_trace_t *t =
- vlib_add_trace (vm, node, b0, sizeof (*t));
- t->epg = epg0;
- t->sclass = sclass0;
- }
-
- vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
- to_next, n_left_to_next,
- bi0, next0);
- }
-
- vlib_put_next_frame (vm, node, next_index, n_left_to_next);
- }
-
- return frame->n_vectors;
-}
-
-VLIB_NODE_FN (l2_gbp_id_2_sclass_node) (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
-{
- return (gbp_sclass_inline (vm, node, frame, 1, 1));
-}
-
-VLIB_NODE_FN (l2_gbp_sclass_2_id_node) (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
-{
- return (gbp_sclass_inline (vm, node, frame, 0, 1));
-}
-
-VLIB_NODE_FN (ip4_gbp_id_2_sclass_node) (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
-{
- return (gbp_sclass_inline (vm, node, frame, 1, 0));
-}
-
-VLIB_NODE_FN (ip4_gbp_sclass_2_id_node) (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
-{
- return (gbp_sclass_inline (vm, node, frame, 0, 0));
-}
-
-VLIB_NODE_FN (ip6_gbp_id_2_sclass_node) (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
-{
- return (gbp_sclass_inline (vm, node, frame, 1, 0));
-}
-
-VLIB_NODE_FN (ip6_gbp_sclass_2_id_node) (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
-{
- return (gbp_sclass_inline (vm, node, frame, 0, 0));
-}
-
-/* packet trace format function */
-static u8 *
-format_gbp_sclass_trace (u8 * s, va_list * args)
-{
- CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
- CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
- gbp_sclass_trace_t *t = va_arg (*args, gbp_sclass_trace_t *);
-
- s = format (s, "epg:%d sclass:%d", t->epg, t->sclass);
-
- return s;
-}
-
-/* *INDENT-OFF* */
-VLIB_REGISTER_NODE (l2_gbp_id_2_sclass_node) = {
- .name = "l2-gbp-id-2-sclass",
- .vector_size = sizeof (u32),
- .format_trace = format_gbp_sclass_trace,
- .type = VLIB_NODE_TYPE_INTERNAL,
-
- .n_next_nodes = GBP_SCLASS_N_NEXT,
-
- .next_nodes = {
- [GBP_SCLASS_NEXT_DROP] = "error-drop",
- },
-};
-VLIB_REGISTER_NODE (l2_gbp_sclass_2_id_node) = {
- .name = "l2-gbp-sclass-2-id",
- .vector_size = sizeof (u32),
- .format_trace = format_gbp_sclass_trace,
- .type = VLIB_NODE_TYPE_INTERNAL,
-
- .n_next_nodes = GBP_SCLASS_N_NEXT,
-
- .next_nodes = {
- [GBP_SCLASS_NEXT_DROP] = "error-drop",
- },
-};
-
-VLIB_REGISTER_NODE (ip4_gbp_id_2_sclass_node) = {
- .name = "ip4-gbp-id-2-sclass",
- .vector_size = sizeof (u32),
- .format_trace = format_gbp_sclass_trace,
- .type = VLIB_NODE_TYPE_INTERNAL,
-
- .n_next_nodes = GBP_SCLASS_N_NEXT,
-
- .next_nodes = {
- [GBP_SCLASS_NEXT_DROP] = "error-drop",
- },
-};
-VLIB_REGISTER_NODE (ip4_gbp_sclass_2_id_node) = {
- .name = "ip4-gbp-sclass-2-id",
- .vector_size = sizeof (u32),
- .format_trace = format_gbp_sclass_trace,
- .type = VLIB_NODE_TYPE_INTERNAL,
-
- .n_next_nodes = GBP_SCLASS_N_NEXT,
-
- .next_nodes = {
- [GBP_SCLASS_NEXT_DROP] = "error-drop",
- },
-};
-
-VLIB_REGISTER_NODE (ip6_gbp_id_2_sclass_node) = {
- .name = "ip6-gbp-id-2-sclass",
- .vector_size = sizeof (u32),
- .format_trace = format_gbp_sclass_trace,
- .type = VLIB_NODE_TYPE_INTERNAL,
-
- .n_next_nodes = GBP_SCLASS_N_NEXT,
-
- .next_nodes = {
- [GBP_SCLASS_NEXT_DROP] = "error-drop",
- },
-};
-VLIB_REGISTER_NODE (ip6_gbp_sclass_2_id_node) = {
- .name = "ip6-gbp-sclass-2-id",
- .vector_size = sizeof (u32),
- .format_trace = format_gbp_sclass_trace,
- .type = VLIB_NODE_TYPE_INTERNAL,
-
- .n_next_nodes = GBP_SCLASS_N_NEXT,
-
- .next_nodes = {
- [GBP_SCLASS_NEXT_DROP] = "error-drop",
- },
-};
-
-
-VNET_FEATURE_INIT (ip4_gbp_sclass_2_id_feat, static) =
-{
- .arc_name = "ip4-unicast",
- .node_name = "ip4-gbp-sclass-2-id",
- .runs_before = VNET_FEATURES ("gbp-learn-ip4"),
-};
-VNET_FEATURE_INIT (ip6_gbp_sclass_2_id_feat, static) =
-{
- .arc_name = "ip6-unicast",
- .node_name = "ip6-gbp-sclass-2-id",
- .runs_before = VNET_FEATURES ("gbp-learn-ip6"),
-};
-VNET_FEATURE_INIT (ip4_gbp_id_2_sclass_feat, static) =
-{
- .arc_name = "ip4-output",
- .node_name = "ip4-gbp-id-2-sclass",
-};
-VNET_FEATURE_INIT (ip6_gbp_id_2_sclass_feat, static) =
-{
- .arc_name = "ip6-output",
- .node_name = "ip6-gbp-id-2-sclass",
-};
-/* *INDENT-ON* */
-
-/*
- * fd.io coding-style-patch-verification: ON
- *
- * Local Variables:
- * eval: (c-set-style "gnu")
- * End:
- */
{
struct
{
- epg_id_t gs_epg;
+ sclass_t gs_sclass;
u32 gs_sw_if_index;
} gs_stitched_external;
struct
{
- epg_id_t gs_epg;
+ sclass_t gs_sclass;
} gs_l3_out;
};
}
static int
-gbp_subnet_external_add (gbp_subnet_t * gs, u32 sw_if_index, epg_id_t epg)
+gbp_subnet_external_add (gbp_subnet_t * gs, u32 sw_if_index, sclass_t sclass)
{
dpo_id_t gpd = DPO_INVALID;
- gs->gs_stitched_external.gs_epg = epg;
+ gs->gs_stitched_external.gs_sclass = sclass;
gs->gs_stitched_external.gs_sw_if_index = sw_if_index;
gbp_policy_dpo_add_or_lock (fib_proto_to_dpo (gs->gs_key->gsk_pfx.fp_proto),
- gs->gs_stitched_external.gs_epg,
+ gs->gs_stitched_external.gs_sclass,
gs->gs_stitched_external.gs_sw_if_index, &gpd);
gs->gs_fei = fib_table_entry_special_dpo_update (gs->gs_key->gsk_fib_index,
}
static int
-gbp_subnet_l3_out_add (gbp_subnet_t * gs, u32 sw_if_index, epg_id_t epg)
+gbp_subnet_l3_out_add (gbp_subnet_t * gs, u32 sw_if_index, sclass_t sclass)
{
dpo_id_t gpd = DPO_INVALID;
- gs->gs_l3_out.gs_epg = epg;
+ gs->gs_l3_out.gs_sclass = sclass;
gbp_policy_dpo_add_or_lock (fib_proto_to_dpo (gs->gs_key->gsk_pfx.fp_proto),
- gs->gs_l3_out.gs_epg, ~0, &gpd);
+ gs->gs_l3_out.gs_sclass, ~0, &gpd);
gs->gs_fei = fib_table_entry_special_dpo_add (gs->gs_key->gsk_fib_index,
&gs->gs_key->gsk_pfx,
int
gbp_subnet_add (u32 rd_id,
const fib_prefix_t * pfx,
- gbp_subnet_type_t type, u32 sw_if_index, epg_id_t epg)
+ gbp_subnet_type_t type, u32 sw_if_index, sclass_t sclass)
{
gbp_route_domain_t *grd;
index_t grdi, gsi;
rv = gbp_subnet_internal_add (gs);
break;
case GBP_SUBNET_STITCHED_EXTERNAL:
- rv = gbp_subnet_external_add (gs, sw_if_index, epg);
+ rv = gbp_subnet_external_add (gs, sw_if_index, sclass);
break;
case GBP_SUBNET_TRANSPORT:
rv = gbp_subnet_transport_add (gs);
break;
case GBP_SUBNET_L3_OUT:
- rv = gbp_subnet_l3_out_add (gs, sw_if_index, epg);
+ rv = gbp_subnet_l3_out_add (gs, sw_if_index, sclass);
break;
}
gbp_route_domain_t *grd;
gbp_subnet_t *gs;
u32 sw_if_index;
- epg_id_t epg;
+ sclass_t sclass;
- epg = EPG_INVALID;
+ sclass = SCLASS_INVALID;
sw_if_index = ~0;
/* *INDENT-OFF* */
break;
case GBP_SUBNET_STITCHED_EXTERNAL:
sw_if_index = gs->gs_stitched_external.gs_sw_if_index;
- epg = gs->gs_stitched_external.gs_epg;
+ sclass = gs->gs_stitched_external.gs_sclass;
break;
case GBP_SUBNET_L3_OUT:
- epg = gs->gs_l3_out.gs_epg;
+ sclass = gs->gs_l3_out.gs_sclass;
break;
}
if (WALK_STOP == cb (grd->grd_id, &gs->gs_key->gsk_pfx,
- gs->gs_type, sw_if_index, epg, ctx))
+ gs->gs_type, sw_if_index, sclass, ctx))
break;
}));
/* *INDENT-ON* */
case GBP_SUBNET_TRANSPORT:
break;
case GBP_SUBNET_STITCHED_EXTERNAL:
- s = format (s, " {epg:%d %U}", gs->gs_stitched_external.gs_epg,
+ s = format (s, " {sclass:%d %U}", gs->gs_stitched_external.gs_sclass,
format_vnet_sw_if_index_name,
vnet_get_main (), gs->gs_stitched_external.gs_sw_if_index);
break;
case GBP_SUBNET_L3_OUT:
- s = format (s, " {epg:%d}", gs->gs_l3_out.gs_epg);
+ s = format (s, " {sclass:%d}", gs->gs_l3_out.gs_sclass);
break;
}
extern int gbp_subnet_add (u32 rd_id,
const fib_prefix_t * pfx,
gbp_subnet_type_t type,
- u32 sw_if_index, epg_id_t epg);
+ u32 sw_if_index, sclass_t sclass);
extern int gbp_subnet_del (u32 rd_id, const fib_prefix_t * pfx);
const fib_prefix_t * pfx,
gbp_subnet_type_t type,
u32 sw_if_index,
- epg_id_t epg, void *ctx);
+ sclass_t sclass, void *ctx);
extern void gbp_subnet_walk (gbp_subnet_cb_t cb, void *ctx);
#include <vnet/vnet.h>
-typedef u16 epg_id_t;
-#define EPG_INVALID ((u16)~0)
+typedef u32 vnid_t;
+#define VNID_INVALID ((u16)~0)
+
+typedef u16 sclass_t;
#define SCLASS_INVALID ((u16)~0)
#endif
#include <plugins/gbp/gbp_learn.h>
#include <plugins/gbp/gbp_bridge_domain.h>
#include <plugins/gbp/gbp_route_domain.h>
-#include <plugins/gbp/gbp_sclass.h>
#include <vnet/vxlan-gbp/vxlan_gbp.h>
#include <vlibmemory/api.h>
vxr->vxr_itf = gbp_itf_add_and_lock (vxr->vxr_sw_if_index,
gt->gt_bd_index);
- ofeat = (L2OUTPUT_FEAT_GBP_POLICY_MAC |
- L2OUTPUT_FEAT_GBP_ID_2_SCLASS);
- ifeat = L2INPUT_FEAT_GBP_SCLASS_2_ID;
+ ofeat = L2OUTPUT_FEAT_GBP_POLICY_MAC;
+ ifeat = L2INPUT_FEAT_NONE;
if (!(gbd->gb_flags & GBP_BD_FLAG_DO_NOT_LEARN))
ifeat |= L2INPUT_FEAT_GBP_LEARN;
grd->grd_table_id[fproto], 1);
gbp_learn_enable (vxr->vxr_sw_if_index, GBP_LEARN_MODE_L3);
- gbp_sclass_enable_ip (vxr->vxr_sw_if_index);
}
}
FOR_EACH_FIB_IP_PROTOCOL (fproto)
ip_table_bind (fproto, vxr->vxr_sw_if_index, 0, 0);
- gbp_sclass_disable_ip (vxr->vxr_sw_if_index);
gbp_learn_disable (vxr->vxr_sw_if_index, GBP_LEARN_MODE_L3);
}
gt->gt_itf = gbp_itf_add_and_lock (gt->gt_sw_if_index,
gt->gt_bd_index);
gbp_learn_enable (gt->gt_sw_if_index, GBP_LEARN_MODE_L2);
- gbp_sclass_enable_l2 (gt->gt_sw_if_index);
}
else
{
grd->grd_vni_sw_if_index = gt->gt_sw_if_index;
gbp_learn_enable (gt->gt_sw_if_index, GBP_LEARN_MODE_L3);
- gbp_sclass_enable_ip (gt->gt_sw_if_index);
ip4_sw_interface_enable_disable (gt->gt_sw_if_index, 1);
ip6_sw_interface_enable_disable (gt->gt_sw_if_index, 1);
if (GBP_VXLAN_TUN_L2 == gt->gt_layer)
{
gbp_learn_disable (gt->gt_sw_if_index, GBP_LEARN_MODE_L2);
- gbp_sclass_disable_l2 (gt->gt_sw_if_index);
gbp_itf_unlock (gt->gt_itf);
gbp_bridge_domain_unlock (gt->gt_gbd);
}
ip6_sw_interface_enable_disable (gt->gt_sw_if_index, 0);
gbp_learn_disable (gt->gt_sw_if_index, GBP_LEARN_MODE_L3);
- gbp_sclass_disable_ip (gt->gt_sw_if_index);
gbp_route_domain_unlock (gt->gt_grd);
}
#include <plugins/gbp/gbp_learn.h>
#include <plugins/gbp/gbp_bridge_domain.h>
#include <plugins/gbp/gbp_route_domain.h>
-#include <plugins/gbp/gbp_sclass.h>
#include <vnet/vxlan-gbp/vxlan_gbp.h>
#include <vlibmemory/api.h>
{
u8 __unused;
u8 flags;
- union
- {
- u16 src_epg;
- u16 sclass;
- };
+ u16 sclass;
} gbp;
/**
s = format (s, "loop_counter: %d", o->loop_counter);
vec_add1 (s, '\n');
- s = format (s, "gbp.flags: %x, gbp.src_epg: %d",
- (u32) (o->gbp.flags), (u32) (o->gbp.src_epg));
+ s = format (s, "gbp.flags: %x, gbp.sclass: %d",
+ (u32) (o->gbp.flags), (u32) (o->gbp.sclass));
vec_add1 (s, '\n');
s = format (s, "pg_replay_timestamp: %llu", (u32) (o->pg_replay_timestamp));
_(GBP_NULL_CLASSIFY, "gbp-null-classify") \
_(GBP_SRC_CLASSIFY, "gbp-src-classify") \
_(GBP_LPM_CLASSIFY, "l2-gbp-lpm-classify") \
- _(GBP_SCLASS_2_ID, "l2-gbp-sclass-2-id") \
_(VTR, "l2-input-vtr") \
_(L2_IP_QOS_RECORD, "l2-ip-qos-record") \
_(VPATH, "vpath-input-l2") \
#define foreach_l2output_feat \
_(OUTPUT, "interface-output") \
_(SPAN, "span-l2-output") \
- _(GBP_ID_2_SCLASS, "l2-gbp-id-2-sclass") \
_(GBP_POLICY_PORT, "gbp-policy-port") \
_(GBP_POLICY_MAC, "gbp-policy-mac") \
_(CFM, "feature-bitmap-drop") \
self.itf.sw_if_index,
[self.ip4.encode(), self.ip6.encode()],
self.vmac.packed,
- self.epg.epg,
+ self.epg.sclass,
self.flags,
self.tun_src.encode(),
self.tun_dst.encode())
return "gbp-endpoint:[%d==%d:%s:%d]" % (self.handle,
self.itf.sw_if_index,
self.ip4.address,
- self.epg.epg)
+ self.epg.sclass)
def query_vpp_config(self):
return find_gbp_endpoint(self._test,
self._test.vapi.gbp_recirc_add_del(
1,
self.recirc.sw_if_index,
- self.epg.epg,
+ self.epg.sclass,
self.is_ext)
self._test.registry.register(self, self._test.logger)
self._test.vapi.gbp_recirc_add_del(
0,
self.recirc.sw_if_index,
- self.epg.epg,
+ self.epg.sclass,
self.is_ext)
def __str__(self):
self.prefix.encode(),
self.type,
sw_if_index=self.sw_if_index if self.sw_if_index else 0xffffffff,
- epg_id=self.epg if self.epg else 0xffff)
+ sclass=self.epg.sclass if self.epg else 0xffff)
self._test.registry.register(self, self._test.logger)
def remove_vpp_config(self):
GBP Endpoint Group
"""
- def __init__(self, test, epg, sclass, rd, bd, uplink,
+ def __init__(self, test, vnid, sclass, rd, bd, uplink,
bvi, bvi_ip4, bvi_ip6=None,
retention=VppGbpEndpointRetention()):
self._test = test
self.bvi = bvi
self.bvi_ip4 = VppIpAddress(bvi_ip4)
self.bvi_ip6 = VppIpAddress(bvi_ip6)
- self.epg = epg
+ self.vnid = vnid
self.bd = bd
self.rd = rd
self.sclass = sclass
def add_vpp_config(self):
self._test.vapi.gbp_endpoint_group_add(
- self.epg,
+ self.vnid,
self.sclass,
self.bd.bd.bd_id,
self.rd.rd_id,
self._test.registry.register(self, self._test.logger)
def remove_vpp_config(self):
- self._test.vapi.gbp_endpoint_group_del(self.epg)
+ self._test.vapi.gbp_endpoint_group_del(self.sclass)
def __str__(self):
return self.object_id()
def object_id(self):
- return "gbp-endpoint-group:[%d]" % (self.epg)
+ return "gbp-endpoint-group:[%d]" % (self.vnid)
def query_vpp_config(self):
epgs = self._test.vapi.gbp_endpoint_group_dump()
for epg in epgs:
- if epg.epg.epg_id == self.epg:
+ if epg.epg.vnid == self.vnid:
return True
return False
rules.append(r.encode())
self._test.vapi.gbp_contract_add_del(
1,
- self.src_epg,
- self.dst_epg,
+ self.src_epg.sclass,
+ self.dst_epg.sclass,
self.acl_index,
rules,
self.allowed_ethertypes)
def remove_vpp_config(self):
self._test.vapi.gbp_contract_add_del(
0,
- self.src_epg,
- self.dst_epg,
+ self.src_epg.sclass,
+ self.dst_epg.sclass,
self.acl_index,
[], [])
return self.object_id()
def object_id(self):
- return "gbp-contract:[%d:%s:%d]" % (self.src_epg,
- self.dst_epg,
+ return "gbp-contract:[%d:%s:%d]" % (self.src_epg.sclass,
+ self.dst_epg.sclass,
self.acl_index)
def query_vpp_config(self):
cs = self._test.vapi.gbp_contract_dump()
for c in cs:
- if c.contract.src_epg == self.src_epg \
- and c.contract.dst_epg == self.dst_epg:
+ if c.contract.sclass == self.src_epg.sclass \
+ and c.contract.dclass == self.dst_epg.sclass:
return True
return False
# 3 EPGs, 2 of which share a BD.
# 2 NAT EPGs, one for floating-IP subnets, the other for internet
#
- epgs = [VppGbpEndpointGroup(self, 220, 0, rd0, gbd1, self.pg4,
- self.loop0,
- "10.0.0.128",
- "2001:10::128"),
- VppGbpEndpointGroup(self, 221, 0, rd0, gbd1, self.pg5,
- self.loop0,
- "10.0.1.128",
- "2001:10:1::128"),
- VppGbpEndpointGroup(self, 222, 0, rd0, gbd2, self.pg6,
- self.loop1,
- "10.0.2.128",
- "2001:10:2::128"),
- VppGbpEndpointGroup(self, 333, 0, rd20, gbd20, self.pg7,
- self.loop2,
- "11.0.0.128",
- "3001::128"),
- VppGbpEndpointGroup(self, 444, 0, rd20, gbd20, self.pg8,
- self.loop2,
- "11.0.0.129",
- "3001::129")]
- recircs = [VppGbpRecirc(self, epgs[0],
- self.loop3),
- VppGbpRecirc(self, epgs[1],
- self.loop4),
- VppGbpRecirc(self, epgs[2],
- self.loop5),
- VppGbpRecirc(self, epgs[3],
- self.loop6, is_ext=True),
- VppGbpRecirc(self, epgs[4],
- self.loop7, is_ext=True)]
+ epgs = [VppGbpEndpointGroup(self, 220, 1220, rd0, gbd1,
+ self.pg4, self.loop0,
+ "10.0.0.128", "2001:10::128"),
+ VppGbpEndpointGroup(self, 221, 1221, rd0, gbd1,
+ self.pg5, self.loop0,
+ "10.0.1.128", "2001:10:1::128"),
+ VppGbpEndpointGroup(self, 222, 1222, rd0, gbd2,
+ self.pg6, self.loop1,
+ "10.0.2.128", "2001:10:2::128"),
+ VppGbpEndpointGroup(self, 333, 1333, rd20, gbd20,
+ self.pg7, self.loop2,
+ "11.0.0.128", "3001::128"),
+ VppGbpEndpointGroup(self, 444, 1444, rd20, gbd20,
+ self.pg8, self.loop2,
+ "11.0.0.129", "3001::129")]
+ recircs = [VppGbpRecirc(self, epgs[0], self.loop3),
+ VppGbpRecirc(self, epgs[1], self.loop4),
+ VppGbpRecirc(self, epgs[2], self.loop5),
+ VppGbpRecirc(self, epgs[3], self.loop6, is_ext=True),
+ VppGbpRecirc(self, epgs[4], self.loop7, is_ext=True)]
epg_nat = epgs[3]
recirc_nat = recircs[3]
rule2 = acl.create_rule(is_ipv6=1, permit_deny=1, proto=17)
acl_index = acl.add_vpp_config([rule, rule2])
c1 = VppGbpContract(
- self, 220, 221, acl_index,
+ self, epgs[0], epgs[1], acl_index,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_PERMIT,
[]),
# contract for the return direction
#
c2 = VppGbpContract(
- self, 221, 220, acl_index,
+ self, epgs[1], epgs[0], acl_index,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_PERMIT,
[]),
# A uni-directional contract from EPG 220 -> 222 'L3 routed'
#
c3 = VppGbpContract(
- self, 220, 222, acl_index,
+ self, epgs[0], epgs[2], acl_index,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_PERMIT,
[]),
self, rd0, "0.0.0.0", 0,
VppEnum.vl_api_gbp_subnet_type_t.GBP_API_SUBNET_STITCHED_EXTERNAL,
sw_if_index=recirc_nat.recirc.sw_if_index,
- epg=epg_nat.epg)
+ epg=epg_nat)
se2 = VppGbpSubnet(
self, rd0, "11.0.0.0", 8,
VppEnum.vl_api_gbp_subnet_type_t.GBP_API_SUBNET_STITCHED_EXTERNAL,
sw_if_index=recirc_nat.recirc.sw_if_index,
- epg=epg_nat.epg)
+ epg=epg_nat)
se16 = VppGbpSubnet(
self, rd0, "::", 0,
VppEnum.vl_api_gbp_subnet_type_t.GBP_API_SUBNET_STITCHED_EXTERNAL,
sw_if_index=recirc_nat.recirc.sw_if_index,
- epg=epg_nat.epg)
+ epg=epg_nat)
# in the NAT RD an external subnet via the NAT EPG's uplink
se3 = VppGbpSubnet(
self, rd20, "0.0.0.0", 0,
VppEnum.vl_api_gbp_subnet_type_t.GBP_API_SUBNET_STITCHED_EXTERNAL,
sw_if_index=epg_nat.uplink.sw_if_index,
- epg=epg_nat.epg)
+ epg=epg_nat)
se36 = VppGbpSubnet(
self, rd20, "::", 0,
VppEnum.vl_api_gbp_subnet_type_t.GBP_API_SUBNET_STITCHED_EXTERNAL,
sw_if_index=epg_nat.uplink.sw_if_index,
- epg=epg_nat.epg)
+ epg=epg_nat)
se4 = VppGbpSubnet(
self, rd20, "11.0.0.0", 8,
VppEnum.vl_api_gbp_subnet_type_t.GBP_API_SUBNET_STITCHED_EXTERNAL,
sw_if_index=epg_nat.uplink.sw_if_index,
- epg=epg_nat.epg)
+ epg=epg_nat)
se1.add_vpp_config()
se2.add_vpp_config()
se16.add_vpp_config()
acl_index2 = acl2.add_vpp_config([rule, rule2])
c4 = VppGbpContract(
- self, 220, 333, acl_index2,
+ self, epgs[0], epgs[3], acl_index2,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_PERMIT,
[]),
pkt_inter_epg_220_from_global * 65)
c5 = VppGbpContract(
- self, 333, 220, acl_index2,
+ self, epgs[3], epgs[0], acl_index2,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_PERMIT,
[]),
rule2 = acl.create_rule(is_ipv6=1, permit_deny=1, proto=17)
acl_index = acl.add_vpp_config([rule, rule2])
c1 = VppGbpContract(
- self, 220, 330, acl_index,
+ self, epg_220, epg_330, acl_index,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_PERMIT,
[]),
# test the src-ip hash mode
#
c1 = VppGbpContract(
- self, 220, 222, acl_index,
+ self, epg_220, epg_222, acl_index,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_REDIRECT,
VppEnum.vl_api_gbp_hash_mode_t.GBP_API_HASH_MODE_SRC_IP,
c1.add_vpp_config()
c2 = VppGbpContract(
- self, 222, 220, acl_index,
+ self, epg_222, epg_220, acl_index,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_REDIRECT,
VppEnum.vl_api_gbp_hash_mode_t.GBP_API_HASH_MODE_SRC_IP,
# test the symmetric hash mode
#
c1 = VppGbpContract(
- self, 220, 222, acl_index,
+ self, epg_220, epg_222, acl_index,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_REDIRECT,
VppEnum.vl_api_gbp_hash_mode_t.GBP_API_HASH_MODE_SYMMETRIC,
c1.add_vpp_config()
c2 = VppGbpContract(
- self, 222, 220, acl_index,
+ self, epg_222, epg_220, acl_index,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_REDIRECT,
VppEnum.vl_api_gbp_hash_mode_t.GBP_API_HASH_MODE_SYMMETRIC,
Raw('\xa5' * 100))]
c3 = VppGbpContract(
- self, 220, 221, acl_index,
+ self, epg_220, epg_221, acl_index,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_REDIRECT,
VppEnum.vl_api_gbp_hash_mode_t.GBP_API_HASH_MODE_SYMMETRIC,
vx_tun_l3.add_vpp_config()
c4 = VppGbpContract(
- self, 221, 220, acl_index,
+ self, epg_221, epg_220, acl_index,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_PERMIT,
[]),
# test the dst-ip hash mode
#
c5 = VppGbpContract(
- self, 220, 221, acl_index,
+ self, epg_220, epg_221, acl_index,
[VppGbpContractRule(
VppEnum.vl_api_gbp_rule_action_t.GBP_API_RULE_REDIRECT,
VppEnum.vl_api_gbp_hash_mode_t.GBP_API_HASH_MODE_DST_IP,
l3o_1 = VppGbpSubnet(
self, rd1, "10.0.0.0", 24,
VppEnum.vl_api_gbp_subnet_type_t.GBP_API_SUBNET_L3_OUT,
- epg=220)
+ epg=epg_220)
l3o_1.add_vpp_config()
#
l3o_220 = VppGbpSubnet(
self, rd1, "10.220.0.0", 24,
VppEnum.vl_api_gbp_subnet_type_t.GBP_API_SUBNET_L3_OUT,
- epg=220)
+ epg=epg_220)
l3o_220.add_vpp_config()
p = (Ether(src=self.pg7.remote_mac,
'enable_ip6': 1 if enable_ip6 else 0,
})
- def gbp_endpoint_add(self, sw_if_index, ips, mac, epg, flags,
+ def gbp_endpoint_add(self, sw_if_index, ips, mac, sclass, flags,
tun_src, tun_dst):
""" GBP endpoint Add """
return self.api(self.papi.gbp_endpoint_add,
'ips': ips,
'n_ips': len(ips),
'mac': mac,
- 'epg_id': epg,
+ 'sclass': sclass,
'flags': flags,
'tun': {
'src': tun_src,
return self.api(self.papi.gbp_endpoint_dump,
{'_no_type_conversion': True})
- def gbp_endpoint_group_add(self, epg, sclass, bd,
+ def gbp_endpoint_group_add(self, vnid, sclass, bd,
rd, uplink_sw_if_index,
retention):
""" GBP endpoint group Add """
'uplink_sw_if_index': uplink_sw_if_index,
'bd_id': bd,
'rd_id': rd,
- 'epg_id': epg,
+ 'vnid': vnid,
'sclass': sclass,
'retention': retention
}})
- def gbp_endpoint_group_del(self, epg):
+ def gbp_endpoint_group_del(self, sclass):
""" GBP endpoint group Del """
return self.api(self.papi.gbp_endpoint_group_del,
- {'epg_id': epg})
+ {'sclass': sclass})
def gbp_endpoint_group_dump(self):
""" GBP endpoint group Dump """
""" GBP Route Domain Dump """
return self.api(self.papi.gbp_route_domain_dump, {})
- def gbp_recirc_add_del(self, is_add, sw_if_index, epg, is_ext):
+ def gbp_recirc_add_del(self, is_add, sw_if_index, sclass, is_ext):
""" GBP recirc Add/Del """
return self.api(self.papi.gbp_recirc_add_del,
{'is_add': is_add,
'recirc': {
'is_ext': is_ext,
'sw_if_index': sw_if_index,
- 'epg_id': epg}})
+ 'sclass': sclass}})
def gbp_recirc_dump(self):
""" GBP recirc Dump """
def gbp_subnet_add_del(self, is_add, rd_id,
prefix, type,
sw_if_index=0xffffffff,
- epg_id=0xffff):
+ sclass=0xffff):
""" GBP Subnet Add/Del """
return self.api(self.papi.gbp_subnet_add_del,
{'is_add': is_add,
'subnet': {
'type': type,
'sw_if_index': sw_if_index,
- 'epg_id': epg_id,
+ 'sclass': sclass,
'prefix': prefix,
'rd_id': rd_id}})
return self.api(self.papi.gbp_subnet_dump,
{'_no_type_conversion': True})
- def gbp_contract_add_del(self, is_add, src_epg, dst_epg, acl_index,
+ def gbp_contract_add_del(self, is_add, sclass, dclass, acl_index,
rules, allowed_ethertypes):
""" GBP contract Add/Del """
return self.api(self.papi.gbp_contract_add_del,
{'is_add': is_add,
'contract': {
'acl_index': acl_index,
- 'src_epg': src_epg,
- 'dst_epg': dst_epg,
+ 'sclass': sclass,
+ 'dclass': dclass,
'n_rules': len(rules),
'rules': rules,
'n_ether_types': len(allowed_ethertypes),
Code Review / vpp.git / commitdiff