[mirror_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 "stp.h"
#include "tag.h"

#ifdef  __cplusplus
extern "C" {
#endif

struct cfm_settings;
struct cls_rule;
struct netdev;
struct ofproto;
struct ofport;
struct shash;
struct netdev_stats;

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;
};

struct ofproto_stp_settings {
    stp_identifier system_id;
    uint16_t priority;
    uint16_t hello_time;
    uint16_t max_age;
    uint16_t fwd_delay;
};

struct ofproto_stp_status {
    bool enabled;               /* If false, ignore other members. */
    stp_identifier bridge_id;
    stp_identifier designated_root;
    int root_path_cost;
};

struct ofproto_port_stp_settings {
    bool enable;
    uint8_t port_num;           /* In the range 1-255, inclusive. */
    uint8_t priority;
    uint16_t path_cost;
};

struct ofproto_port_stp_status {
    bool enabled;               /* If false, ignore other members. */
    int port_id;
    enum stp_state state;
    unsigned int sec_in_state;
    enum stp_role role;
    int tx_count;               /* Number of BPDUs transmitted. */
    int rx_count;               /* Number of valid BPDUs received. */
    int error_count;            /* Number of bad BPDUs received. */
};

struct ofproto_port_queue {
    uint32_t queue;             /* Queue ID. */
    uint8_t dscp;               /* DSCP bits (e.g. [0, 63]). */
};

/* 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 *);
int ofproto_run_fast(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_get_stats(const struct ofport *, struct netdev_stats *stats);

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 *);
int ofproto_set_stp(struct ofproto *, const struct ofproto_stp_settings *);
int ofproto_get_stp_status(struct ofproto *, struct ofproto_stp_status *);

/* 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);
int ofproto_port_set_stp(struct ofproto *, uint16_t ofp_port,
                         const struct ofproto_port_stp_settings *);
int ofproto_port_get_stp_status(struct ofproto *, uint16_t ofp_port,
                                struct ofproto_port_stp_status *);
int ofproto_port_set_queues(struct ofproto *, uint16_t ofp_port,
                            const struct ofproto_port_queue *,
                            size_t n_queues);

/* 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. */
    bool use_priority_tags;     /* Use 802.1p tag for frames in VLAN 0? */

    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. */

    /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
     *
     * This is deprecated.  It is only for compatibility with broken device
     * drivers in old versions of Linux that do not properly support VLANs when
     * VLAN devices are not used.  When broken device drivers are no longer in
     * widespread use, we will delete these interfaces. */
    uint16_t realdev_ofp_port;  /* OpenFlow port number of real device. */
};

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_mirror_get_stats(struct ofproto *, void *aux,
                             uint64_t *packets, uint64_t *bytes);

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

/* Configuration of OpenFlow tables. */
struct ofproto_table_settings {
    char *name;                 /* Name exported via OpenFlow or NULL. */
    unsigned int max_flows;     /* Maximum number of flows or UINT_MAX. */

    /* These members determine the handling of an attempt to add a flow that
     * would cause the table to have more than 'max_flows' flows.
     *
     * If 'groups' is NULL, overflows will be rejected with an error.
     *
     * If 'groups' is nonnull, an overflow will cause a flow to be removed.
     * The flow to be removed is chosen to give fairness among groups
     * distinguished by different values for the subfields within 'groups'. */
    struct mf_subfield *groups;
    size_t n_groups;
};

int ofproto_get_n_tables(const struct ofproto *);
void ofproto_configure_table(struct ofproto *, int table_id,
                             const struct ofproto_table_settings *);

/* 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 *);
\f
/* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
 *
 * This is deprecated.  It is only for compatibility with broken device drivers
 * in old versions of Linux that do not properly support VLANs when VLAN
 * devices are not used.  When broken device drivers are no longer in
 * widespread use, we will delete these interfaces. */

void ofproto_get_vlan_usage(struct ofproto *, unsigned long int *vlan_bitmap);
bool ofproto_has_vlan_usage_changed(const struct ofproto *);
int ofproto_port_set_realdev(struct ofproto *, uint16_t vlandev_ofp_port,
                             uint16_t realdev_ofp_port, int vid);

#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"
21f7563c	29	#include "stp.h"
064af421 BP	30	#include "tag.h"
064af421 BP	31
03292c46 JG	32	#ifdef __cplusplus
	33	extern "C" {
	34	#endif
	35
a5610457	36	struct cfm_settings;
cf3fad8a	37	struct cls_rule;
b5827b24	38	struct netdev;
064af421	39	struct ofproto;
6527c598	40	struct ofport;
bffc0589	41	struct shash;
6527c598	42	struct netdev_stats;
064af421	43
bffc0589 AE	44	struct ofproto_controller_info {
	45	bool is_connected;
	46	enum nx_role role;
	47	struct {
2cdcb898 AE	48	const char *keys[4];
2cdcb898 AE	49	const char *values[4];
bffc0589 AE	50	size_t n;
	51	} pairs;
	52	};
	53
064af421	54	struct ofexpired {
ae412e7d	55	struct flow flow;
0193b2af JG	56	uint64_t packet_count; /* Packets from subrules. */
0193b2af JG	57	uint64_t byte_count; /* Bytes from subrules. */
064af421	58	long long int used; /* Last-used time (0 if never used). */
064af421 BP	59	};
064af421 BP	60
72b06300	61	struct ofproto_sflow_options {
81e2083f	62	struct sset targets;
72b06300 BP	63	uint32_t sampling_rate;
	64	uint32_t polling_interval;
	65	uint32_t header_len;
	66	uint32_t sub_id;
	67	char *agent_device;
	68	char *control_ip;
	69	};
	70
21f7563c JP	71	struct ofproto_stp_settings {
	72	stp_identifier system_id;
	73	uint16_t priority;
	74	uint16_t hello_time;
	75	uint16_t max_age;
	76	uint16_t fwd_delay;
	77	};
	78
	79	struct ofproto_stp_status {
	80	bool enabled; /* If false, ignore other members. */
	81	stp_identifier bridge_id;
	82	stp_identifier designated_root;
	83	int root_path_cost;
	84	};
	85
	86	struct ofproto_port_stp_settings {
	87	bool enable;
	88	uint8_t port_num; /* In the range 1-255, inclusive. */
	89	uint8_t priority;
	90	uint16_t path_cost;
	91	};
	92
	93	struct ofproto_port_stp_status {
	94	bool enabled; /* If false, ignore other members. */
	95	int port_id;
	96	enum stp_state state;
	97	unsigned int sec_in_state;
	98	enum stp_role role;
80740385 JP	99	int tx_count; /* Number of BPDUs transmitted. */
	100	int rx_count; /* Number of valid BPDUs received. */
	101	int error_count; /* Number of bad BPDUs received. */
21f7563c JP	102	};
21f7563c JP	103
8b36f51e EJ	104	struct ofproto_port_queue {
	105	uint32_t queue; /* Queue ID. */
	106	uint8_t dscp; /* DSCP bits (e.g. [0, 63]). */
	107	};
	108
79c9f2ee BP	109	/* How the switch should act if the controller cannot be contacted. */
	110	enum ofproto_fail_mode {
	111	OFPROTO_FAIL_SECURE, /* Preserve flow table. */
	112	OFPROTO_FAIL_STANDALONE /* Act as a standalone switch. */
	113	};
	114
	115	enum ofproto_band {
	116	OFPROTO_IN_BAND, /* In-band connection to controller. */
	117	OFPROTO_OUT_OF_BAND /* Out-of-band connection to controller. */
	118	};
	119
	120	struct ofproto_controller {
	121	char target; / e.g. "tcp:127.0.0.1" */
	122	int max_backoff; /* Maximum reconnection backoff, in seconds. */
	123	int probe_interval; /* Max idle time before probing, in seconds. */
79c9f2ee BP	124	enum ofproto_band band; /* In-band or out-of-band? */
79c9f2ee BP	125
79c9f2ee BP	126	/* OpenFlow packet-in rate-limiting. */
	127	int rate_limit; /* Max packet-in rate in packets per second. */
	128	int burst_limit; /* Limit on accumulating packet credits. */
	129	};
	130
23ff2821 JP	131	#define DEFAULT_MFR_DESC "Nicira Networks, Inc."
	132	#define DEFAULT_HW_DESC "Open vSwitch"
	133	#define DEFAULT_SW_DESC VERSION BUILDNR
	134	#define DEFAULT_SERIAL_DESC "None"
	135	#define DEFAULT_DP_DESC "None"
	136
f79e673f BP	137	void ofproto_enumerate_types(struct sset *types);
	138	const char ofproto_normalize_type(const char );
	139
	140	int ofproto_enumerate_names(const char type, struct sset names);
63d347ce BP	141	void ofproto_parse_name(const char name, char dp_name, char *dp_type);
63d347ce BP	142
1a6f1e2a	143	int ofproto_create(const char datapath, const char datapath_type,
064af421 BP	144	struct ofproto **ofprotop);
064af421 BP	145	void ofproto_destroy(struct ofproto *);
f79e673f BP	146	int ofproto_delete(const char name, const char type);
f79e673f BP	147
064af421	148	int ofproto_run(struct ofproto *);
5fcc0d00	149	int ofproto_run_fast(struct ofproto *);
064af421 BP	150	void ofproto_wait(struct ofproto *);
	151	bool ofproto_is_alive(const struct ofproto *);
	152
b5827b24 BP	153	/* A port within an OpenFlow switch.
	154	*
	155	* 'name' and 'type' are suitable for passing to netdev_open(). */
	156	struct ofproto_port {
	157	char name; / Network device name, e.g. "eth0". */
	158	char type; / Network device type, e.g. "system". */
	159	uint16_t ofp_port; /* OpenFlow port number. */
	160	};
	161	void ofproto_port_clone(struct ofproto_port , const struct ofproto_port );
	162	void ofproto_port_destroy(struct ofproto_port *);
	163
	164	struct ofproto_port_dump {
	165	const struct ofproto *ofproto;
	166	int error;
	167	void *state;
	168	};
	169	void ofproto_port_dump_start(struct ofproto_port_dump *,
	170	const struct ofproto *);
	171	bool ofproto_port_dump_next(struct ofproto_port_dump , struct ofproto_port );
	172	int ofproto_port_dump_done(struct ofproto_port_dump *);
	173
892815f5	174	/* Iterates through each OFPROTO_PORT in OFPROTO, using DUMP as state.
b5827b24 BP	175	*
	176	* Arguments all have pointer type.
	177	*
	178	* If you break out of the loop, then you need to free the dump structure by
	179	* hand using ofproto_port_dump_done(). */
	180	#define OFPROTO_PORT_FOR_EACH(OFPROTO_PORT, DUMP, OFPROTO) \
	181	for (ofproto_port_dump_start(DUMP, OFPROTO); \
	182	(ofproto_port_dump_next(DUMP, OFPROTO_PORT) \
	183	? true \
	184	: (ofproto_port_dump_done(DUMP), false)); \
	185	)
	186
084f5290 SH	187	#define OFPROTO_FLOW_EVICTON_THRESHOLD_DEFAULT 1000
	188	#define OFPROTO_FLOW_EVICTION_THRESHOLD_MIN 100
	189
b5827b24 BP	190	int ofproto_port_add(struct ofproto , struct netdev , uint16_t *ofp_portp);
b5827b24 BP	191	int ofproto_port_del(struct ofproto *, uint16_t ofp_port);
6527c598	192	int ofproto_port_get_stats(const struct ofport , struct netdev_stats stats);
3a6ccc8c	193
b5827b24 BP	194	int ofproto_port_query_by_name(const struct ofproto , const char devname,
	195	struct ofproto_port *);
	196
e7934396	197	/* Top-level configuration. */
064af421	198	void ofproto_set_datapath_id(struct ofproto *, uint64_t datapath_id);
76ce9432 BP	199	void ofproto_set_controllers(struct ofproto *,
76ce9432 BP	200	const struct ofproto_controller *, size_t n);
31681a5d	201	void ofproto_set_fail_mode(struct ofproto *, enum ofproto_fail_mode fail_mode);
fa05809b	202	void ofproto_reconnect_controllers(struct ofproto *);
917e50e1 BP	203	void ofproto_set_extra_in_band_remotes(struct ofproto *,
917e50e1 BP	204	const struct sockaddr_in *, size_t n);
b1da6250	205	void ofproto_set_in_band_queue(struct ofproto *, int queue_id);
084f5290	206	void ofproto_set_flow_eviction_threshold(struct ofproto *, unsigned threshold);
8402c74b	207	void ofproto_set_forward_bpdu(struct ofproto *, bool forward_bpdu);
064af421	208	void ofproto_set_desc(struct ofproto *,
5a719c38 JP	209	const char mfr_desc, const char hw_desc,
5a719c38 JP	210	const char sw_desc, const char serial_desc,
8abc4ed7	211	const char *dp_desc);
81e2083f	212	int ofproto_set_snoops(struct ofproto , const struct sset snoops);
0193b2af JG	213	int ofproto_set_netflow(struct ofproto *,
0193b2af JG	214	const struct netflow_options *nf_options);
abe529af	215	int ofproto_set_sflow(struct ofproto , const struct ofproto_sflow_options );
21f7563c JP	216	int ofproto_set_stp(struct ofproto , const struct ofproto_stp_settings );
21f7563c JP	217	int ofproto_get_stp_status(struct ofproto , struct ofproto_stp_status );
064af421	218
fa066f01	219	/* Configuration of ports. */
892815f5	220	void ofproto_port_unregister(struct ofproto *, uint16_t ofp_port);
fa066f01	221
892815f5 BP	222	void ofproto_port_clear_cfm(struct ofproto *, uint16_t ofp_port);
892815f5 BP	223	void ofproto_port_set_cfm(struct ofproto *, uint16_t ofp_port,
a5610457	224	const struct cfm_settings *);
fa066f01	225	int ofproto_port_is_lacp_current(struct ofproto *, uint16_t ofp_port);
21f7563c JP	226	int ofproto_port_set_stp(struct ofproto *, uint16_t ofp_port,
	227	const struct ofproto_port_stp_settings *);
	228	int ofproto_port_get_stp_status(struct ofproto *, uint16_t ofp_port,
	229	struct ofproto_port_stp_status *);
8b36f51e EJ	230	int ofproto_port_set_queues(struct ofproto *, uint16_t ofp_port,
	231	const struct ofproto_port_queue *,
	232	size_t n_queues);
fa066f01	233
ecac4ebf BP	234	/* The behaviour of the port regarding VLAN handling */
	235	enum port_vlan_mode {
	236	/* This port is an access port. 'vlan' is the VLAN ID. 'trunks' is
	237	* ignored. */
	238	PORT_VLAN_ACCESS,
	239
	240	/* This port is a trunk. 'trunks' is the set of trunks. 'vlan' is
	241	* ignored. */
	242	PORT_VLAN_TRUNK,
	243
	244	/* Untagged incoming packets are part of 'vlan', as are incoming packets
	245	* tagged with 'vlan'. Outgoing packets tagged with 'vlan' stay tagged.
	246	* Other VLANs in 'trunks' are trunked. */
	247	PORT_VLAN_NATIVE_TAGGED,
	248
	249	/* Untagged incoming packets are part of 'vlan', as are incoming packets
	250	* tagged with 'vlan'. Outgoing packets tagged with 'vlan' are untagged.
	251	* Other VLANs in 'trunks' are trunked. */
	252	PORT_VLAN_NATIVE_UNTAGGED
	253	};
	254
fa066f01 BP	255	/* Configuration of bundles. */
	256	struct ofproto_bundle_settings {
	257	char name; / For use in log messages. */
	258
892815f5	259	uint16_t slaves; / OpenFlow port numbers for slaves. */
fa066f01 BP	260	size_t n_slaves;
fa066f01 BP	261
ecac4ebf BP	262	enum port_vlan_mode vlan_mode; /* Selects mode for vlan and trunks */
	263	int vlan; /* VLAN VID, except for PORT_VLAN_TRUNK. */
	264	unsigned long trunks; / vlan_bitmap, except for PORT_VLAN_ACCESS. */
5e9ceccd	265	bool use_priority_tags; /* Use 802.1p tag for frames in VLAN 0? */
fa066f01 BP	266
fa066f01 BP	267	struct bond_settings bond; / Must be nonnull iff if n_slaves > 1. */
00794817	268	uint32_t bond_stable_ids; / Array of n_slaves elements. */
fa066f01 BP	269
	270	struct lacp_settings lacp; / Nonnull to enable LACP. */
	271	struct lacp_slave_settings lacp_slaves; / Array of n_slaves elements. */
52a90c29 BP	272
	273	/* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
	274	*
	275	* This is deprecated. It is only for compatibility with broken device
	276	* drivers in old versions of Linux that do not properly support VLANs when
	277	* VLAN devices are not used. When broken device drivers are no longer in
	278	* widespread use, we will delete these interfaces. */
	279	uint16_t realdev_ofp_port; /* OpenFlow port number of real device. */
fa066f01 BP	280	};
fa066f01 BP	281
abe529af BP	282	int ofproto_bundle_register(struct ofproto , void aux,
	283	const struct ofproto_bundle_settings *);
	284	int ofproto_bundle_unregister(struct ofproto , void aux);
fa066f01 BP	285
	286	/* Configuration of mirrors. */
	287	struct ofproto_mirror_settings {
	288	/* Name for log messages. */
	289	char *name;
	290
	291	/* Bundles that select packets for mirroring upon ingress. */
	292	void *srcs; / A set of registered ofbundle handles. */
	293	size_t n_srcs;
	294
	295	/* Bundles that select packets for mirroring upon egress. */
	296	void *dsts; / A set of registered ofbundle handles. */
	297	size_t n_dsts;
	298
	299	/* VLANs of packets to select for mirroring. */
	300	unsigned long src_vlans; / vlan_bitmap, NULL selects all VLANs. */
	301
	302	/* Output (mutually exclusive). */
	303	void out_bundle; / A registered ofbundle handle or NULL. */
	304	uint16_t out_vlan; /* Output VLAN, only if out_bundle is NULL. */
	305	};
	306
abe529af BP	307	int ofproto_mirror_register(struct ofproto , void aux,
	308	const struct ofproto_mirror_settings *);
	309	int ofproto_mirror_unregister(struct ofproto , void aux);
9d24de3b JP	310	int ofproto_mirror_get_stats(struct ofproto , void aux,
9d24de3b JP	311	uint64_t packets, uint64_t bytes);
fa066f01	312
abe529af	313	int ofproto_set_flood_vlans(struct ofproto , unsigned long flood_vlans);
b4affc74	314	bool ofproto_is_mirror_output_bundle(const struct ofproto , void aux);
e7934396	315
254750ce BP	316	/* Configuration of OpenFlow tables. */
	317	struct ofproto_table_settings {
	318	char name; / Name exported via OpenFlow or NULL. */
	319	unsigned int max_flows; /* Maximum number of flows or UINT_MAX. */
	320
	321	/* These members determine the handling of an attempt to add a flow that
	322	* would cause the table to have more than 'max_flows' flows.
	323	*
	324	* If 'groups' is NULL, overflows will be rejected with an error.
	325	*
	326	* If 'groups' is nonnull, an overflow will cause a flow to be removed.
	327	* The flow to be removed is chosen to give fairness among groups
	328	* distinguished by different values for the subfields within 'groups'. */
	329	struct mf_subfield *groups;
	330	size_t n_groups;
	331	};
	332
	333	int ofproto_get_n_tables(const struct ofproto *);
	334	void ofproto_configure_table(struct ofproto *, int table_id,
	335	const struct ofproto_table_settings *);
	336
064af421	337	/* Configuration querying. */
81e2083f BP	338	bool ofproto_has_snoops(const struct ofproto *);
81e2083f BP	339	void ofproto_get_snoops(const struct ofproto , struct sset );
4f2cad2c	340	void ofproto_get_all_flows(struct ofproto p, struct ds );
b5827b24 BP	341	void ofproto_get_netflow_ids(const struct ofproto *,
b5827b24 BP	342	uint8_t engine_type, uint8_t engine_id);
a5610457	343	int ofproto_port_get_cfm_fault(const struct ofproto *, uint16_t ofp_port);
1de11730 EJ	344	int ofproto_port_get_cfm_remote_mpids(const struct ofproto *,
	345	uint16_t ofp_port, const uint64_t **rmps,
	346	size_t *n_rmps);
064af421	347
bffc0589 AE	348	void ofproto_get_ofproto_controller_info(const struct ofproto , struct shash );
bffc0589 AE	349	void ofproto_free_ofproto_controller_info(struct shash *);
52a90c29 BP	350	\f
	351	/* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
	352	*
	353	* This is deprecated. It is only for compatibility with broken device drivers
	354	* in old versions of Linux that do not properly support VLANs when VLAN
	355	* devices are not used. When broken device drivers are no longer in
	356	* widespread use, we will delete these interfaces. */
	357
	358	void ofproto_get_vlan_usage(struct ofproto , unsigned long int vlan_bitmap);
	359	bool ofproto_has_vlan_usage_changed(const struct ofproto *);
	360	int ofproto_port_set_realdev(struct ofproto *, uint16_t vlandev_ofp_port,
	361	uint16_t realdev_ofp_port, int vid);
bffc0589	362
03292c46 JG	363	#ifdef __cplusplus
	364	}
	365	#endif
	366
064af421	367	#endif /* ofproto.h */