1 /* 2 * Copyright (C) 2017 Netronome Systems, Inc. 3 * 4 * This software is dual licensed under the GNU General License Version 2, 5 * June 1991 as shown in the file COPYING in the top-level directory of this 6 * source tree or the BSD 2-Clause License provided below. You have the 7 * option to license this software under the complete terms of either license. 8 * 9 * The BSD 2-Clause License: 10 * 11 * Redistribution and use in source and binary forms, with or 12 * without modification, are permitted provided that the following 13 * conditions are met: 14 * 15 * 1. Redistributions of source code must retain the above 16 * copyright notice, this list of conditions and the following 17 * disclaimer. 18 * 19 * 2. Redistributions in binary form must reproduce the above 20 * copyright notice, this list of conditions and the following 21 * disclaimer in the documentation and/or other materials 22 * provided with the distribution. 23 * 24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 31 * SOFTWARE. 32 */ 33 34 #include <linux/bitfield.h> 35 #include <net/pkt_cls.h> 36 #include <net/switchdev.h> 37 #include <net/tc_act/tc_gact.h> 38 #include <net/tc_act/tc_mirred.h> 39 #include <net/tc_act/tc_vlan.h> 40 41 #include "cmsg.h" 42 #include "main.h" 43 #include "../nfp_net_repr.h" 44 45 static void nfp_fl_pop_vlan(struct nfp_fl_pop_vlan *pop_vlan) 46 { 47 size_t act_size = sizeof(struct nfp_fl_pop_vlan); 48 u16 tmp_pop_vlan_op; 49 50 tmp_pop_vlan_op = 51 FIELD_PREP(NFP_FL_ACT_LEN_LW, act_size >> NFP_FL_LW_SIZ) | 52 FIELD_PREP(NFP_FL_ACT_JMP_ID, NFP_FL_ACTION_OPCODE_POP_VLAN); 53 54 pop_vlan->a_op = cpu_to_be16(tmp_pop_vlan_op); 55 pop_vlan->reserved = 0; 56 } 57 58 static void 59 nfp_fl_push_vlan(struct nfp_fl_push_vlan *push_vlan, 60 const struct tc_action *action) 61 { 62 size_t act_size = sizeof(struct nfp_fl_push_vlan); 63 struct tcf_vlan *vlan = to_vlan(action); 64 u16 tmp_push_vlan_tci; 65 u16 tmp_push_vlan_op; 66 67 tmp_push_vlan_op = 68 FIELD_PREP(NFP_FL_ACT_LEN_LW, act_size >> NFP_FL_LW_SIZ) | 69 FIELD_PREP(NFP_FL_ACT_JMP_ID, NFP_FL_ACTION_OPCODE_PUSH_VLAN); 70 71 push_vlan->a_op = cpu_to_be16(tmp_push_vlan_op); 72 /* Set action push vlan parameters. */ 73 push_vlan->reserved = 0; 74 push_vlan->vlan_tpid = tcf_vlan_push_proto(action); 75 76 tmp_push_vlan_tci = 77 FIELD_PREP(NFP_FL_PUSH_VLAN_PRIO, vlan->tcfv_push_prio) | 78 FIELD_PREP(NFP_FL_PUSH_VLAN_VID, vlan->tcfv_push_vid) | 79 NFP_FL_PUSH_VLAN_CFI; 80 push_vlan->vlan_tci = cpu_to_be16(tmp_push_vlan_tci); 81 } 82 83 static int 84 nfp_fl_output(struct nfp_fl_output *output, const struct tc_action *action, 85 struct nfp_fl_payload *nfp_flow, bool last, 86 struct net_device *in_dev) 87 { 88 size_t act_size = sizeof(struct nfp_fl_output); 89 struct net_device *out_dev; 90 u16 tmp_output_op; 91 int ifindex; 92 93 /* Set action opcode to output action. */ 94 tmp_output_op = 95 FIELD_PREP(NFP_FL_ACT_LEN_LW, act_size >> NFP_FL_LW_SIZ) | 96 FIELD_PREP(NFP_FL_ACT_JMP_ID, NFP_FL_ACTION_OPCODE_OUTPUT); 97 98 output->a_op = cpu_to_be16(tmp_output_op); 99 100 /* Set action output parameters. */ 101 output->flags = cpu_to_be16(last ? NFP_FL_OUT_FLAGS_LAST : 0); 102 103 ifindex = tcf_mirred_ifindex(action); 104 out_dev = __dev_get_by_index(dev_net(in_dev), ifindex); 105 if (!out_dev) 106 return -EOPNOTSUPP; 107 108 /* Only offload egress ports are on the same device as the ingress 109 * port. 110 */ 111 if (!switchdev_port_same_parent_id(in_dev, out_dev)) 112 return -EOPNOTSUPP; 113 if (!nfp_netdev_is_nfp_repr(out_dev)) 114 return -EOPNOTSUPP; 115 116 output->port = cpu_to_be32(nfp_repr_get_port_id(out_dev)); 117 if (!output->port) 118 return -EOPNOTSUPP; 119 120 nfp_flow->meta.shortcut = output->port; 121 122 return 0; 123 } 124 125 static int 126 nfp_flower_loop_action(const struct tc_action *a, 127 struct nfp_fl_payload *nfp_fl, int *a_len, 128 struct net_device *netdev) 129 { 130 struct nfp_fl_push_vlan *psh_v; 131 struct nfp_fl_pop_vlan *pop_v; 132 struct nfp_fl_output *output; 133 int err; 134 135 if (is_tcf_gact_shot(a)) { 136 nfp_fl->meta.shortcut = cpu_to_be32(NFP_FL_SC_ACT_DROP); 137 } else if (is_tcf_mirred_egress_redirect(a)) { 138 if (*a_len + sizeof(struct nfp_fl_output) > NFP_FL_MAX_A_SIZ) 139 return -EOPNOTSUPP; 140 141 output = (struct nfp_fl_output *)&nfp_fl->action_data[*a_len]; 142 err = nfp_fl_output(output, a, nfp_fl, true, netdev); 143 if (err) 144 return err; 145 146 *a_len += sizeof(struct nfp_fl_output); 147 } else if (is_tcf_mirred_egress_mirror(a)) { 148 if (*a_len + sizeof(struct nfp_fl_output) > NFP_FL_MAX_A_SIZ) 149 return -EOPNOTSUPP; 150 151 output = (struct nfp_fl_output *)&nfp_fl->action_data[*a_len]; 152 err = nfp_fl_output(output, a, nfp_fl, false, netdev); 153 if (err) 154 return err; 155 156 *a_len += sizeof(struct nfp_fl_output); 157 } else if (is_tcf_vlan(a) && tcf_vlan_action(a) == TCA_VLAN_ACT_POP) { 158 if (*a_len + sizeof(struct nfp_fl_pop_vlan) > NFP_FL_MAX_A_SIZ) 159 return -EOPNOTSUPP; 160 161 pop_v = (struct nfp_fl_pop_vlan *)&nfp_fl->action_data[*a_len]; 162 nfp_fl->meta.shortcut = cpu_to_be32(NFP_FL_SC_ACT_POPV); 163 164 nfp_fl_pop_vlan(pop_v); 165 *a_len += sizeof(struct nfp_fl_pop_vlan); 166 } else if (is_tcf_vlan(a) && tcf_vlan_action(a) == TCA_VLAN_ACT_PUSH) { 167 if (*a_len + sizeof(struct nfp_fl_push_vlan) > NFP_FL_MAX_A_SIZ) 168 return -EOPNOTSUPP; 169 170 psh_v = (struct nfp_fl_push_vlan *)&nfp_fl->action_data[*a_len]; 171 nfp_fl->meta.shortcut = cpu_to_be32(NFP_FL_SC_ACT_NULL); 172 173 nfp_fl_push_vlan(psh_v, a); 174 *a_len += sizeof(struct nfp_fl_push_vlan); 175 } else { 176 /* Currently we do not handle any other actions. */ 177 return -EOPNOTSUPP; 178 } 179 180 return 0; 181 } 182 183 int nfp_flower_compile_action(struct tc_cls_flower_offload *flow, 184 struct net_device *netdev, 185 struct nfp_fl_payload *nfp_flow) 186 { 187 int act_len, act_cnt, err; 188 const struct tc_action *a; 189 LIST_HEAD(actions); 190 191 memset(nfp_flow->action_data, 0, NFP_FL_MAX_A_SIZ); 192 nfp_flow->meta.act_len = 0; 193 act_len = 0; 194 act_cnt = 0; 195 196 tcf_exts_to_list(flow->exts, &actions); 197 list_for_each_entry(a, &actions, list) { 198 err = nfp_flower_loop_action(a, nfp_flow, &act_len, netdev); 199 if (err) 200 return err; 201 act_cnt++; 202 } 203 204 /* We optimise when the action list is small, this can unfortunately 205 * not happen once we have more than one action in the action list. 206 */ 207 if (act_cnt > 1) 208 nfp_flow->meta.shortcut = cpu_to_be32(NFP_FL_SC_ACT_NULL); 209 210 nfp_flow->meta.act_len = act_len; 211 212 return 0; 213 } 214