X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fnx-match.c;h=bfead6808e2781f28c61701de9447067906a3e09;hb=4d5f814dfb737aae820b8ce70ff0a8b94c291ec3;hp=6ea06425637a722f24c49a5be842087e03525d8d;hpb=91ae5bece01cfe69741f9e284d0ccf78fce87eb0;p=sliver-openvswitch.git diff --git a/lib/nx-match.c b/lib/nx-match.c index 6ea064256..bfead6808 100644 --- a/lib/nx-match.c +++ b/lib/nx-match.c @@ -90,13 +90,38 @@ nx_entry_ok(const void *p, unsigned int match_len) return header; } +/* Given NXM/OXM value 'value' and mask 'mask', each 'width' bytes long, + * checks for any 1-bit in the value where there is a 0-bit in the mask. If it + * finds one, logs a warning. */ +static void +check_mask_consistency(const uint8_t *p, const struct mf_field *mf) +{ + unsigned int width = mf->n_bytes; + const uint8_t *value = p + 4; + const uint8_t *mask = p + 4 + width; + unsigned int i; + + for (i = 0; i < width; i++) { + if (value[i] & ~mask[i]) { + if (!VLOG_DROP_WARN(&rl)) { + char *s = nx_match_to_string(p, width * 2 + 4); + VLOG_WARN_RL(&rl, "NXM/OXM entry %s has 1-bits in value for " + "bits wildcarded by the mask. (Future versions " + "of OVS may report this as an OpenFlow error.)", + s); + break; + } + } + } +} + static enum ofperr nx_pull_raw(const uint8_t *p, unsigned int match_len, bool strict, struct match *match, ovs_be64 *cookie, ovs_be64 *cookie_mask) { uint32_t header; - assert((cookie != NULL) == (cookie_mask != NULL)); + ovs_assert((cookie != NULL) == (cookie_mask != NULL)); match_init_catchall(match); if (cookie) { @@ -141,6 +166,7 @@ nx_pull_raw(const uint8_t *p, unsigned int match_len, bool strict, error = OFPERR_OFPBMC_BAD_MASK; } else { error = 0; + check_mask_consistency(p, mf); mf_set(mf, &value, &mask, match); } } @@ -547,7 +573,7 @@ nx_put_raw(struct ofpbuf *b, bool oxm, const struct match *match, int match_len; int i; - BUILD_ASSERT_DECL(FLOW_WC_SEQ == 17); + BUILD_ASSERT_DECL(FLOW_WC_SEQ == 20); /* Metadata. */ if (match->wc.masks.in_port) { @@ -589,6 +615,22 @@ nx_put_raw(struct ofpbuf *b, bool oxm, const struct match *match, match->wc.masks.vlan_tci); } + /* MPLS. */ + if (eth_type_mpls(flow->dl_type)) { + if (match->wc.masks.mpls_lse & htonl(MPLS_TC_MASK)) { + nxm_put_8(b, OXM_OF_MPLS_TC, mpls_lse_to_tc(flow->mpls_lse)); + } + + if (match->wc.masks.mpls_lse & htonl(MPLS_BOS_MASK)) { + nxm_put_8(b, OXM_OF_MPLS_BOS, mpls_lse_to_bos(flow->mpls_lse)); + } + + if (match->wc.masks.mpls_lse & htonl(MPLS_LABEL_MASK)) { + nxm_put_32(b, OXM_OF_MPLS_LABEL, + htonl(mpls_lse_to_label(flow->mpls_lse))); + } + } + /* L3. */ if (flow->dl_type == htons(ETH_TYPE_IP)) { /* IP. */ @@ -626,7 +668,8 @@ nx_put_raw(struct ofpbuf *b, bool oxm, const struct match *match, flow->arp_tha, match->wc.masks.arp_tha); } } - } else if (flow->dl_type == htons(ETH_TYPE_ARP)) { + } else if (flow->dl_type == htons(ETH_TYPE_ARP) || + flow->dl_type == htons(ETH_TYPE_RARP)) { /* ARP. */ if (match->wc.masks.nw_proto) { nxm_put_16(b, oxm ? OXM_OF_ARP_OP : NXM_OF_ARP_OP, @@ -643,7 +686,8 @@ nx_put_raw(struct ofpbuf *b, bool oxm, const struct match *match, } /* Tunnel ID. */ - nxm_put_64m(b, NXM_NX_TUN_ID, flow->tun_id, match->wc.masks.tun_id); + nxm_put_64m(b, oxm ? OXM_OF_TUNNEL_ID : NXM_NX_TUN_ID, + flow->tunnel.tun_id, match->wc.masks.tunnel.tun_id); /* Registers. */ for (i = 0; i < FLOW_N_REGS; i++) { @@ -1025,7 +1069,7 @@ set_field_format(const struct ofpact_reg_load *load, struct ds *s) const struct mf_field *mf = load->dst.field; union mf_value value; - assert(load->ofpact.compat == OFPUTIL_OFPAT12_SET_FIELD); + ovs_assert(load->ofpact.compat == OFPUTIL_OFPAT12_SET_FIELD); ds_put_format(s, "set_field:"); memset(&value, 0, sizeof value); bitwise_copy(&load->subvalue, sizeof load->subvalue, 0, @@ -1119,12 +1163,7 @@ nxm_reg_load_from_openflow12_set_field( return OFPERR_OFPBAC_BAD_ARGUMENT; } load = ofpact_put_REG_LOAD(ofpacts); - load->ofpact.compat = OFPUTIL_OFPAT12_SET_FIELD; - load->dst.field = mf; - load->dst.ofs = 0; - load->dst.n_bits = mf->n_bits; - bitwise_copy(oasf + 1, mf->n_bytes, load->dst.ofs, - &load->subvalue, sizeof load->subvalue, 0, mf->n_bits); + ofpact_set_field_init(load, mf, oasf + 1); return nxm_reg_load_check(load, NULL); } @@ -1178,22 +1217,19 @@ set_field_to_ofast(const struct ofpact_reg_load *load, struct ofpbuf *openflow) { const struct mf_field *mf = load->dst.field; + uint16_t padded_value_len = ROUND_UP(mf->n_bytes, 8); struct ofp12_action_set_field *oasf; - uint16_t padded_value_len; - - oasf = ofputil_put_OFPAT12_SET_FIELD(openflow); - oasf->dst = htonl(mf->oxm_header); + char *value; /* Set field is the only action of variable length (so far), * so handling the variable length portion is open-coded here */ - padded_value_len = ROUND_UP(mf->n_bytes, 8); - ofpbuf_put_uninit(openflow, padded_value_len); + oasf = ofputil_put_OFPAT12_SET_FIELD(openflow); + oasf->dst = htonl(mf->oxm_header); oasf->len = htons(ntohs(oasf->len) + padded_value_len); - memset(oasf + 1, 0, padded_value_len); + value = ofpbuf_put_zeros(openflow, padded_value_len); bitwise_copy(&load->subvalue, sizeof load->subvalue, load->dst.ofs, - oasf + 1, mf->n_bytes, load->dst.ofs, load->dst.n_bits); - return; + value, mf->n_bytes, load->dst.ofs, load->dst.n_bits); } void @@ -1205,6 +1241,7 @@ nxm_reg_load_to_nxast(const struct ofpact_reg_load *load, struct ofp_header *oh = (struct ofp_header *)openflow->l2; switch(oh->version) { + case OFP13_VERSION: case OFP12_VERSION: set_field_to_ofast(load, openflow); break; @@ -1275,3 +1312,149 @@ nxm_reg_load(const struct mf_subfield *dst, uint64_t src_data, sizeof src_data_be * 8); mf_write_subfield_flow(dst, &src_subvalue, flow); } + +/* nxm_parse_stack_action, works for both push() and pop(). */ +void +nxm_parse_stack_action(struct ofpact_stack *stack_action, const char *s) +{ + s = mf_parse_subfield(&stack_action->subfield, s); + if (*s != '\0') { + ovs_fatal(0, "%s: trailing garbage following push or pop", s); + } +} + +void +nxm_format_stack_push(const struct ofpact_stack *push, struct ds *s) +{ + ds_put_cstr(s, "push:"); + mf_format_subfield(&push->subfield, s); +} + +void +nxm_format_stack_pop(const struct ofpact_stack *pop, struct ds *s) +{ + ds_put_cstr(s, "pop:"); + mf_format_subfield(&pop->subfield, s); +} + +/* Common set for both push and pop actions. */ +static void +stack_action_from_openflow__(const struct nx_action_stack *nasp, + struct ofpact_stack *stack_action) +{ + stack_action->subfield.field = mf_from_nxm_header(ntohl(nasp->field)); + stack_action->subfield.ofs = ntohs(nasp->offset); + stack_action->subfield.n_bits = ntohs(nasp->n_bits); +} + +static void +nxm_stack_to_nxast__(const struct ofpact_stack *stack_action, + struct nx_action_stack *nasp) +{ + nasp->offset = htons(stack_action->subfield.ofs); + nasp->n_bits = htons(stack_action->subfield.n_bits); + nasp->field = htonl(stack_action->subfield.field->nxm_header); +} + +enum ofperr +nxm_stack_push_from_openflow(const struct nx_action_stack *nasp, + struct ofpbuf *ofpacts) +{ + struct ofpact_stack *push; + + push = ofpact_put_STACK_PUSH(ofpacts); + stack_action_from_openflow__(nasp, push); + + return nxm_stack_push_check(push, NULL); +} + +enum ofperr +nxm_stack_pop_from_openflow(const struct nx_action_stack *nasp, + struct ofpbuf *ofpacts) +{ + struct ofpact_stack *pop; + + pop = ofpact_put_STACK_POP(ofpacts); + stack_action_from_openflow__(nasp, pop); + + return nxm_stack_pop_check(pop, NULL); +} + +enum ofperr +nxm_stack_push_check(const struct ofpact_stack *push, + const struct flow *flow) +{ + return mf_check_src(&push->subfield, flow); +} + +enum ofperr +nxm_stack_pop_check(const struct ofpact_stack *pop, + const struct flow *flow) +{ + return mf_check_dst(&pop->subfield, flow); +} + +void +nxm_stack_push_to_nxast(const struct ofpact_stack *stack, + struct ofpbuf *openflow) +{ + nxm_stack_to_nxast__(stack, ofputil_put_NXAST_STACK_PUSH(openflow)); +} + +void +nxm_stack_pop_to_nxast(const struct ofpact_stack *stack, + struct ofpbuf *openflow) +{ + nxm_stack_to_nxast__(stack, ofputil_put_NXAST_STACK_POP(openflow)); +} + +/* nxm_execute_stack_push(), nxm_execute_stack_pop(). */ +static void +nx_stack_push(struct ofpbuf *stack, union mf_subvalue *v) +{ + ofpbuf_put(stack, v, sizeof *v); +} + +static union mf_subvalue * +nx_stack_pop(struct ofpbuf *stack) +{ + union mf_subvalue *v = NULL; + + if (stack->size) { + stack->size -= sizeof *v; + v = (union mf_subvalue *) ofpbuf_tail(stack); + } + + return v; +} + +void +nxm_execute_stack_push(const struct ofpact_stack *push, + const struct flow *flow, struct ofpbuf *stack) +{ + union mf_subvalue dst_value; + + mf_read_subfield(&push->subfield, flow, &dst_value); + nx_stack_push(stack, &dst_value); +} + +void +nxm_execute_stack_pop(const struct ofpact_stack *pop, + struct flow *flow, struct ofpbuf *stack) +{ + union mf_subvalue *src_value; + + src_value = nx_stack_pop(stack); + + /* Only pop if stack is not empty. Otherwise, give warning. */ + if (src_value) { + mf_write_subfield_flow(&pop->subfield, src_value, flow); + } else { + if (!VLOG_DROP_WARN(&rl)) { + char *flow_str = flow_to_string(flow); + VLOG_WARN_RL(&rl, "Failed to pop from an empty stack. On flow \n" + " %s", flow_str); + free(flow_str); + } + } +}