Merge "* Agent changes to support QoS"

src/ksync/ksync_sock.cc

@@ -1019,6 +1019,16 @@ void KSyncBulkSandeshContext::MplsMsgHandler(vr_mpls_req *req) {
     context->MplsMsgHandler(req);
 }
 
+void KSyncBulkSandeshContext::QosConfigMsgHandler(vr_qos_map_req *req) {
+    AgentSandeshContext *context = GetSandeshContext();
+    context->QosConfigMsgHandler(req);
+}
+
+void KSyncBulkSandeshContext::ForwardingClassMsgHandler(vr_fc_map_req *req) {
+    AgentSandeshContext *context = GetSandeshContext();
+    context->ForwardingClassMsgHandler(req);
+}
+
 // vr_response message is treated as delimiter in a bulk-context. So, move to
 // next io-context within bulk-message context.
 int KSyncBulkSandeshContext::VrResponseMsgHandler(vr_response *resp) {

src/ksync/ksync_sock.h

@@ -53,6 +53,8 @@ class AgentSandeshContext : public SandeshContext {
     virtual void DropStatsMsgHandler(vr_drop_stats_req *req) = 0;
     virtual void VxLanMsgHandler(vr_vxlan_req *req) = 0;
     virtual void VrouterOpsMsgHandler(vrouter_ops *req) = 0;
+    virtual void QosConfigMsgHandler(vr_qos_map_req *req) = 0;
+    virtual void ForwardingClassMsgHandler(vr_fc_map_req *req) = 0;
     virtual void SetErrno(int err) {errno_ = err;}
 
     int GetErrno() const {return errno_;}
@@ -185,6 +187,8 @@ class KSyncBulkSandeshContext : public AgentSandeshContext {
     void DropStatsMsgHandler(vr_drop_stats_req *req);
     void VxLanMsgHandler(vr_vxlan_req *req);
     void VrouterOpsMsgHandler(vrouter_ops *req);
+    void QosConfigMsgHandler(vr_qos_map_req *req);
+    void ForwardingClassMsgHandler(vr_fc_map_req *req);
     void SetErrno(int err);
 
     bool Decoder(char *buff, uint32_t buff_len, uint32_t alignment, bool more);

src/ksync/ksync_sock_user.cc

@@ -924,6 +924,14 @@ void KSyncUserSockContext::RouteMsgHandler(vr_route_req *req) {
     }
 }
 
+void KSyncUserSockContext::QosConfigMsgHandler(vr_qos_map_req *req) {
+    assert(0);
+}
+
+void KSyncUserSockContext::ForwardingClassMsgHandler(vr_fc_map_req *req) {
+    assert(0);
+}
+
 void KSyncUserSockContext::MirrorMsgHandler(vr_mirror_req *req) {
     KSyncSockTypeMap *sock = KSyncSockTypeMap::GetKSyncSockTypeMap();
 

src/ksync/ksync_sock_user.h

@@ -43,6 +43,8 @@ class KSyncUserSockContext : public AgentSandeshContext {
     virtual void VrfStatsMsgHandler(vr_vrf_stats_req *req);
     virtual void DropStatsMsgHandler(vr_drop_stats_req *req);
     virtual void VxLanMsgHandler(vr_vxlan_req *req);
+    virtual void QosConfigMsgHandler(vr_qos_map_req *req);
+    virtual void ForwardingClassMsgHandler(vr_fc_map_req *req);
     virtual void VrouterOpsMsgHandler(vrouter_ops *req);
     virtual void Process() {}
 private:

src/vnsw/agent/cfg/cfg_init.cc

@@ -183,6 +183,26 @@ void AgentConfig::RegisterDBClients(DB *db) {
     assert(cfg_physical_device_table_);
 
 
+    cfg_qos_table_ = (static_cast<IFMapAgentTable *>
+                      (IFMapTable::FindTable(agent_->db(),
+                                             "qos-config")));
+    assert(cfg_qos_table_);
+
+    cfg_global_qos_table_ = (static_cast<IFMapAgentTable *>
+                            (IFMapTable::FindTable(agent_->db(),
+                                                   "global-qos-config")));
+    assert(cfg_global_qos_table_);
+
+    cfg_qos_queue_table_ = (static_cast<IFMapAgentTable *>
+                            (IFMapTable::FindTable(agent_->db(),
+                                                   "qos-queue")));
+    assert(cfg_qos_queue_table_);
+
+    cfg_forwarding_class_table_ = (static_cast<IFMapAgentTable *>
+                            (IFMapTable::FindTable(agent_->db(),
+                                                   "forwarding-class")));
+    assert(cfg_forwarding_class_table_);
+
     cfg_interface_client_->Init();
 }
 

src/vnsw/agent/cfg/cfg_init.h

@@ -77,6 +77,22 @@ class AgentConfig  {
         return cfg_physical_device_table_;
     }
 
+    IFMapAgentTable *cfg_qos_table() const {
+        return cfg_qos_table_;
+    }
+
+    IFMapAgentTable *cfg_global_qos_table() const {
+        return cfg_global_qos_table_;
+    }
+
+    IFMapAgentTable *cfg_qos_queue_table() const {
+        return cfg_qos_queue_table_;
+    }
+
+    IFMapAgentTable *cfg_forwarding_class_table() const {
+        return cfg_forwarding_class_table_;
+    }
+
     Agent *agent() const { return agent_; }
     CfgFilter *cfg_filter() const { return cfg_filter_.get(); }
     IFMapAgentParser *cfg_parser() const { return cfg_parser_.get(); }
@@ -133,6 +149,10 @@ class AgentConfig  {
     IFMapAgentTable *cfg_service_instance_table_;
     IFMapAgentTable *cfg_security_group_table_;
     IFMapAgentTable *cfg_physical_device_table_;
+    IFMapAgentTable *cfg_qos_table_;
+    IFMapAgentTable *cfg_global_qos_table_;
+    IFMapAgentTable *cfg_qos_queue_table_;
+    IFMapAgentTable *cfg_forwarding_class_table_;
 
     DISALLOW_COPY_AND_ASSIGN(AgentConfig);
 };

src/vnsw/agent/cmn/agent.h

@@ -132,6 +132,24 @@ typedef boost::intrusive_ptr<HealthCheckService> HealthCheckServiceRef;
 void intrusive_ptr_release(const HealthCheckService* p);
 void intrusive_ptr_add_ref(const HealthCheckService* p);
 
+class ForwardingClass;
+typedef boost::intrusive_ptr<ForwardingClass> ForwardingClassRef;
+typedef boost::intrusive_ptr<const ForwardingClass> ForwardingClassConstRef;
+void intrusive_ptr_release(const ForwardingClass *p);
+void intrusive_ptr_add_ref(const ForwardingClass *p);
+
+class AgentQosConfig;
+typedef boost::intrusive_ptr<AgentQosConfig> AgentQosConfigRef;
+typedef boost::intrusive_ptr<const AgentQosConfig> AgentQosConfigConstRef;
+void intrusive_ptr_release(const AgentQosConfig *p);
+void intrusive_ptr_add_ref(const AgentQosConfig *p);
+
+class QosQueue;
+typedef boost::intrusive_ptr<QosQueue> QosQueueRef;
+typedef boost::intrusive_ptr<const QosQueue> QosQueueConstRef;
+void intrusive_ptr_release(const QosQueueRef *p);
+void intrusive_ptr_add_ref(const QosQueueRef *p);
+
 //class SecurityGroup;
 typedef std::vector<int> SecurityGroupList;
 typedef std::vector<std::string> CommunityList;
@@ -162,7 +180,9 @@ class VxLanTable;
 class MulticastGroupObject;
 class PhysicalDeviceTable;
 class PhysicalDeviceVnTable;
-
+class ForwardingClassTable;
+class AgentQosConfigTable;
+class QosQueueTable;
 class MirrorCfgTable;
 class IntfMirrorCfgTable;
 
@@ -376,6 +396,28 @@ class Agent {
         intf_cfg_table_ = table;
     }
 
+    ForwardingClassTable *forwarding_class_table() const {
+        return forwarding_class_table_;
+    }
+    void set_forwarding_class_table(ForwardingClassTable *table) {
+        forwarding_class_table_ = table;
+    }
+
+    AgentQosConfigTable *qos_config_table() const {
+        return qos_config_table_;
+    }
+
+    void set_qos_config_table(AgentQosConfigTable *qos_config_table) {
+        qos_config_table_ = qos_config_table;
+    }
+
+    QosQueueTable *qos_queue_table() const {
+        return qos_queue_table_;
+    }
+    void set_qos_queue_table(QosQueueTable *table) {
+        qos_queue_table_ = table;
+    }
+
     DomainConfig *domain_config_table() const;
 
     IntfMirrorCfgTable *interface_mirror_cfg_table() const {
@@ -1065,6 +1107,9 @@ class Agent {
     ServiceInstanceTable *service_instance_table_;
     PhysicalDeviceTable *physical_device_table_;
     PhysicalDeviceVnTable *physical_device_vn_table_;
+    ForwardingClassTable *forwarding_class_table_;
+    QosQueueTable *qos_queue_table_;
+    AgentQosConfigTable *qos_config_table_;
     std::auto_ptr<ConfigManager> config_manager_;
 
     // Mirror config table

src/vnsw/agent/filter/acl.cc

@@ -30,6 +30,7 @@
 #include <oper/agent_sandesh.h>
 #include <oper/nexthop.h>
 #include <oper/mirror_table.h>
+#include <oper/qos_config.h>
 
 static AclTable *acl_table_;
 
@@ -120,7 +121,23 @@ DBEntry *AclTable::OperDBAdd(const DBRequest *req) {
 bool AclTable::OperDBOnChange(DBEntry *entry, const DBRequest *req) {
     bool changed = false;
     AclDBEntry *acl = static_cast<AclDBEntry *>(entry);
-    AclData *data = static_cast<AclData *>(req->data.get());
+    AclData *data = dynamic_cast<AclData *>(req->data.get());
+    AclResyncQosConfigData *qos_config_data =
+        dynamic_cast<AclResyncQosConfigData *>(req->data.get());
+
+    DeleteUnresolvedEntry(acl);
+
+    if (qos_config_data != NULL) {
+        changed = acl->ResyncQosConfigEntries();
+        if (acl->IsQosConfigResolved() == false) {
+            AddUnresolvedEntry(acl);
+        }
+        return changed;
+    }
+
+    if (!data) {
+        return false;
+    }
 
     if (data->ace_id_to_del_) {
         acl->DeleteAclEntry(data->ace_id_to_del_);
@@ -162,12 +179,21 @@ bool AclTable::OperDBOnChange(DBEntry *entry, const DBRequest *req) {
             delete ae;
         }
     }
+
+    if (acl->IsQosConfigResolved() == false) {
+        AddUnresolvedEntry(acl);
+    }
     return changed;
 }
 
+bool AclTable::OperDBResync(DBEntry *entry, const DBRequest *req) {
+    return OperDBOnChange(entry, req);
+}
+
 bool AclTable::OperDBDelete(DBEntry *entry, const DBRequest *req) {
     AclDBEntry *acl = static_cast<AclDBEntry *>(entry);
     ACL_TRACE(Info, "Delete " + UuidToString(acl->GetUuid()));
+    DeleteUnresolvedEntry(acl);
     acl->DeleteAllAclEntries();
     return true;
 }
@@ -189,6 +215,52 @@ AclTable::ConvertActionString(std::string action_str) const {
     }
 }
 
+void AclTable::AddUnresolvedEntry(AclDBEntry *entry) {
+    unresolved_acl_entries_.insert(entry);
+}
+
+void AclTable::DeleteUnresolvedEntry(AclDBEntry *entry) {
+    unresolved_acl_entries_.erase(entry);
+}
+
+void AclTable::Notify(DBTablePartBase *partition,
+                      DBEntryBase *e) {
+    AgentQosConfig *qc = static_cast<AgentQosConfig *>(e);
+    DBState *state = qc->GetState(partition->parent(), qos_config_listener_id_);
+
+    if (qc->IsDeleted()) {
+        qc->ClearState(partition->parent(), qos_config_listener_id_);
+        delete state;
+    }
+
+    if (state) {
+        return;
+    }
+
+    state = new DBState();
+    qc->SetState(partition->parent(), qos_config_listener_id_, state);
+
+    UnResolvedAclEntries::const_iterator it = unresolved_acl_entries_.begin();
+    for (; it != unresolved_acl_entries_.end(); it++) {
+        DBRequest req;
+        req.oper = DBRequest::DB_ENTRY_ADD_CHANGE;
+
+        AclKey *key = new AclKey((*it)->GetUuid());
+        key->sub_op_ = AgentKey::RESYNC;
+
+        req.key.reset(key);
+        req.data.reset(new AclResyncQosConfigData(NULL, NULL));
+        Enqueue(&req);
+    }
+    unresolved_acl_entries_.clear();
+}
+
+void AclTable::ListenerInit() {
+    qos_config_listener_id_ = agent()->qos_config_table()->Register(
+                boost::bind(&AclTable::Notify, this, _1, _2));
+
+}
+
 DBTableBase *AclTable::CreateTable(DB *db, const std::string &name) {
     acl_table_ = new AclTable(db, name);
     acl_table_->Init();
@@ -401,6 +473,33 @@ void AclDBEntry::SetAclEntries(AclEntries &entries)
     }
 }
 
+bool AclDBEntry::IsQosConfigResolved() {
+    AclEntries::iterator it;
+    it = acl_entries_.begin();
+    while (it != acl_entries_.end()) {
+        AclEntry *ae = it.operator->();
+        if (ae->IsQosConfigResolved() == false) {
+            return false;
+        }
+        it++;
+    }
+    return true;
+}
+
+bool AclDBEntry::ResyncQosConfigEntries() {
+    bool ret = false;
+    AclEntries::iterator it;
+    it = acl_entries_.begin();
+    while (it != acl_entries_.end()) {
+        AclEntry *ae = it.operator->();
+        if (ae->ResyncQosConfigEntries()) {
+            ret = true;
+        }
+        it++;
+    }
+    return ret;
+}
+
 AclEntry *AclDBEntry::AddAclEntry(const AclEntrySpec &acl_entry_spec, AclEntries &entries)
 {
     AclEntries::iterator iter;
@@ -508,6 +607,19 @@ bool AclDBEntry::PacketMatch(const PacketHeader &packet_header,
                                                          a->ignore_acl());
              m_acl.action_info.vrf_translate_action_ = vrf_translate_action;
          }
+         if (ta->action_type() == TrafficAction::QOS_ACTION) {
+             const QosConfigAction *a =
+                 static_cast<const QosConfigAction *>(*al_it.operator->());
+             if (a->qos_config_ref() != NULL) {
+                 QosConfigActionSpec qos_action_spec(a->name());
+                 if (a->qos_config_ref() &&
+                     a->qos_config_ref()->IsDeleted() == false) {
+                     qos_action_spec.set_id(a->qos_config_ref()->id());
+                     m_acl.action_info.qos_config_action_ = qos_action_spec;
+                 }
+             }
+         }
+
          if (info && ta->IsDrop()) {
              if (!info->drop) {
                  info->drop = true;
@@ -542,6 +654,21 @@ bool AclDBEntry::PacketMatch(const PacketHeader &packet_header,
     return ret_val;
 }
 
+const AclEntry*
+AclDBEntry::GetAclEntryAtIndex(uint32_t index) const {
+    uint32_t i = 0;
+    AclEntries::const_iterator it = acl_entries_.begin();
+    while (it != acl_entries_.end()) {
+        if (i == index) {
+            return it.operator->();
+        }
+        it++;
+        i++;
+    }
+
+    return NULL;
+}
+
 bool AclDBEntry::Changed(const AclEntries &new_entries) const {
     AclEntries::const_iterator it = acl_entries_.begin();
     AclEntries::const_iterator new_entries_it = new_entries.begin();
@@ -876,6 +1003,15 @@ void AclEntrySpec::PopulateAction(const AclTable *acl_table,
         vrf_translate_spec.vrf_translate.set_ignore_acl(false);
         action_l.push_back(vrf_translate_spec);
     }
+
+    if (!action_list.qos_action.empty()) {
+        ActionSpec qos_translate_spec;
+        qos_translate_spec.ta_type = TrafficAction::QOS_ACTION;
+        qos_translate_spec.simple_action = TrafficAction::APPLY_QOS;
+        qos_translate_spec.qos_config_action.set_name(
+                action_list.qos_action);
+        action_l.push_back(qos_translate_spec);
+    }
 }
 
 void AclTable::set_ace_flow_sandesh_data_cb(FlowAceSandeshDataFn fn) {