fs_tracepoint.h

  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->act_dests.action.action;
207			   __entry->mask_enable = __entry->fg->mask.match_criteria_enable;
208			   __entry->flow_tag = fte->act_dests.flow_context.flow_tag;
209			   __entry->flow_source = fte->act_dests.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->act_dests.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					mlx5_fc_id(rule->dest_attr.counter);
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>