Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 or Linux-OpenIB */
0002 /* Copyright (c) 2019 - 2021 Intel Corporation */
0003 #if !defined(__TRACE_CM_H) || defined(TRACE_HEADER_MULTI_READ)
0004 #define __TRACE_CM_H
0005 
0006 #include <linux/tracepoint.h>
0007 #include <linux/trace_seq.h>
0008 
0009 #include "main.h"
0010 
0011 const char *print_ip_addr(struct trace_seq *p, u32 *addr, u16 port, bool ivp4);
0012 const char *parse_iw_event_type(enum iw_cm_event_type iw_type);
0013 const char *parse_cm_event_type(enum irdma_cm_event_type cm_type);
0014 const char *parse_cm_state(enum irdma_cm_node_state);
0015 #define __print_ip_addr(addr, port, ipv4) print_ip_addr(p, addr, port, ipv4)
0016 
0017 #undef TRACE_SYSTEM
0018 #define TRACE_SYSTEM irdma_cm
0019 
0020 TRACE_EVENT(irdma_create_listen,
0021         TP_PROTO(struct irdma_device *iwdev, struct irdma_cm_info *cm_info),
0022         TP_ARGS(iwdev, cm_info),
0023         TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
0024                  __dynamic_array(u32, laddr, 4)
0025                  __field(u16, lport)
0026                  __field(bool, ipv4)
0027             ),
0028         TP_fast_assign(__entry->iwdev = iwdev;
0029                __entry->lport = cm_info->loc_port;
0030                __entry->ipv4 = cm_info->ipv4;
0031                memcpy(__get_dynamic_array(laddr),
0032                   cm_info->loc_addr, 4);
0033             ),
0034         TP_printk("iwdev=%p  loc: %s",
0035               __entry->iwdev,
0036               __print_ip_addr(__get_dynamic_array(laddr),
0037                       __entry->lport, __entry->ipv4)
0038             )
0039 );
0040 
0041 TRACE_EVENT(irdma_dec_refcnt_listen,
0042         TP_PROTO(struct irdma_cm_listener *listener, void *caller),
0043         TP_ARGS(listener, caller),
0044         TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
0045             __field(u32, refcnt)
0046             __dynamic_array(u32, laddr, 4)
0047             __field(u16, lport)
0048             __field(bool, ipv4)
0049             __field(void *, caller)
0050             ),
0051         TP_fast_assign(__entry->iwdev = listener->iwdev;
0052                __entry->lport = listener->loc_port;
0053                __entry->ipv4 = listener->ipv4;
0054                memcpy(__get_dynamic_array(laddr),
0055                   listener->loc_addr, 4);
0056             ),
0057         TP_printk("iwdev=%p  caller=%pS  loc: %s",
0058               __entry->iwdev,
0059               __entry->caller,
0060               __print_ip_addr(__get_dynamic_array(laddr),
0061                       __entry->lport, __entry->ipv4)
0062             )
0063 );
0064 
0065 DECLARE_EVENT_CLASS(listener_template,
0066             TP_PROTO(struct irdma_cm_listener *listener),
0067             TP_ARGS(listener),
0068             TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
0069                      __field(u16, lport)
0070                      __field(u16, vlan_id)
0071                      __field(bool, ipv4)
0072                      __field(enum irdma_cm_listener_state,
0073                          state)
0074                      __dynamic_array(u32, laddr, 4)
0075                 ),
0076             TP_fast_assign(__entry->iwdev = listener->iwdev;
0077                    __entry->lport = listener->loc_port;
0078                    __entry->vlan_id = listener->vlan_id;
0079                    __entry->ipv4 = listener->ipv4;
0080                    __entry->state = listener->listener_state;
0081                    memcpy(__get_dynamic_array(laddr),
0082                       listener->loc_addr, 4);
0083                 ),
0084             TP_printk("iwdev=%p  vlan=%d  loc: %s",
0085                   __entry->iwdev,
0086                   __entry->vlan_id,
0087                   __print_ip_addr(__get_dynamic_array(laddr),
0088                           __entry->lport, __entry->ipv4)
0089                 )
0090 );
0091 
0092 DEFINE_EVENT(listener_template, irdma_find_listener,
0093          TP_PROTO(struct irdma_cm_listener *listener),
0094          TP_ARGS(listener));
0095 
0096 DEFINE_EVENT(listener_template, irdma_del_multiple_qhash,
0097          TP_PROTO(struct irdma_cm_listener *listener),
0098          TP_ARGS(listener));
0099 
0100 TRACE_EVENT(irdma_negotiate_mpa_v2,
0101         TP_PROTO(struct irdma_cm_node *cm_node),
0102         TP_ARGS(cm_node),
0103         TP_STRUCT__entry(__field(struct irdma_cm_node *, cm_node)
0104                  __field(u16, ord_size)
0105                  __field(u16, ird_size)
0106             ),
0107         TP_fast_assign(__entry->cm_node = cm_node;
0108                __entry->ord_size = cm_node->ord_size;
0109                __entry->ird_size = cm_node->ird_size;
0110             ),
0111         TP_printk("MPVA2 Negotiated cm_node=%p ORD:[%d], IRD:[%d]",
0112               __entry->cm_node,
0113               __entry->ord_size,
0114               __entry->ird_size
0115             )
0116 );
0117 
0118 DECLARE_EVENT_CLASS(tos_template,
0119             TP_PROTO(struct irdma_device *iwdev, u8 tos, u8 user_pri),
0120             TP_ARGS(iwdev, tos, user_pri),
0121             TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
0122                      __field(u8, tos)
0123                      __field(u8, user_pri)
0124                 ),
0125             TP_fast_assign(__entry->iwdev = iwdev;
0126                    __entry->tos = tos;
0127                    __entry->user_pri = user_pri;
0128                 ),
0129             TP_printk("iwdev=%p  TOS:[%d]  UP:[%d]",
0130                   __entry->iwdev,
0131                   __entry->tos,
0132                   __entry->user_pri
0133                 )
0134 );
0135 
0136 DEFINE_EVENT(tos_template, irdma_listener_tos,
0137          TP_PROTO(struct irdma_device *iwdev, u8 tos, u8 user_pri),
0138          TP_ARGS(iwdev, tos, user_pri));
0139 
0140 DEFINE_EVENT(tos_template, irdma_dcb_tos,
0141          TP_PROTO(struct irdma_device *iwdev, u8 tos, u8 user_pri),
0142          TP_ARGS(iwdev, tos, user_pri));
0143 
0144 DECLARE_EVENT_CLASS(qhash_template,
0145             TP_PROTO(struct irdma_device *iwdev,
0146                  struct irdma_cm_listener *listener,
0147                  const char *dev_addr),
0148             TP_ARGS(iwdev, listener, dev_addr),
0149             TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
0150                      __field(u16, lport)
0151                      __field(u16, vlan_id)
0152                      __field(bool, ipv4)
0153                      __dynamic_array(u32, laddr, 4)
0154                      __dynamic_array(u32, mac, ETH_ALEN)
0155                 ),
0156             TP_fast_assign(__entry->iwdev = iwdev;
0157                    __entry->lport = listener->loc_port;
0158                    __entry->vlan_id = listener->vlan_id;
0159                    __entry->ipv4 = listener->ipv4;
0160                    memcpy(__get_dynamic_array(laddr),
0161                       listener->loc_addr, 4);
0162                    ether_addr_copy(__get_dynamic_array(mac),
0163                            dev_addr);
0164                 ),
0165             TP_printk("iwdev=%p  vlan=%d  MAC=%6phC  loc: %s",
0166                   __entry->iwdev,
0167                   __entry->vlan_id,
0168                   __get_dynamic_array(mac),
0169                   __print_ip_addr(__get_dynamic_array(laddr),
0170                           __entry->lport, __entry->ipv4)
0171             )
0172 );
0173 
0174 DEFINE_EVENT(qhash_template, irdma_add_mqh_6,
0175          TP_PROTO(struct irdma_device *iwdev,
0176               struct irdma_cm_listener *listener,
0177               const char *dev_addr),
0178          TP_ARGS(iwdev, listener, dev_addr));
0179 
0180 DEFINE_EVENT(qhash_template, irdma_add_mqh_4,
0181          TP_PROTO(struct irdma_device *iwdev,
0182               struct irdma_cm_listener *listener,
0183               const char *dev_addr),
0184          TP_ARGS(iwdev, listener, dev_addr));
0185 
0186 TRACE_EVENT(irdma_addr_resolve,
0187         TP_PROTO(struct irdma_device *iwdev, char *dev_addr),
0188         TP_ARGS(iwdev, dev_addr),
0189         TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
0190             __dynamic_array(u8, mac, ETH_ALEN)
0191             ),
0192         TP_fast_assign(__entry->iwdev = iwdev;
0193             ether_addr_copy(__get_dynamic_array(mac), dev_addr);
0194             ),
0195         TP_printk("iwdev=%p   MAC=%6phC", __entry->iwdev,
0196               __get_dynamic_array(mac)
0197             )
0198 );
0199 
0200 TRACE_EVENT(irdma_send_cm_event,
0201         TP_PROTO(struct irdma_cm_node *cm_node, struct iw_cm_id *cm_id,
0202              enum iw_cm_event_type type, int status, void *caller),
0203         TP_ARGS(cm_node, cm_id, type, status, caller),
0204         TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
0205                  __field(struct irdma_cm_node *, cm_node)
0206                  __field(struct iw_cm_id *, cm_id)
0207                  __field(u32, refcount)
0208                  __field(u16, lport)
0209                  __field(u16, rport)
0210                  __field(enum irdma_cm_node_state, state)
0211                  __field(bool, ipv4)
0212                  __field(u16, vlan_id)
0213                  __field(int, accel)
0214                  __field(enum iw_cm_event_type, type)
0215                  __field(int, status)
0216                  __field(void *, caller)
0217                  __dynamic_array(u32, laddr, 4)
0218                  __dynamic_array(u32, raddr, 4)
0219             ),
0220         TP_fast_assign(__entry->iwdev = cm_node->iwdev;
0221                __entry->cm_node = cm_node;
0222                __entry->cm_id = cm_id;
0223                __entry->refcount = refcount_read(&cm_node->refcnt);
0224                __entry->state = cm_node->state;
0225                __entry->lport = cm_node->loc_port;
0226                __entry->rport = cm_node->rem_port;
0227                __entry->ipv4 = cm_node->ipv4;
0228                __entry->vlan_id = cm_node->vlan_id;
0229                __entry->accel = cm_node->accelerated;
0230                __entry->type = type;
0231                __entry->status = status;
0232                __entry->caller = caller;
0233                memcpy(__get_dynamic_array(laddr),
0234                   cm_node->loc_addr, 4);
0235                memcpy(__get_dynamic_array(raddr),
0236                   cm_node->rem_addr, 4);
0237             ),
0238         TP_printk("iwdev=%p  caller=%pS  cm_id=%p  node=%p  refcnt=%d  vlan_id=%d  accel=%d  state=%s  event_type=%s  status=%d  loc: %s  rem: %s",
0239               __entry->iwdev,
0240               __entry->caller,
0241               __entry->cm_id,
0242               __entry->cm_node,
0243               __entry->refcount,
0244               __entry->vlan_id,
0245               __entry->accel,
0246               parse_cm_state(__entry->state),
0247               parse_iw_event_type(__entry->type),
0248               __entry->status,
0249               __print_ip_addr(__get_dynamic_array(laddr),
0250                       __entry->lport, __entry->ipv4),
0251               __print_ip_addr(__get_dynamic_array(raddr),
0252                       __entry->rport, __entry->ipv4)
0253             )
0254 );
0255 
0256 TRACE_EVENT(irdma_send_cm_event_no_node,
0257         TP_PROTO(struct iw_cm_id *cm_id, enum iw_cm_event_type type,
0258              int status, void *caller),
0259         TP_ARGS(cm_id, type, status, caller),
0260         TP_STRUCT__entry(__field(struct iw_cm_id *, cm_id)
0261                  __field(enum iw_cm_event_type, type)
0262                  __field(int, status)
0263                  __field(void *, caller)
0264             ),
0265         TP_fast_assign(__entry->cm_id = cm_id;
0266                __entry->type = type;
0267                __entry->status = status;
0268                __entry->caller = caller;
0269             ),
0270         TP_printk("cm_id=%p  caller=%pS  event_type=%s  status=%d",
0271               __entry->cm_id,
0272               __entry->caller,
0273               parse_iw_event_type(__entry->type),
0274               __entry->status
0275             )
0276 );
0277 
0278 DECLARE_EVENT_CLASS(cm_node_template,
0279             TP_PROTO(struct irdma_cm_node *cm_node,
0280                  enum irdma_cm_event_type type, void *caller),
0281             TP_ARGS(cm_node, type, caller),
0282             TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
0283                      __field(struct irdma_cm_node *, cm_node)
0284                      __field(u32, refcount)
0285                      __field(u16, lport)
0286                      __field(u16, rport)
0287                      __field(enum irdma_cm_node_state, state)
0288                      __field(bool, ipv4)
0289                      __field(u16, vlan_id)
0290                      __field(int, accel)
0291                      __field(enum irdma_cm_event_type, type)
0292                      __field(void *, caller)
0293                      __dynamic_array(u32, laddr, 4)
0294                      __dynamic_array(u32, raddr, 4)
0295                 ),
0296             TP_fast_assign(__entry->iwdev = cm_node->iwdev;
0297                    __entry->cm_node = cm_node;
0298                    __entry->refcount = refcount_read(&cm_node->refcnt);
0299                    __entry->state = cm_node->state;
0300                    __entry->lport = cm_node->loc_port;
0301                    __entry->rport = cm_node->rem_port;
0302                    __entry->ipv4 = cm_node->ipv4;
0303                    __entry->vlan_id = cm_node->vlan_id;
0304                    __entry->accel = cm_node->accelerated;
0305                    __entry->type = type;
0306                    __entry->caller = caller;
0307                    memcpy(__get_dynamic_array(laddr),
0308                       cm_node->loc_addr, 4);
0309                    memcpy(__get_dynamic_array(raddr),
0310                       cm_node->rem_addr, 4);
0311                 ),
0312             TP_printk("iwdev=%p  caller=%pS  node=%p  refcnt=%d  vlan_id=%d  accel=%d  state=%s  event_type=%s  loc: %s  rem: %s",
0313                   __entry->iwdev,
0314                   __entry->caller,
0315                   __entry->cm_node,
0316                   __entry->refcount,
0317                   __entry->vlan_id,
0318                   __entry->accel,
0319                   parse_cm_state(__entry->state),
0320                   parse_cm_event_type(__entry->type),
0321                   __print_ip_addr(__get_dynamic_array(laddr),
0322                           __entry->lport, __entry->ipv4),
0323                   __print_ip_addr(__get_dynamic_array(raddr),
0324                           __entry->rport, __entry->ipv4)
0325             )
0326 );
0327 
0328 DEFINE_EVENT(cm_node_template, irdma_create_event,
0329          TP_PROTO(struct irdma_cm_node *cm_node,
0330               enum irdma_cm_event_type type, void *caller),
0331          TP_ARGS(cm_node, type, caller));
0332 
0333 DEFINE_EVENT(cm_node_template, irdma_accept,
0334          TP_PROTO(struct irdma_cm_node *cm_node,
0335               enum irdma_cm_event_type type, void *caller),
0336          TP_ARGS(cm_node, type, caller));
0337 
0338 DEFINE_EVENT(cm_node_template, irdma_connect,
0339          TP_PROTO(struct irdma_cm_node *cm_node,
0340               enum irdma_cm_event_type type, void *caller),
0341          TP_ARGS(cm_node, type, caller));
0342 
0343 DEFINE_EVENT(cm_node_template, irdma_reject,
0344          TP_PROTO(struct irdma_cm_node *cm_node,
0345               enum irdma_cm_event_type type, void *caller),
0346          TP_ARGS(cm_node, type, caller));
0347 
0348 DEFINE_EVENT(cm_node_template, irdma_find_node,
0349          TP_PROTO(struct irdma_cm_node *cm_node,
0350               enum irdma_cm_event_type type, void *caller),
0351          TP_ARGS(cm_node, type, caller));
0352 
0353 DEFINE_EVENT(cm_node_template, irdma_send_reset,
0354          TP_PROTO(struct irdma_cm_node *cm_node,
0355               enum irdma_cm_event_type type, void *caller),
0356          TP_ARGS(cm_node, type, caller));
0357 
0358 DEFINE_EVENT(cm_node_template, irdma_rem_ref_cm_node,
0359          TP_PROTO(struct irdma_cm_node *cm_node,
0360               enum irdma_cm_event_type type, void *caller),
0361          TP_ARGS(cm_node, type, caller));
0362 
0363 DEFINE_EVENT(cm_node_template, irdma_cm_event_handler,
0364          TP_PROTO(struct irdma_cm_node *cm_node,
0365               enum irdma_cm_event_type type, void *caller),
0366          TP_ARGS(cm_node, type, caller));
0367 
0368 TRACE_EVENT(open_err_template,
0369         TP_PROTO(struct irdma_cm_node *cm_node, bool reset, void *caller),
0370         TP_ARGS(cm_node, reset, caller),
0371         TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
0372                  __field(struct irdma_cm_node *, cm_node)
0373                  __field(enum irdma_cm_node_state, state)
0374                  __field(bool, reset)
0375                  __field(void *, caller)
0376             ),
0377         TP_fast_assign(__entry->iwdev = cm_node->iwdev;
0378                __entry->cm_node = cm_node;
0379                __entry->state = cm_node->state;
0380                __entry->reset = reset;
0381                __entry->caller = caller;
0382             ),
0383         TP_printk("iwdev=%p  caller=%pS  node%p reset=%d  state=%s",
0384               __entry->iwdev,
0385               __entry->caller,
0386               __entry->cm_node,
0387               __entry->reset,
0388               parse_cm_state(__entry->state)
0389             )
0390 );
0391 
0392 DEFINE_EVENT(open_err_template, irdma_active_open_err,
0393          TP_PROTO(struct irdma_cm_node *cm_node, bool reset, void *caller),
0394          TP_ARGS(cm_node, reset, caller));
0395 
0396 DEFINE_EVENT(open_err_template, irdma_passive_open_err,
0397          TP_PROTO(struct irdma_cm_node *cm_node, bool reset, void *caller),
0398          TP_ARGS(cm_node, reset, caller));
0399 
0400 DECLARE_EVENT_CLASS(cm_node_ah_template,
0401             TP_PROTO(struct irdma_cm_node *cm_node),
0402             TP_ARGS(cm_node),
0403             TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
0404                      __field(struct irdma_cm_node *, cm_node)
0405                      __field(struct irdma_sc_ah *, ah)
0406                      __field(u32, refcount)
0407                      __field(u16, lport)
0408                      __field(u16, rport)
0409                      __field(enum irdma_cm_node_state, state)
0410                      __field(bool, ipv4)
0411                      __field(u16, vlan_id)
0412                      __field(int, accel)
0413                      __dynamic_array(u32, laddr, 4)
0414                      __dynamic_array(u32, raddr, 4)
0415                 ),
0416             TP_fast_assign(__entry->iwdev = cm_node->iwdev;
0417                    __entry->cm_node = cm_node;
0418                    __entry->ah = cm_node->ah;
0419                    __entry->refcount = refcount_read(&cm_node->refcnt);
0420                    __entry->lport = cm_node->loc_port;
0421                    __entry->rport = cm_node->rem_port;
0422                    __entry->state = cm_node->state;
0423                    __entry->ipv4 = cm_node->ipv4;
0424                    __entry->vlan_id = cm_node->vlan_id;
0425                    __entry->accel = cm_node->accelerated;
0426                    memcpy(__get_dynamic_array(laddr),
0427                       cm_node->loc_addr, 4);
0428                    memcpy(__get_dynamic_array(raddr),
0429                       cm_node->rem_addr, 4);
0430                 ),
0431             TP_printk("iwdev=%p  node=%p  ah=%p  refcnt=%d  vlan_id=%d  accel=%d  state=%s loc: %s  rem: %s",
0432                   __entry->iwdev,
0433                   __entry->cm_node,
0434                   __entry->ah,
0435                   __entry->refcount,
0436                   __entry->vlan_id,
0437                   __entry->accel,
0438                   parse_cm_state(__entry->state),
0439                   __print_ip_addr(__get_dynamic_array(laddr),
0440                           __entry->lport, __entry->ipv4),
0441                   __print_ip_addr(__get_dynamic_array(raddr),
0442                           __entry->rport, __entry->ipv4)
0443             )
0444 );
0445 
0446 DEFINE_EVENT(cm_node_ah_template, irdma_cm_free_ah,
0447          TP_PROTO(struct irdma_cm_node *cm_node),
0448          TP_ARGS(cm_node));
0449 
0450 DEFINE_EVENT(cm_node_ah_template, irdma_create_ah,
0451          TP_PROTO(struct irdma_cm_node *cm_node),
0452          TP_ARGS(cm_node));
0453 
0454 #endif  /* __TRACE_CM_H */
0455 
0456 #undef TRACE_INCLUDE_PATH
0457 #undef TRACE_INCLUDE_FILE
0458 #define TRACE_INCLUDE_PATH .
0459 #define TRACE_INCLUDE_FILE trace_cm
0460 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!