| /* |
| * Copyright 2016-present Open Networking Laboratory |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.onosproject.drivers.bmv2.translators; |
| |
| import com.google.common.annotations.Beta; |
| import org.onlab.util.ImmutableByteSequence; |
| import org.onosproject.bmv2.api.model.Bmv2ModelField; |
| import org.onosproject.bmv2.api.model.Bmv2ModelTable; |
| import org.onosproject.bmv2.api.model.Bmv2ModelTableKey; |
| import org.onosproject.bmv2.api.runtime.Bmv2Action; |
| import org.onosproject.bmv2.api.runtime.Bmv2ExtensionSelector; |
| import org.onosproject.bmv2.api.runtime.Bmv2ExtensionTreatment; |
| import org.onosproject.bmv2.api.runtime.Bmv2LpmMatchParam; |
| import org.onosproject.bmv2.api.runtime.Bmv2MatchKey; |
| import org.onosproject.bmv2.api.runtime.Bmv2TableEntry; |
| import org.onosproject.bmv2.api.runtime.Bmv2TernaryMatchParam; |
| import org.onosproject.net.flow.FlowRule; |
| import org.onosproject.net.flow.TrafficSelector; |
| import org.onosproject.net.flow.TrafficTreatment; |
| import org.onosproject.net.flow.criteria.Criterion; |
| import org.onosproject.net.flow.criteria.EthCriterion; |
| import org.onosproject.net.flow.criteria.EthTypeCriterion; |
| import org.onosproject.net.flow.criteria.ExtensionCriterion; |
| import org.onosproject.net.flow.criteria.ExtensionSelector; |
| import org.onosproject.net.flow.criteria.ExtensionSelectorType.ExtensionSelectorTypes; |
| import org.onosproject.net.flow.criteria.PortCriterion; |
| import org.onosproject.net.flow.instructions.ExtensionTreatment; |
| import org.onosproject.net.flow.instructions.ExtensionTreatmentType.ExtensionTreatmentTypes; |
| import org.onosproject.net.flow.instructions.Instruction; |
| import org.onosproject.net.flow.instructions.Instructions; |
| import org.onosproject.net.flow.instructions.Instructions.ExtensionInstructionWrapper; |
| |
| /** |
| * Default Bmv2 flow rule translator implementation. |
| * <p> |
| * Flow rules are translated into {@link Bmv2TableEntry BMv2 table entries} according to the following logic: |
| * <ul> |
| * <li> table name: obtained from the Bmv2 model using the flow rule table ID; |
| * <li> match key: if the flow rule selector defines only a criterion of type {@link Criterion.Type#EXTENSION EXTENSION} |
| * , then the latter is expected to contain a {@link Bmv2ExtensionSelector Bmv2ExtensionSelector}, which should provide |
| * a match key already formatted for the given table; otherwise a match key is built using the |
| * {@link TranslatorConfig#fieldToCriterionTypeMap() mapping} defined by this translator configuration. |
| * <li> action: if the flow rule treatment contains only one instruction of type |
| * {@link Instruction.Type#EXTENSION EXTENSION}, then the latter is expected to contain a {@link Bmv2ExtensionTreatment} |
| * , which should provide a {@link Bmv2Action} already formatted for the given table; otherwise, an action is |
| * {@link TranslatorConfig#buildAction(TrafficTreatment) built} using this translator configuration. |
| * <li> priority: the same as the flow rule. |
| * <li> timeout: if the table supports timeout, use the same as the flow rule, otherwise none (i.e. permanent entry). |
| * </ul> |
| */ |
| @Beta |
| public class Bmv2DefaultFlowRuleTranslator implements Bmv2FlowRuleTranslator { |
| |
| private final TranslatorConfig config; |
| |
| public Bmv2DefaultFlowRuleTranslator(TranslatorConfig config) { |
| this.config = config; |
| } |
| |
| private static Bmv2TernaryMatchParam buildTernaryParam(Bmv2ModelField field, Criterion criterion, int byteWidth) |
| throws Bmv2FlowRuleTranslatorException { |
| |
| // Value and mask will be filled according to criterion type |
| ImmutableByteSequence value; |
| ImmutableByteSequence mask = null; |
| |
| switch (criterion.type()) { |
| case IN_PORT: |
| // FIXME: allow port numbers of variable bit length (based on model), truncating when necessary |
| short port = (short) ((PortCriterion) criterion).port().toLong(); |
| value = ImmutableByteSequence.copyFrom(port); |
| break; |
| case ETH_DST: |
| EthCriterion c = (EthCriterion) criterion; |
| value = ImmutableByteSequence.copyFrom(c.mac().toBytes()); |
| if (c.mask() != null) { |
| mask = ImmutableByteSequence.copyFrom(c.mask().toBytes()); |
| } |
| break; |
| case ETH_SRC: |
| EthCriterion c2 = (EthCriterion) criterion; |
| value = ImmutableByteSequence.copyFrom(c2.mac().toBytes()); |
| if (c2.mask() != null) { |
| mask = ImmutableByteSequence.copyFrom(c2.mask().toBytes()); |
| } |
| break; |
| case ETH_TYPE: |
| short ethType = ((EthTypeCriterion) criterion).ethType().toShort(); |
| value = ImmutableByteSequence.copyFrom(ethType); |
| break; |
| // TODO: implement building for other criterion types (easy with DefaultCriterion of ONOS-4034) |
| default: |
| throw new Bmv2FlowRuleTranslatorException("Feature not implemented, ternary builder for criterion" + |
| "type: " + criterion.type().name()); |
| } |
| |
| if (mask == null) { |
| // no mask, all ones |
| mask = ImmutableByteSequence.ofOnes(byteWidth); |
| } |
| |
| return new Bmv2TernaryMatchParam(value, mask); |
| } |
| |
| private static Bmv2MatchKey getMatchKeyFromExtension(ExtensionCriterion criterion) |
| throws Bmv2FlowRuleTranslatorException { |
| |
| ExtensionSelector extSelector = criterion.extensionSelector(); |
| |
| if (extSelector.type() == ExtensionSelectorTypes.P4_BMV2_MATCH_KEY.type()) { |
| if (extSelector instanceof Bmv2ExtensionSelector) { |
| return ((Bmv2ExtensionSelector) extSelector).matchKey(); |
| } else { |
| throw new Bmv2FlowRuleTranslatorException("Unable to decode extension selector " + extSelector); |
| } |
| } else { |
| throw new Bmv2FlowRuleTranslatorException("Unsupported extension selector type " + extSelector.type()); |
| } |
| } |
| |
| private static Bmv2Action getActionFromExtension(Instructions.ExtensionInstructionWrapper inst) |
| throws Bmv2FlowRuleTranslatorException { |
| |
| ExtensionTreatment extTreatment = inst.extensionInstruction(); |
| |
| if (extTreatment.type() == ExtensionTreatmentTypes.P4_BMV2_ACTION.type()) { |
| if (extTreatment instanceof Bmv2ExtensionTreatment) { |
| return ((Bmv2ExtensionTreatment) extTreatment).getAction(); |
| } else { |
| throw new Bmv2FlowRuleTranslatorException("Unable to decode treatment extension: " + extTreatment); |
| } |
| } else { |
| throw new Bmv2FlowRuleTranslatorException("Unsupported treatment extension type: " + extTreatment.type()); |
| } |
| } |
| |
| private static Bmv2MatchKey buildMatchKey(TranslatorConfig config, TrafficSelector selector, Bmv2ModelTable table) |
| throws Bmv2FlowRuleTranslatorException { |
| |
| Bmv2MatchKey.Builder matchKeyBuilder = Bmv2MatchKey.builder(); |
| |
| for (Bmv2ModelTableKey key : table.keys()) { |
| |
| String fieldName = key.field().header().name() + "." + key.field().type().name(); |
| int byteWidth = (int) Math.ceil((double) key.field().type().bitWidth() / 8.0); |
| Criterion.Type criterionType = config.fieldToCriterionTypeMap().get(fieldName); |
| |
| if (criterionType == null || selector.getCriterion(criterionType) == null) { |
| // A mapping is not available or the selector doesn't have such a type |
| switch (key.matchType()) { |
| case TERNARY: |
| // Wildcard field |
| matchKeyBuilder.withWildcard(byteWidth); |
| break; |
| case LPM: |
| // LPM with prefix 0 |
| matchKeyBuilder.add(new Bmv2LpmMatchParam(ImmutableByteSequence.ofZeros(byteWidth), 0)); |
| break; |
| default: |
| throw new Bmv2FlowRuleTranslatorException("Match field not supported: " + fieldName); |
| } |
| // Next key |
| continue; |
| } |
| |
| Criterion criterion = selector.getCriterion(criterionType); |
| Bmv2TernaryMatchParam matchParam = null; |
| |
| switch (key.matchType()) { |
| case TERNARY: |
| matchParam = buildTernaryParam(key.field(), criterion, byteWidth); |
| break; |
| default: |
| // TODO: implement other match param builders (exact, LPM, etc.) |
| throw new Bmv2FlowRuleTranslatorException("Feature not implemented, match param builder: " |
| + key.matchType().name()); |
| } |
| |
| matchKeyBuilder.add(matchParam); |
| } |
| |
| return matchKeyBuilder.build(); |
| } |
| |
| @Override |
| public Bmv2TableEntry translate(FlowRule rule) |
| throws Bmv2FlowRuleTranslatorException { |
| |
| int tableId = rule.tableId(); |
| |
| Bmv2ModelTable table = config.model().table(tableId); |
| |
| if (table == null) { |
| throw new Bmv2FlowRuleTranslatorException("Unknown table ID: " + tableId); |
| } |
| |
| /* Translate selector */ |
| |
| TrafficSelector selector = rule.selector(); |
| Bmv2MatchKey bmv2MatchKey = null; |
| |
| // If selector has only 1 criterion of type extension, use that |
| Criterion criterion = selector.getCriterion(Criterion.Type.EXTENSION); |
| if (criterion != null) { |
| if (selector.criteria().size() == 1) { |
| bmv2MatchKey = getMatchKeyFromExtension((ExtensionCriterion) criterion); |
| } else { |
| throw new Bmv2FlowRuleTranslatorException("Unable to translate traffic selector, found multiple " + |
| "criteria of which one is an extension: " + |
| selector.toString()); |
| } |
| } |
| |
| if (bmv2MatchKey == null) { |
| // not an extension |
| bmv2MatchKey = buildMatchKey(config, selector, table); |
| } |
| |
| /* Translate treatment */ |
| |
| TrafficTreatment treatment = rule.treatment(); |
| Bmv2Action bmv2Action = null; |
| |
| // If treatment has only 1 instruction of type extension, use that |
| for (Instruction inst : treatment.allInstructions()) { |
| if (inst.type() == Instruction.Type.EXTENSION) { |
| if (treatment.allInstructions().size() == 1) { |
| bmv2Action = getActionFromExtension((ExtensionInstructionWrapper) inst); |
| } else { |
| throw new Bmv2FlowRuleTranslatorException("Unable to translate traffic treatment, found multiple " + |
| "instructions of which one is an extension: " + |
| selector.toString()); |
| } |
| } |
| } |
| |
| if (bmv2Action == null) { |
| // No extension, use config to build action |
| bmv2Action = config.buildAction(treatment); |
| } |
| |
| if (bmv2Action == null) { |
| // Config returned null |
| throw new Bmv2FlowRuleTranslatorException("Unable to translate treatment: " + treatment); |
| } |
| |
| Bmv2TableEntry.Builder tableEntryBuilder = Bmv2TableEntry.builder(); |
| |
| tableEntryBuilder |
| .withTableName(table.name()) |
| .withPriority(rule.priority()) |
| .withMatchKey(bmv2MatchKey) |
| .withAction(bmv2Action); |
| |
| if (!rule.isPermanent()) { |
| if (table.hasTimeouts()) { |
| tableEntryBuilder.withTimeout((double) rule.timeout()); |
| } |
| //FIXME: add warn log or exception? |
| } |
| |
| return tableEntryBuilder.build(); |
| } |
| |
| @Override |
| public TranslatorConfig config() { |
| return this.config; |
| } |
| } |