Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2015 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : 
       6             : #ifndef SRC_VNSW_AGENT_VROUTER_KSYNC_KSYNC_MEMORY_H_
       7             : #define SRC_VNSW_AGENT_VROUTER_KSYNC_KSYNC_MEMORY_H_
       8             : 
       9             : /*
      10             :  * Module responsible to manage the VRouter memory mapped to agent
      11             :  */
      12             : #include <list>
      13             : #include <base/address.h>
      14             : struct nl_client;
      15             : class KSync;
      16             : class KSyncMemory {
      17             : public:
      18             :     // Time to sweep flow-table for audit
      19             :     static const uint32_t kAuditSweepTime = 180;
      20             :     // Timer interval for audit process
      21             :     static const uint32_t kAuditYieldTimer = 100;  // in msec
      22             :     // Flows in HOLD state longer than kAuditTimeout are deleted
      23             :     static const uint32_t kAuditTimeout = (5 * 1000 * 1000); // in usec
      24             :     // Upper limit on number of entries to visit per timer
      25             :     static const uint32_t kAuditYieldMax = (1024);
      26             :     // Lower limit on number of entries to visit per timer
      27             :     static const uint32_t kAuditYieldMin = (100);
      28             : 
      29             :     KSyncMemory(KSync *ksync, uint32_t minor_id);
      30             :     virtual ~KSyncMemory();
      31             : 
      32             :     virtual void Init();
      33             :     void InitMem(void *hpmem);
      34             :     virtual void InitTest();
      35             :     virtual void Shutdown();
      36             :     bool AuditProcess();
      37             :     void MapSharedMemory();
      38             :     void GetTableSize();
      39             :     int GetKernelTableSize();
      40             :     void UnmapMemTest();
      41             : 
      42             :     virtual int EncodeReq(nl_client *nl, uint32_t attr_len) = 0;
      43             :     virtual int get_entry_size() = 0;
      44           0 :     virtual void SetTableSize() {};
      45             :     virtual bool IsInactiveEntry(uint32_t idx, uint8_t &gen_id) = 0;
      46             :     virtual void CreateProtoAuditEntry(uint32_t index, uint8_t gen_id) = 0;
      47           0 :     virtual void DecrementHoldFlowCounter() {};
      48           0 :     virtual void IncrementHoldFlowCounter() {};
      49           0 :     virtual void UpdateAgentHoldFlowCounter() {};
      50             :     KSync* ksync() const { return ksync_;}
      51           0 :     void set_major_devid(int id) { major_devid_ = id;}
      52           0 :     void set_table_size(int count) { table_size_ = count; }
      53           0 :     void set_table_path(const std::string &path) {
      54           0 :         table_path_ = path;
      55           0 :     }
      56           4 :     uint32_t audit_timeout() const { return audit_timeout_; }
      57             :     void Mmap(bool unlink, void *khpmem, bool kernel_mode);
      58     1447965 :     uint32_t table_entries_count() { return table_entries_count_; }
      59             : 
      60             : protected:
      61             :     struct AuditEntry {
      62           0 :         AuditEntry(uint32_t flow_idx, uint8_t gen_id,
      63           0 :                    uint64_t t) : audit_idx(flow_idx),
      64           0 :                    audit_gen_id(gen_id), timeout(t) {}
      65             : 
      66             :         uint32_t audit_idx;
      67             :         uint8_t audit_gen_id;
      68             :         uint64_t timeout;
      69             :     };
      70             : 
      71             :     KSync        *ksync_;
      72             :     void         *table_;
      73             :     // Name of file used to map flow table
      74             :     std::string   table_path_;
      75             :     // major dev-id on linux based implementation
      76             :     int           major_devid_;
      77             :     int           minor_devid_;
      78             :     // Size of flow table memory
      79             :     int           table_size_;
      80             :     // Count of entries in flow-table
      81             :     uint32_t      table_entries_count_;
      82             :     // Audit related entries
      83             :     Timer                   *audit_timer_;
      84             : 
      85             :     uint32_t                audit_timeout_;
      86             :     uint32_t                audit_yield_;
      87             :     uint32_t                audit_interval_;
      88             :     uint32_t                audit_idx_;
      89             :     std::list<AuditEntry> audit_list_;
      90             : };
      91             : #endif