ofswitch13-device.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 University of Campinas (Unicamp)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Luciano Jerez Chaves <ljerezchaves@gmail.com>
 */
 
#ifndef OFSWITCH13_DEVICE_H
#define OFSWITCH13_DEVICE_H
 
#include "ofswitch13-interface.h"
#include "ofswitch13-socket-handler.h"
 
#include <ns3/inet-socket-address.h>
#include <ns3/socket.h>
#include <ns3/string.h>
#include <ns3/tcp-header.h>
#include <ns3/traced-value.h>
#include <ns3/uinteger.h>
 
namespace ns3
{
 
class OFSwitch13Port;
 
class OFSwitch13Device : public Object
{
  private:
    class RemoteController : public SimpleRefCount<RemoteController>
    {
        friend class OFSwitch13Device;
 
      public:
        RemoteController();
 
      private:
        Ptr<Socket> m_socket;                   
        Ptr<OFSwitch13SocketHandler> m_handler; 
        Address m_address;                      
        struct remote* m_remote;                
    };                                          // Class RemoteController
 
    struct PipelinePacket
    {
      public:
        PipelinePacket();
 
        void SetPacket(uint64_t id, Ptr<Packet> packet);
 
        Ptr<Packet> GetPacket() const;
 
        void Invalidate();
 
        bool IsValid() const;
 
        void NewCopy(uint64_t id);
 
        bool DelCopy(uint64_t id);
 
        bool HasId(uint64_t id);
 
      private:
        bool m_valid;              
        Ptr<Packet> m_packet;      
        std::list<uint64_t> m_ids; 
    };                             // Struct PipelinePacket
 
  public:
    OFSwitch13Device();           
    ~OFSwitch13Device() override; 
 
    static TypeId GetTypeId();
 
    uint64_t GetDatapathId() const;
 
    uint64_t GetDpId() const;
 
    //\{
    uint64_t GetFlowModCounter() const;
    uint64_t GetGroupModCounter() const;
    uint64_t GetMeterModCounter() const;
    uint64_t GetPacketInCounter() const;
    uint64_t GetPacketOutCounter() const;
    //\}
 
    //\{
    uint32_t GetBufferEntries() const;
    uint32_t GetBufferSize() const;
    double GetBufferUsage() const;
    DataRate GetCpuCapacity() const;
    DataRate GetCpuLoad() const;
    double GetCpuUsage() const;
    Time GetDatapathTimeout() const;
    uint32_t GetDftFlowTableSize() const;
    uint32_t GetFlowTableEntries(uint8_t tableId) const;
    uint32_t GetFlowTableSize(uint8_t tableId) const;
    double GetFlowTableUsage(uint8_t tableId) const;
    uint32_t GetGroupTableEntries() const;
    uint32_t GetGroupTableSize() const;
    double GetGroupTableUsage() const;
    uint32_t GetMeterTableEntries() const;
    uint32_t GetMeterTableSize() const;
    double GetMeterTableUsage() const;
    uint32_t GetNControllers() const;
    uint32_t GetNPipelineTables() const;
    uint32_t GetNSwitchPorts() const;
    Time GetPipelineDelay() const;
    uint32_t GetSumFlowEntries() const;
    //\}
 
    struct datapath* GetDatapathStruct();
 
    Ptr<OFSwitch13Port> AddSwitchPort(Ptr<NetDevice> portDevice);
 
    Ptr<OFSwitch13Port> GetSwitchPort(uint32_t no) const;
 
    void ReceiveFromSwitchPort(Ptr<Packet> packet,
                               uint32_t portNo,
                               uint64_t tunnelId = 0);
 
    void StartControllerConnection(Address ctrlAddr);
 
    static void SendPacketToController(struct pipeline* pl,
                                       struct packet* pkt,
                                       uint8_t tableId,
                                       uint8_t reason);
 
    static int SendOpenflowBufferToRemote(struct ofpbuf* buffer,
                                          struct remote* remote);
 
    static void DpActionsOutputPort(struct packet* pkt,
                                    uint32_t outPort,
                                    uint32_t outQueue,
                                    uint16_t maxLength,
                                    uint64_t cookie);
 
    static void MeterCreatedCallback(struct meter_entry* entry);
 
    static void MeterDropCallback(struct packet* pkt,
                                  struct meter_entry* entry);
 
    static void TableDropCallback(struct packet* pkt, struct flow_table* table);
 
    static void PacketCloneCallback(struct packet* pkt, struct packet* clone);
 
    static void PacketDestroyCallback(struct packet* pkt);
 
    static void BufferSaveCallback(struct packet* pkt, time_t timeout);
 
    static void BufferRetrieveCallback(struct packet* pkt);
 
    static Ptr<OFSwitch13Device> GetDevice(uint64_t id);
 
    typedef void (*MeterDropTracedCallback)(Ptr<const Packet> packet,
                                            uint32_t meterId);
 
    typedef void (*TableDropTracedCallback)(Ptr<const Packet> packet,
                                            uint8_t tableId);
 
    typedef void (*DeviceTracedCallback)(Ptr<const OFSwitch13Device> dev);
 
  protected:
    // Inherited from Object
    void DoDispose() override;
 
    // Inherited from ObjectBase.
    void NotifyConstructionCompleted() override;
 
  private:
    struct datapath* DatapathNew();
 
    //\{
    void SetFlowTableSize(uint8_t tableId, uint32_t value);
    void SetDftFlowTableSize(uint32_t value);
    void SetGroupTableSize(uint32_t value);
    void SetMeterTableSize(uint32_t value);
    //\}
 
    void DatapathTimeout(struct datapath* dp);
 
    int SendPacketInMessage(struct packet* pkt,
                            uint8_t tableId,
                            uint8_t reason,
                            uint16_t maxLength,
                            uint64_t cookie = 0);
 
    bool SendToSwitchPort(struct packet* pkt,
                          uint32_t portNo,
                          uint32_t queueNo = 0);
 
    void SendToPipeline(Ptr<Packet> packet,
                        uint32_t portNo,
                        uint64_t tunnelId = 0);
 
    int SendToController(Ptr<Packet> packet,
                         Ptr<OFSwitch13Device::RemoteController> remoteCtrl);
 
    void ReceiveFromController(Ptr<Packet> packet, Address from);
 
    int ReplyWithErrorMessage(ofl_err error,
                              struct ofpbuf* buffer,
                              struct sender* senderCtrl);
 
    void SocketCtrlSucceeded(Ptr<Socket> socket);
 
    void SocketCtrlFailed(Ptr<Socket> socket);
 
    void NotifyMeterEntryCreated(struct meter_entry* entry);
 
    void NotifyPacketCloned(struct packet* pkt, struct packet* clone);
 
    void NotifyPacketDestroyed(struct packet* pkt);
 
    void NotifyPacketDroppedByMeter(struct packet* pkt,
                                    struct meter_entry* entry);
 
    void NotifyPacketDroppedByTable(struct packet* pkt,
                                    struct flow_table* table);
 
    void BufferPacketSave(uint64_t packetId, time_t timeout);
 
    void BufferPacketRetrieve(uint64_t packetId);
 
    void BufferPacketDelete(uint64_t packetId);
 
    Ptr<OFSwitch13Device::RemoteController> GetRemoteController(
        Ptr<Socket> socket);
 
    Ptr<OFSwitch13Device::RemoteController> GetRemoteController(
        Address address);
 
    Ptr<OFSwitch13Device::RemoteController> GetRemoteController(
        struct remote* remote);
 
    static uint64_t GetNewPacketId();
 
    static bool CopyTags(Ptr<const Packet> srcPkt, Ptr<const Packet> dstPkt);
 
    static void RegisterDatapath(uint64_t id, Ptr<OFSwitch13Device> dev);
 
    static void UnregisterDatapath(uint64_t id);
 
    typedef std::vector<Ptr<OFSwitch13Port>> PortList_t;
 
    typedef std::vector<Ptr<OFSwitch13Device::RemoteController>> CtrlList_t;
 
    typedef std::map<uint64_t, Ptr<OFSwitch13Device>> DpIdDevMap_t;
 
    typedef std::map<uint64_t, Ptr<Packet>> IdPacketMap_t;
 
    TracedCallback<Ptr<const Packet>> m_bufferExpireTrace;
 
    TracedCallback<Ptr<const Packet>> m_bufferRetrieveTrace;
 
    TracedCallback<Ptr<const Packet>> m_bufferSaveTrace;
 
    TracedCallback<Ptr<const OFSwitch13Device>> m_datapathTimeoutTrace;
 
    TracedCallback<Ptr<const Packet>> m_loadDropTrace;
 
    TracedCallback<Ptr<const Packet>, uint32_t> m_meterDropTrace;
 
    TracedCallback<Ptr<const Packet>, uint8_t> m_tableDropTrace;
 
    TracedCallback<Ptr<const Packet>> m_pipePacketTrace;
 
    TracedValue<uint32_t> m_groupEntries;
 
    TracedValue<uint32_t> m_meterEntries;
 
    TracedValue<uint32_t> m_sumFlowEntries;
 
    TracedValue<Time> m_pipeDelay;
 
    TracedValue<DataRate> m_cpuLoad;
 
    uint64_t m_dpId;             
    Time m_timeout;              
    Time m_lastTimeout;          
    Time m_tcamDelay;            
    std::string m_libLog;        
    struct datapath* m_datapath; 
    PortList_t m_ports;          
    CtrlList_t m_controllers;    
    uint32_t m_flowTabSize;      
    uint32_t m_groupTabSize;     
    uint32_t m_meterTabSize;     
    uint32_t m_numPipeTabs;      
    IdPacketMap_t m_bufferPkts;  
    uint32_t m_bufferSize;       
    PipelinePacket m_pipePkt;    
    DataRate m_cpuCapacity;      
    uint64_t m_cpuConsumed;      
    uint64_t m_cpuTokens;        
    uint64_t m_cFlowMod;         
    uint64_t m_cGroupMod;        
    uint64_t m_cMeterMod;        
    uint64_t m_cPacketIn;        
    uint64_t m_cPacketOut;       
 
    static uint64_t m_globalDpId;  
    static uint64_t m_globalPktId; 
 
    static DpIdDevMap_t m_globalSwitchMap;
 
}; // Class OFSwitch13Device
 
} // namespace ns3
#endif /* OFSWITCH13_DEVICE_H */