instrumentation/events/lttng-module/lttng-statedump.h

   1 #undef TRACE_SYSTEM
   2 #define TRACE_SYSTEM lttng_statedump
   3
   4 #if !defined(_TRACE_LTTNG_STATEDUMP_H) || defined(TRACE_HEADER_MULTI_READ)
   5 #define _TRACE_LTTNG_STATEDUMP_H
   6
   7 #include <linux/tracepoint.h>
   8 #include <linux/nsproxy.h>
   9
  10 TRACE_EVENT(lttng_statedump_start,
  11         TP_PROTO(struct lttng_session *session),
  12         TP_ARGS(session),
  13         TP_STRUCT__entry(
  14         ),
  15         TP_fast_assign(
  16         ),
  17         TP_printk("")
  18 )
  19
  20 TRACE_EVENT(lttng_statedump_end,
  21         TP_PROTO(struct lttng_session *session),
  22         TP_ARGS(session),
  23         TP_STRUCT__entry(
  24         ),
  25         TP_fast_assign(
  26         ),
  27         TP_printk("")
  28 )
  29
  30 TRACE_EVENT(lttng_statedump_process_state,
  31         TP_PROTO(struct lttng_session *session,
  32                 struct task_struct *p,
  33                 int type, int mode, int submode, int status),
  34         TP_ARGS(session, p, type, mode, submode, status),
  35         TP_STRUCT__entry(
  36                 __field(pid_t, tid)
  37                 __field(pid_t, vtid)
  38                 __field(pid_t, pid)
  39                 __field(pid_t, vpid)
  40                 __field(pid_t, ppid)
  41                 __field(pid_t, vppid)
  42                 __array_text(char, name, TASK_COMM_LEN)
  43                 __field(int, type)
  44                 __field(int, mode)
  45                 __field(int, submode)
  46                 __field(int, status)
  47         ),
  48         TP_fast_assign(
  49                 tp_assign(tid, p->pid)
  50                 tp_assign(vtid,
  51                         ({
  52                                 struct nsproxy *proxy;
  53                                 pid_t ret = 0;
  54
  55                                 rcu_read_lock();
  56                                 proxy = task_nsproxy(p);
  57                                 if (proxy) {
  58                                         ret = task_pid_nr_ns(p,
  59                                                 proxy->pid_ns);
  60                                 }
  61                                 rcu_read_unlock();
  62                                 ret;
  63                         }))
  64                 tp_assign(pid, p->tgid)
  65                 tp_assign(vpid,
  66                         ({
  67                                  struct nsproxy *proxy;
  68                                  pid_t ret = 0;
  69
  70                                  rcu_read_lock();
  71                                  proxy = task_nsproxy(p);
  72                                  if (proxy) {
  73                                          ret = task_tgid_nr_ns(p,
  74                                                  proxy->pid_ns);
  75                                  }
  76                                  rcu_read_unlock();
  77                                  ret;
  78                          }))
  79                 tp_assign(ppid,
  80                         ({
  81                                 pid_t ret;
  82
  83                                 rcu_read_lock();
  84                                 ret = task_tgid_nr(p->real_parent);
  85                                 rcu_read_unlock();
  86                                 ret;
  87                         }))
  88                 tp_assign(vppid,
  89                         ({
  90                                 struct task_struct *parent;
  91                                 struct nsproxy *proxy;
  92                                 pid_t ret = 0;
  93
  94                                 rcu_read_lock();
  95                                 parent = rcu_dereference(p->real_parent);
  96                                 proxy = task_nsproxy(parent);
  97                                 if (proxy) {
  98                                         ret = task_tgid_nr_ns(parent,
  99                                                 proxy->pid_ns);
 100                                 }
 101                                 rcu_read_unlock();
 102                                 ret;
 103                         }))
 104                 tp_memcpy(name, p->comm, TASK_COMM_LEN)
 105                 tp_assign(type, type)
 106                 tp_assign(mode, mode)
 107                 tp_assign(submode, submode)
 108                 tp_assign(status, status)
 109         ),
 110         TP_printk("")
 111 )
 112
 113 TRACE_EVENT(lttng_statedump_file_descriptor,
 114         TP_PROTO(struct lttng_session *session,
 115                 struct task_struct *p, int fd, const char *filename),
 116         TP_ARGS(session, p, fd, filename),
 117         TP_STRUCT__entry(
 118                 __field(pid_t, pid)
 119                 __field(int, fd)
 120                 __string(filename, filename)
 121         ),
 122         TP_fast_assign(
 123                 tp_assign(pid, p->tgid)
 124                 tp_assign(fd, fd)
 125                 tp_strcpy(filename, filename)
 126         ),
 127         TP_printk("")
 128 )
 129
 130 TRACE_EVENT(lttng_statedump_vm_map,
 131         TP_PROTO(struct lttng_session *session,
 132                 struct task_struct *p, struct vm_area_struct *map,
 133                 unsigned long inode),
 134         TP_ARGS(session, p, map, inode),
 135         TP_STRUCT__entry(
 136                 __field(pid_t, pid)
 137                 __field_hex(unsigned long, start)
 138                 __field_hex(unsigned long, end)
 139                 __field_hex(unsigned long, flags)
 140                 __field(unsigned long, inode)
 141                 __field(unsigned long, pgoff)
 142         ),
 143         TP_fast_assign(
 144                 tp_assign(pid, p->tgid)
 145                 tp_assign(start, map->vm_start)
 146                 tp_assign(end, map->vm_end)
 147                 tp_assign(flags, map->vm_flags)
 148                 tp_assign(inode, inode)
 149                 tp_assign(pgoff, map->vm_pgoff << PAGE_SHIFT)
 150         ),
 151         TP_printk("")
 152 )
 153
 154 TRACE_EVENT(lttng_statedump_network_interface,
 155         TP_PROTO(struct lttng_session *session,
 156                 struct net_device *dev, struct in_ifaddr *ifa),
 157         TP_ARGS(session, dev, ifa),
 158         TP_STRUCT__entry(
 159                 __string(name, dev->name)
 160                 __field_network_hex(uint32_t, address_ipv4)
 161         ),
 162         TP_fast_assign(
 163                 tp_strcpy(name, dev->name)
 164                 tp_assign(address_ipv4, ifa ? ifa->ifa_address : 0U)
 165         ),
 166         TP_printk("")
 167 )
 168
 169 /* Called with desc->lock held */
 170 TRACE_EVENT(lttng_statedump_interrupt,
 171         TP_PROTO(struct lttng_session *session,
 172                 unsigned int irq, const char *chip_name,
 173                 struct irqaction *action),
 174         TP_ARGS(session, irq, chip_name, action),
 175         TP_STRUCT__entry(
 176                 __field(unsigned int, irq)
 177                 __string(name, chip_name)
 178                 __string(action, action->name)
 179         ),
 180         TP_fast_assign(
 181                 tp_assign(irq, irq)
 182                 tp_strcpy(name, chip_name)
 183                 tp_strcpy(action, action->name)
 184         ),
 185         TP_printk("")
 186 )
 187
 188 #endif /*  _TRACE_LTTNG_STATEDUMP_H */
 189
 190 /* This part must be outside protection */
 191 #include "../../../probes/define_trace.h"