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

   1/*
   2 * Copyright (c) 2017, 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#if !defined(_MLX5_FS_TP_) || defined(TRACE_HEADER_MULTI_READ)
  34#define _MLX5_FS_TP_
  35
  36#include <linux/tracepoint.h>
  37#include <linux/trace_seq.h>
  38#include "../fs_core.h"
  39
  40#undef TRACE_SYSTEM
  41#define TRACE_SYSTEM mlx5
  42
  43#define __parse_fs_hdrs(match_criteria_enable, mouter, mmisc, minner, vouter, \
  44                        vinner, vmisc)                                        \
  45        parse_fs_hdrs(p, match_criteria_enable, mouter, mmisc, minner, vouter,\
  46                      vinner, vmisc)
  47
  48const char *parse_fs_hdrs(struct trace_seq *p,
  49                          u8 match_criteria_enable,
  50                          const u32 *mask_outer,
  51                          const u32 *mask_misc,
  52                          const u32 *mask_inner,
  53                          const u32 *value_outer,
  54                          const u32 *value_misc,
  55                          const u32 *value_inner);
  56
  57#define __parse_fs_dst(dst, counter_id) \
  58        parse_fs_dst(p, (const struct mlx5_flow_destination *)dst, counter_id)
  59
  60const char *parse_fs_dst(struct trace_seq *p,
  61                         const struct mlx5_flow_destination *dst,
  62                         u32 counter_id);
  63
  64TRACE_EVENT(mlx5_fs_add_ft,
  65            TP_PROTO(const struct mlx5_flow_table *ft),
  66            TP_ARGS(ft),
  67            TP_STRUCT__entry(
  68                __field(const struct mlx5_flow_table *, ft)
  69                __field(u32, id)
  70                __field(u32, level)
  71                __field(u32, type)
  72            ),
  73            TP_fast_assign(
  74                           __entry->ft = ft;
  75                           __entry->id = ft->id;
  76                           __entry->level = ft->level;
  77                           __entry->type = ft->type;
  78            ),
  79            TP_printk("ft=%p id=%u level=%u type=%u \n",
  80                      __entry->ft, __entry->id, __entry->level, __entry->type)
  81            );
  82
  83TRACE_EVENT(mlx5_fs_del_ft,
  84            TP_PROTO(const struct mlx5_flow_table *ft),
  85            TP_ARGS(ft),
  86            TP_STRUCT__entry(
  87                __field(const struct mlx5_flow_table *, ft)
  88                __field(u32, id)
  89            ),
  90            TP_fast_assign(
  91                           __entry->ft = ft;
  92                           __entry->id = ft->id;
  93
  94            ),
  95            TP_printk("ft=%p id=%u\n",
  96                      __entry->ft, __entry->id)
  97            );
  98
  99TRACE_EVENT(mlx5_fs_add_fg,
 100            TP_PROTO(const struct mlx5_flow_group *fg),
 101            TP_ARGS(fg),
 102            TP_STRUCT__entry(
 103                __field(const struct mlx5_flow_group *, fg)
 104                __field(const struct mlx5_flow_table *, ft)
 105                __field(u32, start_index)
 106                __field(u32, end_index)
 107                __field(u32, id)
 108                __field(u8, mask_enable)
 109                __array(u32, mask_outer, MLX5_ST_SZ_DW(fte_match_set_lyr_2_4))
 110                __array(u32, mask_inner, MLX5_ST_SZ_DW(fte_match_set_lyr_2_4))
 111                __array(u32, mask_misc, MLX5_ST_SZ_DW(fte_match_set_misc))
 112            ),
 113            TP_fast_assign(
 114                           __entry->fg = fg;
 115                           fs_get_obj(__entry->ft, fg->node.parent);
 116                           __entry->start_index = fg->start_index;
 117                           __entry->end_index = fg->start_index + fg->max_ftes;
 118                           __entry->id = fg->id;
 119                           __entry->mask_enable = fg->mask.match_criteria_enable;
 120                           memcpy(__entry->mask_outer,
 121                                  MLX5_ADDR_OF(fte_match_param,
 122                                               &fg->mask.match_criteria,
 123                                               outer_headers),
 124                                  sizeof(__entry->mask_outer));
 125                           memcpy(__entry->mask_inner,
 126                                  MLX5_ADDR_OF(fte_match_param,
 127                                               &fg->mask.match_criteria,
 128                                               inner_headers),
 129                                  sizeof(__entry->mask_inner));
 130                           memcpy(__entry->mask_misc,
 131                                  MLX5_ADDR_OF(fte_match_param,
 132                                               &fg->mask.match_criteria,
 133                                               misc_parameters),
 134                                  sizeof(__entry->mask_misc));
 135
 136            ),
 137            TP_printk("fg=%p ft=%p id=%u start=%u end=%u bit_mask=%02x %s\n",
 138                      __entry->fg, __entry->ft, __entry->id,
 139                      __entry->start_index, __entry->end_index,
 140                      __entry->mask_enable,
 141                      __parse_fs_hdrs(__entry->mask_enable,
 142                                      __entry->mask_outer,
 143                                      __entry->mask_misc,
 144                                      __entry->mask_inner,
 145                                      __entry->mask_outer,
 146                                      __entry->mask_misc,
 147                                      __entry->mask_inner))
 148            );
 149
 150TRACE_EVENT(mlx5_fs_del_fg,
 151            TP_PROTO(const struct mlx5_flow_group *fg),
 152            TP_ARGS(fg),
 153            TP_STRUCT__entry(
 154                __field(const struct mlx5_flow_group *, fg)
 155                __field(u32, id)
 156            ),
 157            TP_fast_assign(
 158                           __entry->fg = fg;
 159                           __entry->id = fg->id;
 160
 161            ),
 162            TP_printk("fg=%p id=%u\n",
 163                      __entry->fg, __entry->id)
 164            );
 165
 166#define ACTION_FLAGS \
 167        {MLX5_FLOW_CONTEXT_ACTION_ALLOW,         "ALLOW"},\
 168        {MLX5_FLOW_CONTEXT_ACTION_DROP,          "DROP"},\
 169        {MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,      "FWD"},\
 170        {MLX5_FLOW_CONTEXT_ACTION_COUNT,         "CNT"},\
 171        {MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT, "REFORMAT"},\
 172        {MLX5_FLOW_CONTEXT_ACTION_DECAP,         "DECAP"},\
 173        {MLX5_FLOW_CONTEXT_ACTION_MOD_HDR,       "MOD_HDR"},\
 174        {MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH,     "VLAN_PUSH"},\
 175        {MLX5_FLOW_CONTEXT_ACTION_VLAN_POP,      "VLAN_POP"},\
 176        {MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH_2,   "VLAN_PUSH_2"},\
 177        {MLX5_FLOW_CONTEXT_ACTION_VLAN_POP_2,    "VLAN_POP_2"},\
 178        {MLX5_FLOW_CONTEXT_ACTION_FWD_NEXT_PRIO, "NEXT_PRIO"}
 179
 180TRACE_EVENT(mlx5_fs_set_fte,
 181            TP_PROTO(const struct fs_fte *fte, int new_fte),
 182            TP_ARGS(fte, new_fte),
 183            TP_STRUCT__entry(
 184                __field(const struct fs_fte *, fte)
 185                __field(const struct mlx5_flow_group *, fg)
 186                __field(u32, group_index)
 187                __field(u32, index)
 188                __field(u32, action)
 189                __field(u32, flow_tag)
 190                __field(u32, flow_source)
 191                __field(u8,  mask_enable)
 192                __field(int, new_fte)
 193                __array(u32, mask_outer, MLX5_ST_SZ_DW(fte_match_set_lyr_2_4))
 194                __array(u32, mask_inner, MLX5_ST_SZ_DW(fte_match_set_lyr_2_4))
 195                __array(u32, mask_misc, MLX5_ST_SZ_DW(fte_match_set_misc))
 196                __array(u32, value_outer, MLX5_ST_SZ_DW(fte_match_set_lyr_2_4))
 197                __array(u32, value_inner, MLX5_ST_SZ_DW(fte_match_set_lyr_2_4))
 198                __array(u32, value_misc, MLX5_ST_SZ_DW(fte_match_set_misc))
 199            ),
 200            TP_fast_assign(
 201                           __entry->fte = fte;
 202                           __entry->new_fte = new_fte;
 203                           fs_get_obj(__entry->fg, fte->node.parent);
 204                           __entry->group_index = __entry->fg->id;
 205                           __entry->index = fte->index;
 206                           __entry->action = fte->action.action;
 207                           __entry->mask_enable = __entry->fg->mask.match_criteria_enable;
 208                           __entry->flow_tag = fte->flow_context.flow_tag;
 209                           __entry->flow_source = fte->flow_context.flow_source;
 210                           memcpy(__entry->mask_outer,
 211                                  MLX5_ADDR_OF(fte_match_param,
 212                                               &__entry->fg->mask.match_criteria,
 213                                               outer_headers),
 214                                  sizeof(__entry->mask_outer));
 215                           memcpy(__entry->mask_inner,
 216                                  MLX5_ADDR_OF(fte_match_param,
 217                                               &__entry->fg->mask.match_criteria,
 218                                               inner_headers),
 219                                  sizeof(__entry->mask_inner));
 220                           memcpy(__entry->mask_misc,
 221                                  MLX5_ADDR_OF(fte_match_param,
 222                                               &__entry->fg->mask.match_criteria,
 223                                               misc_parameters),
 224                                  sizeof(__entry->mask_misc));
 225                           memcpy(__entry->value_outer,
 226                                  MLX5_ADDR_OF(fte_match_param,
 227                                               &fte->val,
 228                                               outer_headers),
 229                                  sizeof(__entry->value_outer));
 230                           memcpy(__entry->value_inner,
 231                                  MLX5_ADDR_OF(fte_match_param,
 232                                               &fte->val,
 233                                               inner_headers),
 234                                  sizeof(__entry->value_inner));
 235                           memcpy(__entry->value_misc,
 236                                  MLX5_ADDR_OF(fte_match_param,
 237                                               &fte->val,
 238                                               misc_parameters),
 239                                  sizeof(__entry->value_misc));
 240
 241            ),
 242            TP_printk("op=%s fte=%p fg=%p index=%u group_index=%u action=<%s> flow_tag=%x %s\n",
 243                      __entry->new_fte ? "add" : "set",
 244                      __entry->fte, __entry->fg, __entry->index,
 245                      __entry->group_index, __print_flags(__entry->action, "|",
 246                                                          ACTION_FLAGS),
 247                      __entry->flow_tag,
 248                      __parse_fs_hdrs(__entry->mask_enable,
 249                                      __entry->mask_outer,
 250                                      __entry->mask_misc,
 251                                      __entry->mask_inner,
 252                                      __entry->value_outer,
 253                                      __entry->value_misc,
 254                                      __entry->value_inner))
 255            );
 256
 257TRACE_EVENT(mlx5_fs_del_fte,
 258            TP_PROTO(const struct fs_fte *fte),
 259            TP_ARGS(fte),
 260            TP_STRUCT__entry(
 261                __field(const struct fs_fte *, fte)
 262                __field(u32, index)
 263            ),
 264            TP_fast_assign(
 265                           __entry->fte = fte;
 266                           __entry->index = fte->index;
 267
 268            ),
 269            TP_printk("fte=%p index=%u\n",
 270                      __entry->fte, __entry->index)
 271            );
 272
 273TRACE_EVENT(mlx5_fs_add_rule,
 274            TP_PROTO(const struct mlx5_flow_rule *rule),
 275            TP_ARGS(rule),
 276            TP_STRUCT__entry(
 277                __field(const struct mlx5_flow_rule *, rule)
 278                __field(const struct fs_fte *, fte)
 279                __field(u32, sw_action)
 280                __field(u32, index)
 281                __field(u32, counter_id)
 282                __array(u8, destination, sizeof(struct mlx5_flow_destination))
 283            ),
 284            TP_fast_assign(
 285                           __entry->rule = rule;
 286                           fs_get_obj(__entry->fte, rule->node.parent);
 287                           __entry->index = __entry->fte->dests_size - 1;
 288                           __entry->sw_action = rule->sw_action;
 289                           memcpy(__entry->destination,
 290                                  &rule->dest_attr,
 291                                  sizeof(__entry->destination));
 292                           if (rule->dest_attr.type &
 293                               MLX5_FLOW_DESTINATION_TYPE_COUNTER)
 294                                __entry->counter_id =
 295                                        rule->dest_attr.counter_id;
 296            ),
 297            TP_printk("rule=%p fte=%p index=%u sw_action=<%s> [dst] %s\n",
 298                      __entry->rule, __entry->fte, __entry->index,
 299                      __print_flags(__entry->sw_action, "|", ACTION_FLAGS),
 300                      __parse_fs_dst(__entry->destination, __entry->counter_id))
 301            );
 302
 303TRACE_EVENT(mlx5_fs_del_rule,
 304            TP_PROTO(const struct mlx5_flow_rule *rule),
 305            TP_ARGS(rule),
 306            TP_STRUCT__entry(
 307                __field(const struct mlx5_flow_rule *, rule)
 308                __field(const struct fs_fte *, fte)
 309            ),
 310            TP_fast_assign(
 311                           __entry->rule = rule;
 312                           fs_get_obj(__entry->fte, rule->node.parent);
 313            ),
 314            TP_printk("rule=%p fte=%p\n",
 315                      __entry->rule, __entry->fte)
 316            );
 317#endif
 318
 319#undef TRACE_INCLUDE_PATH
 320#define TRACE_INCLUDE_PATH ./diag
 321#undef TRACE_INCLUDE_FILE
 322#define TRACE_INCLUDE_FILE fs_tracepoint
 323#include <trace/define_trace.h>
 324