From: Ben Pfaff <blp@nicira.com>
Date: Fri, 2 May 2008 00:01:25 +0000 (-0700)
Subject: Convert tabs to spaces to fix indentation issues.
X-Git-Url: http://git.onelab.eu/?a=commitdiff_plain;h=2f20865ed22dd0a7070e25e95806eebaa8419e8f;p=sliver-openvswitch.git
Convert tabs to spaces to fix indentation issues.
---
diff --git a/switch/datapath.c b/switch/datapath.c
index 521150ba8..b569b7741 100644
--- a/switch/datapath.c
+++ b/switch/datapath.c
@@ -548,16 +548,16 @@ static void *
alloc_openflow_buffer(struct datapath *dp, size_t openflow_len, uint8_t type,
const struct sender *sender, struct buffer **bufferp)
{
- struct buffer *buffer;
- struct ofp_header *oh;
-
- buffer = *bufferp = buffer_new(openflow_len);
- oh = buffer_put_uninit(buffer, openflow_len);
- oh->version = OFP_VERSION;
- oh->type = type;
- oh->length = 0; /* Filled in by send_openflow_buffer(). */
- oh->xid = sender ? sender->xid : 0;
- return oh;
+ struct buffer *buffer;
+ struct ofp_header *oh;
+
+ buffer = *bufferp = buffer_new(openflow_len);
+ oh = buffer_put_uninit(buffer, openflow_len);
+ oh->version = OFP_VERSION;
+ oh->type = type;
+ oh->length = 0; /* Filled in by send_openflow_buffer(). */
+ oh->xid = sender ? sender->xid : 0;
+ return oh;
}
static int
@@ -711,23 +711,23 @@ static void
fill_flow_stats(struct ofp_flow_stats *ofs, struct sw_flow *flow,
int table_idx, time_t now)
{
- ofs->match.wildcards = htons(flow->key.wildcards);
- ofs->match.in_port = flow->key.flow.in_port;
- memcpy(ofs->match.dl_src, flow->key.flow.dl_src, ETH_ADDR_LEN);
- memcpy(ofs->match.dl_dst, flow->key.flow.dl_dst, ETH_ADDR_LEN);
- ofs->match.dl_vlan = flow->key.flow.dl_vlan;
- ofs->match.dl_type = flow->key.flow.dl_type;
- ofs->match.nw_src = flow->key.flow.nw_src;
- ofs->match.nw_dst = flow->key.flow.nw_dst;
- ofs->match.nw_proto = flow->key.flow.nw_proto;
- memset(ofs->match.pad, 0, sizeof ofs->match.pad);
- ofs->match.tp_src = flow->key.flow.tp_src;
- ofs->match.tp_dst = flow->key.flow.tp_dst;
- ofs->duration = htonl(now - flow->created);
- ofs->packet_count = htonll(flow->packet_count);
- ofs->byte_count = htonll(flow->byte_count);
- ofs->priority = htons(flow->priority);
- ofs->table_id = table_idx;
+ ofs->match.wildcards = htons(flow->key.wildcards);
+ ofs->match.in_port = flow->key.flow.in_port;
+ memcpy(ofs->match.dl_src, flow->key.flow.dl_src, ETH_ADDR_LEN);
+ memcpy(ofs->match.dl_dst, flow->key.flow.dl_dst, ETH_ADDR_LEN);
+ ofs->match.dl_vlan = flow->key.flow.dl_vlan;
+ ofs->match.dl_type = flow->key.flow.dl_type;
+ ofs->match.nw_src = flow->key.flow.nw_src;
+ ofs->match.nw_dst = flow->key.flow.nw_dst;
+ ofs->match.nw_proto = flow->key.flow.nw_proto;
+ memset(ofs->match.pad, 0, sizeof ofs->match.pad);
+ ofs->match.tp_src = flow->key.flow.tp_src;
+ ofs->match.tp_dst = flow->key.flow.tp_dst;
+ ofs->duration = htonl(now - flow->created);
+ ofs->packet_count = htonll(flow->packet_count);
+ ofs->byte_count = htonll(flow->byte_count);
+ ofs->priority = htons(flow->priority);
+ ofs->table_id = table_idx;
memset(ofs->pad, 0, sizeof ofs->pad);
}
@@ -967,9 +967,9 @@ recv_get_config_request(struct datapath *dp, const struct sender *sender,
sender, &buffer);
assert(sizeof *osc == sizeof dp->config);
- memcpy(((char *)osc) + sizeof osc->header,
- ((char *)&dp->config) + sizeof dp->config.header,
- sizeof dp->config - sizeof dp->config.header);
+ memcpy(((char *)osc) + sizeof osc->header,
+ ((char *)&dp->config) + sizeof dp->config.header,
+ sizeof dp->config - sizeof dp->config.header);
return send_openflow_buffer(dp, buffer, sender);
}
@@ -1123,176 +1123,176 @@ recv_flow(struct datapath *dp, const struct sender *sender UNUSED,
}
struct flow_stats_state {
- int table_idx;
- struct sw_table_position position;
- struct ofp_flow_stats_request rq;
+ int table_idx;
+ struct sw_table_position position;
+ struct ofp_flow_stats_request rq;
time_t now;
struct buffer *buffer;
- int n_flows, max_flows;
+ int n_flows, max_flows;
};
static int flow_stats_init(struct datapath *dp, const void *body, int body_len,
void **state)
{
- const struct ofp_flow_stats_request *fsr = body;
- struct flow_stats_state *s = xmalloc(sizeof *s);
- s->table_idx = fsr->table_id == 0xff ? 0 : fsr->table_id;
- memset(&s->position, 0, sizeof s->position);
- s->rq = *fsr;
- *state = s;
- return 0;
+ const struct ofp_flow_stats_request *fsr = body;
+ struct flow_stats_state *s = xmalloc(sizeof *s);
+ s->table_idx = fsr->table_id == 0xff ? 0 : fsr->table_id;
+ memset(&s->position, 0, sizeof s->position);
+ s->rq = *fsr;
+ *state = s;
+ return 0;
}
static int flow_stats_dump_callback(struct sw_flow *flow, void *private)
{
- struct flow_stats_state *s = private;
+ struct flow_stats_state *s = private;
struct ofp_flow_stats *ofs = buffer_put_uninit(s->buffer, sizeof *ofs);
- fill_flow_stats(ofs, flow, s->table_idx, s->now);
- return ++s->n_flows >= s->max_flows;
+ fill_flow_stats(ofs, flow, s->table_idx, s->now);
+ return ++s->n_flows >= s->max_flows;
}
static int flow_stats_dump(struct datapath *dp, void *state,
struct buffer *buffer)
{
- struct flow_stats_state *s = state;
- struct ofp_flow_stats *ofs;
- struct sw_flow_key match_key;
+ struct flow_stats_state *s = state;
+ struct ofp_flow_stats *ofs;
+ struct sw_flow_key match_key;
- s->max_flows = 4096 / sizeof *ofs;
- if (!s->max_flows)
- return -ENOMEM;
+ s->max_flows = 4096 / sizeof *ofs;
+ if (!s->max_flows)
+ return -ENOMEM;
- flow_extract_match(&match_key, &s->rq.match);
+ flow_extract_match(&match_key, &s->rq.match);
s->buffer = buffer;
- s->n_flows = 0;
+ s->n_flows = 0;
s->now = time(0);
- while (s->table_idx < dp->chain->n_tables
- && (s->rq.table_id == 0xff || s->rq.table_id == s->table_idx))
- {
- struct sw_table *table = dp->chain->tables[s->table_idx];
+ while (s->table_idx < dp->chain->n_tables
+ && (s->rq.table_id == 0xff || s->rq.table_id == s->table_idx))
+ {
+ struct sw_table *table = dp->chain->tables[s->table_idx];
- if (table->iterate(table, &match_key, &s->position,
+ if (table->iterate(table, &match_key, &s->position,
flow_stats_dump_callback, s))
- break;
+ break;
- s->table_idx++;
- memset(&s->position, 0, sizeof s->position);
- }
- return s->n_flows >= s->max_flows;
+ s->table_idx++;
+ memset(&s->position, 0, sizeof s->position);
+ }
+ return s->n_flows >= s->max_flows;
}
static void flow_stats_done(void *state)
{
- free(state);
+ free(state);
}
static int table_stats_dump(struct datapath *dp, void *state,
struct buffer *buffer)
{
- int i;
- for (i = 0; i < dp->chain->n_tables; i++) {
+ int i;
+ for (i = 0; i < dp->chain->n_tables; i++) {
struct ofp_table_stats *ots = buffer_put_uninit(buffer, sizeof *ots);
- struct sw_table_stats stats;
- dp->chain->tables[i]->stats(dp->chain->tables[i], &stats);
- strncpy(ots->name, stats.name, sizeof ots->name);
- ots->table_id = i;
- memset(ots->pad, 0, sizeof ots->pad);
- ots->max_entries = htonl(stats.max_flows);
- ots->active_count = htonl(stats.n_flows);
- ots->matched_count = htonll(0); /* FIXME */
- }
- return 0;
+ struct sw_table_stats stats;
+ dp->chain->tables[i]->stats(dp->chain->tables[i], &stats);
+ strncpy(ots->name, stats.name, sizeof ots->name);
+ ots->table_id = i;
+ memset(ots->pad, 0, sizeof ots->pad);
+ ots->max_entries = htonl(stats.max_flows);
+ ots->active_count = htonl(stats.n_flows);
+ ots->matched_count = htonll(0); /* FIXME */
+ }
+ return 0;
}
struct port_stats_state {
- int port;
+ int port;
};
static int port_stats_init(struct datapath *dp, const void *body, int body_len,
- void **state)
+ void **state)
{
- struct port_stats_state *s = xmalloc(sizeof *s);
- s->port = 0;
- *state = s;
- return 0;
+ struct port_stats_state *s = xmalloc(sizeof *s);
+ s->port = 0;
+ *state = s;
+ return 0;
}
static int port_stats_dump(struct datapath *dp, void *state,
struct buffer *buffer)
{
- struct port_stats_state *s = state;
- int i;
+ struct port_stats_state *s = state;
+ int i;
- for (i = s->port; i < OFPP_MAX; i++) {
- struct sw_port *p = &dp->ports[i];
+ for (i = s->port; i < OFPP_MAX; i++) {
+ struct sw_port *p = &dp->ports[i];
struct ofp_port_stats *ops;
- if (!p->netdev) {
- continue;
+ if (!p->netdev) {
+ continue;
}
ops = buffer_put_uninit(buffer, sizeof *ops);
- ops->port_no = htons(port_no(dp, p));
- memset(ops->pad, 0, sizeof ops->pad);
- ops->rx_count = htonll(p->rx_count);
- ops->tx_count = htonll(p->tx_count);
- ops->drop_count = htonll(p->drop_count);
- ops++;
- }
- s->port = i;
- return 0;
+ ops->port_no = htons(port_no(dp, p));
+ memset(ops->pad, 0, sizeof ops->pad);
+ ops->rx_count = htonll(p->rx_count);
+ ops->tx_count = htonll(p->tx_count);
+ ops->drop_count = htonll(p->drop_count);
+ ops++;
+ }
+ s->port = i;
+ return 0;
}
static void port_stats_done(void *state)
{
- free(state);
+ free(state);
}
struct stats_type {
- /* Minimum and maximum acceptable number of bytes in body member of
- * struct ofp_stats_request. */
- size_t min_body, max_body;
-
- /* Prepares to dump some kind of statistics on 'dp'. 'body' and
- * 'body_len' are the 'body' member of the struct ofp_stats_request.
- * Returns zero if successful, otherwise a negative error code.
- * May initialize '*state' to state information. May be null if no
- * initialization is required.*/
- int (*init)(struct datapath *dp, const void *body, int body_len,
- void **state);
-
- /* Appends statistics for 'dp' to 'buffer', which initially contains a
+ /* Minimum and maximum acceptable number of bytes in body member of
+ * struct ofp_stats_request. */
+ size_t min_body, max_body;
+
+ /* Prepares to dump some kind of statistics on 'dp'. 'body' and
+ * 'body_len' are the 'body' member of the struct ofp_stats_request.
+ * Returns zero if successful, otherwise a negative error code.
+ * May initialize '*state' to state information. May be null if no
+ * initialization is required.*/
+ int (*init)(struct datapath *dp, const void *body, int body_len,
+ void **state);
+
+ /* Appends statistics for 'dp' to 'buffer', which initially contains a
* struct ofp_stats_reply. On success, it should return 1 if it should be
* called again later with another buffer, 0 if it is done, or a negative
* errno value on failure. */
- int (*dump)(struct datapath *dp, void *state, struct buffer *buffer);
+ int (*dump)(struct datapath *dp, void *state, struct buffer *buffer);
- /* Cleans any state created by the init or dump functions. May be null
- * if no cleanup is required. */
- void (*done)(void *state);
+ /* Cleans any state created by the init or dump functions. May be null
+ * if no cleanup is required. */
+ void (*done)(void *state);
};
static const struct stats_type stats[] = {
- [OFPST_FLOW] = {
- sizeof(struct ofp_flow_stats_request),
- sizeof(struct ofp_flow_stats_request),
- flow_stats_init,
- flow_stats_dump,
- flow_stats_done
- },
- [OFPST_TABLE] = {
- 0,
- 0,
- NULL,
- table_stats_dump,
- NULL
- },
- [OFPST_PORT] = {
- 0,
- 0,
- port_stats_init,
- port_stats_dump,
- port_stats_done
- },
+ [OFPST_FLOW] = {
+ sizeof(struct ofp_flow_stats_request),
+ sizeof(struct ofp_flow_stats_request),
+ flow_stats_init,
+ flow_stats_dump,
+ flow_stats_done
+ },
+ [OFPST_TABLE] = {
+ 0,
+ 0,
+ NULL,
+ table_stats_dump,
+ NULL
+ },
+ [OFPST_PORT] = {
+ 0,
+ 0,
+ port_stats_init,
+ port_stats_dump,
+ port_stats_done
+ },
};
struct stats_dump_cb {
@@ -1307,36 +1307,36 @@ static int
stats_dump(struct datapath *dp, void *cb_)
{
struct stats_dump_cb *cb = cb_;
- struct ofp_stats_reply *osr;
+ struct ofp_stats_reply *osr;
struct buffer *buffer;
- int err;
+ int err;
if (cb->done) {
return 0;
- }
+ }
- osr = alloc_openflow_buffer(dp, sizeof *osr, OFPT_STATS_REPLY, &cb->sender,
+ osr = alloc_openflow_buffer(dp, sizeof *osr, OFPT_STATS_REPLY, &cb->sender,
&buffer);
- osr->type = htons(cb->s - stats);
- osr->flags = 0;
+ osr->type = htons(cb->s - stats);
+ osr->flags = 0;
- err = cb->s->dump(dp, cb->state, buffer);
- if (err >= 0) {
+ err = cb->s->dump(dp, cb->state, buffer);
+ if (err >= 0) {
int err2;
- if (!err) {
- cb->done = true;
+ if (!err) {
+ cb->done = true;
} else {
/* Buffer might have been reallocated, so find our data again. */
osr = buffer_at_assert(buffer, 0, sizeof *osr);
- osr->flags = ntohs(OFPSF_REPLY_MORE);
+ osr->flags = ntohs(OFPSF_REPLY_MORE);
}
err2 = send_openflow_buffer(dp, buffer, &cb->sender);
if (err2) {
err = err2;
}
- }
+ }
- return err;
+ return err;
}
static void
@@ -1344,11 +1344,11 @@ stats_done(void *cb_)
{
struct stats_dump_cb *cb = cb_;
if (cb) {
- if (cb->s->done) {
- cb->s->done(cb->state);
+ if (cb->s->done) {
+ cb->s->done(cb->state);
}
free(cb);
- }
+ }
}
static int
@@ -1436,10 +1436,10 @@ fwd_control_input(struct datapath *dp, const struct sender *sender,
sizeof (struct ofp_port_mod),
recv_port_mod,
},
- [OFPT_STATS_REQUEST] = {
- sizeof (struct ofp_stats_request),
- recv_stats_request,
- },
+ [OFPT_STATS_REQUEST] = {
+ sizeof (struct ofp_stats_request),
+ recv_stats_request,
+ },
};
const struct openflow_packet *pkt;
diff --git a/switch/table.h b/switch/table.h
index c86380a04..5ce7f3bbc 100644
--- a/switch/table.h
+++ b/switch/table.h
@@ -55,7 +55,7 @@ struct sw_table_stats {
* The contents are private to the table implementation, except that a position
* initialized to all-zero-bits represents the start of a table. */
struct sw_table_position {
- unsigned long private[4];
+ unsigned long private[4];
};
/* A single table of flows. */
@@ -89,23 +89,23 @@ struct sw_table {
/* Destroys 'table', which must not have any users. */
void (*destroy)(struct sw_table *table);
- /* Iterates through the flow entries in 'table', passing each one
- * matches 'key' to 'callback'. The callback function should return 0
- * to continue iteration or a nonzero error code to stop. The iterator
- * function returns either 0 if the table iteration completed or the
- * value returned by the callback function otherwise.
- *
- * The iteration starts at 'position', which may be initialized to
- * all-zero-bits to iterate from the beginning of the table. If the
- * iteration terminates due to an error from the callback function,
- * 'position' is updated to a value that can be passed back to the
- * iterator function to resume iteration later with the following
- * flow. */
- int (*iterate)(struct sw_table *table,
- const struct sw_flow_key *key,
- struct sw_table_position *position,
- int (*callback)(struct sw_flow *flow, void *private),
- void *private);
+ /* Iterates through the flow entries in 'table', passing each one
+ * matches 'key' to 'callback'. The callback function should return 0
+ * to continue iteration or a nonzero error code to stop. The iterator
+ * function returns either 0 if the table iteration completed or the
+ * value returned by the callback function otherwise.
+ *
+ * The iteration starts at 'position', which may be initialized to
+ * all-zero-bits to iterate from the beginning of the table. If the
+ * iteration terminates due to an error from the callback function,
+ * 'position' is updated to a value that can be passed back to the
+ * iterator function to resume iteration later with the following
+ * flow. */
+ int (*iterate)(struct sw_table *table,
+ const struct sw_flow_key *key,
+ struct sw_table_position *position,
+ int (*callback)(struct sw_flow *flow, void *private),
+ void *private);
/* Dumps statistics for 'table' into 'stats'. */
void (*stats)(struct sw_table *table, struct sw_table_stats *stats);