| /* |
| * Copyright 2019-present Open Networking Foundation |
| * |
| * 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.driver.pipeline.ofdpa; |
| |
| import org.onlab.packet.Ethernet; |
| import org.onlab.packet.IpPrefix; |
| import org.onlab.packet.MacAddress; |
| import org.onlab.packet.VlanId; |
| import org.onosproject.net.driver.Driver; |
| 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.IPCriterion; |
| import org.onosproject.net.flow.criteria.MplsBosCriterion; |
| import org.onosproject.net.flow.criteria.VlanIdCriterion; |
| import org.onosproject.net.flow.instructions.Instruction; |
| import org.onosproject.net.flow.instructions.Instructions; |
| import org.onosproject.net.flow.instructions.L2ModificationInstruction; |
| import org.onosproject.net.flow.instructions.L2ModificationInstruction.L2SubType; |
| import org.onosproject.net.flow.instructions.L2ModificationInstruction.ModTunnelIdInstruction; |
| import org.onosproject.net.flowobjective.FilteringObjective; |
| import org.onosproject.net.flowobjective.ForwardingObjective; |
| import org.onosproject.net.flowobjective.Objective; |
| import org.onosproject.net.flowobjective.ObjectiveError; |
| |
| import static org.onosproject.net.behaviour.Pipeliner.ACCUMULATOR_ENABLED; |
| import static org.onosproject.net.flow.criteria.Criterion.Type.*; |
| import static org.onosproject.net.flow.instructions.Instruction.Type.L2MODIFICATION; |
| import org.onosproject.net.flow.instructions.L2ModificationInstruction.ModVlanIdInstruction; |
| import org.onosproject.net.flow.instructions.L2ModificationInstruction.ModEtherInstruction; |
| |
| public final class OfdpaPipelineUtility { |
| |
| private OfdpaPipelineUtility() { |
| // Utility classes should not have a public or default constructor. |
| } |
| |
| // Ofdpa specific tables number |
| public static final int PORT_TABLE = 0; |
| public static final int VLAN_TABLE = 10; |
| static final int VLAN_1_TABLE = 11; |
| static final int MPLS_L2_PORT_FLOW_TABLE = 13; |
| static final int MPLS_L2_PORT_PCP_TRUST_FLOW_TABLE = 16; |
| public static final int TMAC_TABLE = 20; |
| public static final int UNICAST_ROUTING_TABLE = 30; |
| public static final int MULTICAST_ROUTING_TABLE = 40; |
| public static final int MPLS_TABLE_0 = 23; |
| public static final int MPLS_TABLE_1 = 24; |
| public static final int MPLS_L3_TYPE_TABLE = 27; |
| public static final int MPLS_TYPE_TABLE = 29; |
| public static final int BRIDGING_TABLE = 50; |
| public static final int ACL_TABLE = 60; |
| static final int EGRESS_VLAN_FLOW_TABLE = 210; |
| static final int EGRESS_DSCP_PCP_REMARK_FLOW_TABLE = 230; |
| static final int EGRESS_TPID_FLOW_TABLE = 235; |
| static final int MAC_LEARNING_TABLE = 254; |
| |
| // OF max port number |
| static final long OFPP_MAX = 0xffffff00L; |
| |
| // Priority values |
| static final int HIGHEST_PRIORITY = 0xffff; |
| static final int DEFAULT_PRIORITY = 0x8000; |
| static final int LOWEST_PRIORITY = 0x0; |
| |
| // MPLS L2 table values |
| static final int MPLS_L2_PORT_PRIORITY = 2; |
| static final int MPLS_TUNNEL_ID_BASE = 0x10000; |
| static final int MPLS_TUNNEL_ID_MAX = 0x1FFFF; |
| static final int MPLS_UNI_PORT_MAX = 0x0000FFFF; |
| static final int MPLS_NNI_PORT_BASE = 0x00020000; |
| static final int MPLS_NNI_PORT_MAX = 0x0002FFFF; |
| |
| // Egress table values |
| static final short ALLOW_VLAN_TRANSLATION = 1; |
| static final int COPY_FIELD_NBITS = 12; |
| static final int COPY_FIELD_OFFSET = 0; |
| |
| // Flow retry values |
| static final int MAX_RETRY_ATTEMPTS = 10; |
| static final int RETRY_MS = 1000; |
| |
| ////////////////////////////// |
| // Helper and utility methods |
| ////////////////////////////// |
| |
| /** |
| * Check whether the accumulator is enabled or not. |
| * @param pipeline the pipeline |
| * @return true if the accumulator is enabled. Otherwise not |
| */ |
| static boolean isAccumulatorEnabled(Ofdpa2Pipeline pipeline) { |
| Driver driver = pipeline.data().driver(); |
| // we cannot determine the property |
| if (driver == null) { |
| return false; |
| } |
| return Boolean.parseBoolean(driver.getProperty(ACCUMULATOR_ENABLED)); |
| } |
| |
| static void pass(Objective obj) { |
| obj.context().ifPresent(context -> context.onSuccess(obj)); |
| } |
| |
| static void fail(Objective obj, ObjectiveError error) { |
| obj.context().ifPresent(context -> context.onError(obj, error)); |
| } |
| |
| /** |
| * Returns true iff the given selector matches on BOS==true, indicating that |
| * the selector is trying to match on a label that is bottom-of-stack. |
| * |
| * @param selector the given match |
| * @return true iff BoS==true; false if BOS==false, or BOS matching is not |
| * expressed in the given selector |
| */ |
| static boolean isMplsBos(TrafficSelector selector) { |
| MplsBosCriterion bosCriterion = (MplsBosCriterion) selector.getCriterion(MPLS_BOS); |
| return bosCriterion != null && bosCriterion.mplsBos(); |
| } |
| |
| /** |
| * Returns true iff the given selector matches on BOS==false, indicating |
| * that the selector is trying to match on a label that is not the |
| * bottom-of-stack label. |
| * |
| * @param selector the given match |
| * @return true iff BoS==false; |
| * false if BOS==true, or BOS matching is not expressed in the given selector |
| */ |
| static boolean isNotMplsBos(TrafficSelector selector) { |
| MplsBosCriterion bosCriterion = (MplsBosCriterion) selector.getCriterion(MPLS_BOS); |
| return bosCriterion != null && !bosCriterion.mplsBos(); |
| } |
| |
| /** |
| * Returns true iff the forwarding objective includes a treatment to pop the |
| * MPLS label. |
| * |
| * @param fwd the given forwarding objective |
| * @return true iff mpls pop treatment exists |
| */ |
| static boolean isMplsPop(ForwardingObjective fwd) { |
| if (fwd.treatment() != null) { |
| for (Instruction instr : fwd.treatment().allInstructions()) { |
| if (instr instanceof L2ModificationInstruction |
| && ((L2ModificationInstruction) instr) |
| .subtype() == L2SubType.MPLS_POP) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Returns true iff the given selector matches on ethtype==ipv6, indicating |
| * that the selector is trying to match on ipv6 traffic. |
| * |
| * @param selector the given match |
| * @return true iff ethtype==ipv6; false otherwise |
| */ |
| static boolean isIpv6(TrafficSelector selector) { |
| EthTypeCriterion ethTypeCriterion = (EthTypeCriterion) selector.getCriterion(ETH_TYPE); |
| return ethTypeCriterion != null && ethTypeCriterion.ethType().toShort() == Ethernet.TYPE_IPV6; |
| } |
| |
| /** |
| * Reads vlan id from selector. |
| * |
| * @param selector the given match |
| * @return the vlan id if found. null otherwise |
| */ |
| static VlanId readVlanFromSelector(TrafficSelector selector) { |
| if (selector == null) { |
| return null; |
| } |
| Criterion criterion = selector.getCriterion(Criterion.Type.VLAN_VID); |
| return (criterion == null) |
| ? null : ((VlanIdCriterion) criterion).vlanId(); |
| } |
| |
| /** |
| * Reads eth dst from selector. |
| * |
| * @param selector the given match |
| * @return the eth dst if found. null otherwise |
| */ |
| static MacAddress readEthDstFromSelector(TrafficSelector selector) { |
| if (selector == null) { |
| return null; |
| } |
| Criterion criterion = selector.getCriterion(Criterion.Type.ETH_DST); |
| return (criterion == null) |
| ? null : ((EthCriterion) criterion).mac(); |
| } |
| |
| /** |
| * Reads ipv4 dst from selector. |
| * |
| * @param selector the given match |
| * @return the ipv4 dst if found. null otherwise |
| */ |
| static IpPrefix readIpDstFromSelector(TrafficSelector selector) { |
| if (selector == null) { |
| return null; |
| } |
| Criterion criterion = selector.getCriterion(Criterion.Type.IPV4_DST); |
| return (criterion == null) ? null : ((IPCriterion) criterion).ip(); |
| } |
| |
| /** |
| * Reads vlan id from treatment. |
| * |
| * @param treatment the given actions |
| * @return the vlan id if found. null otherwise |
| */ |
| static VlanId readVlanFromTreatment(TrafficTreatment treatment) { |
| if (treatment == null) { |
| return null; |
| } |
| for (Instruction i : treatment.allInstructions()) { |
| if (i instanceof ModVlanIdInstruction) { |
| return ((ModVlanIdInstruction) i).vlanId(); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Reads eth dst from treatment. |
| * |
| * @param treatment the given actions |
| * @return the eth dst if found. null otherwise |
| */ |
| static MacAddress readEthDstFromTreatment(TrafficTreatment treatment) { |
| if (treatment == null) { |
| return null; |
| } |
| for (Instruction i : treatment.allInstructions()) { |
| if (i instanceof ModEtherInstruction) { |
| ModEtherInstruction modEtherInstruction = (ModEtherInstruction) i; |
| if (modEtherInstruction.subtype() == L2SubType.ETH_DST) { |
| return modEtherInstruction.mac(); |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Reads extensions from selector. |
| * @param selector the given match |
| * @return the extensions if found. null otherwise |
| */ |
| static ExtensionSelector readExtensionFromSelector(TrafficSelector selector) { |
| if (selector == null) { |
| return null; |
| } |
| ExtensionCriterion criterion = (ExtensionCriterion) selector.getCriterion(Criterion.Type.EXTENSION); |
| return (criterion == null) ? null : criterion.extensionSelector(); |
| } |
| |
| /** |
| * Determines if the filtering objective will be used for a pseudowire. |
| * |
| * @param filteringObjective the filtering objective |
| * @return True if objective was created for a pseudowire, false otherwise. |
| */ |
| static boolean isPseudowire(FilteringObjective filteringObjective) { |
| if (filteringObjective.meta() != null) { |
| TrafficTreatment treatment = filteringObjective.meta(); |
| for (Instruction instr : treatment.immediate()) { |
| if (instr.type().equals(Instruction.Type.L2MODIFICATION)) { |
| |
| L2ModificationInstruction l2Instr = (L2ModificationInstruction) instr; |
| if (l2Instr.subtype().equals(L2SubType.TUNNEL_ID)) { |
| return true; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Utility function to get the mod tunnel id instruction |
| * if present. |
| * |
| * @param treatment the treatment to analyze |
| * @return the mod tunnel id instruction if present, |
| * otherwise null |
| */ |
| static ModTunnelIdInstruction getModTunnelIdInstruction(TrafficTreatment treatment) { |
| if (treatment == null) { |
| return null; |
| } |
| L2ModificationInstruction l2ModificationInstruction; |
| for (Instruction instruction : treatment.allInstructions()) { |
| if (instruction.type() == L2MODIFICATION) { |
| l2ModificationInstruction = (L2ModificationInstruction) instruction; |
| if (l2ModificationInstruction.subtype() == L2SubType.TUNNEL_ID) { |
| return (ModTunnelIdInstruction) l2ModificationInstruction; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Utility function to get the output instruction |
| * if present. |
| * |
| * @param treatment the treatment to analyze |
| * @return the output instruction if present, |
| * otherwise null |
| */ |
| static Instructions.OutputInstruction getOutputInstruction(TrafficTreatment treatment) { |
| if (treatment == null) { |
| return null; |
| } |
| for (Instruction instruction : treatment.allInstructions()) { |
| if (instruction.type() == Instruction.Type.OUTPUT) { |
| return (Instructions.OutputInstruction) instruction; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Determines if the filtering objective will be used for double-tagged packets. |
| * |
| * @param fob Filtering objective |
| * @return True if the objective was created for double-tagged packets, false otherwise. |
| */ |
| static boolean isDoubleTagged(FilteringObjective fob) { |
| return fob.meta() != null && |
| fob.meta().allInstructions().stream().anyMatch(inst -> inst.type() == L2MODIFICATION |
| && ((L2ModificationInstruction) inst).subtype() == L2SubType.VLAN_POP) && |
| fob.conditions().stream().anyMatch(criterion -> criterion.type() == VLAN_VID) && |
| fob.conditions().stream().anyMatch(criterion -> criterion.type() == INNER_VLAN_VID); |
| } |
| |
| } |