| /* |
| * Copyright 2017-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.pipelines.fabric.pipeliner; |
| |
| import com.google.common.collect.Lists; |
| import org.onlab.packet.Ethernet; |
| import org.onlab.packet.MacAddress; |
| import org.onlab.packet.VlanId; |
| import org.onlab.util.ImmutableByteSequence; |
| import org.onosproject.net.DeviceId; |
| import org.onosproject.net.PortNumber; |
| import org.onosproject.net.flow.DefaultFlowRule; |
| import org.onosproject.net.flow.DefaultTrafficSelector; |
| import org.onosproject.net.flow.DefaultTrafficTreatment; |
| 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.PiCriterion; |
| import org.onosproject.net.flow.criteria.PortCriterion; |
| import org.onosproject.net.flow.criteria.VlanIdCriterion; |
| import org.onosproject.net.flowobjective.FilteringObjective; |
| import org.onosproject.net.flowobjective.ObjectiveError; |
| import org.onosproject.net.pi.runtime.PiAction; |
| import org.onosproject.net.pi.runtime.PiActionParam; |
| import org.onosproject.pipelines.fabric.FabricConstants; |
| import org.slf4j.Logger; |
| |
| import java.util.Collection; |
| |
| import static org.slf4j.LoggerFactory.getLogger; |
| |
| /** |
| * Handling filtering objective for fabric pipeliner. |
| */ |
| public class FabricFilteringPipeliner { |
| private static final Logger log = getLogger(FabricFilteringPipeliner.class); |
| // Forwarding types |
| static final byte FWD_BRIDGING = 0; |
| static final byte FWD_MPLS = 1; |
| static final byte FWD_IPV4_ROUTING = 2; |
| static final byte FWD_IPV6_ROUTING = 3; |
| private static final PiCriterion VLAN_VALID = PiCriterion.builder() |
| .matchExact(FabricConstants.HDR_VLAN_TAG_IS_VALID, new byte[]{1}) |
| .build(); |
| private static final PiCriterion VLAN_INVALID = PiCriterion.builder() |
| .matchExact(FabricConstants.HDR_VLAN_TAG_IS_VALID, new byte[]{0}) |
| .build(); |
| |
| protected DeviceId deviceId; |
| |
| public FabricFilteringPipeliner(DeviceId deviceId) { |
| this.deviceId = deviceId; |
| } |
| |
| /** |
| * Translates filtering objective to flows and groups. |
| * |
| * @param filterObjective the filtering objective |
| * @return translation result, contains flows, groups or error it generated |
| */ |
| public PipelinerTranslationResult filter(FilteringObjective filterObjective) { |
| PipelinerTranslationResult.Builder resultBuilder = PipelinerTranslationResult.builder(); |
| // maps selector and treatment from filtering objective to filtering |
| // control block. |
| |
| if (filterObjective.type() == FilteringObjective.Type.DENY) { |
| log.warn("Unsupported filtering objective type {}", filterObjective.type()); |
| resultBuilder.setError(ObjectiveError.UNSUPPORTED); |
| return resultBuilder.build(); |
| } |
| |
| if (filterObjective.key() == null || |
| filterObjective.key().type() != Criterion.Type.IN_PORT) { |
| log.warn("Unsupported filter key {}", filterObjective.key()); |
| resultBuilder.setError(ObjectiveError.BADPARAMS); |
| return resultBuilder.build(); |
| } |
| PortCriterion inPortCriterion = (PortCriterion) filterObjective.key(); |
| VlanIdCriterion vlanCriterion = filterObjective.conditions().stream() |
| .filter(criterion -> criterion.type() == Criterion.Type.VLAN_VID) |
| .map(criterion -> (VlanIdCriterion) criterion) |
| .findFirst() |
| .orElse(null); |
| EthCriterion ethDstCriterion = filterObjective.conditions().stream() |
| .filter(criterion -> criterion.type() == Criterion.Type.ETH_DST) |
| .map(criterion -> (EthCriterion) criterion) |
| .findFirst() |
| .orElse(null); |
| EthCriterion ethDstMaskedCriterion = filterObjective.conditions().stream() |
| .filter(criterion -> criterion.type() == Criterion.Type.ETH_DST_MASKED) |
| .map(criterion -> (EthCriterion) criterion) |
| .findFirst() |
| .orElse(null); |
| |
| FlowRule inPortVlanTableRule = createInPortVlanTable(inPortCriterion, vlanCriterion, |
| filterObjective); |
| Collection<FlowRule> fwdClassifierRules = createFwdClassifierRules(inPortCriterion, ethDstCriterion, |
| ethDstMaskedCriterion, filterObjective); |
| |
| resultBuilder.addFlowRule(inPortVlanTableRule); |
| fwdClassifierRules.forEach(resultBuilder::addFlowRule); |
| return resultBuilder.build(); |
| } |
| |
| private FlowRule createInPortVlanTable(Criterion inPortCriterion, |
| VlanIdCriterion vlanCriterion, |
| FilteringObjective filterObjective) { |
| Criterion vlanIsVlalidCriterion; |
| TrafficSelector.Builder selector = DefaultTrafficSelector.builder() |
| .add(inPortCriterion); |
| |
| VlanId vlanId = null; |
| if (vlanCriterion != null) { |
| vlanId = vlanCriterion.vlanId(); |
| } |
| |
| vlanIsVlalidCriterion = VLAN_VALID; |
| if (vlanId == null || vlanId.equals(VlanId.NONE)) { |
| // untag vlan, match in port only |
| vlanIsVlalidCriterion = VLAN_INVALID; |
| } |
| |
| selector.add(vlanIsVlalidCriterion); |
| |
| // TODO: check if this treatment is valid or not |
| TrafficTreatment treatment = filterObjective.meta(); |
| if (treatment == null) { |
| treatment = DefaultTrafficTreatment.emptyTreatment(); |
| } |
| |
| return DefaultFlowRule.builder() |
| .fromApp(filterObjective.appId()) |
| .withPriority(filterObjective.priority()) |
| .withSelector(selector.build()) |
| .withTreatment(treatment) |
| .withPriority(filterObjective.priority()) |
| .forTable(FabricConstants.FABRIC_INGRESS_FILTERING_INGRESS_PORT_VLAN) |
| .forDevice(deviceId) |
| .makePermanent() |
| .build(); |
| } |
| |
| private Collection<FlowRule> createFwdClassifierRules(PortCriterion inPortCriterion, |
| EthCriterion ethDstCriterion, |
| EthCriterion ethDstMaskedCriterion, |
| FilteringObjective filterObjective) { |
| PortNumber port = inPortCriterion.port(); |
| |
| Collection<FlowRule> flowRules = Lists.newArrayList(); |
| if (ethDstCriterion == null) { |
| if (ethDstMaskedCriterion == null) { |
| // Bridging table, do nothing |
| return flowRules; |
| } |
| // Masked fwd classifier rule |
| MacAddress dstMac = ethDstMaskedCriterion.mac(); |
| MacAddress dstMacMask = ethDstMaskedCriterion.mask(); |
| FlowRule flow = createMaskedFwdClassifierRule(port, dstMac, dstMacMask, filterObjective); |
| if (flow != null) { |
| flowRules.add(flow); |
| } |
| return flowRules; |
| } |
| MacAddress dstMac = ethDstCriterion.mac(); |
| flowRules.addAll(createIpFwdClassifierRules(port, dstMac, filterObjective)); |
| flowRules.add(createMplsFwdClassifierRule(port, dstMac, filterObjective)); |
| return flowRules; |
| } |
| |
| private FlowRule createMaskedFwdClassifierRule(PortNumber inPort, MacAddress dstMac, MacAddress dstMacMask, |
| FilteringObjective filterObjective) { |
| TrafficTreatment treatment; |
| short ethType; |
| if (dstMac.equals(MacAddress.IPV4_MULTICAST) && dstMacMask.equals(MacAddress.IPV4_MULTICAST_MASK)) { |
| treatment = createFwdClassifierTreatment(FWD_IPV4_ROUTING); |
| ethType = Ethernet.TYPE_IPV4; |
| } else if (dstMac.equals(MacAddress.IPV6_MULTICAST) && dstMacMask.equals(MacAddress.IPV6_MULTICAST_MASK)) { |
| treatment = createFwdClassifierTreatment(FWD_IPV6_ROUTING); |
| ethType = Ethernet.TYPE_IPV6; |
| } else { |
| log.warn("Unsupported masked fwd classifier rule. mac={}. mask={}", dstMac, dstMacMask); |
| return null; |
| } |
| return createFwdClassifierRule(inPort, ethType, dstMac, dstMacMask, treatment, filterObjective); |
| } |
| |
| private Collection<FlowRule> createIpFwdClassifierRules(PortNumber inPort, |
| MacAddress dstMac, |
| FilteringObjective filterObjective) { |
| Collection<FlowRule> flowRules = Lists.newArrayList(); |
| TrafficTreatment treatment; |
| treatment = createFwdClassifierTreatment(FWD_IPV4_ROUTING); |
| flowRules.add(createFwdClassifierRule(inPort, Ethernet.TYPE_IPV4, dstMac, null, treatment, filterObjective)); |
| treatment = createFwdClassifierTreatment(FWD_IPV6_ROUTING); |
| flowRules.add(createFwdClassifierRule(inPort, Ethernet.TYPE_IPV6, dstMac, null, treatment, filterObjective)); |
| return flowRules; |
| } |
| |
| private FlowRule createMplsFwdClassifierRule(PortNumber inPort, |
| MacAddress dstMac, |
| FilteringObjective filterObjective) { |
| TrafficTreatment treatment = createFwdClassifierTreatment(FWD_MPLS); |
| return createFwdClassifierRule(inPort, Ethernet.MPLS_UNICAST, dstMac, null, treatment, filterObjective); |
| } |
| |
| private FlowRule createFwdClassifierRule(PortNumber inPort, |
| short ethType, |
| MacAddress dstMac, |
| MacAddress dstMacMask, |
| TrafficTreatment treatment, |
| FilteringObjective filterObjective) { |
| TrafficSelector.Builder selector = DefaultTrafficSelector.builder() |
| .matchInPort(inPort) |
| .matchEthType(ethType); |
| if (dstMacMask != null) { |
| selector.matchEthDstMasked(dstMac, dstMacMask); |
| } else { |
| selector.matchEthDstMasked(dstMac, MacAddress.EXACT_MASK); |
| } |
| |
| return DefaultFlowRule.builder() |
| .withSelector(selector.build()) |
| .withTreatment(treatment) |
| .fromApp(filterObjective.appId()) |
| .withPriority(filterObjective.priority()) |
| .forDevice(deviceId) |
| .makePermanent() |
| .forTable(FabricConstants.FABRIC_INGRESS_FILTERING_FWD_CLASSIFIER) |
| .build(); |
| } |
| |
| private TrafficTreatment createFwdClassifierTreatment(byte fwdType) { |
| PiActionParam param = new PiActionParam(FabricConstants.FWD_TYPE, |
| ImmutableByteSequence.copyFrom(fwdType)); |
| PiAction action = PiAction.builder() |
| .withId(FabricConstants.FABRIC_INGRESS_FILTERING_SET_FORWARDING_TYPE) |
| .withParameter(param) |
| .build(); |
| return DefaultTrafficTreatment.builder() |
| .piTableAction(action) |
| .build(); |
| |
| } |
| } |