Alexey Ivanov | 777e802 | 2019-01-03 13:46:38 -0800 | [diff] [blame] | 1 | #!/usr/bin/env python |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 2 | # @lint-avoid-python-3-compatibility-imports |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 3 | # |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 4 | # tcpaccept Trace TCP accept()s. |
| 5 | # For Linux, uses BCC, eBPF. Embedded C. |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 6 | # |
| 7 | # USAGE: tcpaccept [-h] [-t] [-p PID] |
| 8 | # |
| 9 | # This uses dynamic tracing of the kernel inet_csk_accept() socket function |
| 10 | # (from tcp_prot.accept), and will need to be modified to match kernel changes. |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 11 | # |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 12 | # Copyright (c) 2015 Brendan Gregg. |
| 13 | # Licensed under the Apache License, Version 2.0 (the "License") |
| 14 | # |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 15 | # 13-Oct-2015 Brendan Gregg Created this. |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 16 | # 14-Feb-2016 " " Switch to bpf_perf_output. |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 17 | |
| 18 | from __future__ import print_function |
| 19 | from bcc import BPF |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 20 | from socket import inet_ntop, AF_INET, AF_INET6 |
| 21 | from struct import pack |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 22 | import argparse |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 23 | import ctypes as ct |
japroc | aed9b1e | 2019-01-04 20:21:46 +0300 | [diff] [blame] | 24 | from bcc.utils import printb |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 25 | |
| 26 | # arguments |
| 27 | examples = """examples: |
Brendan Gregg | 000a4e6 | 2015-10-13 15:41:46 -0700 | [diff] [blame] | 28 | ./tcpaccept # trace all TCP accept()s |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 29 | ./tcpaccept -t # include timestamps |
| 30 | ./tcpaccept -p 181 # only trace PID 181 |
| 31 | """ |
| 32 | parser = argparse.ArgumentParser( |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 33 | description="Trace TCP accepts", |
| 34 | formatter_class=argparse.RawDescriptionHelpFormatter, |
| 35 | epilog=examples) |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 36 | parser.add_argument("-t", "--timestamp", action="store_true", |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 37 | help="include timestamp on output") |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 38 | parser.add_argument("-p", "--pid", |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 39 | help="trace this PID only") |
Nathan Scott | cf0792f | 2018-02-02 16:56:50 +1100 | [diff] [blame] | 40 | parser.add_argument("--ebpf", action="store_true", |
| 41 | help=argparse.SUPPRESS) |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 42 | args = parser.parse_args() |
| 43 | debug = 0 |
| 44 | |
| 45 | # define BPF program |
| 46 | bpf_text = """ |
| 47 | #include <uapi/linux/ptrace.h> |
| 48 | #include <net/sock.h> |
| 49 | #include <bcc/proto.h> |
| 50 | |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 51 | // separate data structs for ipv4 and ipv6 |
| 52 | struct ipv4_data_t { |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 53 | u64 ts_us; |
Joe Yin | 36ce112 | 2018-08-17 06:04:00 +0800 | [diff] [blame] | 54 | u32 pid; |
Joe Yin | 365eade | 2018-06-21 13:41:03 +0800 | [diff] [blame] | 55 | u32 saddr; |
| 56 | u32 daddr; |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 57 | u64 ip; |
Joe Yin | 36ce112 | 2018-08-17 06:04:00 +0800 | [diff] [blame] | 58 | u16 lport; |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 59 | char task[TASK_COMM_LEN]; |
| 60 | }; |
| 61 | BPF_PERF_OUTPUT(ipv4_events); |
| 62 | |
| 63 | struct ipv6_data_t { |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 64 | u64 ts_us; |
Joe Yin | 36ce112 | 2018-08-17 06:04:00 +0800 | [diff] [blame] | 65 | u32 pid; |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 66 | unsigned __int128 saddr; |
| 67 | unsigned __int128 daddr; |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 68 | u64 ip; |
Joe Yin | 36ce112 | 2018-08-17 06:04:00 +0800 | [diff] [blame] | 69 | u16 lport; |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 70 | char task[TASK_COMM_LEN]; |
| 71 | }; |
| 72 | BPF_PERF_OUTPUT(ipv6_events); |
Joe Yin | 365eade | 2018-06-21 13:41:03 +0800 | [diff] [blame] | 73 | """ |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 74 | |
Joe Yin | 365eade | 2018-06-21 13:41:03 +0800 | [diff] [blame] | 75 | # |
| 76 | # The following is the code for older kernels(Linux pre-4.16). |
| 77 | # It uses kprobes to instrument inet_csk_accept(). On Linux 4.16 and |
| 78 | # later, the sock:inet_sock_set_state tracepoint should be used instead, as |
| 79 | # is done by the code that follows this. |
| 80 | # |
| 81 | bpf_text_kprobe = """ |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 82 | int kretprobe__inet_csk_accept(struct pt_regs *ctx) |
| 83 | { |
Naveen N. Rao | 4afa96a | 2016-05-03 14:54:21 +0530 | [diff] [blame] | 84 | struct sock *newsk = (struct sock *)PT_REGS_RC(ctx); |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 85 | u32 pid = bpf_get_current_pid_tgid(); |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 86 | |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 87 | if (newsk == NULL) |
| 88 | return 0; |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 89 | |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 90 | // check this is TCP |
| 91 | u8 protocol = 0; |
| 92 | // workaround for reading the sk_protocol bitfield: |
Joe Yin | 116bb40 | 2018-06-18 23:34:52 +0800 | [diff] [blame] | 93 | |
| 94 | // Following comments add by Joe Yin: |
| 95 | // Unfortunately,it can not work since Linux 4.10, |
| 96 | // because the sk_wmem_queued is not following the bitfield of sk_protocol. |
| 97 | // And the following member is sk_gso_max_segs. |
| 98 | // So, we can use this: |
| 99 | // bpf_probe_read(&protocol, 1, (void *)((u64)&newsk->sk_gso_max_segs) - 3); |
| 100 | // In order to diff the pre-4.10 and 4.10+ ,introduce the variables gso_max_segs_offset,sk_lingertime, |
| 101 | // sk_lingertime is closed to the gso_max_segs_offset,and |
| 102 | // the offset between the two members is 4 |
| 103 | |
| 104 | int gso_max_segs_offset = offsetof(struct sock, sk_gso_max_segs); |
| 105 | int sk_lingertime_offset = offsetof(struct sock, sk_lingertime); |
| 106 | |
| 107 | if (sk_lingertime_offset - gso_max_segs_offset == 4) |
| 108 | // 4.10+ with little endian |
| 109 | #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ |
Paul Chaignon | 8d78edd | 2018-06-29 07:47:44 +0200 | [diff] [blame] | 110 | protocol = *(u8 *)((u64)&newsk->sk_gso_max_segs - 3); |
Joe Yin | 116bb40 | 2018-06-18 23:34:52 +0800 | [diff] [blame] | 111 | else |
| 112 | // pre-4.10 with little endian |
Paul Chaignon | 8d78edd | 2018-06-29 07:47:44 +0200 | [diff] [blame] | 113 | protocol = *(u8 *)((u64)&newsk->sk_wmem_queued - 3); |
Joe Yin | 116bb40 | 2018-06-18 23:34:52 +0800 | [diff] [blame] | 114 | #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ |
| 115 | // 4.10+ with big endian |
Paul Chaignon | 8d78edd | 2018-06-29 07:47:44 +0200 | [diff] [blame] | 116 | protocol = *(u8 *)((u64)&newsk->sk_gso_max_segs - 1); |
Joe Yin | 116bb40 | 2018-06-18 23:34:52 +0800 | [diff] [blame] | 117 | else |
| 118 | // pre-4.10 with big endian |
Paul Chaignon | 8d78edd | 2018-06-29 07:47:44 +0200 | [diff] [blame] | 119 | protocol = *(u8 *)((u64)&newsk->sk_wmem_queued - 1); |
Joe Yin | 116bb40 | 2018-06-18 23:34:52 +0800 | [diff] [blame] | 120 | #else |
| 121 | # error "Fix your compiler's __BYTE_ORDER__?!" |
| 122 | #endif |
| 123 | |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 124 | if (protocol != IPPROTO_TCP) |
| 125 | return 0; |
Brendan Gregg | 10e1b14 | 2015-10-13 16:35:25 -0700 | [diff] [blame] | 126 | |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 127 | // pull in details |
| 128 | u16 family = 0, lport = 0; |
Paul Chaignon | a9f96c0 | 2018-06-15 00:27:08 +0200 | [diff] [blame] | 129 | family = newsk->__sk_common.skc_family; |
| 130 | lport = newsk->__sk_common.skc_num; |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 131 | |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 132 | if (family == AF_INET) { |
| 133 | struct ipv4_data_t data4 = {.pid = pid, .ip = 4}; |
| 134 | data4.ts_us = bpf_ktime_get_ns() / 1000; |
Paul Chaignon | a9f96c0 | 2018-06-15 00:27:08 +0200 | [diff] [blame] | 135 | data4.saddr = newsk->__sk_common.skc_rcv_saddr; |
| 136 | data4.daddr = newsk->__sk_common.skc_daddr; |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 137 | data4.lport = lport; |
| 138 | bpf_get_current_comm(&data4.task, sizeof(data4.task)); |
| 139 | ipv4_events.perf_submit(ctx, &data4, sizeof(data4)); |
| 140 | |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 141 | } else if (family == AF_INET6) { |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 142 | struct ipv6_data_t data6 = {.pid = pid, .ip = 6}; |
| 143 | data6.ts_us = bpf_ktime_get_ns() / 1000; |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 144 | bpf_probe_read(&data6.saddr, sizeof(data6.saddr), |
| 145 | &newsk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); |
| 146 | bpf_probe_read(&data6.daddr, sizeof(data6.daddr), |
| 147 | &newsk->__sk_common.skc_v6_daddr.in6_u.u6_addr32); |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 148 | data6.lport = lport; |
| 149 | bpf_get_current_comm(&data6.task, sizeof(data6.task)); |
| 150 | ipv6_events.perf_submit(ctx, &data6, sizeof(data6)); |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 151 | } |
| 152 | // else drop |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 153 | |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 154 | return 0; |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 155 | } |
| 156 | """ |
| 157 | |
Joe Yin | 365eade | 2018-06-21 13:41:03 +0800 | [diff] [blame] | 158 | bpf_text_tracepoint = """ |
| 159 | TRACEPOINT_PROBE(sock, inet_sock_set_state) |
| 160 | { |
| 161 | if (args->protocol != IPPROTO_TCP) |
| 162 | return 0; |
| 163 | u32 pid = bpf_get_current_pid_tgid(); |
| 164 | // pull in details |
| 165 | u16 family = 0, lport = 0; |
| 166 | family = args->family; |
| 167 | lport = args->sport; |
| 168 | |
| 169 | if (family == AF_INET) { |
| 170 | struct ipv4_data_t data4 = {.pid = pid, .ip = 4}; |
| 171 | data4.ts_us = bpf_ktime_get_ns() / 1000; |
| 172 | __builtin_memcpy(&data4.saddr, args->saddr, sizeof(data4.saddr)); |
| 173 | __builtin_memcpy(&data4.daddr, args->daddr, sizeof(data4.daddr)); |
| 174 | data4.lport = lport; |
| 175 | bpf_get_current_comm(&data4.task, sizeof(data4.task)); |
| 176 | ipv4_events.perf_submit(args, &data4, sizeof(data4)); |
| 177 | } else if (family == AF_INET6) { |
| 178 | struct ipv6_data_t data6 = {.pid = pid, .ip = 6}; |
| 179 | data6.ts_us = bpf_ktime_get_ns() / 1000; |
| 180 | __builtin_memcpy(&data6.saddr, args->saddr, sizeof(data6.saddr)); |
| 181 | __builtin_memcpy(&data6.daddr, args->daddr, sizeof(data6.daddr)); |
| 182 | data6.lport = lport; |
| 183 | bpf_get_current_comm(&data6.task, sizeof(data6.task)); |
| 184 | ipv6_events.perf_submit(args, &data6, sizeof(data6)); |
| 185 | } |
| 186 | // else drop |
| 187 | |
| 188 | return 0; |
| 189 | } |
| 190 | """ |
| 191 | |
| 192 | if (BPF.tracepoint_exists("sock", "inet_sock_set_state")): |
| 193 | bpf_text += bpf_text_tracepoint |
| 194 | else: |
| 195 | bpf_text += bpf_text_kprobe |
| 196 | |
| 197 | |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 198 | # code substitutions |
| 199 | if args.pid: |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 200 | bpf_text = bpf_text.replace('FILTER', |
| 201 | 'if (pid != %s) { return 0; }' % args.pid) |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 202 | else: |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 203 | bpf_text = bpf_text.replace('FILTER', '') |
Nathan Scott | cf0792f | 2018-02-02 16:56:50 +1100 | [diff] [blame] | 204 | if debug or args.ebpf: |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 205 | print(bpf_text) |
Nathan Scott | cf0792f | 2018-02-02 16:56:50 +1100 | [diff] [blame] | 206 | if args.ebpf: |
| 207 | exit() |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 208 | |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 209 | # event data |
| 210 | TASK_COMM_LEN = 16 # linux/sched.h |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 211 | |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 212 | class Data_ipv4(ct.Structure): |
| 213 | _fields_ = [ |
| 214 | ("ts_us", ct.c_ulonglong), |
Joe Yin | 36ce112 | 2018-08-17 06:04:00 +0800 | [diff] [blame] | 215 | ("pid", ct.c_uint), |
Joe Yin | 365eade | 2018-06-21 13:41:03 +0800 | [diff] [blame] | 216 | ("saddr", ct.c_uint), |
| 217 | ("daddr", ct.c_uint), |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 218 | ("ip", ct.c_ulonglong), |
Joe Yin | 36ce112 | 2018-08-17 06:04:00 +0800 | [diff] [blame] | 219 | ("lport", ct.c_ushort), |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 220 | ("task", ct.c_char * TASK_COMM_LEN) |
| 221 | ] |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 222 | |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 223 | class Data_ipv6(ct.Structure): |
| 224 | _fields_ = [ |
| 225 | ("ts_us", ct.c_ulonglong), |
Joe Yin | 36ce112 | 2018-08-17 06:04:00 +0800 | [diff] [blame] | 226 | ("pid", ct.c_uint), |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 227 | ("saddr", (ct.c_ulonglong * 2)), |
| 228 | ("daddr", (ct.c_ulonglong * 2)), |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 229 | ("ip", ct.c_ulonglong), |
Joe Yin | 36ce112 | 2018-08-17 06:04:00 +0800 | [diff] [blame] | 230 | ("lport", ct.c_ushort), |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 231 | ("task", ct.c_char * TASK_COMM_LEN) |
| 232 | ] |
| 233 | |
| 234 | # process event |
| 235 | def print_ipv4_event(cpu, data, size): |
| 236 | event = ct.cast(data, ct.POINTER(Data_ipv4)).contents |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 237 | global start_ts |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 238 | if args.timestamp: |
| 239 | if start_ts == 0: |
| 240 | start_ts = event.ts_us |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 241 | print("%-9.3f" % ((float(event.ts_us) - start_ts) / 1000000), end="") |
japroc | aed9b1e | 2019-01-04 20:21:46 +0300 | [diff] [blame] | 242 | printb(b"%-6d %-12.12s %-2d %-16s %-16s %-4d" % (event.pid, |
jeromemarchand | b96ebcd | 2018-10-10 01:58:15 +0200 | [diff] [blame] | 243 | event.task.decode('utf-8', 'replace'), event.ip, |
Rafael F | 78948e4 | 2017-03-26 14:54:25 +0200 | [diff] [blame] | 244 | inet_ntop(AF_INET, pack("I", event.daddr)), |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 245 | inet_ntop(AF_INET, pack("I", event.saddr)), event.lport)) |
| 246 | |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 247 | def print_ipv6_event(cpu, data, size): |
| 248 | event = ct.cast(data, ct.POINTER(Data_ipv6)).contents |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 249 | global start_ts |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 250 | if args.timestamp: |
| 251 | if start_ts == 0: |
| 252 | start_ts = event.ts_us |
Mark Drayton | 11de298 | 2016-06-26 21:14:44 +0100 | [diff] [blame] | 253 | print("%-9.3f" % ((float(event.ts_us) - start_ts) / 1000000), end="") |
japroc | aed9b1e | 2019-01-04 20:21:46 +0300 | [diff] [blame] | 254 | printb(b"%-6d %-12.12s %-2d %-16s %-16s %-4d" % (event.pid, |
jeromemarchand | b96ebcd | 2018-10-10 01:58:15 +0200 | [diff] [blame] | 255 | event.task.decode('utf-8', 'replace'), event.ip, |
| 256 | inet_ntop(AF_INET6, event.daddr),inet_ntop(AF_INET6, event.saddr), |
| 257 | event.lport)) |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 258 | |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 259 | # initialize BPF |
| 260 | b = BPF(text=bpf_text) |
| 261 | |
| 262 | # header |
| 263 | if args.timestamp: |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 264 | print("%-9s" % ("TIME(s)"), end="") |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 265 | print("%-6s %-12s %-2s %-16s %-16s %-4s" % ("PID", "COMM", "IP", "RADDR", |
| 266 | "LADDR", "LPORT")) |
| 267 | |
| 268 | start_ts = 0 |
| 269 | |
Brendan Gregg | 2482552 | 2016-02-14 16:32:29 -0800 | [diff] [blame] | 270 | # read events |
| 271 | b["ipv4_events"].open_perf_buffer(print_ipv4_event) |
| 272 | b["ipv6_events"].open_perf_buffer(print_ipv6_event) |
Brendan Gregg | 052f89c | 2015-10-13 15:35:58 -0700 | [diff] [blame] | 273 | while 1: |
Jerome Marchand | 5167127 | 2018-12-19 01:57:24 +0100 | [diff] [blame] | 274 | try: |
| 275 | b.perf_buffer_poll() |
| 276 | except KeyboardInterrupt: |
| 277 | exit() |