struct nfp_app *nfp_app_from_netdev(struct net_device *netdev) { if (nfp_netdev_is_nfp_net(netdev)) { struct nfp_net *nn = netdev_priv(netdev); return nn->app; } if (nfp_netdev_is_nfp_repr(netdev)) { struct nfp_repr *repr = netdev_priv(netdev); return repr->app; } WARN(1, "Unknown netdev type for nfp_app\n"); return NULL; }
static int nfp_flower_remove_rate_limiter(struct nfp_app *app, struct net_device *netdev, struct tc_cls_matchall_offload *flow, struct netlink_ext_ack *extack) { struct nfp_flower_priv *fl_priv = app->priv; struct nfp_flower_repr_priv *repr_priv; struct nfp_police_config *config; struct nfp_repr *repr; struct sk_buff *skb; u32 netdev_port_id; if (!nfp_netdev_is_nfp_repr(netdev)) { NL_SET_ERR_MSG_MOD(extack, "unsupported offload: qos rate limit offload not supported on higher level port"); return -EOPNOTSUPP; } repr = netdev_priv(netdev); netdev_port_id = nfp_repr_get_port_id(netdev); repr_priv = repr->app_priv; if (!repr_priv->qos_table.netdev_port_id) { NL_SET_ERR_MSG_MOD(extack, "unsupported offload: cannot remove qos entry that does not exist"); return -EOPNOTSUPP; } skb = nfp_flower_cmsg_alloc(repr->app, sizeof(struct nfp_police_config), NFP_FLOWER_CMSG_TYPE_QOS_DEL, GFP_KERNEL); if (!skb) return -ENOMEM; /* Clear all qos associate data for this interface */ memset(&repr_priv->qos_table, 0, sizeof(struct nfp_fl_qos)); fl_priv->qos_rate_limiters--; if (!fl_priv->qos_rate_limiters) cancel_delayed_work_sync(&fl_priv->qos_stats_work); config = nfp_flower_cmsg_get_data(skb); memset(config, 0, sizeof(struct nfp_police_config)); config->head.port = cpu_to_be32(netdev_port_id); nfp_ctrl_tx(repr->app->ctrl, skb); return 0; }
static int nfp_flower_stats_rate_limiter(struct nfp_app *app, struct net_device *netdev, struct tc_cls_matchall_offload *flow, struct netlink_ext_ack *extack) { struct nfp_flower_priv *fl_priv = app->priv; struct nfp_flower_repr_priv *repr_priv; struct nfp_stat_pair *curr_stats; struct nfp_stat_pair *prev_stats; u64 diff_bytes, diff_pkts; struct nfp_repr *repr; if (!nfp_netdev_is_nfp_repr(netdev)) { NL_SET_ERR_MSG_MOD(extack, "unsupported offload: qos rate limit offload not supported on higher level port"); return -EOPNOTSUPP; } repr = netdev_priv(netdev); repr_priv = repr->app_priv; if (!repr_priv->qos_table.netdev_port_id) { NL_SET_ERR_MSG_MOD(extack, "unsupported offload: cannot find qos entry for stats update"); return -EOPNOTSUPP; } spin_lock_bh(&fl_priv->qos_stats_lock); curr_stats = &repr_priv->qos_table.curr_stats; prev_stats = &repr_priv->qos_table.prev_stats; diff_pkts = curr_stats->pkts - prev_stats->pkts; diff_bytes = curr_stats->bytes - prev_stats->bytes; prev_stats->pkts = curr_stats->pkts; prev_stats->bytes = curr_stats->bytes; spin_unlock_bh(&fl_priv->qos_stats_lock); flow_stats_update(&flow->stats, diff_bytes, diff_pkts, repr_priv->qos_table.last_update); return 0; }
static int nfp_flower_install_rate_limiter(struct nfp_app *app, struct net_device *netdev, struct tc_cls_matchall_offload *flow, struct netlink_ext_ack *extack) { struct flow_action_entry *action = &flow->rule->action.entries[0]; struct nfp_flower_priv *fl_priv = app->priv; struct nfp_flower_repr_priv *repr_priv; struct nfp_police_config *config; struct nfp_repr *repr; struct sk_buff *skb; u32 netdev_port_id; u64 burst, rate; if (!nfp_netdev_is_nfp_repr(netdev)) { NL_SET_ERR_MSG_MOD(extack, "unsupported offload: qos rate limit offload not supported on higher level port"); return -EOPNOTSUPP; } repr = netdev_priv(netdev); repr_priv = repr->app_priv; if (repr_priv->block_shared) { NL_SET_ERR_MSG_MOD(extack, "unsupported offload: qos rate limit offload not supported on shared blocks"); return -EOPNOTSUPP; } if (repr->port->type != NFP_PORT_VF_PORT) { NL_SET_ERR_MSG_MOD(extack, "unsupported offload: qos rate limit offload not supported on non-VF ports"); return -EOPNOTSUPP; } if (!flow_offload_has_one_action(&flow->rule->action)) { NL_SET_ERR_MSG_MOD(extack, "unsupported offload: qos rate limit offload requires a single action"); return -EOPNOTSUPP; } if (flow->common.prio != (1 << 16)) { NL_SET_ERR_MSG_MOD(extack, "unsupported offload: qos rate limit offload requires highest priority"); return -EOPNOTSUPP; } if (action->id != FLOW_ACTION_POLICE) { NL_SET_ERR_MSG_MOD(extack, "unsupported offload: qos rate limit offload requires police action"); return -EOPNOTSUPP; } rate = action->police.rate_bytes_ps; burst = div_u64(rate * PSCHED_NS2TICKS(action->police.burst), PSCHED_TICKS_PER_SEC); netdev_port_id = nfp_repr_get_port_id(netdev); skb = nfp_flower_cmsg_alloc(repr->app, sizeof(struct nfp_police_config), NFP_FLOWER_CMSG_TYPE_QOS_MOD, GFP_KERNEL); if (!skb) return -ENOMEM; config = nfp_flower_cmsg_get_data(skb); memset(config, 0, sizeof(struct nfp_police_config)); config->head.port = cpu_to_be32(netdev_port_id); config->bkt_tkn_p = cpu_to_be32(burst); config->bkt_tkn_c = cpu_to_be32(burst); config->pbs = cpu_to_be32(burst); config->cbs = cpu_to_be32(burst); config->pir = cpu_to_be32(rate); config->cir = cpu_to_be32(rate); nfp_ctrl_tx(repr->app->ctrl, skb); repr_priv->qos_table.netdev_port_id = netdev_port_id; fl_priv->qos_rate_limiters++; if (fl_priv->qos_rate_limiters == 1) schedule_delayed_work(&fl_priv->qos_stats_work, NFP_FL_QOS_UPDATE); return 0; }
int nfp_flower_compile_flow_match(struct nfp_app *app, struct tc_cls_flower_offload *flow, struct nfp_fl_key_ls *key_ls, struct net_device *netdev, struct nfp_fl_payload *nfp_flow, enum nfp_flower_tun_type tun_type) { u32 cmsg_port = 0; int err; u8 *ext; u8 *msk; if (nfp_netdev_is_nfp_repr(netdev)) cmsg_port = nfp_repr_get_port_id(netdev); memset(nfp_flow->unmasked_data, 0, key_ls->key_size); memset(nfp_flow->mask_data, 0, key_ls->key_size); ext = nfp_flow->unmasked_data; msk = nfp_flow->mask_data; nfp_flower_compile_meta_tci((struct nfp_flower_meta_tci *)ext, (struct nfp_flower_meta_tci *)msk, flow, key_ls->key_layer); ext += sizeof(struct nfp_flower_meta_tci); msk += sizeof(struct nfp_flower_meta_tci); /* Populate Extended Metadata if Required. */ if (NFP_FLOWER_LAYER_EXT_META & key_ls->key_layer) { nfp_flower_compile_ext_meta((struct nfp_flower_ext_meta *)ext, key_ls->key_layer_two); nfp_flower_compile_ext_meta((struct nfp_flower_ext_meta *)msk, key_ls->key_layer_two); ext += sizeof(struct nfp_flower_ext_meta); msk += sizeof(struct nfp_flower_ext_meta); } /* Populate Exact Port data. */ err = nfp_flower_compile_port((struct nfp_flower_in_port *)ext, cmsg_port, false, tun_type); if (err) return err; /* Populate Mask Port Data. */ err = nfp_flower_compile_port((struct nfp_flower_in_port *)msk, cmsg_port, true, tun_type); if (err) return err; ext += sizeof(struct nfp_flower_in_port); msk += sizeof(struct nfp_flower_in_port); if (NFP_FLOWER_LAYER_MAC & key_ls->key_layer) { nfp_flower_compile_mac((struct nfp_flower_mac_mpls *)ext, (struct nfp_flower_mac_mpls *)msk, flow); ext += sizeof(struct nfp_flower_mac_mpls); msk += sizeof(struct nfp_flower_mac_mpls); } if (NFP_FLOWER_LAYER_TP & key_ls->key_layer) { nfp_flower_compile_tport((struct nfp_flower_tp_ports *)ext, (struct nfp_flower_tp_ports *)msk, flow); ext += sizeof(struct nfp_flower_tp_ports); msk += sizeof(struct nfp_flower_tp_ports); } if (NFP_FLOWER_LAYER_IPV4 & key_ls->key_layer) { nfp_flower_compile_ipv4((struct nfp_flower_ipv4 *)ext, (struct nfp_flower_ipv4 *)msk, flow); ext += sizeof(struct nfp_flower_ipv4); msk += sizeof(struct nfp_flower_ipv4); } if (NFP_FLOWER_LAYER_IPV6 & key_ls->key_layer) { nfp_flower_compile_ipv6((struct nfp_flower_ipv6 *)ext, (struct nfp_flower_ipv6 *)msk, flow); ext += sizeof(struct nfp_flower_ipv6); msk += sizeof(struct nfp_flower_ipv6); } if (key_ls->key_layer & NFP_FLOWER_LAYER_VXLAN || key_ls->key_layer_two & NFP_FLOWER_LAYER2_GENEVE) { __be32 tun_dst; nfp_flower_compile_ipv4_udp_tun((void *)ext, (void *)msk, flow); tun_dst = ((struct nfp_flower_ipv4_udp_tun *)ext)->ip_dst; ext += sizeof(struct nfp_flower_ipv4_udp_tun); msk += sizeof(struct nfp_flower_ipv4_udp_tun); /* Store the tunnel destination in the rule data. * This must be present and be an exact match. */ nfp_flow->nfp_tun_ipv4_addr = tun_dst; nfp_tunnel_add_ipv4_off(app, tun_dst); if (key_ls->key_layer_two & NFP_FLOWER_LAYER2_GENEVE_OP) { err = nfp_flower_compile_geneve_opt(ext, msk, flow); if (err) return err; } } return 0; }