physical_switch.h

Go to the documentation of this file.

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef __PHYSICAL_SWITCH_H__
#define __PHYSICAL_SWITCH_H__

#include <stdlib.h> 
#include <string.h> 
#include "rofl.h"
#include "openflow/of_switch.h"
#include "switch_port.h"
#include "monitoring.h"
#include "platform/lock.h"

#ifndef PHYSICAL_SWITCH_MAX_LS

    #define PHYSICAL_SWITCH_MAX_LS 64
#endif

#ifndef PHYSICAL_SWITCH_MAX_NUM_PHY_PORTS

    #define PHYSICAL_SWITCH_MAX_NUM_PHY_PORTS 1024 
#endif

#ifndef PHYSICAL_SWITCH_MAX_NUM_VIR_PORTS

    #define PHYSICAL_SWITCH_MAX_NUM_VIR_PORTS 256
#endif

#ifndef PHYSICAL_SWITCH_MAX_NUM_TUN_PORTS

    #define PHYSICAL_SWITCH_MAX_NUM_TUN_PORTS 32
#endif
    
#define PHYSICAL_SWITCH_MAX_NUM_META_PORTS 8

//Opaque platform state (to be used, maybe, for platform hooks).
//Currently unused
typedef void platform_physical_switch_state_t;


extern switch_port_t* flood_meta_port;

extern switch_port_t* in_port_meta_port;

extern switch_port_t* all_meta_port;

typedef struct physical_switch{

        /*
        * List of all logical switches in the system
        */
        unsigned int num_of_logical_switches;
        of_switch_t* logical_switches[PHYSICAL_SWITCH_MAX_LS];

        /*
        * Ports
        */
        //physical: index is the physical port of the platform.
        switch_port_t* physical_ports[PHYSICAL_SWITCH_MAX_NUM_PHY_PORTS];

        //tunnel ports
        switch_port_t* tunnel_ports[PHYSICAL_SWITCH_MAX_NUM_TUN_PORTS]; //Not used yet

        //virtual ports (which are not tunnel)
        switch_port_t* virtual_ports[PHYSICAL_SWITCH_MAX_NUM_VIR_PORTS]; //Not used yet

        //meta ports (esoteric ports). This is NOT an array of pointers!
        switch_port_t meta_ports[PHYSICAL_SWITCH_MAX_NUM_META_PORTS]; 

        //Monitoring data
        monitoring_state_t monitoring;

        /* 
        * Other state 
        */
        //Mutex
        platform_mutex_t* mutex;

        //Opaque platform specific extra state 
        platform_physical_switch_state_t* platform_state;       
}physical_switch_t; 

typedef struct dpid_list{

        //Number of ports in the port list
        unsigned int num_of_lsis;
        
        //dpids
        uint64_t* dpids;
}dpid_list_t; 

//C++ extern C
ROFL_BEGIN_DECLS


//
//
// Physical switch mgmt
//
//

rofl_result_t physical_switch_init(void);

physical_switch_t* get_physical_switch(void);

//Only used in multi-process deployments (with shared memory)
void __set_physical_switch(physical_switch_t* sw);

void physical_switch_destroy(void);


//
//
// Logical switch management
//
//

of_switch_t** physical_switch_get_logical_switches(unsigned int* max_switches);

rofl_result_t physical_switch_add_logical_switch(of_switch_t* sw);

rofl_result_t physical_switch_remove_logical_switch_by_dpid(const uint64_t dpid);

rofl_result_t physical_switch_remove_logical_switch(of_switch_t* sw);

//Getters
of_switch_t* physical_switch_get_logical_switch_by_dpid(const uint64_t dpid);

of_switch_t* physical_switch_get_logical_switch_attached_to_port(const switch_port_t port);

//
//
// Port management routines
//
//

switch_port_t* physical_switch_get_port_by_name(const char *name);

switch_port_t** physical_switch_get_physical_ports(unsigned int* max_ports);

switch_port_t** physical_switch_get_virtual_ports(unsigned int* max_ports);

switch_port_t** physical_switch_get_tunnel_ports(unsigned int* max_ports);

rofl_result_t physical_switch_add_port(switch_port_t* port);

rofl_result_t physical_switch_remove_port(const char* name);


//
//
// Logical switches port management
//
//

switch_port_t* physical_switch_get_port_by_num(const uint64_t dpid, unsigned int port_num);


rofl_result_t get_logical_switch_ports(of_switch_t* sw, logical_switch_port_t** ports, unsigned int* num_of_ports, unsigned int* logical_sw_max_ports);

rofl_result_t physical_switch_attach_port_to_logical_switch(switch_port_t* port, of_switch_t* sw, unsigned int* port_num);

rofl_result_t physical_switch_attach_port_to_logical_switch_at_port_num(switch_port_t* port, of_switch_t* sw, unsigned int port_num);

rofl_result_t physical_switch_detach_port_num_from_logical_switch(unsigned int port_num, of_switch_t* sw);

rofl_result_t physical_switch_detach_port_from_logical_switch(switch_port_t* port, of_switch_t* sw);

rofl_result_t physical_switch_detach_all_ports_from_logical_switch(of_switch_t* sw);



//
// Monitoring
//
static inline monitoring_state_t* physical_switch_get_monitoring(void){
        physical_switch_t* psw = get_physical_switch();
        
        if(psw)
                return &psw->monitoring;        
        return NULL;
}

//
// Snapshots
//

//Ports
switch_port_name_list_t* physical_switch_get_all_port_names(void);

switch_port_snapshot_t* physical_switch_get_port_snapshot(const char* name);


//LSIs

dpid_list_t* physical_switch_get_all_lsi_dpids(void);

void dpid_list_destroy(dpid_list_t* list);

of_switch_snapshot_t* physical_switch_get_logical_switch_snapshot(const uint64_t dpid);


//
// Other
//

//This should not be used in general. Generates the matching algorithm list
void __physical_switch_generate_matching_algorithm_list(void);


//C++ extern C
ROFL_END_DECLS

#endif //PHYSICAL_SWITCH