Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * net/tipc/trace.h: TIPC tracepoints
0003  *
0004  * Copyright (c) 2018, Ericsson AB
0005  * All rights reserved.
0006  *
0007  * Redistribution and use in source and binary forms, with or without
0008  * modification, are permitted provided that the following conditions are met:
0009  *
0010  * 1. Redistributions of source code must retain the above copyright
0011  *    notice, this list of conditions and the following disclaimer.
0012  * 2. Redistributions in binary form must reproduce the above copyright
0013  *    notice, this list of conditions and the following disclaimer in the
0014  *    documentation and/or other materials provided with the distribution.
0015  * 3. Neither the names of the copyright holders nor the names of its
0016  *    contributors may be used to endorse or promote products derived from
0017  *    this software without specific prior written permission.
0018  *
0019  * Alternatively, this software may be distributed under the terms of the
0020  * GNU General Public License ("GPL") version 2 as published by the Free
0021  * Software Foundation.
0022  *
0023  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "ASIS"
0024  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
0025  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
0026  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
0027  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
0028  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
0029  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
0030  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
0031  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
0032  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
0033  * POSSIBILITY OF SUCH DAMAGE.
0034  */
0035 
0036 #undef TRACE_SYSTEM
0037 #define TRACE_SYSTEM tipc
0038 
0039 #if !defined(_TIPC_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
0040 #define _TIPC_TRACE_H
0041 
0042 #include <linux/tracepoint.h>
0043 #include "core.h"
0044 #include "link.h"
0045 #include "socket.h"
0046 #include "node.h"
0047 
0048 #define SKB_LMIN    (100)
0049 #define SKB_LMAX    (SKB_LMIN * 2)
0050 #define LIST_LMIN   (SKB_LMIN * 3)
0051 #define LIST_LMAX   (SKB_LMIN * 11)
0052 #define SK_LMIN     (SKB_LMIN * 2)
0053 #define SK_LMAX     (SKB_LMIN * 11)
0054 #define LINK_LMIN   (SKB_LMIN)
0055 #define LINK_LMAX   (SKB_LMIN * 16)
0056 #define NODE_LMIN   (SKB_LMIN)
0057 #define NODE_LMAX   (SKB_LMIN * 11)
0058 
0059 #ifndef __TIPC_TRACE_ENUM
0060 #define __TIPC_TRACE_ENUM
0061 enum {
0062     TIPC_DUMP_NONE      = 0,
0063 
0064     TIPC_DUMP_TRANSMQ   = 1,
0065     TIPC_DUMP_BACKLOGQ  = (1 << 1),
0066     TIPC_DUMP_DEFERDQ   = (1 << 2),
0067     TIPC_DUMP_INPUTQ    = (1 << 3),
0068     TIPC_DUMP_WAKEUP        = (1 << 4),
0069 
0070     TIPC_DUMP_SK_SNDQ   = (1 << 8),
0071     TIPC_DUMP_SK_RCVQ   = (1 << 9),
0072     TIPC_DUMP_SK_BKLGQ  = (1 << 10),
0073     TIPC_DUMP_ALL       = 0xffffu
0074 };
0075 #endif
0076 
0077 /* Link & Node FSM states: */
0078 #define state_sym(val)                            \
0079     __print_symbolic(val,                         \
0080             {(0xe),     "ESTABLISHED"           },\
0081             {(0xe << 4),    "ESTABLISHING"          },\
0082             {(0x1 << 8),    "RESET"             },\
0083             {(0x2 << 12),   "RESETTING"         },\
0084             {(0xd << 16),   "PEER_RESET"            },\
0085             {(0xf << 20),   "FAILINGOVER"           },\
0086             {(0xc << 24),   "SYNCHING"          },\
0087             {(0xdd),    "SELF_DOWN_PEER_DOWN"       },\
0088             {(0xaa),    "SELF_UP_PEER_UP"       },\
0089             {(0xd1),    "SELF_DOWN_PEER_LEAVING"    },\
0090             {(0xac),    "SELF_UP_PEER_COMING"       },\
0091             {(0xca),    "SELF_COMING_PEER_UP"       },\
0092             {(0x1d),    "SELF_LEAVING_PEER_DOWN"    },\
0093             {(0xf0),    "FAILINGOVER"           },\
0094             {(0xcc),    "SYNCHING"          })
0095 
0096 /* Link & Node FSM events: */
0097 #define evt_sym(val)                              \
0098     __print_symbolic(val,                         \
0099             {(0xec1ab1e),   "ESTABLISH_EVT"         },\
0100             {(0x9eed0e),    "PEER_RESET_EVT"        },\
0101             {(0xfa110e),    "FAILURE_EVT"           },\
0102             {(0x10ca1d0e),  "RESET_EVT"         },\
0103             {(0xfa110bee),  "FAILOVER_BEGIN_EVT"        },\
0104             {(0xfa110ede),  "FAILOVER_END_EVT"      },\
0105             {(0xc1ccbee),   "SYNCH_BEGIN_EVT"       },\
0106             {(0xc1ccede),   "SYNCH_END_EVT"         },\
0107             {(0xece),   "SELF_ESTABL_CONTACT_EVT"   },\
0108             {(0x1ce),   "SELF_LOST_CONTACT_EVT"     },\
0109             {(0x9ece),  "PEER_ESTABL_CONTACT_EVT"   },\
0110             {(0x91ce),  "PEER_LOST_CONTACT_EVT"     },\
0111             {(0xfbe),   "FAILOVER_BEGIN_EVT"        },\
0112             {(0xfee),   "FAILOVER_END_EVT"      },\
0113             {(0xcbe),   "SYNCH_BEGIN_EVT"       },\
0114             {(0xcee),   "SYNCH_END_EVT"         })
0115 
0116 /* Bearer, net device events: */
0117 #define dev_evt_sym(val)                          \
0118     __print_symbolic(val,                         \
0119             {(NETDEV_CHANGE),   "NETDEV_CHANGE"     },\
0120             {(NETDEV_GOING_DOWN),   "NETDEV_GOING_DOWN" },\
0121             {(NETDEV_UP),       "NETDEV_UP"     },\
0122             {(NETDEV_CHANGEMTU),    "NETDEV_CHANGEMTU"  },\
0123             {(NETDEV_CHANGEADDR),   "NETDEV_CHANGEADDR" },\
0124             {(NETDEV_UNREGISTER),   "NETDEV_UNREGISTER" },\
0125             {(NETDEV_CHANGENAME),   "NETDEV_CHANGENAME" })
0126 
0127 extern unsigned long sysctl_tipc_sk_filter[5] __read_mostly;
0128 
0129 int tipc_skb_dump(struct sk_buff *skb, bool more, char *buf);
0130 int tipc_list_dump(struct sk_buff_head *list, bool more, char *buf);
0131 int tipc_sk_dump(struct sock *sk, u16 dqueues, char *buf);
0132 int tipc_link_dump(struct tipc_link *l, u16 dqueues, char *buf);
0133 int tipc_node_dump(struct tipc_node *n, bool more, char *buf);
0134 bool tipc_sk_filtering(struct sock *sk);
0135 
0136 DECLARE_EVENT_CLASS(tipc_skb_class,
0137 
0138     TP_PROTO(struct sk_buff *skb, bool more, const char *header),
0139 
0140     TP_ARGS(skb, more, header),
0141 
0142     TP_STRUCT__entry(
0143         __string(header, header)
0144         __dynamic_array(char, buf, (more) ? SKB_LMAX : SKB_LMIN)
0145     ),
0146 
0147     TP_fast_assign(
0148         __assign_str(header, header);
0149         tipc_skb_dump(skb, more, __get_str(buf));
0150     ),
0151 
0152     TP_printk("%s\n%s", __get_str(header), __get_str(buf))
0153 )
0154 
0155 #define DEFINE_SKB_EVENT(name) \
0156 DEFINE_EVENT(tipc_skb_class, name, \
0157     TP_PROTO(struct sk_buff *skb, bool more, const char *header), \
0158     TP_ARGS(skb, more, header))
0159 DEFINE_SKB_EVENT(tipc_skb_dump);
0160 DEFINE_SKB_EVENT(tipc_proto_build);
0161 DEFINE_SKB_EVENT(tipc_proto_rcv);
0162 
0163 DECLARE_EVENT_CLASS(tipc_list_class,
0164 
0165     TP_PROTO(struct sk_buff_head *list, bool more, const char *header),
0166 
0167     TP_ARGS(list, more, header),
0168 
0169     TP_STRUCT__entry(
0170         __string(header, header)
0171         __dynamic_array(char, buf, (more) ? LIST_LMAX : LIST_LMIN)
0172     ),
0173 
0174     TP_fast_assign(
0175         __assign_str(header, header);
0176         tipc_list_dump(list, more, __get_str(buf));
0177     ),
0178 
0179     TP_printk("%s\n%s", __get_str(header), __get_str(buf))
0180 );
0181 
0182 #define DEFINE_LIST_EVENT(name) \
0183 DEFINE_EVENT(tipc_list_class, name, \
0184     TP_PROTO(struct sk_buff_head *list, bool more, const char *header), \
0185     TP_ARGS(list, more, header))
0186 DEFINE_LIST_EVENT(tipc_list_dump);
0187 
0188 DECLARE_EVENT_CLASS(tipc_sk_class,
0189 
0190     TP_PROTO(struct sock *sk, struct sk_buff *skb, u16 dqueues,
0191          const char *header),
0192 
0193     TP_ARGS(sk, skb, dqueues, header),
0194 
0195     TP_STRUCT__entry(
0196         __string(header, header)
0197         __field(u32, portid)
0198         __dynamic_array(char, buf, (dqueues) ? SK_LMAX : SK_LMIN)
0199         __dynamic_array(char, skb_buf, (skb) ? SKB_LMIN : 1)
0200     ),
0201 
0202     TP_fast_assign(
0203         __assign_str(header, header);
0204         __entry->portid = tipc_sock_get_portid(sk);
0205         tipc_sk_dump(sk, dqueues, __get_str(buf));
0206         if (skb)
0207             tipc_skb_dump(skb, false, __get_str(skb_buf));
0208         else
0209             *(__get_str(skb_buf)) = '\0';
0210     ),
0211 
0212     TP_printk("<%u> %s\n%s%s", __entry->portid, __get_str(header),
0213           __get_str(skb_buf), __get_str(buf))
0214 );
0215 
0216 #define DEFINE_SK_EVENT_FILTER(name) \
0217 DEFINE_EVENT_CONDITION(tipc_sk_class, name, \
0218     TP_PROTO(struct sock *sk, struct sk_buff *skb, u16 dqueues, \
0219          const char *header), \
0220     TP_ARGS(sk, skb, dqueues, header), \
0221     TP_CONDITION(tipc_sk_filtering(sk)))
0222 DEFINE_SK_EVENT_FILTER(tipc_sk_dump);
0223 DEFINE_SK_EVENT_FILTER(tipc_sk_create);
0224 DEFINE_SK_EVENT_FILTER(tipc_sk_sendmcast);
0225 DEFINE_SK_EVENT_FILTER(tipc_sk_sendmsg);
0226 DEFINE_SK_EVENT_FILTER(tipc_sk_sendstream);
0227 DEFINE_SK_EVENT_FILTER(tipc_sk_poll);
0228 DEFINE_SK_EVENT_FILTER(tipc_sk_filter_rcv);
0229 DEFINE_SK_EVENT_FILTER(tipc_sk_advance_rx);
0230 DEFINE_SK_EVENT_FILTER(tipc_sk_rej_msg);
0231 DEFINE_SK_EVENT_FILTER(tipc_sk_drop_msg);
0232 DEFINE_SK_EVENT_FILTER(tipc_sk_release);
0233 DEFINE_SK_EVENT_FILTER(tipc_sk_shutdown);
0234 
0235 #define DEFINE_SK_EVENT_FILTER_COND(name, cond) \
0236 DEFINE_EVENT_CONDITION(tipc_sk_class, name, \
0237     TP_PROTO(struct sock *sk, struct sk_buff *skb, u16 dqueues, \
0238          const char *header), \
0239     TP_ARGS(sk, skb, dqueues, header), \
0240     TP_CONDITION(tipc_sk_filtering(sk) && (cond)))
0241 DEFINE_SK_EVENT_FILTER_COND(tipc_sk_overlimit1, tipc_sk_overlimit1(sk, skb));
0242 DEFINE_SK_EVENT_FILTER_COND(tipc_sk_overlimit2, tipc_sk_overlimit2(sk, skb));
0243 
0244 DECLARE_EVENT_CLASS(tipc_link_class,
0245 
0246     TP_PROTO(struct tipc_link *l, u16 dqueues, const char *header),
0247 
0248     TP_ARGS(l, dqueues, header),
0249 
0250     TP_STRUCT__entry(
0251         __string(header, header)
0252         __array(char, name, TIPC_MAX_LINK_NAME)
0253         __dynamic_array(char, buf, (dqueues) ? LINK_LMAX : LINK_LMIN)
0254     ),
0255 
0256     TP_fast_assign(
0257         __assign_str(header, header);
0258         memcpy(__entry->name, tipc_link_name(l), TIPC_MAX_LINK_NAME);
0259         tipc_link_dump(l, dqueues, __get_str(buf));
0260     ),
0261 
0262     TP_printk("<%s> %s\n%s", __entry->name, __get_str(header),
0263           __get_str(buf))
0264 );
0265 
0266 #define DEFINE_LINK_EVENT(name) \
0267 DEFINE_EVENT(tipc_link_class, name, \
0268     TP_PROTO(struct tipc_link *l, u16 dqueues, const char *header), \
0269     TP_ARGS(l, dqueues, header))
0270 DEFINE_LINK_EVENT(tipc_link_dump);
0271 DEFINE_LINK_EVENT(tipc_link_conges);
0272 DEFINE_LINK_EVENT(tipc_link_timeout);
0273 DEFINE_LINK_EVENT(tipc_link_reset);
0274 
0275 #define DEFINE_LINK_EVENT_COND(name, cond) \
0276 DEFINE_EVENT_CONDITION(tipc_link_class, name, \
0277     TP_PROTO(struct tipc_link *l, u16 dqueues, const char *header), \
0278     TP_ARGS(l, dqueues, header), \
0279     TP_CONDITION(cond))
0280 DEFINE_LINK_EVENT_COND(tipc_link_too_silent, tipc_link_too_silent(l));
0281 
0282 DECLARE_EVENT_CLASS(tipc_link_transmq_class,
0283 
0284     TP_PROTO(struct tipc_link *r, u16 f, u16 t, struct sk_buff_head *tq),
0285 
0286     TP_ARGS(r, f, t, tq),
0287 
0288     TP_STRUCT__entry(
0289         __array(char, name, TIPC_MAX_LINK_NAME)
0290         __field(u16, from)
0291         __field(u16, to)
0292         __field(u32, len)
0293         __field(u16, fseqno)
0294         __field(u16, lseqno)
0295     ),
0296 
0297     TP_fast_assign(
0298         memcpy(__entry->name, tipc_link_name(r), TIPC_MAX_LINK_NAME);
0299         __entry->from = f;
0300         __entry->to = t;
0301         __entry->len = skb_queue_len(tq);
0302         __entry->fseqno = __entry->len ?
0303                   msg_seqno(buf_msg(skb_peek(tq))) : 0;
0304         __entry->lseqno = __entry->len ?
0305                   msg_seqno(buf_msg(skb_peek_tail(tq))) : 0;
0306     ),
0307 
0308     TP_printk("<%s> retrans req: [%u-%u] transmq: %u [%u-%u]\n",
0309           __entry->name, __entry->from, __entry->to,
0310           __entry->len, __entry->fseqno, __entry->lseqno)
0311 );
0312 
0313 DEFINE_EVENT_CONDITION(tipc_link_transmq_class, tipc_link_retrans,
0314     TP_PROTO(struct tipc_link *r, u16 f, u16 t, struct sk_buff_head *tq),
0315     TP_ARGS(r, f, t, tq),
0316     TP_CONDITION(less_eq(f, t))
0317 );
0318 
0319 DEFINE_EVENT_PRINT(tipc_link_transmq_class, tipc_link_bc_ack,
0320     TP_PROTO(struct tipc_link *r, u16 f, u16 t, struct sk_buff_head *tq),
0321     TP_ARGS(r, f, t, tq),
0322     TP_printk("<%s> acked: %u gap: %u transmq: %u [%u-%u]\n",
0323           __entry->name, __entry->from, __entry->to,
0324           __entry->len, __entry->fseqno, __entry->lseqno)
0325 );
0326 
0327 DECLARE_EVENT_CLASS(tipc_node_class,
0328 
0329     TP_PROTO(struct tipc_node *n, bool more, const char *header),
0330 
0331     TP_ARGS(n, more, header),
0332 
0333     TP_STRUCT__entry(
0334         __string(header, header)
0335         __field(u32, addr)
0336         __dynamic_array(char, buf, (more) ? NODE_LMAX : NODE_LMIN)
0337     ),
0338 
0339     TP_fast_assign(
0340         __assign_str(header, header);
0341         __entry->addr = tipc_node_get_addr(n);
0342         tipc_node_dump(n, more, __get_str(buf));
0343     ),
0344 
0345     TP_printk("<%x> %s\n%s", __entry->addr, __get_str(header),
0346           __get_str(buf))
0347 );
0348 
0349 #define DEFINE_NODE_EVENT(name) \
0350 DEFINE_EVENT(tipc_node_class, name, \
0351     TP_PROTO(struct tipc_node *n, bool more, const char *header), \
0352     TP_ARGS(n, more, header))
0353 DEFINE_NODE_EVENT(tipc_node_dump);
0354 DEFINE_NODE_EVENT(tipc_node_create);
0355 DEFINE_NODE_EVENT(tipc_node_delete);
0356 DEFINE_NODE_EVENT(tipc_node_lost_contact);
0357 DEFINE_NODE_EVENT(tipc_node_timeout);
0358 DEFINE_NODE_EVENT(tipc_node_link_up);
0359 DEFINE_NODE_EVENT(tipc_node_link_down);
0360 DEFINE_NODE_EVENT(tipc_node_reset_links);
0361 DEFINE_NODE_EVENT(tipc_node_check_state);
0362 
0363 DECLARE_EVENT_CLASS(tipc_fsm_class,
0364 
0365     TP_PROTO(const char *name, u32 os, u32 ns, int evt),
0366 
0367     TP_ARGS(name, os, ns, evt),
0368 
0369     TP_STRUCT__entry(
0370         __string(name, name)
0371         __field(u32, os)
0372         __field(u32, ns)
0373         __field(u32, evt)
0374     ),
0375 
0376     TP_fast_assign(
0377         __assign_str(name, name);
0378         __entry->os = os;
0379         __entry->ns = ns;
0380         __entry->evt = evt;
0381     ),
0382 
0383     TP_printk("<%s> %s--(%s)->%s\n", __get_str(name),
0384           state_sym(__entry->os), evt_sym(__entry->evt),
0385           state_sym(__entry->ns))
0386 );
0387 
0388 #define DEFINE_FSM_EVENT(fsm_name) \
0389 DEFINE_EVENT(tipc_fsm_class, fsm_name, \
0390     TP_PROTO(const char *name, u32 os, u32 ns, int evt), \
0391     TP_ARGS(name, os, ns, evt))
0392 DEFINE_FSM_EVENT(tipc_link_fsm);
0393 DEFINE_FSM_EVENT(tipc_node_fsm);
0394 
0395 TRACE_EVENT(tipc_l2_device_event,
0396 
0397     TP_PROTO(struct net_device *dev, struct tipc_bearer *b,
0398          unsigned long evt),
0399 
0400     TP_ARGS(dev, b, evt),
0401 
0402     TP_STRUCT__entry(
0403         __string(dev_name, dev->name)
0404         __string(b_name, b->name)
0405         __field(unsigned long, evt)
0406         __field(u8, b_up)
0407         __field(u8, carrier)
0408         __field(u8, oper)
0409     ),
0410 
0411     TP_fast_assign(
0412         __assign_str(dev_name, dev->name);
0413         __assign_str(b_name, b->name);
0414         __entry->evt = evt;
0415         __entry->b_up = test_bit(0, &b->up);
0416         __entry->carrier = netif_carrier_ok(dev);
0417         __entry->oper = netif_oper_up(dev);
0418     ),
0419 
0420     TP_printk("%s on: <%s>/<%s> oper: %s carrier: %s bearer: %s\n",
0421           dev_evt_sym(__entry->evt), __get_str(dev_name),
0422           __get_str(b_name), (__entry->oper) ? "up" : "down",
0423           (__entry->carrier) ? "ok" : "notok",
0424           (__entry->b_up) ? "up" : "down")
0425 );
0426 
0427 #endif /* _TIPC_TRACE_H */
0428 
0429 /* This part must be outside protection */
0430 #undef TRACE_INCLUDE_PATH
0431 #define TRACE_INCLUDE_PATH .
0432 #undef TRACE_INCLUDE_FILE
0433 #define TRACE_INCLUDE_FILE trace
0434 #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!