blob: 3b508875f8806376e494eab5593c2566667cfaa3 [file] [log] [blame]
Alexey Ivanovcc01a9c2019-01-16 09:50:46 -08001#!/usr/bin/python
Alexei Starovoitovbdf07732016-01-14 10:09:20 -08002# @lint-avoid-python-3-compatibility-imports
Brendan Greggbedd1502015-09-17 21:52:52 -07003#
Alexei Starovoitovbdf07732016-01-14 10:09:20 -08004# opensnoop Trace open() syscalls.
5# For Linux, uses BCC, eBPF. Embedded C.
Brendan Greggbedd1502015-09-17 21:52:52 -07006#
Paul Chaignon702de382018-01-28 13:41:35 +01007# USAGE: opensnoop [-h] [-T] [-x] [-p PID] [-d DURATION] [-t TID] [-n NAME]
Brendan Greggbedd1502015-09-17 21:52:52 -07008#
9# Copyright (c) 2015 Brendan Gregg.
10# Licensed under the Apache License, Version 2.0 (the "License")
11#
Alexei Starovoitovbdf07732016-01-14 10:09:20 -080012# 17-Sep-2015 Brendan Gregg Created this.
Dina Goldshtein99a3bc82016-10-10 21:37:36 +030013# 29-Apr-2016 Allan McAleavy Updated for BPF_PERF_OUTPUT.
14# 08-Oct-2016 Dina Goldshtein Support filtering by PID and TID.
Tim Douglasd3583a82018-12-30 13:18:54 -050015# 28-Dec-2018 Tim Douglas Print flags argument, enable filtering
takumakumef8990372019-01-02 17:12:14 +090016# 06-Jan-2019 Takuma Kume Support filtering by UID
Brendan Greggbedd1502015-09-17 21:52:52 -070017
18from __future__ import print_function
Gary Lin40fd6692018-02-12 16:51:14 +080019from bcc import ArgString, BPF
Alban Crequy32ab8582020-03-22 16:06:44 +010020from bcc.containers import filter_by_containers
japrocaed9b1e2019-01-04 20:21:46 +030021from bcc.utils import printb
Brendan Greggbedd1502015-09-17 21:52:52 -070022import argparse
Paul Chaignon702de382018-01-28 13:41:35 +010023from datetime import datetime, timedelta
Tim Douglasd3583a82018-12-30 13:18:54 -050024import os
Brendan Greggbedd1502015-09-17 21:52:52 -070025
26# arguments
27examples = """examples:
28 ./opensnoop # trace all open() syscalls
Dina Goldshtein99a3bc82016-10-10 21:37:36 +030029 ./opensnoop -T # include timestamps
takumakumef8990372019-01-02 17:12:14 +090030 ./opensnoop -U # include UID
Brendan Greggbedd1502015-09-17 21:52:52 -070031 ./opensnoop -x # only show failed opens
32 ./opensnoop -p 181 # only trace PID 181
Dina Goldshtein99a3bc82016-10-10 21:37:36 +030033 ./opensnoop -t 123 # only trace TID 123
takumakumef8990372019-01-02 17:12:14 +090034 ./opensnoop -u 1000 # only trace UID 1000
Paul Chaignon702de382018-01-28 13:41:35 +010035 ./opensnoop -d 10 # trace for 10 seconds only
KarimAllah Ahmed765dfe22016-09-10 12:01:07 +020036 ./opensnoop -n main # only print process names containing "main"
Tim Douglasd3583a82018-12-30 13:18:54 -050037 ./opensnoop -e # show extended fields
38 ./opensnoop -f O_WRONLY -f O_RDWR # only print calls for writing
Alban Crequy32ab8582020-03-22 16:06:44 +010039 ./opensnoop --cgroupmap mappath # only trace cgroups in this BPF map
40 ./opensnoop --mntnsmap mappath # only trace mount namespaces in the map
Brendan Greggbedd1502015-09-17 21:52:52 -070041"""
42parser = argparse.ArgumentParser(
Alexei Starovoitovbdf07732016-01-14 10:09:20 -080043 description="Trace open() syscalls",
44 formatter_class=argparse.RawDescriptionHelpFormatter,
45 epilog=examples)
Dina Goldshtein99a3bc82016-10-10 21:37:36 +030046parser.add_argument("-T", "--timestamp", action="store_true",
Alexei Starovoitovbdf07732016-01-14 10:09:20 -080047 help="include timestamp on output")
takumakumef8990372019-01-02 17:12:14 +090048parser.add_argument("-U", "--print-uid", action="store_true",
49 help="print UID column")
Brendan Greggbedd1502015-09-17 21:52:52 -070050parser.add_argument("-x", "--failed", action="store_true",
Alexei Starovoitovbdf07732016-01-14 10:09:20 -080051 help="only show failed opens")
Brendan Greggbedd1502015-09-17 21:52:52 -070052parser.add_argument("-p", "--pid",
Alexei Starovoitovbdf07732016-01-14 10:09:20 -080053 help="trace this PID only")
Dina Goldshtein99a3bc82016-10-10 21:37:36 +030054parser.add_argument("-t", "--tid",
55 help="trace this TID only")
Alban Crequyb2aa29f2019-12-16 10:54:18 +010056parser.add_argument("--cgroupmap",
57 help="trace cgroups in this BPF map only")
Alban Crequy32ab8582020-03-22 16:06:44 +010058parser.add_argument("--mntnsmap",
59 help="trace mount namespaces in this BPF map only")
takumakumef8990372019-01-02 17:12:14 +090060parser.add_argument("-u", "--uid",
61 help="trace this UID only")
Paul Chaignon702de382018-01-28 13:41:35 +010062parser.add_argument("-d", "--duration",
63 help="total duration of trace in seconds")
KarimAllah Ahmed765dfe22016-09-10 12:01:07 +020064parser.add_argument("-n", "--name",
Gary Lin40fd6692018-02-12 16:51:14 +080065 type=ArgString,
KarimAllah Ahmed765dfe22016-09-10 12:01:07 +020066 help="only print process names containing this name")
Nathan Scottcf0792f2018-02-02 16:56:50 +110067parser.add_argument("--ebpf", action="store_true",
68 help=argparse.SUPPRESS)
Tim Douglasd3583a82018-12-30 13:18:54 -050069parser.add_argument("-e", "--extended_fields", action="store_true",
70 help="show extended fields")
71parser.add_argument("-f", "--flag_filter", action="append",
72 help="filter on flags argument (e.g., O_WRONLY)")
Brendan Greggbedd1502015-09-17 21:52:52 -070073args = parser.parse_args()
74debug = 0
Paul Chaignon702de382018-01-28 13:41:35 +010075if args.duration:
76 args.duration = timedelta(seconds=int(args.duration))
Tim Douglasd3583a82018-12-30 13:18:54 -050077flag_filter_mask = 0
78for flag in args.flag_filter or []:
79 if not flag.startswith('O_'):
80 exit("Bad flag: %s" % flag)
81 try:
82 flag_filter_mask |= getattr(os, flag)
83 except AttributeError:
84 exit("Bad flag: %s" % flag)
Brendan Greggbedd1502015-09-17 21:52:52 -070085
86# define BPF program
87bpf_text = """
88#include <uapi/linux/ptrace.h>
mcaleavya3c446c72016-04-29 13:38:51 +010089#include <uapi/linux/limits.h>
90#include <linux/sched.h>
91
92struct val_t {
Dina Goldshtein99a3bc82016-10-10 21:37:36 +030093 u64 id;
mcaleavya3c446c72016-04-29 13:38:51 +010094 char comm[TASK_COMM_LEN];
95 const char *fname;
Tim Douglasd3583a82018-12-30 13:18:54 -050096 int flags; // EXTENDED_STRUCT_MEMBER
mcaleavya3c446c72016-04-29 13:38:51 +010097};
98
99struct data_t {
Dina Goldshtein99a3bc82016-10-10 21:37:36 +0300100 u64 id;
mcaleavya3c446c72016-04-29 13:38:51 +0100101 u64 ts;
takumakumef8990372019-01-02 17:12:14 +0900102 u32 uid;
mcaleavya3c446c72016-04-29 13:38:51 +0100103 int ret;
104 char comm[TASK_COMM_LEN];
105 char fname[NAME_MAX];
Tim Douglasd3583a82018-12-30 13:18:54 -0500106 int flags; // EXTENDED_STRUCT_MEMBER
mcaleavya3c446c72016-04-29 13:38:51 +0100107};
Brendan Greggbedd1502015-09-17 21:52:52 -0700108
mcaleavya3c446c72016-04-29 13:38:51 +0100109BPF_PERF_OUTPUT(events);
Jiri Olsac347fe62019-12-22 15:52:39 +0100110"""
111
112bpf_text_kprobe = """
113BPF_HASH(infotmp, u64, struct val_t);
Brendan Greggbedd1502015-09-17 21:52:52 -0700114
mcaleavya3c446c72016-04-29 13:38:51 +0100115int trace_return(struct pt_regs *ctx)
Brendan Greggbedd1502015-09-17 21:52:52 -0700116{
Dina Goldshtein99a3bc82016-10-10 21:37:36 +0300117 u64 id = bpf_get_current_pid_tgid();
mcaleavya3c446c72016-04-29 13:38:51 +0100118 struct val_t *valp;
119 struct data_t data = {};
Brendan Greggbedd1502015-09-17 21:52:52 -0700120
mcaleavya3c446c72016-04-29 13:38:51 +0100121 u64 tsp = bpf_ktime_get_ns();
122
Dina Goldshtein99a3bc82016-10-10 21:37:36 +0300123 valp = infotmp.lookup(&id);
mcaleavya3c446c72016-04-29 13:38:51 +0100124 if (valp == 0) {
Alexei Starovoitovbdf07732016-01-14 10:09:20 -0800125 // missed entry
126 return 0;
127 }
Sumanth Korikkar7f6066d2020-05-20 10:49:56 -0500128 bpf_probe_read_kernel(&data.comm, sizeof(data.comm), valp->comm);
Sumanth Korikkar023154c2020-04-20 05:54:57 -0500129 bpf_probe_read_user(&data.fname, sizeof(data.fname), (void *)valp->fname);
Dina Goldshtein99a3bc82016-10-10 21:37:36 +0300130 data.id = valp->id;
mcaleavya3c446c72016-04-29 13:38:51 +0100131 data.ts = tsp / 1000;
takumakumef8990372019-01-02 17:12:14 +0900132 data.uid = bpf_get_current_uid_gid();
Tim Douglasd3583a82018-12-30 13:18:54 -0500133 data.flags = valp->flags; // EXTENDED_STRUCT_MEMBER
Naveen N. Rao4afa96a2016-05-03 14:54:21 +0530134 data.ret = PT_REGS_RC(ctx);
Brendan Greggbedd1502015-09-17 21:52:52 -0700135
mcaleavya3c446c72016-04-29 13:38:51 +0100136 events.perf_submit(ctx, &data, sizeof(data));
Dina Goldshtein99a3bc82016-10-10 21:37:36 +0300137 infotmp.delete(&id);
Brendan Greggbedd1502015-09-17 21:52:52 -0700138
Alexei Starovoitovbdf07732016-01-14 10:09:20 -0800139 return 0;
Brendan Greggbedd1502015-09-17 21:52:52 -0700140}
141"""
Jiri Olsac347fe62019-12-22 15:52:39 +0100142
He Zhe6889afe2020-07-20 18:31:56 +0800143bpf_text_kprobe_header_open = """
144int syscall__trace_entry_open(struct pt_regs *ctx, const char __user *filename, int flags)
Jiri Olsac347fe62019-12-22 15:52:39 +0100145{
He Zhe6889afe2020-07-20 18:31:56 +0800146"""
147
148bpf_text_kprobe_header_openat = """
149int syscall__trace_entry_openat(struct pt_regs *ctx, int dfd, const char __user *filename, int flags)
150{
151"""
152
153bpf_text_kprobe_header_openat2 = """
154#include <uapi/linux/openat2.h>
155int syscall__trace_entry_openat2(struct pt_regs *ctx, int dfd, const char __user *filename, struct open_how *how)
156{
157 int flags = how->flags;
158"""
159
160bpf_text_kprobe_body = """
161 struct val_t val = {};
162 u64 id = bpf_get_current_pid_tgid();
163 u32 pid = id >> 32; // PID is higher part
164 u32 tid = id; // Cast and get the lower part
165 u32 uid = bpf_get_current_uid_gid();
166
167 PID_TID_FILTER
168 UID_FILTER
169 FLAGS_FILTER
170
171 if (container_should_be_filtered()) {
172 return 0;
173 }
174
175 if (bpf_get_current_comm(&val.comm, sizeof(val.comm)) == 0) {
176 val.id = id;
177 val.fname = filename;
178 val.flags = flags; // EXTENDED_STRUCT_MEMBER
179 infotmp.update(&id, &val);
180 }
181
182 return 0;
183};
184"""
185
186bpf_text_kfunc_header_open = """
187#if defined(CONFIG_ARCH_HAS_SYSCALL_WRAPPER) && !defined(__s390x__)
188KRETFUNC_PROBE(FNNAME, struct pt_regs *regs, int ret)
189{
190 const char __user *filename = (char *)PT_REGS_PARM1(regs);
191 int flags = PT_REGS_PARM2(regs);
192#else
193KRETFUNC_PROBE(FNNAME, const char __user *filename, int flags, int ret)
194{
195#endif
196"""
197
198bpf_text_kfunc_header_openat = """
199#if defined(CONFIG_ARCH_HAS_SYSCALL_WRAPPER) && !defined(__s390x__)
200KRETFUNC_PROBE(FNNAME, struct pt_regs *regs, int ret)
201{
202 int dfd = PT_REGS_PARM1(regs);
203 const char __user *filename = (char *)PT_REGS_PARM2(regs);
204 int flags = PT_REGS_PARM3(regs);
205#else
206KRETFUNC_PROBE(FNNAME, int dfd, const char __user *filename, int flags, int ret)
207{
208#endif
209"""
210
211bpf_text_kfunc_header_openat2 = """
212#include <uapi/linux/openat2.h>
213#if defined(CONFIG_ARCH_HAS_SYSCALL_WRAPPER) && !defined(__s390x__)
214KRETFUNC_PROBE(FNNAME, struct pt_regs *regs, int ret)
215{
216 int dfd = PT_REGS_PARM1(regs);
217 const char __user *filename = (char *)PT_REGS_PARM2(regs);
218 struct open_how __user *how = (struct open_how *)PT_REGS_PARM3(regs);
219 int flags = how->flags;
220#else
221KRETFUNC_PROBE(FNNAME, int dfd, const char __user *filename, struct open_how __user *how, int ret)
222{
223 int flags = how->flags;
224#endif
225"""
226
227bpf_text_kfunc_body = """
Jiri Olsac347fe62019-12-22 15:52:39 +0100228 u64 id = bpf_get_current_pid_tgid();
229 u32 pid = id >> 32; // PID is higher part
230 u32 tid = id; // Cast and get the lower part
231 u32 uid = bpf_get_current_uid_gid();
232
233 PID_TID_FILTER
234 UID_FILTER
235 FLAGS_FILTER
Alban Crequy32ab8582020-03-22 16:06:44 +0100236 if (container_should_be_filtered()) {
237 return 0;
Alban Crequy510fc742020-03-19 14:07:38 +0100238 }
Jiri Olsac347fe62019-12-22 15:52:39 +0100239
240 struct data_t data = {};
241 bpf_get_current_comm(&data.comm, sizeof(data.comm));
242
243 u64 tsp = bpf_ktime_get_ns();
244
Sumanth Korikkar023154c2020-04-20 05:54:57 -0500245 bpf_probe_read_user(&data.fname, sizeof(data.fname), (void *)filename);
Jiri Olsac347fe62019-12-22 15:52:39 +0100246 data.id = id;
247 data.ts = tsp / 1000;
248 data.uid = bpf_get_current_uid_gid();
249 data.flags = flags; // EXTENDED_STRUCT_MEMBER
250 data.ret = ret;
251
252 events.perf_submit(ctx, &data, sizeof(data));
Mauricio Vásquez44e0f432020-05-21 11:50:52 -0500253
Mauricio Vásquez8cd27172020-06-08 08:12:08 -0500254 return 0;
Jiri Olsac347fe62019-12-22 15:52:39 +0100255}
256"""
257
He Zhe6889afe2020-07-20 18:31:56 +0800258b = BPF(text='')
259# open and openat are always in place since 2.6.16
260fnname_open = b.get_syscall_prefix().decode() + 'open'
261fnname_openat = b.get_syscall_prefix().decode() + 'openat'
262fnname_openat2 = b.get_syscall_prefix().decode() + 'openat2'
263if b.ksymname(fnname_openat2) == -1:
264 fnname_openat2 = None
265
Jiri Olsac347fe62019-12-22 15:52:39 +0100266is_support_kfunc = BPF.support_kfunc()
267if is_support_kfunc:
He Zhe6889afe2020-07-20 18:31:56 +0800268 bpf_text += bpf_text_kfunc_header_open.replace('FNNAME', fnname_open)
269 bpf_text += bpf_text_kfunc_body
270
271 bpf_text += bpf_text_kfunc_header_openat.replace('FNNAME', fnname_openat)
272 bpf_text += bpf_text_kfunc_body
273
274 if fnname_openat2:
275 bpf_text += bpf_text_kfunc_header_openat2.replace('FNNAME', fnname_openat2)
276 bpf_text += bpf_text_kfunc_body
Jiri Olsac347fe62019-12-22 15:52:39 +0100277else:
278 bpf_text += bpf_text_kprobe
279
He Zhe6889afe2020-07-20 18:31:56 +0800280 bpf_text += bpf_text_kprobe_header_open
281 bpf_text += bpf_text_kprobe_body
282
283 bpf_text += bpf_text_kprobe_header_openat
284 bpf_text += bpf_text_kprobe_body
285
286 if fnname_openat2:
287 bpf_text += bpf_text_kprobe_header_openat2
288 bpf_text += bpf_text_kprobe_body
289
Dina Goldshtein99a3bc82016-10-10 21:37:36 +0300290if args.tid: # TID trumps PID
Tim Douglasd3583a82018-12-30 13:18:54 -0500291 bpf_text = bpf_text.replace('PID_TID_FILTER',
Dina Goldshtein99a3bc82016-10-10 21:37:36 +0300292 'if (tid != %s) { return 0; }' % args.tid)
293elif args.pid:
Tim Douglasd3583a82018-12-30 13:18:54 -0500294 bpf_text = bpf_text.replace('PID_TID_FILTER',
Alexei Starovoitovbdf07732016-01-14 10:09:20 -0800295 'if (pid != %s) { return 0; }' % args.pid)
Brendan Greggbedd1502015-09-17 21:52:52 -0700296else:
Tim Douglasd3583a82018-12-30 13:18:54 -0500297 bpf_text = bpf_text.replace('PID_TID_FILTER', '')
takumakumef8990372019-01-02 17:12:14 +0900298if args.uid:
299 bpf_text = bpf_text.replace('UID_FILTER',
300 'if (uid != %s) { return 0; }' % args.uid)
301else:
302 bpf_text = bpf_text.replace('UID_FILTER', '')
Alban Crequy32ab8582020-03-22 16:06:44 +0100303bpf_text = filter_by_containers(args) + bpf_text
Tim Douglasd3583a82018-12-30 13:18:54 -0500304if args.flag_filter:
305 bpf_text = bpf_text.replace('FLAGS_FILTER',
306 'if (!(flags & %d)) { return 0; }' % flag_filter_mask)
307else:
308 bpf_text = bpf_text.replace('FLAGS_FILTER', '')
309if not (args.extended_fields or args.flag_filter):
310 bpf_text = '\n'.join(x for x in bpf_text.split('\n')
311 if 'EXTENDED_STRUCT_MEMBER' not in x)
Nathan Scottcf0792f2018-02-02 16:56:50 +1100312if debug or args.ebpf:
Alexei Starovoitovbdf07732016-01-14 10:09:20 -0800313 print(bpf_text)
Nathan Scottcf0792f2018-02-02 16:56:50 +1100314 if args.ebpf:
315 exit()
Brendan Greggbedd1502015-09-17 21:52:52 -0700316
317# initialize BPF
318b = BPF(text=bpf_text)
Jiri Olsac347fe62019-12-22 15:52:39 +0100319if not is_support_kfunc:
He Zhe6889afe2020-07-20 18:31:56 +0800320 b.attach_kprobe(event=fnname_open, fn_name="syscall__trace_entry_open")
321 b.attach_kretprobe(event=fnname_open, fn_name="trace_return")
322
323 b.attach_kprobe(event=fnname_openat, fn_name="syscall__trace_entry_openat")
324 b.attach_kretprobe(event=fnname_openat, fn_name="trace_return")
325
326 if fnname_openat2:
327 b.attach_kprobe(event=fnname_openat2, fn_name="syscall__trace_entry_openat2")
328 b.attach_kretprobe(event=fnname_openat2, fn_name="trace_return")
mcaleavya3c446c72016-04-29 13:38:51 +0100329
KarimAllah Ahmeda17d1e82016-09-10 12:00:32 +0200330initial_ts = 0
Brendan Greggbedd1502015-09-17 21:52:52 -0700331
332# header
333if args.timestamp:
Alexei Starovoitovbdf07732016-01-14 10:09:20 -0800334 print("%-14s" % ("TIME(s)"), end="")
takumakumef8990372019-01-02 17:12:14 +0900335if args.print_uid:
336 print("%-6s" % ("UID"), end="")
Tim Douglasd3583a82018-12-30 13:18:54 -0500337print("%-6s %-16s %4s %3s " %
338 ("TID" if args.tid else "PID", "COMM", "FD", "ERR"), end="")
339if args.extended_fields:
340 print("%-9s" % ("FLAGS"), end="")
341print("PATH")
Brendan Greggbedd1502015-09-17 21:52:52 -0700342
mcaleavya3c446c72016-04-29 13:38:51 +0100343# process event
344def print_event(cpu, data, size):
Xiaozhou Liu51d62d32019-02-15 13:03:05 +0800345 event = b["events"].event(data)
KarimAllah Ahmeda17d1e82016-09-10 12:00:32 +0200346 global initial_ts
Brendan Greggbedd1502015-09-17 21:52:52 -0700347
Alexei Starovoitovbdf07732016-01-14 10:09:20 -0800348 # split return value into FD and errno columns
mcaleavya3c446c72016-04-29 13:38:51 +0100349 if event.ret >= 0:
350 fd_s = event.ret
Alexei Starovoitovbdf07732016-01-14 10:09:20 -0800351 err = 0
352 else:
mcaleavya3c446c72016-04-29 13:38:51 +0100353 fd_s = -1
354 err = - event.ret
Brendan Greggbedd1502015-09-17 21:52:52 -0700355
KarimAllah Ahmeda17d1e82016-09-10 12:00:32 +0200356 if not initial_ts:
357 initial_ts = event.ts
mcaleavya3c446c72016-04-29 13:38:51 +0100358
KarimAllah Ahmeda17d1e82016-09-10 12:00:32 +0200359 if args.failed and (event.ret >= 0):
mcaleavya3c446c72016-04-29 13:38:51 +0100360 return
361
Gary Lin40fd6692018-02-12 16:51:14 +0800362 if args.name and bytes(args.name) not in event.comm:
KarimAllah Ahmed765dfe22016-09-10 12:01:07 +0200363 return
364
Alexei Starovoitovbdf07732016-01-14 10:09:20 -0800365 if args.timestamp:
KarimAllah Ahmeda17d1e82016-09-10 12:00:32 +0200366 delta = event.ts - initial_ts
Gary Lin6c793312019-04-18 15:17:56 +0800367 printb(b"%-14.9f" % (float(delta) / 1000000), nl="")
mcaleavya3c446c72016-04-29 13:38:51 +0100368
takumakumef8990372019-01-02 17:12:14 +0900369 if args.print_uid:
Gary Lin6c793312019-04-18 15:17:56 +0800370 printb(b"%-6d" % event.uid, nl="")
takumakumef8990372019-01-02 17:12:14 +0900371
Gary Lin6c793312019-04-18 15:17:56 +0800372 printb(b"%-6d %-16s %4d %3d " %
373 (event.id & 0xffffffff if args.tid else event.id >> 32,
374 event.comm, fd_s, err), nl="")
Tim Douglasd3583a82018-12-30 13:18:54 -0500375
376 if args.extended_fields:
Gary Lin6c793312019-04-18 15:17:56 +0800377 printb(b"%08o " % event.flags, nl="")
Tim Douglasd3583a82018-12-30 13:18:54 -0500378
Yonghong Songebe19512019-01-10 14:54:16 -0800379 printb(b'%s' % event.fname)
mcaleavya3c446c72016-04-29 13:38:51 +0100380
381# loop with callback to print_event
Mark Drayton5f5687e2017-02-20 18:13:03 +0000382b["events"].open_perf_buffer(print_event, page_cnt=64)
Paul Chaignon702de382018-01-28 13:41:35 +0100383start_time = datetime.now()
384while not args.duration or datetime.now() - start_time < args.duration:
Jerome Marchand51671272018-12-19 01:57:24 +0100385 try:
386 b.perf_buffer_poll()
387 except KeyboardInterrupt:
388 exit()