LXR linux/drivers/net/ethernet/mellanox/mlx5/core/fs

   1/*
   2 * Copyright (c) 2015, Mellanox Technologies. All rights reserved.
   3 *
   4 * This software is available to you under a choice of one of two
   5 * licenses.  You may choose to be licensed under the terms of the GNU
   6 * General Public License (GPL) Version 2, available from the file
   7 * COPYING in the main directory of this source tree, or the
   8 * OpenIB.org BSD license below:
   9 *
  10 *     Redistribution and use in source and binary forms, with or
  11 *     without modification, are permitted provided that the following
  12 *     conditions are met:
  13 *
  14 *      - Redistributions of source code must retain the above
  15 *        copyright notice, this list of conditions and the following
  16 *        disclaimer.
  17 *
  18 *      - Redistributions in binary form must reproduce the above
  19 *        copyright notice, this list of conditions and the following
  20 *        disclaimer in the documentation and/or other materials
  21 *        provided with the distribution.
  22 *
  23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30 * SOFTWARE.
  31 */
  32
  33#ifndef _MLX5_FS_CORE_
  34#define _MLX5_FS_CORE_
  35
  36#include <linux/mlx5/fs.h>
  37
  38enum fs_node_type {
  39        FS_TYPE_NAMESPACE,
  40        FS_TYPE_PRIO,
  41        FS_TYPE_FLOW_TABLE,
  42        FS_TYPE_FLOW_GROUP,
  43        FS_TYPE_FLOW_ENTRY,
  44        FS_TYPE_FLOW_DEST
  45};
  46
  47enum fs_flow_table_type {
  48        FS_FT_NIC_RX     = 0x0,
  49        FS_FT_FDB        = 0X4,
  50};
  51
  52enum fs_fte_status {
  53        FS_FTE_STATUS_EXISTING = 1UL << 0,
  54};
  55
  56struct fs_node {
  57        struct list_head        list;
  58        struct list_head        children;
  59        enum fs_node_type       type;
  60        struct fs_node          *parent;
  61        struct fs_node          *root;
  62        /* lock the node for writing and traversing */
  63        struct mutex            lock;
  64        atomic_t                refcount;
  65        void                    (*remove_func)(struct fs_node *);
  66};
  67
  68struct mlx5_flow_rule {
  69        struct fs_node                          node;
  70        struct mlx5_flow_destination            dest_attr;
  71        /* next_ft should be accessed under chain_lock and only of
  72         * destination type is FWD_NEXT_fT.
  73         */
  74        struct list_head                        next_ft;
  75        u32                                     sw_action;
  76};
  77
  78/* Type of children is mlx5_flow_group */
  79struct mlx5_flow_table {
  80        struct fs_node                  node;
  81        u32                             id;
  82        unsigned int                    max_fte;
  83        unsigned int                    level;
  84        enum fs_flow_table_type         type;
  85        struct {
  86                bool                    active;
  87                unsigned int            required_groups;
  88                unsigned int            num_groups;
  89        } autogroup;
  90        /* Protect fwd_rules */
  91        struct mutex                    lock;
  92        /* FWD rules that point on this flow table */
  93        struct list_head                fwd_rules;
  94};
  95
  96/* Type of children is mlx5_flow_rule */
  97struct fs_fte {
  98        struct fs_node                  node;
  99        u32                             val[MLX5_ST_SZ_DW(fte_match_param)];
 100        u32                             dests_size;
 101        u32                             flow_tag;
 102        u32                             index;
 103        u32                             action;
 104        enum fs_fte_status              status;
 105};
 106
 107/* Type of children is mlx5_flow_table/namespace */
 108struct fs_prio {
 109        struct fs_node                  node;
 110        unsigned int                    max_ft;
 111        unsigned int                    start_level;
 112        unsigned int                    prio;
 113        unsigned int                    num_ft;
 114};
 115
 116/* Type of children is fs_prio */
 117struct mlx5_flow_namespace {
 118        /* parent == NULL => root ns */
 119        struct  fs_node                 node;
 120};
 121
 122struct mlx5_flow_group_mask {
 123        u8      match_criteria_enable;
 124        u32     match_criteria[MLX5_ST_SZ_DW(fte_match_param)];
 125};
 126
 127/* Type of children is fs_fte */
 128struct mlx5_flow_group {
 129        struct fs_node                  node;
 130        struct mlx5_flow_group_mask     mask;
 131        u32                             start_index;
 132        u32                             max_ftes;
 133        u32                             num_ftes;
 134        u32                             id;
 135};
 136
 137struct mlx5_flow_root_namespace {
 138        struct mlx5_flow_namespace      ns;
 139        enum   fs_flow_table_type       table_type;
 140        struct mlx5_core_dev            *dev;
 141        struct mlx5_flow_table          *root_ft;
 142        /* Should be held when chaining flow tables */
 143        struct mutex                    chain_lock;
 144};
 145
 146int mlx5_init_fs(struct mlx5_core_dev *dev);
 147void mlx5_cleanup_fs(struct mlx5_core_dev *dev);
 148
 149#define fs_get_obj(v, _node)  {v = container_of((_node), typeof(*v), node); }
 150
 151#define fs_list_for_each_entry(pos, root)               \
 152        list_for_each_entry(pos, root, node.list)
 153
 154#define fs_list_for_each_entry_safe(pos, tmp, root)             \
 155        list_for_each_entry_safe(pos, tmp, root, node.list)
 156
 157#define fs_for_each_ns_or_ft_reverse(pos, prio)                         \
 158        list_for_each_entry_reverse(pos, &(prio)->node.children, list)
 159
 160#define fs_for_each_ns_or_ft(pos, prio)                                 \
 161        list_for_each_entry(pos, (&(prio)->node.children), list)
 162
 163#define fs_for_each_prio(pos, ns)                       \
 164        fs_list_for_each_entry(pos, &(ns)->node.children)
 165
 166#define fs_for_each_ns(pos, prio)                       \
 167        fs_list_for_each_entry(pos, &(prio)->node.children)
 168
 169#define fs_for_each_ft(pos, prio)                       \
 170        fs_list_for_each_entry(pos, &(prio)->node.children)
 171
 172#define fs_for_each_ft_safe(pos, tmp, prio)                     \
 173        fs_list_for_each_entry_safe(pos, tmp, &(prio)->node.children)
 174
 175#define fs_for_each_fg(pos, ft)                 \
 176        fs_list_for_each_entry(pos, &(ft)->node.children)
 177
 178#define fs_for_each_fte(pos, fg)                        \
 179        fs_list_for_each_entry(pos, &(fg)->node.children)
 180
 181#define fs_for_each_dst(pos, fte)                       \
 182        fs_list_for_each_entry(pos, &(fte)->node.children)
 183
 184#endif
 185