[ovs.git] / ofproto / ofproto.h

/*
 * Copyright (c) 2009, 2010, 2011 Nicira Networks.
 *
 * 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 OFPROTO_H
#define OFPROTO_H 1

#include <sys/types.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "cfm.h"
#include "flow.h"
#include "netflow.h"
#include "sset.h"
#include "tag.h"

#ifdef  __cplusplus
extern "C" {
#endif

struct cfm_settings;
struct cls_rule;
struct netdev;
struct ofproto;
struct shash;

struct ofproto_controller_info {
    bool is_connected;
    enum nx_role role;
    struct {
        const char *keys[4];
        const char *values[4];
        size_t n;
    } pairs;
};

struct ofexpired {
    struct flow flow;
    uint64_t packet_count;      /* Packets from subrules. */
    uint64_t byte_count;        /* Bytes from subrules. */
    long long int used;         /* Last-used time (0 if never used). */
};

struct ofproto_sflow_options {
    struct sset targets;
    uint32_t sampling_rate;
    uint32_t polling_interval;
    uint32_t header_len;
    uint32_t sub_id;
    char *agent_device;
    char *control_ip;
};

/* How the switch should act if the controller cannot be contacted. */
enum ofproto_fail_mode {
    OFPROTO_FAIL_SECURE,        /* Preserve flow table. */
    OFPROTO_FAIL_STANDALONE     /* Act as a standalone switch. */
};

enum ofproto_band {
    OFPROTO_IN_BAND,            /* In-band connection to controller. */
    OFPROTO_OUT_OF_BAND         /* Out-of-band connection to controller. */
};

struct ofproto_controller {
    char *target;               /* e.g. "tcp:127.0.0.1" */
    int max_backoff;            /* Maximum reconnection backoff, in seconds. */
    int probe_interval;         /* Max idle time before probing, in seconds. */
    enum ofproto_band band;      /* In-band or out-of-band? */

    /* OpenFlow packet-in rate-limiting. */
    int rate_limit;             /* Max packet-in rate in packets per second. */
    int burst_limit;            /* Limit on accumulating packet credits. */
};

#define DEFAULT_MFR_DESC "Nicira Networks, Inc."
#define DEFAULT_HW_DESC "Open vSwitch"
#define DEFAULT_SW_DESC VERSION BUILDNR
#define DEFAULT_SERIAL_DESC "None"
#define DEFAULT_DP_DESC "None"

void ofproto_enumerate_types(struct sset *types);
const char *ofproto_normalize_type(const char *);

int ofproto_enumerate_names(const char *type, struct sset *names);
void ofproto_parse_name(const char *name, char **dp_name, char **dp_type);

int ofproto_create(const char *datapath, const char *datapath_type,
                   struct ofproto **ofprotop);
void ofproto_destroy(struct ofproto *);
int ofproto_delete(const char *name, const char *type);

int ofproto_run(struct ofproto *);
void ofproto_wait(struct ofproto *);
bool ofproto_is_alive(const struct ofproto *);

/* A port within an OpenFlow switch.
 *
 * 'name' and 'type' are suitable for passing to netdev_open(). */
struct ofproto_port {
    char *name;                 /* Network device name, e.g. "eth0". */
    char *type;                 /* Network device type, e.g. "system". */
    uint16_t ofp_port;          /* OpenFlow port number. */
};
void ofproto_port_clone(struct ofproto_port *, const struct ofproto_port *);
void ofproto_port_destroy(struct ofproto_port *);

struct ofproto_port_dump {
    const struct ofproto *ofproto;
    int error;
    void *state;
};
void ofproto_port_dump_start(struct ofproto_port_dump *,
                             const struct ofproto *);
bool ofproto_port_dump_next(struct ofproto_port_dump *, struct ofproto_port *);
int ofproto_port_dump_done(struct ofproto_port_dump *);

/* Iterates through each OFPROTO_PORT in OFPROTO, using DUMP as state.
 *
 * Arguments all have pointer type.
 *
 * If you break out of the loop, then you need to free the dump structure by
 * hand using ofproto_port_dump_done(). */
#define OFPROTO_PORT_FOR_EACH(OFPROTO_PORT, DUMP, OFPROTO)  \
    for (ofproto_port_dump_start(DUMP, OFPROTO);            \
         (ofproto_port_dump_next(DUMP, OFPROTO_PORT)        \
          ? true                                            \
          : (ofproto_port_dump_done(DUMP), false));         \
        )

#define OFPROTO_FLOW_EVICTON_THRESHOLD_DEFAULT	1000
#define OFPROTO_FLOW_EVICTION_THRESHOLD_MIN	100

int ofproto_port_add(struct ofproto *, struct netdev *, uint16_t *ofp_portp);
int ofproto_port_del(struct ofproto *, uint16_t ofp_port);

int ofproto_port_query_by_name(const struct ofproto *, const char *devname,
                               struct ofproto_port *);

/* Top-level configuration. */
void ofproto_set_datapath_id(struct ofproto *, uint64_t datapath_id);
void ofproto_set_controllers(struct ofproto *,
                             const struct ofproto_controller *, size_t n);
void ofproto_set_fail_mode(struct ofproto *, enum ofproto_fail_mode fail_mode);
void ofproto_reconnect_controllers(struct ofproto *);
void ofproto_set_extra_in_band_remotes(struct ofproto *,
                                       const struct sockaddr_in *, size_t n);
void ofproto_set_in_band_queue(struct ofproto *, int queue_id);
void ofproto_set_flow_eviction_threshold(struct ofproto *, unsigned threshold);
void ofproto_set_forward_bpdu(struct ofproto *, bool forward_bpdu);
void ofproto_set_desc(struct ofproto *,
                      const char *mfr_desc, const char *hw_desc,
                      const char *sw_desc, const char *serial_desc,
                      const char *dp_desc);
int ofproto_set_snoops(struct ofproto *, const struct sset *snoops);
int ofproto_set_netflow(struct ofproto *,
                        const struct netflow_options *nf_options);
int ofproto_set_sflow(struct ofproto *, const struct ofproto_sflow_options *);

/* Configuration of ports. */

void ofproto_port_unregister(struct ofproto *, uint16_t ofp_port);

void ofproto_port_clear_cfm(struct ofproto *, uint16_t ofp_port);
void ofproto_port_set_cfm(struct ofproto *, uint16_t ofp_port,
                          const struct cfm_settings *);
int ofproto_port_is_lacp_current(struct ofproto *, uint16_t ofp_port);

/* The behaviour of the port regarding VLAN handling */
enum port_vlan_mode {
    /* This port is an access port.  'vlan' is the VLAN ID.  'trunks' is
     * ignored. */
    PORT_VLAN_ACCESS,

    /* This port is a trunk.  'trunks' is the set of trunks. 'vlan' is
     * ignored. */
    PORT_VLAN_TRUNK,

    /* Untagged incoming packets are part of 'vlan', as are incoming packets
     * tagged with 'vlan'.  Outgoing packets tagged with 'vlan' stay tagged.
     * Other VLANs in 'trunks' are trunked. */
    PORT_VLAN_NATIVE_TAGGED,

    /* Untagged incoming packets are part of 'vlan', as are incoming packets
     * tagged with 'vlan'.  Outgoing packets tagged with 'vlan' are untagged.
     * Other VLANs in 'trunks' are trunked. */
    PORT_VLAN_NATIVE_UNTAGGED
};

/* Configuration of bundles. */
struct ofproto_bundle_settings {
    char *name;                 /* For use in log messages. */

    uint16_t *slaves;           /* OpenFlow port numbers for slaves. */
    size_t n_slaves;

    enum port_vlan_mode vlan_mode; /* Selects mode for vlan and trunks */
    int vlan;                   /* VLAN VID, except for PORT_VLAN_TRUNK. */
    unsigned long *trunks;      /* vlan_bitmap, except for PORT_VLAN_ACCESS. */

    struct bond_settings *bond; /* Must be nonnull iff if n_slaves > 1. */
    uint32_t *bond_stable_ids;  /* Array of n_slaves elements. */

    struct lacp_settings *lacp;              /* Nonnull to enable LACP. */
    struct lacp_slave_settings *lacp_slaves; /* Array of n_slaves elements. */
};

int ofproto_bundle_register(struct ofproto *, void *aux,
                            const struct ofproto_bundle_settings *);
int ofproto_bundle_unregister(struct ofproto *, void *aux);

/* Configuration of mirrors. */
struct ofproto_mirror_settings {
    /* Name for log messages. */
    char *name;

    /* Bundles that select packets for mirroring upon ingress.  */
    void **srcs;                /* A set of registered ofbundle handles. */
    size_t n_srcs;

    /* Bundles that select packets for mirroring upon egress.  */
    void **dsts;                /* A set of registered ofbundle handles. */
    size_t n_dsts;

    /* VLANs of packets to select for mirroring. */
    unsigned long *src_vlans;   /* vlan_bitmap, NULL selects all VLANs. */

    /* Output (mutually exclusive). */
    void *out_bundle;           /* A registered ofbundle handle or NULL. */
    uint16_t out_vlan;          /* Output VLAN, only if out_bundle is NULL. */
};

int ofproto_mirror_register(struct ofproto *, void *aux,
                            const struct ofproto_mirror_settings *);
int ofproto_mirror_unregister(struct ofproto *, void *aux);

int ofproto_set_flood_vlans(struct ofproto *, unsigned long *flood_vlans);
bool ofproto_is_mirror_output_bundle(struct ofproto *, void *aux);

/* Configuration querying. */
bool ofproto_has_snoops(const struct ofproto *);
void ofproto_get_snoops(const struct ofproto *, struct sset *);
void ofproto_get_all_flows(struct ofproto *p, struct ds *);
void ofproto_get_netflow_ids(const struct ofproto *,
                             uint8_t *engine_type, uint8_t *engine_id);
int ofproto_port_get_cfm_fault(const struct ofproto *, uint16_t ofp_port);
int ofproto_port_get_cfm_remote_mpids(const struct ofproto *,
                                      uint16_t ofp_port, const uint64_t **rmps,
                                      size_t *n_rmps);

void ofproto_get_ofproto_controller_info(const struct ofproto *, struct shash *);
void ofproto_free_ofproto_controller_info(struct shash *);

#ifdef  __cplusplus
}
#endif

#endif /* ofproto.h */
Commit	Line	Data
064af421	1	/*
195c8086	2	* Copyright (c) 2009, 2010, 2011 Nicira Networks.
064af421	3	*
a14bc59f BP	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at:
064af421	7	*
a14bc59f BP	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
064af421 BP	15	*/
	16
	17	#ifndef OFPROTO_H
	18	#define OFPROTO_H 1
	19
d2ede7bc BP	20	#include <sys/types.h>
d2ede7bc BP	21	#include <netinet/in.h>
064af421 BP	22	#include <stdbool.h>
	23	#include <stddef.h>
	24	#include <stdint.h>
1de11730	25	#include "cfm.h"
064af421	26	#include "flow.h"
0193b2af	27	#include "netflow.h"
81e2083f	28	#include "sset.h"
064af421 BP	29	#include "tag.h"
064af421 BP	30
03292c46 JG	31	#ifdef __cplusplus
	32	extern "C" {
	33	#endif
	34
a5610457	35	struct cfm_settings;
cf3fad8a	36	struct cls_rule;
b5827b24	37	struct netdev;
064af421	38	struct ofproto;
bffc0589	39	struct shash;
064af421	40
bffc0589 AE	41	struct ofproto_controller_info {
	42	bool is_connected;
	43	enum nx_role role;
	44	struct {
2cdcb898 AE	45	const char *keys[4];
2cdcb898 AE	46	const char *values[4];
bffc0589 AE	47	size_t n;
	48	} pairs;
	49	};
	50
064af421	51	struct ofexpired {
ae412e7d	52	struct flow flow;
0193b2af JG	53	uint64_t packet_count; /* Packets from subrules. */
0193b2af JG	54	uint64_t byte_count; /* Bytes from subrules. */
064af421	55	long long int used; /* Last-used time (0 if never used). */
064af421 BP	56	};
064af421 BP	57
72b06300	58	struct ofproto_sflow_options {
81e2083f	59	struct sset targets;
72b06300 BP	60	uint32_t sampling_rate;
	61	uint32_t polling_interval;
	62	uint32_t header_len;
	63	uint32_t sub_id;
	64	char *agent_device;
	65	char *control_ip;
	66	};
	67
79c9f2ee BP	68	/* How the switch should act if the controller cannot be contacted. */
	69	enum ofproto_fail_mode {
	70	OFPROTO_FAIL_SECURE, /* Preserve flow table. */
	71	OFPROTO_FAIL_STANDALONE /* Act as a standalone switch. */
	72	};
	73
	74	enum ofproto_band {
	75	OFPROTO_IN_BAND, /* In-band connection to controller. */
	76	OFPROTO_OUT_OF_BAND /* Out-of-band connection to controller. */
	77	};
	78
	79	struct ofproto_controller {
	80	char target; / e.g. "tcp:127.0.0.1" */
	81	int max_backoff; /* Maximum reconnection backoff, in seconds. */
	82	int probe_interval; /* Max idle time before probing, in seconds. */
79c9f2ee BP	83	enum ofproto_band band; /* In-band or out-of-band? */
79c9f2ee BP	84
79c9f2ee BP	85	/* OpenFlow packet-in rate-limiting. */
	86	int rate_limit; /* Max packet-in rate in packets per second. */
	87	int burst_limit; /* Limit on accumulating packet credits. */
	88	};
	89
23ff2821 JP	90	#define DEFAULT_MFR_DESC "Nicira Networks, Inc."
	91	#define DEFAULT_HW_DESC "Open vSwitch"
	92	#define DEFAULT_SW_DESC VERSION BUILDNR
	93	#define DEFAULT_SERIAL_DESC "None"
	94	#define DEFAULT_DP_DESC "None"
	95
f79e673f BP	96	void ofproto_enumerate_types(struct sset *types);
	97	const char ofproto_normalize_type(const char );
	98
	99	int ofproto_enumerate_names(const char type, struct sset names);
63d347ce BP	100	void ofproto_parse_name(const char name, char dp_name, char *dp_type);
63d347ce BP	101
1a6f1e2a	102	int ofproto_create(const char datapath, const char datapath_type,
064af421 BP	103	struct ofproto **ofprotop);
064af421 BP	104	void ofproto_destroy(struct ofproto *);
f79e673f BP	105	int ofproto_delete(const char name, const char type);
f79e673f BP	106
064af421	107	int ofproto_run(struct ofproto *);
064af421 BP	108	void ofproto_wait(struct ofproto *);
	109	bool ofproto_is_alive(const struct ofproto *);
	110
b5827b24 BP	111	/* A port within an OpenFlow switch.
	112	*
	113	* 'name' and 'type' are suitable for passing to netdev_open(). */
	114	struct ofproto_port {
	115	char name; / Network device name, e.g. "eth0". */
	116	char type; / Network device type, e.g. "system". */
	117	uint16_t ofp_port; /* OpenFlow port number. */
	118	};
	119	void ofproto_port_clone(struct ofproto_port , const struct ofproto_port );
	120	void ofproto_port_destroy(struct ofproto_port *);
	121
	122	struct ofproto_port_dump {
	123	const struct ofproto *ofproto;
	124	int error;
	125	void *state;
	126	};
	127	void ofproto_port_dump_start(struct ofproto_port_dump *,
	128	const struct ofproto *);
	129	bool ofproto_port_dump_next(struct ofproto_port_dump , struct ofproto_port );
	130	int ofproto_port_dump_done(struct ofproto_port_dump *);
	131
892815f5	132	/* Iterates through each OFPROTO_PORT in OFPROTO, using DUMP as state.
b5827b24 BP	133	*
	134	* Arguments all have pointer type.
	135	*
	136	* If you break out of the loop, then you need to free the dump structure by
	137	* hand using ofproto_port_dump_done(). */
	138	#define OFPROTO_PORT_FOR_EACH(OFPROTO_PORT, DUMP, OFPROTO) \
	139	for (ofproto_port_dump_start(DUMP, OFPROTO); \
	140	(ofproto_port_dump_next(DUMP, OFPROTO_PORT) \
	141	? true \
	142	: (ofproto_port_dump_done(DUMP), false)); \
	143	)
	144
084f5290 SH	145	#define OFPROTO_FLOW_EVICTON_THRESHOLD_DEFAULT 1000
	146	#define OFPROTO_FLOW_EVICTION_THRESHOLD_MIN 100
	147
b5827b24 BP	148	int ofproto_port_add(struct ofproto , struct netdev , uint16_t *ofp_portp);
b5827b24 BP	149	int ofproto_port_del(struct ofproto *, uint16_t ofp_port);
3a6ccc8c	150
b5827b24 BP	151	int ofproto_port_query_by_name(const struct ofproto , const char devname,
	152	struct ofproto_port *);
	153
e7934396	154	/* Top-level configuration. */
064af421	155	void ofproto_set_datapath_id(struct ofproto *, uint64_t datapath_id);
76ce9432 BP	156	void ofproto_set_controllers(struct ofproto *,
76ce9432 BP	157	const struct ofproto_controller *, size_t n);
31681a5d	158	void ofproto_set_fail_mode(struct ofproto *, enum ofproto_fail_mode fail_mode);
fa05809b	159	void ofproto_reconnect_controllers(struct ofproto *);
917e50e1 BP	160	void ofproto_set_extra_in_band_remotes(struct ofproto *,
917e50e1 BP	161	const struct sockaddr_in *, size_t n);
b1da6250	162	void ofproto_set_in_band_queue(struct ofproto *, int queue_id);
084f5290	163	void ofproto_set_flow_eviction_threshold(struct ofproto *, unsigned threshold);
8402c74b	164	void ofproto_set_forward_bpdu(struct ofproto *, bool forward_bpdu);
064af421	165	void ofproto_set_desc(struct ofproto *,
5a719c38 JP	166	const char mfr_desc, const char hw_desc,
5a719c38 JP	167	const char sw_desc, const char serial_desc,
8abc4ed7	168	const char *dp_desc);
81e2083f	169	int ofproto_set_snoops(struct ofproto , const struct sset snoops);
0193b2af JG	170	int ofproto_set_netflow(struct ofproto *,
0193b2af JG	171	const struct netflow_options *nf_options);
abe529af	172	int ofproto_set_sflow(struct ofproto , const struct ofproto_sflow_options );
064af421	173
fa066f01 BP	174	/* Configuration of ports. */
fa066f01 BP	175
892815f5	176	void ofproto_port_unregister(struct ofproto *, uint16_t ofp_port);
fa066f01	177
892815f5 BP	178	void ofproto_port_clear_cfm(struct ofproto *, uint16_t ofp_port);
892815f5 BP	179	void ofproto_port_set_cfm(struct ofproto *, uint16_t ofp_port,
a5610457	180	const struct cfm_settings *);
fa066f01 BP	181	int ofproto_port_is_lacp_current(struct ofproto *, uint16_t ofp_port);
fa066f01 BP	182
ecac4ebf BP	183	/* The behaviour of the port regarding VLAN handling */
	184	enum port_vlan_mode {
	185	/* This port is an access port. 'vlan' is the VLAN ID. 'trunks' is
	186	* ignored. */
	187	PORT_VLAN_ACCESS,
	188
	189	/* This port is a trunk. 'trunks' is the set of trunks. 'vlan' is
	190	* ignored. */
	191	PORT_VLAN_TRUNK,
	192
	193	/* Untagged incoming packets are part of 'vlan', as are incoming packets
	194	* tagged with 'vlan'. Outgoing packets tagged with 'vlan' stay tagged.
	195	* Other VLANs in 'trunks' are trunked. */
	196	PORT_VLAN_NATIVE_TAGGED,
	197
	198	/* Untagged incoming packets are part of 'vlan', as are incoming packets
	199	* tagged with 'vlan'. Outgoing packets tagged with 'vlan' are untagged.
	200	* Other VLANs in 'trunks' are trunked. */
	201	PORT_VLAN_NATIVE_UNTAGGED
	202	};
	203
fa066f01 BP	204	/* Configuration of bundles. */
	205	struct ofproto_bundle_settings {
	206	char name; / For use in log messages. */
	207
892815f5	208	uint16_t slaves; / OpenFlow port numbers for slaves. */
fa066f01 BP	209	size_t n_slaves;
fa066f01 BP	210
ecac4ebf BP	211	enum port_vlan_mode vlan_mode; /* Selects mode for vlan and trunks */
	212	int vlan; /* VLAN VID, except for PORT_VLAN_TRUNK. */
	213	unsigned long trunks; / vlan_bitmap, except for PORT_VLAN_ACCESS. */
fa066f01 BP	214
fa066f01 BP	215	struct bond_settings bond; / Must be nonnull iff if n_slaves > 1. */
00794817	216	uint32_t bond_stable_ids; / Array of n_slaves elements. */
fa066f01 BP	217
	218	struct lacp_settings lacp; / Nonnull to enable LACP. */
	219	struct lacp_slave_settings lacp_slaves; / Array of n_slaves elements. */
	220	};
	221
abe529af BP	222	int ofproto_bundle_register(struct ofproto , void aux,
	223	const struct ofproto_bundle_settings *);
	224	int ofproto_bundle_unregister(struct ofproto , void aux);
fa066f01 BP	225
	226	/* Configuration of mirrors. */
	227	struct ofproto_mirror_settings {
	228	/* Name for log messages. */
	229	char *name;
	230
	231	/* Bundles that select packets for mirroring upon ingress. */
	232	void *srcs; / A set of registered ofbundle handles. */
	233	size_t n_srcs;
	234
	235	/* Bundles that select packets for mirroring upon egress. */
	236	void *dsts; / A set of registered ofbundle handles. */
	237	size_t n_dsts;
	238
	239	/* VLANs of packets to select for mirroring. */
	240	unsigned long src_vlans; / vlan_bitmap, NULL selects all VLANs. */
	241
	242	/* Output (mutually exclusive). */
	243	void out_bundle; / A registered ofbundle handle or NULL. */
	244	uint16_t out_vlan; /* Output VLAN, only if out_bundle is NULL. */
	245	};
	246
abe529af BP	247	int ofproto_mirror_register(struct ofproto , void aux,
	248	const struct ofproto_mirror_settings *);
	249	int ofproto_mirror_unregister(struct ofproto , void aux);
fa066f01	250
abe529af	251	int ofproto_set_flood_vlans(struct ofproto , unsigned long flood_vlans);
fa066f01	252	bool ofproto_is_mirror_output_bundle(struct ofproto , void aux);
e7934396	253
064af421	254	/* Configuration querying. */
81e2083f BP	255	bool ofproto_has_snoops(const struct ofproto *);
81e2083f BP	256	void ofproto_get_snoops(const struct ofproto , struct sset );
4f2cad2c	257	void ofproto_get_all_flows(struct ofproto p, struct ds );
b5827b24 BP	258	void ofproto_get_netflow_ids(const struct ofproto *,
b5827b24 BP	259	uint8_t engine_type, uint8_t engine_id);
a5610457	260	int ofproto_port_get_cfm_fault(const struct ofproto *, uint16_t ofp_port);
1de11730 EJ	261	int ofproto_port_get_cfm_remote_mpids(const struct ofproto *,
	262	uint16_t ofp_port, const uint64_t **rmps,
	263	size_t *n_rmps);
064af421	264
bffc0589 AE	265	void ofproto_get_ofproto_controller_info(const struct ofproto , struct shash );
	266	void ofproto_free_ofproto_controller_info(struct shash *);
	267
03292c46 JG	268	#ifdef __cplusplus
	269	}
	270	#endif
	271
064af421	272	#endif /* ofproto.h */