X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-actions.c;h=cccd6b1745ab7a50be2fc404114b461a62dc9d3e;hb=0386824614e9739d4b20b8355cfe973d0a3655c7;hp=0d1a2acdda193ce7b32d647a1c8575487ef123fd;hpb=7bcb1506ee2de6a460db35404e642f21d8219b5f;p=sliver-openvswitch.git diff --git a/lib/ofp-actions.c b/lib/ofp-actions.c index 0d1a2acdd..cccd6b174 100644 --- a/lib/ofp-actions.c +++ b/lib/ofp-actions.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,7 +16,6 @@ #include #include "ofp-actions.h" -#include "autopath.h" #include "bundle.h" #include "byte-order.h" #include "compiler.h" @@ -27,6 +26,7 @@ #include "nx-match.h" #include "ofp-util.h" #include "ofpbuf.h" +#include "util.h" #include "vlog.h" VLOG_DEFINE_THIS_MODULE(ofp_actions); @@ -35,6 +35,50 @@ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); /* Converting OpenFlow 1.0 to ofpacts. */ +union ofp_action { + ovs_be16 type; + struct ofp_action_header header; + struct ofp_action_vendor_header vendor; + struct ofp10_action_output output10; + struct ofp_action_vlan_vid vlan_vid; + struct ofp_action_vlan_pcp vlan_pcp; + struct ofp_action_nw_addr nw_addr; + struct ofp_action_nw_tos nw_tos; + struct ofp11_action_nw_ecn nw_ecn; + struct ofp11_action_nw_ttl nw_ttl; + struct ofp_action_tp_port tp_port; + struct ofp_action_dl_addr dl_addr; + struct ofp10_action_enqueue enqueue; + struct ofp11_action_output ofp11_output; + struct ofp11_action_push push; + struct ofp11_action_pop_mpls ofp11_pop_mpls; + struct ofp11_action_set_queue ofp11_set_queue; + struct ofp11_action_mpls_ttl ofp11_mpls_ttl; + struct ofp11_action_group group; + struct ofp12_action_set_field set_field; + struct nx_action_header nxa_header; + struct nx_action_resubmit resubmit; + struct nx_action_set_tunnel set_tunnel; + struct nx_action_set_tunnel64 set_tunnel64; + struct nx_action_write_metadata write_metadata; + struct nx_action_set_queue set_queue; + struct nx_action_reg_move reg_move; + struct nx_action_reg_load reg_load; + struct nx_action_stack stack; + struct nx_action_note note; + struct nx_action_multipath multipath; + struct nx_action_bundle bundle; + struct nx_action_output_reg output_reg; + struct nx_action_cnt_ids cnt_ids; + struct nx_action_fin_timeout fin_timeout; + struct nx_action_controller controller; + struct nx_action_push_mpls push_mpls; + struct nx_action_mpls_ttl mpls_ttl; + struct nx_action_pop_mpls pop_mpls; + struct nx_action_sample sample; + struct nx_action_learn learn; +}; + static enum ofperr output_from_openflow10(const struct ofp10_action_output *oao, struct ofpbuf *out) @@ -42,22 +86,23 @@ output_from_openflow10(const struct ofp10_action_output *oao, struct ofpact_output *output; output = ofpact_put_OUTPUT(out); - output->port = ntohs(oao->port); + output->port = u16_to_ofp(ntohs(oao->port)); output->max_len = ntohs(oao->max_len); return ofputil_check_output_port(output->port, OFPP_MAX); } static enum ofperr -enqueue_from_openflow10(const struct ofp_action_enqueue *oae, +enqueue_from_openflow10(const struct ofp10_action_enqueue *oae, struct ofpbuf *out) { struct ofpact_enqueue *enqueue; enqueue = ofpact_put_ENQUEUE(out); - enqueue->port = ntohs(oae->port); + enqueue->port = u16_to_ofp(ntohs(oae->port)); enqueue->queue = ntohl(oae->queue_id); - if (enqueue->port >= OFPP_MAX && enqueue->port != OFPP_IN_PORT + if (ofp_to_u16(enqueue->port) >= ofp_to_u16(OFPP_MAX) + && enqueue->port != OFPP_IN_PORT && enqueue->port != OFPP_LOCAL) { return OFPERR_OFPBAC_BAD_OUT_PORT; } @@ -72,7 +117,7 @@ resubmit_from_openflow(const struct nx_action_resubmit *nar, resubmit = ofpact_put_RESUBMIT(out); resubmit->ofpact.compat = OFPUTIL_NXAST_RESUBMIT; - resubmit->in_port = ntohs(nar->in_port); + resubmit->in_port = u16_to_ofp(ntohs(nar->in_port)); resubmit->table_id = 0xff; } @@ -88,7 +133,7 @@ resubmit_table_from_openflow(const struct nx_action_resubmit *nar, resubmit = ofpact_put_RESUBMIT(out); resubmit->ofpact.compat = OFPUTIL_NXAST_RESUBMIT_TABLE; - resubmit->in_port = ntohs(nar->in_port); + resubmit->in_port = u16_to_ofp(ntohs(nar->in_port)); resubmit->table_id = nar->table; return 0; } @@ -135,6 +180,23 @@ controller_from_openflow(const struct nx_action_controller *nac, oc->reason = nac->reason; } +static enum ofperr +metadata_from_nxast(const struct nx_action_write_metadata *nawm, + struct ofpbuf *out) +{ + struct ofpact_metadata *om; + + if (!is_all_zeros(nawm->zeros, sizeof nawm->zeros)) { + return OFPERR_NXBRC_MUST_BE_ZERO; + } + + om = ofpact_put_WRITE_METADATA(out); + om->metadata = nawm->metadata; + om->mask = nawm->mask; + + return 0; +} + static void note_from_openflow(const struct nx_action_note *nan, struct ofpbuf *out) { @@ -192,18 +254,53 @@ dec_ttl_cnt_ids_from_openflow(const struct nx_action_cnt_ids *nac_ids, for (i = 0; i < ids->n_controllers; i++) { uint16_t id = ntohs(((ovs_be16 *)(nac_ids + 1))[i]); ofpbuf_put(out, &id, sizeof id); + ids = out->l2; } - ids = out->l2; ofpact_update_len(out, &ids->ofpact); return 0; } +static enum ofperr +sample_from_openflow(const struct nx_action_sample *nas, + struct ofpbuf *out) +{ + struct ofpact_sample *sample; + + sample = ofpact_put_SAMPLE(out); + sample->probability = ntohs(nas->probability); + sample->collector_set_id = ntohl(nas->collector_set_id); + sample->obs_domain_id = ntohl(nas->obs_domain_id); + sample->obs_point_id = ntohl(nas->obs_point_id); + + if (sample->probability == 0) { + return OFPERR_OFPBAC_BAD_ARGUMENT; + } + + return 0; +} + +static enum ofperr +push_mpls_from_openflow(ovs_be16 ethertype, enum ofpact_mpls_position position, + struct ofpbuf *out) +{ + struct ofpact_push_mpls *oam; + + if (!eth_type_mpls(ethertype)) { + return OFPERR_OFPBAC_BAD_ARGUMENT; + } + oam = ofpact_put_PUSH_MPLS(out); + oam->ethertype = ethertype; + oam->position = position; + + return 0; +} + static enum ofperr decode_nxast_action(const union ofp_action *a, enum ofputil_action_code *code) { - const struct nx_action_header *nah = (const struct nx_action_header *) a; + const struct nx_action_header *nah = &a->nxa_header; uint16_t len = ntohs(a->header.len); if (len < sizeof(struct nx_action_header)) { @@ -238,8 +335,8 @@ decode_nxast_action(const union ofp_action *a, enum ofputil_action_code *code) * '*code' is indeterminate. * * The caller must have already verified that 'a''s length is potentially - * correct (that is, a->header.len is nonzero and a multiple of sizeof(union - * ofp_action) and no longer than the amount of space allocated to 'a'). + * correct (that is, a->header.len is nonzero and a multiple of + * OFP_ACTION_ALIGN and no longer than the amount of space allocated to 'a'). * * This function verifies that 'a''s length is correct for the type of action * that it represents. */ @@ -271,11 +368,6 @@ static enum ofperr ofpact_from_nxast(const union ofp_action *a, enum ofputil_action_code code, struct ofpbuf *out) { - const struct nx_action_resubmit *nar; - const struct nx_action_set_tunnel *nast; - const struct nx_action_set_queue *nasq; - const struct nx_action_note *nan; - const struct nx_action_set_tunnel64 *nast64; struct ofpact_tunnel *tunnel; enum ofperr error = 0; @@ -287,19 +379,21 @@ ofpact_from_nxast(const union ofp_action *a, enum ofputil_action_code code, NOT_REACHED(); case OFPUTIL_NXAST_RESUBMIT: - resubmit_from_openflow((const struct nx_action_resubmit *) a, out); + resubmit_from_openflow(&a->resubmit, out); break; case OFPUTIL_NXAST_SET_TUNNEL: - nast = (const struct nx_action_set_tunnel *) a; tunnel = ofpact_put_SET_TUNNEL(out); tunnel->ofpact.compat = code; - tunnel->tun_id = ntohl(nast->tun_id); + tunnel->tun_id = ntohl(a->set_tunnel.tun_id); + break; + + case OFPUTIL_NXAST_WRITE_METADATA: + error = metadata_from_nxast(&a->write_metadata, out); break; case OFPUTIL_NXAST_SET_QUEUE: - nasq = (const struct nx_action_set_queue *) a; - ofpact_put_SET_QUEUE(out)->queue_id = ntohl(nasq->queue_id); + ofpact_put_SET_QUEUE(out)->queue_id = ntohl(a->set_queue.queue_id); break; case OFPUTIL_NXAST_POP_QUEUE: @@ -307,54 +401,51 @@ ofpact_from_nxast(const union ofp_action *a, enum ofputil_action_code code, break; case OFPUTIL_NXAST_REG_MOVE: - error = nxm_reg_move_from_openflow( - (const struct nx_action_reg_move *) a, out); + error = nxm_reg_move_from_openflow(&a->reg_move, out); break; case OFPUTIL_NXAST_REG_LOAD: - error = nxm_reg_load_from_openflow( - (const struct nx_action_reg_load *) a, out); + error = nxm_reg_load_from_openflow(&a->reg_load, out); + break; + + case OFPUTIL_NXAST_STACK_PUSH: + error = nxm_stack_push_from_openflow(&a->stack, out); + break; + + case OFPUTIL_NXAST_STACK_POP: + error = nxm_stack_pop_from_openflow(&a->stack, out); break; case OFPUTIL_NXAST_NOTE: - nan = (const struct nx_action_note *) a; - note_from_openflow(nan, out); + note_from_openflow(&a->note, out); break; case OFPUTIL_NXAST_SET_TUNNEL64: - nast64 = (const struct nx_action_set_tunnel64 *) a; tunnel = ofpact_put_SET_TUNNEL(out); tunnel->ofpact.compat = code; - tunnel->tun_id = ntohll(nast64->tun_id); + tunnel->tun_id = ntohll(a->set_tunnel64.tun_id); break; case OFPUTIL_NXAST_MULTIPATH: - error = multipath_from_openflow((const struct nx_action_multipath *) a, + error = multipath_from_openflow(&a->multipath, ofpact_put_MULTIPATH(out)); break; - case OFPUTIL_NXAST_AUTOPATH__DEPRECATED: - error = autopath_from_openflow((const struct nx_action_autopath *) a, - ofpact_put_AUTOPATH(out)); - break; - case OFPUTIL_NXAST_BUNDLE: case OFPUTIL_NXAST_BUNDLE_LOAD: - error = bundle_from_openflow((const struct nx_action_bundle *) a, out); + error = bundle_from_openflow(&a->bundle, out); break; case OFPUTIL_NXAST_OUTPUT_REG: - error = output_reg_from_openflow( - (const struct nx_action_output_reg *) a, out); + error = output_reg_from_openflow(&a->output_reg, out); break; case OFPUTIL_NXAST_RESUBMIT_TABLE: - nar = (const struct nx_action_resubmit *) a; - error = resubmit_table_from_openflow(nar, out); + error = resubmit_table_from_openflow(&a->resubmit, out); break; case OFPUTIL_NXAST_LEARN: - error = learn_from_openflow((const struct nx_action_learn *) a, out); + error = learn_from_openflow(&a->learn, out); break; case OFPUTIL_NXAST_EXIT: @@ -366,17 +457,39 @@ ofpact_from_nxast(const union ofp_action *a, enum ofputil_action_code code, break; case OFPUTIL_NXAST_DEC_TTL_CNT_IDS: - error = dec_ttl_cnt_ids_from_openflow( - (const struct nx_action_cnt_ids *) a, out); + error = dec_ttl_cnt_ids_from_openflow(&a->cnt_ids, out); break; case OFPUTIL_NXAST_FIN_TIMEOUT: - fin_timeout_from_openflow( - (const struct nx_action_fin_timeout *) a, out); + fin_timeout_from_openflow(&a->fin_timeout, out); break; case OFPUTIL_NXAST_CONTROLLER: - controller_from_openflow((const struct nx_action_controller *) a, out); + controller_from_openflow(&a->controller, out); + break; + + case OFPUTIL_NXAST_PUSH_MPLS: + error = push_mpls_from_openflow(a->push_mpls.ethertype, + OFPACT_MPLS_AFTER_VLAN, out); + break; + + case OFPUTIL_NXAST_SET_MPLS_TTL: + ofpact_put_SET_MPLS_TTL(out)->ttl = a->mpls_ttl.ttl; + break; + + case OFPUTIL_NXAST_DEC_MPLS_TTL: + ofpact_put_DEC_MPLS_TTL(out); + break; + + case OFPUTIL_NXAST_POP_MPLS: + if (eth_type_mpls(a->pop_mpls.ethertype)) { + return OFPERR_OFPBAC_BAD_ARGUMENT; + } + ofpact_put_POP_MPLS(out)->ethertype = a->pop_mpls.ethertype; + break; + + case OFPUTIL_NXAST_SAMPLE: + error = sample_from_openflow(&a->sample, out); break; } @@ -422,13 +535,13 @@ ofpact_from_openflow10(const union ofp_action *a, struct ofpbuf *out) break; case OFPUTIL_OFPAT10_SET_DL_SRC: - memcpy(ofpact_put_SET_ETH_SRC(out)->mac, - ((const struct ofp_action_dl_addr *) a)->dl_addr, ETH_ADDR_LEN); + memcpy(ofpact_put_SET_ETH_SRC(out)->mac, a->dl_addr.dl_addr, + ETH_ADDR_LEN); break; case OFPUTIL_OFPAT10_SET_DL_DST: - memcpy(ofpact_put_SET_ETH_DST(out)->mac, - ((const struct ofp_action_dl_addr *) a)->dl_addr, ETH_ADDR_LEN); + memcpy(ofpact_put_SET_ETH_DST(out)->mac, a->dl_addr.dl_addr, + ETH_ADDR_LEN); break; case OFPUTIL_OFPAT10_SET_NW_SRC: @@ -443,7 +556,7 @@ ofpact_from_openflow10(const union ofp_action *a, struct ofpbuf *out) if (a->nw_tos.nw_tos & ~IP_DSCP_MASK) { return OFPERR_OFPBAC_BAD_ARGUMENT; } - ofpact_put_SET_IPV4_DSCP(out)->dscp = a->nw_tos.nw_tos; + ofpact_put_SET_IP_DSCP(out)->dscp = a->nw_tos.nw_tos; break; case OFPUTIL_OFPAT10_SET_TP_SRC: @@ -456,8 +569,7 @@ ofpact_from_openflow10(const union ofp_action *a, struct ofpbuf *out) break; case OFPUTIL_OFPAT10_ENQUEUE: - error = enqueue_from_openflow10((const struct ofp_action_enqueue *) a, - out); + error = enqueue_from_openflow10(&a->enqueue, out); break; #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM: @@ -476,32 +588,33 @@ action_next(const union ofp_action *a) } static inline bool -action_is_valid(const union ofp_action *a, size_t n_actions) +action_is_valid(const union ofp_action *a, size_t max_actions) { uint16_t len = ntohs(a->header.len); return (!(len % OFP_ACTION_ALIGN) - && len >= sizeof *a - && len / sizeof *a <= n_actions); + && len >= OFP_ACTION_ALIGN + && len / OFP_ACTION_ALIGN <= max_actions); } /* This macro is careful to check for actions with bad lengths. */ -#define ACTION_FOR_EACH(ITER, LEFT, ACTIONS, N_ACTIONS) \ - for ((ITER) = (ACTIONS), (LEFT) = (N_ACTIONS); \ +#define ACTION_FOR_EACH(ITER, LEFT, ACTIONS, MAX_ACTIONS) \ + for ((ITER) = (ACTIONS), (LEFT) = (MAX_ACTIONS); \ (LEFT) > 0 && action_is_valid(ITER, LEFT); \ - ((LEFT) -= ntohs((ITER)->header.len) / sizeof(union ofp_action), \ + ((LEFT) -= ntohs((ITER)->header.len) / OFP_ACTION_ALIGN, \ (ITER) = action_next(ITER))) static void -log_bad_action(const union ofp_action *actions, size_t n_actions, size_t ofs, - enum ofperr error) +log_bad_action(const union ofp_action *actions, size_t max_actions, + const union ofp_action *bad_action, enum ofperr error) { if (!VLOG_DROP_WARN(&rl)) { struct ds s; ds_init(&s); - ds_put_hex_dump(&s, actions, n_actions * sizeof *actions, 0, false); - VLOG_WARN("bad action at offset %#zx (%s):\n%s", - ofs * sizeof *actions, ofperr_get_name(error), ds_cstr(&s)); + ds_put_hex_dump(&s, actions, max_actions * OFP_ACTION_ALIGN, 0, false); + VLOG_WARN("bad action at offset %#tx (%s):\n%s", + (char *)bad_action - (char *)actions, + ofperr_get_name(error), ds_cstr(&s)); ds_destroy(&s); } } @@ -518,13 +631,13 @@ ofpacts_from_openflow(const union ofp_action *in, size_t n_in, ACTION_FOR_EACH (a, left, in, n_in) { enum ofperr error = ofpact_from_openflow(a, out); if (error) { - log_bad_action(in, n_in, a - in, error); + log_bad_action(in, n_in, a, error); return error; } } if (left) { enum ofperr error = OFPERR_OFPBAC_BAD_LEN; - log_bad_action(in, n_in, n_in - left, error); + log_bad_action(in, n_in, a, error); return error; } @@ -543,7 +656,7 @@ static enum ofperr ofpacts_pull_actions(struct ofpbuf *openflow, unsigned int actions_len, struct ofpbuf *ofpacts, enum ofperr (*translate)(const union ofp_action *actions, - size_t n_actions, + size_t max_actions, struct ofpbuf *ofpacts)) { static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); @@ -567,6 +680,12 @@ ofpacts_pull_actions(struct ofpbuf *openflow, unsigned int actions_len, } error = translate(actions, actions_len / OFP_ACTION_ALIGN, ofpacts); + if (error) { + ofpbuf_clear(ofpacts); + return error; + } + + error = ofpacts_verify(ofpacts->data, ofpacts->size); if (error) { ofpbuf_clear(ofpacts); } @@ -598,8 +717,8 @@ ofpacts_pull_openflow10(struct ofpbuf *openflow, unsigned int actions_len, * '*code' is indeterminate. * * The caller must have already verified that 'a''s length is potentially - * correct (that is, a->header.len is nonzero and a multiple of sizeof(union - * ofp_action) and no longer than the amount of space allocated to 'a'). + * correct (that is, a->header.len is nonzero and a multiple of + * OFP_ACTION_ALIGN and no longer than the amount of space allocated to 'a'). * * This function verifies that 'a''s length is correct for the type of action * that it represents. */ @@ -668,8 +787,7 @@ ofpact_from_openflow11(const union ofp_action *a, struct ofpbuf *out) NOT_REACHED(); case OFPUTIL_OFPAT11_OUTPUT: - return output_from_openflow11((const struct ofp11_action_output *) a, - out); + return output_from_openflow11(&a->ofp11_output, out); case OFPUTIL_OFPAT11_SET_VLAN_VID: if (a->vlan_vid.vlan_vid & ~htons(0xfff)) { @@ -685,14 +803,31 @@ ofpact_from_openflow11(const union ofp_action *a, struct ofpbuf *out) ofpact_put_SET_VLAN_PCP(out)->vlan_pcp = a->vlan_pcp.vlan_pcp; break; + case OFPUTIL_OFPAT11_PUSH_VLAN: + if (a->push.ethertype != htons(ETH_TYPE_VLAN_8021Q)) { + /* XXX 802.1AD(QinQ) isn't supported at the moment */ + return OFPERR_OFPBAC_BAD_ARGUMENT; + } + ofpact_put_PUSH_VLAN(out); + break; + + case OFPUTIL_OFPAT11_POP_VLAN: + ofpact_put_STRIP_VLAN(out); + break; + + case OFPUTIL_OFPAT11_SET_QUEUE: + ofpact_put_SET_QUEUE(out)->queue_id = + ntohl(a->ofp11_set_queue.queue_id); + break; + case OFPUTIL_OFPAT11_SET_DL_SRC: - memcpy(ofpact_put_SET_ETH_SRC(out)->mac, - ((const struct ofp_action_dl_addr *) a)->dl_addr, ETH_ADDR_LEN); + memcpy(ofpact_put_SET_ETH_SRC(out)->mac, a->dl_addr.dl_addr, + ETH_ADDR_LEN); break; case OFPUTIL_OFPAT11_SET_DL_DST: - memcpy(ofpact_put_SET_ETH_DST(out)->mac, - ((const struct ofp_action_dl_addr *) a)->dl_addr, ETH_ADDR_LEN); + memcpy(ofpact_put_SET_ETH_DST(out)->mac, a->dl_addr.dl_addr, + ETH_ADDR_LEN); break; case OFPUTIL_OFPAT11_DEC_NW_TTL: @@ -711,7 +846,18 @@ ofpact_from_openflow11(const union ofp_action *a, struct ofpbuf *out) if (a->nw_tos.nw_tos & ~IP_DSCP_MASK) { return OFPERR_OFPBAC_BAD_ARGUMENT; } - ofpact_put_SET_IPV4_DSCP(out)->dscp = a->nw_tos.nw_tos; + ofpact_put_SET_IP_DSCP(out)->dscp = a->nw_tos.nw_tos; + break; + + case OFPUTIL_OFPAT11_SET_NW_ECN: + if (a->nw_ecn.nw_ecn & ~IP_ECN_MASK) { + return OFPERR_OFPBAC_BAD_ARGUMENT; + } + ofpact_put_SET_IP_ECN(out)->ecn = a->nw_ecn.nw_ecn; + break; + + case OFPUTIL_OFPAT11_SET_NW_TTL: + ofpact_put_SET_IP_TTL(out)->ttl = a->nw_ttl.nw_ttl; break; case OFPUTIL_OFPAT11_SET_TP_SRC: @@ -723,8 +869,31 @@ ofpact_from_openflow11(const union ofp_action *a, struct ofpbuf *out) break; case OFPUTIL_OFPAT12_SET_FIELD: - return nxm_reg_load_from_openflow12_set_field( - (const struct ofp12_action_set_field *)a, out); + return nxm_reg_load_from_openflow12_set_field(&a->set_field, out); + + case OFPUTIL_OFPAT11_SET_MPLS_TTL: + ofpact_put_SET_MPLS_TTL(out)->ttl = a->ofp11_mpls_ttl.mpls_ttl; + break; + + case OFPUTIL_OFPAT11_DEC_MPLS_TTL: + ofpact_put_DEC_MPLS_TTL(out); + break; + + case OFPUTIL_OFPAT11_PUSH_MPLS: + error = push_mpls_from_openflow(a->push.ethertype, + OFPACT_MPLS_AFTER_VLAN, out); + break; + + case OFPUTIL_OFPAT11_POP_MPLS: + if (eth_type_mpls(a->ofp11_pop_mpls.ethertype)) { + return OFPERR_OFPBAC_BAD_ARGUMENT; + } + ofpact_put_POP_MPLS(out)->ethertype = a->ofp11_pop_mpls.ethertype; + break; + + case OFPUTIL_OFPAT11_GROUP: + ofpact_put_GROUP(out)->group_id = ntohl(a->group.group_id); + break; #define NXAST_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM: #include "ofp-util.def" @@ -740,18 +909,278 @@ ofpacts_from_openflow11(const union ofp_action *in, size_t n_in, { return ofpacts_from_openflow(in, n_in, out, ofpact_from_openflow11); } + +/* True if an action sets the value of a field + * in a way that is compatibile with the action set. + * False otherwise. */ +static bool +ofpact_is_set_action(const struct ofpact *a) +{ + switch (a->type) { + case OFPACT_REG_LOAD: + case OFPACT_SET_ETH_DST: + case OFPACT_SET_ETH_SRC: + case OFPACT_SET_IP_DSCP: + case OFPACT_SET_IP_ECN: + case OFPACT_SET_IP_TTL: + case OFPACT_SET_IPV4_DST: + case OFPACT_SET_IPV4_SRC: + case OFPACT_SET_L4_DST_PORT: + case OFPACT_SET_L4_SRC_PORT: + case OFPACT_SET_MPLS_TTL: + case OFPACT_SET_QUEUE: + case OFPACT_SET_TUNNEL: + case OFPACT_SET_VLAN_PCP: + case OFPACT_SET_VLAN_VID: + return true; + case OFPACT_BUNDLE: + case OFPACT_CLEAR_ACTIONS: + case OFPACT_CONTROLLER: + case OFPACT_DEC_MPLS_TTL: + case OFPACT_DEC_TTL: + case OFPACT_ENQUEUE: + case OFPACT_EXIT: + case OFPACT_FIN_TIMEOUT: + case OFPACT_GOTO_TABLE: + case OFPACT_GROUP: + case OFPACT_LEARN: + case OFPACT_METER: + case OFPACT_MULTIPATH: + case OFPACT_NOTE: + case OFPACT_OUTPUT: + case OFPACT_OUTPUT_REG: + case OFPACT_POP_MPLS: + case OFPACT_POP_QUEUE: + case OFPACT_PUSH_MPLS: + case OFPACT_PUSH_VLAN: + case OFPACT_REG_MOVE: + case OFPACT_RESUBMIT: + case OFPACT_SAMPLE: + case OFPACT_STACK_POP: + case OFPACT_STACK_PUSH: + case OFPACT_STRIP_VLAN: + case OFPACT_WRITE_ACTIONS: + case OFPACT_WRITE_METADATA: + return false; + default: + NOT_REACHED(); + } +} + +/* True if an action is allowed in the action set. + * False otherwise. */ +static bool +ofpact_is_allowed_in_actions_set(const struct ofpact *a) +{ + switch (a->type) { + case OFPACT_DEC_MPLS_TTL: + case OFPACT_DEC_TTL: + case OFPACT_GROUP: + case OFPACT_OUTPUT: + case OFPACT_POP_MPLS: + case OFPACT_PUSH_MPLS: + case OFPACT_PUSH_VLAN: + case OFPACT_REG_LOAD: + case OFPACT_SET_ETH_DST: + case OFPACT_SET_ETH_SRC: + case OFPACT_SET_IP_DSCP: + case OFPACT_SET_IP_ECN: + case OFPACT_SET_IP_TTL: + case OFPACT_SET_IPV4_DST: + case OFPACT_SET_IPV4_SRC: + case OFPACT_SET_L4_DST_PORT: + case OFPACT_SET_L4_SRC_PORT: + case OFPACT_SET_MPLS_TTL: + case OFPACT_SET_QUEUE: + case OFPACT_SET_TUNNEL: + case OFPACT_SET_VLAN_PCP: + case OFPACT_SET_VLAN_VID: + case OFPACT_STRIP_VLAN: + return true; + + /* In general these actions are excluded because they are not part of + * the OpenFlow specification nor map to actions that are defined in + * the specification. Thus the order in which they should be applied + * in the action set is undefined. */ + case OFPACT_BUNDLE: + case OFPACT_CONTROLLER: + case OFPACT_ENQUEUE: + case OFPACT_EXIT: + case OFPACT_FIN_TIMEOUT: + case OFPACT_LEARN: + case OFPACT_MULTIPATH: + case OFPACT_NOTE: + case OFPACT_OUTPUT_REG: + case OFPACT_POP_QUEUE: + case OFPACT_REG_MOVE: + case OFPACT_RESUBMIT: + case OFPACT_SAMPLE: + case OFPACT_STACK_POP: + case OFPACT_STACK_PUSH: + + /* The action set may only include actions and thus + * may not include any instructions */ + case OFPACT_CLEAR_ACTIONS: + case OFPACT_GOTO_TABLE: + case OFPACT_METER: + case OFPACT_WRITE_ACTIONS: + case OFPACT_WRITE_METADATA: + return false; + default: + NOT_REACHED(); + } +} + +/* Append ofpact 'a' onto the tail of 'out' */ +static void +ofpact_copy(struct ofpbuf *out, const struct ofpact *a) +{ + ofpbuf_put(out, a, OFPACT_ALIGN(a->len)); +} + +/* Copies the last ofpact whose type is 'filter' from 'in' to 'out'. */ +static bool +ofpacts_copy_last(struct ofpbuf *out, const struct ofpbuf *in, + enum ofpact_type filter) +{ + const struct ofpact *target; + const struct ofpact *a; + + target = NULL; + OFPACT_FOR_EACH (a, in->data, in->size) { + if (a->type == filter) { + target = a; + } + } + if (target) { + ofpact_copy(out, target); + } + return target != NULL; +} + +/* Append all ofpacts, for which 'filter' returns true, from 'in' to 'out'. + * The order of appended ofpacts is preserved between 'in' and 'out' */ +static void +ofpacts_copy_all(struct ofpbuf *out, const struct ofpbuf *in, + bool (*filter)(const struct ofpact *)) +{ + const struct ofpact *a; + + OFPACT_FOR_EACH (a, in->data, in->size) { + if (filter(a)) { + ofpact_copy(out, a); + } + } +} + +/* Reads 'action_set', which contains ofpacts accumulated by + * OFPACT_WRITE_ACTIONS instructions, and writes equivalent actions to be + * executed directly into 'action_list'. (These names correspond to the + * "Action Set" and "Action List" terms used in OpenFlow 1.1+.) + * + * In general this involves appending the last instance of each action that is + * adimissible in the action set in the order described in the OpenFlow + * specification. + * + * Exceptions: + * + output action is only appended if no group action was present in 'in'. + * + As a simplification all set actions are copied in the order the are + * provided in 'in' as many set actions applied to a field has the same + * affect as only applying the last action that sets a field and + * duplicates are removed by do_xlate_actions(). + * This has an unwanted side-effect of compsoting multiple + * LOAD_REG actions that touch different regions of the same field. */ +void +ofpacts_execute_action_set(struct ofpbuf *action_list, + const struct ofpbuf *action_set) +{ + /* The OpenFlow spec "Action Set" section specifies this order. */ + ofpacts_copy_last(action_list, action_set, OFPACT_STRIP_VLAN); + ofpacts_copy_last(action_list, action_set, OFPACT_POP_MPLS); + ofpacts_copy_last(action_list, action_set, OFPACT_PUSH_MPLS); + ofpacts_copy_last(action_list, action_set, OFPACT_PUSH_VLAN); + ofpacts_copy_last(action_list, action_set, OFPACT_DEC_TTL); + ofpacts_copy_last(action_list, action_set, OFPACT_DEC_MPLS_TTL); + ofpacts_copy_all(action_list, action_set, ofpact_is_set_action); + ofpacts_copy_last(action_list, action_set, OFPACT_SET_QUEUE); + + /* If both OFPACT_GROUP and OFPACT_OUTPUT are present, OpenFlow says that + * we should execute only OFPACT_GROUP. + * + * If neither OFPACT_GROUP nor OFPACT_OUTPUT is present, then we can drop + * all the actions because there's no point in modifying a packet that will + * not be sent anywhere. */ + if (!ofpacts_copy_last(action_list, action_set, OFPACT_GROUP) && + !ofpacts_copy_last(action_list, action_set, OFPACT_OUTPUT)) { + ofpbuf_clear(action_list); + } +} + + +static enum ofperr +ofpacts_from_openflow11_for_action_set(const union ofp_action *in, + size_t n_in, struct ofpbuf *out) +{ + enum ofperr error; + struct ofpact *a; + size_t start = out->size; + + error = ofpacts_from_openflow11(in, n_in, out); + if (error) { + return error; + } + + OFPACT_FOR_EACH (a, ofpact_end(out->data, start), out->size - start) { + if (!ofpact_is_allowed_in_actions_set(a)) { + VLOG_WARN_RL(&rl, "disallowed action in action set"); + return OFPERR_OFPBAC_BAD_TYPE; + } + } + + return 0; +} + + +static enum ofperr +ofpact_from_openflow13(const union ofp_action *a, struct ofpbuf *out) +{ + enum ofputil_action_code code; + enum ofperr error; + + error = decode_openflow11_action(a, &code); + if (error) { + return error; + } + + if (code == OFPUTIL_OFPAT11_PUSH_MPLS) { + struct ofp11_action_push *oap = (struct ofp11_action_push *)a; + error = push_mpls_from_openflow(oap->ethertype, + OFPACT_MPLS_BEFORE_VLAN, out); + } else { + error = ofpact_from_openflow11(a, out); + } + + return error; +} + +static enum ofperr +ofpacts_from_openflow13(const union ofp_action *in, size_t n_in, + struct ofpbuf *out) +{ + return ofpacts_from_openflow(in, n_in, out, ofpact_from_openflow13); +} /* OpenFlow 1.1 instructions. */ #define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME) \ - static inline const struct STRUCT * \ + static inline const struct STRUCT * OVS_UNUSED \ instruction_get_##ENUM(const struct ofp11_instruction *inst)\ { \ - assert(inst->type == htons(ENUM)); \ - return (struct STRUCT *)inst; \ + ovs_assert(inst->type == htons(ENUM)); \ + return ALIGNED_CAST(struct STRUCT *, inst); \ } \ \ - static inline void \ + static inline void OVS_UNUSED \ instruction_init_##ENUM(struct STRUCT *s) \ { \ memset(s, 0, sizeof *s); \ @@ -759,7 +1188,7 @@ ofpacts_from_openflow11(const union ofp_action *in, size_t n_in, s->len = htons(sizeof *s); \ } \ \ - static inline struct STRUCT * \ + static inline struct STRUCT * OVS_UNUSED \ instruction_put_##ENUM(struct ofpbuf *buf) \ { \ struct STRUCT *s = ofpbuf_put_uninit(buf, sizeof *s); \ @@ -781,13 +1210,13 @@ OVS_INSTRUCTIONS }; const char * -ofpact_instruction_name_from_type(enum ovs_instruction_type type) +ovs_instruction_name_from_type(enum ovs_instruction_type type) { return inst_info[type].name; } int -ofpact_instruction_type_from_name(const char *name) +ovs_instruction_type_from_name(const char *name) { const struct instruction_type_info *p; for (p = inst_info; p < &inst_info[ARRAY_SIZE(inst_info)]; p++) { @@ -798,6 +1227,63 @@ ofpact_instruction_type_from_name(const char *name) return -1; } +enum ovs_instruction_type +ovs_instruction_type_from_ofpact_type(enum ofpact_type type) +{ + switch (type) { + case OFPACT_METER: + return OVSINST_OFPIT13_METER; + case OFPACT_CLEAR_ACTIONS: + return OVSINST_OFPIT11_CLEAR_ACTIONS; + case OFPACT_WRITE_ACTIONS: + return OVSINST_OFPIT11_WRITE_ACTIONS; + case OFPACT_WRITE_METADATA: + return OVSINST_OFPIT11_WRITE_METADATA; + case OFPACT_GOTO_TABLE: + return OVSINST_OFPIT11_GOTO_TABLE; + case OFPACT_OUTPUT: + case OFPACT_GROUP: + case OFPACT_CONTROLLER: + case OFPACT_ENQUEUE: + case OFPACT_OUTPUT_REG: + case OFPACT_BUNDLE: + case OFPACT_SET_VLAN_VID: + case OFPACT_SET_VLAN_PCP: + case OFPACT_STRIP_VLAN: + case OFPACT_PUSH_VLAN: + case OFPACT_SET_ETH_SRC: + case OFPACT_SET_ETH_DST: + case OFPACT_SET_IPV4_SRC: + case OFPACT_SET_IPV4_DST: + case OFPACT_SET_IP_DSCP: + case OFPACT_SET_IP_ECN: + case OFPACT_SET_IP_TTL: + case OFPACT_SET_L4_SRC_PORT: + case OFPACT_SET_L4_DST_PORT: + case OFPACT_REG_MOVE: + case OFPACT_REG_LOAD: + case OFPACT_STACK_PUSH: + case OFPACT_STACK_POP: + case OFPACT_DEC_TTL: + case OFPACT_SET_MPLS_TTL: + case OFPACT_DEC_MPLS_TTL: + case OFPACT_PUSH_MPLS: + case OFPACT_POP_MPLS: + case OFPACT_SET_TUNNEL: + case OFPACT_SET_QUEUE: + case OFPACT_POP_QUEUE: + case OFPACT_FIN_TIMEOUT: + case OFPACT_RESUBMIT: + case OFPACT_LEARN: + case OFPACT_MULTIPATH: + case OFPACT_NOTE: + case OFPACT_EXIT: + case OFPACT_SAMPLE: + default: + return OVSINST_OFPIT11_APPLY_ACTIONS; + } +} + static inline struct ofp11_instruction * instruction_next(const struct ofp11_instruction *inst) { @@ -870,7 +1356,7 @@ decode_openflow11_instructions(const struct ofp11_instruction insts[], } if (out[type]) { - return OFPERR_OFPIT_BAD_INSTRUCTION; + return OFPERR_ONFBIC_DUP_INSTRUCTION; } out[type] = inst; } @@ -885,18 +1371,21 @@ decode_openflow11_instructions(const struct ofp11_instruction insts[], static void get_actions_from_instruction(const struct ofp11_instruction *inst, - const union ofp_action **actions, - size_t *n_actions) + const union ofp_action **actions, + size_t *max_actions) { - *actions = (const union ofp_action *) (inst + 1); - *n_actions = (ntohs(inst->len) - sizeof *inst) / OFP11_INSTRUCTION_ALIGN; + *actions = ALIGNED_CAST(const union ofp_action *, inst + 1); + *max_actions = (ntohs(inst->len) - sizeof *inst) / OFP11_INSTRUCTION_ALIGN; } -/* Attempts to convert 'actions_len' bytes of OpenFlow 1.1 actions from the +/* Attempts to convert 'actions_len' bytes of OpenFlow actions from the * front of 'openflow' into ofpacts. On success, replaces any existing content * in 'ofpacts' by the converted ofpacts; on failure, clears 'ofpacts'. * Returns 0 if successful, otherwise an OpenFlow error. * + * Actions are processed according to their OpenFlow version which + * is provided in the 'version' parameter. + * * In most places in OpenFlow 1.1 and 1.2, actions appear encapsulated in * instructions, so you should call ofpacts_pull_openflow11_instructions() * instead of this function. @@ -908,15 +1397,27 @@ get_actions_from_instruction(const struct ofp11_instruction *inst, * valid in a specific context. */ enum ofperr ofpacts_pull_openflow11_actions(struct ofpbuf *openflow, + enum ofp_version version, unsigned int actions_len, struct ofpbuf *ofpacts) { - return ofpacts_pull_actions(openflow, actions_len, ofpacts, - ofpacts_from_openflow11); + switch (version) { + case OFP10_VERSION: + case OFP11_VERSION: + case OFP12_VERSION: + return ofpacts_pull_actions(openflow, actions_len, ofpacts, + ofpacts_from_openflow11); + case OFP13_VERSION: + return ofpacts_pull_actions(openflow, actions_len, ofpacts, + ofpacts_from_openflow13); + default: + NOT_REACHED(); + } } enum ofperr ofpacts_pull_openflow11_instructions(struct ofpbuf *openflow, + enum ofp_version version, unsigned int instructions_len, struct ofpbuf *ofpacts) { @@ -951,13 +1452,34 @@ ofpacts_pull_openflow11_instructions(struct ofpbuf *openflow, goto exit; } + if (insts[OVSINST_OFPIT13_METER]) { + const struct ofp13_instruction_meter *oim; + struct ofpact_meter *om; + + oim = ALIGNED_CAST(const struct ofp13_instruction_meter *, + insts[OVSINST_OFPIT13_METER]); + + om = ofpact_put_METER(ofpacts); + om->meter_id = ntohl(oim->meter_id); + } if (insts[OVSINST_OFPIT11_APPLY_ACTIONS]) { const union ofp_action *actions; - size_t n_actions; + size_t max_actions; get_actions_from_instruction(insts[OVSINST_OFPIT11_APPLY_ACTIONS], - &actions, &n_actions); - error = ofpacts_from_openflow11(actions, n_actions, ofpacts); + &actions, &max_actions); + switch (version) { + case OFP10_VERSION: + case OFP11_VERSION: + case OFP12_VERSION: + error = ofpacts_from_openflow11(actions, max_actions, ofpacts); + break; + case OFP13_VERSION: + error = ofpacts_from_openflow13(actions, max_actions, ofpacts); + break; + default: + NOT_REACHED(); + } if (error) { goto exit; } @@ -967,8 +1489,37 @@ ofpacts_pull_openflow11_instructions(struct ofpbuf *openflow, insts[OVSINST_OFPIT11_CLEAR_ACTIONS]); ofpact_put_CLEAR_ACTIONS(ofpacts); } - /* TODO:XXX Write-Actions */ - /* TODO:XXX Write-Metadata */ + if (insts[OVSINST_OFPIT11_WRITE_ACTIONS]) { + struct ofpact_nest *on; + const union ofp_action *actions; + size_t max_actions; + size_t start; + + ofpact_pad(ofpacts); + start = ofpacts->size; + on = ofpact_put(ofpacts, OFPACT_WRITE_ACTIONS, + offsetof(struct ofpact_nest, actions)); + get_actions_from_instruction(insts[OVSINST_OFPIT11_WRITE_ACTIONS], + &actions, &max_actions); + error = ofpacts_from_openflow11_for_action_set(actions, max_actions, + ofpacts); + if (error) { + goto exit; + } + on = ofpbuf_at_assert(ofpacts, start, sizeof *on); + on->ofpact.len = ofpacts->size - start; + } + if (insts[OVSINST_OFPIT11_WRITE_METADATA]) { + const struct ofp11_instruction_write_metadata *oiwm; + struct ofpact_metadata *om; + + oiwm = ALIGNED_CAST(const struct ofp11_instruction_write_metadata *, + insts[OVSINST_OFPIT11_WRITE_METADATA]); + + om = ofpact_put_WRITE_METADATA(ofpacts); + om->metadata = oiwm->metadata; + om->mask = oiwm->metadata_mask; + } if (insts[OVSINST_OFPIT11_GOTO_TABLE]) { const struct ofp11_instruction_goto_table *oigt; struct ofpact_goto_table *ogt; @@ -979,12 +1530,7 @@ ofpacts_pull_openflow11_instructions(struct ofpbuf *openflow, ogt->table_id = oigt->table_id; } - if (insts[OVSINST_OFPIT11_WRITE_METADATA] || - insts[OVSINST_OFPIT11_WRITE_ACTIONS]) { - error = OFPERR_OFPBIC_UNSUP_INST; - goto exit; - } - + error = ofpacts_verify(ofpacts->data, ofpacts->size); exit: if (error) { ofpbuf_clear(ofpacts); @@ -992,8 +1538,10 @@ exit: return error; } +/* May modify flow->dl_type, caller must restore it. */ static enum ofperr -ofpact_check__(const struct ofpact *a, const struct flow *flow, int max_ports) +ofpact_check__(const struct ofpact *a, struct flow *flow, ofp_port_t max_ports, + uint8_t table_id, bool enforce_consistency) { const struct ofpact_enqueue *enqueue; @@ -1007,7 +1555,8 @@ ofpact_check__(const struct ofpact *a, const struct flow *flow, int max_ports) case OFPACT_ENQUEUE: enqueue = ofpact_get_ENQUEUE(a); - if (enqueue->port >= max_ports && enqueue->port != OFPP_IN_PORT + if (ofp_to_u16(enqueue->port) >= ofp_to_u16(max_ports) + && enqueue->port != OFPP_IN_PORT && enqueue->port != OFPP_LOCAL) { return OFPERR_OFPBAC_BAD_OUT_PORT; } @@ -1021,14 +1570,48 @@ ofpact_check__(const struct ofpact *a, const struct flow *flow, int max_ports) case OFPACT_SET_VLAN_VID: case OFPACT_SET_VLAN_PCP: + return 0; + case OFPACT_STRIP_VLAN: + if (!(flow->vlan_tci & htons(VLAN_CFI))) { + goto inconsistent; + } + return 0; + + case OFPACT_PUSH_VLAN: + if (flow->vlan_tci & htons(VLAN_CFI)) { + /* Multiple VLAN headers not supported. */ + return OFPERR_OFPBAC_BAD_TAG; + } + return 0; + case OFPACT_SET_ETH_SRC: case OFPACT_SET_ETH_DST: + return 0; + case OFPACT_SET_IPV4_SRC: case OFPACT_SET_IPV4_DST: - case OFPACT_SET_IPV4_DSCP: + if (flow->dl_type != htons(ETH_TYPE_IP)) { + goto inconsistent; + } + return 0; + + case OFPACT_SET_IP_DSCP: + case OFPACT_SET_IP_ECN: + case OFPACT_SET_IP_TTL: + case OFPACT_DEC_TTL: + if (!is_ip_any(flow)) { + goto inconsistent; + } + return 0; + case OFPACT_SET_L4_SRC_PORT: case OFPACT_SET_L4_DST_PORT: + if (!is_ip_any(flow) || + (flow->nw_proto != IPPROTO_TCP && flow->nw_proto != IPPROTO_UDP + && flow->nw_proto != IPPROTO_SCTP)) { + goto inconsistent; + } return 0; case OFPACT_REG_MOVE: @@ -1037,50 +1620,151 @@ ofpact_check__(const struct ofpact *a, const struct flow *flow, int max_ports) case OFPACT_REG_LOAD: return nxm_reg_load_check(ofpact_get_REG_LOAD(a), flow); - case OFPACT_DEC_TTL: + case OFPACT_STACK_PUSH: + return nxm_stack_push_check(ofpact_get_STACK_PUSH(a), flow); + + case OFPACT_STACK_POP: + return nxm_stack_pop_check(ofpact_get_STACK_POP(a), flow); + + case OFPACT_SET_MPLS_TTL: + case OFPACT_DEC_MPLS_TTL: + if (!eth_type_mpls(flow->dl_type)) { + goto inconsistent; + } + return 0; + case OFPACT_SET_TUNNEL: case OFPACT_SET_QUEUE: case OFPACT_POP_QUEUE: - case OFPACT_FIN_TIMEOUT: case OFPACT_RESUBMIT: return 0; + case OFPACT_FIN_TIMEOUT: + if (flow->nw_proto != IPPROTO_TCP) { + goto inconsistent; + } + return 0; + case OFPACT_LEARN: return learn_check(ofpact_get_LEARN(a), flow); case OFPACT_MULTIPATH: return multipath_check(ofpact_get_MULTIPATH(a), flow); - case OFPACT_AUTOPATH: - return autopath_check(ofpact_get_AUTOPATH(a), flow); - case OFPACT_NOTE: case OFPACT_EXIT: return 0; + case OFPACT_PUSH_MPLS: + flow->dl_type = ofpact_get_PUSH_MPLS(a)->ethertype; + return 0; + + case OFPACT_POP_MPLS: + flow->dl_type = ofpact_get_POP_MPLS(a)->ethertype; + if (!eth_type_mpls(flow->dl_type)) { + goto inconsistent; + } + return 0; + + case OFPACT_SAMPLE: + return 0; + case OFPACT_CLEAR_ACTIONS: + return 0; + + case OFPACT_WRITE_ACTIONS: { + struct ofpact_nest *on = ofpact_get_WRITE_ACTIONS(a); + return ofpacts_check(on->actions, ofpact_nest_get_action_len(on), + flow, max_ports, table_id, false); + } + + case OFPACT_WRITE_METADATA: + return 0; + + case OFPACT_METER: { + uint32_t mid = ofpact_get_METER(a)->meter_id; + if (mid == 0 || mid > OFPM13_MAX) { + return OFPERR_OFPMMFC_INVALID_METER; + } + return 0; + } + case OFPACT_GOTO_TABLE: + if (ofpact_get_GOTO_TABLE(a)->table_id <= table_id) { + return OFPERR_OFPBRC_BAD_TABLE_ID; + } + return 0; + + case OFPACT_GROUP: return 0; default: NOT_REACHED(); } + + inconsistent: + if (enforce_consistency) { + return OFPERR_OFPBAC_MATCH_INCONSISTENT; + } + return 0; } /* Checks that the 'ofpacts_len' bytes of actions in 'ofpacts' are * appropriate for a packet with the prerequisites satisfied by 'flow' in a - * switch with no more than 'max_ports' ports. */ + * switch with no more than 'max_ports' ports. + * + * May temporarily modify 'flow', but restores the changes before returning. */ enum ofperr ofpacts_check(const struct ofpact ofpacts[], size_t ofpacts_len, - const struct flow *flow, int max_ports) + struct flow *flow, ofp_port_t max_ports, uint8_t table_id, + bool enforce_consistency) { const struct ofpact *a; + ovs_be16 dl_type = flow->dl_type; + enum ofperr error = 0; OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) { - enum ofperr error = ofpact_check__(a, flow, max_ports); + error = ofpact_check__(a, flow, max_ports, table_id, + enforce_consistency); if (error) { - return error; + break; + } + } + flow->dl_type = dl_type; /* Restore. */ + return error; +} + +/* Verifies that the 'ofpacts_len' bytes of actions in 'ofpacts' are + * in the appropriate order as defined by the OpenFlow spec. */ +enum ofperr +ofpacts_verify(const struct ofpact ofpacts[], size_t ofpacts_len) +{ + const struct ofpact *a; + enum ovs_instruction_type inst; + + inst = OVSINST_OFPIT11_APPLY_ACTIONS; + OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) { + enum ovs_instruction_type next; + + next = ovs_instruction_type_from_ofpact_type(a->type); + if (inst == OVSINST_OFPIT11_APPLY_ACTIONS + ? next < inst + : next <= inst) { + const char *name = ovs_instruction_name_from_type(inst); + const char *next_name = ovs_instruction_name_from_type(next); + + if (next == inst) { + VLOG_WARN("duplicate %s instruction not allowed, for OpenFlow " + "1.1+ compatibility", name); + } else { + VLOG_WARN("invalid instruction ordering: %s must appear " + "before %s, for OpenFlow 1.1+ compatibility", + next_name, name); + } + return OFPERR_OFPBAC_UNSUPPORTED_ORDER; } + + inst = next; } return 0; @@ -1113,7 +1797,7 @@ ofpact_resubmit_to_nxast(const struct ofpact_resubmit *resubmit, nar = ofputil_put_NXAST_RESUBMIT_TABLE(out); nar->table = resubmit->table_id; } - nar->in_port = htons(resubmit->in_port); + nar->in_port = htons(ofp_to_u16(resubmit->in_port)); } static void @@ -1130,6 +1814,17 @@ ofpact_set_tunnel_to_nxast(const struct ofpact_tunnel *tunnel, } } +static void +ofpact_write_metadata_to_nxast(const struct ofpact_metadata *om, + struct ofpbuf *out) +{ + struct nx_action_write_metadata *nawm; + + nawm = ofputil_put_NXAST_WRITE_METADATA(out); + nawm->metadata = om->metadata; + nawm->mask = om->mask; +} + static void ofpact_note_to_nxast(const struct ofpact_note *note, struct ofpbuf *out) { @@ -1148,7 +1843,7 @@ ofpact_note_to_nxast(const struct ofpact_note *note, struct ofpbuf *out) if (remainder) { ofpbuf_put_zeros(out, OFP_ACTION_ALIGN - remainder); } - nan = (struct nx_action_note *)((char *)out->data + start_ofs); + nan = ofpbuf_at(out, start_ofs, sizeof *nan); nan->len = htons(out->size - start_ofs); } @@ -1196,6 +1891,19 @@ ofpact_fin_timeout_to_nxast(const struct ofpact_fin_timeout *fin_timeout, naft->fin_hard_timeout = htons(fin_timeout->fin_hard_timeout); } +static void +ofpact_sample_to_nxast(const struct ofpact_sample *os, + struct ofpbuf *out) +{ + struct nx_action_sample *nas; + + nas = ofputil_put_NXAST_SAMPLE(out); + nas->probability = htons(os->probability); + nas->collector_set_id = htonl(os->collector_set_id); + nas->obs_domain_id = htonl(os->obs_domain_id); + nas->obs_point_id = htonl(os->obs_point_id); +} + static void ofpact_to_nxast(const struct ofpact *a, struct ofpbuf *out) { @@ -1220,14 +1928,35 @@ ofpact_to_nxast(const struct ofpact *a, struct ofpbuf *out) nxm_reg_load_to_nxast(ofpact_get_REG_LOAD(a), out); break; + case OFPACT_STACK_PUSH: + nxm_stack_push_to_nxast(ofpact_get_STACK_PUSH(a), out); + break; + + case OFPACT_STACK_POP: + nxm_stack_pop_to_nxast(ofpact_get_STACK_POP(a), out); + break; + case OFPACT_DEC_TTL: ofpact_dec_ttl_to_nxast(ofpact_get_DEC_TTL(a), out); break; + case OFPACT_SET_MPLS_TTL: + ofputil_put_NXAST_SET_MPLS_TTL(out)->ttl + = ofpact_get_SET_MPLS_TTL(a)->ttl; + break; + + case OFPACT_DEC_MPLS_TTL: + ofputil_put_NXAST_DEC_MPLS_TTL(out); + break; + case OFPACT_SET_TUNNEL: ofpact_set_tunnel_to_nxast(ofpact_get_SET_TUNNEL(a), out); break; + case OFPACT_WRITE_METADATA: + ofpact_write_metadata_to_nxast(ofpact_get_WRITE_METADATA(a), out); + break; + case OFPACT_SET_QUEUE: ofputil_put_NXAST_SET_QUEUE(out)->queue_id = htonl(ofpact_get_SET_QUEUE(a)->queue_id); @@ -1253,10 +1982,6 @@ ofpact_to_nxast(const struct ofpact *a, struct ofpbuf *out) multipath_to_nxast(ofpact_get_MULTIPATH(a), out); break; - case OFPACT_AUTOPATH: - autopath_to_nxast(ofpact_get_AUTOPATH(a), out); - break; - case OFPACT_NOTE: ofpact_note_to_nxast(ofpact_get_NOTE(a), out); break; @@ -1265,20 +1990,40 @@ ofpact_to_nxast(const struct ofpact *a, struct ofpbuf *out) ofputil_put_NXAST_EXIT(out); break; + case OFPACT_PUSH_MPLS: + ofputil_put_NXAST_PUSH_MPLS(out)->ethertype = + ofpact_get_PUSH_MPLS(a)->ethertype; + break; + + case OFPACT_POP_MPLS: + ofputil_put_NXAST_POP_MPLS(out)->ethertype = + ofpact_get_POP_MPLS(a)->ethertype; + break; + + case OFPACT_SAMPLE: + ofpact_sample_to_nxast(ofpact_get_SAMPLE(a), out); + break; + + case OFPACT_GROUP: case OFPACT_OUTPUT: case OFPACT_ENQUEUE: case OFPACT_SET_VLAN_VID: case OFPACT_SET_VLAN_PCP: case OFPACT_STRIP_VLAN: + case OFPACT_PUSH_VLAN: case OFPACT_SET_ETH_SRC: case OFPACT_SET_ETH_DST: case OFPACT_SET_IPV4_SRC: case OFPACT_SET_IPV4_DST: - case OFPACT_SET_IPV4_DSCP: + case OFPACT_SET_IP_DSCP: + case OFPACT_SET_IP_ECN: + case OFPACT_SET_IP_TTL: case OFPACT_SET_L4_SRC_PORT: case OFPACT_SET_L4_DST_PORT: + case OFPACT_WRITE_ACTIONS: case OFPACT_CLEAR_ACTIONS: case OFPACT_GOTO_TABLE: + case OFPACT_METER: NOT_REACHED(); } } @@ -1292,7 +2037,7 @@ ofpact_output_to_openflow10(const struct ofpact_output *output, struct ofp10_action_output *oao; oao = ofputil_put_OFPAT10_OUTPUT(out); - oao->port = htons(output->port); + oao->port = htons(ofp_to_u16(output->port)); oao->max_len = htons(output->max_len); } @@ -1300,10 +2045,10 @@ static void ofpact_enqueue_to_openflow10(const struct ofpact_enqueue *enqueue, struct ofpbuf *out) { - struct ofp_action_enqueue *oae; + struct ofp10_action_enqueue *oae; oae = ofputil_put_OFPAT10_ENQUEUE(out); - oae->port = htons(enqueue->port); + oae->port = htons(ofp_to_u16(enqueue->port)); oae->queue_id = htonl(enqueue->queue); } @@ -1353,9 +2098,9 @@ ofpact_to_openflow10(const struct ofpact *a, struct ofpbuf *out) = ofpact_get_SET_IPV4_DST(a)->ipv4; break; - case OFPACT_SET_IPV4_DSCP: + case OFPACT_SET_IP_DSCP: ofputil_put_OFPAT10_SET_NW_TOS(out)->nw_tos - = ofpact_get_SET_IPV4_DSCP(a)->dscp; + = ofpact_get_SET_IP_DSCP(a)->dscp; break; case OFPACT_SET_L4_SRC_PORT: @@ -1368,9 +2113,15 @@ ofpact_to_openflow10(const struct ofpact *a, struct ofpbuf *out) = htons(ofpact_get_SET_L4_DST_PORT(a)->port); break; + case OFPACT_PUSH_VLAN: case OFPACT_CLEAR_ACTIONS: + case OFPACT_WRITE_ACTIONS: case OFPACT_GOTO_TABLE: - /* TODO:XXX */ + case OFPACT_METER: + /* XXX */ + break; + + case OFPACT_GROUP: break; case OFPACT_CONTROLLER: @@ -1378,17 +2129,26 @@ ofpact_to_openflow10(const struct ofpact *a, struct ofpbuf *out) case OFPACT_BUNDLE: case OFPACT_REG_MOVE: case OFPACT_REG_LOAD: + case OFPACT_STACK_PUSH: + case OFPACT_STACK_POP: case OFPACT_DEC_TTL: + case OFPACT_SET_IP_ECN: + case OFPACT_SET_IP_TTL: + case OFPACT_SET_MPLS_TTL: + case OFPACT_DEC_MPLS_TTL: case OFPACT_SET_TUNNEL: + case OFPACT_WRITE_METADATA: case OFPACT_SET_QUEUE: case OFPACT_POP_QUEUE: case OFPACT_FIN_TIMEOUT: case OFPACT_RESUBMIT: case OFPACT_LEARN: case OFPACT_MULTIPATH: - case OFPACT_AUTOPATH: case OFPACT_NOTE: case OFPACT_EXIT: + case OFPACT_PUSH_MPLS: + case OFPACT_POP_MPLS: + case OFPACT_SAMPLE: ofpact_to_nxast(a, out); break; } @@ -1421,6 +2181,19 @@ ofpact_output_to_openflow11(const struct ofpact_output *output, oao->max_len = htons(output->max_len); } +static void +ofpact_dec_ttl_to_openflow11(const struct ofpact_cnt_ids *dec_ttl, + struct ofpbuf *out) +{ + if (dec_ttl->n_controllers == 1 && dec_ttl->cnt_ids[0] == 0 + && (!dec_ttl->ofpact.compat || + dec_ttl->ofpact.compat == OFPUTIL_OFPAT11_DEC_NW_TTL)) { + ofputil_put_OFPAT11_DEC_NW_TTL(out); + } else { + ofpact_dec_ttl_to_nxast(dec_ttl, out); + } +} + static void ofpact_to_openflow11(const struct ofpact *a, struct ofpbuf *out) { @@ -1443,7 +2216,18 @@ ofpact_to_openflow11(const struct ofpact *a, struct ofpbuf *out) break; case OFPACT_STRIP_VLAN: - /* XXX */ + ofputil_put_OFPAT11_POP_VLAN(out); + break; + + case OFPACT_PUSH_VLAN: + /* XXX ETH_TYPE_VLAN_8021AD case */ + ofputil_put_OFPAT11_PUSH_VLAN(out)->ethertype = + htons(ETH_TYPE_VLAN_8021Q); + break; + + case OFPACT_SET_QUEUE: + ofputil_put_OFPAT11_SET_QUEUE(out)->queue_id + = htonl(ofpact_get_SET_QUEUE(a)->queue_id); break; case OFPACT_SET_ETH_SRC: @@ -1466,9 +2250,19 @@ ofpact_to_openflow11(const struct ofpact *a, struct ofpbuf *out) = ofpact_get_SET_IPV4_DST(a)->ipv4; break; - case OFPACT_SET_IPV4_DSCP: + case OFPACT_SET_IP_DSCP: ofputil_put_OFPAT11_SET_NW_TOS(out)->nw_tos - = ofpact_get_SET_IPV4_DSCP(a)->dscp; + = ofpact_get_SET_IP_DSCP(a)->dscp; + break; + + case OFPACT_SET_IP_ECN: + ofputil_put_OFPAT11_SET_NW_ECN(out)->nw_ecn + = ofpact_get_SET_IP_ECN(a)->ecn; + break; + + case OFPACT_SET_IP_TTL: + ofputil_put_OFPAT11_SET_NW_TTL(out)->nw_ttl + = ofpact_get_SET_IP_TTL(a)->ttl; break; case OFPACT_SET_L4_SRC_PORT: @@ -1482,32 +2276,60 @@ ofpact_to_openflow11(const struct ofpact *a, struct ofpbuf *out) break; case OFPACT_DEC_TTL: - if (a->compat == OFPUTIL_OFPAT11_DEC_NW_TTL) { - ofputil_put_OFPAT11_DEC_NW_TTL(out); - } else { - ofpact_to_nxast(a, out); - } + ofpact_dec_ttl_to_openflow11(ofpact_get_DEC_TTL(a), out); + break; + + case OFPACT_SET_MPLS_TTL: + ofputil_put_OFPAT11_SET_MPLS_TTL(out)->mpls_ttl + = ofpact_get_SET_MPLS_TTL(a)->ttl; + break; + + case OFPACT_DEC_MPLS_TTL: + ofputil_put_OFPAT11_DEC_MPLS_TTL(out); + break; + + case OFPACT_WRITE_METADATA: + /* OpenFlow 1.1 uses OFPIT_WRITE_METADATA to express this action. */ + break; + + case OFPACT_PUSH_MPLS: + ofputil_put_OFPAT11_PUSH_MPLS(out)->ethertype = + ofpact_get_PUSH_MPLS(a)->ethertype; + break; + + case OFPACT_POP_MPLS: + ofputil_put_OFPAT11_POP_MPLS(out)->ethertype = + ofpact_get_POP_MPLS(a)->ethertype; + break; case OFPACT_CLEAR_ACTIONS: + case OFPACT_WRITE_ACTIONS: case OFPACT_GOTO_TABLE: + case OFPACT_METER: NOT_REACHED(); + case OFPACT_GROUP: + ofputil_put_OFPAT11_GROUP(out)->group_id = + htonl(ofpact_get_GROUP(a)->group_id); + break; + case OFPACT_CONTROLLER: case OFPACT_OUTPUT_REG: case OFPACT_BUNDLE: case OFPACT_REG_MOVE: case OFPACT_REG_LOAD: + case OFPACT_STACK_PUSH: + case OFPACT_STACK_POP: case OFPACT_SET_TUNNEL: - case OFPACT_SET_QUEUE: case OFPACT_POP_QUEUE: case OFPACT_FIN_TIMEOUT: case OFPACT_RESUBMIT: case OFPACT_LEARN: case OFPACT_MULTIPATH: - case OFPACT_AUTOPATH: case OFPACT_NOTE: case OFPACT_EXIT: + case OFPACT_SAMPLE: ofpact_to_nxast(a, out); break; } @@ -1552,18 +2374,41 @@ ofpacts_put_openflow11_instructions(const struct ofpact ofpacts[], const struct ofpact *a; OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) { - /* TODO:XXX Write-Actions */ - /* TODO:XXX Write-Metadata */ - if (a->type == OFPACT_CLEAR_ACTIONS) { + switch (ovs_instruction_type_from_ofpact_type(a->type)) { + case OVSINST_OFPIT11_CLEAR_ACTIONS: instruction_put_OFPIT11_CLEAR_ACTIONS(openflow); - } else if (a->type == OFPACT_GOTO_TABLE) { - struct ofp11_instruction_goto_table *oigt; + break; + case OVSINST_OFPIT11_GOTO_TABLE: { + struct ofp11_instruction_goto_table *oigt; oigt = instruction_put_OFPIT11_GOTO_TABLE(openflow); oigt->table_id = ofpact_get_GOTO_TABLE(a)->table_id; memset(oigt->pad, 0, sizeof oigt->pad); - } else if (!ofpact_is_instruction(a)) { - /* Apply-actions */ + break; + } + + case OVSINST_OFPIT11_WRITE_METADATA: { + const struct ofpact_metadata *om; + struct ofp11_instruction_write_metadata *oiwm; + + om = ofpact_get_WRITE_METADATA(a); + oiwm = instruction_put_OFPIT11_WRITE_METADATA(openflow); + oiwm->metadata = om->metadata; + oiwm->metadata_mask = om->mask; + break; + } + + case OVSINST_OFPIT13_METER: { + const struct ofpact_meter *om; + struct ofp13_instruction_meter *oim; + + om = ofpact_get_METER(a); + oim = instruction_put_OFPIT13_METER(openflow); + oim->meter_id = htonl(om->meter_id); + break; + } + + case OVSINST_OFPIT11_APPLY_ACTIONS: { const size_t ofs = openflow->size; const size_t ofpacts_len_left = (uint8_t*)ofpact_end(ofpacts, ofpacts_len) - (uint8_t*)a; @@ -1572,7 +2417,8 @@ ofpacts_put_openflow11_instructions(const struct ofpact ofpacts[], instruction_put_OFPIT11_APPLY_ACTIONS(openflow); OFPACT_FOR_EACH(action, a, ofpacts_len_left) { - if (ofpact_is_instruction(action)) { + if (ovs_instruction_type_from_ofpact_type(action->type) + != OVSINST_OFPIT11_APPLY_ACTIONS) { break; } ofpact_to_openflow11(action, openflow); @@ -1580,13 +2426,29 @@ ofpacts_put_openflow11_instructions(const struct ofpact ofpacts[], } ofpacts_update_instruction_actions(openflow, ofs); a = processed; + break; + } + + case OVSINST_OFPIT11_WRITE_ACTIONS: { + const size_t ofs = openflow->size; + const struct ofpact_nest *on; + + on = ofpact_get_WRITE_ACTIONS(a); + instruction_put_OFPIT11_WRITE_ACTIONS(openflow); + ofpacts_put_openflow11_actions(on->actions, + ofpact_nest_get_action_len(on), + openflow); + ofpacts_update_instruction_actions(openflow, ofs); + + break; + } } } } /* Returns true if 'action' outputs to 'port', false otherwise. */ static bool -ofpact_outputs_to_port(const struct ofpact *ofpact, uint16_t port) +ofpact_outputs_to_port(const struct ofpact *ofpact, ofp_port_t port) { switch (ofpact->type) { case OFPACT_OUTPUT: @@ -1601,28 +2463,41 @@ ofpact_outputs_to_port(const struct ofpact *ofpact, uint16_t port) case OFPACT_SET_VLAN_VID: case OFPACT_SET_VLAN_PCP: case OFPACT_STRIP_VLAN: + case OFPACT_PUSH_VLAN: case OFPACT_SET_ETH_SRC: case OFPACT_SET_ETH_DST: case OFPACT_SET_IPV4_SRC: case OFPACT_SET_IPV4_DST: - case OFPACT_SET_IPV4_DSCP: + case OFPACT_SET_IP_DSCP: + case OFPACT_SET_IP_ECN: + case OFPACT_SET_IP_TTL: case OFPACT_SET_L4_SRC_PORT: case OFPACT_SET_L4_DST_PORT: case OFPACT_REG_MOVE: case OFPACT_REG_LOAD: + case OFPACT_STACK_PUSH: + case OFPACT_STACK_POP: case OFPACT_DEC_TTL: + case OFPACT_SET_MPLS_TTL: + case OFPACT_DEC_MPLS_TTL: case OFPACT_SET_TUNNEL: + case OFPACT_WRITE_METADATA: case OFPACT_SET_QUEUE: case OFPACT_POP_QUEUE: case OFPACT_FIN_TIMEOUT: case OFPACT_RESUBMIT: case OFPACT_LEARN: case OFPACT_MULTIPATH: - case OFPACT_AUTOPATH: case OFPACT_NOTE: case OFPACT_EXIT: + case OFPACT_PUSH_MPLS: + case OFPACT_POP_MPLS: + case OFPACT_SAMPLE: case OFPACT_CLEAR_ACTIONS: + case OFPACT_WRITE_ACTIONS: case OFPACT_GOTO_TABLE: + case OFPACT_METER: + case OFPACT_GROUP: default: return false; } @@ -1632,7 +2507,7 @@ ofpact_outputs_to_port(const struct ofpact *ofpact, uint16_t port) * to 'port', false otherwise. */ bool ofpacts_output_to_port(const struct ofpact *ofpacts, size_t ofpacts_len, - uint16_t port) + ofp_port_t port) { const struct ofpact *a; @@ -1645,12 +2520,54 @@ ofpacts_output_to_port(const struct ofpact *ofpacts, size_t ofpacts_len, return false; } +/* Returns true if any action in the 'ofpacts_len' bytes of 'ofpacts' outputs + * to 'group', false otherwise. */ +bool +ofpacts_output_to_group(const struct ofpact *ofpacts, size_t ofpacts_len, + uint32_t group_id) +{ + const struct ofpact *a; + + OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) { + if (a->type == OFPACT_GROUP + && ofpact_get_GROUP(a)->group_id == group_id) { + return true; + } + } + + return false; +} + bool ofpacts_equal(const struct ofpact *a, size_t a_len, const struct ofpact *b, size_t b_len) { return a_len == b_len && !memcmp(a, b, a_len); } + +/* Finds the OFPACT_METER action, if any, in the 'ofpacts_len' bytes of + * 'ofpacts'. If found, returns its meter ID; if not, returns 0. + * + * This function relies on the order of 'ofpacts' being correct (as checked by + * ofpacts_verify()). */ +uint32_t +ofpacts_get_meter(const struct ofpact ofpacts[], size_t ofpacts_len) +{ + const struct ofpact *a; + + OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) { + enum ovs_instruction_type inst; + + inst = ovs_instruction_type_from_ofpact_type(a->type); + if (a->type == OFPACT_METER) { + return ofpact_get_METER(a)->meter_id; + } else if (inst > OVSINST_OFPIT13_METER) { + break; + } + } + + return 0; +} /* Formatting ofpacts. */ @@ -1709,15 +2626,16 @@ ofpact_format(const struct ofpact *a, struct ds *s) { const struct ofpact_enqueue *enqueue; const struct ofpact_resubmit *resubmit; - const struct ofpact_autopath *autopath; const struct ofpact_controller *controller; + const struct ofpact_metadata *metadata; const struct ofpact_tunnel *tunnel; - uint16_t port; + const struct ofpact_sample *sample; + ofp_port_t port; switch (a->type) { case OFPACT_OUTPUT: port = ofpact_get_OUTPUT(a)->port; - if (port < OFPP_MAX) { + if (ofp_to_u16(port) < ofp_to_u16(OFPP_MAX)) { ds_put_format(s, "output:%"PRIu16, port); } else { ofputil_format_port(port, s); @@ -1738,8 +2656,11 @@ ofpact_format(const struct ofpact *a, struct ds *s) ds_put_cstr(s, "controller("); if (reason != OFPR_ACTION) { + char reasonbuf[OFPUTIL_PACKET_IN_REASON_BUFSIZE]; + ds_put_format(s, "reason=%s,", - ofputil_packet_in_reason_to_string(reason)); + ofputil_packet_in_reason_to_string( + reason, reasonbuf, sizeof reasonbuf)); } if (controller->max_len != UINT16_MAX) { ds_put_format(s, "max_len=%"PRIu16",", controller->max_len); @@ -1782,6 +2703,11 @@ ofpact_format(const struct ofpact *a, struct ds *s) ds_put_cstr(s, "strip_vlan"); break; + case OFPACT_PUSH_VLAN: + /* XXX 802.1AD case*/ + ds_put_format(s, "push_vlan:%#"PRIx16, ETH_TYPE_VLAN_8021Q); + break; + case OFPACT_SET_ETH_SRC: ds_put_format(s, "mod_dl_src:"ETH_ADDR_FMT, ETH_ADDR_ARGS(ofpact_get_SET_ETH_SRC(a)->mac)); @@ -1794,16 +2720,24 @@ ofpact_format(const struct ofpact *a, struct ds *s) case OFPACT_SET_IPV4_SRC: ds_put_format(s, "mod_nw_src:"IP_FMT, - IP_ARGS(&ofpact_get_SET_IPV4_SRC(a)->ipv4)); + IP_ARGS(ofpact_get_SET_IPV4_SRC(a)->ipv4)); break; case OFPACT_SET_IPV4_DST: ds_put_format(s, "mod_nw_dst:"IP_FMT, - IP_ARGS(&ofpact_get_SET_IPV4_DST(a)->ipv4)); + IP_ARGS(ofpact_get_SET_IPV4_DST(a)->ipv4)); + break; + + case OFPACT_SET_IP_DSCP: + ds_put_format(s, "mod_nw_tos:%d", ofpact_get_SET_IP_DSCP(a)->dscp); + break; + + case OFPACT_SET_IP_ECN: + ds_put_format(s, "mod_nw_ecn:%d", ofpact_get_SET_IP_ECN(a)->ecn); break; - case OFPACT_SET_IPV4_DSCP: - ds_put_format(s, "mod_nw_tos:%d", ofpact_get_SET_IPV4_DSCP(a)->dscp); + case OFPACT_SET_IP_TTL: + ds_put_format(s, "mod_nw_ttl:%d", ofpact_get_SET_IP_TTL(a)->ttl); break; case OFPACT_SET_L4_SRC_PORT: @@ -1822,10 +2756,27 @@ ofpact_format(const struct ofpact *a, struct ds *s) nxm_format_reg_load(ofpact_get_REG_LOAD(a), s); break; + case OFPACT_STACK_PUSH: + nxm_format_stack_push(ofpact_get_STACK_PUSH(a), s); + break; + + case OFPACT_STACK_POP: + nxm_format_stack_pop(ofpact_get_STACK_POP(a), s); + break; + case OFPACT_DEC_TTL: print_dec_ttl(ofpact_get_DEC_TTL(a), s); break; + case OFPACT_SET_MPLS_TTL: + ds_put_format(s, "set_mpls_ttl(%"PRIu8")", + ofpact_get_SET_MPLS_TTL(a)->ttl); + break; + + case OFPACT_DEC_MPLS_TTL: + ds_put_cstr(s, "dec_mpls_ttl"); + break; + case OFPACT_SET_TUNNEL: tunnel = ofpact_get_SET_TUNNEL(a); ds_put_format(s, "set_tunnel%s:%#"PRIx64, @@ -1873,35 +2824,77 @@ ofpact_format(const struct ofpact *a, struct ds *s) multipath_format(ofpact_get_MULTIPATH(a), s); break; - case OFPACT_AUTOPATH: - autopath = ofpact_get_AUTOPATH(a); - ds_put_cstr(s, "autopath("); - ofputil_format_port(autopath->port, s); - ds_put_char(s, ','); - mf_format_subfield(&autopath->dst, s); - ds_put_char(s, ')'); - break; - case OFPACT_NOTE: print_note(ofpact_get_NOTE(a), s); break; + case OFPACT_PUSH_MPLS: + ds_put_format(s, "push_mpls:0x%04"PRIx16, + ntohs(ofpact_get_PUSH_MPLS(a)->ethertype)); + break; + + case OFPACT_POP_MPLS: + ds_put_format(s, "pop_mpls:0x%04"PRIx16, + ntohs(ofpact_get_POP_MPLS(a)->ethertype)); + break; + case OFPACT_EXIT: ds_put_cstr(s, "exit"); break; + case OFPACT_SAMPLE: + sample = ofpact_get_SAMPLE(a); + ds_put_format( + s, "sample(probability=%"PRIu16",collector_set_id=%"PRIu32 + ",obs_domain_id=%"PRIu32",obs_point_id=%"PRIu32")", + sample->probability, sample->collector_set_id, + sample->obs_domain_id, sample->obs_point_id); + break; + + case OFPACT_WRITE_ACTIONS: { + struct ofpact_nest *on = ofpact_get_WRITE_ACTIONS(a); + ds_put_format(s, "%s(", + ovs_instruction_name_from_type( + OVSINST_OFPIT11_WRITE_ACTIONS)); + ofpacts_format(on->actions, ofpact_nest_get_action_len(on), s); + ds_put_char(s, ')'); + break; + } + case OFPACT_CLEAR_ACTIONS: ds_put_format(s, "%s", - ofpact_instruction_name_from_type( + ovs_instruction_name_from_type( OVSINST_OFPIT11_CLEAR_ACTIONS)); break; + case OFPACT_WRITE_METADATA: + metadata = ofpact_get_WRITE_METADATA(a); + ds_put_format(s, "%s:%#"PRIx64, + ovs_instruction_name_from_type( + OVSINST_OFPIT11_WRITE_METADATA), + ntohll(metadata->metadata)); + if (metadata->mask != OVS_BE64_MAX) { + ds_put_format(s, "/%#"PRIx64, ntohll(metadata->mask)); + } + break; + case OFPACT_GOTO_TABLE: ds_put_format(s, "%s:%"PRIu8, - ofpact_instruction_name_from_type( + ovs_instruction_name_from_type( OVSINST_OFPIT11_GOTO_TABLE), ofpact_get_GOTO_TABLE(a)->table_id); break; + + case OFPACT_METER: + ds_put_format(s, "%s:%"PRIu32, + ovs_instruction_name_from_type(OVSINST_OFPIT13_METER), + ofpact_get_METER(a)->meter_id); + break; + + case OFPACT_GROUP: + ds_put_format(s, "group:%"PRIu32, + ofpact_get_GROUP(a)->group_id); + break; } } @@ -1911,7 +2904,6 @@ void ofpacts_format(const struct ofpact *ofpacts, size_t ofpacts_len, struct ds *string) { - ds_put_cstr(string, "actions="); if (!ofpacts_len) { ds_put_cstr(string, "drop"); } else { @@ -1922,8 +2914,7 @@ ofpacts_format(const struct ofpact *ofpacts, size_t ofpacts_len, ds_put_cstr(string, ","); } - /* TODO:XXX write-actions */ - /* TODO:XXX write-metadata */ + /* XXX write-actions */ ofpact_format(a, string); } } @@ -1960,7 +2951,7 @@ ofpact_init(struct ofpact *ofpact, enum ofpact_type type, size_t len) void ofpact_update_len(struct ofpbuf *ofpacts, struct ofpact *ofpact) { - assert(ofpact == ofpacts->l2); + ovs_assert(ofpact == ofpacts->l2); ofpact->len = (char *) ofpbuf_tail(ofpacts) - (char *) ofpact; }