/*
- * Copyright (c) 2012, 2013, 2014 Nicira, Inc.
+ * Copyright (c) 2012, 2013, 2014, 2015, 2016 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "openflow/nicira-ext.h"
#include "openflow/openflow.h"
#include "ovs-thread.h"
-#include "vlog.h"
+#include "openvswitch/vlog.h"
VLOG_DEFINE_THIS_MODULE(ofp_msgs);
#define OFPT11_STATS_REPLY 19
#define OFPST_VENDOR 0xffff
+/* Vendor extension message. */
+struct ofp_vendor_header {
+ struct ofp_header header; /* OFPT_VENDOR. */
+ ovs_be32 vendor; /* Vendor ID:
+ * - MSB 0: low-order bytes are IEEE OUI.
+ * - MSB != 0: defined by OpenFlow
+ * consortium. */
+
+ /* In theory everything after 'vendor' is vendor specific. In practice,
+ * the vendors we support put a 32-bit subtype here. We'll change this
+ * structure if we start adding support for other vendor formats. */
+ ovs_be32 subtype; /* Vendor-specific subtype. */
+
+ /* Followed by vendor-defined additional data. */
+};
+OFP_ASSERT(sizeof(struct ofp_vendor_header) == 16);
+
+/* Statistics request or reply message. */
+struct ofp10_stats_msg {
+ struct ofp_header header;
+ ovs_be16 type; /* One of the OFPST_* constants. */
+ ovs_be16 flags; /* Requests: always 0.
+ * Replies: 0 or OFPSF_REPLY_MORE. */
+};
+OFP_ASSERT(sizeof(struct ofp10_stats_msg) == 12);
+
+/* Vendor extension stats message. */
+struct ofp10_vendor_stats_msg {
+ struct ofp10_stats_msg osm; /* Type OFPST_VENDOR. */
+ ovs_be32 vendor; /* Vendor ID:
+ * - MSB 0: low-order bytes are IEEE OUI.
+ * - MSB != 0: defined by OpenFlow
+ * consortium. */
+ /* Followed by vendor-defined arbitrary additional data. */
+};
+OFP_ASSERT(sizeof(struct ofp10_vendor_stats_msg) == 16);
+
+struct ofp11_stats_msg {
+ struct ofp_header header;
+ ovs_be16 type; /* One of the OFPST_* constants. */
+ ovs_be16 flags; /* OFPSF_REQ_* flags (none yet defined). */
+ uint8_t pad[4];
+ /* Followed by the body of the request. */
+};
+OFP_ASSERT(sizeof(struct ofp11_stats_msg) == 16);
+
+/* Vendor extension stats message. */
+struct ofp11_vendor_stats_msg {
+ struct ofp11_stats_msg osm; /* Type OFPST_VENDOR. */
+ ovs_be32 vendor; /* Vendor ID:
+ * - MSB 0: low-order bytes are IEEE OUI.
+ * - MSB != 0: defined by OpenFlow
+ * consortium. */
+
+ /* In theory everything after 'vendor' is vendor specific. In practice,
+ * the vendors we support put a 32-bit subtype here. We'll change this
+ * structure if we start adding support for other vendor formats. */
+ ovs_be32 subtype; /* Vendor-specific subtype. */
+
+ /* Followed by vendor-defined additional data. */
+};
+OFP_ASSERT(sizeof(struct ofp11_vendor_stats_msg) == 24);
+
+/* Header for Nicira vendor stats request and reply messages in OpenFlow
+ * 1.0. */
+struct nicira10_stats_msg {
+ struct ofp10_vendor_stats_msg vsm; /* Vendor NX_VENDOR_ID. */
+ ovs_be32 subtype; /* One of NXST_* below. */
+ uint8_t pad[4]; /* Align to 64-bits. */
+};
+OFP_ASSERT(sizeof(struct nicira10_stats_msg) == 24);
+
/* A thin abstraction of OpenFlow headers:
*
* - 'version' and 'type' come straight from struct ofp_header, so these are
static ovs_be32
alloc_xid(void)
{
- static atomic_uint32_t next_xid = ATOMIC_VAR_INIT(1);
- uint32_t xid;
+ static atomic_count next_xid = ATOMIC_COUNT_INIT(1);
- atomic_add(&next_xid, 1, &xid);
- return htonl(xid);
+ return htonl(atomic_count_inc(&next_xid));
}
\f
static uint32_t
ofphdrs_hash(const struct ofphdrs *hdrs)
{
- BUILD_ASSERT_DECL(sizeof *hdrs == 12);
- return hash_words((const uint32_t *) hdrs, 3, 0);
+ BUILD_ASSERT_DECL(sizeof *hdrs % 4 == 0);
+ return hash_bytes32((const uint32_t *) hdrs, sizeof *hdrs, 0);
}
static bool
ovh = (const struct ofp_vendor_header *) oh;
hdrs->vendor = ntohl(ovh->vendor);
- if (hdrs->vendor == NX_VENDOR_ID) {
- /* Get Nicira message subtype (NXT_*). */
- const struct nicira_header *nh;
-
- if (length < sizeof *nh) {
- return OFPERR_OFPBRC_BAD_LEN;
- }
- nh = (const struct nicira_header *) oh;
- hdrs->subtype = ntohl(nh->subtype);
+ if (hdrs->vendor == NX_VENDOR_ID || hdrs->vendor == ONF_VENDOR_ID) {
+ hdrs->subtype = ntohl(ovh->subtype);
} else {
log_bad_vendor(hdrs->vendor);
return OFPERR_OFPBRC_BAD_VENDOR;
ovsm = (const struct ofp11_vendor_stats_msg *) oh;
hdrs->vendor = ntohl(ovsm->vendor);
- if (hdrs->vendor == NX_VENDOR_ID) {
- /* Get Nicira statistic type (NXST_*). */
- const struct nicira11_stats_msg *nsm;
-
- if (length < sizeof *nsm) {
- return OFPERR_OFPBRC_BAD_LEN;
- }
- nsm = (const struct nicira11_stats_msg *) oh;
- hdrs->subtype = ntohl(nsm->subtype);
+ if (hdrs->vendor == NX_VENDOR_ID ||
+ hdrs->vendor == ONF_VENDOR_ID) {
+ hdrs->subtype = ntohl(ovsm->subtype);
} else {
log_bad_vendor(hdrs->vendor);
return OFPERR_OFPBRC_BAD_VENDOR;
ofphdrs_len(const struct ofphdrs *hdrs)
{
if (hdrs->type == OFPT_VENDOR) {
- return sizeof(struct nicira_header);
+ return sizeof(struct ofp_vendor_header);
}
switch ((enum ofp_version) hdrs->version) {
if (hdrs->type == OFPT11_STATS_REQUEST ||
hdrs->type == OFPT11_STATS_REPLY) {
return (hdrs->stat == OFPST_VENDOR
- ? sizeof(struct nicira11_stats_msg)
+ ? sizeof(struct ofp11_vendor_stats_msg)
: sizeof(struct ofp11_stats_msg));
}
break;
enum ofperr
ofpraw_decode(enum ofpraw *raw, const struct ofp_header *oh)
{
- struct ofpbuf msg;
-
- ofpbuf_use_const(&msg, oh, ntohs(oh->length));
+ struct ofpbuf msg = ofpbuf_const_initializer(oh, ntohs(oh->length));
return ofpraw_pull(raw, &msg);
}
}
/* Determines the OFPRAW_* type of the OpenFlow message in 'msg', which starts
- * at 'ofpbuf_data(msg)' and has length 'ofpbuf_size(msg)' bytes. On success,
+ * at 'msg->data' and has length 'msg->size' bytes. On success,
* returns 0 and stores the type into '*rawp'. On failure, returns an OFPERR_*
* error code and zeros '*rawp'.
*
*
* In addition to setting '*rawp', this function pulls off the OpenFlow header
* (including the stats headers, vendor header, and any subtype header) with
- * ofpbuf_pull(). It also sets 'msg->frame' to the start of the OpenFlow
- * header and 'msg->l3' just beyond the headers (that is, to the final value of
- * ofpbuf_data(msg)). */
+ * ofpbuf_pull(). It also sets 'msg->header' to the start of the OpenFlow
+ * header and 'msg->msg' just beyond the headers (that is, to the final value
+ * of msg->data). */
enum ofperr
ofpraw_pull(enum ofpraw *rawp, struct ofpbuf *msg)
{
enum ofpraw raw;
/* Set default outputs. */
- msg->frame = ofpbuf_data(msg);
- ofpbuf_set_l3(msg, msg->frame);
+ msg->header = msg->data;
+ msg->msg = msg->header;
*rawp = 0;
- len = ofpbuf_size(msg);
- error = ofphdrs_decode(&hdrs, ofpbuf_data(msg), len);
+ len = msg->size;
+ error = ofphdrs_decode(&hdrs, msg->data, len);
if (error) {
return error;
}
info = raw_info_get(raw);
instance = raw_instance_get(info, hdrs.version);
- msg->frame = ofpbuf_pull(msg, instance->hdrs_len);
- ofpbuf_set_l3(msg, ofpbuf_data(msg));
+ msg->header = ofpbuf_pull(msg, instance->hdrs_len);
+ msg->msg = msg->data;
min_len = instance->hdrs_len + info->min_body;
switch (info->extra_multiple) {
* Each 'raw' value is valid only for certain OpenFlow versions. The caller
* must specify a valid (raw, version) pair.
*
- * In the returned ofpbuf, 'frame' points to the beginning of the
- * OpenFlow header and 'l3' points just after it, to where the
+ * In the returned ofpbuf, 'header' points to the beginning of the
+ * OpenFlow header and 'msg' points just after it, to where the
* message's body will start. The caller must actually allocate the
* body into the space reserved for it, e.g. with ofpbuf_put_uninit().
*
* value. Every stats request has a corresponding reply, so the (raw, version)
* pairing pitfalls of the other ofpraw_alloc_*() functions don't apply here.
*
- * In the returned ofpbuf, 'frame' points to the beginning of the
- * OpenFlow header and 'l3' points just after it, to where the
+ * In the returned ofpbuf, 'header' points to the beginning of the
+ * OpenFlow header and 'msg' points just after it, to where the
* message's body will start. The caller must actually allocate the
* body into the space reserved for it, e.g. with ofpbuf_put_uninit().
*
* Each 'raw' value is valid only for certain OpenFlow versions. The caller
* must specify a valid (raw, version) pair.
*
- * Upon return, 'buf->frame' points to the beginning of the OpenFlow header and
- * 'buf->l3' points just after it, to where the message's body will start. The
- * caller must actually allocating the body into the space reserved for it,
+ * Upon return, 'buf->header' points to the beginning of the OpenFlow header
+ * and 'buf->msg' points just after it, to where the message's body will start.
+ * The caller must actually allocating the body into the space reserved for it,
* e.g. with ofpbuf_put_uninit(). */
void
ofpraw_put(enum ofpraw raw, uint8_t version, struct ofpbuf *buf)
* value. Every stats request has a corresponding reply, so the (raw, version)
* pairing pitfalls of the other ofpraw_alloc_*() functions don't apply here.
*
- * In the returned ofpbuf, 'frame' points to the beginning of the
- * OpenFlow header and 'l3' points just after it, to where the
+ * In the returned ofpbuf, 'header' points to the beginning of the
+ * OpenFlow header and 'msg' points just after it, to where the
* message's body will start. The caller must actually allocate the
* body into the space reserved for it, e.g. with ofpbuf_put_uninit().
*
ofpbuf_prealloc_tailroom(buf, (instance->hdrs_len + info->min_body
+ extra_tailroom));
- buf->frame = ofpbuf_put_uninit(buf, instance->hdrs_len);
- ofpbuf_set_l3(buf, ofpbuf_tail(buf));
+ buf->header = ofpbuf_put_uninit(buf, instance->hdrs_len);
+ buf->msg = ofpbuf_tail(buf);
- oh = buf->frame;
+ oh = buf->header;
oh->version = version;
oh->type = hdrs->type;
- oh->length = htons(ofpbuf_size(buf));
+ oh->length = htons(buf->size);
oh->xid = xid;
if (hdrs->type == OFPT_VENDOR) {
- struct nicira_header *nh = buf->frame;
+ struct ofp_vendor_header *ovh = buf->header;
- ovs_assert(hdrs->vendor == NX_VENDOR_ID);
- nh->vendor = htonl(hdrs->vendor);
- nh->subtype = htonl(hdrs->subtype);
+ ovh->vendor = htonl(hdrs->vendor);
+ ovh->subtype = htonl(hdrs->subtype);
} else if (version == OFP10_VERSION
&& (hdrs->type == OFPT10_STATS_REQUEST ||
hdrs->type == OFPT10_STATS_REPLY)) {
- struct ofp10_stats_msg *osm = buf->frame;
+ struct ofp10_stats_msg *osm = buf->header;
osm->type = htons(hdrs->stat);
osm->flags = htons(0);
if (hdrs->stat == OFPST_VENDOR) {
- struct ofp10_vendor_stats_msg *ovsm = buf->frame;
+ struct ofp10_vendor_stats_msg *ovsm = buf->header;
ovsm->vendor = htonl(hdrs->vendor);
if (hdrs->vendor == NX_VENDOR_ID) {
- struct nicira10_stats_msg *nsm = buf->frame;
+ struct nicira10_stats_msg *nsm = buf->header;
nsm->subtype = htonl(hdrs->subtype);
memset(nsm->pad, 0, sizeof nsm->pad);
} else if (version != OFP10_VERSION
&& (hdrs->type == OFPT11_STATS_REQUEST ||
hdrs->type == OFPT11_STATS_REPLY)) {
- struct ofp11_stats_msg *osm = buf->frame;
+ struct ofp11_stats_msg *osm = buf->header;
osm->type = htons(hdrs->stat);
osm->flags = htons(0);
memset(osm->pad, 0, sizeof osm->pad);
if (hdrs->stat == OFPST_VENDOR) {
- struct ofp11_vendor_stats_msg *ovsm = buf->frame;
+ struct ofp11_vendor_stats_msg *ovsm = buf->header;
ovsm->vendor = htonl(hdrs->vendor);
- if (hdrs->vendor == NX_VENDOR_ID) {
- struct nicira11_stats_msg *nsm = buf->frame;
-
- nsm->subtype = htonl(hdrs->subtype);
- } else {
- OVS_NOT_REACHED();
- }
+ ovsm->subtype = htonl(hdrs->subtype);
}
}
}
}
/* Determines the OFPTYPE_* type of the OpenFlow message in 'msg', which starts
- * at 'ofpbuf_data(msg)' and has length 'ofpbuf_size(msg)' bytes. On success,
+ * at 'msg->data' and has length 'msg->size' bytes. On success,
* returns 0 and stores the type into '*typep'. On failure, returns an
* OFPERR_* error code and zeros '*typep'.
*
*
* In addition to setting '*typep', this function pulls off the OpenFlow header
* (including the stats headers, vendor header, and any subtype header) with
- * ofpbuf_pull(). It also sets 'msg->frame' to the start of the OpenFlow
- * header and 'msg->l3' just beyond the headers (that is, to the final value of
- * ofpbuf_data(msg)). */
+ * ofpbuf_pull(). It also sets 'msg->header' to the start of the OpenFlow
+ * header and 'msg->msg' just beyond the headers (that is, to the final value
+ * of msg->data). */
enum ofperr
ofptype_pull(enum ofptype *typep, struct ofpbuf *buf)
{
{
return raw_info_get(raw)->type;
}
+
+const char *
+ofptype_get_name(enum ofptype type)
+{
+ ovs_assert(type < ARRAY_SIZE(type_names));
+ return type_names[type];
+}
\f
/* Updates the 'length' field of the OpenFlow message in 'buf' to
- * 'ofpbuf_size(buf)'. */
+ * 'buf->size'. */
void
ofpmsg_update_length(struct ofpbuf *buf)
{
struct ofp_header *oh = ofpbuf_at_assert(buf, 0, sizeof *oh);
- oh->length = htons(ofpbuf_size(buf));
+ oh->length = htons(buf->size);
}
-/* Returns just past the Openflow header (including the stats headers, vendor
+/* Returns just past the OpenFlow header (including the stats headers, vendor
* header, and any subtype header) in 'oh'. */
const void *
ofpmsg_body(const struct ofp_header *oh)
* use calls to the other ofpmp_*() functions to add to the body and split the
* message into multiple parts, if necessary. */
void
-ofpmp_init(struct list *replies, const struct ofp_header *request)
+ofpmp_init(struct ovs_list *replies, const struct ofp_header *request)
{
struct ofpbuf *msg;
* have not actually been allocated, so the caller must do so with
* e.g. ofpbuf_put_uninit(). */
struct ofpbuf *
-ofpmp_reserve(struct list *replies, size_t len)
+ofpmp_reserve(struct ovs_list *replies, size_t len)
{
struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
- if (ofpbuf_size(msg) + len <= UINT16_MAX) {
+ if (msg->size + len <= UINT16_MAX) {
ofpbuf_prealloc_tailroom(msg, len);
return msg;
} else {
struct ofpbuf *next;
struct ofphdrs hdrs;
- ofphdrs_decode_assert(&hdrs, ofpbuf_data(msg), ofpbuf_size(msg));
+ ofphdrs_decode_assert(&hdrs, msg->data, msg->size);
hdrs_len = ofphdrs_len(&hdrs);
next = ofpbuf_new(MAX(1024, hdrs_len + len));
- ofpbuf_put(next, ofpbuf_data(msg), hdrs_len);
- next->frame = ofpbuf_data(next);
- ofpbuf_set_l3(next, ofpbuf_tail(next));
+ ofpbuf_put(next, msg->data, hdrs_len);
+ next->header = next->data;
+ next->msg = ofpbuf_tail(next);
list_push_back(replies, &next->list_node);
- *ofpmp_flags__(ofpbuf_data(msg)) |= htons(OFPSF_REPLY_MORE);
+ *ofpmp_flags__(msg->data) |= htons(OFPSF_REPLY_MORE);
return next;
}
/* Appends 'len' bytes to the series of statistics replies in 'replies', and
* returns the first byte. */
void *
-ofpmp_append(struct list *replies, size_t len)
+ofpmp_append(struct ovs_list *replies, size_t len)
{
return ofpbuf_put_uninit(ofpmp_reserve(replies, len), len);
}
* the first 'start_ofs' bytes, the second one containing the bytes from that
* offset onward. */
void
-ofpmp_postappend(struct list *replies, size_t start_ofs)
+ofpmp_postappend(struct ovs_list *replies, size_t start_ofs)
{
struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
ovs_assert(start_ofs <= UINT16_MAX);
- if (ofpbuf_size(msg) > UINT16_MAX) {
- size_t len = ofpbuf_size(msg) - start_ofs;
+ if (msg->size > UINT16_MAX) {
+ size_t len = msg->size - start_ofs;
memcpy(ofpmp_append(replies, len),
- (const uint8_t *) ofpbuf_data(msg) + start_ofs, len);
- ofpbuf_set_size(msg, start_ofs);
+ (const uint8_t *) msg->data + start_ofs, len);
+ msg->size = start_ofs;
}
}
/* Returns the OpenFlow version of the replies being constructed in 'replies',
* which should have been initialized by ofpmp_init(). */
enum ofp_version
-ofpmp_version(struct list *replies)
+ofpmp_version(struct ovs_list *replies)
{
struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
- const struct ofp_header *oh = ofpbuf_data(msg);
+ const struct ofp_header *oh = msg->data;
return oh->version;
}
/* Determines the OFPRAW_* type of the OpenFlow messages in 'replies', which
* should have been initialized by ofpmp_init(). */
enum ofpraw
-ofpmp_decode_raw(struct list *replies)
+ofpmp_decode_raw(struct ovs_list *replies)
{
struct ofpbuf *msg = ofpbuf_from_list(list_back(replies));
enum ofperr error;
enum ofpraw raw;
- error = ofpraw_decode_partial(&raw, ofpbuf_data(msg), ofpbuf_size(msg));
+ error = ofpraw_decode_partial(&raw, msg->data, msg->size);
ovs_assert(!error);
return raw;
}
projects / cascardo / ovs.git / blobdiff