From 9b6a0e357c30b52e115f803bb6babb3ffc4fdabf Mon Sep 17 00:00:00 2001 From: Rohan Garg Date: Tue, 18 Feb 2020 11:16:50 -0800 Subject: [PATCH 001/278] tools/stackcount: Fix address resolution for user-space stack This patch fixes issue #2748. The bug was that address-to-symbol resolution didn't work for user-space stacks without the `-P` (per-pid) flag when tracing single, isolated processes. The current documentation of the `-P` option indicates that it's used to "display stacks separately for each process", and this doesn't match with the intended usage. This patch has two parts: - Fix `tools/stackcount.py` to explicitly set perpid to True if `-p ` is used - Remove the `-P` option from the example of tracing single, isolated process in `tools/stackcount_example.txt`, since the usage of the option can be confusing (and unnecessary after the current change) --- tools/stackcount.py | 6 ++++++ tools/stackcount_example.txt | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/tools/stackcount.py b/tools/stackcount.py index a58f9e316..2afb91ff8 100755 --- a/tools/stackcount.py +++ b/tools/stackcount.py @@ -275,6 +275,12 @@ def __init__(self): self.kernel_stack = self.args.kernel_stacks_only self.user_stack = self.args.user_stacks_only + # For tracing single processes in isolation, explicitly set perpid + # to True, if not already set. This is required to generate the correct + # BPF program that can store pid in the tgid field of the key_t object. + if self.args.pid is not None and self.args.pid > 0: + self.args.perpid = True + self.probe = Probe(self.args.pattern, self.kernel_stack, self.user_stack, self.args.regexp, self.args.pid, self.args.perpid, self.args.cpu) diff --git a/tools/stackcount_example.txt b/tools/stackcount_example.txt index 26233d798..805aff36f 100644 --- a/tools/stackcount_example.txt +++ b/tools/stackcount_example.txt @@ -487,7 +487,7 @@ User-space functions can also be traced if a library name is provided. For example, to quickly identify code locations that allocate heap memory for PID 4902 (using -p), by tracing malloc from libc ("c:malloc"): -# ./stackcount -P -p 4902 c:malloc +# ./stackcount -p 4902 c:malloc Tracing 1 functions for "malloc"... Hit Ctrl-C to end. ^C malloc From 1332e68676fe0f1365dccd5ebffc05259b67abc1 Mon Sep 17 00:00:00 2001 From: jnach <33467747+jnach@users.noreply.github.com> Date: Tue, 18 Feb 2020 16:23:18 -0500 Subject: [PATCH 002/278] Update dddos.py Fix a few more typos --- examples/tracing/dddos.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/tracing/dddos.py b/examples/tracing/dddos.py index fe1afd726..09e9f6d86 100755 --- a/examples/tracing/dddos.py +++ b/examples/tracing/dddos.py @@ -53,7 +53,7 @@ * test a real case attack using hping3. However; if regular network * traffic increases above predefined detection settings, a false * positive alert will be triggered (an example would be the - case of large file downloads). + * case of large file downloads). */ rcv_packets_nb_ptr = rcv_packets.lookup(&rcv_packets_nb_index); rcv_packets_ts_ptr = rcv_packets.lookup(&rcv_packets_ts_index); @@ -86,7 +86,7 @@ class DetectionTimestamp(ct.Structure): _fields_ = [("nb_ddos_packets", ct.c_ulonglong)] -# Show message when ePBF stats +# Show message when ePBF starts print("DDOS detector started ... Hit Ctrl-C to end!") print("%-26s %-10s" % ("TIME(s)", "MESSAGE")) From 8dd4b5a521602d86a9331b5c6c6bdd53a8b4ed72 Mon Sep 17 00:00:00 2001 From: Pavel Dubovitsky <57279150+pdubovitsky@users.noreply.github.com> Date: Tue, 18 Feb 2020 19:49:11 -0800 Subject: [PATCH 003/278] bindsnoop BCC tool (#2749) bindsnoop BCC utility bindsnoop tool traces the kernel function performing socket binding and print socket options set before the system call invocation that might impact bind behavior and bound interface --- README.md | 1 + man/man8/bindsnoop.8 | 144 +++++++++ tests/python/test_tools_smoke.py | 4 + tools/bindsnoop.py | 515 +++++++++++++++++++++++++++++++ tools/bindsnoop_example.txt | 115 +++++++ 5 files changed, 779 insertions(+) create mode 100644 man/man8/bindsnoop.8 create mode 100755 tools/bindsnoop.py create mode 100644 tools/bindsnoop_example.txt diff --git a/README.md b/README.md index bc3639ca2..6553db792 100644 --- a/README.md +++ b/README.md @@ -85,6 +85,7 @@ pair of .c and .py files, and some are directories of files. - tools/[argdist](tools/argdist.py): Display function parameter values as a histogram or frequency count. [Examples](tools/argdist_example.txt). - tools/[bashreadline](tools/bashreadline.py): Print entered bash commands system wide. [Examples](tools/bashreadline_example.txt). +- tools/[bindsnoop](tools/bindsnoop.py): Trace IPv4 and IPv6 bind() system calls (bind()). [Examples](tools/bindsnoop_example.txt). - tools/[biolatency](tools/biolatency.py): Summarize block device I/O latency as a histogram. [Examples](tools/biolatency_example.txt). - tools/[biotop](tools/biotop.py): Top for disks: Summarize block device I/O by process. [Examples](tools/biotop_example.txt). - tools/[biosnoop](tools/biosnoop.py): Trace block device I/O with PID and latency. [Examples](tools/biosnoop_example.txt). diff --git a/man/man8/bindsnoop.8 b/man/man8/bindsnoop.8 new file mode 100644 index 000000000..ec7ca1dae --- /dev/null +++ b/man/man8/bindsnoop.8 @@ -0,0 +1,144 @@ +.TH bindsnoop 8 "12 February 2020" "" "" +.SH NAME +bindsnoop \- Trace bind() system calls. +.SH SYNOPSIS +.B bindsnoop.py [\fB-h\fP] [\fB-w\fP] [\fB-t\fP] [\fB-p\fP PID] [\fB-P\fP PORT] [\fB-E\fP] [\fB-U\fP] [\fB-u\fP UID] [\fB--count\fP] [\fB--cgroupmap MAP\fP] +.SH DESCRIPTION +bindsnoop reports socket options set before the bind call that would impact this system call behavior. +.PP +.SH REQUIREMENTS +CONFIG_BPF and bcc. +.SH +OPTIONS: +.RS +.TP +Show help message and exit: +.TP +.B +\fB-h\fP, \fB--help\fP +.TP +Include timestamp on output: +.TP +.B +\fB-t\fP, \fB--timestamp\fP +.TP +Wider columns (fit IPv6): +.TP +.B +\fB-w\fP, \fB--wide\fP +.TP +Trace this PID only: +.TP +.B +\fB-p\fP PID, \fB--pid\fP PID +.TP +Comma-separated list of ports to trace: +.TP +.B +\fB-P\fP PORT, \fB--port\fP PORT +.TP +Trace cgroups in this BPF map: +.TP +.B +\fB--cgroupmap\fP MAP +.TP +Include errors in the output: +.TP +.B +\fB-E\fP, \fB--errors\fP +.TP +Include UID on output: +.TP +.B +\fB-U\fP, \fB--print-uid\fP +.TP +Trace this UID only: +.TP +.B +\fB-u\fP UID, \fB--uid\fP UID +.TP +Count binds per src ip and port: +.TP +.B +\fB--count\fP +.RE +.PP +.SH +EXAMPLES: +.RS +.TP +Trace all IPv4 and IPv6 \fBbind\fP()s +.TP +.B +bindsnoop +.TP +Include timestamps +.TP +.B +bindsnoop \fB-t\fP +.TP +Trace PID 181 +.TP +.B +bindsnoop \fB-p\fP 181 +.TP +Trace port 80 +.TP +.B +bindsnoop \fB-P\fP 80 +.TP +Trace port 80 and 81 +.TP +.B +bindsnoop \fB-P\fP 80,81 +.TP +Include UID +.TP +.B +bindsnoop \fB-U\fP +.TP +Trace UID 1000 +.TP +.B +bindsnoop \fB-u\fP 1000 +.TP +Report bind errors +.TP +.B +bindsnoop \fB-E\fP +.TP +Count bind per src ip +.TP +.B +bindsnoop \fB--count\fP +.RE +.PP +Trace IPv4 and IPv6 bind system calls and report socket options that would impact bind call behavior: +.RS +.TP +SOL_IP IP_FREEBIND F\.\.\.\. +.TP +SOL_IP IP_TRANSPARENT \.T\.\.\. +.TP +SOL_IP IP_BIND_ADDRESS_NO_PORT \.\.N\.\. +.TP +SOL_SOCKET SO_REUSEADDR \.\.\.R. +.TP +SOL_SOCKET SO_REUSEPORT \.\.\.\.r +.PP +SO_BINDTODEVICE interface is reported as "IF" index +.SH SOURCE +This is from bcc. +.IP +https://github.com/iovisor/bcc +.PP +Also look in the bcc distribution for a companion _examples.txt file containing +example usage, output, and commentary for this tool. +.SH OS +Linux +.SH STABILITY +Unstable - in development. +.SH AUTHOR +Pavel Dubovitsky +.SH SEE ALSO +tcpaccept(8) diff --git a/tests/python/test_tools_smoke.py b/tests/python/test_tools_smoke.py index 66fb666bf..9222e3766 100755 --- a/tests/python/test_tools_smoke.py +++ b/tests/python/test_tools_smoke.py @@ -74,6 +74,10 @@ def test_argdist(self): def test_bashreadline(self): self.run_with_int("bashreadline.py") + @skipUnless(kernel_version_ge(4,4), "requires kernel >= 4.4") + def test_bindsnoop(self): + self.run_with_int("bindsnoop.py") + def test_biolatency(self): self.run_with_duration("biolatency.py 1 1") diff --git a/tools/bindsnoop.py b/tools/bindsnoop.py new file mode 100755 index 000000000..4d3133fcf --- /dev/null +++ b/tools/bindsnoop.py @@ -0,0 +1,515 @@ +#!/usr/bin/python +# +# bindsnoop Trace IPv4 and IPv6 binds()s. +# For Linux, uses BCC, eBPF. Embedded C. +# +# based on tcpconnect utility from Brendan Gregg's suite. +# +# USAGE: bindsnoop [-h] [-t] [-E] [-p PID] [-P PORT[,PORT ...]] [-w] +# [--count] [--cgroupmap mappath] +# +# bindsnoop reports socket options set before the bind call +# that would impact this system call behavior: +# SOL_IP IP_FREEBIND F.... +# SOL_IP IP_TRANSPARENT .T... +# SOL_IP IP_BIND_ADDRESS_NO_PORT ..N.. +# SOL_SOCKET SO_REUSEADDR ...R. +# SOL_SOCKET SO_REUSEPORT ....r +# +# SO_BINDTODEVICE interface is reported as "BOUND_IF" index +# +# This uses dynamic tracing of kernel functions, and will need to be updated +# to match kernel changes. +# +# Copyright (c) 2020-present Facebook. +# Licensed under the Apache License, Version 2.0 (the "License") +# +# 14-Feb-2020 Pavel Dubovitsky Created this. + +from __future__ import print_function, absolute_import, unicode_literals +from bcc import BPF, DEBUG_SOURCE +from bcc.utils import printb +import argparse +import re +from os import strerror +from socket import ( + inet_ntop, AF_INET, AF_INET6, __all__ as socket_all, __dict__ as socket_dct +) +from struct import pack +from time import sleep + +# arguments +examples = """examples: + ./bindsnoop # trace all TCP bind()s + ./bindsnoop -t # include timestamps + ./tcplife -w # wider columns (fit IPv6) + ./bindsnoop -p 181 # only trace PID 181 + ./bindsnoop -P 80 # only trace port 80 + ./bindsnoop -P 80,81 # only trace port 80 and 81 + ./bindsnoop -U # include UID + ./bindsnoop -u 1000 # only trace UID 1000 + ./bindsnoop -E # report bind errors + ./bindsnoop --count # count bind per src ip + ./bindsnoop --cgroupmap mappath # only trace cgroups in this BPF map + +it is reporting socket options set before the bins call +impacting system call behavior: + SOL_IP IP_FREEBIND F.... + SOL_IP IP_TRANSPARENT .T... + SOL_IP IP_BIND_ADDRESS_NO_PORT ..N.. + SOL_SOCKET SO_REUSEADDR ...R. + SOL_SOCKET SO_REUSEPORT ....r + + SO_BINDTODEVICE interface is reported as "IF" index +""" +parser = argparse.ArgumentParser( + description="Trace TCP binds", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=examples) +parser.add_argument("-t", "--timestamp", action="store_true", + help="include timestamp on output") +parser.add_argument("-w", "--wide", action="store_true", + help="wide column output (fits IPv6 addresses)") +parser.add_argument("-p", "--pid", + help="trace this PID only") +parser.add_argument("-P", "--port", + help="comma-separated list of ports to trace.") +parser.add_argument("-E", "--errors", action="store_true", + help="include errors in the output.") +parser.add_argument("-U", "--print-uid", action="store_true", + help="include UID on output") +parser.add_argument("-u", "--uid", + help="trace this UID only") +parser.add_argument("--count", action="store_true", + help="count binds per src ip and port") +parser.add_argument("--cgroupmap", + help="trace cgroups in this BPF map only") +parser.add_argument("--ebpf", action="store_true", + help=argparse.SUPPRESS) +parser.add_argument("--debug-source", action="store_true", + help=argparse.SUPPRESS) +args = parser.parse_args() + +# define BPF program +bpf_text = """ +#include +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#include +#pragma clang diagnostic pop +#include +#include +#include + +BPF_HASH(currsock, u32, struct socket *); + +// separate data structs for ipv4 and ipv6 +struct ipv4_bind_data_t { + u64 ts_us; + u32 pid; + u32 uid; + u64 ip; + u32 saddr; + u32 bound_dev_if; + int return_code; + u16 sport; + u8 socket_options; + u8 protocol; + char task[TASK_COMM_LEN]; +}; +BPF_PERF_OUTPUT(ipv4_bind_events); + +struct ipv6_bind_data_t { + // int128 would be aligned on 16 bytes boundary, better to go first + unsigned __int128 saddr; + u64 ts_us; + u32 pid; + u32 uid; + u64 ip; + u32 bound_dev_if; + int return_code; + u16 sport; + u8 socket_options; + u8 protocol; + char task[TASK_COMM_LEN]; +}; +BPF_PERF_OUTPUT(ipv6_bind_events); + +// separate flow keys per address family +struct ipv4_flow_key_t { + u32 saddr; + u16 sport; +}; +BPF_HASH(ipv4_count, struct ipv4_flow_key_t); + +struct ipv6_flow_key_t { + unsigned __int128 saddr; + u16 sport; +}; +BPF_HASH(ipv6_count, struct ipv6_flow_key_t); + +CGROUP_MAP + +// bind options for event reporting +union bind_options { + u8 data; + struct { + u8 freebind:1; + u8 transparent:1; + u8 bind_address_no_port:1; + u8 reuseaddress:1; + u8 reuseport:1; + } fields; +}; + +// TODO: add reporting for the original bind arguments +int bindsnoop_entry(struct pt_regs *ctx, struct socket *socket) +{ + u64 pid_tgid = bpf_get_current_pid_tgid(); + u32 pid = pid_tgid >> 32; + u32 tid = pid_tgid; + FILTER_PID + + u32 uid = bpf_get_current_uid_gid(); + + FILTER_UID + + FILTER_CGROUP + + // stash the sock ptr for lookup on return + currsock.update(&tid, &socket); + + return 0; +}; + + +static int bindsnoop_return(struct pt_regs *ctx, short ipver) +{ + int ret = PT_REGS_RC(ctx); + u64 pid_tgid = bpf_get_current_pid_tgid(); + u32 pid = pid_tgid >> 32; + u32 tid = pid_tgid; + + struct socket **skpp; + skpp = currsock.lookup(&tid); + if (skpp == 0) { + return 0; // missed entry + } + + int ignore_errors = 1; + FILTER_ERRORS + if (ret != 0 && ignore_errors) { + // failed to bind + currsock.delete(&tid); + return 0; + } + + // pull in details + struct socket *skp_ = *skpp; + struct sock *skp = skp_->sk; + + struct inet_sock *sockp = (struct inet_sock *)skp; + + u16 sport = 0; + bpf_probe_read(&sport, sizeof(sport), &sockp->inet_sport); + sport = ntohs(sport); + + FILTER_PORT + + union bind_options opts = {0}; + u8 bitfield; + // fetching freebind, transparent, and bind_address_no_port bitfields + // via the next struct member, rcv_tos + bitfield = (u8) *(&sockp->rcv_tos - 2) & 0xFF; + // IP_FREEBIND (sockp->freebind) + opts.fields.freebind = bitfield >> 2 & 0x01; + // IP_TRANSPARENT (sockp->transparent) + opts.fields.transparent = bitfield >> 5 & 0x01; + // IP_BIND_ADDRESS_NO_PORT (sockp->bind_address_no_port) + opts.fields.bind_address_no_port = *(&sockp->rcv_tos - 1) & 0x01; + + // SO_REUSEADDR and SO_REUSEPORT are bitfields that + // cannot be accessed directly, fetched via the next struct member, + // __sk_common.skc_bound_dev_if + bitfield = *((u8*)&skp->__sk_common.skc_bound_dev_if - 1); + // SO_REUSEADDR (skp->reuse) + // it is 4 bit, but we are interested in the lowest one + opts.fields.reuseaddress = bitfield & 0x0F; + // SO_REUSEPORT (skp->reuseport) + opts.fields.reuseport = bitfield >> 4 & 0x01; + + // workaround for reading the sk_protocol bitfield (from tcpaccept.py): + u8 protocol; + int gso_max_segs_offset = offsetof(struct sock, sk_gso_max_segs); + int sk_lingertime_offset = offsetof(struct sock, sk_lingertime); + if (sk_lingertime_offset - gso_max_segs_offset == 4) + // 4.10+ with little endian +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + protocol = *(u8 *)((u64)&skp->sk_gso_max_segs - 3); + else + // pre-4.10 with little endian + protocol = *(u8 *)((u64)&skp->sk_wmem_queued - 3); +#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + // 4.10+ with big endian + protocol = *(u8 *)((u64)&skp->sk_gso_max_segs - 1); + else + // pre-4.10 with big endian + protocol = *(u8 *)((u64)&skp->sk_wmem_queued - 1); +#else +# error "Fix your compiler's __BYTE_ORDER__?!" +#endif + + if (ipver == 4) { + IPV4_CODE + } else /* 6 */ { + IPV6_CODE + } + + currsock.delete(&tid); + + return 0; +} + +int bindsnoop_v4_return(struct pt_regs *ctx) +{ + return bindsnoop_return(ctx, 4); +} + +int bindsnoop_v6_return(struct pt_regs *ctx) +{ + return bindsnoop_return(ctx, 6); +} +""" + +struct_init = { + 'ipv4': { + 'count': """ + struct ipv4_flow_key_t flow_key = {}; + flow_key.saddr = skp->__sk_common.skc_rcv_saddr; + flow_key.sport = sport; + ipv4_count.increment(flow_key);""", + 'trace': """ + struct ipv4_bind_data_t data4 = {.pid = pid, .ip = ipver}; + data4.uid = bpf_get_current_uid_gid(); + data4.ts_us = bpf_ktime_get_ns() / 1000; + bpf_probe_read( + &data4.saddr, sizeof(data4.saddr), &sockp->inet_saddr); + data4.return_code = ret; + data4.sport = sport; + data4.bound_dev_if = skp->__sk_common.skc_bound_dev_if; + data4.socket_options = opts.data; + data4.protocol = protocol; + bpf_get_current_comm(&data4.task, sizeof(data4.task)); + ipv4_bind_events.perf_submit(ctx, &data4, sizeof(data4));""" + }, + 'ipv6': { + 'count': """ + struct ipv6_flow_key_t flow_key = {}; + bpf_probe_read(&flow_key.saddr, sizeof(flow_key.saddr), + skp->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); + flow_key.sport = sport; + ipv6_count.increment(flow_key);""", + 'trace': """ + struct ipv6_bind_data_t data6 = {.pid = pid, .ip = ipver}; + data6.uid = bpf_get_current_uid_gid(); + data6.ts_us = bpf_ktime_get_ns() / 1000; + bpf_probe_read(&data6.saddr, sizeof(data6.saddr), + skp->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); + data6.return_code = ret; + data6.sport = sport; + data6.bound_dev_if = skp->__sk_common.skc_bound_dev_if; + data6.socket_options = opts.data; + data6.protocol = protocol; + bpf_get_current_comm(&data6.task, sizeof(data6.task)); + ipv6_bind_events.perf_submit(ctx, &data6, sizeof(data6));""" + }, + 'filter_cgroup': """ + u64 cgroupid = bpf_get_current_cgroup_id(); + if (cgroupset.lookup(&cgroupid) == NULL) { + return 0; + }""", +} + +# code substitutions +if args.count: + bpf_text = bpf_text.replace("IPV4_CODE", struct_init['ipv4']['count']) + bpf_text = bpf_text.replace("IPV6_CODE", struct_init['ipv6']['count']) +else: + bpf_text = bpf_text.replace("IPV4_CODE", struct_init['ipv4']['trace']) + bpf_text = bpf_text.replace("IPV6_CODE", struct_init['ipv6']['trace']) + +if args.pid: + bpf_text = bpf_text.replace('FILTER_PID', + 'if (pid != %s) { return 0; }' % args.pid) +if args.port: + sports = [int(sport) for sport in args.port.split(',')] + sports_if = ' && '.join(['sport != %d' % sport for sport in sports]) + bpf_text = bpf_text.replace('FILTER_PORT', + 'if (%s) { currsock.delete(&pid); return 0; }' % sports_if) +if args.uid: + bpf_text = bpf_text.replace('FILTER_UID', + 'if (uid != %s) { return 0; }' % args.uid) +if args.errors: + bpf_text = bpf_text.replace('FILTER_ERRORS', 'ignore_errors = 0;') +if args.cgroupmap: + bpf_text = bpf_text.replace('FILTER_CGROUP', struct_init['filter_cgroup']) + bpf_text = bpf_text.replace( + 'CGROUP_MAP', + ( + 'BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "%s");' % + args.cgroupmap + ) + ) + +bpf_text = bpf_text.replace('FILTER_PID', '') +bpf_text = bpf_text.replace('FILTER_PORT', '') +bpf_text = bpf_text.replace('FILTER_UID', '') +bpf_text = bpf_text.replace('FILTER_ERRORS', '') +bpf_text = bpf_text.replace('FILTER_CGROUP', '') +bpf_text = bpf_text.replace('CGROUP_MAP', '') + +# selecting output format - 80 characters or wide, fitting IPv6 addresses +header_fmt = "%8s %-12.12s %-4s %-15s %-5s %5s %2s" +output_fmt = b"%8d %-12.12s %-4.4s %-15.15s %5d %-5s %2d" +error_header_fmt = "%3s " +error_output_fmt = b"%3s " +error_value_fmt = str +if args.wide: + header_fmt = "%10s %-12.12s %-4s %-39s %-5s %5s %2s" + output_fmt = b"%10d %-12.12s %-4s %-39s %5d %-5s %2d" + error_header_fmt = "%-25s " + error_output_fmt = b"%-25s " + error_value_fmt = strerror + +if args.ebpf: + print(bpf_text) + exit() + +# L4 protocol resolver +class L4Proto: + def __init__(self): + self.num2str = {} + proto_re = re.compile("IPPROTO_(.*)") + for attr in socket_all: + proto_match = proto_re.match(attr) + if proto_match: + self.num2str[socket_dct[attr]] = proto_match.group(1) + + def proto2str(self, proto): + return self.num2str.get(proto, "UNKNOWN") + +l4 = L4Proto() + +# bind options: +# SOL_IP IP_FREEBIND F.... +# SOL_IP IP_TRANSPARENT .T... +# SOL_IP IP_BIND_ADDRESS_NO_PORT ..N.. +# SOL_SOCKET SO_REUSEADDR ...R. +# SOL_SOCKET SO_REUSEPORT ....r +def opts2str(bitfield): + str_options = "" + bit = 1 + for opt in "FTNRr": + str_options += opt if bitfield & bit else "." + bit *= 2 + return str_options.encode() + + +# process events +def print_ipv4_bind_event(cpu, data, size): + event = b["ipv4_bind_events"].event(data) + global start_ts + if args.timestamp: + if start_ts == 0: + start_ts = event.ts_us + printb(b"%-9.6f " % ((float(event.ts_us) - start_ts) / 1000000), nl="") + if args.print_uid: + printb(b"%6d " % event.uid, nl="") + if args.errors: + printb( + error_output_fmt % error_value_fmt(event.return_code).encode(), + nl="", + ) + printb(output_fmt % (event.pid, event.task, + l4.proto2str(event.protocol).encode(), + inet_ntop(AF_INET, pack("I", event.saddr)).encode(), + event.sport, opts2str(event.socket_options), event.bound_dev_if)) + + +def print_ipv6_bind_event(cpu, data, size): + event = b["ipv6_bind_events"].event(data) + global start_ts + if args.timestamp: + if start_ts == 0: + start_ts = event.ts_us + printb(b"%-9.6f " % ((float(event.ts_us) - start_ts) / 1000000), nl="") + if args.print_uid: + printb(b"%6d " % event.uid, nl="") + if args.errors: + printb( + error_output_fmt % error_value_fmt(event.return_code).encode(), + nl="", + ) + printb(output_fmt % (event.pid, event.task, + l4.proto2str(event.protocol).encode(), + inet_ntop(AF_INET6, event.saddr).encode(), + event.sport, opts2str(event.socket_options), event.bound_dev_if)) + + +def depict_cnt(counts_tab, l3prot='ipv4'): + for k, v in sorted( + counts_tab.items(), key=lambda counts: counts[1].value, reverse=True + ): + depict_key = "" + if l3prot == 'ipv4': + depict_key = "%-32s %20s" % ( + (inet_ntop(AF_INET, pack('I', k.saddr))), k.sport + ) + else: + depict_key = "%-32s %20s" % ( + (inet_ntop(AF_INET6, k.saddr)), k.sport + ) + print("%s %-10d" % (depict_key, v.value)) + + +# initialize BPF +b = BPF(text=bpf_text) +b.attach_kprobe(event="inet_bind", fn_name="bindsnoop_entry") +b.attach_kprobe(event="inet6_bind", fn_name="bindsnoop_entry") +b.attach_kretprobe(event="inet_bind", fn_name="bindsnoop_v4_return") +b.attach_kretprobe(event="inet6_bind", fn_name="bindsnoop_v6_return") + +print("Tracing binds ... Hit Ctrl-C to end") +if args.count: + try: + while 1: + sleep(99999999) + except KeyboardInterrupt: + pass + + # header + print("\n%-32s %20s %-10s" % ( + "LADDR", "LPORT", "BINDS")) + depict_cnt(b["ipv4_count"]) + depict_cnt(b["ipv6_count"], l3prot='ipv6') +# read events +else: + # header + if args.timestamp: + print("%-9s " % ("TIME(s)"), end="") + if args.print_uid: + print("%6s " % ("UID"), end="") + if args.errors: + print(error_header_fmt % ("RC"), end="") + print(header_fmt % ("PID", "COMM", "PROT", "ADDR", "PORT", "OPTS", "IF")) + + start_ts = 0 + + # read events + b["ipv4_bind_events"].open_perf_buffer(print_ipv4_bind_event) + b["ipv6_bind_events"].open_perf_buffer(print_ipv6_bind_event) + while 1: + try: + b.perf_buffer_poll() + except KeyboardInterrupt: + exit() diff --git a/tools/bindsnoop_example.txt b/tools/bindsnoop_example.txt new file mode 100644 index 000000000..77e040ed7 --- /dev/null +++ b/tools/bindsnoop_example.txt @@ -0,0 +1,115 @@ +Demonstrations of bindsnoop, the Linux eBPF/bcc version. + +This tool traces the kernel function performing socket binding and +print socket options set before the system call invocation that might +impact bind behavior and bound interface: +SOL_IP IP_FREEBIND F.... +SOL_IP IP_TRANSPARENT .T... +SOL_IP IP_BIND_ADDRESS_NO_PORT ..N.. +SOL_SOCKET SO_REUSEADDR ...R. +SOL_SOCKET SO_REUSEPORT ....r + + +# ./bindsnoop.py +Tracing binds ... Hit Ctrl-C to end +PID COMM PROT ADDR PORT OPTS IF +3941081 test_bind_op TCP 192.168.1.102 0 F.N.. 0 +3940194 dig TCP :: 62087 ..... 0 +3940219 dig UDP :: 48665 ..... 0 +3940893 Acceptor Thr TCP :: 35343 ...R. 0 + +The output shows four bind system calls: +two "test_bind_op" instances, one with IP_FREEBIND and IP_BIND_ADDRESS_NO_PORT +options, dig process called bind for TCP and UDP sockets, +and Acceptor called bind for TCP with SO_REUSEADDR option set. + + +The -t option prints a timestamp column + +# ./bindsnoop.py -t +TIME(s) PID COMM PROT ADDR PORT OPTS IF +0.000000 3956801 dig TCP :: 49611 ..... 0 +0.011045 3956822 dig UDP :: 56343 ..... 0 +2.310629 3956498 test_bind_op TCP 192.168.1.102 39609 F...r 0 + + +The -U option prints a UID column: + +# ./bindsnoop.py -U +Tracing binds ... Hit Ctrl-C to end + UID PID COMM PROT ADDR PORT OPTS IF +127072 3956498 test_bind_op TCP 192.168.1.102 44491 F...r 0 +127072 3960261 Acceptor Thr TCP :: 48869 ...R. 0 + 0 3960729 Acceptor Thr TCP :: 44637 ...R. 0 + 0 3959075 chef-client UDP :: 61722 ..... 0 + + +The -u option filtering UID: + +# ./bindsnoop.py -Uu 0 +Tracing binds ... Hit Ctrl-C to end + UID PID COMM PROT ADDR PORT OPTS IF + 0 3966330 Acceptor Thr TCP :: 39319 ...R. 0 + 0 3968044 python3.7 TCP ::1 59371 ..... 0 + 0 10224 fetch TCP 0.0.0.0 42091 ...R. 0 + + +The --cgroupmap option filters based on a cgroup set. +It is meant to be used with an externally created map. + +# ./bindsnoop.py --cgroupmap /sys/fs/bpf/test01 + +For more details, see docs/filtering_by_cgroups.md + + +In order to track heavy bind usage one can use --count option +# ./bindsnoop.py --count +Tracing binds ... Hit Ctrl-C to end +LADDR LPORT BINDS +0.0.0.0 6771 4 +0.0.0.0 4433 4 +127.0.0.1 33665 1 + + +Usage message: +# ./bindsnoop.py -h +usage: bindsnoop.py [-h] [-t] [-w] [-p PID] [-P PORT] [-E] [-U] [-u UID] + [--count] [--cgroupmap CGROUPMAP] + +Trace TCP binds + +optional arguments: + -h, --help show this help message and exit + -t, --timestamp include timestamp on output + -w, --wide wide column output (fits IPv6 addresses) + -p PID, --pid PID trace this PID only + -P PORT, --port PORT comma-separated list of ports to trace. + -E, --errors include errors in the output. + -U, --print-uid include UID on output + -u UID, --uid UID trace this UID only + --count count binds per src ip and port + --cgroupmap CGROUPMAP + trace cgroups in this BPF map only + +examples: + ./bindsnoop # trace all TCP bind()s + ./bindsnoop -t # include timestamps + ./bindsnoop -w # wider columns (fit IPv6) + ./bindsnoop -p 181 # only trace PID 181 + ./bindsnoop -P 80 # only trace port 80 + ./bindsnoop -P 80,81 # only trace port 80 and 81 + ./bindsnoop -U # include UID + ./bindsnoop -u 1000 # only trace UID 1000 + ./bindsnoop -E # report bind errors + ./bindsnoop --count # count bind per src ip + ./bindsnoop --cgroupmap mappath # only trace cgroups in this BPF map + + it is reporting socket options set before the bins call + impacting system call behavior: + SOL_IP IP_FREEBIND F.... + SOL_IP IP_TRANSPARENT .T... + SOL_IP IP_BIND_ADDRESS_NO_PORT ..N.. + SOL_SOCKET SO_REUSEADDR ...R. + SOL_SOCKET SO_REUSEPORT ....r + + SO_BINDTODEVICE interface is reported as "IF" index From 51be481a7957b8d84bd02487f66f819f79e94f4a Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Tue, 18 Feb 2020 20:11:05 -0800 Subject: [PATCH 004/278] sync to latest libbpf sync to latest libbpf (libbpf release v0.0.7) to prepare bcc release. Signed-off-by: Yonghong Song --- src/cc/libbpf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cc/libbpf b/src/cc/libbpf index e5dbc1a96..583bddce6 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit e5dbc1a96f138e7c47324a65269adff0ca0f4f6e +Subproject commit 583bddce6b93bafa31471212a9811fd7d38b5f9a From 29aa61985c98456177d52a5f00cba092b572e778 Mon Sep 17 00:00:00 2001 From: Gil Raphaelli Date: Wed, 19 Feb 2020 11:09:52 -0500 Subject: [PATCH 005/278] tools/profile: fix kernel delimiter when folding (#2758) retain delimiter with folding enabled --- tools/profile.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tools/profile.py b/tools/profile.py index b710b797a..11f3e98da 100755 --- a/tools/profile.py +++ b/tools/profile.py @@ -296,8 +296,6 @@ def aksym(addr): has_enomem = False counts = b.get_table("counts") stack_traces = b.get_table("stack_traces") -need_delimiter = args.delimited and not (args.kernel_stacks_only or - args.user_stacks_only) for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): # handle get_stackid errors if not args.user_stacks_only and stack_id_err(k.kernel_stack_id): @@ -334,7 +332,7 @@ def aksym(addr): else: line.extend([b.sym(addr, k.pid) for addr in reversed(user_stack)]) if not args.user_stacks_only: - line.extend(b["-"] if (need_delimiter and k.kernel_stack_id >= 0 and k.user_stack_id >= 0) else []) + line.extend([b"-"] if (need_delimiter and k.kernel_stack_id >= 0 and k.user_stack_id >= 0) else []) if stack_id_err(k.kernel_stack_id): line.append(b"[Missed Kernel Stack]") else: From b26b429cf38b0e1afe915ceee0a1f0172e803ea4 Mon Sep 17 00:00:00 2001 From: Alban Crequy Date: Wed, 19 Feb 2020 16:46:34 +0100 Subject: [PATCH 006/278] tools: fix confusion between execsnoop and opensnoop The execsnoop documentation mispelled 'execsnoop' as 'opensnoop'. Bug introduced by https://github.com/iovisor/bcc/pull/2651 --- tools/execsnoop.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/execsnoop.py b/tools/execsnoop.py index b8b269808..57dfab291 100755 --- a/tools/execsnoop.py +++ b/tools/execsnoop.py @@ -36,7 +36,7 @@ ./execsnoop -q # add "quotemarks" around arguments ./execsnoop -n main # only print command lines containing "main" ./execsnoop -l tpkg # only print command where arguments contains "tpkg" - ./opensnoop --cgroupmap ./mappath # only trace cgroups in this BPF map + ./execsnoop --cgroupmap ./mappath # only trace cgroups in this BPF map """ parser = argparse.ArgumentParser( description="Trace exec() syscalls", From 942227484d3207f6a42103674001ef01fb5335a0 Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Wed, 19 Feb 2020 20:29:52 -0800 Subject: [PATCH 007/278] debian changelog for v0.13.0 tag * Support for kernel up to 5.5 * bindsnoop tool to track tcp/udp bind information * added compile-once run-everywhere based libbpf-tools, currently only runqslower is implemented. * new map support: sockhash, sockmap, sk_storage, cgroup_storage * enable to run github actions on the diff * cgroupmap based cgroup filtering for opensnoop, execsnoop and bindsnoop. * lots of bug fixes. Signed-off-by: Yonghong Song --- debian/changelog | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/debian/changelog b/debian/changelog index 8728038f7..57464abe9 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,16 @@ +bcc (0.13.0-1) unstable; urgency=low + + * Support for kernel up to 5.5 + * bindsnoop tool to track tcp/udp bind information + * added compile-once run-everywhere based libbpf-tools, currently + only runqslower is implemented. + * new map support: sockhash, sockmap, sk_storage, cgroup_storage + * enable to run github actions on the diff + * cgroupmap based cgroup filtering for opensnoop, execsnoop and bindsnoop. + * lots of bug fixes. + + -- Yonghong Song Wed, 19 Feb 2020 17:00:00 +0000 + bcc (0.12.0-1) unstable; urgency=low * Support for kernel up to 5.4 From 1ce868fbb4b4cd45f9d3d043c6d697f45fc6268d Mon Sep 17 00:00:00 2001 From: Alban Crequy Date: Wed, 19 Feb 2020 17:07:41 +0100 Subject: [PATCH 008/278] tools: add option --cgroupmap to tcp tools List of tcp tools updated: tcpaccept, tcpconnect, tcptracer --- docs/filtering_by_cgroups.md | 3 +++ tools/tcpaccept.py | 20 ++++++++++++++++++ tools/tcpaccept_example.txt | 23 +++++++++++++++------ tools/tcpconnect.py | 19 +++++++++++++++++ tools/tcpconnect_example.txt | 17 ++++++++++++--- tools/tcptracer.py | 40 +++++++++++++++++++++++++++++++++++- tools/tcptracer_example.txt | 8 ++++++++ 7 files changed, 120 insertions(+), 10 deletions(-) diff --git a/docs/filtering_by_cgroups.md b/docs/filtering_by_cgroups.md index 1c711a240..f2f08926d 100644 --- a/docs/filtering_by_cgroups.md +++ b/docs/filtering_by_cgroups.md @@ -8,6 +8,9 @@ Examples of commands: ``` # ./opensnoop --cgroupmap /sys/fs/bpf/test01 # ./execsnoop --cgroupmap /sys/fs/bpf/test01 +# ./tcpconnect --cgroupmap /sys/fs/bpf/test01 +# ./tcpaccept --cgroupmap /sys/fs/bpf/test01 +# ./tcptracer --cgroupmap /sys/fs/bpf/test01 ``` The commands above will only display results from processes that belong to one diff --git a/tools/tcpaccept.py b/tools/tcpaccept.py index 7c1042084..03b05e0ab 100755 --- a/tools/tcpaccept.py +++ b/tools/tcpaccept.py @@ -29,6 +29,7 @@ ./tcpaccept -t # include timestamps ./tcpaccept -P 80,81 # only trace port 80 and 81 ./tcpaccept -p 181 # only trace PID 181 + ./tcpaccept --cgroupmap ./mappath # only trace cgroups in this BPF map """ parser = argparse.ArgumentParser( description="Trace TCP accepts", @@ -42,6 +43,8 @@ help="trace this PID only") parser.add_argument("-P", "--port", help="comma-separated list of local ports to trace") +parser.add_argument("--cgroupmap", + help="trace cgroups in this BPF map only") parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) args = parser.parse_args() @@ -77,6 +80,11 @@ char task[TASK_COMM_LEN]; }; BPF_PERF_OUTPUT(ipv6_events); + +#if CGROUPSET +BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); +#endif + """ # @@ -89,6 +97,13 @@ bpf_text_kprobe = """ int kretprobe__inet_csk_accept(struct pt_regs *ctx) { +#if CGROUPSET + u64 cgroupid = bpf_get_current_cgroup_id(); + if (cgroupset.lookup(&cgroupid) == NULL) { + return 0; + } +#endif + struct sock *newsk = (struct sock *)PT_REGS_RC(ctx); u32 pid = bpf_get_current_pid_tgid() >> 32; @@ -184,6 +199,11 @@ lports_if = ' && '.join(['lport != %d' % lport for lport in lports]) bpf_text = bpf_text.replace('##FILTER_PORT##', 'if (%s) { return 0; }' % lports_if) +if args.cgroupmap: + bpf_text = bpf_text.replace('CGROUPSET', '1') + bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) +else: + bpf_text = bpf_text.replace('CGROUPSET', '0') if debug or args.ebpf: print(bpf_text) if args.ebpf: diff --git a/tools/tcpaccept_example.txt b/tools/tcpaccept_example.txt index 2adee452e..5b6b1a6d8 100644 --- a/tools/tcpaccept_example.txt +++ b/tools/tcpaccept_example.txt @@ -33,22 +33,33 @@ TIME(s) PID COMM IP RADDR RPORT LADDR LPORT 1.984 907 sshd 4 127.0.0.1 51250 127.0.0.1 22 +The --cgroupmap option filters based on a cgroup set. It is meant to be used +with an externally created map. + +# ./tcpaccept --cgroupmap /sys/fs/bpf/test01 + +For more details, see docs/filtering_by_cgroups.md + + USAGE message: # ./tcpaccept -h -usage: tcpaccept [-h] [-T] [-t] [-p PID] [-P PORTS] +usage: tcpaccept.py [-h] [-T] [-t] [-p PID] [-P PORT] [--cgroupmap CGROUPMAP] Trace TCP accepts optional arguments: - -h, --help show this help message and exit - -T, --time include time column on output (HH:MM:SS) - -t, --timestamp include timestamp on output - -p PID, --pid PID trace this PID only - -P PORTS, --port PORTS comma-separated list of local ports to trace + -h, --help show this help message and exit + -T, --time include time column on output (HH:MM:SS) + -t, --timestamp include timestamp on output + -p PID, --pid PID trace this PID only + -P PORT, --port PORT comma-separated list of local ports to trace + --cgroupmap CGROUPMAP + trace cgroups in this BPF map only examples: ./tcpaccept # trace all TCP accept()s ./tcpaccept -t # include timestamps ./tcpaccept -P 80,81 # only trace port 80 and 81 ./tcpaccept -p 181 # only trace PID 181 + ./tcpaccept --cgroupmap ./mappath # only trace cgroups in this BPF map diff --git a/tools/tcpconnect.py b/tools/tcpconnect.py index eb12667eb..67f2cef19 100755 --- a/tools/tcpconnect.py +++ b/tools/tcpconnect.py @@ -37,6 +37,7 @@ ./tcpconnect -U # include UID ./tcpconnect -u 1000 # only trace UID 1000 ./tcpconnect -c # count connects per src ip and dest ip/port + ./tcpconnect --cgroupmap ./mappath # only trace cgroups in this BPF map """ parser = argparse.ArgumentParser( description="Trace TCP connects", @@ -54,6 +55,8 @@ help="trace this UID only") parser.add_argument("-c", "--count", action="store_true", help="count connects per src ip and dest ip/port") +parser.add_argument("--cgroupmap", + help="trace cgroups in this BPF map only") parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) args = parser.parse_args() @@ -67,6 +70,10 @@ BPF_HASH(currsock, u32, struct sock *); +#if CGROUPSET +BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); +#endif + // separate data structs for ipv4 and ipv6 struct ipv4_data_t { u64 ts_us; @@ -109,6 +116,13 @@ int trace_connect_entry(struct pt_regs *ctx, struct sock *sk) { +#if CGROUPSET + u64 cgroupid = bpf_get_current_cgroup_id(); + if (cgroupset.lookup(&cgroupid) == NULL) { + return 0; + } +#endif + u64 pid_tgid = bpf_get_current_pid_tgid(); u32 pid = pid_tgid >> 32; u32 tid = pid_tgid; @@ -234,6 +248,11 @@ if args.uid: bpf_text = bpf_text.replace('FILTER_UID', 'if (uid != %s) { return 0; }' % args.uid) +if args.cgroupmap: + bpf_text = bpf_text.replace('CGROUPSET', '1') + bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) +else: + bpf_text = bpf_text.replace('CGROUPSET', '0') bpf_text = bpf_text.replace('FILTER_PID', '') bpf_text = bpf_text.replace('FILTER_PORT', '') diff --git a/tools/tcpconnect_example.txt b/tools/tcpconnect_example.txt index e88701e02..cf9756272 100644 --- a/tools/tcpconnect_example.txt +++ b/tools/tcpconnect_example.txt @@ -68,10 +68,19 @@ LADDR RADDR RPORT CONNECTS [...] +The --cgroupmap option filters based on a cgroup set. It is meant to be used +with an externally created map. + +# ./tcpconnect --cgroupmap /sys/fs/bpf/test01 + +For more details, see docs/filtering_by_cgroups.md + + USAGE message: # ./tcpconnect -h -usage: tcpconnect [-h] [-c] [-t] [-p PID] [-P PORT] +usage: tcpconnect.py [-h] [-t] [-p PID] [-P PORT] [-U] [-u UID] [-c] + [--cgroupmap CGROUPMAP] Trace TCP connects @@ -79,11 +88,12 @@ optional arguments: -h, --help show this help message and exit -t, --timestamp include timestamp on output -p PID, --pid PID trace this PID only - -P PORT, --port PORT - comma-separated list of destination ports to trace. + -P PORT, --port PORT comma-separated list of destination ports to trace. -U, --print-uid include UID on output -u UID, --uid UID trace this UID only -c, --count count connects per src ip and dest ip/port + --cgroupmap CGROUPMAP + trace cgroups in this BPF map only examples: ./tcpconnect # trace all TCP connect()s @@ -94,3 +104,4 @@ examples: ./tcpconnect -U # include UID ./tcpconnect -u 1000 # only trace UID 1000 ./tcpconnect -c # count connects per src ip and dest ip/port + ./tcpconnect --cgroupmap ./mappath # only trace cgroups in this BPF map diff --git a/tools/tcptracer.py b/tools/tcptracer.py index e61fe9ba7..8e6e1ec2b 100755 --- a/tools/tcptracer.py +++ b/tools/tcptracer.py @@ -11,7 +11,7 @@ # The following code should be replaced, and simplified, when static TCP probes # exist. # -# Copyright 2017 Kinvolk GmbH +# Copyright 2017-2020 Kinvolk GmbH # # Licensed under the Apache License, Version 2.0 (the "License") from __future__ import print_function @@ -29,6 +29,8 @@ help="trace this PID only") parser.add_argument("-N", "--netns", default=0, type=int, help="trace this Network Namespace only") +parser.add_argument("--cgroupmap", + help="trace cgroups in this BPF map only") parser.add_argument("-v", "--verbose", action="store_true", help="include Network Namespace in the output") parser.add_argument("--ebpf", action="store_true", @@ -77,6 +79,10 @@ }; BPF_PERF_OUTPUT(tcp_ipv6_event); +#if CGROUPSET +BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); +#endif + // tcp_set_state doesn't run in the context of the process that initiated the // connection so we need to store a map TUPLE -> PID to send the right PID on // the event @@ -173,6 +179,13 @@ int trace_connect_v4_entry(struct pt_regs *ctx, struct sock *sk) { +#if CGROUPSET + u64 cgroupid = bpf_get_current_cgroup_id(); + if (cgroupset.lookup(&cgroupid) == NULL) { + return 0; + } +#endif + u64 pid = bpf_get_current_pid_tgid(); ##FILTER_PID## @@ -220,6 +233,12 @@ int trace_connect_v6_entry(struct pt_regs *ctx, struct sock *sk) { +#if CGROUPSET + u64 cgroupid = bpf_get_current_cgroup_id(); + if (cgroupset.lookup(&cgroupid) == NULL) { + return 0; + } +#endif u64 pid = bpf_get_current_pid_tgid(); ##FILTER_PID## @@ -352,6 +371,13 @@ int trace_close_entry(struct pt_regs *ctx, struct sock *skp) { +#if CGROUPSET + u64 cgroupid = bpf_get_current_cgroup_id(); + if (cgroupset.lookup(&cgroupid) == NULL) { + return 0; + } +#endif + u64 pid = bpf_get_current_pid_tgid(); ##FILTER_PID## @@ -413,6 +439,13 @@ int trace_accept_return(struct pt_regs *ctx) { +#if CGROUPSET + u64 cgroupid = bpf_get_current_cgroup_id(); + if (cgroupset.lookup(&cgroupid) == NULL) { + return 0; + } +#endif + struct sock *newsk = (struct sock *)PT_REGS_RC(ctx); u64 pid = bpf_get_current_pid_tgid(); @@ -581,6 +614,11 @@ def print_ipv6_event(cpu, data, size): bpf_text = bpf_text.replace('##FILTER_PID##', pid_filter) bpf_text = bpf_text.replace('##FILTER_NETNS##', netns_filter) +if args.cgroupmap: + bpf_text = bpf_text.replace('CGROUPSET', '1') + bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) +else: + bpf_text = bpf_text.replace('CGROUPSET', '0') if args.ebpf: print(bpf_text) diff --git a/tools/tcptracer_example.txt b/tools/tcptracer_example.txt index 2873d036a..b6e52589d 100644 --- a/tools/tcptracer_example.txt +++ b/tools/tcptracer_example.txt @@ -35,3 +35,11 @@ TIME(s) T PID COMM IP SADDR DADDR SPORT 3.546 C 748 curl 6 [::1] [::1] 42592 80 4.294 X 31002 telnet 4 192.168.1.2 192.168.1.1 42590 23 ``` + + +The --cgroupmap option filters based on a cgroup set. It is meant to be used +with an externally created map. + +# ./tcptracer --cgroupmap /sys/fs/bpf/test01 + +For more details, see docs/filtering_by_cgroups.md From 5e3f9e4915fab83effccf3d20d3fbee715d96f6c Mon Sep 17 00:00:00 2001 From: Alban Crequy Date: Thu, 20 Feb 2020 15:43:13 +0100 Subject: [PATCH 009/278] man pages: add documentation about --cgroupmap --- man/man8/execsnoop.8 | 11 +++++++++-- man/man8/opensnoop.8 | 12 ++++++++++-- man/man8/tcpaccept.8 | 13 ++++++++++--- man/man8/tcpconnect.8 | 13 ++++++++++--- man/man8/tcptracer.8 | 10 ++++++++-- 5 files changed, 47 insertions(+), 12 deletions(-) diff --git a/man/man8/execsnoop.8 b/man/man8/execsnoop.8 index 500a93218..aec2d70b7 100644 --- a/man/man8/execsnoop.8 +++ b/man/man8/execsnoop.8 @@ -1,9 +1,9 @@ -.TH execsnoop 8 "2016-02-07" "USER COMMANDS" +.TH execsnoop 8 "2020-02-20" "USER COMMANDS" .SH NAME execsnoop \- Trace new processes via exec() syscalls. Uses Linux eBPF/bcc. .SH SYNOPSIS .B execsnoop [\-h] [\-T] [\-t] [\-x] [\-q] [\-n NAME] [\-l LINE] -.B [\-\-max-args MAX_ARGS] +.B [\-\-max-args MAX_ARGS] [\-\-cgroupmap MAPPATH] .SH DESCRIPTION execsnoop traces new processes, showing the filename executed and argument list. @@ -46,6 +46,9 @@ Only print commands where arg contains this line (regex) .TP \--max-args MAXARGS Maximum number of arguments parsed and displayed, defaults to 20 +.TP +\-\-cgroupmap MAPPATH +Trace cgroups in this BPF map only (filtered in-kernel). .SH EXAMPLES .TP Trace all exec() syscalls: @@ -71,6 +74,10 @@ Only trace exec()s where the filename contains "mount": Only trace exec()s where argument's line contains "testpkg": # .B execsnoop \-l testpkg +.TP +Trace a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +# +.B execsnoop \-\-cgroupmap /sys/fs/bpf/test01 .SH FIELDS .TP TIME diff --git a/man/man8/opensnoop.8 b/man/man8/opensnoop.8 index 874332d47..54a7788a2 100644 --- a/man/man8/opensnoop.8 +++ b/man/man8/opensnoop.8 @@ -1,9 +1,10 @@ -.TH opensnoop 8 "2015-08-18" "USER COMMANDS" +.TH opensnoop 8 "2020-02-20" "USER COMMANDS" .SH NAME opensnoop \- Trace open() syscalls. Uses Linux eBPF/bcc. .SH SYNOPSIS .B opensnoop.py [\-h] [\-T] [\-U] [\-x] [\-p PID] [\-t TID] [\-u UID] [\-d DURATION] [\-n NAME] [\-e] [\-f FLAG_FILTER] + [--cgroupmap MAPPATH] .SH DESCRIPTION opensnoop traces the open() syscall, showing which processes are attempting to open which files. This can be useful for determining the location of config @@ -54,6 +55,9 @@ Show extended fields. .TP \-f FLAG Filter on open() flags, e.g., O_WRONLY. +.TP +\--cgroupmap MAPPATH +Trace cgroups in this BPF map only (filtered in-kernel). .SH EXAMPLES .TP Trace all open() syscalls: @@ -95,6 +99,10 @@ Show extended fields: Only print calls for writing: # .B opensnoop \-f O_WRONLY \-f O_RDWR +.TP +Trace a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +# +.B opensnoop \-\-cgroupmap /sys/fs/bpf/test01 .SH FIELDS .TP TIME(s) @@ -142,4 +150,4 @@ Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO -funccount(1) +execsnoop(8), funccount(1) diff --git a/man/man8/tcpaccept.8 b/man/man8/tcpaccept.8 index 6e340bd09..432192605 100644 --- a/man/man8/tcpaccept.8 +++ b/man/man8/tcpaccept.8 @@ -1,8 +1,8 @@ -.TH tcpaccept 8 "2019-03-08" "USER COMMANDS" +.TH tcpaccept 8 "2020-02-20" "USER COMMANDS" .SH NAME tcpaccept \- Trace TCP passive connections (accept()). Uses Linux eBPF/bcc. .SH SYNOPSIS -.B tcpaccept [\-h] [\-T] [\-t] [\-p PID] [\-P PORTS] +.B tcpaccept [\-h] [\-T] [\-t] [\-p PID] [\-P PORTS] [\-\-cgroupmap MAPPATH] .SH DESCRIPTION This tool traces passive TCP connections (eg, via an accept() syscall; connect() are active connections). This can be useful for general @@ -33,6 +33,9 @@ Trace this process ID only (filtered in-kernel). .TP \-P PORTS Comma-separated list of local ports to trace (filtered in-kernel). +.TP +\-\-cgroupmap MAPPATH +Trace cgroups in this BPF map only (filtered in-kernel). .SH EXAMPLES .TP Trace all passive TCP connections (accept()s): @@ -50,6 +53,10 @@ Trace connections to local ports 80 and 81 only: Trace PID 181 only: # .B tcpaccept \-p 181 +.TP +Trace a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +# +.B tcpaccept \-\-cgroupmap /sys/fs/bpf/test01 .SH FIELDS .TP TIME @@ -99,4 +106,4 @@ Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO -tcpconnect(8), funccount(8), tcpdump(8) +tcptracer(8), tcpconnect(8), funccount(8), tcpdump(8) diff --git a/man/man8/tcpconnect.8 b/man/man8/tcpconnect.8 index 9bf44e9c9..60aac1e21 100644 --- a/man/man8/tcpconnect.8 +++ b/man/man8/tcpconnect.8 @@ -1,8 +1,8 @@ -.TH tcpconnect 8 "2015-08-25" "USER COMMANDS" +.TH tcpconnect 8 "2020-02-20" "USER COMMANDS" .SH NAME tcpconnect \- Trace TCP active connections (connect()). Uses Linux eBPF/bcc. .SH SYNOPSIS -.B tcpconnect [\-h] [\-c] [\-t] [\-x] [\-p PID] [-P PORT] +.B tcpconnect [\-h] [\-c] [\-t] [\-x] [\-p PID] [-P PORT] [\-\-cgroupmap MAPPATH] .SH DESCRIPTION This tool traces active TCP connections (eg, via a connect() syscall; accept() are passive connections). This can be useful for general @@ -33,6 +33,9 @@ Trace this process ID only (filtered in-kernel). .TP \-P PORT Comma-separated list of destination ports to trace (filtered in-kernel). +.TP +\-\-cgroupmap MAPPATH +Trace cgroups in this BPF map only (filtered in-kernel). .SH EXAMPLES .TP \-U @@ -68,6 +71,10 @@ Trace UID 1000 only: Count connects per src ip and dest ip/port: # .B tcpconnect \-c +.TP +Trace a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +# +.B tcpconnect \-\-cgroupmap /sys/fs/bpf/test01 .SH FIELDS .TP TIME(s) @@ -116,4 +123,4 @@ Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO -tcpaccept(8), funccount(8), tcpdump(8) +tcptracer(8), tcpaccept(8), funccount(8), tcpdump(8) diff --git a/man/man8/tcptracer.8 b/man/man8/tcptracer.8 index b5b306171..728c80af5 100644 --- a/man/man8/tcptracer.8 +++ b/man/man8/tcptracer.8 @@ -1,8 +1,8 @@ -.TH tcptracer 8 "2017-03-27" "USER COMMANDS" +.TH tcptracer 8 "2020-02-20" "USER COMMANDS" .SH NAME tcptracer \- Trace TCP established connections. Uses Linux eBPF/bcc. .SH SYNOPSIS -.B tcptracer [\-h] [\-v] [\-p PID] [\-N NETNS] +.B tcptracer [\-h] [\-v] [\-p PID] [\-N NETNS] [\-\-cgroupmap MAPPATH] .SH DESCRIPTION This tool traces established TCP connections that open and close while tracing, and prints a line of output per connect, accept and close events. This includes @@ -29,6 +29,8 @@ Trace this process ID only (filtered in-kernel). \-N NETNS Trace this network namespace only (filtered in-kernel). .TP +\-\-cgroupmap MAPPATH +Trace cgroups in this BPF map only (filtered in-kernel). .SH EXAMPLES .TP Trace all TCP established connections: @@ -46,6 +48,10 @@ Trace PID 181 only: Trace connections in network namespace 4026531969 only: # .B tcptracer \-N 4026531969 +.TP +Trace a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +# +.B tcptracer \-\-cgroupmap /sys/fs/bpf/test01 .SH FIELDS .TP TYPE From 5681ea9edb5763c6199c2e2e7956bdfa7c13ea36 Mon Sep 17 00:00:00 2001 From: Matt Mullins Date: Thu, 20 Feb 2020 14:28:53 -0800 Subject: [PATCH 010/278] c++ api: add wrapper for raw tracepoints --- src/cc/api/BPF.cc | 50 +++++++++++++++++++++++++++++++++++++++++++++++ src/cc/api/BPF.h | 7 +++++++ src/cc/libbpf.c | 2 +- src/cc/libbpf.h | 2 +- 4 files changed, 59 insertions(+), 2 deletions(-) diff --git a/src/cc/api/BPF.cc b/src/cc/api/BPF.cc index a3a14fee9..2fea44cd2 100644 --- a/src/cc/api/BPF.cc +++ b/src/cc/api/BPF.cc @@ -138,6 +138,15 @@ StatusTuple BPF::detach_all() { } } + for (auto& it : raw_tracepoints_) { + auto res = detach_raw_tracepoint_event(it.first, it.second); + if (res.code() != 0) { + error_msg += "Failed to detach Raw tracepoint " + it.first + ": "; + error_msg += res.msg() + "\n"; + has_error = true; + } + } + for (auto& it : perf_buffers_) { auto res = it.second->close_all_cpu(); if (res.code() != 0) { @@ -326,6 +335,29 @@ StatusTuple BPF::attach_tracepoint(const std::string& tracepoint, return StatusTuple(0); } +StatusTuple BPF::attach_raw_tracepoint(const std::string& tracepoint, const std::string& probe_func) { + if (raw_tracepoints_.find(tracepoint) != raw_tracepoints_.end()) + return StatusTuple(-1, "Raw tracepoint %s already attached", + tracepoint.c_str()); + + int probe_fd; + TRY2(load_func(probe_func, BPF_PROG_TYPE_RAW_TRACEPOINT, probe_fd)); + + int res_fd = bpf_attach_raw_tracepoint(probe_fd, tracepoint.c_str()); + + if (res_fd < 0) { + TRY2(unload_func(probe_func)); + return StatusTuple(-1, "Unable to attach Raw tracepoint %s using %s", + tracepoint.c_str(), probe_func.c_str()); + } + + open_probe_t p = {}; + p.perf_event_fd = res_fd; + p.func = probe_func; + raw_tracepoints_[tracepoint] = std::move(p); + return StatusTuple(0); +} + StatusTuple BPF::attach_perf_event(uint32_t ev_type, uint32_t ev_config, const std::string& probe_func, uint64_t sample_period, uint64_t sample_freq, @@ -485,6 +517,16 @@ StatusTuple BPF::detach_tracepoint(const std::string& tracepoint) { return StatusTuple(0); } +StatusTuple BPF::detach_raw_tracepoint(const std::string& tracepoint) { + auto it = raw_tracepoints_.find(tracepoint); + if (it == raw_tracepoints_.end()) + return StatusTuple(-1, "No open Raw tracepoint %s", tracepoint.c_str()); + + TRY2(detach_raw_tracepoint_event(it->first, it->second)); + raw_tracepoints_.erase(it); + return StatusTuple(0); +} + StatusTuple BPF::detach_perf_event(uint32_t ev_type, uint32_t ev_config) { auto it = perf_events_.find(std::make_pair(ev_type, ev_config)); if (it == perf_events_.end()) @@ -789,6 +831,14 @@ StatusTuple BPF::detach_tracepoint_event(const std::string& tracepoint, return StatusTuple(0); } +StatusTuple BPF::detach_raw_tracepoint_event(const std::string& tracepoint, + open_probe_t& attr) { + TRY2(close(attr.perf_event_fd)); + TRY2(unload_func(attr.func)); + + return StatusTuple(0); +} + StatusTuple BPF::detach_perf_event_all_cpu(open_probe_t& attr) { bool has_error = false; std::string err_msg; diff --git a/src/cc/api/BPF.h b/src/cc/api/BPF.h index 612f2b526..4752ca056 100644 --- a/src/cc/api/BPF.h +++ b/src/cc/api/BPF.h @@ -91,6 +91,10 @@ class BPF { const std::string& probe_func); StatusTuple detach_tracepoint(const std::string& tracepoint); + StatusTuple attach_raw_tracepoint(const std::string& tracepoint, + const std::string& probe_func); + StatusTuple detach_raw_tracepoint(const std::string& tracepoint); + StatusTuple attach_perf_event(uint32_t ev_type, uint32_t ev_config, const std::string& probe_func, uint64_t sample_period, uint64_t sample_freq, @@ -248,6 +252,8 @@ class BPF { StatusTuple detach_uprobe_event(const std::string& event, open_probe_t& attr); StatusTuple detach_tracepoint_event(const std::string& tracepoint, open_probe_t& attr); + StatusTuple detach_raw_tracepoint_event(const std::string& tracepoint, + open_probe_t& attr); StatusTuple detach_perf_event_all_cpu(open_probe_t& attr); std::string attach_type_debug(bpf_probe_attach_type type) { @@ -302,6 +308,7 @@ class BPF { std::map kprobes_; std::map uprobes_; std::map tracepoints_; + std::map raw_tracepoints_; std::map perf_buffers_; std::map perf_event_arrays_; std::map, open_probe_t> perf_events_; diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index 974dc272e..a34c2dd2a 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -1136,7 +1136,7 @@ int bpf_detach_tracepoint(const char *tp_category, const char *tp_name) { return 0; } -int bpf_attach_raw_tracepoint(int progfd, char *tp_name) +int bpf_attach_raw_tracepoint(int progfd, const char *tp_name) { int ret; diff --git a/src/cc/libbpf.h b/src/cc/libbpf.h index 77bb728c5..bd42e0d0b 100644 --- a/src/cc/libbpf.h +++ b/src/cc/libbpf.h @@ -92,7 +92,7 @@ int bpf_attach_tracepoint(int progfd, const char *tp_category, const char *tp_name); int bpf_detach_tracepoint(const char *tp_category, const char *tp_name); -int bpf_attach_raw_tracepoint(int progfd, char *tp_name); +int bpf_attach_raw_tracepoint(int progfd, const char *tp_name); void * bpf_open_perf_buffer(perf_reader_raw_cb raw_cb, perf_reader_lost_cb lost_cb, void *cb_cookie, From 2a2e7290b60fdc420baa93954c20af8338fa6fae Mon Sep 17 00:00:00 2001 From: Matt Mullins Date: Thu, 20 Feb 2020 14:59:19 -0800 Subject: [PATCH 011/278] cpp examples: use a raw tracepoint for RandomRead --- examples/cpp/RandomRead.cc | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/examples/cpp/RandomRead.cc b/examples/cpp/RandomRead.cc index 8e38596c3..4851ddec6 100644 --- a/examples/cpp/RandomRead.cc +++ b/examples/cpp/RandomRead.cc @@ -24,14 +24,6 @@ const std::string BPF_PROGRAM = R"( #define CGROUP_FILTER 0 #endif -struct urandom_read_args { - // See /sys/kernel/debug/tracing/events/random/urandom_read/format - uint64_t common__unused; - int got_bits; - int pool_left; - int input_left; -}; - struct event_t { int pid; char comm[16]; @@ -42,7 +34,7 @@ struct event_t { BPF_PERF_OUTPUT(events); BPF_CGROUP_ARRAY(cgroup, 1); -int on_urandom_read(struct urandom_read_args* attr) { +int on_urandom_read(struct bpf_raw_tracepoint_args *ctx) { if (CGROUP_FILTER && (cgroup.check_current_task(0) != 1)) return 0; @@ -50,9 +42,11 @@ int on_urandom_read(struct urandom_read_args* attr) { event.pid = bpf_get_current_pid_tgid(); bpf_get_current_comm(&event.comm, sizeof(event.comm)); event.cpu = bpf_get_smp_processor_id(); - event.got_bits = attr->got_bits; + // from include/trace/events/random.h: + // TP_PROTO(int got_bits, int pool_left, int input_left) + event.got_bits = ctx->args[0]; - events.perf_submit(attr, &event, sizeof(event)); + events.perf_submit(ctx, &event, sizeof(event)); return 0; } )"; @@ -126,7 +120,7 @@ int main(int argc, char** argv) { } auto attach_res = - bpf->attach_tracepoint("random:urandom_read", "on_urandom_read"); + bpf->attach_raw_tracepoint("urandom_read", "on_urandom_read"); if (attach_res.code() != 0) { std::cerr << attach_res.msg() << std::endl; return 1; From 7ad17638acd9c1d82264451c9b0800ecf5ce4f59 Mon Sep 17 00:00:00 2001 From: Andrii Nakryiko Date: Thu, 20 Feb 2020 22:19:01 -0800 Subject: [PATCH 012/278] libbpf-tools: add links to BPF CO-RE posts Add links to BPF CO-RE blog posts, explainint what it is, how to use it, and giving practical recommendations on how to convert BCC BPF program to libbpf-based one. Signed-off-by: Andrii Nakryiko --- libbpf-tools/README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/libbpf-tools/README.md b/libbpf-tools/README.md index 8f1492bf9..152f72b69 100644 --- a/libbpf-tools/README.md +++ b/libbpf-tools/README.md @@ -1,3 +1,9 @@ +Useful links +------------ + +- [BPF Portability and CO-RE](https://facebookmicrosites.github.io/bpf/blog/2020/02/19/bpf-portability-and-co-re.html) +- [HOWTO: BCC to libbpf conversion](https://facebookmicrosites.github.io/bpf/blog/2020/02/20/bcc-to-libbpf-howto-guide.html) + Building ------- From c949f613315f19fce1fe5e6dacb1f0e5759c91c9 Mon Sep 17 00:00:00 2001 From: Slava Bacherikov Date: Thu, 20 Feb 2020 13:20:47 +0200 Subject: [PATCH 013/278] tools: execsnoop add -U and -u flags Add flags to display UID and filter by UID --- man/man8/execsnoop.8 | 25 +++++++++++++++++++-- tools/execsnoop.py | 45 +++++++++++++++++++++++++++++++++++++ tools/execsnoop_example.txt | 33 +++++++++++++++++++++++++-- 3 files changed, 99 insertions(+), 4 deletions(-) diff --git a/man/man8/execsnoop.8 b/man/man8/execsnoop.8 index aec2d70b7..4a88e0074 100644 --- a/man/man8/execsnoop.8 +++ b/man/man8/execsnoop.8 @@ -2,8 +2,8 @@ .SH NAME execsnoop \- Trace new processes via exec() syscalls. Uses Linux eBPF/bcc. .SH SYNOPSIS -.B execsnoop [\-h] [\-T] [\-t] [\-x] [\-q] [\-n NAME] [\-l LINE] -.B [\-\-max-args MAX_ARGS] [\-\-cgroupmap MAPPATH] +.B execsnoop [\-h] [\-T] [\-t] [\-x] [\-\-cgroupmap CGROUPMAP] [\-u USER] +.B [\-q] [\-n NAME] [\-l LINE] [\-U] [\-\-max-args MAX_ARGS] .SH DESCRIPTION execsnoop traces new processes, showing the filename executed and argument list. @@ -28,9 +28,15 @@ Print usage message. \-T Include a time column (HH:MM:SS). .TP +\-U +Include UID column. +.TP \-t Include a timestamp column. .TP +\-u USER +Filter by UID (or username) +.TP \-x Include failed exec()s .TP @@ -59,6 +65,18 @@ Trace all exec() syscalls, and include timestamps: # .B execsnoop \-t .TP +Display process UID: +# +.B execsnoop \-U +.TP +Trace only UID 1000: +# +.B execsnoop \-u 1000 +.TP +Trace only processes launched by root and display UID column: +# +.B execsnoop \-Uu root +.TP Include failed exec()s: # .B execsnoop \-x @@ -86,6 +104,9 @@ Time of exec() return, in HH:MM:SS format. TIME(s) Time of exec() return, in seconds. .TP +UID +User ID +.TP PCOMM Parent process/command name. .TP diff --git a/tools/execsnoop.py b/tools/execsnoop.py index 57dfab291..26cbce660 100755 --- a/tools/execsnoop.py +++ b/tools/execsnoop.py @@ -24,14 +24,35 @@ import argparse import re import time +import pwd from collections import defaultdict from time import strftime + +def parse_uid(user): + try: + result = int(user) + except ValueError: + try: + user_info = pwd.getpwnam(user) + except KeyError: + raise argparse.ArgumentTypeError( + "{0!r} is not valid UID or user entry".format(user)) + else: + return user_info.pw_uid + else: + # Maybe validate if UID < 0 ? + return result + + # arguments examples = """examples: ./execsnoop # trace all exec() syscalls ./execsnoop -x # include failed exec()s ./execsnoop -T # include time (HH:MM:SS) + ./execsnoop -U # include UID + ./execsnoop -u 1000 # only trace UID 1000 + ./execsnoop -u user # get user UID and trace only them ./execsnoop -t # include timestamps ./execsnoop -q # add "quotemarks" around arguments ./execsnoop -n main # only print command lines containing "main" @@ -50,6 +71,8 @@ help="include failed exec()s") parser.add_argument("--cgroupmap", help="trace cgroups in this BPF map only") +parser.add_argument("-u", "--uid", type=parse_uid, metavar='USER', + help="trace this UID only") parser.add_argument("-q", "--quote", action="store_true", help="Add quotemarks (\") around arguments." ) @@ -59,6 +82,8 @@ parser.add_argument("-l", "--line", type=ArgString, help="only print commands where arg contains this line (regex)") +parser.add_argument("-U", "--print-uid", action="store_true", + help="print UID column") parser.add_argument("--max-args", default="20", help="maximum number of arguments parsed and displayed, defaults to 20") parser.add_argument("--ebpf", action="store_true", @@ -81,6 +106,7 @@ struct data_t { u32 pid; // PID as in the userspace term (i.e. task->tgid in kernel) u32 ppid; // Parent PID as in the userspace term (i.e task->real_parent->tgid in kernel) + u32 uid; char comm[TASK_COMM_LEN]; enum event_type type; char argv[ARGSIZE]; @@ -114,6 +140,11 @@ const char __user *const __user *__argv, const char __user *const __user *__envp) { + + u32 uid = bpf_get_current_uid_gid() & 0xffffffff; + + UID_FILTER + #if CGROUPSET u64 cgroupid = bpf_get_current_cgroup_id(); if (cgroupset.lookup(&cgroupid) == NULL) { @@ -164,7 +195,11 @@ struct data_t data = {}; struct task_struct *task; + u32 uid = bpf_get_current_uid_gid() & 0xffffffff; + UID_FILTER + data.pid = bpf_get_current_pid_tgid() >> 32; + data.uid = uid; task = (struct task_struct *)bpf_get_current_task(); // Some kernels, like Ubuntu 4.13.0-generic, return 0 @@ -182,6 +217,12 @@ """ bpf_text = bpf_text.replace("MAXARG", args.max_args) + +if args.uid: + bpf_text = bpf_text.replace('UID_FILTER', + 'if (uid != %s) { return 0; }' % args.uid) +else: + bpf_text = bpf_text.replace('UID_FILTER', '') if args.cgroupmap: bpf_text = bpf_text.replace('CGROUPSET', '1') bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) @@ -202,6 +243,8 @@ print("%-9s" % ("TIME"), end="") if args.timestamp: print("%-8s" % ("TIME(s)"), end="") +if args.print_uid: + print("%-6s" % ("UID"), end="") print("%-16s %-6s %-6s %3s %s" % ("PCOMM", "PID", "PPID", "RET", "ARGS")) class EventType(object): @@ -251,6 +294,8 @@ def print_event(cpu, data, size): printb(b"%-9s" % strftime("%H:%M:%S").encode('ascii'), nl="") if args.timestamp: printb(b"%-8.3f" % (time.time() - start_ts), nl="") + if args.print_uid: + printb(b"%-6d" % event.uid, nl="") ppid = event.ppid if event.ppid > 0 else get_ppid(event.pid) ppid = b"%d" % ppid if ppid > 0 else b"?" argv_text = b' '.join(argv[event.pid]).replace(b'\n', b'\\n') diff --git a/tools/execsnoop_example.txt b/tools/execsnoop_example.txt index 618bcf65e..a90d00794 100644 --- a/tools/execsnoop_example.txt +++ b/tools/execsnoop_example.txt @@ -85,11 +85,32 @@ with an externally created map. For more details, see docs/filtering_by_cgroups.md +The -U option include UID on output: + +# ./execsnoop -U + +UID PCOMM PID PPID RET ARGS +1000 ls 171318 133702 0 /bin/ls --color=auto +1000 w 171322 133702 0 /usr/bin/w + +The -u options filters output based process UID. You also can use username as +argument, in that cause UID will be looked up using getpwnam (see man 3 getpwnam). + +# ./execsnoop -Uu 1000 +UID PCOMM PID PPID RET ARGS +1000 ls 171335 133702 0 /bin/ls --color=auto +1000 man 171340 133702 0 /usr/bin/man getpwnam +1000 bzip2 171341 171340 0 /bin/bzip2 -dc +1000 bzip2 171342 171340 0 /bin/bzip2 -dc +1000 bzip2 171345 171340 0 /bin/bzip2 -dc +1000 manpager 171355 171340 0 /usr/bin/manpager +1000 less 171355 171340 0 /usr/bin/less USAGE message: # ./execsnoop -h -usage: execsnoop [-h] [-T] [-t] [-x] [-q] [-n NAME] [-l LINE] [--max-args MAX_ARGS] +usage: execsnoop.py [-h] [-T] [-t] [-x] [--cgroupmap CGROUPMAP] [-u USER] [-q] + [-n NAME] [-l LINE] [-U] [--max-args MAX_ARGS] Trace exec() syscalls @@ -98,11 +119,15 @@ optional arguments: -T, --time include time column on output (HH:MM:SS) -t, --timestamp include timestamp on output -x, --fails include failed exec()s - -q, --quote Add quotemarks (") around arguments + --cgroupmap CGROUPMAP + trace cgroups in this BPF map only + -u USER, --uid USER trace this UID only + -q, --quote Add quotemarks (") around arguments. -n NAME, --name NAME only print commands matching this name (regex), any arg -l LINE, --line LINE only print commands where arg contains this line (regex) + -U, --print-uid print UID column --max-args MAX_ARGS maximum number of arguments parsed and displayed, defaults to 20 @@ -110,7 +135,11 @@ examples: ./execsnoop # trace all exec() syscalls ./execsnoop -x # include failed exec()s ./execsnoop -T # include time (HH:MM:SS) + ./execsnoop -U # include UID + ./execsnoop -u 1000 # only trace UID 1000 + ./execsnoop -u root # get root UID and trace only this ./execsnoop -t # include timestamps ./execsnoop -q # add "quotemarks" around arguments ./execsnoop -n main # only print command lines containing "main" ./execsnoop -l tpkg # only print command where arguments contains "tpkg" + ./execsnoop --cgroupmap ./mappath # only trace cgroups in this BPF map From 9edbae394f1827a2f5d549795848dc892c6531bf Mon Sep 17 00:00:00 2001 From: Xiaozhou Liu Date: Sun, 23 Feb 2020 16:26:09 +0000 Subject: [PATCH 014/278] tools/oomkill: output PID instead of thread ID (user's view) --- tools/oomkill.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tools/oomkill.py b/tools/oomkill.py index 4f3b6ce75..298e35363 100755 --- a/tools/oomkill.py +++ b/tools/oomkill.py @@ -26,8 +26,8 @@ #include struct data_t { - u64 fpid; - u64 tpid; + u32 fpid; + u32 tpid; u64 pages; char fcomm[TASK_COMM_LEN]; char tcomm[TASK_COMM_LEN]; @@ -40,7 +40,7 @@ unsigned long totalpages; struct task_struct *p = oc->chosen; struct data_t data = {}; - u32 pid = bpf_get_current_pid_tgid(); + u32 pid = bpf_get_current_pid_tgid() >> 32; data.fpid = pid; data.tpid = p->pid; data.pages = oc->totalpages; From 6f3c33b01ce72a44c89a6dcccd3f1cbd99fe1949 Mon Sep 17 00:00:00 2001 From: Matthieu De Beule <48329535+matdb@users.noreply.github.com> Date: Fri, 21 Feb 2020 18:23:53 +0100 Subject: [PATCH 015/278] Fix the python part of the http-parse-complete example The example wasn't working on my machine, just like in issue #2169 --- .../http_filter/http-parse-complete.py | 464 +++++++++--------- 1 file changed, 236 insertions(+), 228 deletions(-) diff --git a/examples/networking/http_filter/http-parse-complete.py b/examples/networking/http_filter/http-parse-complete.py index 0f9951051..abf5f0f2c 100644 --- a/examples/networking/http_filter/http-parse-complete.py +++ b/examples/networking/http_filter/http-parse-complete.py @@ -1,86 +1,82 @@ #!/usr/bin/python # -#Bertrone Matteo - Polytechnic of Turin -#November 2015 +# Bertrone Matteo - Polytechnic of Turin +# November 2015 # -#eBPF application that parses HTTP packets -#and extracts (and prints on screen) the URL contained in the GET/POST request. +# eBPF application that parses HTTP packets +# and extracts (and prints on screen) the URL +# contained in the GET/POST request. # -#eBPF program http_filter is used as SOCKET_FILTER attached to eth0 interface. -#only packet of type ip and tcp containing HTTP GET/POST are returned to userspace, others dropped +# eBPF program http_filter is used as SOCKET_FILTER attached to eth0 interface. +# Only packets of type ip and tcp containing HTTP GET/POST are +# returned to userspace, others dropped # -#python script uses bcc BPF Compiler Collection by iovisor (https://github.com/iovisor/bcc) -#and prints on stdout the first line of the HTTP GET/POST request containing the url +# Python script uses bcc BPF Compiler Collection by +# iovisor (https://github.com/iovisor/bcc) and prints on stdout the first +# line of the HTTP GET/POST request containing the url from __future__ import print_function from bcc import BPF -from ctypes import * -from struct import * from sys import argv -import sys import socket import os -import struct import binascii import time -CLEANUP_N_PACKETS = 50 #run cleanup every CLEANUP_N_PACKETS packets received -MAX_URL_STRING_LEN = 8192 #max url string len (usually 8K) -MAX_AGE_SECONDS = 30 #max age entry in bpf_sessions map +CLEANUP_N_PACKETS = 50 # cleanup every CLEANUP_N_PACKETS packets received +MAX_URL_STRING_LEN = 8192 # max url string len (usually 8K) +MAX_AGE_SECONDS = 30 # max age entry in bpf_sessions map -#convert a bin string into a string of hex char -#helper function to print raw packet in hex + +# convert a bin string into a string of hex char +# helper function to print raw packet in hex def toHex(s): - lst = [] + lst = "" for ch in s: - hv = hex(ord(ch)).replace('0x', '') + hv = hex(ch).replace('0x', '') if len(hv) == 1: - hv = '0'+hv - lst.append(hv) - - return reduce(lambda x,y:x+y, lst) - -#print str until CR+LF -def printUntilCRLF(str): - for k in range (0,len(str)-1): - if (str[k] == '\n'): - if (str[k-1] == '\r'): - print ("") - return - print ("%c" % (str[k]), end = "") - print("") - return + hv = '0' + hv + lst = lst + hv + return lst + -#cleanup function +# print str until CR+LF +def printUntilCRLF(s): + print(s.split(b'\r\n')[0].decode()) + + +# cleanup function def cleanup(): - #get current time in seconds + # get current time in seconds current_time = int(time.time()) - #looking for leaf having: - #timestap == 0 --> update with current timestamp - #AGE > MAX_AGE_SECONDS --> delete item - for key,leaf in bpf_sessions.items(): - try: - current_leaf = bpf_sessions[key] - #set timestamp if timestamp == 0 - if (current_leaf.timestamp == 0): - bpf_sessions[key] = bpf_sessions.Leaf(current_time) - else: - #delete older entries - if (current_time - current_leaf.timestamp > MAX_AGE_SECONDS): - del bpf_sessions[key] - except: - print("cleanup exception.") + # looking for leaf having: + # timestap == 0 --> update with current timestamp + # AGE > MAX_AGE_SECONDS --> delete item + for key, leaf in bpf_sessions.items(): + try: + current_leaf = bpf_sessions[key] + # set timestamp if timestamp == 0 + if (current_leaf.timestamp == 0): + bpf_sessions[key] = bpf_sessions.Leaf(current_time) + else: + # delete older entries + if (current_time - current_leaf.timestamp > MAX_AGE_SECONDS): + del bpf_sessions[key] + except: + print("cleanup exception.") return -#args + +# args def usage(): print("USAGE: %s [-i ]" % argv[0]) print("") print("Try '%s -h' for more options." % argv[0]) exit() -#help + +# help def help(): print("USAGE: %s [-i ]" % argv[0]) print("") @@ -93,206 +89,218 @@ def help(): print(" http-parse -i wlan0 # bind socket to wlan0") exit() -#arguments -interface="eth0" + +# arguments +interface = "eth0" if len(argv) == 2: - if str(argv[1]) == '-h': - help() - else: - usage() + if str(argv[1]) == '-h': + help() + else: + usage() if len(argv) == 3: - if str(argv[1]) == '-i': - interface = argv[2] - else: - usage() + if str(argv[1]) == '-i': + interface = argv[2] + else: + usage() if len(argv) > 3: - usage() + usage() -print ("binding socket to '%s'" % interface) +print("binding socket to '%s'" % interface) # initialize BPF - load source code from http-parse-complete.c -bpf = BPF(src_file = "http-parse-complete.c",debug = 0) +bpf = BPF(src_file="http-parse-complete.c", debug=0) -#load eBPF program http_filter of type SOCKET_FILTER into the kernel eBPF vm -#more info about eBPF program types -#http://man7.org/linux/man-pages/man2/bpf.2.html +# load eBPF program http_filter of type SOCKET_FILTER into the kernel eBPF vm +# more info about eBPF program types +# http://man7.org/linux/man-pages/man2/bpf.2.html function_http_filter = bpf.load_func("http_filter", BPF.SOCKET_FILTER) -#create raw socket, bind it to interface -#attach bpf program to socket created +# create raw socket, bind it to interface +# attach bpf program to socket created BPF.attach_raw_socket(function_http_filter, interface) -#get file descriptor of the socket previously created inside BPF.attach_raw_socket +# get file descriptor of the socket previously +# created inside BPF.attach_raw_socket socket_fd = function_http_filter.sock -#create python socket object, from the file descriptor -sock = socket.fromfd(socket_fd,socket.PF_PACKET,socket.SOCK_RAW,socket.IPPROTO_IP) -#set it as blocking socket +# create python socket object, from the file descriptor +sock = socket.fromfd(socket_fd, socket.PF_PACKET, + socket.SOCK_RAW, socket.IPPROTO_IP) +# set it as blocking socket sock.setblocking(True) -#get pointer to bpf map of type hash +# get pointer to bpf map of type hash bpf_sessions = bpf.get_table("sessions") -#packets counter +# packets counter packet_count = 0 -#dictionary containing association -#if url is not entirely contained in only one packet, save the firt part of it in this local dict -#when I find \r\n in a next pkt, append and print all the url +# dictionary containing association +# . +# if url is not entirely contained in only one packet, +# save the firt part of it in this local dict +# when I find \r\n in a next pkt, append and print the whole url local_dictionary = {} while 1: - #retrieve raw packet from socket - packet_str = os.read(socket_fd,4096) #set packet length to max packet length on the interface - packet_count += 1 - - #DEBUG - print raw packet in hex format - #packet_hex = toHex(packet_str) - #print ("%s" % packet_hex) - - #convert packet into bytearray - packet_bytearray = bytearray(packet_str) - - #ethernet header length - ETH_HLEN = 14 - - #IP HEADER - #https://tools.ietf.org/html/rfc791 - # 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 - # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - # |Version| IHL |Type of Service| Total Length | - # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - # - #IHL : Internet Header Length is the length of the internet header - #value to multiply * 4 byte - #e.g. IHL = 5 ; IP Header Length = 5 * 4 byte = 20 byte - # - #Total length: This 16-bit field defines the entire packet size, - #including header and data, in bytes. - - #calculate packet total length - total_length = packet_bytearray[ETH_HLEN + 2] #load MSB - total_length = total_length << 8 #shift MSB - total_length = total_length + packet_bytearray[ETH_HLEN+3] #add LSB - - #calculate ip header length - ip_header_length = packet_bytearray[ETH_HLEN] #load Byte - ip_header_length = ip_header_length & 0x0F #mask bits 0..3 - ip_header_length = ip_header_length << 2 #shift to obtain length - - #retrieve ip source/dest - ip_src_str = packet_str[ETH_HLEN+12:ETH_HLEN+16] #ip source offset 12..15 - ip_dst_str = packet_str[ETH_HLEN+16:ETH_HLEN+20] #ip dest offset 16..19 - - ip_src = int(toHex(ip_src_str),16) - ip_dst = int(toHex(ip_dst_str),16) - - #TCP HEADER - #https://www.rfc-editor.org/rfc/rfc793.txt - # 12 13 14 15 - # 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 - # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - # | Data | |U|A|P|R|S|F| | - # | Offset| Reserved |R|C|S|S|Y|I| Window | - # | | |G|K|H|T|N|N| | - # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - # - #Data Offset: This indicates where the data begins. - #The TCP header is an integral number of 32 bits long. - #value to multiply * 4 byte - #e.g. DataOffset = 5 ; TCP Header Length = 5 * 4 byte = 20 byte - - #calculate tcp header length - tcp_header_length = packet_bytearray[ETH_HLEN + ip_header_length + 12] #load Byte - tcp_header_length = tcp_header_length & 0xF0 #mask bit 4..7 - tcp_header_length = tcp_header_length >> 2 #SHR 4 ; SHL 2 -> SHR 2 - - #retrieve port source/dest - port_src_str = packet_str[ETH_HLEN+ip_header_length:ETH_HLEN+ip_header_length+2] - port_dst_str = packet_str[ETH_HLEN+ip_header_length+2:ETH_HLEN+ip_header_length+4] - - port_src = int(toHex(port_src_str),16) - port_dst = int(toHex(port_dst_str),16) - - #calculate payload offset - payload_offset = ETH_HLEN + ip_header_length + tcp_header_length - - #payload_string contains only packet payload - payload_string = packet_str[(payload_offset):(len(packet_bytearray))] - - #CR + LF (substring to find) - crlf = "\r\n" - - #current_Key contains ip source/dest and port source/map - #useful for direct bpf_sessions map access - current_Key = bpf_sessions.Key(ip_src,ip_dst,port_src,port_dst) - - #looking for HTTP GET/POST request - if ((payload_string[:3] == "GET") or (payload_string[:4] == "POST") or (payload_string[:4] == "HTTP") \ - or ( payload_string[:3] == "PUT") or (payload_string[:6] == "DELETE") or (payload_string[:4] == "HEAD") ): - #match: HTTP GET/POST packet found - if (crlf in payload_string): - #url entirely contained in first packet -> print it all - printUntilCRLF(payload_string) - - #delete current_Key from bpf_sessions, url already printed. current session not useful anymore - try: - del bpf_sessions[current_Key] - except: - print ("error during delete from bpf map ") - else: - #url NOT entirely contained in first packet - #not found \r\n in payload. - #save current part of the payload_string in dictionary - local_dictionary[binascii.hexlify(current_Key)] = payload_string - else: - #NO match: HTTP GET/POST NOT found - - #check if the packet belong to a session saved in bpf_sessions - if (current_Key in bpf_sessions): - #check id the packet belong to a session saved in local_dictionary - #(local_dictionary maintains HTTP GET/POST url not printed yet because split in N packets) - if (binascii.hexlify(current_Key) in local_dictionary): - #first part of the HTTP GET/POST url is already present in local dictionary (prev_payload_string) - prev_payload_string = local_dictionary[binascii.hexlify(current_Key)] - #looking for CR+LF in current packet. + # retrieve raw packet from socket + packet_str = os.read(socket_fd, 4096) # set packet length to max packet length on the interface + packet_count += 1 + + # DEBUG - print raw packet in hex format + # packet_hex = toHex(packet_str) + # print ("%s" % packet_hex) + + # convert packet into bytearray + packet_bytearray = bytearray(packet_str) + + # ethernet header length + ETH_HLEN = 14 + + # IP HEADER + # https://tools.ietf.org/html/rfc791 + # 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + # |Version| IHL |Type of Service| Total Length | + # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + # + # IHL : Internet Header Length is the length of the internet header + # value to multiply * 4 byte + # e.g. IHL = 5 ; IP Header Length = 5 * 4 byte = 20 byte + # + # Total length: This 16-bit field defines the entire packet size, + # including header and data, in bytes. + + # calculate packet total length + total_length = packet_bytearray[ETH_HLEN + 2] # load MSB + total_length = total_length << 8 # shift MSB + total_length = total_length + packet_bytearray[ETH_HLEN + 3] # add LSB + + # calculate ip header length + ip_header_length = packet_bytearray[ETH_HLEN] # load Byte + ip_header_length = ip_header_length & 0x0F # mask bits 0..3 + ip_header_length = ip_header_length << 2 # shift to obtain length + + # retrieve ip source/dest + ip_src_str = packet_str[ETH_HLEN + 12: ETH_HLEN + 16] # ip source offset 12..15 + ip_dst_str = packet_str[ETH_HLEN + 16:ETH_HLEN + 20] # ip dest offset 16..19 + + ip_src = int(toHex(ip_src_str), 16) + ip_dst = int(toHex(ip_dst_str), 16) + + # TCP HEADER + # https://www.rfc-editor.org/rfc/rfc793.txt + # 12 13 14 15 + # 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + # | Data | |U|A|P|R|S|F| | + # | Offset| Reserved |R|C|S|S|Y|I| Window | + # | | |G|K|H|T|N|N| | + # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + # + # Data Offset: This indicates where the data begins. + # The TCP header is an integral number of 32 bits long. + # value to multiply * 4 byte + # e.g. DataOffset = 5 ; TCP Header Length = 5 * 4 byte = 20 byte + + # calculate tcp header length + tcp_header_length = packet_bytearray[ETH_HLEN + ip_header_length + 12] # load Byte + tcp_header_length = tcp_header_length & 0xF0 # mask bit 4..7 + tcp_header_length = tcp_header_length >> 2 # SHR 4 ; SHL 2 -> SHR 2 + + # retrieve port source/dest + port_src_str = packet_str[ETH_HLEN + ip_header_length:ETH_HLEN + ip_header_length + 2] + port_dst_str = packet_str[ETH_HLEN + ip_header_length + 2:ETH_HLEN + ip_header_length + 4] + + port_src = int(toHex(port_src_str), 16) + port_dst = int(toHex(port_dst_str), 16) + + # calculate payload offset + payload_offset = ETH_HLEN + ip_header_length + tcp_header_length + + # payload_string contains only packet payload + payload_string = packet_str[(payload_offset):(len(packet_bytearray))] + # CR + LF (substring to find) + crlf = b'\r\n' + + # current_Key contains ip source/dest and port source/map + # useful for direct bpf_sessions map access + current_Key = bpf_sessions.Key(ip_src, ip_dst, port_src, port_dst) + + # looking for HTTP GET/POST request + if ((payload_string[:3] == b'GET') or (payload_string[:4] == b'POST') + or (payload_string[:4] == b'HTTP') or (payload_string[:3] == b'PUT') + or (payload_string[:6] == b'DELETE') or (payload_string[:4] == b'HEAD')): + # match: HTTP GET/POST packet found if (crlf in payload_string): - #last packet. containing last part of HTTP GET/POST url split in N packets. - #append current payload - prev_payload_string += payload_string - #print HTTP GET/POST url - printUntilCRLF(prev_payload_string) - #clean bpf_sessions & local_dictionary - try: - del bpf_sessions[current_Key] - del local_dictionary[binascii.hexlify(current_Key)] - except: - print ("error deleting from map or dictionary") - else: - #NOT last packet. containing part of HTTP GET/POST url split in N packets. - #append current payload - prev_payload_string += payload_string - #check if not size exceeding (usually HTTP GET/POST url < 8K ) - if (len(prev_payload_string) > MAX_URL_STRING_LEN): - print("url too long") + # url entirely contained in first packet -> print it all + printUntilCRLF(payload_string) + + # delete current_Key from bpf_sessions, url already printed. + # current session not useful anymore try: - del bpf_sessions[current_Key] - del local_dictionary[binascii.hexlify(current_Key)] + del bpf_sessions[current_Key] except: - print ("error deleting from map or dict") - #update dictionary - local_dictionary[binascii.hexlify(current_Key)] = prev_payload_string - else: - #first part of the HTTP GET/POST url is NOT present in local dictionary - #bpf_sessions contains invalid entry -> delete it - try: - del bpf_sessions[current_Key] - except: - print ("error del bpf_session") - - #check if dirty entry are present in bpf_sessions - if (((packet_count) % CLEANUP_N_PACKETS) == 0): - cleanup() + print("error during delete from bpf map ") + else: + # url NOT entirely contained in first packet + # not found \r\n in payload. + # save current part of the payload_string in dictionary + # + local_dictionary[binascii.hexlify(current_Key)] = payload_string + else: + # NO match: HTTP GET/POST NOT found + + # check if the packet belong to a session saved in bpf_sessions + if (current_Key in bpf_sessions): + # check id the packet belong to a session saved in local_dictionary + # (local_dictionary maintains HTTP GET/POST url not + # printed yet because split in N packets) + if (binascii.hexlify(current_Key) in local_dictionary): + # first part of the HTTP GET/POST url is already present in + # local dictionary (prev_payload_string) + prev_payload_string = local_dictionary[binascii.hexlify(current_Key)] + # looking for CR+LF in current packet. + if (crlf in payload_string): + # last packet. containing last part of HTTP GET/POST + # url split in N packets. Append current payload + prev_payload_string += payload_string + # print HTTP GET/POST url + printUntilCRLF(prev_payload_string) + # clean bpf_sessions & local_dictionary + try: + del bpf_sessions[current_Key] + del local_dictionary[binascii.hexlify(current_Key)] + except: + print("error deleting from map or dictionary") + else: + # NOT last packet. Containing part of HTTP GET/POST url + # split in N packets. + # Append current payload + prev_payload_string += payload_string + # check if not size exceeding + # (usually HTTP GET/POST url < 8K ) + if (len(prev_payload_string) > MAX_URL_STRING_LEN): + print("url too long") + try: + del bpf_sessions[current_Key] + del local_dictionary[binascii.hexlify(current_Key)] + except: + print("error deleting from map or dict") + # update dictionary + local_dictionary[binascii.hexlify(current_Key)] = prev_payload_string + else: + # first part of the HTTP GET/POST url is + # NOT present in local dictionary + # bpf_sessions contains invalid entry -> delete it + try: + del bpf_sessions[current_Key] + except: + print("error del bpf_session") + + # check if dirty entry are present in bpf_sessions + if (((packet_count) % CLEANUP_N_PACKETS) == 0): + cleanup() From 08de253fbbc2603d59c19618a3e9f18f5bff7bff Mon Sep 17 00:00:00 2001 From: Masanori Misono Date: Tue, 25 Feb 2020 17:36:10 +0900 Subject: [PATCH 016/278] Fix a table of contents of maps Signed-off-by: Masanori Misono --- docs/reference_guide.md | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 9080deee6..38c0cb66e 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -45,16 +45,18 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [10. BPF_DEVMAP](#10-bpf_devmap) - [11. BPF_CPUMAP](#11-bpf_cpumap) - [12. BPF_XSKMAP](#12-bpf_xskmap) - - [13. map.lookup()](#13-maplookup) - - [14. map.lookup_or_try_init()](#14-maplookup_or_try_init) - - [15. map.delete()](#15-mapdelete) - - [16. map.update()](#16-mapupdate) - - [17. map.insert()](#17-mapinsert) - - [18. map.increment()](#18-mapincrement) - - [19. map.get_stackid()](#19-mapget_stackid) - - [20. map.perf_read()](#20-mapperf_read) - - [21. map.call()](#21-mapcall) - - [22. map.redirect_map()](#22-mapredirect_map) + - [13. BPF_ARRAY_OF_MAPS](#13-bpf_array_of_maps) + - [14. BPF_HASH_OF_MAPS](#14-bpf_hash_of_maps) + - [15. map.lookup()](#15-maplookup) + - [16. map.lookup_or_try_init()](#16-maplookup_or_try_init) + - [17. map.delete()](#17-mapdelete) + - [18. map.update()](#18-mapupdate) + - [19. map.insert()](#19-mapinsert) + - [20. map.increment()](#20-mapincrement) + - [21. map.get_stackid()](#21-mapget_stackid) + - [22. map.perf_read()](#22-mapperf_read) + - [23. map.call()](#23-mapcall) + - [24. map.redirect_map()](#24-mapredirect_map) - [Licensing](#licensing) - [bcc Python](#bcc-python) From 18da40cd186296d277e193fa92dec1791a888b8c Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Tue, 28 Jan 2020 23:04:02 +0100 Subject: [PATCH 017/278] Fix bpf linking if specified via LIBBPF_LIBRARIES variable We need to use LIBBPF_LIBRARIES variable instead of just using bpf for libbpf linking, so it user specified library gets linked in. Signed-off-by: Jiri Olsa --- tests/cc/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/cc/CMakeLists.txt b/tests/cc/CMakeLists.txt index ebcef1c66..0435e646a 100644 --- a/tests/cc/CMakeLists.txt +++ b/tests/cc/CMakeLists.txt @@ -49,7 +49,7 @@ if(LIBBPF_FOUND) add_executable(test_libbcc_no_libbpf ${TEST_LIBBCC_SOURCES}) add_dependencies(test_libbcc_no_libbpf bcc-shared-no-libbpf) - target_link_libraries(test_libbcc_no_libbpf ${PROJECT_BINARY_DIR}/src/cc/libbcc-no-libbpf.so dl usdt_test_lib bpf) + target_link_libraries(test_libbcc_no_libbpf ${PROJECT_BINARY_DIR}/src/cc/libbcc-no-libbpf.so dl usdt_test_lib ${LIBBPF_LIBRARIES}) set_target_properties(test_libbcc_no_libbpf PROPERTIES INSTALL_RPATH ${PROJECT_BINARY_DIR}/src/cc) target_compile_definitions(test_libbcc_no_libbpf PRIVATE -DLIBBCC_NAME=\"libbcc-no-libbpf.so\") From 1e7862fdfd8b428e6b2e3ea23f63a1469c3fabf3 Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Tue, 25 Feb 2020 16:00:42 +0100 Subject: [PATCH 018/278] Unite libbpf includes Currently we include headers from local libbpf subpackage, which does not work if user specify LIBBPF_INCLUDE_DIR. Adding HAVE_EXTERNAL_LIBBPF macro, that gets defined when user specifies libbpf header path. This macro is checked in bcc_libbpf_inc.h and proper files are included. Using bcc_libbpf_inc.h in place of libbpf includes. Signed-off-by: Jiri Olsa --- src/cc/CMakeLists.txt | 14 ++++++++------ src/cc/bcc_btf.cc | 3 +-- src/cc/bcc_libbpf_inc.h | 11 +++++++++++ src/cc/bpf_module.cc | 2 +- src/cc/frontends/clang/b_frontend_action.cc | 2 +- src/cc/libbpf.c | 3 +-- 6 files changed, 23 insertions(+), 12 deletions(-) create mode 100644 src/cc/bcc_libbpf_inc.h diff --git a/src/cc/CMakeLists.txt b/src/cc/CMakeLists.txt index cc8b769b9..56a4bc600 100644 --- a/src/cc/CMakeLists.txt +++ b/src/cc/CMakeLists.txt @@ -28,13 +28,15 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DLLVM_MAJOR_VERSION=${CMAKE_MATCH_1}") include(static_libstdc++) -if(LIBBPF_FOUND) - # We need to include the libbpf packaged source to get the - # headers location, becaseu they are installed under 'bpf' - # directory, but the libbpf code references them localy - - include_directories(${LIBBPF_INCLUDE_DIR}/bpf) +if(LIBBPF_INCLUDE_DIR) + # Add user libbpf include and notify compilation + # that we are using external libbpf. It's checked + # in src/cc/libbpf.h and proper files are included. + include_directories(${LIBBPF_INCLUDE_DIR}) + add_definitions(-DHAVE_EXTERNAL_LIBBPF) +endif() +if(LIBBPF_FOUND) set(extract_dir ${CMAKE_CURRENT_BINARY_DIR}/libbpf_a_extract) execute_process(COMMAND sh -c "mkdir -p ${extract_dir} && cd ${extract_dir} && ${CMAKE_AR} x ${LIBBPF_STATIC_LIBRARIES}") file(GLOB libbpf_sources "${extract_dir}/*.o") diff --git a/src/cc/bcc_btf.cc b/src/cc/bcc_btf.cc index 69d36bc4b..e220f117c 100644 --- a/src/cc/bcc_btf.cc +++ b/src/cc/bcc_btf.cc @@ -19,8 +19,7 @@ #include #include "linux/btf.h" #include "libbpf.h" -#include "libbpf/src/libbpf.h" -#include "libbpf/src/btf.h" +#include "bcc_libbpf_inc.h" #include #define BCC_MAX_ERRNO 4095 diff --git a/src/cc/bcc_libbpf_inc.h b/src/cc/bcc_libbpf_inc.h new file mode 100644 index 000000000..94e389506 --- /dev/null +++ b/src/cc/bcc_libbpf_inc.h @@ -0,0 +1,11 @@ +#pragma once + +#ifdef HAVE_EXTERNAL_LIBBPF +# include +# include +# include +#else +# include "libbpf/src/bpf.h" +# include "libbpf/src/btf.h" +# include "libbpf/src/libbpf.h" +#endif diff --git a/src/cc/bpf_module.cc b/src/cc/bpf_module.cc index 27e8f76d5..638fad9d9 100644 --- a/src/cc/bpf_module.cc +++ b/src/cc/bpf_module.cc @@ -45,7 +45,7 @@ #include "exported_files.h" #include "libbpf.h" #include "bcc_btf.h" -#include "libbpf/src/bpf.h" +#include "bcc_libbpf_inc.h" namespace ebpf { diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc index 8beefafb7..89511effd 100644 --- a/src/cc/frontends/clang/b_frontend_action.cc +++ b/src/cc/frontends/clang/b_frontend_action.cc @@ -34,7 +34,7 @@ #include "loader.h" #include "table_storage.h" #include "arch_helper.h" -#include "libbpf/src/bpf.h" +#include "bcc_libbpf_inc.h" #include "libbpf.h" diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index a34c2dd2a..127d2a697 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -52,8 +52,7 @@ // TODO: Remove this when CentOS 6 support is not needed anymore #include "setns.h" -#include "libbpf/src/bpf.h" -#include "libbpf/src/libbpf.h" +#include "bcc_libbpf_inc.h" // TODO: remove these defines when linux-libc-dev exports them properly From 550706a220da1636fafd322f0366cfde2a188d16 Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Thu, 30 Jan 2020 13:20:57 +0100 Subject: [PATCH 019/278] Do not initialize kern_version for TRACING/EXT programs The TRACING/EXT programs use attach_btf_id and attach_prog_fd fields from struct bpf_load_program_attr. The attach_prog_fd field shares space with kern_version, so by setting kern_version unconditionally we also set attach_prog_fd to bogus value and kernel fails the load because it tries to look it up. Setting kern_version only for programs other than TRACING/EXT type. Signed-off-by: Jiri Olsa --- src/cc/bpf_module.cc | 5 ++++- src/cc/libbpf.c | 3 ++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/cc/bpf_module.cc b/src/cc/bpf_module.cc index 638fad9d9..d75d8ea5e 100644 --- a/src/cc/bpf_module.cc +++ b/src/cc/bpf_module.cc @@ -907,7 +907,10 @@ int BPFModule::bcc_func_load(int prog_type, const char *name, attr.name = name; attr.insns = insns; attr.license = license; - attr.kern_version = kern_version; + if (attr.prog_type != BPF_PROG_TYPE_TRACING && + attr.prog_type != BPF_PROG_TYPE_EXT) { + attr.kern_version = kern_version; + } attr.log_level = log_level; if (dev_name) attr.prog_ifindex = if_nametoindex(dev_name); diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index 127d2a697..12cd92067 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -671,7 +671,8 @@ int bcc_prog_load(enum bpf_prog_type prog_type, const char *name, attr.name = name; attr.insns = insns; attr.license = license; - attr.kern_version = kern_version; + if (prog_type != BPF_PROG_TYPE_TRACING && prog_type != BPF_PROG_TYPE_EXT) + attr.kern_version = kern_version; attr.log_level = log_level; return bcc_prog_load_xattr(&attr, prog_len, log_buf, log_buf_size, true); } From 572478b2083651f25c4e278f8c34ff3d16e3be6a Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Sun, 29 Dec 2019 15:23:00 +0100 Subject: [PATCH 020/278] Introduce {attach|detach}_kfunc API Kernel added new probe called trampoline allowing to probe almost any kernel function when BTF info is available in the system. Adding the interface to define trampoline function for given kernel function via BPF_PROG macro, like: KFUNC_PROBE(do_sys_open, int dfd, const char *filename, int flags, int mode) { ... } which defines trampoline function with the 'kfunc__do_sys_open' name, that instruments do_sys_open kernel function before the function is executed. or: KRETFUNC_PROBE(do_sys_open, int dfd, const char *filename, int flags, int mode, int ret) { ... } which defines trampoline function with the 'kfunc__do_sys_open' name, that instruments do_sys_open kernel function after the function is executed. The main benefit is really lower overhead for trampolines (please see following commit for klockstat.py with perf comparison). Another benefit is the ability of kretfunc probe to access function arguments, so some tools might need only one program instead of entry/exit ones (please see following commit for opensnoop.py changes). Currently the interface does not allow to define function of different name than: kfunc__ or kretfunc__ which is sufficient by now, and can be easily changed in future if needed. Signed-off-by: Jiri Olsa --- docs/reference_guide.md | 46 ++++++++++++++++++++++++++ src/cc/export/helpers.h | 45 +++++++++++++++++++++++++ src/cc/libbpf.c | 33 ++++++++++++++++++- src/cc/libbpf.h | 4 +++ src/python/bcc/__init__.py | 67 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 194 insertions(+), 1 deletion(-) diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 38c0cb66e..6197963f5 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -16,6 +16,8 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [6. USDT probes](#6-usdt-probes) - [7. Raw Tracepoints](#7-raw-tracepoints) - [8. system call tracepoints](#8-system-call-tracepoints) + - [9. kfuncs](#9-kfuncs) + - [10. kretfuncs](#9-kretfuncs) - [Data](#data) - [1. bpf_probe_read()](#1-bpf_probe_read) - [2. bpf_probe_read_str()](#2-bpf_probe_read_str) @@ -317,6 +319,50 @@ b.attach_kprobe(event=execve_fnname, fn_name="syscall__execve") Examples in situ: [code](https://github.com/iovisor/bcc/blob/552658edda09298afdccc8a4b5e17311a2d8a771/tools/execsnoop.py#L101) ([output](https://github.com/iovisor/bcc/blob/552658edda09298afdccc8a4b5e17311a2d8a771/tools/execsnoop_example.txt#L8)) +### 9. kfuncs + +Syntax: KFUNC_PROBE(*function*, typeof(arg1) arg1, typeof(arg2) arge ...) + +This is a macro that instruments the kernel function via trampoline +*before* the function is executed. It's defined by *function* name and +the function arguments defined as *argX*. + +For example: +```C +KFUNC_PROBE(do_sys_open, int dfd, const char *filename, int flags, int mode) +{ + ... +``` + +This instruments the do_sys_open kernel function and make its arguments +accessible as standard argument values. + +Examples in situ: +[search /tools](https://github.com/iovisor/bcc/search?q=KFUNC_PROBE+path%3Atools&type=Code) + +### 10. kretfuncs + +Syntax: KRETFUNC_PROBE(*event*, typeof(arg1) arg1, typeof(arg2) arge ..., int ret) + +This is a macro that instruments the kernel function via trampoline +*after* the function is executed. It's defined by *function* name and +the function arguments defined as *argX*. + +The last argument of the probe is the return value of the instrumented function. + +For example: +```C +KFUNC_PROBE(do_sys_open, int dfd, const char *filename, int flags, int mode, int ret) +{ + ... +``` + +This instruments the do_sys_open kernel function and make its arguments +accessible as standard argument values together with its return value. + +Examples in situ: +[search /tools](https://github.com/iovisor/bcc/search?q=KRETFUNC_PROBE+path%3Atools&type=Code) + ## Data diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index 49aa66feb..590f4d8df 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -945,6 +945,51 @@ int tracepoint__##category##__##event(struct tracepoint__##category##__##event * #define RAW_TRACEPOINT_PROBE(event) \ int raw_tracepoint__##event(struct bpf_raw_tracepoint_args *ctx) +/* BPF_PROG macro allows to define trampoline function, + * borrowed from kernel bpf selftest code. + */ +#define ___bpf_concat(a, b) a ## b +#define ___bpf_apply(fn, n) ___bpf_concat(fn, n) +#define ___bpf_nth(_, _1, _2, _3, _4, _5, _6, _7, _8, _9, _a, _b, _c, N, ...) N +#define ___bpf_narg(...) \ + ___bpf_nth(_, ##__VA_ARGS__, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) + +#define ___bpf_ctx_cast0() ctx +#define ___bpf_ctx_cast1(x) ___bpf_ctx_cast0(), (void *)ctx[0] +#define ___bpf_ctx_cast2(x, args...) ___bpf_ctx_cast1(args), (void *)ctx[1] +#define ___bpf_ctx_cast3(x, args...) ___bpf_ctx_cast2(args), (void *)ctx[2] +#define ___bpf_ctx_cast4(x, args...) ___bpf_ctx_cast3(args), (void *)ctx[3] +#define ___bpf_ctx_cast5(x, args...) ___bpf_ctx_cast4(args), (void *)ctx[4] +#define ___bpf_ctx_cast6(x, args...) ___bpf_ctx_cast5(args), (void *)ctx[5] +#define ___bpf_ctx_cast7(x, args...) ___bpf_ctx_cast6(args), (void *)ctx[6] +#define ___bpf_ctx_cast8(x, args...) ___bpf_ctx_cast7(args), (void *)ctx[7] +#define ___bpf_ctx_cast9(x, args...) ___bpf_ctx_cast8(args), (void *)ctx[8] +#define ___bpf_ctx_cast10(x, args...) ___bpf_ctx_cast9(args), (void *)ctx[9] +#define ___bpf_ctx_cast11(x, args...) ___bpf_ctx_cast10(args), (void *)ctx[10] +#define ___bpf_ctx_cast12(x, args...) ___bpf_ctx_cast11(args), (void *)ctx[11] +#define ___bpf_ctx_cast(args...) \ + ___bpf_apply(___bpf_ctx_cast, ___bpf_narg(args))(args) + +#define BPF_PROG(name, args...) \ +int name(unsigned long long *ctx); \ +__attribute__((always_inline)) \ +static void ____##name(unsigned long long *ctx, ##args); \ +int name(unsigned long long *ctx) \ +{ \ + _Pragma("GCC diagnostic push") \ + _Pragma("GCC diagnostic ignored \"-Wint-conversion\"") \ + ____##name(___bpf_ctx_cast(args)); \ + _Pragma("GCC diagnostic pop") \ + return 0; \ +} \ +static void ____##name(unsigned long long *ctx, ##args) + +#define KFUNC_PROBE(event, args...) \ + BPF_PROG(kfunc__ ## event, args) + +#define KRETFUNC_PROBE(event, args...) \ + BPF_PROG(kretfunc__ ## event, args) + #define TP_DATA_LOC_READ_CONST(dst, field, length) \ do { \ unsigned short __offset = args->data_loc_##field & 0xFFFF; \ diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index 12cd92067..f4c68bdeb 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -510,7 +510,7 @@ int bcc_prog_load_xattr(struct bpf_load_program_attr *attr, int prog_len, unsigned name_len = attr->name ? strlen(attr->name) : 0; char *tmp_log_buf = NULL, *attr_log_buf = NULL; unsigned tmp_log_buf_size = 0, attr_log_buf_size = 0; - int ret = 0, name_offset = 0; + int ret = 0, name_offset = 0, expected_attach_type = 0; char prog_name[BPF_OBJ_NAME_LEN] = {}; unsigned insns_cnt = prog_len / sizeof(struct bpf_insn); @@ -547,6 +547,20 @@ int bcc_prog_load_xattr(struct bpf_load_program_attr *attr, int prog_len, name_offset = 12; else if (strncmp(attr->name, "raw_tracepoint__", 16) == 0) name_offset = 16; + else if (strncmp(attr->name, "kfunc__", 7) == 0) { + name_offset = 7; + expected_attach_type = BPF_TRACE_FENTRY; + } else if (strncmp(attr->name, "kretfunc__", 10) == 0) { + name_offset = 10; + expected_attach_type = BPF_TRACE_FEXIT; + } + + if (attr->prog_type == BPF_PROG_TYPE_TRACING) { + attr->attach_btf_id = libbpf_find_vmlinux_btf_id(attr->name + name_offset, + expected_attach_type); + attr->expected_attach_type = expected_attach_type; + } + memcpy(prog_name, attr->name + name_offset, min(name_len - name_offset, BPF_OBJ_NAME_LEN - 1)); attr->name = prog_name; @@ -1146,6 +1160,23 @@ int bpf_attach_raw_tracepoint(int progfd, const char *tp_name) return ret; } +int bpf_detach_kfunc(int prog_fd, char *func) +{ + UNUSED(prog_fd); + UNUSED(func); + return 0; +} + +int bpf_attach_kfunc(int prog_fd) +{ + int ret; + + ret = bpf_raw_tracepoint_open(NULL, prog_fd); + if (ret < 0) + fprintf(stderr, "bpf_attach_raw_tracepoint (kfunc): %s\n", strerror(errno)); + return ret; +} + void * bpf_open_perf_buffer(perf_reader_raw_cb raw_cb, perf_reader_lost_cb lost_cb, void *cb_cookie, int pid, int cpu, int page_cnt) { diff --git a/src/cc/libbpf.h b/src/cc/libbpf.h index bd42e0d0b..3f76083b6 100644 --- a/src/cc/libbpf.h +++ b/src/cc/libbpf.h @@ -94,6 +94,10 @@ int bpf_detach_tracepoint(const char *tp_category, const char *tp_name); int bpf_attach_raw_tracepoint(int progfd, const char *tp_name); +int bpf_detach_kfunc(int prog_fd, char *func); + +int bpf_attach_kfunc(int prog_fd); + void * bpf_open_perf_buffer(perf_reader_raw_cb raw_cb, perf_reader_lost_cb lost_cb, void *cb_cookie, int pid, int cpu, int page_cnt); diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index 1c94c7871..dcffc0e5b 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -156,6 +156,7 @@ class BPF(object): SK_MSG = 16 RAW_TRACEPOINT = 17 CGROUP_SOCK_ADDR = 18 + TRACING = 26 # from xdp_action uapi/linux/bpf.h XDP_ABORTED = 0 @@ -164,6 +165,10 @@ class BPF(object): XDP_TX = 3 XDP_REDIRECT = 4 + # from bpf_attach_type uapi/linux/bpf.h + TRACE_FENTRY = 24 + TRACE_FEXIT = 25 + _probe_repl = re.compile(b"[^a-zA-Z0-9_]") _sym_caches = {} _bsymcache = lib.bcc_buildsymcache_new() @@ -303,6 +308,8 @@ def __init__(self, src_file=b"", hdr_file=b"", text=None, debug=0, self.uprobe_fds = {} self.tracepoint_fds = {} self.raw_tracepoint_fds = {} + self.kfunc_entry_fds = {} + self.kfunc_exit_fds = {} self.perf_buffers = {} self.open_perf_events = {} self.tracefile = None @@ -869,6 +876,58 @@ def detach_raw_tracepoint(self, tp=b""): os.close(self.raw_tracepoint_fds[tp]) del self.raw_tracepoint_fds[tp] + @staticmethod + def add_prefix(prefix, name): + if not name.startswith(prefix): + name = prefix + name + return name + + def detach_kfunc(self, fn_name=b""): + fn_name = _assert_is_bytes(fn_name) + fn_name = BPF.add_prefix(b"kfunc__", fn_name) + + if fn_name not in self.kfunc_entry_fds: + raise Exception("Kernel entry func %s is not attached" % fn_name) + os.close(self.kfunc_entry_fds[fn_name]) + del self.kfunc_entry_fds[fn_name] + + def detach_kretfunc(self, fn_name=b""): + fn_name = _assert_is_bytes(fn_name) + fn_name = BPF.add_prefix(b"kretfunc__", fn_name) + + if fn_name not in self.kfunc_exit_fds: + raise Exception("Kernel exit func %s is not attached" % fn_name) + os.close(self.kfunc_exit_fds[fn_name]) + del self.kfunc_exit_fds[fn_name] + + def attach_kfunc(self, fn_name=b""): + fn_name = _assert_is_bytes(fn_name) + fn_name = BPF.add_prefix(b"kfunc__", fn_name) + + if fn_name in self.kfunc_entry_fds: + raise Exception("Kernel entry func %s has been attached" % fn_name) + + fn = self.load_func(fn_name, BPF.TRACING) + fd = lib.bpf_attach_kfunc(fn.fd) + if fd < 0: + raise Exception("Failed to attach BPF to entry kernel func") + self.kfunc_entry_fds[fn_name] = fd; + return self + + def attach_kretfunc(self, fn_name=b""): + fn_name = _assert_is_bytes(fn_name) + fn_name = BPF.add_prefix(b"kretfunc__", fn_name) + + if fn_name in self.kfunc_exit_fds: + raise Exception("Kernel exit func %s has been attached" % fn_name) + + fn = self.load_func(fn_name, BPF.TRACING) + fd = lib.bpf_attach_kfunc(fn.fd) + if fd < 0: + raise Exception("Failed to attach BPF to exit kernel func") + self.kfunc_exit_fds[fn_name] = fd; + return self + @staticmethod def support_raw_tracepoint(): # kernel symbol "bpf_find_raw_tracepoint" indicates raw_tracepoint support @@ -1124,6 +1183,10 @@ def _trace_autoload(self): fn = self.load_func(func_name, BPF.RAW_TRACEPOINT) tp = fn.name[len(b"raw_tracepoint__"):] self.attach_raw_tracepoint(tp=tp, fn_name=fn.name) + elif func_name.startswith(b"kfunc__"): + self.attach_kfunc(fn_name=func_name) + elif func_name.startswith(b"kretfunc__"): + self.attach_kretfunc(fn_name=func_name) def trace_open(self, nonblocking=False): """trace_open(nonblocking=False) @@ -1353,6 +1416,10 @@ def cleanup(self): self.detach_tracepoint(k) for k, v in list(self.raw_tracepoint_fds.items()): self.detach_raw_tracepoint(k) + for k, v in list(self.kfunc_entry_fds.items()): + self.detach_kfunc(k) + for k, v in list(self.kfunc_exit_fds.items()): + self.detach_kretfunc(k) # Clean up opened perf ring buffer and perf events table_keys = list(self.tables.keys()) From 1ad2656a1d9ca1e451ebad5af1330863c66a4035 Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Sun, 22 Dec 2019 12:29:22 +0100 Subject: [PATCH 021/278] Add support_kfunc function to BPF object Adding support_kfunc function to BPF object to return state of kfunc trampolines support. Signed-off-by: Jiri Olsa --- src/cc/libbpf.c | 5 +++++ src/cc/libbpf.h | 2 ++ src/python/bcc/__init__.py | 9 +++++++++ 3 files changed, 16 insertions(+) diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index f4c68bdeb..a610e01da 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -1160,6 +1160,11 @@ int bpf_attach_raw_tracepoint(int progfd, const char *tp_name) return ret; } +bool bpf_has_kernel_btf(void) +{ + return libbpf_find_vmlinux_btf_id("bpf_prog_put", 0); +} + int bpf_detach_kfunc(int prog_fd, char *func) { UNUSED(prog_fd); diff --git a/src/cc/libbpf.h b/src/cc/libbpf.h index 3f76083b6..b9bf11e51 100644 --- a/src/cc/libbpf.h +++ b/src/cc/libbpf.h @@ -98,6 +98,8 @@ int bpf_detach_kfunc(int prog_fd, char *func); int bpf_attach_kfunc(int prog_fd); +bool bpf_has_kernel_btf(void); + void * bpf_open_perf_buffer(perf_reader_raw_cb raw_cb, perf_reader_lost_cb lost_cb, void *cb_cookie, int pid, int cpu, int page_cnt); diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index dcffc0e5b..5b3ff7b2c 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -882,6 +882,15 @@ def add_prefix(prefix, name): name = prefix + name return name + @staticmethod + def support_kfunc(): + if not lib.bpf_has_kernel_btf(): + return False; + # kernel symbol "bpf_trampoline_link_prog" indicates kfunc support + if BPF.ksymname("bpf_trampoline_link_prog") != -1: + return True + return False + def detach_kfunc(self, fn_name=b""): fn_name = _assert_is_bytes(fn_name) fn_name = BPF.add_prefix(b"kfunc__", fn_name) From c347fe6c9f75d6740cf45f80312009daba275f76 Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Sun, 22 Dec 2019 15:52:39 +0100 Subject: [PATCH 022/278] Support kfunc in opensnoop.py Adding kfunc return trampoline probe if available instead of kprobe/kretprobe probes. The return trampoline has access to function entry arguments, so we are good with just single eBPF program. The kfunc trampolines are also faster - less intrusive. Below are stats for compiling linux kernel while running opensnoop.py on the background for kprobes and kfuncs. Without opensnoop.py: Performance counter stats for 'system wide': 849,741,782,765 cycles:k 162.235646336 seconds time elapsed With opensnoop.py using kprobes: Performance counter stats for 'system wide': 941,615,199,769 cycles:k 164.355032879 seconds time elapsed With opensnoop.py using trampolines: Performance counter stats for 'system wide': 913,437,005,488 cycles:k 163.742914795 seconds time elapsed Signed-off-by: Jiri Olsa --- tools/opensnoop.py | 45 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 42 insertions(+), 3 deletions(-) diff --git a/tools/opensnoop.py b/tools/opensnoop.py index 6d1388b3c..4f94d01d5 100755 --- a/tools/opensnoop.py +++ b/tools/opensnoop.py @@ -105,8 +105,11 @@ #if CGROUPSET BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); #endif -BPF_HASH(infotmp, u64, struct val_t); BPF_PERF_OUTPUT(events); +""" + +bpf_text_kprobe = """ +BPF_HASH(infotmp, u64, struct val_t); int trace_entry(struct pt_regs *ctx, int dfd, const char __user *filename, int flags) { @@ -162,6 +165,41 @@ return 0; } """ + +bpf_text_kfunc= """ +KRETFUNC_PROBE(do_sys_open, int dfd, const char *filename, int flags, int mode, int ret) +{ + u64 id = bpf_get_current_pid_tgid(); + u32 pid = id >> 32; // PID is higher part + u32 tid = id; // Cast and get the lower part + u32 uid = bpf_get_current_uid_gid(); + + PID_TID_FILTER + UID_FILTER + FLAGS_FILTER + + struct data_t data = {}; + bpf_get_current_comm(&data.comm, sizeof(data.comm)); + + u64 tsp = bpf_ktime_get_ns(); + + bpf_probe_read(&data.fname, sizeof(data.fname), (void *)filename); + data.id = id; + data.ts = tsp / 1000; + data.uid = bpf_get_current_uid_gid(); + data.flags = flags; // EXTENDED_STRUCT_MEMBER + data.ret = ret; + + events.perf_submit(ctx, &data, sizeof(data)); +} +""" + +is_support_kfunc = BPF.support_kfunc() +if is_support_kfunc: + bpf_text += bpf_text_kfunc +else: + bpf_text += bpf_text_kprobe + if args.tid: # TID trumps PID bpf_text = bpf_text.replace('PID_TID_FILTER', 'if (tid != %s) { return 0; }' % args.tid) @@ -195,8 +233,9 @@ # initialize BPF b = BPF(text=bpf_text) -b.attach_kprobe(event="do_sys_open", fn_name="trace_entry") -b.attach_kretprobe(event="do_sys_open", fn_name="trace_return") +if not is_support_kfunc: + b.attach_kprobe(event="do_sys_open", fn_name="trace_entry") + b.attach_kretprobe(event="do_sys_open", fn_name="trace_return") initial_ts = 0 From da7cac733c931f06801cc3ce118140892fcb8066 Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Mon, 23 Dec 2019 23:08:27 +0100 Subject: [PATCH 023/278] Support kfunc in klockstat.py Adding kfunc return trampoline probe if available instead of kprobe/kretprobe probes. The kfunc trampolines are faster - less intrusive. The benchmark without klockstat.py script on background: $ perf bench sched messaging -l 50000 # Running 'sched/messaging' benchmark: # 20 sender and receiver processes per group # 10 groups == 400 processes run Total time: 18.571 [sec] With kprobe tracing: $ perf bench sched messaging -l 50000 # Running 'sched/messaging' benchmark: # 20 sender and receiver processes per group # 10 groups == 400 processes run Total time: 183.395 [sec] With kfunc tracing: $ perf bench sched messaging -l 50000 # Running 'sched/messaging' benchmark: # 20 sender and receiver processes per group # 10 groups == 400 processes run Total time: 39.773 [sec] Signed-off-by: Jiri Olsa --- tools/klockstat.py | 55 ++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 48 insertions(+), 7 deletions(-) diff --git a/tools/klockstat.py b/tools/klockstat.py index e20478803..540dd4e7d 100755 --- a/tools/klockstat.py +++ b/tools/klockstat.py @@ -124,7 +124,7 @@ def stack_id_err(stack_id): return 1; } -int mutex_lock_enter(struct pt_regs *ctx) +static int do_mutex_lock_enter(void *ctx, int skip) { if (!is_enabled()) return 0; @@ -149,7 +149,7 @@ def stack_id_err(stack_id): return 0; } - int stackid = stack_traces.get_stackid(ctx, 0); + int stackid = stack_traces.get_stackid(ctx, skip); struct depth_id did = { .id = id, .depth = *depth, @@ -237,7 +237,7 @@ def stack_id_err(stack_id): } } -int mutex_lock_return(struct pt_regs *ctx) +static int do_mutex_lock_return(void) { if (!is_enabled()) return 0; @@ -285,7 +285,7 @@ def stack_id_err(stack_id): return 0; } -int mutex_unlock_enter(struct pt_regs *ctx) +static int do_mutex_unlock_enter(void) { if (!is_enabled()) return 0; @@ -330,9 +330,49 @@ def stack_id_err(stack_id): time_held.delete(&did); return 0; } +""" + +program_kprobe = """ +int mutex_unlock_enter(struct pt_regs *ctx) +{ + return do_mutex_unlock_enter(); +} + +int mutex_lock_return(struct pt_regs *ctx) +{ + return do_mutex_lock_return(); +} + +int mutex_lock_enter(struct pt_regs *ctx) +{ + return do_mutex_lock_enter(ctx, 0); +} +""" + +program_kfunc = """ +KFUNC_PROBE(mutex_unlock, void *lock) +{ + do_mutex_unlock_enter(); +} + +KRETFUNC_PROBE(mutex_lock, void *lock, int ret) +{ + do_mutex_lock_return(); +} + +KFUNC_PROBE(mutex_lock, void *lock) +{ + do_mutex_lock_enter(ctx, 3); +} """ +is_support_kfunc = BPF.support_kfunc() +if is_support_kfunc: + program += program_kfunc +else: + program += program_kprobe + def sort_list(maxs, totals, counts): if (not args.sort): return maxs; @@ -387,9 +427,10 @@ def display(sort, maxs, totals, counts): b = BPF(text=program) -b.attach_kprobe(event="mutex_unlock", fn_name="mutex_unlock_enter") -b.attach_kretprobe(event="mutex_lock", fn_name="mutex_lock_return") -b.attach_kprobe(event="mutex_lock", fn_name="mutex_lock_enter") +if not is_support_kfunc: + b.attach_kprobe(event="mutex_unlock", fn_name="mutex_unlock_enter") + b.attach_kretprobe(event="mutex_lock", fn_name="mutex_lock_return") + b.attach_kprobe(event="mutex_lock", fn_name="mutex_lock_enter") enabled = b.get_table("enabled"); From 2fa54c0bd388898fdda58f30dcfe5a68d6715efc Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Wed, 19 Feb 2020 18:48:44 +0100 Subject: [PATCH 024/278] Support kfunc in vfsstat.py Adding kfunc return trampoline probe if available instead of kprobe/kretprobe probes. The kfunc trampolines are faster - less intrusive. Below are stats for running perf bench sched pipe benchamark while running vfsstat.py on the background for kprobes and kfuncs. With kprobes: Performance counter stats for './perf bench sched pipe -l 5000000' (3 runs): 112,520,853,574 cycles:k 48.674 +- 0.672 seconds time elapsed ( +- 1.38% ) With kfuncs: Performance counter stats for './perf bench sched pipe -l 5000000' (3 runs): 106,304,165,424 cycles:k 46.820 +- 0.197 seconds time elapsed ( +- 0.42% ) Signed-off-by: Jiri Olsa --- tools/vfsstat.py | 34 +++++++++++++++++++++++++++------- 1 file changed, 27 insertions(+), 7 deletions(-) diff --git a/tools/vfsstat.py b/tools/vfsstat.py index 1764c6012..e044ce502 100755 --- a/tools/vfsstat.py +++ b/tools/vfsstat.py @@ -37,7 +37,7 @@ def usage(): usage() # load BPF program -b = BPF(text=""" +bpf_text = """ #include enum stat_types { @@ -55,18 +55,38 @@ def usage(): u64 *leaf = stats.lookup(&key); if (leaf) (*leaf)++; } +""" +bpf_text_kprobe = """ void do_read(struct pt_regs *ctx) { stats_increment(S_READ); } void do_write(struct pt_regs *ctx) { stats_increment(S_WRITE); } void do_fsync(struct pt_regs *ctx) { stats_increment(S_FSYNC); } void do_open(struct pt_regs *ctx) { stats_increment(S_OPEN); } void do_create(struct pt_regs *ctx) { stats_increment(S_CREATE); } -""") -b.attach_kprobe(event="vfs_read", fn_name="do_read") -b.attach_kprobe(event="vfs_write", fn_name="do_write") -b.attach_kprobe(event="vfs_fsync", fn_name="do_fsync") -b.attach_kprobe(event="vfs_open", fn_name="do_open") -b.attach_kprobe(event="vfs_create", fn_name="do_create") +""" + +bpf_text_kfunc = """ +KFUNC_PROBE(vfs_read, int unused) { stats_increment(S_READ); } +KFUNC_PROBE(vfs_write, int unused) { stats_increment(S_WRITE); } +KFUNC_PROBE(vfs_fsync, int unused) { stats_increment(S_FSYNC); } +KFUNC_PROBE(vfs_open, int unused) { stats_increment(S_OPEN); } +KFUNC_PROBE(vfs_create, int unused) { stats_increment(S_CREATE); } +""" + +is_support_kfunc = BPF.support_kfunc() +#is_support_kfunc = False #BPF.support_kfunc() +if is_support_kfunc: + bpf_text += bpf_text_kfunc +else: + bpf_text += bpf_text_kprobe + +b = BPF(text=bpf_text) +if not is_support_kfunc: + b.attach_kprobe(event="vfs_read", fn_name="do_read") + b.attach_kprobe(event="vfs_write", fn_name="do_write") + b.attach_kprobe(event="vfs_fsync", fn_name="do_fsync") + b.attach_kprobe(event="vfs_open", fn_name="do_open") + b.attach_kprobe(event="vfs_create", fn_name="do_create") # stat column labels and indexes stat_types = { From 6de96c71f11ace5091651c6cdf645a2d3426214b Mon Sep 17 00:00:00 2001 From: Yaxiong Zhao Date: Wed, 26 Feb 2020 10:35:49 -0800 Subject: [PATCH 025/278] Update StatusTuple to use enum Code --- src/cc/bcc_exception.h | 53 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 52 insertions(+), 1 deletion(-) diff --git a/src/cc/bcc_exception.h b/src/cc/bcc_exception.h index 7933adca7..744036f56 100644 --- a/src/cc/bcc_exception.h +++ b/src/cc/bcc_exception.h @@ -23,6 +23,22 @@ namespace ebpf { class StatusTuple { public: + enum class Code { + // Not an error, indicates success. + OK = 0, + // For any error that is not covered in the existing codes. + UNKNOWN, + + INVALID_ARGUMENT, + PERMISSION_DENIED, + // For any error that was raised when making syscalls. + SYSTEM, + }; + + static StatusTuple OK() { + return StatusTuple(Code::OK, ""); + } + StatusTuple(int ret) : ret_(ret) {} StatusTuple(int ret, const char *msg) : ret_(ret), msg_(msg) {} @@ -36,16 +52,34 @@ class StatusTuple { msg_ = std::string(buf); } + StatusTuple(Code code, const std::string &msg) : use_enum_code_(true), code_(code), msg_(msg) {} + void append_msg(const std::string& msg) { msg_ += msg; } - int code() const { return ret_; } + bool ok() const { + if (use_enum_code_) { + return code_ == Code::OK; + } + return ret_ == 0; + } + + int code() const { + if (use_enum_code_) { + return static_cast(code_); + } + return ret_; + } const std::string& msg() const { return msg_; } private: int ret_; + + bool use_enum_code_ = false; + Code code_; + std::string msg_; }; @@ -57,4 +91,21 @@ class StatusTuple { } \ } while (0) +namespace error { + +#define DECLARE_ERROR(FN, CODE) \ + inline StatusTuple FN(const std::string& msg) { \ + return StatusTuple(::ebpf::StatusTuple::Code::CODE, msg); \ + } \ + inline bool Is##FN(const StatusTuple& status) { \ + return status.code() == static_cast(::ebpf::StatusTuple::Code::CODE); \ + } + +DECLARE_ERROR(Unknown, UNKNOWN) +DECLARE_ERROR(InvalidArgument, INVALID_ARGUMENT) +DECLARE_ERROR(PermissionDenied, PERMISSION_DENIED) +DECLARE_ERROR(System, SYSTEM) + +} // namespace error + } // namespace ebpf From 440016f70b24e2913860e21eb2c2a6bbca970f0d Mon Sep 17 00:00:00 2001 From: FUJI Goro Date: Thu, 27 Feb 2020 13:41:43 +0900 Subject: [PATCH 026/278] doc: add python3 doc to "Ubuntu - Source" section in INSTALL.md --- INSTALL.md | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/INSTALL.md b/INSTALL.md index 80063f006..fbbab742d 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -118,7 +118,7 @@ sudo dnf install bcc **Note**: if you keep getting `Failed to load program: Operation not permitted` when trying to run the `hello_world.py` example as root then you might need to lift -the so-called kernel lockdown (cf. +the so-called kernel lockdown (cf. [FAQ](https://github.com/iovisor/bcc/blob/c00d10d4552f647491395e326d2e4400f3a0b6c5/FAQ.txt#L24), [background article](https://gehrcke.de/2019/09/running-an-ebpf-program-may-require-lifting-the-kernel-lockdown)). @@ -352,12 +352,18 @@ sudo apt-get -y install luajit luajit-5.1-dev ``` ### Install and compile BCC + ``` git clone https://github.com/iovisor/bcc.git mkdir bcc/build; cd bcc/build cmake .. -DCMAKE_INSTALL_PREFIX=/usr make sudo make install +cmake -DPYTHON_CMD=python3 .. # build python3 binding +pushd src/python/ +make +sudo make install +popd ``` ## Fedora - Source From c46c7b3d4203adbbc964c25451b918c0df5d94ff Mon Sep 17 00:00:00 2001 From: FUJI Goro Date: Mon, 2 Mar 2020 17:22:29 +0900 Subject: [PATCH 027/278] usdt.py: improve error messags for enable_probe() --- src/python/bcc/usdt.py | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/src/python/bcc/usdt.py b/src/python/bcc/usdt.py index 5fb1cda4d..aa8f5e6c7 100644 --- a/src/python/bcc/usdt.py +++ b/src/python/bcc/usdt.py @@ -149,20 +149,18 @@ def enable_probe(self, probe, fn_name): if lib.bcc_usdt_enable_probe(self.context, probe.encode('ascii'), fn_name.encode('ascii')) != 0: raise USDTException( - ("failed to enable probe '%s'; a possible cause " + - "can be that the probe requires a pid to enable") % - probe - ) +"""Failed to enable USDT probe '%s': +the specified pid might not contain the given language's runtime, +or the runtime was not built with the required USDT probes. Look +for a configure flag similar to --with-dtrace or --enable-dtrace. +To check which probes are present in the process, use the tplist tool. +""" % probe) def enable_probe_or_bail(self, probe, fn_name): - if lib.bcc_usdt_enable_probe(self.context, probe.encode('ascii'), - fn_name.encode('ascii')) != 0: - print( -"""Error attaching USDT probes: the specified pid might not contain the -given language's runtime, or the runtime was not built with the required -USDT probes. Look for a configure flag similar to --with-dtrace or ---enable-dtrace. To check which probes are present in the process, use the -tplist tool.""") + try: + self.enable_probe(probe, fn_name) + except USDTException as e: + print(e) sys.exit(1) def get_context(self): From 17ff39223a4dd2ff28f63239cb82f785e47ba45c Mon Sep 17 00:00:00 2001 From: Andrii Nakryiko Date: Tue, 3 Mar 2020 15:19:00 -0800 Subject: [PATCH 028/278] libbpf-tools: update bpftool Newer bpftool generates vmlinux.h with header guard `#define`, which plays nicely with bpf_tracing.h header and PT_REGS_PARM macros. Signed-off-by: Andrii Nakryiko --- libbpf-tools/bin/bpftool | Bin 2371800 -> 2376176 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/libbpf-tools/bin/bpftool b/libbpf-tools/bin/bpftool index a58ab1abf660d1412f7554efc5f5b62d686cda2f..51d90694310a71b9fe0bba21172e1e616f2e15dc 100755 GIT binary patch delta 505789 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�%z3BDgumk`@t9V7bde2 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 Date: Wed, 4 Mar 2020 04:31:27 +0000 Subject: [PATCH 029/278] libbpf-tools: covert BCC drsnoop to BPF CO-RE version Signed-off-by: Wenbo Zhang --- libbpf-tools/Makefile | 8 +- libbpf-tools/drsnoop.bpf.c | 95 ++++++++++++ libbpf-tools/drsnoop.c | 240 +++++++++++++++++++++++++++++++ libbpf-tools/drsnoop.h | 15 ++ libbpf-tools/drsnoop_example.txt | 71 +++++++++ libbpf-tools/trace_helpers.c | 166 +++++++++++++++++++++ libbpf-tools/trace_helpers.h | 21 +++ man/man8/compactsnoop.8 | 2 +- man/man8/drsnoop.8 | 2 +- snap/snapcraft.yaml | 2 + tools/drsnoop.py | 6 +- 11 files changed, 620 insertions(+), 8 deletions(-) create mode 100644 libbpf-tools/drsnoop.bpf.c create mode 100644 libbpf-tools/drsnoop.c create mode 100644 libbpf-tools/drsnoop.h create mode 100644 libbpf-tools/drsnoop_example.txt create mode 100644 libbpf-tools/trace_helpers.c create mode 100644 libbpf-tools/trace_helpers.h diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index cf7f8afe9..985278d1b 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -8,7 +8,7 @@ LIBBPF_OBJ := $(abspath $(OUTPUT)/libbpf.a) INCLUDES := -I$(OUTPUT) CFLAGS := -g -Wall -APPS = runqslower +APPS = drsnoop runqslower .PHONY: all all: $(APPS) @@ -31,11 +31,13 @@ $(OUTPUT) $(OUTPUT)/libbpf: $(call msg,MKDIR,$@) $(Q)mkdir -p $@ -$(APPS): %: $(OUTPUT)/%.o $(LIBBPF_OBJ) | $(OUTPUT) +$(APPS): %: $(OUTPUT)/%.o $(LIBBPF_OBJ) $(OUTPUT)/trace_helpers.o | $(OUTPUT) $(call msg,BINARY,$@) $(Q)$(CC) $(CFLAGS) $^ -lelf -lz -o $@ -$(OUTPUT)/%.o: %.c $(OUTPUT)/%.skel.h $(wildcard %.h) | $(OUTPUT) +$(patsubst %,$(OUTPUT)/%.o,$(APPS)): %.o: %.skel.h + +$(OUTPUT)/%.o: %.c $(wildcard %.h) | $(OUTPUT) $(call msg,CC,$@) $(Q)$(CC) $(CFLAGS) $(INCLUDES) -c $(filter %.c,$^) -o $@ diff --git a/libbpf-tools/drsnoop.bpf.c b/libbpf-tools/drsnoop.bpf.c new file mode 100644 index 000000000..d6662a1e4 --- /dev/null +++ b/libbpf-tools/drsnoop.bpf.c @@ -0,0 +1,95 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include +#include "drsnoop.h" + +#define BPF_F_INDEX_MASK 0xffffffffULL +#define BPF_F_CURRENT_CPU BPF_F_INDEX_MASK + +const volatile pid_t targ_pid = 0; +const volatile pid_t targ_tgid = 0; +const volatile __u64 vm_zone_stat_kaddr = 0; + +struct piddata { + u64 ts; + u64 nr_free_pages; +}; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, 8192); + __type(key, u32); + __type(value, struct piddata); +} start SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY); + __uint(key_size, sizeof(u32)); + __uint(value_size, sizeof(u32)); +} events SEC(".maps"); + +SEC("tp_btf/mm_vmscan_direct_reclaim_begin") +int handle__mm_vmscan_direct_reclaim_begin(u64 *ctx) +{ + u64 *vm_zone_stat_kaddrp = (u64*)vm_zone_stat_kaddr; + u64 id = bpf_get_current_pid_tgid(); + struct piddata piddata = {}; + u32 tgid = id >> 32; + u32 pid = id; + + if (targ_tgid && targ_tgid != tgid) + return 0; + if (targ_pid && targ_pid != pid) + return 0; + + piddata.ts = bpf_ktime_get_ns(); + if (vm_zone_stat_kaddrp) { + bpf_probe_read(&piddata.nr_free_pages, + sizeof(*vm_zone_stat_kaddrp), + &vm_zone_stat_kaddrp[NR_FREE_PAGES]); + } + + bpf_map_update_elem(&start, &pid, &piddata, 0); + return 0; +} + +SEC("tp_btf/mm_vmscan_direct_reclaim_end") +int handle__mm_vmscan_direct_reclaim_end(u64 *ctx) +{ + u64 id = bpf_get_current_pid_tgid(); + /* TP_PROTO(unsigned long nr_reclaimed) */ + u64 nr_reclaimed = ctx[0]; + struct piddata *piddatap; + struct event event = {}; + u32 tgid = id >> 32; + u32 pid = id; + u64 delta_ns; + + if (targ_tgid && targ_tgid != tgid) + return 0; + if (targ_pid && targ_pid != pid) + return 0; + + /* fetch timestamp and calculate delta */ + piddatap = bpf_map_lookup_elem(&start, &pid); + if (!piddatap) + return 0; /* missed entry */ + + delta_ns = bpf_ktime_get_ns() - piddatap->ts; + + event.pid = pid; + event.nr_reclaimed = nr_reclaimed; + event.delta_ns = delta_ns; + event.nr_free_pages = piddatap->nr_free_pages; + bpf_get_current_comm(&event.task, TASK_COMM_LEN); + + /* output */ + bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, + &event, sizeof(event)); + + bpf_map_delete_elem(&start, &pid); + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/drsnoop.c b/libbpf-tools/drsnoop.c new file mode 100644 index 000000000..a31626f9c --- /dev/null +++ b/libbpf-tools/drsnoop.c @@ -0,0 +1,240 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on drsnoop(8) from BCC by Wenbo Zhang. +// 28-Feb-2020 Wenbo Zhang Created this. +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "drsnoop.h" +#include "drsnoop.skel.h" +#include "trace_helpers.h" + +#define PERF_BUFFER_PAGES 16 +#define PERF_POLL_TIMEOUT_MS 100 + +static struct env { + pid_t pid; + pid_t tid; + time_t duration; + bool extended; + bool verbose; +} env = { }; + +const char *argp_program_version = "drsnoop 0.1"; +const char *argp_program_bug_address = ""; +const char argp_program_doc[] = +"Trace direct reclaim latency.\n" +"\n" +"USAGE: drsnoop [--help] [-p PID] [-t TID] [-d DURATION] [-e]\n" +"\n" +"EXAMPLES:\n" +" drsnoop # trace all direct reclaim events\n" +" drsnoop -p 123 # trace pid 123\n" +" drsnoop -t 123 # trace tid 123 (use for threads only)\n" +" drsnoop -d 10 # trace for 10 seconds only\n" +" drsnoop -e # trace all direct reclaim events with extended faileds\n"; + +static const struct argp_option opts[] = { + { "duration", 'd', "DURATION", 0, "Total duration of trace in seconds" }, + { "extended", 'e', NULL, 0, "Extended fields output" }, + { "pid", 'p', "PID", 0, "Process PID to trace" }, + { "tid", 't', "TID", 0, "Thread TID to trace" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static int page_size; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + time_t duration; + int pid; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'd': + errno = 0; + duration = strtol(arg, NULL, 10); + if (errno || duration <= 0) { + fprintf(stderr, "invalid DURATION: %s\n", arg); + argp_usage(state); + } + env.duration = duration; + break; + case 'e': + env.extended = true; + break; + case 'p': + errno = 0; + pid = strtol(arg, NULL, 10); + if (errno || pid <= 0) { + fprintf(stderr, "invalid PID: %s\n", arg); + argp_usage(state); + } + env.pid = pid; + break; + case 't': + errno = 0; + pid = strtol(arg, NULL, 10); + if (errno || pid <= 0) { + fprintf(stderr, "invalid TID: %s\n", arg); + argp_usage(state); + } + env.tid = pid; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static int bump_memlock_rlimit(void) +{ + struct rlimit rlim_new = { + .rlim_cur = RLIM_INFINITY, + .rlim_max = RLIM_INFINITY, + }; + + return setrlimit(RLIMIT_MEMLOCK, &rlim_new); +} + +void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) +{ + const struct event *e = data; + struct tm *tm; + char ts[32]; + time_t t; + + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + printf("%-8s %-16s %-6d %8.3f %5lld", + ts, e->task, e->pid, (double)e->delta_ns / 1000000, + e->nr_reclaimed); + if (env.extended) + printf(" %8llu", e->nr_free_pages * page_size / 1024); + printf("\n"); +} + +void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt) +{ + fprintf(stderr, "lost %llu events on CPU #%d\n", lost_cnt, cpu); +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct perf_buffer_opts pb_opts; + struct perf_buffer *pb = NULL; + struct ksyms *ksyms = NULL; + const struct ksym *ksym; + struct drsnoop_bpf *obj; + time_t start_time; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = drsnoop_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + return 1; + } + + /* initialize global data (filtering options) */ + obj->rodata->targ_tgid = env.pid; + obj->rodata->targ_pid = env.tid; + if (env.extended) { + ksyms = ksyms__load(); + if (!ksyms) { + fprintf(stderr, "failed to load kallsyms\n"); + goto cleanup; + } + ksym = ksyms__get_symbol(ksyms, "vm_zone_stat"); + if (!ksym) { + fprintf(stderr, "failed to get vm_zone_stat's addr\n"); + goto cleanup; + } + obj->rodata->vm_zone_stat_kaddr = ksym->addr; + page_size = sysconf(_SC_PAGESIZE); + } + + err = drsnoop_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + err = drsnoop_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs\n"); + goto cleanup; + } + + printf("Tracing direct reclaim events"); + if (env.duration) + printf(" for %ld secs.\n", env.duration); + else + printf("... Hit Ctrl-C to end.\n"); + printf("%-8s %-16s %-6s %8s %5s", + "TIME", "COMM", "TID", "LAT(ms)", "PAGES"); + if (env.extended) + printf(" %8s", "FREE(KB)"); + printf("\n"); + + pb_opts.sample_cb = handle_event; + pb_opts.lost_cb = handle_lost_events; + pb = perf_buffer__new(bpf_map__fd(obj->maps.events), PERF_BUFFER_PAGES, + &pb_opts); + err = libbpf_get_error(pb); + if (err) { + pb = NULL; + fprintf(stderr, "failed to open perf buffer: %d\n", err); + goto cleanup; + } + + start_time = time(NULL); + while (!env.duration || time(NULL) - start_time < env.duration) { + if ((err = perf_buffer__poll(pb, PERF_POLL_TIMEOUT_MS)) < 0) { + printf("error polling perf buffer: %d\n", err); + break; + } + } + +cleanup: + perf_buffer__free(pb); + drsnoop_bpf__destroy(obj); + ksyms__free(ksyms); + + return err != 0; +} diff --git a/libbpf-tools/drsnoop.h b/libbpf-tools/drsnoop.h new file mode 100644 index 000000000..bdd5b7d5d --- /dev/null +++ b/libbpf-tools/drsnoop.h @@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __DRSNOOP_H +#define __DRSNOOP_H + +#define TASK_COMM_LEN 16 + +struct event { + char task[TASK_COMM_LEN]; + __u64 delta_ns; + __u64 nr_reclaimed; + __u64 nr_free_pages; + pid_t pid; +}; + +#endif /* __DRSNOOP_H */ diff --git a/libbpf-tools/drsnoop_example.txt b/libbpf-tools/drsnoop_example.txt new file mode 100644 index 000000000..ae96c31ef --- /dev/null +++ b/libbpf-tools/drsnoop_example.txt @@ -0,0 +1,71 @@ +Demonstrations of drsnoop, the Linux BPF CO-RE version. + + +drsnoop traces the direct reclaim system-wide, and prints various details. +Example output: + +# drsnoop + +Tracing direct reclaim events... Hit Ctrl-C to end. +TIME COMM TID LAT(ms) PAGES +14:56:43 in:imklog 268 106.637 39 +14:56:43 systemd-udevd 232 110.708 53 +14:56:43 systemd-journal 19531 106.083 62 +^C + +While tracing, the processes alloc pages due to insufficient memory available +in the system, direct reclaim events happened, which will increase the waiting +delay of the processes. + +drsnoop can be useful for discovering when allocstall(/proc/vmstat) continues +to increase, whether it is caused by some critical processes or not. + +The -p option can be used to filter on a PID, which is filtered in-kernel. + +# drsnoop -p 17491 + +Tracing direct reclaim events... Hit Ctrl-C to end. +TIME COMM TID LAT(ms) PAGES +14:59:56 summond 17491 0.24 50 +14:59:56 summond 17491 0.26 38 +14:59:56 summond 17491 0.36 72 +^C + +This shows the summond process allocs pages, and direct reclaim events happening, +and the delays are not affected much. + +A maximum tracing duration can be set with the -d option. For example, to trace +for 2 seconds: + +# drsnoop -d 2 + +Tracing direct reclaim events for 2 secs. +TIME COMM TID LAT(ms) PAGES +15:02:16 head 21715 0.15 195 + +USAGE message: + +# drsnoop --help + +Usage: drsnoop [OPTION...] +Trace direct reclaim latency. + +USAGE: drsnoop [--help] [-p PID] [-t TID] [-d DURATION] [-e] + +EXAMPLES: + drsnoop # trace all direct reclaim events + drsnoop -p 123 # trace pid 123 + drsnoop -t 123 # trace tid 123 (use for threads only) + drsnoop -d 10 # trace for 10 seconds only + drsnoop -e # trace all direct reclaim events with extended faileds + + -d, --duration=DURATION Total duration of trace in seconds + -e, --extended Extended fields output + -p, --pid=PID Process PID to trace + -t, --tid=TID Thread TID to trace + -v, --verbose Verbose debug output + -?, --help Give this help list + --usage Give a short usage message + -V, --version Print program version + +Report bugs to . diff --git a/libbpf-tools/trace_helpers.c b/libbpf-tools/trace_helpers.c new file mode 100644 index 000000000..46cff337f --- /dev/null +++ b/libbpf-tools/trace_helpers.c @@ -0,0 +1,166 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#include +#include +#include +#include +#include "trace_helpers.h" + +#define MAX_SYMS 300000 + +static int ksyms__insert_symbol(struct ksyms *ksyms, long addr, + const char *name) +{ + struct ksym *ksym = &ksyms->syms[ksyms->syms_cnt++]; + size_t len = strlen(name) + 1; + + ksym->name = malloc(len); + if (!ksym->name) + return -1; + + memcpy((void*)ksym->name, name, len); + ksym->addr = addr; + return 0; +} + +static struct ksyms *ksyms__new(void) +{ + struct ksyms *ksyms = malloc(sizeof(*ksyms)); + + if (!ksyms) + return NULL; + + ksyms->syms_cnt = 0; + ksyms->syms = malloc(MAX_SYMS * sizeof(struct ksym)); + if (!ksyms->syms) + return NULL; + return ksyms; +} + +static int ksym_cmp(const void *p1, const void *p2) +{ + long cmp = ((struct ksym *)p1)->addr - ((struct ksym *)p2)->addr; + + if (cmp < 0) + return -1; + else if (cmp > 0) + return 1; + else + return 0; +} + +static int hex2long(const char *ptr, long *long_val) +{ + char *p; + + *long_val = strtoul(ptr, &p, 16); + return p - ptr; +} + +struct ksyms *ksyms__load(void) +{ + FILE *f = fopen("/proc/kallsyms", "r"); + const char *symbol_name; + struct ksyms *ksyms; + char *line = NULL; + long symbol_addr; + int line_len; + int parsed; + size_t n; + int err; + + if (!f) + return NULL; + + ksyms = ksyms__new(); + if (!ksyms) + goto cleanup; + + while (!feof(f)) { + line_len = getline(&line, &n, f); + if (line_len < 0 || !line) + break; + + line[--line_len] = '\0'; /* \n */ + + parsed = hex2long(line, &symbol_addr); + + /* Skip the line if we failed to parse the address. */ + if (!parsed) + continue; + + parsed++; + if (parsed + 2 >= line_len) + continue; + + parsed += 2; /* ignore symbol type */ + symbol_name = line + parsed; + parsed = line_len - parsed; + + err = ksyms__insert_symbol(ksyms, symbol_addr, symbol_name); + if (err) + goto cleanup; + } + + qsort(ksyms->syms, ksyms->syms_cnt, sizeof(struct ksym), ksym_cmp); + return ksyms; + +cleanup: + free(line); + fclose(f); + return NULL; +} + +void ksyms__free(struct ksyms *ksyms) +{ + int i; + + if (!ksyms) + return; + + for (i = 0; i < ksyms->syms_cnt; i++) { + free((void*)ksyms->syms[i].name); + } + free(ksyms); +} + +const struct ksym *ksyms__map_addr(const struct ksyms *ksyms, long addr) +{ + int start = 0, end = ksyms->syms_cnt; + long result; + + /* kallsyms not loaded. return NULL */ + if (ksyms->syms_cnt == 0) + return NULL; + + while (start < end) { + size_t mid = start + (end - start) / 2; + + result = addr - ksyms->syms[mid].addr; + if (result < 0) + end = mid; + else if (result > 0) + start = mid + 1; + else + return &ksyms->syms[mid]; + } + + if (start >= 1 && ksyms->syms[start - 1].addr < addr && + addr < ksyms->syms[start].addr) + /* valid ksym */ + return &ksyms->syms[start - 1]; + + return NULL; +} + +const struct ksym *ksyms__get_symbol(const struct ksyms *ksyms, + const char *name) +{ + int i; + + for (i = 0; i < ksyms->syms_cnt; i++) { + if (strcmp(ksyms->syms[i].name, name) == 0) + return &ksyms->syms[i]; + } + + return NULL; +} diff --git a/libbpf-tools/trace_helpers.h b/libbpf-tools/trace_helpers.h new file mode 100644 index 000000000..d2c06d7de --- /dev/null +++ b/libbpf-tools/trace_helpers.h @@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __TRACE_HELPERS_H +#define __TRACE_HELPERS_H + +struct ksym { + long addr; + const char *name; +}; + +struct ksyms { + struct ksym *syms; + int syms_cnt; +}; + +struct ksyms *ksyms__load(void); +void ksyms__free(struct ksyms *ksyms); +const struct ksym *ksyms__map_addr(const struct ksyms *ksyms, long addr); +const struct ksym *ksyms__get_symbol(const struct ksyms *ksyms, + const char *name); + +#endif /* __TRACE_HELPERS_H */ diff --git a/man/man8/compactsnoop.8 b/man/man8/compactsnoop.8 index 8479e8095..a2933d7a2 100644 --- a/man/man8/compactsnoop.8 +++ b/man/man8/compactsnoop.8 @@ -176,4 +176,4 @@ Linux .SH STABILITY Unstable - in development. .SH AUTHOR -Ethercflow +Wenbo Zhang diff --git a/man/man8/drsnoop.8 b/man/man8/drsnoop.8 index c4ba2686b..572c0dceb 100644 --- a/man/man8/drsnoop.8 +++ b/man/man8/drsnoop.8 @@ -107,4 +107,4 @@ Linux .SH STABILITY Unstable - in development. .SH AUTHOR -Ethercflow +Wenbo Zhang diff --git a/snap/snapcraft.yaml b/snap/snapcraft.yaml index 500cb9203..950ed7d44 100644 --- a/snap/snapcraft.yaml +++ b/snap/snapcraft.yaml @@ -135,6 +135,8 @@ apps: command: bcc-wrapper dcstat deadlock: command: bcc-wrapper deadlock + drsnoop: + command: bcc-wrapper drsnoop execsnoop: command: bcc-wrapper execsnoop ext4dist: diff --git a/tools/drsnoop.py b/tools/drsnoop.py index c77f52064..3dc8d7abe 100755 --- a/tools/drsnoop.py +++ b/tools/drsnoop.py @@ -8,11 +8,11 @@ # direct reclaim begin, as well as a starting timestamp for calculating # latency. # -# Copyright (c) 2019 Ethercflow +# Copyright (c) 2019 Wenbo Zhang # Licensed under the Apache License, Version 2.0 (the "License") # -# 20-Feb-2019 Ethercflow Created this. -# 09-Mar-2019 Ethercflow Updated for show sys mem info. +# 20-Feb-2019 Wenbo Zhang Created this. +# 09-Mar-2019 Wenbo Zhang Updated for show sys mem info. from __future__ import print_function from bcc import ArgString, BPF From aeea0e9fce7e868f27cac45f5d6ab4f67c383c62 Mon Sep 17 00:00:00 2001 From: FUJI Goro Date: Tue, 3 Mar 2020 00:01:01 -0800 Subject: [PATCH 030/278] usdt.py: print errors to stderr in enable_probe_or_bail() --- src/python/bcc/usdt.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/python/bcc/usdt.py b/src/python/bcc/usdt.py index aa8f5e6c7..cd2557847 100644 --- a/src/python/bcc/usdt.py +++ b/src/python/bcc/usdt.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +from __future__ import print_function import ctypes as ct import os, sys from .libbcc import lib, _USDT_CB, _USDT_PROBE_CB, \ @@ -160,7 +161,7 @@ def enable_probe_or_bail(self, probe, fn_name): try: self.enable_probe(probe, fn_name) except USDTException as e: - print(e) + print(e, file=sys.stderr) sys.exit(1) def get_context(self): From 5011f992b3167c162b5a0ad57fd3fa23c9ea76b3 Mon Sep 17 00:00:00 2001 From: Nick Gasson Date: Tue, 25 Feb 2020 13:01:36 +0800 Subject: [PATCH 031/278] usdt: fix parsing sp register in arguments on AArch64 One of the USDT probes for OpenJDK on AArch64 has an argument as an offset from the stack pointer register like "8@[sp, 112]". This causes the argument parser to fail: Parse error: 8@x22 8@x20 8@x23 8@x0 8@x26 8@x27 8@[sp, 112] 8@[sp, 120] ------------------------------------------^ The error message then repeats forever. Changed ArgumentParser_aarch64::parse_register so it accepts either "xNN" or "sp" and outputs the register name rather than the register number. The stack pointer is in a separate field `sp` in `struct pt_regs` rather than in the `regs[]` array [1]. Note that the parser currently accepts "x31" and converts that into a reference to `regs[31]' but that array only has 31 elements. Made x31 an alias for `sp` to avoid undefined behaviour from reading past the end of the array. [1]: https://elixir.bootlin.com/linux/latest/source/arch/arm64/include/asm/ptrace.h#L160 Change-Id: I88b6ff741914b5d06ad5798a55bd21ea03f69825 Signed-off-by: Nick Gasson --- src/cc/usdt.h | 6 +++-- src/cc/usdt/usdt_args.cc | 46 +++++++++++++++++++++++++------------- tests/cc/test_usdt_args.cc | 7 ++++-- 3 files changed, 40 insertions(+), 19 deletions(-) diff --git a/src/cc/usdt.h b/src/cc/usdt.h index b32e8f38f..800beeb72 100644 --- a/src/cc/usdt.h +++ b/src/cc/usdt.h @@ -102,6 +102,8 @@ class ArgumentParser { } bool error_return(ssize_t error_start, ssize_t skip_start) { print_error(error_start); + if (isspace(arg_[skip_start])) + skip_start++; // Make sure we skip at least one character skip_until_whitespace_from(skip_start); return false; } @@ -115,9 +117,9 @@ class ArgumentParser { class ArgumentParser_aarch64 : public ArgumentParser { private: - bool parse_register(ssize_t pos, ssize_t &new_pos, optional *reg_num); + bool parse_register(ssize_t pos, ssize_t &new_pos, std::string ®_name); bool parse_size(ssize_t pos, ssize_t &new_pos, optional *arg_size); - bool parse_mem(ssize_t pos, ssize_t &new_pos, optional *reg_num, + bool parse_mem(ssize_t pos, ssize_t &new_pos, std::string ®_name, optional *offset); public: diff --git a/src/cc/usdt/usdt_args.cc b/src/cc/usdt/usdt_args.cc index a6a04b9a4..3bf194635 100644 --- a/src/cc/usdt/usdt_args.cc +++ b/src/cc/usdt/usdt_args.cc @@ -133,11 +133,27 @@ void ArgumentParser::skip_until_whitespace_from(size_t pos) { } bool ArgumentParser_aarch64::parse_register(ssize_t pos, ssize_t &new_pos, - optional *reg_num) { - new_pos = parse_number(pos, reg_num); - if (new_pos == pos || *reg_num < 0 || *reg_num > 31) + std::string ®_name) { + if (arg_[pos] == 'x') { + optional reg_num; + new_pos = parse_number(pos + 1, ®_num); + if (new_pos == pos + 1 || *reg_num < 0 || *reg_num > 31) + return error_return(pos + 1, pos + 1); + + if (*reg_num == 31) { + reg_name = "sp"; + } else { + reg_name = "regs[" + std::to_string(reg_num.value()) + "]"; + } + + return true; + } else if (arg_[pos] == 's' && arg_[pos + 1] == 'p') { + reg_name = "sp"; + new_pos = pos + 2; + return true; + } else { return error_return(pos, pos); - return true; + } } bool ArgumentParser_aarch64::parse_size(ssize_t pos, ssize_t &new_pos, @@ -156,11 +172,9 @@ bool ArgumentParser_aarch64::parse_size(ssize_t pos, ssize_t &new_pos, } bool ArgumentParser_aarch64::parse_mem(ssize_t pos, ssize_t &new_pos, - optional *reg_num, + std::string ®_name, optional *offset) { - if (arg_[pos] != 'x') - return error_return(pos, pos); - if (parse_register(pos + 1, new_pos, reg_num) == false) + if (parse_register(pos, new_pos, reg_name) == false) return false; if (arg_[new_pos] == ',') { @@ -195,20 +209,22 @@ bool ArgumentParser_aarch64::parse(Argument *dest) { return error_return(new_pos, new_pos); cur_pos = new_pos + 1; - if (arg_[cur_pos] == 'x') { + if (arg_[cur_pos] == 'x' || arg_[cur_pos] == 's') { // Parse ...@ - optional reg_num; - if (parse_register(cur_pos + 1, new_pos, ®_num) == false) + std::string reg_name; + if (parse_register(cur_pos, new_pos, reg_name) == false) return false; + cur_pos_ = new_pos; - dest->base_register_name_ = "regs[" + std::to_string(reg_num.value()) + "]"; + dest->base_register_name_ = reg_name; } else if (arg_[cur_pos] == '[') { // Parse ...@[] and ...@[] - optional reg_num, offset = 0; - if (parse_mem(cur_pos + 1, new_pos, ®_num, &offset) == false) + optional offset = 0; + std::string reg_name; + if (parse_mem(cur_pos + 1, new_pos, reg_name, &offset) == false) return false; cur_pos_ = new_pos; - dest->base_register_name_ = "regs[" + std::to_string(reg_num.value()) + "]"; + dest->base_register_name_ = reg_name; dest->deref_offset_ = offset; } else { // Parse ...@ diff --git a/tests/cc/test_usdt_args.cc b/tests/cc/test_usdt_args.cc index db1f8c8e6..c2c5fff36 100644 --- a/tests/cc/test_usdt_args.cc +++ b/tests/cc/test_usdt_args.cc @@ -74,11 +74,14 @@ TEST_CASE("test usdt argument parsing", "[usdt]") { } SECTION("argument examples from the Python implementation") { #ifdef __aarch64__ - USDT::ArgumentParser_aarch64 parser("-1@x0 4@5 8@[x12] -4@[x31,-40]"); + USDT::ArgumentParser_aarch64 parser( + "-1@x0 4@5 8@[x12] -4@[x30,-40] -4@[x31,-40] 8@[sp, 120]"); verify_register(parser, -1, "regs[0]"); verify_register(parser, 4, 5); verify_register(parser, 8, "regs[12]", 0); - verify_register(parser, -4, "regs[31]", -40); + verify_register(parser, -4, "regs[30]", -40); + verify_register(parser, -4, "sp", -40); + verify_register(parser, 8, "sp", 120); #elif __powerpc64__ USDT::ArgumentParser_powerpc64 parser( "-4@0 8@%r0 8@i0 4@0(%r0) -2@0(0) " From e508059878525159ccff8c3672d36ecb03b27dac Mon Sep 17 00:00:00 2001 From: Yaxiong Zhao Date: Fri, 6 Mar 2020 11:01:47 -0800 Subject: [PATCH 032/278] Replace StatusTuple(0) with StatusTuple::OK() With the following shell command: $ find src -type f -regex '.*\.\(h\|cc\)' -exec sed -i 's/StatusTuple(0)/StatusTuple::OK()/' {} \; --- src/cc/api/BPF.cc | 66 +++++++++++----------- src/cc/api/BPFTable.cc | 68 +++++++++++----------- src/cc/api/BPFTable.h | 26 ++++----- src/cc/bpf_module_rw_engine.cc | 2 +- src/cc/frontends/b/codegen_llvm.cc | 90 +++++++++++++++--------------- src/cc/frontends/b/printer.cc | 58 +++++++++---------- src/cc/frontends/b/type_check.cc | 68 +++++++++++----------- 7 files changed, 189 insertions(+), 189 deletions(-) diff --git a/src/cc/api/BPF.cc b/src/cc/api/BPF.cc index 2fea44cd2..4bb15918c 100644 --- a/src/cc/api/BPF.cc +++ b/src/cc/api/BPF.cc @@ -64,7 +64,7 @@ StatusTuple BPF::init_usdt(const USDT& usdt) { usdt_.push_back(std::move(u)); all_bpf_program_ += usdt_.back().program_text_; - return StatusTuple(0); + return StatusTuple::OK(); } void BPF::init_fail_reset() { @@ -95,7 +95,7 @@ StatusTuple BPF::init(const std::string& bpf_program, return StatusTuple(-1, "Unable to initialize BPF program"); } - return StatusTuple(0); + return StatusTuple::OK(); }; BPF::~BPF() { @@ -187,7 +187,7 @@ StatusTuple BPF::detach_all() { if (has_error) return StatusTuple(-1, error_msg); else - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::attach_kprobe(const std::string& kernel_func, @@ -217,7 +217,7 @@ StatusTuple BPF::attach_kprobe(const std::string& kernel_func, p.perf_event_fd = res_fd; p.func = probe_func; kprobes_[probe_event] = std::move(p); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::attach_uprobe(const std::string& binary_path, @@ -261,7 +261,7 @@ StatusTuple BPF::attach_uprobe(const std::string& binary_path, p.perf_event_fd = res_fd; p.func = probe_func; uprobes_[probe_event] = std::move(p); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::attach_usdt(const USDT& usdt, pid_t pid) { @@ -296,7 +296,7 @@ StatusTuple BPF::attach_usdt(const USDT& usdt, pid_t pid) { } return StatusTuple(-1, err_msg); } else { - return StatusTuple(0); + return StatusTuple::OK(); } } } @@ -332,7 +332,7 @@ StatusTuple BPF::attach_tracepoint(const std::string& tracepoint, p.perf_event_fd = res_fd; p.func = probe_func; tracepoints_[tracepoint] = std::move(p); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::attach_raw_tracepoint(const std::string& tracepoint, const std::string& probe_func) { @@ -355,7 +355,7 @@ StatusTuple BPF::attach_raw_tracepoint(const std::string& tracepoint, const std: p.perf_event_fd = res_fd; p.func = probe_func; raw_tracepoints_[tracepoint] = std::move(p); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::attach_perf_event(uint32_t ev_type, uint32_t ev_config, @@ -395,7 +395,7 @@ StatusTuple BPF::attach_perf_event(uint32_t ev_type, uint32_t ev_config, p.func = probe_func; p.per_cpu_fd = fds; perf_events_[ev_pair] = std::move(p); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::attach_perf_event_raw(void* perf_event_attr, @@ -436,7 +436,7 @@ StatusTuple BPF::attach_perf_event_raw(void* perf_event_attr, p.func = probe_func; p.per_cpu_fd = fds; perf_events_[ev_pair] = std::move(p); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::detach_kprobe(const std::string& kernel_func, @@ -451,7 +451,7 @@ StatusTuple BPF::detach_kprobe(const std::string& kernel_func, TRY2(detach_kprobe_event(it->first, it->second)); kprobes_.erase(it); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::detach_uprobe(const std::string& binary_path, @@ -472,7 +472,7 @@ StatusTuple BPF::detach_uprobe(const std::string& binary_path, TRY2(detach_uprobe_event(it->first, it->second)); uprobes_.erase(it); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::detach_usdt(const USDT& usdt, pid_t pid) { @@ -500,7 +500,7 @@ StatusTuple BPF::detach_usdt(const USDT& usdt, pid_t pid) { if (failed) return StatusTuple(-1, err_msg); else - return StatusTuple(0); + return StatusTuple::OK(); } } @@ -514,7 +514,7 @@ StatusTuple BPF::detach_tracepoint(const std::string& tracepoint) { TRY2(detach_tracepoint_event(it->first, it->second)); tracepoints_.erase(it); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::detach_raw_tracepoint(const std::string& tracepoint) { @@ -524,7 +524,7 @@ StatusTuple BPF::detach_raw_tracepoint(const std::string& tracepoint) { TRY2(detach_raw_tracepoint_event(it->first, it->second)); raw_tracepoints_.erase(it); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::detach_perf_event(uint32_t ev_type, uint32_t ev_config) { @@ -534,7 +534,7 @@ StatusTuple BPF::detach_perf_event(uint32_t ev_type, uint32_t ev_config) { ev_config); TRY2(detach_perf_event_all_cpu(it->second)); perf_events_.erase(it); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::detach_perf_event_raw(void* perf_event_attr) { @@ -553,7 +553,7 @@ StatusTuple BPF::open_perf_event(const std::string& name, uint32_t type, } auto table = perf_event_arrays_[name]; TRY2(table->open_all_cpu(type, config)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::close_perf_event(const std::string& name) { @@ -561,7 +561,7 @@ StatusTuple BPF::close_perf_event(const std::string& name) { if (it == perf_event_arrays_.end()) return StatusTuple(-1, "Perf Event for %s not open", name.c_str()); TRY2(it->second->close_all_cpu()); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::open_perf_buffer(const std::string& name, @@ -580,7 +580,7 @@ StatusTuple BPF::open_perf_buffer(const std::string& name, return StatusTuple(-1, "open_perf_buffer page_cnt must be a power of two"); auto table = perf_buffers_[name]; TRY2(table->open_all_cpu(cb, lost_cb, cb_cookie, page_cnt)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::close_perf_buffer(const std::string& name) { @@ -588,7 +588,7 @@ StatusTuple BPF::close_perf_buffer(const std::string& name) { if (it == perf_buffers_.end()) return StatusTuple(-1, "Perf buffer for %s not open", name.c_str()); TRY2(it->second->close_all_cpu()); - return StatusTuple(0); + return StatusTuple::OK(); } BPFPerfBuffer* BPF::get_perf_buffer(const std::string& name) { @@ -607,7 +607,7 @@ StatusTuple BPF::load_func(const std::string& func_name, bpf_prog_type type, int& fd) { if (funcs_.find(func_name) != funcs_.end()) { fd = funcs_[func_name]; - return StatusTuple(0); + return StatusTuple::OK(); } uint8_t* func_start = bpf_module_->function_start(func_name); @@ -635,20 +635,20 @@ StatusTuple BPF::load_func(const std::string& func_name, bpf_prog_type type, if (ret < 0) fprintf(stderr, "WARNING: cannot get prog tag, ignore saving source with program tag\n"); funcs_[func_name] = fd; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::unload_func(const std::string& func_name) { auto it = funcs_.find(func_name); if (it == funcs_.end()) - return StatusTuple(0); + return StatusTuple::OK(); int res = close(it->second); if (res != 0) return StatusTuple(-1, "Can't close FD for %s: %d", it->first.c_str(), res); funcs_.erase(it); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::attach_func(int prog_fd, int attachable_fd, @@ -660,7 +660,7 @@ StatusTuple BPF::attach_func(int prog_fd, int attachable_fd, "attach_type %d, flags %ld: error %d", prog_fd, attachable_fd, attach_type, flags, res); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::detach_func(int prog_fd, int attachable_fd, @@ -671,7 +671,7 @@ StatusTuple BPF::detach_func(int prog_fd, int attachable_fd, "attach_type %d: error %d", prog_fd, attachable_fd, attach_type, res); - return StatusTuple(0); + return StatusTuple::OK(); } std::string BPF::get_syscall_fnname(const std::string& name) { @@ -711,7 +711,7 @@ StatusTuple BPF::check_binary_symbol(const std::string& binary_path, module_res = ""; } offset_res = output.offset + symbol_offset; - return StatusTuple(0); + return StatusTuple::OK(); } std::string BPF::get_kprobe_event(const std::string& kernel_func, @@ -810,7 +810,7 @@ StatusTuple BPF::detach_kprobe_event(const std::string& event, TRY2(unload_func(attr.func)); if (bpf_detach_kprobe(event.c_str()) < 0) return StatusTuple(-1, "Unable to detach kprobe %s", event.c_str()); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::detach_uprobe_event(const std::string& event, @@ -819,7 +819,7 @@ StatusTuple BPF::detach_uprobe_event(const std::string& event, TRY2(unload_func(attr.func)); if (bpf_detach_uprobe(event.c_str()) < 0) return StatusTuple(-1, "Unable to detach uprobe %s", event.c_str()); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::detach_tracepoint_event(const std::string& tracepoint, @@ -828,7 +828,7 @@ StatusTuple BPF::detach_tracepoint_event(const std::string& tracepoint, TRY2(unload_func(attr.func)); // TODO: bpf_detach_tracepoint currently does nothing. - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::detach_raw_tracepoint_event(const std::string& tracepoint, @@ -836,7 +836,7 @@ StatusTuple BPF::detach_raw_tracepoint_event(const std::string& tracepoint, TRY2(close(attr.perf_event_fd)); TRY2(unload_func(attr.func)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPF::detach_perf_event_all_cpu(open_probe_t& attr) { @@ -856,7 +856,7 @@ StatusTuple BPF::detach_perf_event_all_cpu(open_probe_t& attr) { if (has_error) return StatusTuple(-1, err_msg); - return StatusTuple(0); + return StatusTuple::OK(); } int BPF::free_bcc_memory() { @@ -968,7 +968,7 @@ StatusTuple USDT::init() { program_text_ = ::USDT::USDT_PROGRAM_HEADER + stream.str(); initialized_ = true; - return StatusTuple(0); + return StatusTuple::OK(); } } // namespace ebpf diff --git a/src/cc/api/BPFTable.cc b/src/cc/api/BPFTable.cc index db62de74b..2c819614a 100644 --- a/src/cc/api/BPFTable.cc +++ b/src/cc/api/BPFTable.cc @@ -78,7 +78,7 @@ StatusTuple BPFTable::get_value(const std::string& key_str, if (r.code() != 0) return r; } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFTable::update_value(const std::string& key_str, @@ -99,7 +99,7 @@ StatusTuple BPFTable::update_value(const std::string& key_str, if (!update(key, value)) return StatusTuple(-1, "error updating element"); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFTable::update_value(const std::string& key_str, @@ -126,7 +126,7 @@ StatusTuple BPFTable::update_value(const std::string& key_str, if (!update(key, value)) return StatusTuple(-1, "error updating element"); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFTable::remove_value(const std::string& key_str) { @@ -141,7 +141,7 @@ StatusTuple BPFTable::remove_value(const std::string& key_str) { if (!remove(key)) return StatusTuple(-1, "error removing element"); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFTable::clear_table_non_atomic() { @@ -177,7 +177,7 @@ StatusTuple BPFTable::clear_table_non_atomic() { desc.name.c_str()); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFTable::get_table_offline( @@ -225,7 +225,7 @@ StatusTuple BPFTable::get_table_offline( res.clear(); // For other maps, try to use the first() and next() interfaces if (!this->first(key.get())) - return StatusTuple(0); + return StatusTuple::OK(); while (true) { if (!this->lookup(key.get(), value.get())) @@ -243,7 +243,7 @@ StatusTuple BPFTable::get_table_offline( } } - return StatusTuple(0); + return StatusTuple::OK(); } size_t BPFTable::get_possible_cpu_count() { return get_possible_cpus().size(); } @@ -417,7 +417,7 @@ StatusTuple BPFPerfBuffer::open_on_cpu(perf_reader_raw_cb cb, } cpu_readers_[cpu] = reader; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFPerfBuffer::open_all_cpu(perf_reader_raw_cb cb, @@ -437,18 +437,18 @@ StatusTuple BPFPerfBuffer::open_all_cpu(perf_reader_raw_cb cb, return res; } } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFPerfBuffer::close_on_cpu(int cpu) { auto it = cpu_readers_.find(cpu); if (it == cpu_readers_.end()) - return StatusTuple(0); + return StatusTuple::OK(); perf_reader_free(static_cast(it->second)); if (!remove(const_cast(&(it->first)))) return StatusTuple(-1, "Unable to close perf buffer on CPU %d", it->first); cpu_readers_.erase(it); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFPerfBuffer::close_all_cpu() { @@ -479,7 +479,7 @@ StatusTuple BPFPerfBuffer::close_all_cpu() { if (has_error) return StatusTuple(-1, errors); - return StatusTuple(0); + return StatusTuple::OK(); } int BPFPerfBuffer::poll(int timeout_ms) { @@ -519,7 +519,7 @@ StatusTuple BPFPerfEventArray::open_all_cpu(uint32_t type, uint64_t config) { return res; } } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFPerfEventArray::close_all_cpu() { @@ -540,7 +540,7 @@ StatusTuple BPFPerfEventArray::close_all_cpu() { if (has_error) return StatusTuple(-1, errors); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFPerfEventArray::open_on_cpu(int cpu, uint32_t type, @@ -558,17 +558,17 @@ StatusTuple BPFPerfEventArray::open_on_cpu(int cpu, uint32_t type, std::strerror(errno)); } cpu_fds_[cpu] = fd; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFPerfEventArray::close_on_cpu(int cpu) { auto it = cpu_fds_.find(cpu); if (it == cpu_fds_.end()) { - return StatusTuple(0); + return StatusTuple::OK(); } bpf_close_perf_event_fd(it->second); cpu_fds_.erase(it); - return StatusTuple(0); + return StatusTuple::OK(); } BPFPerfEventArray::~BPFPerfEventArray() { @@ -589,13 +589,13 @@ BPFProgTable::BPFProgTable(const TableDesc& desc) StatusTuple BPFProgTable::update_value(const int& index, const int& prog_fd) { if (!this->update(const_cast(&index), const_cast(&prog_fd))) return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFProgTable::remove_value(const int& index) { if (!this->remove(const_cast(&index))) return StatusTuple(-1, "Error removing value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } BPFCgroupArray::BPFCgroupArray(const TableDesc& desc) @@ -609,7 +609,7 @@ StatusTuple BPFCgroupArray::update_value(const int& index, const int& cgroup2_fd) { if (!this->update(const_cast(&index), const_cast(&cgroup2_fd))) return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFCgroupArray::update_value(const int& index, @@ -618,13 +618,13 @@ StatusTuple BPFCgroupArray::update_value(const int& index, if ((int)f < 0) return StatusTuple(-1, "Unable to open %s", cgroup2_path.c_str()); TRY2(update_value(index, (int)f)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFCgroupArray::remove_value(const int& index) { if (!this->remove(const_cast(&index))) return StatusTuple(-1, "Error removing value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } BPFDevmapTable::BPFDevmapTable(const TableDesc& desc) @@ -638,20 +638,20 @@ StatusTuple BPFDevmapTable::update_value(const int& index, const int& value) { if (!this->update(const_cast(&index), const_cast(&value))) return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFDevmapTable::get_value(const int& index, int& value) { if (!this->lookup(const_cast(&index), &value)) return StatusTuple(-1, "Error getting value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFDevmapTable::remove_value(const int& index) { if (!this->remove(const_cast(&index))) return StatusTuple(-1, "Error removing value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } BPFXskmapTable::BPFXskmapTable(const TableDesc& desc) @@ -665,20 +665,20 @@ StatusTuple BPFXskmapTable::update_value(const int& index, const int& value) { if (!this->update(const_cast(&index), const_cast(&value))) return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFXskmapTable::get_value(const int& index, int& value) { if (!this->lookup(const_cast(&index), &value)) return StatusTuple(-1, "Error getting value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFXskmapTable::remove_value(const int& index) { if (!this->remove(const_cast(&index))) return StatusTuple(-1, "Error removing value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } BPFMapInMapTable::BPFMapInMapTable(const TableDesc& desc) @@ -693,13 +693,13 @@ StatusTuple BPFMapInMapTable::update_value(const int& index, const int& inner_map_fd) { if (!this->update(const_cast(&index), const_cast(&inner_map_fd))) return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFMapInMapTable::remove_value(const int& index) { if (!this->remove(const_cast(&index))) return StatusTuple(-1, "Error removing value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } BPFSockmapTable::BPFSockmapTable(const TableDesc& desc) @@ -713,13 +713,13 @@ StatusTuple BPFSockmapTable::update_value(const int& index, const int& value) { if (!this->update(const_cast(&index), const_cast(&value))) return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFSockmapTable::remove_value(const int& index) { if (!this->remove(const_cast(&index))) return StatusTuple(-1, "Error removing value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } BPFSockhashTable::BPFSockhashTable(const TableDesc& desc) @@ -733,13 +733,13 @@ StatusTuple BPFSockhashTable::update_value(const int& key, const int& value) { if (!this->update(const_cast(&key), const_cast(&value))) return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple BPFSockhashTable::remove_value(const int& key) { if (!this->remove(const_cast(&key))) return StatusTuple(-1, "Error removing value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } } // namespace ebpf diff --git a/src/cc/api/BPFTable.h b/src/cc/api/BPFTable.h index f8e3396a4..c47c3dfe3 100644 --- a/src/cc/api/BPFTable.h +++ b/src/cc/api/BPFTable.h @@ -137,14 +137,14 @@ class BPFArrayTable : public BPFTableBase { virtual StatusTuple get_value(const int& index, ValueType& value) { if (!this->lookup(const_cast(&index), get_value_addr(value))) return StatusTuple(-1, "Error getting value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } virtual StatusTuple update_value(const int& index, const ValueType& value) { if (!this->update(const_cast(&index), get_value_addr(const_cast(value)))) return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } ValueType operator[](const int& key) { @@ -211,20 +211,20 @@ class BPFHashTable : public BPFTableBase { virtual StatusTuple get_value(const KeyType& key, ValueType& value) { if (!this->lookup(const_cast(&key), get_value_addr(value))) return StatusTuple(-1, "Error getting value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } virtual StatusTuple update_value(const KeyType& key, const ValueType& value) { if (!this->update(const_cast(&key), get_value_addr(const_cast(value)))) return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } virtual StatusTuple remove_value(const KeyType& key) { if (!this->remove(const_cast(&key))) return StatusTuple(-1, "Error removing value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } ValueType operator[](const KeyType& key) { @@ -260,7 +260,7 @@ class BPFHashTable : public BPFTableBase { while (this->first(&cur)) TRY2(remove_value(cur)); - return StatusTuple(0); + return StatusTuple::OK(); } }; @@ -447,20 +447,20 @@ class BPFSkStorageTable : public BPFTableBase { virtual StatusTuple get_value(const int& sock_fd, ValueType& value) { if (!this->lookup(const_cast(&sock_fd), get_value_addr(value))) return StatusTuple(-1, "Error getting value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } virtual StatusTuple update_value(const int& sock_fd, const ValueType& value) { if (!this->update(const_cast(&sock_fd), get_value_addr(const_cast(value)))) return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } virtual StatusTuple remove_value(const int& sock_fd) { if (!this->remove(const_cast(&sock_fd))) return StatusTuple(-1, "Error removing value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } }; @@ -478,14 +478,14 @@ class BPFCgStorageTable : public BPFTableBase { if (!this->lookup(const_cast(&key), get_value_addr(value))) return StatusTuple(-1, "Error getting value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } virtual StatusTuple update_value(struct bpf_cgroup_storage_key& key, const ValueType& value) { if (!this->update(const_cast(&key), get_value_addr(const_cast(value)))) return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } }; @@ -508,7 +508,7 @@ class BPFPercpuCgStorageTable : public BPFTableBase> if (!this->lookup(const_cast(&key), get_value_addr(value))) return StatusTuple(-1, "Error getting value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } virtual StatusTuple update_value(struct bpf_cgroup_storage_key& key, @@ -517,7 +517,7 @@ class BPFPercpuCgStorageTable : public BPFTableBase> if (!this->update(const_cast(&key), get_value_addr(const_cast&>(value)))) return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); - return StatusTuple(0); + return StatusTuple::OK(); } private: unsigned int ncpus; diff --git a/src/cc/bpf_module_rw_engine.cc b/src/cc/bpf_module_rw_engine.cc index 418355d3b..d7e31a71e 100644 --- a/src/cc/bpf_module_rw_engine.cc +++ b/src/cc/bpf_module_rw_engine.cc @@ -433,7 +433,7 @@ StatusTuple BPFModule::snprintf(string fn_name, char *str, size_t sz, return StatusTuple(rc, "error in snprintf: %s", std::strerror(errno)); if ((size_t)rc == sz) return StatusTuple(-1, "buffer of size %zd too small", sz); - return StatusTuple(0); + return StatusTuple::OK(); } } // namespace ebpf diff --git a/src/cc/frontends/b/codegen_llvm.cc b/src/cc/frontends/b/codegen_llvm.cc index 0983c49a2..fefd4d551 100644 --- a/src/cc/frontends/b/codegen_llvm.cc +++ b/src/cc/frontends/b/codegen_llvm.cc @@ -126,7 +126,7 @@ StatusTuple CodegenLLVM::visit_block_stmt_node(BlockStmtNode *n) { if (n->scope_) scopes_->pop_var(); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_if_stmt_node(IfStmtNode *n) { @@ -159,7 +159,7 @@ StatusTuple CodegenLLVM::visit_if_stmt_node(IfStmtNode *n) { B.SetInsertPoint(label_end); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_onvalid_stmt_node(OnValidStmtNode *n) { @@ -192,7 +192,7 @@ StatusTuple CodegenLLVM::visit_onvalid_stmt_node(OnValidStmtNode *n) { } B.SetInsertPoint(label_end); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_switch_stmt_node(SwitchStmtNode *n) { @@ -213,7 +213,7 @@ StatusTuple CodegenLLVM::visit_switch_stmt_node(SwitchStmtNode *n) { B.SetInsertPoint(resolve_label("DONE")); label_end->eraseFromParent(); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_case_stmt_node(CaseStmtNode *n) { @@ -236,7 +236,7 @@ StatusTuple CodegenLLVM::visit_case_stmt_node(CaseStmtNode *n) { if (!B.GetInsertBlock()->getTerminator()) B.CreateBr(label_end); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_ident_expr_node(IdentExprNode *n) { @@ -308,7 +308,7 @@ StatusTuple CodegenLLVM::visit_ident_expr_node(IdentExprNode *n) { } } } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_assign_expr_node(AssignExprNode *n) { @@ -343,7 +343,7 @@ StatusTuple CodegenLLVM::visit_assign_expr_node(AssignExprNode *n) { } } } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::lookup_var(Node *n, const string &name, Scopes::VarScope *scope, @@ -353,7 +353,7 @@ StatusTuple CodegenLLVM::lookup_var(Node *n, const string &name, Scopes::VarScop auto it = vars_.find(*decl); if (it == vars_.end()) return mkstatus_(n, "unable to find %s memory location", name.c_str()); *mem = it->second; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_packet_expr_node(PacketExprNode *n) { @@ -407,7 +407,7 @@ StatusTuple CodegenLLVM::visit_packet_expr_node(PacketExprNode *n) { return mkstatus_(n, "unsupported"); } } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_integer_expr_node(IntegerExprNode *n) { @@ -416,7 +416,7 @@ StatusTuple CodegenLLVM::visit_integer_expr_node(IntegerExprNode *n) { expr_ = ConstantInt::get(mod_->getContext(), val); if (n->bits_) expr_ = B.CreateIntCast(expr_, B.getIntNTy(n->bits_), false); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_string_expr_node(StringExprNode *n) { @@ -432,7 +432,7 @@ StatusTuple CodegenLLVM::visit_string_expr_node(StringExprNode *n) { #endif expr_ = ptr; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::emit_short_circuit_and(BinopExprNode *n) { @@ -459,7 +459,7 @@ StatusTuple CodegenLLVM::emit_short_circuit_and(BinopExprNode *n) { phi->addIncoming(pop_expr(), label_then); expr_ = phi; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::emit_short_circuit_or(BinopExprNode *n) { @@ -486,7 +486,7 @@ StatusTuple CodegenLLVM::emit_short_circuit_or(BinopExprNode *n) { phi->addIncoming(pop_expr(), label_then); expr_ = phi; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_binop_expr_node(BinopExprNode *n) { @@ -514,7 +514,7 @@ StatusTuple CodegenLLVM::visit_binop_expr_node(BinopExprNode *n) { case Tok::TLOR: expr_ = B.CreateOr(lhs, rhs); break; default: return mkstatus_(n, "unsupported binary operator"); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_unop_expr_node(UnopExprNode *n) { @@ -524,11 +524,11 @@ StatusTuple CodegenLLVM::visit_unop_expr_node(UnopExprNode *n) { case Tok::TCMPL: expr_ = B.CreateNeg(pop_expr()); break; default: {} } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_bitop_expr_node(BitopExprNode *n) { - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_goto_expr_node(GotoExprNode *n) { @@ -558,7 +558,7 @@ StatusTuple CodegenLLVM::visit_goto_expr_node(GotoExprNode *n) { } } B.CreateBr(resolve_label(jump_label)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_return_expr_node(ReturnExprNode *n) { @@ -567,7 +567,7 @@ StatusTuple CodegenLLVM::visit_return_expr_node(ReturnExprNode *n) { Value *cast_1 = B.CreateIntCast(pop_expr(), parent->getReturnType(), true); B.CreateStore(cast_1, retval_); B.CreateBr(resolve_label("DONE")); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::emit_table_lookup(MethodCallExprNode *n) { @@ -610,7 +610,7 @@ StatusTuple CodegenLLVM::emit_table_lookup(MethodCallExprNode *n) { } else { return mkstatus_(n, "lookup in table type %s unsupported", table->type_id()->c_str()); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::emit_table_update(MethodCallExprNode *n) { @@ -641,7 +641,7 @@ StatusTuple CodegenLLVM::emit_table_update(MethodCallExprNode *n) { } else { return mkstatus_(n, "unsupported"); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::emit_table_delete(MethodCallExprNode *n) { @@ -668,7 +668,7 @@ StatusTuple CodegenLLVM::emit_table_delete(MethodCallExprNode *n) { } else { return mkstatus_(n, "unsupported"); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::emit_log(MethodCallExprNode *n) { @@ -689,13 +689,13 @@ StatusTuple CodegenLLVM::emit_log(MethodCallExprNode *n) { PointerType::getUnqual(printk_fn_type)); expr_ = B.CreateCall(printk_fn, args); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::emit_packet_rewrite_field(MethodCallExprNode *n) { TRY2(n->args_[1]->accept(this)); TRY2(n->args_[0]->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::emit_atomic_add(MethodCallExprNode *n) { @@ -706,7 +706,7 @@ StatusTuple CodegenLLVM::emit_atomic_add(MethodCallExprNode *n) { AtomicRMWInst *atomic_inst = B.CreateAtomicRMW( AtomicRMWInst::Add, lhs, rhs, AtomicOrdering::SequentiallyConsistent); atomic_inst->setVolatile(false); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::emit_incr_cksum(MethodCallExprNode *n, size_t sz) { @@ -743,11 +743,11 @@ StatusTuple CodegenLLVM::emit_incr_cksum(MethodCallExprNode *n, size_t sz) { Value *skb_ptr8 = B.CreateBitCast(skb_ptr, B.getInt8PtrTy()); expr_ = B.CreateCall(csum_fn, vector({skb_ptr8, offset, old_val, new_val, flags})); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::emit_get_usec_time(MethodCallExprNode *n) { - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_method_call_expr_node(MethodCallExprNode *n) { @@ -773,7 +773,7 @@ StatusTuple CodegenLLVM::visit_method_call_expr_node(MethodCallExprNode *n) { return mkstatus_(n, "unsupported"); } TRY2(n->block_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } /* result = lookup(key) @@ -884,7 +884,7 @@ StatusTuple CodegenLLVM::visit_table_index_expr_node(TableIndexExprNode *n) { } else { expr_ = result; } - return StatusTuple(0); + return StatusTuple::OK(); } /// on_match @@ -917,7 +917,7 @@ StatusTuple CodegenLLVM::visit_match_decl_stmt_node(MatchDeclStmtNode *n) { } B.SetInsertPoint(label_end); - return StatusTuple(0); + return StatusTuple::OK(); } /// on_miss @@ -945,7 +945,7 @@ StatusTuple CodegenLLVM::visit_miss_decl_stmt_node(MissDeclStmtNode *n) { } B.SetInsertPoint(label_end); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_failure_decl_stmt_node(FailureDeclStmtNode *n) { @@ -955,12 +955,12 @@ StatusTuple CodegenLLVM::visit_failure_decl_stmt_node(FailureDeclStmtNode *n) { StatusTuple CodegenLLVM::visit_expr_stmt_node(ExprStmtNode *n) { TRY2(n->expr_->accept(this)); expr_ = nullptr; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_struct_variable_decl_stmt_node(StructVariableDeclStmtNode *n) { if (n->struct_id_->name_ == "" || n->struct_id_->name_[0] == '_') { - return StatusTuple(0); + return StatusTuple::OK(); } StructType *stype; @@ -1018,12 +1018,12 @@ StatusTuple CodegenLLVM::visit_struct_variable_decl_stmt_node(StructVariableDecl } } } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_integer_variable_decl_stmt_node(IntegerVariableDeclStmtNode *n) { if (!B.GetInsertBlock()) - return StatusTuple(0); + return StatusTuple::OK(); // uintX var = init AllocaInst *ptr_a = make_alloca(resolve_entry_stack(), @@ -1033,7 +1033,7 @@ StatusTuple CodegenLLVM::visit_integer_variable_decl_stmt_node(IntegerVariableDe // todo if (!n->init_.empty()) TRY2(n->init_[0]->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_struct_decl_stmt_node(StructDeclStmtNode *n) { @@ -1044,7 +1044,7 @@ StatusTuple CodegenLLVM::visit_struct_decl_stmt_node(StructDeclStmtNode *n) { fields.push_back(B.getIntNTy((*it)->bit_width_)); struct_type->setBody(fields, n->is_packed()); structs_[n] = struct_type; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_parser_state_stmt_node(ParserStateStmtNode *n) { @@ -1053,12 +1053,12 @@ StatusTuple CodegenLLVM::visit_parser_state_stmt_node(ParserStateStmtNode *n) { B.SetInsertPoint(label_entry); if (n->next_state_) TRY2(n->next_state_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_state_decl_stmt_node(StateDeclStmtNode *n) { if (!n->id_) - return StatusTuple(0); + return StatusTuple::OK(); string jump_label = n->scoped_name(); BasicBlock *label_entry = resolve_label(jump_label); B.SetInsertPoint(label_entry); @@ -1082,7 +1082,7 @@ StatusTuple CodegenLLVM::visit_state_decl_stmt_node(StateDeclStmtNode *n) { } scopes_->pop_state(); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_table_decl_stmt_node(TableDeclStmtNode *n) { @@ -1124,7 +1124,7 @@ StatusTuple CodegenLLVM::visit_table_decl_stmt_node(TableDeclStmtNode *n) { } else { return mkstatus_(n, "Table %s not implemented", n->table_type_->name_.c_str()); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::lookup_struct_type(StructDeclStmtNode *decl, StructType **stype) const { @@ -1133,7 +1133,7 @@ StatusTuple CodegenLLVM::lookup_struct_type(StructDeclStmtNode *decl, StructType return mkstatus_(decl, "could not find IR for type %s", decl->id_->c_str()); *stype = struct_it->second; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::lookup_struct_type(VariableDeclStmtNode *n, StructType **stype, @@ -1155,7 +1155,7 @@ StatusTuple CodegenLLVM::lookup_struct_type(VariableDeclStmtNode *n, StructType if (decl) *decl = type; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit_func_decl_stmt_node(FuncDeclStmtNode *n) { @@ -1235,7 +1235,7 @@ StatusTuple CodegenLLVM::visit_func_decl_stmt_node(FuncDeclStmtNode *n) { B.CreateRet(B.CreateLoad(retval_)); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::visit(Node *root, TableStorage &ts, const string &id, @@ -1265,7 +1265,7 @@ StatusTuple CodegenLLVM::visit(Node *root, TableStorage &ts, const string &id, table.first->size_, 0, }); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple CodegenLLVM::print_header() { @@ -1293,7 +1293,7 @@ StatusTuple CodegenLLVM::print_header() { continue; TRY2((*it)->accept(this)); } - return StatusTuple(0); + return StatusTuple::OK(); } int CodegenLLVM::get_table_fd(const string &name) const { diff --git a/src/cc/frontends/b/printer.cc b/src/cc/frontends/b/printer.cc index e16a8239f..75ff9071c 100644 --- a/src/cc/frontends/b/printer.cc +++ b/src/cc/frontends/b/printer.cc @@ -38,7 +38,7 @@ StatusTuple Printer::visit_block_stmt_node(BlockStmtNode* n) { --indent_; } fprintf(out_, "%*s}", indent_, ""); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_if_stmt_node(IfStmtNode* n) { @@ -50,7 +50,7 @@ StatusTuple Printer::visit_if_stmt_node(IfStmtNode* n) { fprintf(out_, " else "); TRY2(n->false_block_->accept(this)); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_onvalid_stmt_node(OnValidStmtNode* n) { @@ -62,7 +62,7 @@ StatusTuple Printer::visit_onvalid_stmt_node(OnValidStmtNode* n) { fprintf(out_, " else "); TRY2(n->else_block_->accept(this)); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_switch_stmt_node(SwitchStmtNode* n) { @@ -70,7 +70,7 @@ StatusTuple Printer::visit_switch_stmt_node(SwitchStmtNode* n) { TRY2(n->cond_->accept(this)); fprintf(out_, ") "); TRY2(n->block_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_case_stmt_node(CaseStmtNode* n) { @@ -81,7 +81,7 @@ StatusTuple Printer::visit_case_stmt_node(CaseStmtNode* n) { fprintf(out_, "default"); } TRY2(n->block_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_ident_expr_node(IdentExprNode* n) { @@ -92,37 +92,37 @@ StatusTuple Printer::visit_ident_expr_node(IdentExprNode* n) { if (n->sub_name_.size()) { fprintf(out_, ".%s", n->sub_name_.c_str()); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_assign_expr_node(AssignExprNode* n) { TRY2(n->lhs_->accept(this)); fprintf(out_, " = "); TRY2(n->rhs_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_packet_expr_node(PacketExprNode* n) { fprintf(out_, "$"); TRY2(n->id_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_integer_expr_node(IntegerExprNode* n) { fprintf(out_, "%s:%zu", n->val_.c_str(), n->bits_); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_string_expr_node(StringExprNode *n) { fprintf(out_, "%s", n->val_.c_str()); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_binop_expr_node(BinopExprNode* n) { TRY2(n->lhs_->accept(this)); fprintf(out_, "%d", n->op_); TRY2(n->rhs_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_unop_expr_node(UnopExprNode* n) { @@ -135,25 +135,25 @@ StatusTuple Printer::visit_unop_expr_node(UnopExprNode* n) { } fprintf(out_, "%s", s); TRY2(n->expr_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_bitop_expr_node(BitopExprNode* n) { - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_return_expr_node(ReturnExprNode* n) { fprintf(out_, "return "); TRY2(n->expr_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_goto_expr_node(GotoExprNode* n) { const char* s = n->is_continue_ ? "continue " : "goto "; fprintf(out_, "%s", s); TRY2(n->id_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_method_call_expr_node(MethodCallExprNode* n) { @@ -177,19 +177,19 @@ StatusTuple Printer::visit_method_call_expr_node(MethodCallExprNode* n) { --indent_; fprintf(out_, "%*s}", indent_, ""); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_table_index_expr_node(TableIndexExprNode *n) { fprintf(out_, "%s[", n->id_->c_str()); TRY2(n->index_->accept(this)); fprintf(out_, "]"); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_expr_stmt_node(ExprStmtNode* n) { TRY2(n->expr_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_struct_variable_decl_stmt_node(StructVariableDeclStmtNode* n) { @@ -207,7 +207,7 @@ StatusTuple Printer::visit_struct_variable_decl_stmt_node(StructVariableDeclStmt } fprintf(out_, "}"); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_integer_variable_decl_stmt_node(IntegerVariableDeclStmtNode* n) { @@ -218,7 +218,7 @@ StatusTuple Printer::visit_integer_variable_decl_stmt_node(IntegerVariableDeclSt fprintf(out_, "; "); TRY2(n->init_[0]->accept(this)); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_struct_decl_stmt_node(StructDeclStmtNode* n) { @@ -233,12 +233,12 @@ StatusTuple Printer::visit_struct_decl_stmt_node(StructDeclStmtNode* n) { } --indent_; fprintf(out_, "%*s}", indent_, ""); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_state_decl_stmt_node(StateDeclStmtNode* n) { if (!n->id_) { - return StatusTuple(0); + return StatusTuple::OK(); } fprintf(out_, "state "); TRY2(n->id_->accept(this)); @@ -249,11 +249,11 @@ StatusTuple Printer::visit_state_decl_stmt_node(StateDeclStmtNode* n) { // TRY2(n->id2_->accept(this)); //} //TRY2(n->block_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_parser_state_stmt_node(ParserStateStmtNode* n) { - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_match_decl_stmt_node(MatchDeclStmtNode* n) { @@ -268,7 +268,7 @@ StatusTuple Printer::visit_match_decl_stmt_node(MatchDeclStmtNode* n) { } fprintf(out_, ") "); TRY2(n->block_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_miss_decl_stmt_node(MissDeclStmtNode* n) { @@ -283,7 +283,7 @@ StatusTuple Printer::visit_miss_decl_stmt_node(MissDeclStmtNode* n) { } fprintf(out_, ") "); TRY2(n->block_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_failure_decl_stmt_node(FailureDeclStmtNode* n) { @@ -298,7 +298,7 @@ StatusTuple Printer::visit_failure_decl_stmt_node(FailureDeclStmtNode* n) { } fprintf(out_, ") "); TRY2(n->block_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_table_decl_stmt_node(TableDeclStmtNode* n) { @@ -313,7 +313,7 @@ StatusTuple Printer::visit_table_decl_stmt_node(TableDeclStmtNode* n) { fprintf(out_, "> "); TRY2(n->id_->accept(this)); fprintf(out_, "(%zu)", n->size_); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple Printer::visit_func_decl_stmt_node(FuncDeclStmtNode *n) { @@ -328,7 +328,7 @@ StatusTuple Printer::visit_func_decl_stmt_node(FuncDeclStmtNode *n) { } fprintf(out_, ") "); TRY2(n->block_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } } // namespace cc diff --git a/src/cc/frontends/b/type_check.cc b/src/cc/frontends/b/type_check.cc index 7c5b7ce5f..4300c768e 100644 --- a/src/cc/frontends/b/type_check.cc +++ b/src/cc/frontends/b/type_check.cc @@ -37,7 +37,7 @@ StatusTuple TypeCheck::visit_block_stmt_node(BlockStmtNode *n) { if (n->scope_) scopes_->pop_var(); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_if_stmt_node(IfStmtNode *n) { @@ -48,7 +48,7 @@ StatusTuple TypeCheck::visit_if_stmt_node(IfStmtNode *n) { if (n->false_block_) { TRY2(n->false_block_->accept(this)); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_onvalid_stmt_node(OnValidStmtNode *n) { @@ -60,7 +60,7 @@ StatusTuple TypeCheck::visit_onvalid_stmt_node(OnValidStmtNode *n) { if (n->else_block_) { TRY2(n->else_block_->accept(this)); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_switch_stmt_node(SwitchStmtNode *n) { @@ -71,7 +71,7 @@ StatusTuple TypeCheck::visit_switch_stmt_node(SwitchStmtNode *n) { for (auto it = n->block_->stmts_.begin(); it != n->block_->stmts_.end(); ++it) { /// @todo check for duplicates } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_case_stmt_node(CaseStmtNode *n) { @@ -81,7 +81,7 @@ StatusTuple TypeCheck::visit_case_stmt_node(CaseStmtNode *n) { return mkstatus_(n, "Switch condition must be a numeric type"); } TRY2(n->block_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_ident_expr_node(IdentExprNode *n) { @@ -131,7 +131,7 @@ StatusTuple TypeCheck::visit_ident_expr_node(IdentExprNode *n) { n->bit_width_ = n->sub_decl_->bit_width_; n->flags_[ExprNode::WRITE] = true; } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_assign_expr_node(AssignExprNode *n) { @@ -151,7 +151,7 @@ StatusTuple TypeCheck::visit_assign_expr_node(AssignExprNode *n) { return mkstatus_(n, "Right-hand side of assignment must be a numeric type"); } n->typeof_ = ExprNode::VOID; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_packet_expr_node(PacketExprNode *n) { @@ -172,20 +172,20 @@ StatusTuple TypeCheck::visit_packet_expr_node(PacketExprNode *n) { n->bit_width_ = sub_decl->bit_width_; } n->flags_[ExprNode::WRITE] = true; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_integer_expr_node(IntegerExprNode *n) { n->typeof_ = ExprNode::INTEGER; n->bit_width_ = n->bits_; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_string_expr_node(StringExprNode *n) { n->typeof_ = ExprNode::STRING; n->flags_[ExprNode::IS_REF] = true; n->bit_width_ = n->val_.size() << 3; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_binop_expr_node(BinopExprNode *n) { @@ -208,7 +208,7 @@ StatusTuple TypeCheck::visit_binop_expr_node(BinopExprNode *n) { default: n->bit_width_ = std::max(n->lhs_->bit_width_, n->rhs_->bit_width_); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_unop_expr_node(UnopExprNode *n) { @@ -216,26 +216,26 @@ StatusTuple TypeCheck::visit_unop_expr_node(UnopExprNode *n) { if (n->expr_->typeof_ != ExprNode::INTEGER) return mkstatus_(n, "Unary operand must be a numeric type"); n->copy_type(*n->expr_); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_bitop_expr_node(BitopExprNode *n) { if (n->expr_->typeof_ != ExprNode::INTEGER) return mkstatus_(n, "Bitop [] can only operate on numeric types"); n->typeof_ = ExprNode::INTEGER; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_goto_expr_node(GotoExprNode *n) { //n->id_->accept(this); n->typeof_ = ExprNode::VOID; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_return_expr_node(ReturnExprNode *n) { TRY2(n->expr_->accept(this)); n->typeof_ = ExprNode::VOID; - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::expect_method_arg(MethodCallExprNode *n, size_t num, size_t num_def_args = 0) { @@ -248,7 +248,7 @@ StatusTuple TypeCheck::expect_method_arg(MethodCallExprNode *n, size_t num, size return mkstatus_(n, "%s expected %d argument%s (%d default), %zu given", n->id_->sub_name_.c_str(), num, num == 1 ? "" : "s", num_def_args, n->args_.size()); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::check_lookup_method(MethodCallExprNode *n) { @@ -264,7 +264,7 @@ StatusTuple TypeCheck::check_lookup_method(MethodCallExprNode *n) { n->block_->scope_->add("_result", result.get()); n->block_->stmts_.insert(n->block_->stmts_.begin(), move(result)); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::check_update_method(MethodCallExprNode *n) { @@ -275,7 +275,7 @@ StatusTuple TypeCheck::check_update_method(MethodCallExprNode *n) { TRY2(expect_method_arg(n, 2)); else if (table->type_id()->name_ == "LPM") TRY2(expect_method_arg(n, 3)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::check_delete_method(MethodCallExprNode *n) { @@ -286,7 +286,7 @@ StatusTuple TypeCheck::check_delete_method(MethodCallExprNode *n) { TRY2(expect_method_arg(n, 1)); else if (table->type_id()->name_ == "LPM") {} - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_method_call_expr_node(MethodCallExprNode *n) { @@ -339,7 +339,7 @@ StatusTuple TypeCheck::visit_method_call_expr_node(MethodCallExprNode *n) { return mkstatus_(n, "%s does not allow trailing block statements", n->id_->full_name().c_str()); TRY2(n->block_->accept(this)); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_table_index_expr_node(TableIndexExprNode *n) { @@ -359,12 +359,12 @@ StatusTuple TypeCheck::visit_table_index_expr_node(TableIndexExprNode *n) { n->flags_[ExprNode::IS_REF] = true; n->struct_type_ = n->table_->leaf_type_; } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_expr_stmt_node(ExprStmtNode *n) { TRY2(n->expr_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_struct_variable_decl_stmt_node(StructVariableDeclStmtNode *n) { @@ -399,7 +399,7 @@ StatusTuple TypeCheck::visit_struct_variable_decl_stmt_node(StructVariableDeclSt TRY2((*it)->accept(this)); } } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_integer_variable_decl_stmt_node(IntegerVariableDeclStmtNode *n) { @@ -407,7 +407,7 @@ StatusTuple TypeCheck::visit_integer_variable_decl_stmt_node(IntegerVariableDecl if (!n->init_.empty()) { TRY2(n->init_[0]->accept(this)); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_struct_decl_stmt_node(StructDeclStmtNode *n) { @@ -415,16 +415,16 @@ StatusTuple TypeCheck::visit_struct_decl_stmt_node(StructDeclStmtNode *n) { for (auto it = n->stmts_.begin(); it != n->stmts_.end(); ++it) { TRY2((*it)->accept(this)); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_parser_state_stmt_node(ParserStateStmtNode *n) { - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_state_decl_stmt_node(StateDeclStmtNode *n) { if (!n->id_) { - return StatusTuple(0); + return StatusTuple::OK(); } auto s1 = proto_scopes_->top_state()->lookup(n->id_->name_, true); if (s1) { @@ -479,7 +479,7 @@ StatusTuple TypeCheck::visit_state_decl_stmt_node(StateDeclStmtNode *n) { scopes_->pop_state(); } - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_match_decl_stmt_node(MatchDeclStmtNode *n) { @@ -488,7 +488,7 @@ StatusTuple TypeCheck::visit_match_decl_stmt_node(MatchDeclStmtNode *n) { TRY2((*it)->accept(this)); } TRY2(n->block_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_miss_decl_stmt_node(MissDeclStmtNode *n) { @@ -497,7 +497,7 @@ StatusTuple TypeCheck::visit_miss_decl_stmt_node(MissDeclStmtNode *n) { TRY2((*it)->accept(this)); } TRY2(n->block_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_failure_decl_stmt_node(FailureDeclStmtNode *n) { @@ -506,7 +506,7 @@ StatusTuple TypeCheck::visit_failure_decl_stmt_node(FailureDeclStmtNode *n) { TRY2((*it)->accept(this)); } TRY2(n->block_->accept(this)); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_table_decl_stmt_node(TableDeclStmtNode *n) { @@ -524,7 +524,7 @@ StatusTuple TypeCheck::visit_table_decl_stmt_node(TableDeclStmtNode *n) { } if (n->policy_id()->name_ != "AUTO" && n->policy_id()->name_ != "NONE") return mkstatus_(n, "Unsupported policy type %s", n->policy_id()->c_str()); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit_func_decl_stmt_node(FuncDeclStmtNode *n) { @@ -539,7 +539,7 @@ StatusTuple TypeCheck::visit_func_decl_stmt_node(FuncDeclStmtNode *n) { scopes_->push_state(n->scope_); TRY2(n->block_->accept(this)); scopes_->pop_state(); - return StatusTuple(0); + return StatusTuple::OK(); } StatusTuple TypeCheck::visit(Node *root) { @@ -580,7 +580,7 @@ StatusTuple TypeCheck::visit(Node *root) { } return StatusTuple(-1, errors_.begin()->c_str()); } - return StatusTuple(0); + return StatusTuple::OK(); } } // namespace cc From 98c18b640117b10f923c8697be8bfff8ad39834b Mon Sep 17 00:00:00 2001 From: Fuji Goro Date: Fri, 6 Mar 2020 05:29:25 +0000 Subject: [PATCH 033/278] print error messages to stderr and exit(1) instead of exit(0) for fatal errors --- src/python/bcc/table.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/python/bcc/table.py b/src/python/bcc/table.py index 12ba1bf48..9f8842634 100644 --- a/src/python/bcc/table.py +++ b/src/python/bcc/table.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +from __future__ import print_function from collections import MutableMapping import ctypes as ct from functools import reduce @@ -19,6 +20,7 @@ import os import errno import re +import sys from .libbcc import lib, _RAW_CB_TYPE, _LOST_CB_TYPE from .perf import Perf @@ -645,9 +647,11 @@ def _get_event_class(self): else: fields.append((field_name, ct_mapping[field_type])) except KeyError: + # Using print+sys.exit instead of raising exceptions, + # because exceptions are caught by the caller. print("Type: '%s' not recognized. Please define the data with ctypes manually." - % field_type) - exit() + % field_type, file=sys.stderr) + sys.exit(1) i += 1 return type('', (ct.Structure,), {'_fields_': fields}) From cf20a499655583a985eb959f98fae9c2e7ecf189 Mon Sep 17 00:00:00 2001 From: Alban Crequy Date: Thu, 5 Mar 2020 16:48:43 +0100 Subject: [PATCH 034/278] GitHub Actions: optionally publish container image This is optional: this GitHub Action will only attempt to publish the container image if the GitHub repository has been configured with GitHub secrets (e.g. https://github.com/iovisor/bcc/settings/secrets). The GitHub secrets can be configured as follows: - DOCKER_PUBLISH = 1 - DOCKER_IMAGE = docker.io/myorg/bcc - DOCKER_USERNAME = username - DOCKER_PASSWORD = password This is intended to make it easy for anyone to fork iovisor/bcc on GitHub and publish custom container images with bcc. --- .github/workflows/bcc-test.yml | 35 ++++++++++++++++++++++++++++++++++ Dockerfile.ubuntu | 5 ++++- 2 files changed, 39 insertions(+), 1 deletion(-) diff --git a/.github/workflows/bcc-test.yml b/.github/workflows/bcc-test.yml index 4907e2941..1a72ff541 100644 --- a/.github/workflows/bcc-test.yml +++ b/.github/workflows/bcc-test.yml @@ -92,3 +92,38 @@ jobs: # https://github.com/marketplace/actions/debugging-with-tmate # - name: Setup tmate session # uses: mxschmitt/action-tmate@v1 + + # Optionally publish container images, guarded by the GitHub secret + # DOCKER_PUBLISH. + # GitHub secrets can be configured as follows: + # - DOCKER_PUBLISH = 1 + # - DOCKER_IMAGE = docker.io/myorg/bcc + # - DOCKER_USERNAME = username + # - DOCKER_PASSWORD = password + publish: + name: Publish + runs-on: ubuntu-latest + steps: + + - uses: actions/checkout@v1 + + - name: Initialize workflow variables + id: vars + shell: bash + run: | + echo ::set-output name=DOCKER_PUBLISH::${DOCKER_PUBLISH} + env: + DOCKER_PUBLISH: "${{ secrets.DOCKER_PUBLISH }}" + + - name: Build container image and publish to registry + id: publish-registry + uses: elgohr/Publish-Docker-Github-Action@2.8 + if: ${{ steps.vars.outputs.DOCKER_PUBLISH }} + with: + name: ${{ secrets.DOCKER_IMAGE }} + username: ${{ secrets.DOCKER_USERNAME }} + password: ${{ secrets.DOCKER_PASSWORD }} + workdir: . + dockerfile: Dockerfile.ubuntu + snapshot: true + cache: ${{ github.event_name != 'schedule' }} diff --git a/Dockerfile.ubuntu b/Dockerfile.ubuntu index 71d025d52..596f23e00 100644 --- a/Dockerfile.ubuntu +++ b/Dockerfile.ubuntu @@ -10,4 +10,7 @@ COPY ./ /root/bcc WORKDIR /root/bcc RUN /usr/lib/pbuilder/pbuilder-satisfydepends && \ - ./scripts/build-deb.sh + ./scripts/build-deb.sh && \ + apt-get update -y && \ + DEBIAN_FRONTEND=noninteractive apt-get install -y python python3 binutils libelf1 && \ + dpkg -i /root/bcc/*.deb From b7541d0b9497e5bca4de28d894d18cc8578ccdc4 Mon Sep 17 00:00:00 2001 From: Andrii Nakryiko Date: Thu, 5 Mar 2020 11:02:52 -0800 Subject: [PATCH 035/278] libbpf-tools: optimize ksyms cache Re-implement internals of ksyms cache to minimize memory overhead and allocations. Addr is also changed to be unsigned long. fscanf() can be further optimized into manual parsing, but it's low enough overhead right now that I felt like readibility is more important. Benchmarking ksyms loading/parsing parts: BEFORE: $ /usr/bin/time ./test 0.03user 0.04system 0:00.08elapsed 98%CPU (0avgtext+0avgdata 6968maxresident)k 0inputs+0outputs (0major+1512minor)pagefaults 0swaps AFTER: $ /usr/bin/time ./test 0.02user 0.03system 0:00.06elapsed 100%CPU (0avgtext+0avgdata 9508maxresident)k 0inputs+0outputs (0major+2106minor)pagefaults 0swaps RSS goes down from 9.5MB to <7MB, while CPU time went up about 20ms. Signed-off-by: Andrii Nakryiko --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 2 +- libbpf-tools/trace_helpers.c | 184 ++++++++++++++++------------------- libbpf-tools/trace_helpers.h | 10 +- 4 files changed, 91 insertions(+), 106 deletions(-) diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 404942cc9..45243f724 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -1,2 +1,3 @@ /.output /runqslower +/drsnoop diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 985278d1b..afbbdac65 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -6,7 +6,7 @@ BPFTOOL ?= bin/bpftool LIBBPF_SRC := $(abspath ../src/cc/libbpf/src) LIBBPF_OBJ := $(abspath $(OUTPUT)/libbpf.a) INCLUDES := -I$(OUTPUT) -CFLAGS := -g -Wall +CFLAGS := -g -O2 -Wall APPS = drsnoop runqslower diff --git a/libbpf-tools/trace_helpers.c b/libbpf-tools/trace_helpers.c index 46cff337f..355fd2d6d 100644 --- a/libbpf-tools/trace_helpers.c +++ b/libbpf-tools/trace_helpers.c @@ -5,150 +5,136 @@ #include #include "trace_helpers.h" -#define MAX_SYMS 300000 - -static int ksyms__insert_symbol(struct ksyms *ksyms, long addr, - const char *name) +struct ksyms { + struct ksym *syms; + int syms_sz; + int syms_cap; + char *strs; + int strs_sz; + int strs_cap; +}; + +static int ksyms__add_symbol(struct ksyms *ksyms, const char *name, unsigned long addr) { - struct ksym *ksym = &ksyms->syms[ksyms->syms_cnt++]; - size_t len = strlen(name) + 1; - - ksym->name = malloc(len); - if (!ksym->name) - return -1; + size_t new_cap, name_len = strlen(name) + 1; + struct ksym *ksym; + void *tmp; + + if (ksyms->strs_sz + name_len > ksyms->strs_cap) { + new_cap = ksyms->strs_cap * 4 / 3; + if (new_cap < ksyms->strs_sz + name_len) + new_cap = ksyms->strs_sz + name_len; + if (new_cap < 1024) + new_cap = 1024; + tmp = realloc(ksyms->strs, new_cap); + if (!tmp) + return -1; + ksyms->strs = tmp; + ksyms->strs_cap = new_cap; + } + if (ksyms->syms_sz + 1 > ksyms->syms_cap) { + new_cap = ksyms->syms_cap * 4 / 3; + if (new_cap < 1024) + new_cap = 1024; + tmp = realloc(ksyms->syms, sizeof(*ksyms->syms) * new_cap); + if (!tmp) + return -1; + ksyms->syms = tmp; + ksyms->syms_cap = new_cap; + } - memcpy((void*)ksym->name, name, len); + ksym = &ksyms->syms[ksyms->syms_sz]; + /* while constructing, re-use pointer as just a plain offset */ + ksym->name = (void *)(unsigned long)ksyms->strs_sz; ksym->addr = addr; - return 0; -} -static struct ksyms *ksyms__new(void) -{ - struct ksyms *ksyms = malloc(sizeof(*ksyms)); + memcpy(ksyms->strs + ksyms->strs_sz, name, name_len); + ksyms->strs_sz += name_len; + ksyms->syms_sz++; - if (!ksyms) - return NULL; - - ksyms->syms_cnt = 0; - ksyms->syms = malloc(MAX_SYMS * sizeof(struct ksym)); - if (!ksyms->syms) - return NULL; - return ksyms; + return 0; } static int ksym_cmp(const void *p1, const void *p2) { - long cmp = ((struct ksym *)p1)->addr - ((struct ksym *)p2)->addr; - - if (cmp < 0) - return -1; - else if (cmp > 0) - return 1; - else - return 0; -} + const struct ksym *s1 = p1, *s2 = p2; -static int hex2long(const char *ptr, long *long_val) -{ - char *p; - - *long_val = strtoul(ptr, &p, 16); - return p - ptr; + if (s1->addr == s2->addr) + return strcmp(s1->name, s2->name); + return s1->addr < s2->addr ? -1 : 1; } struct ksyms *ksyms__load(void) { - FILE *f = fopen("/proc/kallsyms", "r"); - const char *symbol_name; + char sym_type, sym_name[256]; struct ksyms *ksyms; - char *line = NULL; - long symbol_addr; - int line_len; - int parsed; - size_t n; - int err; + unsigned long sym_addr; + int i, ret; + FILE *f; + f = fopen("/proc/kallsyms", "r"); if (!f) return NULL; - ksyms = ksyms__new(); + ksyms = calloc(1, sizeof(*ksyms)); if (!ksyms) - goto cleanup; + goto err_out; - while (!feof(f)) { - line_len = getline(&line, &n, f); - if (line_len < 0 || !line) + while (true) { + ret = fscanf(f, "%lx %c %s%*[^\n]\n", + &sym_addr, &sym_type, sym_name); + if (ret == EOF && feof(f)) break; + if (ret != 3) + goto err_out; + if (ksyms__add_symbol(ksyms, sym_name, sym_addr)) + goto err_out; + } - line[--line_len] = '\0'; /* \n */ - - parsed = hex2long(line, &symbol_addr); - - /* Skip the line if we failed to parse the address. */ - if (!parsed) - continue; - - parsed++; - if (parsed + 2 >= line_len) - continue; - - parsed += 2; /* ignore symbol type */ - symbol_name = line + parsed; - parsed = line_len - parsed; + /* now when strings are finalized, adjust pointers properly */ + for (i = 0; i < ksyms->syms_sz; i++) + ksyms->syms[i].name += (unsigned long)ksyms->strs; - err = ksyms__insert_symbol(ksyms, symbol_addr, symbol_name); - if (err) - goto cleanup; - } + qsort(ksyms->syms, ksyms->syms_sz, sizeof(*ksyms->syms), ksym_cmp); - qsort(ksyms->syms, ksyms->syms_cnt, sizeof(struct ksym), ksym_cmp); + fclose(f); return ksyms; -cleanup: - free(line); +err_out: + ksyms__free(ksyms); fclose(f); return NULL; } void ksyms__free(struct ksyms *ksyms) { - int i; - if (!ksyms) return; - for (i = 0; i < ksyms->syms_cnt; i++) { - free((void*)ksyms->syms[i].name); - } + free(ksyms->syms); + free(ksyms->strs); free(ksyms); } -const struct ksym *ksyms__map_addr(const struct ksyms *ksyms, long addr) +const struct ksym *ksyms__map_addr(const struct ksyms *ksyms, + unsigned long addr) { - int start = 0, end = ksyms->syms_cnt; - long result; - - /* kallsyms not loaded. return NULL */ - if (ksyms->syms_cnt == 0) - return NULL; + int start = 0, end = ksyms->syms_sz - 1, mid; + unsigned long sym_addr; + /* find largest sym_addr <= addr using binary search */ while (start < end) { - size_t mid = start + (end - start) / 2; + mid = start + (end - start + 1) / 2; + sym_addr = ksyms->syms[mid].addr; - result = addr - ksyms->syms[mid].addr; - if (result < 0) - end = mid; - else if (result > 0) - start = mid + 1; + if (sym_addr <= addr) + start = mid; else - return &ksyms->syms[mid]; + end = mid - 1; } - if (start >= 1 && ksyms->syms[start - 1].addr < addr && - addr < ksyms->syms[start].addr) - /* valid ksym */ - return &ksyms->syms[start - 1]; - + if (start == end && ksyms->syms[start].addr <= addr) + return &ksyms->syms[start]; return NULL; } @@ -157,7 +143,7 @@ const struct ksym *ksyms__get_symbol(const struct ksyms *ksyms, { int i; - for (i = 0; i < ksyms->syms_cnt; i++) { + for (i = 0; i < ksyms->syms_sz; i++) { if (strcmp(ksyms->syms[i].name, name) == 0) return &ksyms->syms[i]; } diff --git a/libbpf-tools/trace_helpers.h b/libbpf-tools/trace_helpers.h index d2c06d7de..9d7156e56 100644 --- a/libbpf-tools/trace_helpers.h +++ b/libbpf-tools/trace_helpers.h @@ -3,18 +3,16 @@ #define __TRACE_HELPERS_H struct ksym { - long addr; const char *name; + unsigned long addr; }; -struct ksyms { - struct ksym *syms; - int syms_cnt; -}; +struct ksyms; struct ksyms *ksyms__load(void); void ksyms__free(struct ksyms *ksyms); -const struct ksym *ksyms__map_addr(const struct ksyms *ksyms, long addr); +const struct ksym *ksyms__map_addr(const struct ksyms *ksyms, + unsigned long addr); const struct ksym *ksyms__get_symbol(const struct ksyms *ksyms, const char *name); From 37cd183a71f19c25c08a2a93d271450b392bdca5 Mon Sep 17 00:00:00 2001 From: Fuji Goro Date: Sat, 7 Mar 2020 01:35:44 +0000 Subject: [PATCH 036/278] python binding: allow fully-specified probe names for enable_probe() --- src/python/bcc/libbcc.py | 3 +++ src/python/bcc/usdt.py | 13 +++++++++++-- tests/python/test_usdt3.py | 3 ++- 3 files changed, 16 insertions(+), 3 deletions(-) diff --git a/src/python/bcc/libbcc.py b/src/python/bcc/libbcc.py index 4c992dda9..0f3321556 100644 --- a/src/python/bcc/libbcc.py +++ b/src/python/bcc/libbcc.py @@ -222,6 +222,9 @@ class bcc_symbol_option(ct.Structure): lib.bcc_usdt_enable_probe.restype = ct.c_int lib.bcc_usdt_enable_probe.argtypes = [ct.c_void_p, ct.c_char_p, ct.c_char_p] +lib.bcc_usdt_enable_fully_specified_probe.restype = ct.c_int +lib.bcc_usdt_enable_fully_specified_probe.argtypes = [ct.c_void_p, ct.c_char_p, ct.c_char_p, ct.c_char_p] + lib.bcc_usdt_genargs.restype = ct.c_char_p lib.bcc_usdt_genargs.argtypes = [ct.POINTER(ct.c_void_p), ct.c_int] diff --git a/src/python/bcc/usdt.py b/src/python/bcc/usdt.py index cd2557847..021222f21 100644 --- a/src/python/bcc/usdt.py +++ b/src/python/bcc/usdt.py @@ -147,8 +147,17 @@ def __del__(self): lib.bcc_usdt_close(self.context) def enable_probe(self, probe, fn_name): - if lib.bcc_usdt_enable_probe(self.context, probe.encode('ascii'), - fn_name.encode('ascii')) != 0: + probe_parts = probe.split(":", 1) + if len(probe_parts) == 1: + ret = lib.bcc_usdt_enable_probe( + self.context, probe.encode('ascii'), fn_name.encode('ascii')) + else: + (provider_name, probe_name) = probe_parts + ret = lib.bcc_usdt_enable_fully_specified_probe( + self.context, provider_name.encode('ascii'), probe_name.encode('ascii'), + fn_name.encode('ascii')) + + if ret != 0: raise USDTException( """Failed to enable USDT probe '%s': the specified pid might not contain the given language's runtime, diff --git a/tests/python/test_usdt3.py b/tests/python/test_usdt3.py index 9a40a5ae5..61c1b54ca 100755 --- a/tests/python/test_usdt3.py +++ b/tests/python/test_usdt3.py @@ -20,6 +20,7 @@ def setUp(self): static inline void record_val(int val) { FOLLY_SDT(test, probe, val); + FOLLY_SDT(test_dup_name, probe, val); } extern void record_a(int val); @@ -110,7 +111,7 @@ def _create_file(name, text): def test_attach1(self): # enable USDT probe from given PID and verifier generated BPF programs u = USDT(pid=int(self.app.pid)) - u.enable_probe(probe="probe", fn_name="do_trace") + u.enable_probe(probe="test:probe", fn_name="do_trace") b = BPF(text=self.bpf_text, usdt_contexts=[u]) # processing events From 21625167988a5ed1e07046e8048b4de59e9fd023 Mon Sep 17 00:00:00 2001 From: Fuji Goro Date: Sun, 8 Mar 2020 08:16:54 +0000 Subject: [PATCH 037/278] trace.py: support an optional provider name for the probe spec --- src/cc/bcc_usdt.h | 3 +++ src/cc/usdt/usdt.cc | 9 +++++++++ src/python/bcc/libbcc.py | 3 +++ src/python/bcc/usdt.py | 10 ++++++++-- tools/trace.py | 18 +++++++++++++++--- 5 files changed, 38 insertions(+), 5 deletions(-) diff --git a/src/cc/bcc_usdt.h b/src/cc/bcc_usdt.h index 86e24e4ca..3efdfa462 100644 --- a/src/cc/bcc_usdt.h +++ b/src/cc/bcc_usdt.h @@ -77,6 +77,9 @@ const char *bcc_usdt_genargs(void **ctx_array, int len); const char *bcc_usdt_get_probe_argctype( void *ctx, const char* probe_name, const int arg_index ); +const char *bcc_usdt_get_fully_specified_probe_argctype( + void *ctx, const char* provider_name, const char* probe_name, const int arg_index +); typedef void (*bcc_usdt_uprobe_cb)(const char *, const char *, uint64_t, int); void bcc_usdt_foreach_uprobe(void *usdt, bcc_usdt_uprobe_cb callback); diff --git a/src/cc/usdt/usdt.cc b/src/cc/usdt/usdt.cc index 0c02601ba..c992bbbdf 100644 --- a/src/cc/usdt/usdt.cc +++ b/src/cc/usdt/usdt.cc @@ -506,6 +506,15 @@ const char *bcc_usdt_get_probe_argctype( return ""; } +const char *bcc_usdt_get_fully_specified_probe_argctype( + void *ctx, const char* provider_name, const char* probe_name, const int arg_index +) { + USDT::Probe *p = static_cast(ctx)->get(provider_name, probe_name); + if (p) + return p->get_arg_ctype(arg_index).c_str(); + return ""; +} + void bcc_usdt_foreach(void *usdt, bcc_usdt_cb callback) { USDT::Context *ctx = static_cast(usdt); ctx->each(callback); diff --git a/src/python/bcc/libbcc.py b/src/python/bcc/libbcc.py index 0f3321556..d2c4d2e3e 100644 --- a/src/python/bcc/libbcc.py +++ b/src/python/bcc/libbcc.py @@ -231,6 +231,9 @@ class bcc_symbol_option(ct.Structure): lib.bcc_usdt_get_probe_argctype.restype = ct.c_char_p lib.bcc_usdt_get_probe_argctype.argtypes = [ct.c_void_p, ct.c_char_p, ct.c_int] +lib.bcc_usdt_get_fully_specified_probe_argctype.restype = ct.c_char_p +lib.bcc_usdt_get_fully_specified_probe_argctype.argtypes = [ct.c_void_p, ct.c_char_p, ct.c_char_p, ct.c_int] + class bcc_usdt(ct.Structure): _fields_ = [ ('provider', ct.c_char_p), diff --git a/src/python/bcc/usdt.py b/src/python/bcc/usdt.py index 021222f21..67525c2b2 100644 --- a/src/python/bcc/usdt.py +++ b/src/python/bcc/usdt.py @@ -182,8 +182,14 @@ def get_text(self): return lib.bcc_usdt_genargs(ctx_array, 1).decode() def get_probe_arg_ctype(self, probe_name, arg_index): - return lib.bcc_usdt_get_probe_argctype( - self.context, probe_name.encode('ascii'), arg_index).decode() + probe_parts = probe_name.split(":", 1) + if len(probe_parts) == 1: + return lib.bcc_usdt_get_probe_argctype( + self.context, probe_name.encode('ascii'), arg_index).decode() + else: + (provider_name, probe) = probe_parts + return lib.bcc_usdt_get_fully_specified_probe_argctype( + self.context, provider_name.encode('ascii'), probe.encode('ascii'), arg_index).decode() def enumerate_probes(self): probes = [] diff --git a/tools/trace.py b/tools/trace.py index 8b2ca3587..c87edef72 100755 --- a/tools/trace.py +++ b/tools/trace.py @@ -160,8 +160,9 @@ def _parse_spec(self, spec): self.library = "" # kernel self.function = "" # from TRACEPOINT_PROBE elif self.probe_type == "u": - self.library = ':'.join(parts[1:-1]) - self.usdt_name = parts[-1] + # u:[:]: where : is optional + self.library = parts[1] + self.usdt_name = ":".join(parts[2:]) self.function = "" # no function, just address # We will discover the USDT provider by matching on # the USDT name in the specified library @@ -180,8 +181,17 @@ def _find_usdt_probe(self): target = Probe.pid if Probe.pid and Probe.pid != -1 \ else Probe.tgid self.usdt = USDT(path=self.library, pid=target) + + parts = self.usdt_name.split(":") + if len(parts) == 1: + provider_name = None + usdt_name = parts[0].encode("ascii") + else: + provider_name = parts[0].encode("ascii") + usdt_name = parts[1].encode("ascii") for probe in self.usdt.enumerate_probes(): - if probe.name == self.usdt_name.encode('ascii'): + if ((not provider_name or probe.provider == provider_name) + and probe.name == usdt_name): return # Found it, will enable later self._bail("unrecognized USDT probe %s" % self.usdt_name) @@ -677,6 +687,8 @@ class Tool(object): Trace the block_rq_complete kernel tracepoint and print # of tx sectors trace 'u:pthread:pthread_create (arg4 != 0)' Trace the USDT probe pthread_create when its 4th argument is non-zero +trace 'u:pthread:libpthread:pthread_create (arg4 != 0)' + Ditto, but the provider name "libpthread" is specified. trace 'p::SyS_nanosleep(struct timespec *ts) "sleep for %lld ns", ts->tv_nsec' Trace the nanosleep syscall and print the sleep duration in ns trace -c /sys/fs/cgroup/system.slice/workload.service '__x64_sys_nanosleep' '__x64_sys_clone' From 9465f8cf2a19d28dcc8bce5845b5e8017ee9feb8 Mon Sep 17 00:00:00 2001 From: edwardwu Date: Mon, 9 Mar 2020 14:09:52 +0800 Subject: [PATCH 038/278] softirqs: Combined CPU as part of the key is necessary to avoid amiss value. In the environment of massive software interrupts. -0 [003] ..s1 106.421020: softirq_entry: vec=6 [action=TASKLET] -0 [000] ..s1 106.421063: softirq_entry: vec=3 [action=NET_RX] -0 [003] ..s1 106.421083: softirq_exit: vec=6 [action=TASKLET] Follow the above ftrace logs, we know the correct vec-6 start timestamp is replaced with incorrect vec-3. Because PID is idle-0. It will produce the wrong result after calculating delta. --- tools/softirqs.py | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/tools/softirqs.py b/tools/softirqs.py index 1e2daf5f9..32bbef5de 100755 --- a/tools/softirqs.py +++ b/tools/softirqs.py @@ -54,6 +54,11 @@ bpf_text = """ #include +typedef struct entry_key { + u32 pid; + u32 cpu; +} entry_key_t; + typedef struct irq_key { u32 vec; u64 slot; @@ -64,17 +69,22 @@ u32 vec; } account_val_t; -BPF_HASH(start, u32, account_val_t); +BPF_HASH(start, entry_key_t, account_val_t); BPF_HASH(iptr, u32); BPF_HISTOGRAM(dist, irq_key_t); TRACEPOINT_PROBE(irq, softirq_entry) { - u32 pid = bpf_get_current_pid_tgid(); account_val_t val = {}; + entry_key_t key = {}; + + key.pid = bpf_get_current_pid_tgid(); + key.cpu = bpf_get_smp_processor_id(); val.ts = bpf_ktime_get_ns(); val.vec = args->vec; - start.update(&pid, &val); + + start.update(&key, &val); + return 0; } @@ -82,12 +92,15 @@ { u64 delta; u32 vec; - u32 pid = bpf_get_current_pid_tgid(); account_val_t *valp; irq_key_t key = {0}; + entry_key_t entry_key = {}; + + entry_key.pid = bpf_get_current_pid_tgid(); + entry_key.cpu = bpf_get_smp_processor_id(); // fetch timestamp and calculate delta - valp = start.lookup(&pid); + valp = start.lookup(&entry_key); if (valp == 0) { return 0; // missed start } @@ -97,7 +110,7 @@ // store as sum or histogram STORE - start.delete(&pid); + start.delete(&entry_key); return 0; } """ From 15e998db6ea8617ae8798a09b9d8115ce5e95473 Mon Sep 17 00:00:00 2001 From: Alban Crequy Date: Fri, 6 Mar 2020 19:40:28 +0100 Subject: [PATCH 039/278] tools: add option --cgroupmap to capable.py Documentation (man page and example text) updated. --- man/man8/capable.8 | 12 ++++++++++-- tools/capable.py | 18 ++++++++++++++++++ tools/capable_example.txt | 25 +++++++++++++++++++------ 3 files changed, 47 insertions(+), 8 deletions(-) diff --git a/man/man8/capable.8 b/man/man8/capable.8 index e20eb78fa..6f7768673 100644 --- a/man/man8/capable.8 +++ b/man/man8/capable.8 @@ -1,8 +1,8 @@ -.TH capable 8 "2016-09-13" "USER COMMANDS" +.TH capable 8 "2020-03-06" "USER COMMANDS" .SH NAME capable \- Trace security capability checks (cap_capable()). .SH SYNOPSIS -.B capable [\-h] [\-v] [\-p PID] [\-K] [\-U] +.B capable [\-h] [\-v] [\-p PID] [\-K] [\-U] [\-x] [\-\-cgroupmap MAPPATH] .SH DESCRIPTION This traces security capability checks in the kernel, and prints details for each call. This can be useful for general debugging, and also security @@ -28,6 +28,9 @@ Include user-space stack traces to the output. .TP \-x Show extra fields in TID and INSETID columns. +.TP +\-\-cgroupmap MAPPATH +Trace cgroups in this BPF map only (filtered in-kernel). .SH EXAMPLES .TP Trace all capability checks system-wide: @@ -37,6 +40,11 @@ Trace all capability checks system-wide: Trace capability checks for PID 181: # .B capable \-p 181 +.TP +Trace capability checks in a set of cgroups only (see filtering_by_cgroups.md +from bcc sources for more details): +# +.B capable \-\-cgroupmap /sys/fs/bpf/test01 .SH FIELDS .TP TIME(s) diff --git a/tools/capable.py b/tools/capable.py index 69fef3de4..64e6069f0 100755 --- a/tools/capable.py +++ b/tools/capable.py @@ -27,6 +27,7 @@ ./capable -K # add kernel stacks to trace ./capable -U # add user-space stacks to trace ./capable -x # extra fields: show TID and INSETID columns + ./capable --cgroupmap ./mappath # only trace cgroups in this BPF map """ parser = argparse.ArgumentParser( description="Trace security capability checks", @@ -42,6 +43,8 @@ help="output user stack trace") parser.add_argument("-x", "--extra", action="store_true", help="show extra fields in TID and INSETID columns") +parser.add_argument("--cgroupmap", + help="trace cgroups in this BPF map only") args = parser.parse_args() debug = 0 @@ -122,6 +125,10 @@ def __getattr__(self, name): BPF_PERF_OUTPUT(events); +#if CGROUPSET +BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); +#endif + #if defined(USER_STACKS) || defined(KERNEL_STACKS) BPF_STACK_TRACE(stacks, 2048); #endif @@ -146,6 +153,12 @@ def __getattr__(self, name): FILTER1 FILTER2 FILTER3 +#if CGROUPSET + u64 cgroupid = bpf_get_current_cgroup_id(); + if (cgroupset.lookup(&cgroupid) == NULL) { + return 0; + } +#endif u32 uid = bpf_get_current_uid_gid(); struct data_t data = {.tgid = tgid, .pid = pid, .uid = uid, .cap = cap, .audit = audit, .insetid = insetid}; @@ -174,6 +187,11 @@ def __getattr__(self, name): bpf_text = bpf_text.replace('FILTER2', '') bpf_text = bpf_text.replace('FILTER3', 'if (pid == %s) { return 0; }' % getpid()) +if args.cgroupmap: + bpf_text = bpf_text.replace('CGROUPSET', '1') + bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) +else: + bpf_text = bpf_text.replace('CGROUPSET', '0') if debug: print(bpf_text) diff --git a/tools/capable_example.txt b/tools/capable_example.txt index 28e44a5d6..f82e6925c 100644 --- a/tools/capable_example.txt +++ b/tools/capable_example.txt @@ -88,19 +88,30 @@ TIME UID PID COMM CAP NAME AUDIT Similarly, it is possible to include user-space stack with -U (or they can be used both at the same time to include user and kernel stack). +The --cgroupmap option filters based on a cgroup set. It is meant to be used +with an externally created map. + +# ./capable.py --cgroupmap /sys/fs/bpf/test01 + +For more details, see docs/filtering_by_cgroups.md + + USAGE: # ./capable.py -h -usage: capable.py [-h] [-v] [-p PID] [-K] [-U] +usage: capable.py [-h] [-v] [-p PID] [-K] [-U] [-x] [--cgroupmap CGROUPMAP] Trace security capability checks optional arguments: - -h, --help show this help message and exit - -v, --verbose include non-audit checks - -p PID, --pid PID trace this PID only - -K, --kernel-stack output kernel stack trace - -U, --user-stack output user stack trace + -h, --help show this help message and exit + -v, --verbose include non-audit checks + -p PID, --pid PID trace this PID only + -K, --kernel-stack output kernel stack trace + -U, --user-stack output user stack trace + -x, --extra show extra fields in TID and INSETID columns + --cgroupmap CGROUPMAP + trace cgroups in this BPF map only examples: ./capable # trace capability checks @@ -108,3 +119,5 @@ examples: ./capable -p 181 # only trace PID 181 ./capable -K # add kernel stacks to trace ./capable -U # add user-space stacks to trace + ./capable -x # extra fields: show TID and INSETID columns + ./capable --cgroupmap ./mappath # only trace cgroups in this BPF map From 9d7feeed87c5e2977e0e996cc097dcd9d3001c0d Mon Sep 17 00:00:00 2001 From: Alban Crequy Date: Sun, 8 Mar 2020 13:46:15 +0100 Subject: [PATCH 040/278] tools: add option --unique to capable.py Some processes can do a lot of security capability checks, generating a lot of ouput. In this case, the --unique option is useful to only print once the same set of capability, pid (or cgroup if --cgroupmap is used) and kernel/user stacks (if -K or -U are used). # ./capable.py -K -U --unique Documentation (man page and example text) updated. --- man/man8/capable.8 | 6 ++++- tools/capable.py | 46 +++++++++++++++++++++++++++++++++++++++ tools/capable_example.txt | 10 +++++++++ 3 files changed, 61 insertions(+), 1 deletion(-) diff --git a/man/man8/capable.8 b/man/man8/capable.8 index 6f7768673..dfb8a6aad 100644 --- a/man/man8/capable.8 +++ b/man/man8/capable.8 @@ -1,8 +1,9 @@ -.TH capable 8 "2020-03-06" "USER COMMANDS" +.TH capable 8 "2020-03-08" "USER COMMANDS" .SH NAME capable \- Trace security capability checks (cap_capable()). .SH SYNOPSIS .B capable [\-h] [\-v] [\-p PID] [\-K] [\-U] [\-x] [\-\-cgroupmap MAPPATH] + [--unique] .SH DESCRIPTION This traces security capability checks in the kernel, and prints details for each call. This can be useful for general debugging, and also security @@ -31,6 +32,9 @@ Show extra fields in TID and INSETID columns. .TP \-\-cgroupmap MAPPATH Trace cgroups in this BPF map only (filtered in-kernel). +.TP +\-\-unique +Don't repeat stacks for the same PID or cgroup. .SH EXAMPLES .TP Trace all capability checks system-wide: diff --git a/tools/capable.py b/tools/capable.py index 64e6069f0..c19cddb93 100755 --- a/tools/capable.py +++ b/tools/capable.py @@ -27,6 +27,7 @@ ./capable -K # add kernel stacks to trace ./capable -U # add user-space stacks to trace ./capable -x # extra fields: show TID and INSETID columns + ./capable --unique # don't repeat stacks for the same pid or cgroup ./capable --cgroupmap ./mappath # only trace cgroups in this BPF map """ parser = argparse.ArgumentParser( @@ -45,6 +46,8 @@ help="show extra fields in TID and INSETID columns") parser.add_argument("--cgroupmap", help="trace cgroups in this BPF map only") +parser.add_argument("--unique", action="store_true", + help="don't repeat stacks for the same pid or cgroup") args = parser.parse_args() debug = 0 @@ -125,6 +128,23 @@ def __getattr__(self, name): BPF_PERF_OUTPUT(events); +#if UNIQUESET +struct repeat_t { + int cap; + u32 tgid; +#if CGROUPSET + u64 cgroupid; +#endif +#ifdef KERNEL_STACKS + int kernel_stack_id; +#endif +#ifdef USER_STACKS + int user_stack_id; +#endif +}; +BPF_HASH(seen, struct repeat_t, u64); +#endif + #if CGROUPSET BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); #endif @@ -168,6 +188,28 @@ def __getattr__(self, name): #ifdef USER_STACKS data.user_stack_id = stacks.get_stackid(ctx, BPF_F_USER_STACK); #endif + +#if UNIQUESET + struct repeat_t repeat = {0,}; + repeat.cap = cap; +#if CGROUPSET + repeat.cgroupid = bpf_get_current_cgroup_id(), +#else + repeat.tgid = tgid; +#endif +#ifdef KERNEL_STACKS + repeat.kernel_stack_id = data.kernel_stack_id; +#endif +#ifdef USER_STACKS + repeat.user_stack_id = data.user_stack_id; +#endif + if (seen.lookup(&repeat) != NULL) { + return 0; + } + u64 zero = 0; + seen.update(&repeat, &zero); +#endif + bpf_get_current_comm(&data.comm, sizeof(data.comm)); events.perf_submit(ctx, &data, sizeof(data)); @@ -192,6 +234,10 @@ def __getattr__(self, name): bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) else: bpf_text = bpf_text.replace('CGROUPSET', '0') +if args.unique: + bpf_text = bpf_text.replace('UNIQUESET', '1') +else: + bpf_text = bpf_text.replace('UNIQUESET', '0') if debug: print(bpf_text) diff --git a/tools/capable_example.txt b/tools/capable_example.txt index f82e6925c..bcd6d01ee 100644 --- a/tools/capable_example.txt +++ b/tools/capable_example.txt @@ -88,6 +88,13 @@ TIME UID PID COMM CAP NAME AUDIT Similarly, it is possible to include user-space stack with -U (or they can be used both at the same time to include user and kernel stack). +Some processes can do a lot of security capability checks, generating a lot of +ouput. In this case, the --unique option is useful to only print once the same +set of capability, pid (or cgroup if --cgroupmap is used) and kernel/user +stacks (if -K or -U are used). + +# ./capable.py -K -U --unique + The --cgroupmap option filters based on a cgroup set. It is meant to be used with an externally created map. @@ -100,6 +107,7 @@ USAGE: # ./capable.py -h usage: capable.py [-h] [-v] [-p PID] [-K] [-U] [-x] [--cgroupmap CGROUPMAP] + [--unique] Trace security capability checks @@ -112,6 +120,7 @@ optional arguments: -x, --extra show extra fields in TID and INSETID columns --cgroupmap CGROUPMAP trace cgroups in this BPF map only + --unique don't repeat stacks for the same pid or cgroup examples: ./capable # trace capability checks @@ -120,4 +129,5 @@ examples: ./capable -K # add kernel stacks to trace ./capable -U # add user-space stacks to trace ./capable -x # extra fields: show TID and INSETID columns + ./capable --unique # don't repeat stacks for the same pid or cgroup ./capable --cgroupmap ./mappath # only trace cgroups in this BPF map From c9cfb52f3bc39fd78f40e3c3de5e066239ce1904 Mon Sep 17 00:00:00 2001 From: Alban Crequy Date: Sun, 8 Mar 2020 14:05:40 +0100 Subject: [PATCH 041/278] Reduce container image size with multi-stage builds Before this patch, Dockerfile.ubuntu was generating an oversized image. Uncompressed size Compressed size Before this patch: 1.3GB 390MB After this patch: 250MB 110MB --- Dockerfile.ubuntu | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/Dockerfile.ubuntu b/Dockerfile.ubuntu index 596f23e00..8ac79066a 100644 --- a/Dockerfile.ubuntu +++ b/Dockerfile.ubuntu @@ -1,4 +1,4 @@ -FROM ubuntu:bionic +FROM ubuntu:bionic as builder MAINTAINER Brenden Blanco @@ -10,7 +10,14 @@ COPY ./ /root/bcc WORKDIR /root/bcc RUN /usr/lib/pbuilder/pbuilder-satisfydepends && \ - ./scripts/build-deb.sh && \ + ./scripts/build-deb.sh + + +FROM ubuntu:bionic + +COPY --from=builder /root/bcc/*.deb /root/bcc/ + +RUN \ apt-get update -y && \ DEBIAN_FRONTEND=noninteractive apt-get install -y python python3 binutils libelf1 && \ dpkg -i /root/bcc/*.deb From 5e123df1dd33cdff5798560e4f0390c69cdba00f Mon Sep 17 00:00:00 2001 From: Brendan Gregg Date: Mon, 9 Mar 2020 09:46:22 -0700 Subject: [PATCH 042/278] libbpf-tools: add CO-RE opensnoop (#2778) * libbpf-tools: add CO-RE opensnoop * libbpf-tools/opensnoop: feedback --- libbpf-tools/Makefile | 2 +- libbpf-tools/opensnoop.bpf.c | 131 +++++++++++++++ libbpf-tools/opensnoop.c | 315 +++++++++++++++++++++++++++++++++++ libbpf-tools/opensnoop.h | 24 +++ 4 files changed, 471 insertions(+), 1 deletion(-) create mode 100644 libbpf-tools/opensnoop.bpf.c create mode 100644 libbpf-tools/opensnoop.c create mode 100644 libbpf-tools/opensnoop.h diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index afbbdac65..399a086db 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -8,7 +8,7 @@ LIBBPF_OBJ := $(abspath $(OUTPUT)/libbpf.a) INCLUDES := -I$(OUTPUT) CFLAGS := -g -O2 -Wall -APPS = drsnoop runqslower +APPS = drsnoop opensnoop runqslower .PHONY: all all: $(APPS) diff --git a/libbpf-tools/opensnoop.bpf.c b/libbpf-tools/opensnoop.bpf.c new file mode 100644 index 000000000..0b2589c62 --- /dev/null +++ b/libbpf-tools/opensnoop.bpf.c @@ -0,0 +1,131 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2019 Facebook +// Copyright (c) 2020 Netflix +#include "vmlinux.h" +#include +#include "opensnoop.h" + +#define TASK_RUNNING 0 + +#define BPF_F_INDEX_MASK 0xffffffffULL +#define BPF_F_CURRENT_CPU BPF_F_INDEX_MASK + +const volatile __u64 min_us = 0; +const volatile pid_t targ_pid = 0; +const volatile pid_t targ_tgid = 0; +const volatile pid_t targ_uid = 0; +const volatile bool targ_failed = false; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, 10240); + __type(key, u32); + __type(value, struct args_t); +} start SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY); + __uint(key_size, sizeof(u32)); + __uint(value_size, sizeof(u32)); +} events SEC(".maps"); + +static __always_inline +int trace_filtered(u32 tgid, u32 pid) +{ + u32 uid; + + /* filters */ + if (targ_tgid && targ_tgid != tgid) + return 1; + if (targ_pid && targ_pid != pid) + return 1; + if (targ_uid) { + uid = bpf_get_current_uid_gid(); + if (targ_uid != uid) { + return 1; + } + } + return 0; +} + +SEC("tracepoint/syscalls/sys_enter_open") +int tracepoint__syscalls__sys_enter_open(struct trace_event_raw_sys_enter* ctx) +{ + u64 id = bpf_get_current_pid_tgid(); + /* use kernel terminology here for tgid/pid: */ + u32 tgid = id >> 32; + u32 pid = id; + + /* store arg info for later lookup */ + if (!trace_filtered(tgid, pid)) { + struct args_t args = {}; + args.fname = (const char *)ctx->args[0]; + args.flags = (int)ctx->args[1]; + bpf_map_update_elem(&start, &pid, &args, 0); + } + return 0; +} + +SEC("tracepoint/syscalls/sys_enter_openat") +int tracepoint__syscalls__sys_enter_openat(struct trace_event_raw_sys_enter* ctx) +{ + u64 id = bpf_get_current_pid_tgid(); + /* use kernel terminology here for tgid/pid: */ + u32 tgid = id >> 32; + u32 pid = id; + + /* store arg info for later lookup */ + if (!trace_filtered(tgid, pid)) { + struct args_t args = {}; + args.fname = (const char *)ctx->args[1]; + args.flags = (int)ctx->args[2]; + bpf_map_update_elem(&start, &pid, &args, 0); + } + return 0; +} + +static __always_inline +int trace_exit(struct trace_event_raw_sys_exit* ctx) +{ + struct event event = {}; + struct args_t *ap; + int ret; + u32 pid = bpf_get_current_pid_tgid(); + + ap = bpf_map_lookup_elem(&start, &pid); + if (!ap) + return 0; /* missed entry */ + ret = ctx->ret; + if (targ_failed && ret >= 0) + goto cleanup; /* want failed only */ + + /* event data */ + event.pid = bpf_get_current_pid_tgid() >> 32; + event.uid = bpf_get_current_uid_gid(); + bpf_get_current_comm(&event.comm, sizeof(event.comm)); + bpf_probe_read_str(&event.fname, sizeof(event.fname), ap->fname); + event.flags = ap->flags; + event.ret = ret; + + /* emit event */ + bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, + &event, sizeof(event)); + +cleanup: + bpf_map_delete_elem(&start, &pid); + return 0; +} + +SEC("tracepoint/syscalls/sys_exit_open") +int tracepoint__syscalls__sys_exit_open(struct trace_event_raw_sys_exit* ctx) +{ + return trace_exit(ctx); +} + +SEC("tracepoint/syscalls/sys_exit_openat") +int tracepoint__syscalls__sys_exit_openat(struct trace_event_raw_sys_exit* ctx) +{ + return trace_exit(ctx); +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/opensnoop.c b/libbpf-tools/opensnoop.c new file mode 100644 index 000000000..e6f50f50a --- /dev/null +++ b/libbpf-tools/opensnoop.c @@ -0,0 +1,315 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2019 Facebook +// Copyright (c) 2020 Netflix +// +// Based on opensnoop(8) from BCC by Brendan Gregg and others. +// 14-Feb-2020 Brendan Gregg Created this. +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "opensnoop.h" +#include "opensnoop.skel.h" + +/* Tune the buffer size and wakeup rate. These settings cope with roughly + * 50k opens/sec. + */ +#define PERF_BUFFER_PAGES 64 +#define PERF_BUFFER_TIME_MS 10 + +/* Set the poll timeout when no events occur. This can affect -d accuracy. */ +#define PERF_POLL_TIMEOUT_MS 100 + +#define NSEC_PER_SEC 1000000000ULL + +static struct env { + pid_t pid; + pid_t tid; + uid_t uid; + int duration; + bool verbose; + bool timestamp; + bool print_uid; + bool extended; + bool failed; + char *name; +} env = {}; + +const char *argp_program_version = "opensnoop 0.1"; +const char *argp_program_bug_address = ""; +const char argp_program_doc[] = +"Trace open family syscalls\n" +"\n" +"USAGE: opensnoop [-h] [-T] [-U] [-x] [-p PID] [-t TID] [-u UID] [-d DURATION]\n" +" [-n NAME] [-e]\n" +"\n" +"EXAMPLES:\n" +" ./opensnoop # trace all open() syscalls\n" +" ./opensnoop -T # include timestamps\n" +" ./opensnoop -U # include UID\n" +" ./opensnoop -x # only show failed opens\n" +" ./opensnoop -p 181 # only trace PID 181\n" +" ./opensnoop -t 123 # only trace TID 123\n" +" ./opensnoop -u 1000 # only trace UID 1000\n" +" ./opensnoop -d 10 # trace for 10 seconds only\n" +" ./opensnoop -n main # only print process names containing \"main\"\n" +" ./opensnoop -e # show extended fields\n"; + +static const struct argp_option opts[] = { + { "duration", 'd', "DURATION", 0, "Duration to trace"}, + { "extended-fields", 'e', NULL, 0, "Print extended fields"}, + { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help"}, + { "name", 'n', "NAME", 0, "Trace process names containing this"}, + { "pid", 'p', "PID", 0, "Process ID to trace"}, + { "tid", 't', "TID", 0, "Thread ID to trace"}, + { "timestamp", 'T', NULL, 0, "Print timestamp"}, + { "uid", 'u', "UID", 0, "User ID to trace"}, + { "print-uid", 'U', NULL, 0, "Print UID"}, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + { "failed", 'x', NULL, 0, "Failed opens only"}, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static int pos_args; + int pid, uid, duration; + + switch (key) { + case 'e': + env.extended = true; + break; + case 'h': + argp_usage(state); + break; + case 'T': + env.timestamp = true; + break; + case 'U': + env.print_uid = true; + break; + case 'v': + env.verbose = true; + break; + case 'x': + env.failed = true; + break; + case 'd': + errno = 0; + duration = strtol(arg, NULL, 10); + if (errno || duration <= 0) { + fprintf(stderr, "Invalid duration: %s\n", arg); + argp_usage(state); + } + env.duration = duration; + break; + case 'n': + errno = 0; + env.name = arg; + break; + case 'p': + errno = 0; + pid = strtol(arg, NULL, 10); + if (errno || pid <= 0) { + fprintf(stderr, "Invalid PID: %s\n", arg); + argp_usage(state); + } + env.pid = pid; + break; + case 't': + errno = 0; + pid = strtol(arg, NULL, 10); + if (errno || pid <= 0) { + fprintf(stderr, "Invalid TID: %s\n", arg); + argp_usage(state); + } + env.tid = pid; + break; + case 'u': + errno = 0; + uid = strtol(arg, NULL, 10); + if (errno || uid <= 0) { + fprintf(stderr, "Invalid UID %s\n", arg); + argp_usage(state); + } + env.uid = uid; + break; + case ARGP_KEY_ARG: + if (pos_args++) { + fprintf(stderr, + "Unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + errno = 0; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static int bump_memlock_rlimit(void) +{ + struct rlimit rlim_new = { + .rlim_cur = RLIM_INFINITY, + .rlim_max = RLIM_INFINITY, + }; + + return setrlimit(RLIMIT_MEMLOCK, &rlim_new); +} + +void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) +{ + const struct event *e = data; + struct tm *tm; + char ts[32]; + time_t t; + int fd, err; + + /* name filtering is currently done in user space */ + if (env.name && strstr(e->comm, env.name) == NULL) + return; + + /* prepare fields */ + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + if (e->ret >= 0) { + fd = e->ret; + err = 0; + } else { + fd = -1; + err = - e->ret; + } + + /* print output */ + if (env.timestamp) + printf("%-8s ", ts); + if (env.print_uid) + printf("%-6d ", e->uid); + printf("%-6d %-16s %3d %3d ", e->pid, e->comm, fd, err); + if (env.extended) + printf("%08o ", e->flags); + printf("%s\n", e->fname); +} + +void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt) +{ + fprintf(stderr, "Lost %llu events on CPU #%d!\n", lost_cnt, cpu); +} + +__u64 gettimens() +{ + struct timespec ts = {}; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec); +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct perf_buffer_opts pb_opts; + struct perf_buffer *pb = NULL; + struct opensnoop_bpf *obj; + __u64 time_end; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = opensnoop_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF object\n"); + return 1; + } + + /* initialize global data (filtering options) */ + obj->rodata->targ_tgid = env.pid; + obj->rodata->targ_pid = env.tid; + obj->rodata->targ_uid = env.uid; + obj->rodata->targ_failed = env.failed; + + err = opensnoop_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + err = opensnoop_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs\n"); + goto cleanup; + } + + /* print headers */ + if (env.timestamp) + printf("%-8s ", "TIME"); + if (env.print_uid) + printf("%-6s ", "UID"); + printf("%-6s %-16s %3s %3s ", "PID", "COMM", "FD", "ERR"); + if (env.extended) + printf("%-8s ", "FLAGS"); + printf("%s\n", "PATH"); + + /* setup event callbacks */ + pb_opts.sample_cb = handle_event; + pb_opts.lost_cb = handle_lost_events; + pb = perf_buffer__new(bpf_map__fd(obj->maps.events), PERF_BUFFER_PAGES, + &pb_opts); + err = libbpf_get_error(pb); + if (err) { + pb = NULL; + fprintf(stderr, "failed to open perf buffer: %d\n", err); + goto cleanup; + } + + /* setup duration */ + if (env.duration) + time_end = gettimens() + env.duration * NSEC_PER_SEC; + + /* main: poll */ + while (1) { + usleep(PERF_BUFFER_TIME_MS * 1000); + if ((err = perf_buffer__poll(pb, PERF_POLL_TIMEOUT_MS)) < 0) + break; + if (env.duration) { + if (gettimens() > time_end) { + goto cleanup; + } + } + } + printf("Error polling perf buffer: %d\n", err); + +cleanup: + perf_buffer__free(pb); + opensnoop_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/opensnoop.h b/libbpf-tools/opensnoop.h new file mode 100644 index 000000000..a1e0c0c32 --- /dev/null +++ b/libbpf-tools/opensnoop.h @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __OPENSNOOP_H +#define __OPENSNOOP_H + +#define TASK_COMM_LEN 16 +#define NAME_MAX 255 + +struct args_t { + const char *fname; + int flags; +}; + +struct event { + /* user terminology for pid: */ + __u64 ts; + pid_t pid; + uid_t uid; + int ret; + int flags; + char comm[TASK_COMM_LEN]; + char fname[NAME_MAX]; +}; + +#endif /* __OPENSNOOP_H */ From 7d62656805cca60ff9d6f5e9b8b5b8d096cf226a Mon Sep 17 00:00:00 2001 From: Alban Crequy Date: Sun, 8 Mar 2020 16:41:34 +0100 Subject: [PATCH 043/278] tools: add option --cgroupmap to tcptop --- man/man8/tcptop.8 | 12 ++++++++++-- tools/tcptop.py | 24 ++++++++++++++++++++++++ tools/tcptop_example.txt | 25 ++++++++++++++++++------- 3 files changed, 52 insertions(+), 9 deletions(-) diff --git a/man/man8/tcptop.8 b/man/man8/tcptop.8 index 672e8eddd..631c00c32 100644 --- a/man/man8/tcptop.8 +++ b/man/man8/tcptop.8 @@ -1,8 +1,9 @@ -.TH tcptop 8 "2016-09-13" "USER COMMANDS" +.TH tcptop 8 "2020-03-08" "USER COMMANDS" .SH NAME tcptop \- Summarize TCP send/recv throughput by host. Top for TCP. .SH SYNOPSIS -.B tcptop [\-h] [\-C] [\-S] [\-p PID] [interval] [count] +.B tcptop [\-h] [\-C] [\-S] [\-p PID] [\-\-cgroupmap MAPPATH] + [interval] [count] .SH DESCRIPTION This is top for TCP sessions. @@ -35,6 +36,9 @@ Don't print the system summary line (load averages). \-p PID Trace this PID only. .TP +\-\-cgroupmap MAPPATH +Trace cgroups in this BPF map only (filtered in-kernel). +.TP interval Interval between updates, seconds (default 1). .TP @@ -53,6 +57,10 @@ Don't clear the screen (rolling output), and 5 second summaries: Trace PID 181 only, and don't clear the screen: # .B tcptop \-Cp 181 +.TP +Trace a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +# +.B tcptop \-\-cgroupmap /sys/fs/bpf/test01 .SH FIELDS .TP loadavg: diff --git a/tools/tcptop.py b/tools/tcptop.py index 330d5bbbb..2d4b7572e 100755 --- a/tools/tcptop.py +++ b/tools/tcptop.py @@ -45,6 +45,7 @@ def range_check(string): ./tcptop # trace TCP send/recv by host ./tcptop -C # don't clear the screen ./tcptop -p 181 # only trace PID 181 + ./tcptop --cgroupmap ./mappath # only trace cgroups in this BPF map """ parser = argparse.ArgumentParser( description="Summarize TCP send/recv throughput by host", @@ -60,6 +61,8 @@ def range_check(string): help="output interval, in seconds (default 1)") parser.add_argument("count", nargs="?", default=-1, type=range_check, help="number of outputs") +parser.add_argument("--cgroupmap", + help="trace cgroups in this BPF map only") parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) args = parser.parse_args() @@ -94,11 +97,21 @@ def range_check(string): BPF_HASH(ipv6_send_bytes, struct ipv6_key_t); BPF_HASH(ipv6_recv_bytes, struct ipv6_key_t); +#if CGROUPSET +BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); +#endif + int kprobe__tcp_sendmsg(struct pt_regs *ctx, struct sock *sk, struct msghdr *msg, size_t size) { u32 pid = bpf_get_current_pid_tgid() >> 32; FILTER +#if CGROUPSET + u64 cgroupid = bpf_get_current_cgroup_id(); + if (cgroupset.lookup(&cgroupid) == NULL) { + return 0; + } +#endif u16 dport = 0, family = sk->__sk_common.skc_family; if (family == AF_INET) { @@ -136,6 +149,12 @@ def range_check(string): { u32 pid = bpf_get_current_pid_tgid() >> 32; FILTER +#if CGROUPSET + u64 cgroupid = bpf_get_current_cgroup_id(); + if (cgroupset.lookup(&cgroupid) == NULL) { + return 0; + } +#endif u16 dport = 0, family = sk->__sk_common.skc_family; u64 *val, zero = 0; @@ -174,6 +193,11 @@ def range_check(string): 'if (pid != %s) { return 0; }' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '') +if args.cgroupmap: + bpf_text = bpf_text.replace('CGROUPSET', '1') + bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) +else: + bpf_text = bpf_text.replace('CGROUPSET', '0') if debug or args.ebpf: print(bpf_text) if args.ebpf: diff --git a/tools/tcptop_example.txt b/tools/tcptop_example.txt index 63ba2efae..379aff208 100644 --- a/tools/tcptop_example.txt +++ b/tools/tcptop_example.txt @@ -92,25 +92,36 @@ PID COMM LADDR RADDR RX_KB TX_KB You can disable the loadavg summary line with -S if needed. +The --cgroupmap option filters based on a cgroup set. It is meant to be used +with an externally created map. + +# tcptop --cgroupmap /sys/fs/bpf/test01 + +For more details, see docs/filtering_by_cgroups.md + USAGE: # tcptop -h -usage: tcptop.py [-h] [-C] [-S] [-p PID] [interval] [count] +usage: tcptop.py [-h] [-C] [-S] [-p PID] [--cgroupmap CGROUPMAP] + [interval] [count] Summarize TCP send/recv throughput by host positional arguments: - interval output interval, in seconds (default 1) - count number of outputs + interval output interval, in seconds (default 1) + count number of outputs optional arguments: - -h, --help show this help message and exit - -C, --noclear don't clear the screen - -S, --nosummary skip system summary line - -p PID, --pid PID trace this PID only + -h, --help show this help message and exit + -C, --noclear don't clear the screen + -S, --nosummary skip system summary line + -p PID, --pid PID trace this PID only + --cgroupmap CGROUPMAP + trace cgroups in this BPF map only examples: ./tcptop # trace TCP send/recv by host ./tcptop -C # don't clear the screen ./tcptop -p 181 # only trace PID 181 + ./tcptop --cgroupmap ./mappath # only trace cgroups in this BPF map From 8b6a7db9c8eeb5c513a162c90a7dd8f0bd7620dd Mon Sep 17 00:00:00 2001 From: Andrii Nakryiko Date: Mon, 9 Mar 2020 00:11:48 -0700 Subject: [PATCH 044/278] libbpf-tools: update vmlinux.h with BPF helper flags generated from UAPI Update vmlinux.h to a version generated from same v5.5 tag and default config with cherry-picked 1aae4bdd7879 ("bpf: Switch BPF UAPI #define constants used from BPF program side to enums") on top of it. This adds lots of BPF helper flags often useful from BPF program side. Signed-off-by: Andrii Nakryiko --- libbpf-tools/vmlinux_505.h | 415 ++++++++++++++++++++++--------------- 1 file changed, 246 insertions(+), 169 deletions(-) diff --git a/libbpf-tools/vmlinux_505.h b/libbpf-tools/vmlinux_505.h index beed1f2fd..092bd646d 100644 --- a/libbpf-tools/vmlinux_505.h +++ b/libbpf-tools/vmlinux_505.h @@ -1,3 +1,6 @@ +#ifndef __VMLINUX_H__ +#define __VMLINUX_H__ + #ifndef BPF_NO_PRESERVE_ACCESS_INDEX #pragma clang attribute push (__attribute__((preserve_access_index)), apply_to = record) #endif @@ -4699,10 +4702,10 @@ struct orc_entry { } __attribute__((packed)); enum perf_event_state { - PERF_EVENT_STATE_DEAD = -4, - PERF_EVENT_STATE_EXIT = -3, - PERF_EVENT_STATE_ERROR = -2, - PERF_EVENT_STATE_OFF = -1, + PERF_EVENT_STATE_DEAD = 4294967292, + PERF_EVENT_STATE_EXIT = 4294967293, + PERF_EVENT_STATE_ERROR = 4294967294, + PERF_EVENT_STATE_OFF = 4294967295, PERF_EVENT_STATE_INACTIVE = 0, PERF_EVENT_STATE_ACTIVE = 1, }; @@ -7316,7 +7319,7 @@ struct device_node { }; enum cpuhp_state { - CPUHP_INVALID = -1, + CPUHP_INVALID = 4294967295, CPUHP_OFFLINE = 0, CPUHP_CREATE_THREADS = 1, CPUHP_PERF_PREPARE = 2, @@ -8759,7 +8762,7 @@ enum rseq_cs_flags_bit { }; enum perf_event_task_context { - perf_invalid_context = -1, + perf_invalid_context = 4294967295, perf_hw_context = 0, perf_sw_context = 1, perf_nr_task_contexts = 2, @@ -8773,11 +8776,11 @@ enum rseq_event_mask_bits { enum { PROC_ROOT_INO = 1, - PROC_IPC_INIT_INO = -268435457, - PROC_UTS_INIT_INO = -268435458, - PROC_USER_INIT_INO = -268435459, - PROC_PID_INIT_INO = -268435460, - PROC_CGROUP_INIT_INO = -268435461, + PROC_IPC_INIT_INO = 4026531839, + PROC_UTS_INIT_INO = 4026531838, + PROC_USER_INIT_INO = 4026531837, + PROC_PID_INIT_INO = 4026531836, + PROC_CGROUP_INIT_INO = 4026531835, }; typedef __u16 __le16; @@ -12151,7 +12154,7 @@ struct tc_sizespec { }; enum netdev_tx { - __NETDEV_TX_MIN = -2147483648, + __NETDEV_TX_MIN = 2147483648, NETDEV_TX_OK = 0, NETDEV_TX_BUSY = 16, }; @@ -13950,7 +13953,7 @@ enum { }; enum ctx_state { - CONTEXT_DISABLED = -1, + CONTEXT_DISABLED = 4294967295, CONTEXT_KERNEL = 0, CONTEXT_USER = 1, CONTEXT_GUEST = 2, @@ -14248,7 +14251,7 @@ enum perf_event_sample_format { PERF_SAMPLE_PHYS_ADDR = 524288, PERF_SAMPLE_AUX = 1048576, PERF_SAMPLE_MAX = 2097152, - __PERF_SAMPLE_CALLCHAIN_EARLY = -1, + __PERF_SAMPLE_CALLCHAIN_EARLY = 4294967295, }; enum perf_branch_sample_type { @@ -15009,7 +15012,7 @@ struct unwind_state { }; enum extra_reg_type { - EXTRA_REG_NONE = -1, + EXTRA_REG_NONE = 4294967295, EXTRA_REG_RSP_0 = 0, EXTRA_REG_RSP_1 = 1, EXTRA_REG_LBR = 2, @@ -19371,7 +19374,7 @@ enum e820_type { E820_TYPE_UNUSABLE = 5, E820_TYPE_PMEM = 7, E820_TYPE_PRAM = 12, - E820_TYPE_SOFT_RESERVED = -268435457, + E820_TYPE_SOFT_RESERVED = 4026531839, E820_TYPE_RESERVED_KERN = 128, }; @@ -19874,8 +19877,8 @@ enum { WORK_OFFQ_POOL_BITS = 31, WORK_OFFQ_POOL_NONE = 2147483647, WORK_STRUCT_FLAG_MASK = 255, - WORK_STRUCT_WQ_DATA_MASK = -256, - WORK_STRUCT_NO_POOL = -32, + WORK_STRUCT_WQ_DATA_MASK = 4294967040, + WORK_STRUCT_NO_POOL = 4294967264, WORK_BUSY_PENDING = 1, WORK_BUSY_RUNNING = 2, WORKER_DESC_LEN = 24, @@ -21593,7 +21596,7 @@ struct cstate_entry { }; enum reboot_mode { - REBOOT_UNDEFINED = -1, + REBOOT_UNDEFINED = 4294967295, REBOOT_COLD = 0, REBOOT_WARM = 1, REBOOT_HARD = 2, @@ -23401,7 +23404,7 @@ struct inodes_stat_t { }; enum sysctl_writes_mode { - SYSCTL_WRITES_LEGACY = -1, + SYSCTL_WRITES_LEGACY = 4294967295, SYSCTL_WRITES_WARN = 0, SYSCTL_WRITES_STRICT = 1, }; @@ -24080,8 +24083,8 @@ enum { MAYDAY_INITIAL_TIMEOUT = 10, MAYDAY_INTERVAL = 100, CREATE_COOLDOWN = 1000, - RESCUER_NICE_LEVEL = -20, - HIGHPRI_NICE_LEVEL = -20, + RESCUER_NICE_LEVEL = 4294967276, + HIGHPRI_NICE_LEVEL = 4294967276, WQ_NAME_LEN = 24, }; @@ -24303,7 +24306,7 @@ enum what { PROC_EVENT_PTRACE = 256, PROC_EVENT_COMM = 512, PROC_EVENT_COREDUMP = 1073741824, - PROC_EVENT_EXIT = -2147483648, + PROC_EVENT_EXIT = 2147483648, }; typedef u64 async_cookie_t; @@ -30393,9 +30396,9 @@ enum { }; enum { - TOO_MANY_CLOSE = -1, - TOO_MANY_OPEN = -2, - MISSING_QUOTE = -3, + TOO_MANY_CLOSE = 4294967295, + TOO_MANY_OPEN = 4294967294, + MISSING_QUOTE = 4294967293, }; struct filter_list { @@ -35499,7 +35502,7 @@ enum perf_probe_config { }; enum { - IF_ACT_NONE = -1, + IF_ACT_NONE = 4294967295, IF_ACT_FILTER = 0, IF_ACT_START = 1, IF_ACT_STOP = 2, @@ -35529,13 +35532,13 @@ struct perf_aux_event___2 { }; enum perf_callchain_context { - PERF_CONTEXT_HV = -32, - PERF_CONTEXT_KERNEL = -128, - PERF_CONTEXT_USER = -512, - PERF_CONTEXT_GUEST = -2048, - PERF_CONTEXT_GUEST_KERNEL = -2176, - PERF_CONTEXT_GUEST_USER = -2560, - PERF_CONTEXT_MAX = -4095, + PERF_CONTEXT_HV = 4294967264, + PERF_CONTEXT_KERNEL = 4294967168, + PERF_CONTEXT_USER = 4294966784, + PERF_CONTEXT_GUEST = 4294965248, + PERF_CONTEXT_GUEST_KERNEL = 4294965120, + PERF_CONTEXT_GUEST_USER = 4294964736, + PERF_CONTEXT_MAX = 4294963201, }; struct callchain_cpus_entries { @@ -35679,8 +35682,8 @@ typedef void (*dr_release_t___2)(struct device___2 *, void *); typedef int (*dr_match_t___2)(struct device___2 *, void *, void *); enum rseq_cpu_id_state { - RSEQ_CPU_ID_UNINITIALIZED = -1, - RSEQ_CPU_ID_REGISTRATION_FAILED = -2, + RSEQ_CPU_ID_UNINITIALIZED = 4294967295, + RSEQ_CPU_ID_REGISTRATION_FAILED = 4294967294, }; enum rseq_flags { @@ -40641,7 +40644,7 @@ struct pde_opener { }; enum { - BIAS = -2147483648, + BIAS = 2147483648, }; typedef int (*proc_write_t___2)(struct file *, char *, size_t); @@ -44850,9 +44853,9 @@ struct rpc_xprt_ops { enum xprt_transports { XPRT_TRANSPORT_UDP = 17, XPRT_TRANSPORT_TCP = 6, - XPRT_TRANSPORT_BC_TCP = -2147483642, + XPRT_TRANSPORT_BC_TCP = 2147483654, XPRT_TRANSPORT_RDMA = 256, - XPRT_TRANSPORT_BC_RDMA = -2147483392, + XPRT_TRANSPORT_BC_RDMA = 2147483904, XPRT_TRANSPORT_LOCAL = 257, }; @@ -45121,7 +45124,7 @@ enum nfs3_stable_how { NFS_UNSTABLE = 0, NFS_DATA_SYNC = 1, NFS_FILE_SYNC = 2, - NFS_INVALID_STABLE_HOW = -1, + NFS_INVALID_STABLE_HOW = 4294967295, }; struct nfs4_label { @@ -50768,7 +50771,7 @@ struct lsm_blob_sizes { }; enum lsm_order { - LSM_ORDER_FIRST = -1, + LSM_ORDER_FIRST = 4294967295, LSM_ORDER_MUTABLE = 0, }; @@ -51186,14 +51189,14 @@ struct nf_nat_hook { }; enum nf_ip_hook_priorities { - NF_IP_PRI_FIRST = -2147483648, - NF_IP_PRI_RAW_BEFORE_DEFRAG = -450, - NF_IP_PRI_CONNTRACK_DEFRAG = -400, - NF_IP_PRI_RAW = -300, - NF_IP_PRI_SELINUX_FIRST = -225, - NF_IP_PRI_CONNTRACK = -200, - NF_IP_PRI_MANGLE = -150, - NF_IP_PRI_NAT_DST = -100, + NF_IP_PRI_FIRST = 2147483648, + NF_IP_PRI_RAW_BEFORE_DEFRAG = 4294966846, + NF_IP_PRI_CONNTRACK_DEFRAG = 4294966896, + NF_IP_PRI_RAW = 4294966996, + NF_IP_PRI_SELINUX_FIRST = 4294967071, + NF_IP_PRI_CONNTRACK = 4294967096, + NF_IP_PRI_MANGLE = 4294967146, + NF_IP_PRI_NAT_DST = 4294967196, NF_IP_PRI_FILTER = 0, NF_IP_PRI_SECURITY = 50, NF_IP_PRI_NAT_SRC = 100, @@ -51204,14 +51207,14 @@ enum nf_ip_hook_priorities { }; enum nf_ip6_hook_priorities { - NF_IP6_PRI_FIRST = -2147483648, - NF_IP6_PRI_RAW_BEFORE_DEFRAG = -450, - NF_IP6_PRI_CONNTRACK_DEFRAG = -400, - NF_IP6_PRI_RAW = -300, - NF_IP6_PRI_SELINUX_FIRST = -225, - NF_IP6_PRI_CONNTRACK = -200, - NF_IP6_PRI_MANGLE = -150, - NF_IP6_PRI_NAT_DST = -100, + NF_IP6_PRI_FIRST = 2147483648, + NF_IP6_PRI_RAW_BEFORE_DEFRAG = 4294966846, + NF_IP6_PRI_CONNTRACK_DEFRAG = 4294966896, + NF_IP6_PRI_RAW = 4294966996, + NF_IP6_PRI_SELINUX_FIRST = 4294967071, + NF_IP6_PRI_CONNTRACK = 4294967096, + NF_IP6_PRI_MANGLE = 4294967146, + NF_IP6_PRI_NAT_DST = 4294967196, NF_IP6_PRI_FILTER = 0, NF_IP6_PRI_SECURITY = 50, NF_IP6_PRI_NAT_SRC = 100, @@ -52767,7 +52770,7 @@ struct selinux_mnt_opts { }; enum { - Opt_error = -1, + Opt_error = 4294967295, Opt_context = 0, Opt_defcontext = 1, Opt_fscontext = 2, @@ -55184,7 +55187,7 @@ enum blk_default_limits { BLK_SAFE_MAX_SECTORS = 255, BLK_DEF_MAX_SECTORS = 2560, BLK_MAX_SEGMENT_SIZE = 65536, - BLK_SEG_BOUNDARY_MASK = -1, + BLK_SEG_BOUNDARY_MASK = 4294967295, }; enum { @@ -55210,9 +55213,9 @@ enum { }; enum { - BLK_MQ_TAG_FAIL = -1, + BLK_MQ_TAG_FAIL = 4294967295, BLK_MQ_TAG_MIN = 1, - BLK_MQ_TAG_MAX = -2, + BLK_MQ_TAG_MAX = 4294967294, }; struct mq_inflight { @@ -56954,7 +56957,7 @@ enum release_type { }; enum enable_type { - undefined = -1, + undefined = 4294967295, user_disabled = 0, auto_disabled = 1, user_enabled = 2, @@ -57104,7 +57107,7 @@ struct acpi_pci_root { }; enum pm_qos_flags_status { - PM_QOS_FLAGS_UNDEFINED = -1, + PM_QOS_FLAGS_UNDEFINED = 4294967295, PM_QOS_FLAGS_NONE = 0, PM_QOS_FLAGS_SOME = 1, PM_QOS_FLAGS_ALL = 2, @@ -57190,7 +57193,7 @@ enum hpx_type3_cfg_loc { }; enum device_link_state { - DL_STATE_NONE = -1, + DL_STATE_NONE = 4294967295, DL_STATE_DORMANT = 0, DL_STATE_AVAILABLE = 1, DL_STATE_CONSUMER_PROBE = 2, @@ -57385,10 +57388,10 @@ enum dmi_device_type { DMI_DEV_TYPE_PATA = 8, DMI_DEV_TYPE_SATA = 9, DMI_DEV_TYPE_SAS = 10, - DMI_DEV_TYPE_IPMI = -1, - DMI_DEV_TYPE_OEM_STRING = -2, - DMI_DEV_TYPE_DEV_ONBOARD = -3, - DMI_DEV_TYPE_DEV_SLOT = -4, + DMI_DEV_TYPE_IPMI = 4294967295, + DMI_DEV_TYPE_OEM_STRING = 4294967294, + DMI_DEV_TYPE_DEV_ONBOARD = 4294967293, + DMI_DEV_TYPE_DEV_SLOT = 4294967292, }; struct dmi_device { @@ -57660,7 +57663,7 @@ struct hdmi_audio_infoframe { }; enum hdmi_3d_structure { - HDMI_3D_STRUCTURE_INVALID = -1, + HDMI_3D_STRUCTURE_INVALID = 4294967295, HDMI_3D_STRUCTURE_FRAME_PACKING = 0, HDMI_3D_STRUCTURE_FIELD_ALTERNATIVE = 1, HDMI_3D_STRUCTURE_LINE_ALTERNATIVE = 2, @@ -58419,13 +58422,13 @@ struct fbcon_ops { }; enum { - FBCON_LOGO_CANSHOW = -1, - FBCON_LOGO_DRAW = -2, - FBCON_LOGO_DONTSHOW = -3, + FBCON_LOGO_CANSHOW = 4294967295, + FBCON_LOGO_DRAW = 4294967294, + FBCON_LOGO_DONTSHOW = 4294967293, }; enum drm_panel_orientation { - DRM_MODE_PANEL_ORIENTATION_UNKNOWN = -1, + DRM_MODE_PANEL_ORIENTATION_UNKNOWN = 4294967295, DRM_MODE_PANEL_ORIENTATION_NORMAL = 0, DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP = 1, DRM_MODE_PANEL_ORIENTATION_LEFT_UP = 2, @@ -61952,7 +61955,7 @@ struct acpi_video_device_brightness { }; enum acpi_backlight_type { - acpi_backlight_undef = -1, + acpi_backlight_undef = 4294967295, acpi_backlight_none = 0, acpi_backlight_video = 1, acpi_backlight_vendor = 2, @@ -64158,7 +64161,7 @@ struct plat_serial8250_port { }; enum { - PLAT8250_DEV_LEGACY = -1, + PLAT8250_DEV_LEGACY = 4294967295, PLAT8250_DEV_PLATFORM = 0, PLAT8250_DEV_PLATFORM1 = 1, PLAT8250_DEV_PLATFORM2 = 2, @@ -64798,7 +64801,7 @@ enum { VIA_XSTORE_CNT_MASK = 15, VIA_RNG_CHUNK_8 = 0, VIA_RNG_CHUNK_4 = 1, - VIA_RNG_CHUNK_4_MASK = -1, + VIA_RNG_CHUNK_4_MASK = 4294967295, VIA_RNG_CHUNK_2 = 2, VIA_RNG_CHUNK_2_MASK = 65535, VIA_RNG_CHUNK_1 = 3, @@ -66668,9 +66671,9 @@ enum drm_mode_status { MODE_NO_REDUCED = 34, MODE_NO_STEREO = 35, MODE_NO_420 = 36, - MODE_STALE = -3, - MODE_BAD = -2, - MODE_ERROR = -1, + MODE_STALE = 4294967293, + MODE_BAD = 4294967294, + MODE_ERROR = 4294967295, }; struct drm_display_mode { @@ -67390,7 +67393,7 @@ enum drm_driver_feature { DRIVER_SG = 268435456, DRIVER_HAVE_DMA = 536870912, DRIVER_HAVE_IRQ = 1073741824, - DRIVER_KMS_LEGACY_CONTEXT = -2147483648, + DRIVER_KMS_LEGACY_CONTEXT = 2147483648, }; struct drm_mm; @@ -68594,9 +68597,9 @@ enum drm_mm_insert_mode { DRM_MM_INSERT_LOW = 1, DRM_MM_INSERT_HIGH = 2, DRM_MM_INSERT_EVICT = 3, - DRM_MM_INSERT_ONCE = -2147483648, - DRM_MM_INSERT_HIGHEST = -2147483646, - DRM_MM_INSERT_LOWEST = -2147483647, + DRM_MM_INSERT_ONCE = 2147483648, + DRM_MM_INSERT_HIGHEST = 2147483650, + DRM_MM_INSERT_LOWEST = 2147483649, }; struct drm_mm_scan { @@ -69703,7 +69706,7 @@ struct drm_i915_gem_pwrite { }; enum pipe { - INVALID_PIPE = -1, + INVALID_PIPE = 4294967295, PIPE_A = 0, PIPE_B = 1, PIPE_C = 2, @@ -69713,7 +69716,7 @@ enum pipe { }; enum transcoder { - INVALID_TRANSCODER = -1, + INVALID_TRANSCODER = 4294967295, TRANSCODER_A = 0, TRANSCODER_B = 1, TRANSCODER_C = 2, @@ -69745,7 +69748,7 @@ enum plane_id { }; enum port { - PORT_NONE = -1, + PORT_NONE = 4294967295, PORT_A = 0, PORT_B = 1, PORT_C = 2, @@ -71072,7 +71075,7 @@ struct drm_i915_display_funcs { }; enum intel_pch { - PCH_NOP = -1, + PCH_NOP = 4294967295, PCH_NONE = 0, PCH_IBX = 1, PCH_CPT = 2, @@ -71513,7 +71516,7 @@ enum intel_uc_fw_type { }; enum intel_uc_fw_status { - INTEL_UC_FIRMWARE_NOT_SUPPORTED = -1, + INTEL_UC_FIRMWARE_NOT_SUPPORTED = 4294967295, INTEL_UC_FIRMWARE_UNINITIALIZED = 0, INTEL_UC_FIRMWARE_DISABLED = 1, INTEL_UC_FIRMWARE_SELECTED = 2, @@ -71995,7 +71998,7 @@ struct i915_power_well_desc { }; enum intel_dpll_id { - DPLL_ID_PRIVATE = -1, + DPLL_ID_PRIVATE = 4294967295, DPLL_ID_PCH_PLL_A = 0, DPLL_ID_PCH_PLL_B = 1, DPLL_ID_WRPLL1 = 0, @@ -72041,7 +72044,7 @@ struct dpll_info { }; enum dsb_id { - INVALID_DSB = -1, + INVALID_DSB = 4294967295, DSB1 = 0, DSB2 = 1, DSB3 = 2, @@ -73780,7 +73783,7 @@ struct intel_dp_mst_encoder { }; enum tc_port { - PORT_TC_NONE = -1, + PORT_TC_NONE = 4294967295, PORT_TC1 = 0, PORT_TC2 = 1, PORT_TC3 = 2, @@ -73797,7 +73800,7 @@ enum drm_i915_gem_engine_class { I915_ENGINE_CLASS_COPY = 1, I915_ENGINE_CLASS_VIDEO = 2, I915_ENGINE_CLASS_VIDEO_ENHANCE = 3, - I915_ENGINE_CLASS_INVALID = -1, + I915_ENGINE_CLASS_INVALID = 4294967295, }; struct drm_i915_getparam { @@ -74147,8 +74150,8 @@ struct guc_stage_desc { enum i915_map_type { I915_MAP_WB = 0, I915_MAP_WC = 1, - I915_MAP_FORCE_WB = -2147483648, - I915_MAP_FORCE_WC = -2147483647, + I915_MAP_FORCE_WB = 2147483648, + I915_MAP_FORCE_WC = 2147483649, }; struct intel_guc_client { @@ -74233,7 +74236,7 @@ struct measure_breadcrumb { }; enum { - I915_PRIORITY_MIN = -1024, + I915_PRIORITY_MIN = 4294966272, I915_PRIORITY_NORMAL = 0, I915_PRIORITY_MAX = 1024, I915_PRIORITY_HEARTBEAT = 1025, @@ -75588,8 +75591,8 @@ struct guc_doorbell_info { }; enum hdmi_force_audio { - HDMI_AUDIO_OFF_DVI = -2, - HDMI_AUDIO_OFF = -1, + HDMI_AUDIO_OFF_DVI = 4294967294, + HDMI_AUDIO_OFF = 4294967295, HDMI_AUDIO_AUTO = 0, HDMI_AUDIO_ON = 1, }; @@ -75656,7 +75659,7 @@ struct hdmi_aud_ncts { }; enum phy { - PHY_NONE = -1, + PHY_NONE = 4294967295, PHY_A = 0, PHY_B = 1, PHY_C = 2, @@ -79362,7 +79365,7 @@ enum { enum { SD_DEF_XFER_BLOCKS = 65535, - SD_MAX_XFER_BLOCKS = -1, + SD_MAX_XFER_BLOCKS = 4294967295, SD_MAX_WS10_BLOCKS = 65535, SD_MAX_WS16_BLOCKS = 8388607, }; @@ -79805,7 +79808,7 @@ enum { ATA_UDMA_MASK_40C = 7, ATA_PRD_SZ = 8, ATA_PRD_TBL_SZ = 2048, - ATA_PRD_EOT = -2147483648, + ATA_PRD_EOT = 2147483648, ATA_DMA_TABLE_OFS = 4, ATA_DMA_STATUS = 2, ATA_DMA_CMD = 0, @@ -80154,7 +80157,7 @@ enum { ATAPI_MAX_DRAIN = 16384, ATA_ALL_DEVICES = 3, ATA_SHT_EMULATED = 1, - ATA_SHT_THIS_ID = -1, + ATA_SHT_THIS_ID = 4294967295, ATA_TFLAG_LBA48 = 1, ATA_TFLAG_ISADDR = 2, ATA_TFLAG_DEVICE = 4, @@ -80882,7 +80885,7 @@ enum { ATA_DNXFER_40C = 2, ATA_DNXFER_FORCE_PIO = 3, ATA_DNXFER_FORCE_PIO0 = 4, - ATA_DNXFER_QUIET = -2147483648, + ATA_DNXFER_QUIET = 2147483648, }; struct ata_force_param { @@ -80934,7 +80937,7 @@ enum { ATA_EH_SPDN_KEEP_ERRORS = 8, ATA_EFLAG_IS_IO = 1, ATA_EFLAG_DUBIOUS_XFER = 2, - ATA_EFLAG_OLD_ER = -2147483648, + ATA_EFLAG_OLD_ER = 2147483648, ATA_ECAT_NONE = 0, ATA_ECAT_ATA_BUS = 1, ATA_ECAT_TOUT_HSM = 2, @@ -81093,7 +81096,7 @@ enum { AHCI_MAX_PORTS = 32, AHCI_MAX_CLKS = 5, AHCI_MAX_SG = 168, - AHCI_DMA_BOUNDARY = -1, + AHCI_DMA_BOUNDARY = 4294967295, AHCI_MAX_CMDS = 32, AHCI_CMD_SZ = 32, AHCI_CMD_SLOT_SZ = 1024, @@ -81104,7 +81107,7 @@ enum { AHCI_CMD_TBL_AR_SZ = 90112, AHCI_PORT_PRIV_DMA_SZ = 91392, AHCI_PORT_PRIV_FBS_DMA_SZ = 95232, - AHCI_IRQ_ON_SG = -2147483648, + AHCI_IRQ_ON_SG = 2147483648, AHCI_CMD_ATAPI = 32, AHCI_CMD_WRITE = 64, AHCI_CMD_PREFETCH = 128, @@ -81125,7 +81128,7 @@ enum { HOST_RESET = 1, HOST_IRQ_EN = 2, HOST_MRSM = 4, - HOST_AHCI_EN = -2147483648, + HOST_AHCI_EN = 2147483648, HOST_CAP_SXS = 32, HOST_CAP_EMS = 64, HOST_CAP_CCC = 128, @@ -81142,7 +81145,7 @@ enum { HOST_CAP_MPS = 268435456, HOST_CAP_SNTF = 536870912, HOST_CAP_NCQ = 1073741824, - HOST_CAP_64 = -2147483648, + HOST_CAP_64 = 2147483648, HOST_CAP2_BOH = 1, HOST_CAP2_NVMHCI = 2, HOST_CAP2_APST = 4, @@ -81166,7 +81169,7 @@ enum { PORT_SCR_NTF = 60, PORT_FBS = 64, PORT_DEVSLP = 68, - PORT_IRQ_COLD_PRES = -2147483648, + PORT_IRQ_COLD_PRES = 2147483648, PORT_IRQ_TF_ERR = 1073741824, PORT_IRQ_HBUS_ERR = 536870912, PORT_IRQ_HBUS_DATA_ERR = 268435456, @@ -81200,7 +81203,7 @@ enum { PORT_CMD_POWER_ON = 4, PORT_CMD_SPIN_UP = 2, PORT_CMD_START = 1, - PORT_CMD_ICC_MASK = -268435456, + PORT_CMD_ICC_MASK = 4026531840, PORT_CMD_ICC_ACTIVE = 268435456, PORT_CMD_ICC_PARTIAL = 536870912, PORT_CMD_ICC_SLUMBER = 1610612736, @@ -81389,9 +81392,9 @@ enum { P1 = 1, P2 = 2, P3 = 3, - IDE = -1, - NA = -2, - RV = -3, + IDE = 4294967295, + NA = 4294967294, + RV = 4294967293, PIIX_AHCI_DEVICE = 6, PIIX_HOST_BROKEN_SUSPEND = 16777216, }; @@ -81441,7 +81444,7 @@ enum { MDM = 768, UDM = 458752, PPE = 1073741824, - USD = -2147483648, + USD = 2147483648, }; struct ethtool_cmd { @@ -82702,8 +82705,8 @@ enum phy___3 { phy_82562_em = 52429480, phy_82562_ek = 51380904, phy_82562_eh = 24117928, - phy_82552_v = -798949299, - phy_unknown = -1, + phy_82552_v = 3496017997, + phy_unknown = 4294967295, }; struct csr { @@ -82731,7 +82734,7 @@ enum scb_status { enum ru_state { RU_SUSPENDED = 0, RU_RUNNING = 1, - RU_UNINITIALIZED = -1, + RU_UNINITIALIZED = 4294967295, }; enum scb_stat_ack { @@ -84502,7 +84505,7 @@ enum { }; enum pci_dev_reg_1 { - PCI_Y2_PIG_ENA = -2147483648, + PCI_Y2_PIG_ENA = 2147483648, PCI_Y2_DLL_DIS = 1073741824, PCI_SW_PWR_ON_RST = 1073741824, PCI_Y2_PHY2_COMA = 536870912, @@ -84517,7 +84520,7 @@ enum pci_dev_reg_1 { }; enum pci_dev_reg_2 { - PCI_VPD_WR_THR = -16777216, + PCI_VPD_WR_THR = 4278190080, PCI_DEV_SEL = 16646144, PCI_VPD_ROM_SZ = 114688, PCI_PATCH_DIR = 3840, @@ -84552,7 +84555,7 @@ enum pci_dev_reg_3 { }; enum pci_dev_reg_4 { - P_PEX_LTSSM_STAT_MSK = -33554432, + P_PEX_LTSSM_STAT_MSK = 4261412864, P_PEX_LTSSM_L1_STAT = 52, P_PEX_LTSSM_DET_STAT = 1, P_TIMER_VALUE_MSK = 16711680, @@ -84569,7 +84572,7 @@ enum pci_dev_reg_4 { }; enum pci_dev_reg_5 { - P_CTL_DIV_CORE_CLK_ENA = -2147483648, + P_CTL_DIV_CORE_CLK_ENA = 2147483648, P_CTL_SRESET_VMAIN_AV = 1073741824, P_CTL_BYPASS_VMAIN_AV = 536870912, P_CTL_TIM_VMAIN_AV_MSK = 402653184, @@ -84728,7 +84731,7 @@ enum { }; enum { - Y2_IS_HW_ERR = -2147483648, + Y2_IS_HW_ERR = 2147483648, Y2_IS_STAT_BMU = 1073741824, Y2_IS_ASF = 536870912, Y2_IS_CPU_TO = 268435456, @@ -84749,10 +84752,10 @@ enum { Y2_IS_CHK_RX1 = 4, Y2_IS_CHK_TXS1 = 2, Y2_IS_CHK_TXA1 = 1, - Y2_IS_BASE = -1073741824, + Y2_IS_BASE = 3221225472, Y2_IS_PORT_1 = 29, Y2_IS_PORT_2 = 7424, - Y2_IS_ERROR = -2147480307, + Y2_IS_ERROR = 2147486989, }; enum { @@ -84796,7 +84799,7 @@ enum { }; enum { - GLB_GPIO_CLK_DEB_ENA = -2147483648, + GLB_GPIO_CLK_DEB_ENA = 2147483648, GLB_GPIO_CLK_DBG_MSK = 1006632960, GLB_GPIO_INT_RST_D3_DIS = 32768, GLB_GPIO_LED_PAD_SPEED_UP = 16384, @@ -84899,7 +84902,7 @@ enum { }; enum { - PEX_RD_ACCESS = -2147483648, + PEX_RD_ACCESS = 2147483648, PEX_DB_ACCESS = 1073741824, }; @@ -84978,7 +84981,7 @@ enum { }; enum { - F_TX_CHK_AUTO_OFF = -2147483648, + F_TX_CHK_AUTO_OFF = 2147483648, F_TX_CHK_AUTO_ON = 1073741824, F_M_RX_RAM_DIS = 16777216, }; @@ -85050,7 +85053,7 @@ enum { }; enum { - BMU_IDLE = -2147483648, + BMU_IDLE = 2147483648, BMU_RX_TCP_PKT = 1073741824, BMU_RX_IP_PKT = 536870912, BMU_ENA_RX_RSS_HASH = 32768, @@ -85077,7 +85080,7 @@ enum { }; enum { - TBMU_TEST_BMU_TX_CHK_AUTO_OFF = -2147483648, + TBMU_TEST_BMU_TX_CHK_AUTO_OFF = 2147483648, TBMU_TEST_BMU_TX_CHK_AUTO_ON = 1073741824, TBMU_TEST_HOME_ADD_PAD_FIX1_EN = 536870912, TBMU_TEST_HOME_ADD_PAD_FIX1_DIS = 268435456, @@ -85742,7 +85745,7 @@ enum { }; enum { - RX_GCLKMAC_ENA = -2147483648, + RX_GCLKMAC_ENA = 2147483648, RX_GCLKMAC_OFF = 1073741824, RX_STFW_DIS = 536870912, RX_STFW_ENA = 268435456, @@ -85794,7 +85797,7 @@ enum { }; enum { - TX_STFW_DIS = -2147483648, + TX_STFW_DIS = 2147483648, TX_STFW_ENA = 1073741824, TX_VLAN_TAG_ON = 33554432, TX_VLAN_TAG_OFF = 16777216, @@ -86474,7 +86477,7 @@ enum TxStatusBits { TxStatOK = 32768, TxOutOfWindow = 536870912, TxAborted = 1073741824, - TxCarrierLost = -2147483648, + TxCarrierLost = 2147483648, }; enum RxStatusBits { @@ -86940,7 +86943,7 @@ enum rtl_register_content { }; enum rtl_desc_bit { - DescOwn = -2147483648, + DescOwn = 2147483648, RingEnd = 1073741824, FirstFrag = 536870912, LastFrag = 268435456, @@ -86963,7 +86966,7 @@ enum rtl_tx_desc_bit_1 { TD1_IPv6_CS = 268435456, TD1_IPv4_CS = 536870912, TD1_TCP_CS = 1073741824, - TD1_UDP_CS = -2147483648, + TD1_UDP_CS = 2147483648, }; enum rtl_rx_desc_bit { @@ -87953,7 +87956,7 @@ struct yenta_socket { }; enum { - CARDBUS_TYPE_DEFAULT = -1, + CARDBUS_TYPE_DEFAULT = 4294967295, CARDBUS_TYPE_TI = 0, CARDBUS_TYPE_TI113X = 1, CARDBUS_TYPE_TI12XX = 2, @@ -91536,7 +91539,7 @@ struct min_max_quirk { }; enum { - SYNAPTICS_INTERTOUCH_NOT_SET = -1, + SYNAPTICS_INTERTOUCH_NOT_SET = 4294967295, SYNAPTICS_INTERTOUCH_OFF = 0, SYNAPTICS_INTERTOUCH_ON = 1, }; @@ -96179,7 +96182,7 @@ struct snd_kcontrol { enum { SNDRV_CTL_TLV_OP_READ = 0, SNDRV_CTL_TLV_OP_WRITE = 1, - SNDRV_CTL_TLV_OP_CMD = -1, + SNDRV_CTL_TLV_OP_CMD = 4294967295, }; struct snd_kcontrol_new { @@ -96290,12 +96293,12 @@ struct snd_ctl_elem_value32 { }; enum { - SNDRV_CTL_IOCTL_ELEM_LIST32 = -1069001456, - SNDRV_CTL_IOCTL_ELEM_INFO32 = -1055894255, - SNDRV_CTL_IOCTL_ELEM_READ32 = -1027320558, - SNDRV_CTL_IOCTL_ELEM_WRITE32 = -1027320557, - SNDRV_CTL_IOCTL_ELEM_ADD32 = -1055894249, - SNDRV_CTL_IOCTL_ELEM_REPLACE32 = -1055894248, + SNDRV_CTL_IOCTL_ELEM_LIST32 = 3225965840, + SNDRV_CTL_IOCTL_ELEM_INFO32 = 3239073041, + SNDRV_CTL_IOCTL_ELEM_READ32 = 3267646738, + SNDRV_CTL_IOCTL_ELEM_WRITE32 = 3267646739, + SNDRV_CTL_IOCTL_ELEM_ADD32 = 3239073047, + SNDRV_CTL_IOCTL_ELEM_REPLACE32 = 3239073048, }; struct snd_pci_quirk { @@ -96447,7 +96450,7 @@ enum { }; enum { - SNDRV_TIMER_CLASS_NONE = -1, + SNDRV_TIMER_CLASS_NONE = 4294967295, SNDRV_TIMER_CLASS_SLAVE = 0, SNDRV_TIMER_CLASS_GLOBAL = 1, SNDRV_TIMER_CLASS_CARD = 2, @@ -96693,7 +96696,7 @@ struct snd_timer_status32 { enum { SNDRV_TIMER_IOCTL_GPARAMS32 = 1077695492, - SNDRV_TIMER_IOCTL_INFO32 = -2132782063, + SNDRV_TIMER_IOCTL_INFO32 = 2162185233, SNDRV_TIMER_IOCTL_STATUS32 = 1079530516, }; @@ -97044,8 +97047,8 @@ typedef u64 u_int64_t; enum { SNDRV_PCM_MMAP_OFFSET_DATA = 0, - SNDRV_PCM_MMAP_OFFSET_STATUS = -2147483648, - SNDRV_PCM_MMAP_OFFSET_CONTROL = -2130706432, + SNDRV_PCM_MMAP_OFFSET_STATUS = 2147483648, + SNDRV_PCM_MMAP_OFFSET_CONTROL = 2164260864, }; typedef int snd_pcm_hw_param_t; @@ -97243,20 +97246,20 @@ struct snd_pcm_sync_ptr32 { }; enum { - SNDRV_PCM_IOCTL_HW_REFINE32 = -1034141424, - SNDRV_PCM_IOCTL_HW_PARAMS32 = -1034141423, - SNDRV_PCM_IOCTL_SW_PARAMS32 = -1066909421, - SNDRV_PCM_IOCTL_STATUS32 = -2140389088, - SNDRV_PCM_IOCTL_STATUS_EXT32 = -1066647260, - SNDRV_PCM_IOCTL_DELAY32 = -2147204831, - SNDRV_PCM_IOCTL_CHANNEL_INFO32 = -2146418382, + SNDRV_PCM_IOCTL_HW_REFINE32 = 3260825872, + SNDRV_PCM_IOCTL_HW_PARAMS32 = 3260825873, + SNDRV_PCM_IOCTL_SW_PARAMS32 = 3228057875, + SNDRV_PCM_IOCTL_STATUS32 = 2154578208, + SNDRV_PCM_IOCTL_STATUS_EXT32 = 3228320036, + SNDRV_PCM_IOCTL_DELAY32 = 2147762465, + SNDRV_PCM_IOCTL_CHANNEL_INFO32 = 2148548914, SNDRV_PCM_IOCTL_REWIND32 = 1074020678, SNDRV_PCM_IOCTL_FORWARD32 = 1074020681, SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = 1074544976, - SNDRV_PCM_IOCTL_READI_FRAMES32 = -2146680495, + SNDRV_PCM_IOCTL_READI_FRAMES32 = 2148286801, SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = 1074544978, - SNDRV_PCM_IOCTL_READN_FRAMES32 = -2146680493, - SNDRV_PCM_IOCTL_SYNC_PTR32 = -1065074397, + SNDRV_PCM_IOCTL_READN_FRAMES32 = 2148286803, + SNDRV_PCM_IOCTL_SYNC_PTR32 = 3229892899, }; enum { @@ -97839,11 +97842,11 @@ struct snd_seq_port_info32 { }; enum { - SNDRV_SEQ_IOCTL_CREATE_PORT32 = -1062972640, + SNDRV_SEQ_IOCTL_CREATE_PORT32 = 3231994656, SNDRV_SEQ_IOCTL_DELETE_PORT32 = 1084511009, - SNDRV_SEQ_IOCTL_GET_PORT_INFO32 = -1062972638, + SNDRV_SEQ_IOCTL_GET_PORT_INFO32 = 3231994658, SNDRV_SEQ_IOCTL_SET_PORT_INFO32 = 1084511011, - SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT32 = -1062972590, + SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT32 = 3231994706, }; typedef int (*snd_seq_dump_func_t)(void *, void *, int); @@ -100883,6 +100886,12 @@ enum bpf_ret_code { BPF_LWT_REROUTE = 128, }; +enum { + BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG = 1, + BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL = 2, + BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP = 4, +}; + enum devlink_port_type { DEVLINK_PORT_TYPE_NOTSET = 0, DEVLINK_PORT_TYPE_AUTO = 1, @@ -102761,6 +102770,54 @@ enum bpf_func_id { __BPF_FUNC_MAX_ID = 116, }; +enum { + BPF_F_RECOMPUTE_CSUM = 1, + BPF_F_INVALIDATE_HASH = 2, +}; + +enum { + BPF_F_HDR_FIELD_MASK = 15, +}; + +enum { + BPF_F_PSEUDO_HDR = 16, + BPF_F_MARK_MANGLED_0 = 32, + BPF_F_MARK_ENFORCE = 64, +}; + +enum { + BPF_F_INGRESS = 1, +}; + +enum { + BPF_F_TUNINFO_IPV6 = 1, +}; + +enum { + BPF_F_ZERO_CSUM_TX = 2, + BPF_F_DONT_FRAGMENT = 4, + BPF_F_SEQ_NUMBER = 8, +}; + +enum { + BPF_F_INDEX_MASK = 4294967295, + BPF_F_CURRENT_CPU = 4294967295, + BPF_F_CTXLEN_MASK = 0, +}; + +enum { + BPF_F_ADJ_ROOM_FIXED_GSO = 1, + BPF_F_ADJ_ROOM_ENCAP_L3_IPV4 = 2, + BPF_F_ADJ_ROOM_ENCAP_L3_IPV6 = 4, + BPF_F_ADJ_ROOM_ENCAP_L4_GRE = 8, + BPF_F_ADJ_ROOM_ENCAP_L4_UDP = 16, +}; + +enum { + BPF_ADJ_ROOM_ENCAP_L2_MASK = 255, + BPF_ADJ_ROOM_ENCAP_L2_SHIFT = 56, +}; + enum bpf_adj_room_mode { BPF_ADJ_ROOM_NET = 0, BPF_ADJ_ROOM_MAC = 1, @@ -102994,6 +103051,14 @@ struct bpf_sock_ops { }; }; +enum { + BPF_SOCK_OPS_RTO_CB_FLAG = 1, + BPF_SOCK_OPS_RETRANS_CB_FLAG = 2, + BPF_SOCK_OPS_STATE_CB_FLAG = 4, + BPF_SOCK_OPS_RTT_CB_FLAG = 8, + BPF_SOCK_OPS_ALL_CB_FLAGS = 15, +}; + enum { BPF_SOCK_OPS_VOID = 0, BPF_SOCK_OPS_TIMEOUT_INIT = 1, @@ -103010,6 +103075,16 @@ enum { BPF_SOCK_OPS_RTT_CB = 12, }; +enum { + TCP_BPF_IW = 1001, + TCP_BPF_SNDCWND_CLAMP = 1002, +}; + +enum { + BPF_FIB_LOOKUP_DIRECT = 1, + BPF_FIB_LOOKUP_OUTPUT = 2, +}; + enum { BPF_FIB_LKUP_RET_SUCCESS = 0, BPF_FIB_LKUP_RET_BLACKHOLE = 1, @@ -103119,7 +103194,7 @@ enum rt_class_t { RT_TABLE_DEFAULT = 253, RT_TABLE_MAIN = 254, RT_TABLE_LOCAL = 255, - RT_TABLE_MAX = -1, + RT_TABLE_MAX = 4294967295, }; struct bpf_skb_data_end { @@ -109206,9 +109281,9 @@ struct trace_event_data_offsets_fib6_table_lookup { }; enum rt6_nud_state { - RT6_NUD_FAIL_HARD = -3, - RT6_NUD_FAIL_PROBE = -2, - RT6_NUD_FAIL_DO_RR = -1, + RT6_NUD_FAIL_HARD = 4294967293, + RT6_NUD_FAIL_PROBE = 4294967294, + RT6_NUD_FAIL_DO_RR = 4294967295, RT6_NUD_SUCCEED = 1, }; @@ -110717,7 +110792,7 @@ struct rpc_cred_cache { }; enum { - SVC_POOL_AUTO = -1, + SVC_POOL_AUTO = 4294967295, SVC_POOL_GLOBAL = 0, SVC_POOL_PERCPU = 1, SVC_POOL_PERNODE = 2, @@ -111877,7 +111952,7 @@ enum nl80211_feature_flags { NL80211_FEATURE_TDLS_CHANNEL_SWITCH = 268435456, NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR = 536870912, NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR = 1073741824, - NL80211_FEATURE_ND_RANDOM_MAC_ADDR = -2147483648, + NL80211_FEATURE_ND_RANDOM_MAC_ADDR = 2147483648, }; enum nl80211_ext_feature_index { @@ -119552,7 +119627,7 @@ enum mac80211_tx_info_flags { IEEE80211_TX_STATUS_EOSP = 268435456, IEEE80211_TX_CTL_USE_MINRATE = 536870912, IEEE80211_TX_CTL_DONTFRAG = 1073741824, - IEEE80211_TX_STAT_NOACK_TRANSMITTED = -2147483648, + IEEE80211_TX_STAT_NOACK_TRANSMITTED = 2147483648, }; enum mac80211_rate_control_flags { @@ -119790,9 +119865,9 @@ enum ieee80211_internal_key_flags { enum { TKIP_DECRYPT_OK = 0, - TKIP_DECRYPT_NO_EXT_IV = -1, - TKIP_DECRYPT_INVALID_KEYIDX = -2, - TKIP_DECRYPT_REPLAY = -3, + TKIP_DECRYPT_NO_EXT_IV = 4294967295, + TKIP_DECRYPT_INVALID_KEYIDX = 4294967294, + TKIP_DECRYPT_REPLAY = 4294967293, }; enum mac80211_rx_encoding { @@ -122153,3 +122228,5 @@ enum reg_type { #ifndef BPF_NO_PRESERVE_ACCESS_INDEX #pragma clang attribute pop #endif + +#endif /* __VMLINUX_H__ */ From 77d60b19f9d608d1039c3297f3e7fcf9548c879e Mon Sep 17 00:00:00 2001 From: Andrii Nakryiko Date: Wed, 11 Mar 2020 21:58:14 -0700 Subject: [PATCH 045/278] libbpf: sync to latest version Sync libbpf to latest revision. It brings latest BPF headers, among other things. Signed-off-by: Andrii Nakryiko --- src/cc/libbpf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cc/libbpf b/src/cc/libbpf index 583bddce6..9a424bea4 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit 583bddce6b93bafa31471212a9811fd7d38b5f9a +Subproject commit 9a424bea428bd7cde6f1bdaa2ee41f48e5686774 From 454b138e6b75a47d4070a4f99c8f2372b383f71e Mon Sep 17 00:00:00 2001 From: Andrii Nakryiko Date: Tue, 10 Mar 2020 21:25:16 -0700 Subject: [PATCH 046/278] libbpf-tools: small clean ups across all tools Remove BPF_F_CURRENT_CPU definitions, which are now provided by vmlinux.h after 1aae4bdd7879 ("bpf: Switch BPF UAPI #define constants used from BPF program side to enums") commit in kernel. Fix potential uninitialized read warning in opensnoop. Also add opensnoop to .gitignore. Signed-off-by: Andrii Nakryiko --- libbpf-tools/.gitignore | 3 ++- libbpf-tools/drsnoop.bpf.c | 3 --- libbpf-tools/opensnoop.bpf.c | 3 --- libbpf-tools/opensnoop.c | 2 +- libbpf-tools/runqslower.bpf.c | 3 --- 5 files changed, 3 insertions(+), 11 deletions(-) diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 45243f724..2e888747e 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -1,3 +1,4 @@ /.output -/runqslower /drsnoop +/opensnoop +/runqslower diff --git a/libbpf-tools/drsnoop.bpf.c b/libbpf-tools/drsnoop.bpf.c index d6662a1e4..491de15da 100644 --- a/libbpf-tools/drsnoop.bpf.c +++ b/libbpf-tools/drsnoop.bpf.c @@ -4,9 +4,6 @@ #include #include "drsnoop.h" -#define BPF_F_INDEX_MASK 0xffffffffULL -#define BPF_F_CURRENT_CPU BPF_F_INDEX_MASK - const volatile pid_t targ_pid = 0; const volatile pid_t targ_tgid = 0; const volatile __u64 vm_zone_stat_kaddr = 0; diff --git a/libbpf-tools/opensnoop.bpf.c b/libbpf-tools/opensnoop.bpf.c index 0b2589c62..44e591113 100644 --- a/libbpf-tools/opensnoop.bpf.c +++ b/libbpf-tools/opensnoop.bpf.c @@ -7,9 +7,6 @@ #define TASK_RUNNING 0 -#define BPF_F_INDEX_MASK 0xffffffffULL -#define BPF_F_CURRENT_CPU BPF_F_INDEX_MASK - const volatile __u64 min_us = 0; const volatile pid_t targ_pid = 0; const volatile pid_t targ_tgid = 0; diff --git a/libbpf-tools/opensnoop.c b/libbpf-tools/opensnoop.c index e6f50f50a..b2d7a88a8 100644 --- a/libbpf-tools/opensnoop.c +++ b/libbpf-tools/opensnoop.c @@ -229,7 +229,7 @@ int main(int argc, char **argv) struct perf_buffer_opts pb_opts; struct perf_buffer *pb = NULL; struct opensnoop_bpf *obj; - __u64 time_end; + __u64 time_end = 0; int err; err = argp_parse(&argp, argc, argv, 0, NULL, NULL); diff --git a/libbpf-tools/runqslower.bpf.c b/libbpf-tools/runqslower.bpf.c index 09abab252..65a9ca961 100644 --- a/libbpf-tools/runqslower.bpf.c +++ b/libbpf-tools/runqslower.bpf.c @@ -6,9 +6,6 @@ #define TASK_RUNNING 0 -#define BPF_F_INDEX_MASK 0xffffffffULL -#define BPF_F_CURRENT_CPU BPF_F_INDEX_MASK - const volatile __u64 min_us = 0; const volatile pid_t targ_pid = 0; const volatile pid_t targ_tgid = 0; From 2b5fcc6ec332f8067dab50da833ee870fd690579 Mon Sep 17 00:00:00 2001 From: Andrii Nakryiko Date: Wed, 11 Mar 2020 22:44:57 -0700 Subject: [PATCH 047/278] libbpf-tools: determine target host architecture BPF code is compiled with -target bpf, but for PT_REGS_PARM macro (and by induction for BPF_KPROBE/BPF_KRETPROBE macros as well), it's important to know what's the target host original architecture was, to use correct definition of struct pt_regs. Determine that based on output of `uname -m` (taking into account that both x86_64 and x86 are defined as x86 internally for kernel). Signed-off-by: Andrii Nakryiko --- libbpf-tools/Makefile | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 399a086db..1d2b153af 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -7,6 +7,7 @@ LIBBPF_SRC := $(abspath ../src/cc/libbpf/src) LIBBPF_OBJ := $(abspath $(OUTPUT)/libbpf.a) INCLUDES := -I$(OUTPUT) CFLAGS := -g -O2 -Wall +ARCH := $(shell uname -m | sed 's/x86_64/x86/') APPS = drsnoop opensnoop runqslower @@ -47,8 +48,8 @@ $(OUTPUT)/%.skel.h: $(OUTPUT)/%.bpf.o | $(OUTPUT) $(OUTPUT)/%.bpf.o: %.bpf.c $(LIBBPF_OBJ) $(wildcard %.h) vmlinux.h | $(OUTPUT) $(call msg,BPF,$@) - $(Q)$(CLANG) -g -O2 -target bpf $(INCLUDES) \ - -c $(filter %.c,$^) -o $@ && \ + $(Q)$(CLANG) -g -O2 -target bpf -D__TARGET_ARCH_$(ARCH) \ + $(INCLUDES) -c $(filter %.c,$^) -o $@ && \ $(LLVM_STRIP) -g $@ # Build libbpf.a From d0ec8a27db740304d46d898d1a930bfcb6e09627 Mon Sep 17 00:00:00 2001 From: Daniel Poelzleithner Date: Thu, 12 Mar 2020 12:31:39 +0100 Subject: [PATCH 048/278] Backport tcpstates to kernels < 4.15 The tracepoint inet_sock_set_state only exists in kernels 4.15. Backported the bpf tracepoint to use kprobes on older kernels. --- tools/tcpstates.py | 116 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 110 insertions(+), 6 deletions(-) diff --git a/tools/tcpstates.py b/tools/tcpstates.py index b9a643873..48f878840 100755 --- a/tools/tcpstates.py +++ b/tools/tcpstates.py @@ -59,7 +59,7 @@ debug = 0 # define BPF program -bpf_text = """ +bpf_header = """ #include #define KBUILD_MODNAME "foo" #include @@ -101,7 +101,8 @@ u32 pid; char task[TASK_COMM_LEN]; }; - +""" +bpf_text_tracepoint = """ TRACEPOINT_PROBE(sock, inet_sock_set_state) { if (args->protocol != IPPROTO_TCP) @@ -166,10 +167,113 @@ } """ -if (not BPF.tracepoint_exists("sock", "inet_sock_set_state")): - print("ERROR: tracepoint sock:inet_sock_set_state missing " - "(added in Linux 4.16). Exiting") - exit() +bpf_text_kprobe = """ +int kprobe__tcp_set_state(struct pt_regs *ctx, struct sock *sk, int state) +{ + // check this is TCP + u8 protocol = 0; + + // Following comments add by Joe Yin: + // Unfortunately,it can not work since Linux 4.10, + // because the sk_wmem_queued is not following the bitfield of sk_protocol. + // And the following member is sk_gso_max_segs. + // So, we can use this: + // bpf_probe_read(&protocol, 1, (void *)((u64)&newsk->sk_gso_max_segs) - 3); + // In order to diff the pre-4.10 and 4.10+ ,introduce the variables gso_max_segs_offset,sk_lingertime, + // sk_lingertime is closed to the gso_max_segs_offset,and + // the offset between the two members is 4 + + int gso_max_segs_offset = offsetof(struct sock, sk_gso_max_segs); + int sk_lingertime_offset = offsetof(struct sock, sk_lingertime); + + if (sk_lingertime_offset - gso_max_segs_offset == 4) + // 4.10+ with little endian +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + bpf_probe_read(&protocol, 1, (void *)((u64)&sk->sk_gso_max_segs) - 3); +else + // pre-4.10 with little endian + bpf_probe_read(&protocol, 1, (void *)((u64)&sk->sk_wmem_queued) - 3); +#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + // 4.10+ with big endian + bpf_probe_read(&protocol, 1, (void *)((u64)&sk->sk_gso_max_segs) - 1); +else + // pre-4.10 with big endian + bpf_probe_read(&protocol, 1, (void *)((u64)&sk->sk_wmem_queued) - 1); +#else +# error "Fix your compiler's __BYTE_ORDER__?!" +#endif + + if (protocol != IPPROTO_TCP) + return 0; + + u32 pid = bpf_get_current_pid_tgid() >> 32; + // sk is used as a UUID + + // lport is either used in a filter here, or later + u16 lport = sk->__sk_common.skc_num; + FILTER_LPORT + + // dport is either used in a filter here, or later + u16 dport = sk->__sk_common.skc_dport; + FILTER_DPORT + + // calculate delta + u64 *tsp, delta_us; + tsp = last.lookup(&sk); + if (tsp == 0) + delta_us = 0; + else + delta_us = (bpf_ktime_get_ns() - *tsp) / 1000; + + u16 family = sk->__sk_common.skc_family; + + if (family == AF_INET) { + struct ipv4_data_t data4 = { + .span_us = delta_us, + .oldstate = sk->__sk_common.skc_state, + .newstate = state }; + data4.skaddr = (u64)sk; + data4.ts_us = bpf_ktime_get_ns() / 1000; + data4.saddr = sk->__sk_common.skc_rcv_saddr; + data4.daddr = sk->__sk_common.skc_daddr; + // a workaround until data4 compiles with separate lport/dport + data4.ports = dport + ((0ULL + lport) << 16); + data4.pid = pid; + + bpf_get_current_comm(&data4.task, sizeof(data4.task)); + ipv4_events.perf_submit(ctx, &data4, sizeof(data4)); + + } else /* 6 */ { + struct ipv6_data_t data6 = { + .span_us = delta_us, + .oldstate = sk->__sk_common.skc_state, + .newstate = state }; + data6.skaddr = (u64)sk; + data6.ts_us = bpf_ktime_get_ns() / 1000; + bpf_probe_read(&data6.saddr, sizeof(data6.saddr), + sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); + bpf_probe_read(&data6.daddr, sizeof(data6.daddr), + sk->__sk_common.skc_v6_daddr.in6_u.u6_addr32); + // a workaround until data6 compiles with separate lport/dport + data6.ports = dport + ((0ULL + lport) << 16); + data6.pid = pid; + bpf_get_current_comm(&data6.task, sizeof(data6.task)); + ipv6_events.perf_submit(ctx, &data6, sizeof(data6)); + } + + u64 ts = bpf_ktime_get_ns(); + last.update(&sk, &ts); + + return 0; + +}; +""" + +bpf_text = bpf_header +if (BPF.tracepoint_exists("sock", "inet_sock_set_state")): + bpf_text += bpf_text_tracepoint +else: + bpf_text += bpf_text_kprobe # code substitutions if args.remoteport: From cd43be4c6a52540a8e272ed3dcea48211c198073 Mon Sep 17 00:00:00 2001 From: Andrii Nakryiko Date: Fri, 13 Mar 2020 12:38:47 -0700 Subject: [PATCH 049/278] libbpf-tools: adjust Kconfig and re-build vmlinux.h Default v5.5 kernel config doesn't have most of BPF-related functionality enabled, which leads to vmlinux.h not containing a lot of useful constants. This patch contains re-generated vmlinux.h from kernel built with default config plus minimal changes to enable most (all?) BPF-relevant parts of kernel. Here's a list of added options: CONFIG_BPF_EVENTS=y CONFIG_BPFILTER_UMH=m CONFIG_BPFILTER=y CONFIG_BPF_JIT=y CONFIG_BPF_KPROBE_OVERRIDE=y CONFIG_BPF_STREAM_PARSER=y CONFIG_BPF_SYSCALL=y CONFIG_CC_HAS_ASM_INLINE=y CONFIG_CC_HAS_KASAN_GENERIC=y CONFIG_CC_HAS_SANCOV_TRACE_PC=y CONFIG_CGROUP_BPF=y CONFIG_GCC_VERSION=70300 CONFIG_IPV6_MULTIPLE_TABLES=y CONFIG_IPV6_SEG6_BPF=y CONFIG_IPV6_SEG6_LWTUNNEL=y CONFIG_LIBCRC32C=y CONFIG_LWTUNNEL_BPF=y CONFIG_LWTUNNEL=y CONFIG_NET_ACT_BPF=y CONFIG_NET_CLS_BPF=y CONFIG_NETFILTER_ADVANCED=y CONFIG_NETFILTER_XT_MATCH_BPF=y CONFIG_NET_SOCK_MSG=y CONFIG_NF_CT_PROTO_DCCP=y CONFIG_NF_CT_PROTO_SCTP=y CONFIG_NF_CT_PROTO_UDPLITE=y CONFIG_SOCK_CGROUP_DATA=y CONFIG_STREAM_PARSER=y CONFIG_XDP_SOCKETS_DIAG=y CONFIG_XDP_SOCKETS=y To make this vmlinux.h generation process easier for future adjustments (e.g., if some of the tools would need types that default config compiles out), check in used Kconfig along the vmlinux.h itself. Signed-off-by: Andrii Nakryiko --- libbpf-tools/kernel.config | 4814 +++ libbpf-tools/vmlinux_505.h | 64033 +++++++++++++++++++---------------- 2 files changed, 39435 insertions(+), 29412 deletions(-) create mode 100644 libbpf-tools/kernel.config diff --git a/libbpf-tools/kernel.config b/libbpf-tools/kernel.config new file mode 100644 index 000000000..1b93a3b7f --- /dev/null +++ b/libbpf-tools/kernel.config @@ -0,0 +1,4814 @@ +# +# Automatically generated file; DO NOT EDIT. +# Linux/x86 5.5.0 Kernel Configuration +# + +# +# Compiler: gcc (GCC) 7.x 20200121 (Facebook) 8.x +# +CONFIG_CC_IS_GCC=y +CONFIG_GCC_VERSION=70300 +CONFIG_CLANG_VERSION=0 +CONFIG_CC_CAN_LINK=y +CONFIG_CC_HAS_ASM_GOTO=y +CONFIG_CC_HAS_ASM_INLINE=y +CONFIG_CC_HAS_WARN_MAYBE_UNINITIALIZED=y +CONFIG_IRQ_WORK=y +CONFIG_BUILDTIME_EXTABLE_SORT=y +CONFIG_THREAD_INFO_IN_TASK=y + +# +# General setup +# +CONFIG_INIT_ENV_ARG_LIMIT=32 +# CONFIG_COMPILE_TEST is not set +CONFIG_LOCALVERSION="" +# CONFIG_LOCALVERSION_AUTO is not set +CONFIG_BUILD_SALT="" +CONFIG_HAVE_KERNEL_GZIP=y +CONFIG_HAVE_KERNEL_BZIP2=y +CONFIG_HAVE_KERNEL_LZMA=y +CONFIG_HAVE_KERNEL_XZ=y +CONFIG_HAVE_KERNEL_LZO=y +CONFIG_HAVE_KERNEL_LZ4=y +CONFIG_KERNEL_GZIP=y +# CONFIG_KERNEL_BZIP2 is not set +# CONFIG_KERNEL_LZMA is not set +# CONFIG_KERNEL_XZ is not set +# CONFIG_KERNEL_LZO is not set +# CONFIG_KERNEL_LZ4 is not set +CONFIG_DEFAULT_HOSTNAME="(none)" +CONFIG_SWAP=y +CONFIG_SYSVIPC=y +CONFIG_SYSVIPC_SYSCTL=y +CONFIG_POSIX_MQUEUE=y +CONFIG_POSIX_MQUEUE_SYSCTL=y +CONFIG_CROSS_MEMORY_ATTACH=y +CONFIG_USELIB=y +CONFIG_AUDIT=y +CONFIG_HAVE_ARCH_AUDITSYSCALL=y +CONFIG_AUDITSYSCALL=y + +# +# IRQ subsystem +# +CONFIG_GENERIC_IRQ_PROBE=y +CONFIG_GENERIC_IRQ_SHOW=y +CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK=y +CONFIG_GENERIC_PENDING_IRQ=y +CONFIG_GENERIC_IRQ_MIGRATION=y +CONFIG_IRQ_DOMAIN=y +CONFIG_IRQ_DOMAIN_HIERARCHY=y +CONFIG_GENERIC_MSI_IRQ=y +CONFIG_GENERIC_MSI_IRQ_DOMAIN=y +CONFIG_IRQ_MSI_IOMMU=y +CONFIG_GENERIC_IRQ_MATRIX_ALLOCATOR=y +CONFIG_GENERIC_IRQ_RESERVATION_MODE=y +CONFIG_IRQ_FORCED_THREADING=y +CONFIG_SPARSE_IRQ=y +# CONFIG_GENERIC_IRQ_DEBUGFS is not set +# end of IRQ subsystem + +CONFIG_CLOCKSOURCE_WATCHDOG=y +CONFIG_ARCH_CLOCKSOURCE_DATA=y +CONFIG_ARCH_CLOCKSOURCE_INIT=y +CONFIG_CLOCKSOURCE_VALIDATE_LAST_CYCLE=y +CONFIG_GENERIC_TIME_VSYSCALL=y +CONFIG_GENERIC_CLOCKEVENTS=y +CONFIG_GENERIC_CLOCKEVENTS_BROADCAST=y +CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST=y +CONFIG_GENERIC_CMOS_UPDATE=y + +# +# Timers subsystem +# +CONFIG_TICK_ONESHOT=y +CONFIG_NO_HZ_COMMON=y +# CONFIG_HZ_PERIODIC is not set +CONFIG_NO_HZ_IDLE=y +# CONFIG_NO_HZ_FULL is not set +CONFIG_NO_HZ=y +CONFIG_HIGH_RES_TIMERS=y +# end of Timers subsystem + +# CONFIG_PREEMPT_NONE is not set +CONFIG_PREEMPT_VOLUNTARY=y +# CONFIG_PREEMPT is not set + +# +# CPU/Task time and stats accounting +# +CONFIG_TICK_CPU_ACCOUNTING=y +# CONFIG_VIRT_CPU_ACCOUNTING_GEN is not set +# CONFIG_IRQ_TIME_ACCOUNTING is not set +CONFIG_BSD_PROCESS_ACCT=y +# CONFIG_BSD_PROCESS_ACCT_V3 is not set +CONFIG_TASKSTATS=y +CONFIG_TASK_DELAY_ACCT=y +CONFIG_TASK_XACCT=y +CONFIG_TASK_IO_ACCOUNTING=y +# CONFIG_PSI is not set +# end of CPU/Task time and stats accounting + +CONFIG_CPU_ISOLATION=y + +# +# RCU Subsystem +# +CONFIG_TREE_RCU=y +# CONFIG_RCU_EXPERT is not set +CONFIG_SRCU=y +CONFIG_TREE_SRCU=y +CONFIG_RCU_STALL_COMMON=y +CONFIG_RCU_NEED_SEGCBLIST=y +# end of RCU Subsystem + +# CONFIG_IKCONFIG is not set +# CONFIG_IKHEADERS is not set +CONFIG_LOG_BUF_SHIFT=18 +CONFIG_LOG_CPU_MAX_BUF_SHIFT=12 +CONFIG_PRINTK_SAFE_LOG_BUF_SHIFT=13 +CONFIG_HAVE_UNSTABLE_SCHED_CLOCK=y + +# +# Scheduler features +# +# end of Scheduler features + +CONFIG_ARCH_SUPPORTS_NUMA_BALANCING=y +CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH=y +CONFIG_CC_HAS_INT128=y +CONFIG_ARCH_SUPPORTS_INT128=y +# CONFIG_NUMA_BALANCING is not set +CONFIG_CGROUPS=y +# CONFIG_MEMCG is not set +# CONFIG_BLK_CGROUP is not set +CONFIG_CGROUP_SCHED=y +CONFIG_FAIR_GROUP_SCHED=y +# CONFIG_CFS_BANDWIDTH is not set +# CONFIG_RT_GROUP_SCHED is not set +# CONFIG_CGROUP_PIDS is not set +# CONFIG_CGROUP_RDMA is not set +CONFIG_CGROUP_FREEZER=y +# CONFIG_CGROUP_HUGETLB is not set +CONFIG_CPUSETS=y +CONFIG_PROC_PID_CPUSET=y +# CONFIG_CGROUP_DEVICE is not set +CONFIG_CGROUP_CPUACCT=y +# CONFIG_CGROUP_PERF is not set +CONFIG_CGROUP_BPF=y +# CONFIG_CGROUP_DEBUG is not set +CONFIG_SOCK_CGROUP_DATA=y +CONFIG_NAMESPACES=y +CONFIG_UTS_NS=y +CONFIG_IPC_NS=y +# CONFIG_USER_NS is not set +CONFIG_PID_NS=y +CONFIG_NET_NS=y +# CONFIG_CHECKPOINT_RESTORE is not set +# CONFIG_SCHED_AUTOGROUP is not set +# CONFIG_SYSFS_DEPRECATED is not set +CONFIG_RELAY=y +CONFIG_BLK_DEV_INITRD=y +CONFIG_INITRAMFS_SOURCE="" +CONFIG_RD_GZIP=y +CONFIG_RD_BZIP2=y +CONFIG_RD_LZMA=y +CONFIG_RD_XZ=y +CONFIG_RD_LZO=y +CONFIG_RD_LZ4=y +CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE=y +# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set +CONFIG_SYSCTL=y +CONFIG_HAVE_UID16=y +CONFIG_SYSCTL_EXCEPTION_TRACE=y +CONFIG_HAVE_PCSPKR_PLATFORM=y +CONFIG_BPF=y +# CONFIG_EXPERT is not set +CONFIG_UID16=y +CONFIG_MULTIUSER=y +CONFIG_SGETMASK_SYSCALL=y +CONFIG_SYSFS_SYSCALL=y +CONFIG_FHANDLE=y +CONFIG_POSIX_TIMERS=y +CONFIG_PRINTK=y +CONFIG_PRINTK_NMI=y +CONFIG_BUG=y +CONFIG_ELF_CORE=y +CONFIG_PCSPKR_PLATFORM=y +CONFIG_BASE_FULL=y +CONFIG_FUTEX=y +CONFIG_FUTEX_PI=y +CONFIG_EPOLL=y +CONFIG_SIGNALFD=y +CONFIG_TIMERFD=y +CONFIG_EVENTFD=y +CONFIG_SHMEM=y +CONFIG_AIO=y +CONFIG_IO_URING=y +CONFIG_ADVISE_SYSCALLS=y +CONFIG_MEMBARRIER=y +CONFIG_KALLSYMS=y +# CONFIG_KALLSYMS_ALL is not set +CONFIG_KALLSYMS_ABSOLUTE_PERCPU=y +CONFIG_KALLSYMS_BASE_RELATIVE=y +CONFIG_BPF_SYSCALL=y +# CONFIG_BPF_JIT_ALWAYS_ON is not set +# CONFIG_USERFAULTFD is not set +CONFIG_ARCH_HAS_MEMBARRIER_SYNC_CORE=y +CONFIG_RSEQ=y +# CONFIG_EMBEDDED is not set +CONFIG_HAVE_PERF_EVENTS=y + +# +# Kernel Performance Events And Counters +# +CONFIG_PERF_EVENTS=y +# CONFIG_DEBUG_PERF_USE_VMALLOC is not set +# end of Kernel Performance Events And Counters + +CONFIG_VM_EVENT_COUNTERS=y +CONFIG_SLUB_DEBUG=y +# CONFIG_COMPAT_BRK is not set +# CONFIG_SLAB is not set +CONFIG_SLUB=y +CONFIG_SLAB_MERGE_DEFAULT=y +# CONFIG_SLAB_FREELIST_RANDOM is not set +# CONFIG_SLAB_FREELIST_HARDENED is not set +# CONFIG_SHUFFLE_PAGE_ALLOCATOR is not set +CONFIG_SLUB_CPU_PARTIAL=y +CONFIG_SYSTEM_DATA_VERIFICATION=y +CONFIG_PROFILING=y +CONFIG_TRACEPOINTS=y +# end of General setup + +CONFIG_64BIT=y +CONFIG_X86_64=y +CONFIG_X86=y +CONFIG_INSTRUCTION_DECODER=y +CONFIG_OUTPUT_FORMAT="elf64-x86-64" +CONFIG_ARCH_DEFCONFIG="arch/x86/configs/x86_64_defconfig" +CONFIG_LOCKDEP_SUPPORT=y +CONFIG_STACKTRACE_SUPPORT=y +CONFIG_MMU=y +CONFIG_ARCH_MMAP_RND_BITS_MIN=28 +CONFIG_ARCH_MMAP_RND_BITS_MAX=32 +CONFIG_ARCH_MMAP_RND_COMPAT_BITS_MIN=8 +CONFIG_ARCH_MMAP_RND_COMPAT_BITS_MAX=16 +CONFIG_GENERIC_ISA_DMA=y +CONFIG_GENERIC_BUG=y +CONFIG_GENERIC_BUG_RELATIVE_POINTERS=y +CONFIG_ARCH_MAY_HAVE_PC_FDC=y +CONFIG_GENERIC_CALIBRATE_DELAY=y +CONFIG_ARCH_HAS_CPU_RELAX=y +CONFIG_ARCH_HAS_CACHE_LINE_SIZE=y +CONFIG_ARCH_HAS_FILTER_PGPROT=y +CONFIG_HAVE_SETUP_PER_CPU_AREA=y +CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK=y +CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK=y +CONFIG_ARCH_HIBERNATION_POSSIBLE=y +CONFIG_ARCH_SUSPEND_POSSIBLE=y +CONFIG_ARCH_WANT_GENERAL_HUGETLB=y +CONFIG_ZONE_DMA32=y +CONFIG_AUDIT_ARCH=y +CONFIG_ARCH_SUPPORTS_DEBUG_PAGEALLOC=y +CONFIG_HAVE_INTEL_TXT=y +CONFIG_X86_64_SMP=y +CONFIG_ARCH_SUPPORTS_UPROBES=y +CONFIG_FIX_EARLYCON_MEM=y +CONFIG_PGTABLE_LEVELS=5 +CONFIG_CC_HAS_SANE_STACKPROTECTOR=y + +# +# Processor type and features +# +CONFIG_ZONE_DMA=y +CONFIG_SMP=y +CONFIG_X86_FEATURE_NAMES=y +CONFIG_X86_MPPARSE=y +# CONFIG_GOLDFISH is not set +CONFIG_RETPOLINE=y +# CONFIG_X86_CPU_RESCTRL is not set +CONFIG_X86_EXTENDED_PLATFORM=y +# CONFIG_X86_VSMP is not set +# CONFIG_X86_GOLDFISH is not set +# CONFIG_X86_INTEL_MID is not set +# CONFIG_X86_INTEL_LPSS is not set +# CONFIG_X86_AMD_PLATFORM_DEVICE is not set +CONFIG_IOSF_MBI=y +# CONFIG_IOSF_MBI_DEBUG is not set +CONFIG_X86_SUPPORTS_MEMORY_FAILURE=y +CONFIG_SCHED_OMIT_FRAME_POINTER=y +# CONFIG_HYPERVISOR_GUEST is not set +# CONFIG_MK8 is not set +# CONFIG_MPSC is not set +# CONFIG_MCORE2 is not set +# CONFIG_MATOM is not set +CONFIG_GENERIC_CPU=y +CONFIG_X86_INTERNODE_CACHE_SHIFT=6 +CONFIG_X86_L1_CACHE_SHIFT=6 +CONFIG_X86_TSC=y +CONFIG_X86_CMPXCHG64=y +CONFIG_X86_CMOV=y +CONFIG_X86_MINIMUM_CPU_FAMILY=64 +CONFIG_X86_DEBUGCTLMSR=y +CONFIG_CPU_SUP_INTEL=y +CONFIG_CPU_SUP_AMD=y +CONFIG_CPU_SUP_HYGON=y +CONFIG_CPU_SUP_CENTAUR=y +CONFIG_CPU_SUP_ZHAOXIN=y +CONFIG_HPET_TIMER=y +CONFIG_HPET_EMULATE_RTC=y +CONFIG_DMI=y +# CONFIG_GART_IOMMU is not set +# CONFIG_MAXSMP is not set +CONFIG_NR_CPUS_RANGE_BEGIN=2 +CONFIG_NR_CPUS_RANGE_END=512 +CONFIG_NR_CPUS_DEFAULT=64 +CONFIG_NR_CPUS=64 +CONFIG_SCHED_SMT=y +CONFIG_SCHED_MC=y +CONFIG_SCHED_MC_PRIO=y +CONFIG_X86_LOCAL_APIC=y +CONFIG_X86_IO_APIC=y +CONFIG_X86_REROUTE_FOR_BROKEN_BOOT_IRQS=y +CONFIG_X86_MCE=y +# CONFIG_X86_MCELOG_LEGACY is not set +CONFIG_X86_MCE_INTEL=y +CONFIG_X86_MCE_AMD=y +CONFIG_X86_MCE_THRESHOLD=y +# CONFIG_X86_MCE_INJECT is not set +CONFIG_X86_THERMAL_VECTOR=y + +# +# Performance monitoring +# +CONFIG_PERF_EVENTS_INTEL_UNCORE=y +CONFIG_PERF_EVENTS_INTEL_RAPL=y +CONFIG_PERF_EVENTS_INTEL_CSTATE=y +# CONFIG_PERF_EVENTS_AMD_POWER is not set +# end of Performance monitoring + +CONFIG_X86_16BIT=y +CONFIG_X86_ESPFIX64=y +CONFIG_X86_VSYSCALL_EMULATION=y +CONFIG_X86_IOPL_IOPERM=y +# CONFIG_I8K is not set +CONFIG_MICROCODE=y +CONFIG_MICROCODE_INTEL=y +CONFIG_MICROCODE_AMD=y +# CONFIG_MICROCODE_OLD_INTERFACE is not set +CONFIG_X86_MSR=y +CONFIG_X86_CPUID=y +CONFIG_X86_5LEVEL=y +CONFIG_X86_DIRECT_GBPAGES=y +# CONFIG_X86_CPA_STATISTICS is not set +# CONFIG_AMD_MEM_ENCRYPT is not set +CONFIG_NUMA=y +CONFIG_AMD_NUMA=y +CONFIG_X86_64_ACPI_NUMA=y +CONFIG_NODES_SPAN_OTHER_NODES=y +# CONFIG_NUMA_EMU is not set +CONFIG_NODES_SHIFT=6 +CONFIG_ARCH_SPARSEMEM_ENABLE=y +CONFIG_ARCH_SPARSEMEM_DEFAULT=y +CONFIG_ARCH_SELECT_MEMORY_MODEL=y +CONFIG_ARCH_PROC_KCORE_TEXT=y +CONFIG_ILLEGAL_POINTER_VALUE=0xdead000000000000 +# CONFIG_X86_PMEM_LEGACY is not set +CONFIG_X86_CHECK_BIOS_CORRUPTION=y +CONFIG_X86_BOOTPARAM_MEMORY_CORRUPTION_CHECK=y +CONFIG_X86_RESERVE_LOW=64 +CONFIG_MTRR=y +# CONFIG_MTRR_SANITIZER is not set +CONFIG_X86_PAT=y +CONFIG_ARCH_USES_PG_UNCACHED=y +CONFIG_ARCH_RANDOM=y +CONFIG_X86_SMAP=y +CONFIG_X86_UMIP=y +# CONFIG_X86_INTEL_MPX is not set +CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS=y +CONFIG_X86_INTEL_TSX_MODE_OFF=y +# CONFIG_X86_INTEL_TSX_MODE_ON is not set +# CONFIG_X86_INTEL_TSX_MODE_AUTO is not set +CONFIG_EFI=y +CONFIG_EFI_STUB=y +CONFIG_EFI_MIXED=y +CONFIG_SECCOMP=y +# CONFIG_HZ_100 is not set +# CONFIG_HZ_250 is not set +# CONFIG_HZ_300 is not set +CONFIG_HZ_1000=y +CONFIG_HZ=1000 +CONFIG_SCHED_HRTICK=y +CONFIG_KEXEC=y +# CONFIG_KEXEC_FILE is not set +CONFIG_CRASH_DUMP=y +# CONFIG_KEXEC_JUMP is not set +CONFIG_PHYSICAL_START=0x1000000 +CONFIG_RELOCATABLE=y +CONFIG_RANDOMIZE_BASE=y +CONFIG_X86_NEED_RELOCS=y +CONFIG_PHYSICAL_ALIGN=0x200000 +CONFIG_DYNAMIC_MEMORY_LAYOUT=y +CONFIG_RANDOMIZE_MEMORY=y +CONFIG_RANDOMIZE_MEMORY_PHYSICAL_PADDING=0x0 +CONFIG_HOTPLUG_CPU=y +# CONFIG_BOOTPARAM_HOTPLUG_CPU0 is not set +# CONFIG_DEBUG_HOTPLUG_CPU0 is not set +# CONFIG_COMPAT_VDSO is not set +# CONFIG_LEGACY_VSYSCALL_EMULATE is not set +CONFIG_LEGACY_VSYSCALL_XONLY=y +# CONFIG_LEGACY_VSYSCALL_NONE is not set +# CONFIG_CMDLINE_BOOL is not set +CONFIG_MODIFY_LDT_SYSCALL=y +CONFIG_HAVE_LIVEPATCH=y +# end of Processor type and features + +CONFIG_ARCH_HAS_ADD_PAGES=y +CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y +CONFIG_USE_PERCPU_NUMA_NODE_ID=y +CONFIG_ARCH_ENABLE_SPLIT_PMD_PTLOCK=y +CONFIG_ARCH_ENABLE_HUGEPAGE_MIGRATION=y + +# +# Power management and ACPI options +# +CONFIG_ARCH_HIBERNATION_HEADER=y +CONFIG_SUSPEND=y +CONFIG_SUSPEND_FREEZER=y +CONFIG_HIBERNATE_CALLBACKS=y +CONFIG_HIBERNATION=y +CONFIG_PM_STD_PARTITION="" +CONFIG_PM_SLEEP=y +CONFIG_PM_SLEEP_SMP=y +# CONFIG_PM_AUTOSLEEP is not set +# CONFIG_PM_WAKELOCKS is not set +CONFIG_PM=y +CONFIG_PM_DEBUG=y +# CONFIG_PM_ADVANCED_DEBUG is not set +# CONFIG_PM_TEST_SUSPEND is not set +CONFIG_PM_SLEEP_DEBUG=y +CONFIG_PM_TRACE=y +CONFIG_PM_TRACE_RTC=y +CONFIG_PM_CLK=y +# CONFIG_WQ_POWER_EFFICIENT_DEFAULT is not set +# CONFIG_ENERGY_MODEL is not set +CONFIG_ARCH_SUPPORTS_ACPI=y +CONFIG_ACPI=y +CONFIG_ACPI_LEGACY_TABLES_LOOKUP=y +CONFIG_ARCH_MIGHT_HAVE_ACPI_PDC=y +CONFIG_ACPI_SYSTEM_POWER_STATES_SUPPORT=y +# CONFIG_ACPI_DEBUGGER is not set +CONFIG_ACPI_SPCR_TABLE=y +CONFIG_ACPI_LPIT=y +CONFIG_ACPI_SLEEP=y +# CONFIG_ACPI_PROCFS_POWER is not set +CONFIG_ACPI_REV_OVERRIDE_POSSIBLE=y +# CONFIG_ACPI_EC_DEBUGFS is not set +CONFIG_ACPI_AC=y +CONFIG_ACPI_BATTERY=y +CONFIG_ACPI_BUTTON=y +CONFIG_ACPI_VIDEO=y +CONFIG_ACPI_FAN=y +# CONFIG_ACPI_TAD is not set +CONFIG_ACPI_DOCK=y +CONFIG_ACPI_CPU_FREQ_PSS=y +CONFIG_ACPI_PROCESSOR_CSTATE=y +CONFIG_ACPI_PROCESSOR_IDLE=y +CONFIG_ACPI_CPPC_LIB=y +CONFIG_ACPI_PROCESSOR=y +CONFIG_ACPI_HOTPLUG_CPU=y +# CONFIG_ACPI_PROCESSOR_AGGREGATOR is not set +CONFIG_ACPI_THERMAL=y +CONFIG_ARCH_HAS_ACPI_TABLE_UPGRADE=y +CONFIG_ACPI_TABLE_UPGRADE=y +# CONFIG_ACPI_DEBUG is not set +# CONFIG_ACPI_PCI_SLOT is not set +CONFIG_ACPI_CONTAINER=y +CONFIG_ACPI_HOTPLUG_IOAPIC=y +# CONFIG_ACPI_SBS is not set +# CONFIG_ACPI_HED is not set +# CONFIG_ACPI_CUSTOM_METHOD is not set +CONFIG_ACPI_BGRT=y +# CONFIG_ACPI_NFIT is not set +CONFIG_ACPI_NUMA=y +# CONFIG_ACPI_HMAT is not set +CONFIG_HAVE_ACPI_APEI=y +CONFIG_HAVE_ACPI_APEI_NMI=y +# CONFIG_ACPI_APEI is not set +# CONFIG_DPTF_POWER is not set +# CONFIG_ACPI_EXTLOG is not set +# CONFIG_PMIC_OPREGION is not set +# CONFIG_ACPI_CONFIGFS is not set +CONFIG_X86_PM_TIMER=y +# CONFIG_SFI is not set + +# +# CPU Frequency scaling +# +CONFIG_CPU_FREQ=y +CONFIG_CPU_FREQ_GOV_ATTR_SET=y +CONFIG_CPU_FREQ_GOV_COMMON=y +# CONFIG_CPU_FREQ_STAT is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE is not set +CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE=y +# CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_SCHEDUTIL is not set +CONFIG_CPU_FREQ_GOV_PERFORMANCE=y +# CONFIG_CPU_FREQ_GOV_POWERSAVE is not set +CONFIG_CPU_FREQ_GOV_USERSPACE=y +CONFIG_CPU_FREQ_GOV_ONDEMAND=y +# CONFIG_CPU_FREQ_GOV_CONSERVATIVE is not set +# CONFIG_CPU_FREQ_GOV_SCHEDUTIL is not set + +# +# CPU frequency scaling drivers +# +CONFIG_X86_INTEL_PSTATE=y +# CONFIG_X86_PCC_CPUFREQ is not set +CONFIG_X86_ACPI_CPUFREQ=y +CONFIG_X86_ACPI_CPUFREQ_CPB=y +# CONFIG_X86_POWERNOW_K8 is not set +# CONFIG_X86_AMD_FREQ_SENSITIVITY is not set +# CONFIG_X86_SPEEDSTEP_CENTRINO is not set +# CONFIG_X86_P4_CLOCKMOD is not set + +# +# shared options +# +# end of CPU Frequency scaling + +# +# CPU Idle +# +CONFIG_CPU_IDLE=y +# CONFIG_CPU_IDLE_GOV_LADDER is not set +CONFIG_CPU_IDLE_GOV_MENU=y +# CONFIG_CPU_IDLE_GOV_TEO is not set +# end of CPU Idle + +# CONFIG_INTEL_IDLE is not set +# end of Power management and ACPI options + +# +# Bus options (PCI etc.) +# +CONFIG_PCI_DIRECT=y +CONFIG_PCI_MMCONFIG=y +CONFIG_MMCONF_FAM10H=y +CONFIG_ISA_DMA_API=y +CONFIG_AMD_NB=y +# CONFIG_X86_SYSFB is not set +# end of Bus options (PCI etc.) + +# +# Binary Emulations +# +CONFIG_IA32_EMULATION=y +# CONFIG_X86_X32 is not set +CONFIG_COMPAT_32=y +CONFIG_COMPAT=y +CONFIG_COMPAT_FOR_U64_ALIGNMENT=y +CONFIG_SYSVIPC_COMPAT=y +# end of Binary Emulations + +# +# Firmware Drivers +# +# CONFIG_EDD is not set +CONFIG_FIRMWARE_MEMMAP=y +CONFIG_DMIID=y +# CONFIG_DMI_SYSFS is not set +CONFIG_DMI_SCAN_MACHINE_NON_EFI_FALLBACK=y +# CONFIG_FW_CFG_SYSFS is not set +# CONFIG_GOOGLE_FIRMWARE is not set + +# +# EFI (Extensible Firmware Interface) Support +# +CONFIG_EFI_VARS=y +CONFIG_EFI_ESRT=y +CONFIG_EFI_RUNTIME_MAP=y +# CONFIG_EFI_FAKE_MEMMAP is not set +CONFIG_EFI_RUNTIME_WRAPPERS=y +# CONFIG_EFI_BOOTLOADER_CONTROL is not set +# CONFIG_EFI_CAPSULE_LOADER is not set +# CONFIG_EFI_TEST is not set +# CONFIG_APPLE_PROPERTIES is not set +# CONFIG_RESET_ATTACK_MITIGATION is not set +# CONFIG_EFI_RCI2_TABLE is not set +# end of EFI (Extensible Firmware Interface) Support + +CONFIG_EFI_EARLYCON=y + +# +# Tegra firmware driver +# +# end of Tegra firmware driver +# end of Firmware Drivers + +CONFIG_HAVE_KVM=y +CONFIG_VIRTUALIZATION=y +# CONFIG_KVM is not set +# CONFIG_VHOST_NET is not set +# CONFIG_VHOST_CROSS_ENDIAN_LEGACY is not set + +# +# General architecture-dependent options +# +CONFIG_CRASH_CORE=y +CONFIG_KEXEC_CORE=y +CONFIG_HOTPLUG_SMT=y +# CONFIG_OPROFILE is not set +CONFIG_HAVE_OPROFILE=y +CONFIG_OPROFILE_NMI_TIMER=y +CONFIG_KPROBES=y +CONFIG_JUMP_LABEL=y +# CONFIG_STATIC_KEYS_SELFTEST is not set +CONFIG_OPTPROBES=y +CONFIG_UPROBES=y +CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS=y +CONFIG_ARCH_USE_BUILTIN_BSWAP=y +CONFIG_KRETPROBES=y +CONFIG_HAVE_IOREMAP_PROT=y +CONFIG_HAVE_KPROBES=y +CONFIG_HAVE_KRETPROBES=y +CONFIG_HAVE_OPTPROBES=y +CONFIG_HAVE_KPROBES_ON_FTRACE=y +CONFIG_HAVE_FUNCTION_ERROR_INJECTION=y +CONFIG_HAVE_NMI=y +CONFIG_HAVE_ARCH_TRACEHOOK=y +CONFIG_HAVE_DMA_CONTIGUOUS=y +CONFIG_GENERIC_SMP_IDLE_THREAD=y +CONFIG_ARCH_HAS_FORTIFY_SOURCE=y +CONFIG_ARCH_HAS_SET_MEMORY=y +CONFIG_ARCH_HAS_SET_DIRECT_MAP=y +CONFIG_HAVE_ARCH_THREAD_STRUCT_WHITELIST=y +CONFIG_ARCH_WANTS_DYNAMIC_TASK_STRUCT=y +CONFIG_HAVE_ASM_MODVERSIONS=y +CONFIG_HAVE_REGS_AND_STACK_ACCESS_API=y +CONFIG_HAVE_RSEQ=y +CONFIG_HAVE_FUNCTION_ARG_ACCESS_API=y +CONFIG_HAVE_CLK=y +CONFIG_HAVE_HW_BREAKPOINT=y +CONFIG_HAVE_MIXED_BREAKPOINTS_REGS=y +CONFIG_HAVE_USER_RETURN_NOTIFIER=y +CONFIG_HAVE_PERF_EVENTS_NMI=y +CONFIG_HAVE_HARDLOCKUP_DETECTOR_PERF=y +CONFIG_HAVE_PERF_REGS=y +CONFIG_HAVE_PERF_USER_STACK_DUMP=y +CONFIG_HAVE_ARCH_JUMP_LABEL=y +CONFIG_HAVE_ARCH_JUMP_LABEL_RELATIVE=y +CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG=y +CONFIG_HAVE_ALIGNED_STRUCT_PAGE=y +CONFIG_HAVE_CMPXCHG_LOCAL=y +CONFIG_HAVE_CMPXCHG_DOUBLE=y +CONFIG_ARCH_WANT_COMPAT_IPC_PARSE_VERSION=y +CONFIG_ARCH_WANT_OLD_COMPAT_IPC=y +CONFIG_HAVE_ARCH_SECCOMP_FILTER=y +CONFIG_SECCOMP_FILTER=y +CONFIG_HAVE_ARCH_STACKLEAK=y +CONFIG_HAVE_STACKPROTECTOR=y +CONFIG_CC_HAS_STACKPROTECTOR_NONE=y +CONFIG_STACKPROTECTOR=y +CONFIG_STACKPROTECTOR_STRONG=y +CONFIG_HAVE_ARCH_WITHIN_STACK_FRAMES=y +CONFIG_HAVE_CONTEXT_TRACKING=y +CONFIG_HAVE_VIRT_CPU_ACCOUNTING_GEN=y +CONFIG_HAVE_IRQ_TIME_ACCOUNTING=y +CONFIG_HAVE_MOVE_PMD=y +CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE=y +CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD=y +CONFIG_HAVE_ARCH_HUGE_VMAP=y +CONFIG_ARCH_WANT_HUGE_PMD_SHARE=y +CONFIG_HAVE_ARCH_SOFT_DIRTY=y +CONFIG_HAVE_MOD_ARCH_SPECIFIC=y +CONFIG_MODULES_USE_ELF_RELA=y +CONFIG_HAVE_IRQ_EXIT_ON_IRQ_STACK=y +CONFIG_ARCH_HAS_ELF_RANDOMIZE=y +CONFIG_HAVE_ARCH_MMAP_RND_BITS=y +CONFIG_HAVE_EXIT_THREAD=y +CONFIG_ARCH_MMAP_RND_BITS=28 +CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS=y +CONFIG_ARCH_MMAP_RND_COMPAT_BITS=8 +CONFIG_HAVE_ARCH_COMPAT_MMAP_BASES=y +CONFIG_HAVE_COPY_THREAD_TLS=y +CONFIG_HAVE_STACK_VALIDATION=y +CONFIG_HAVE_RELIABLE_STACKTRACE=y +CONFIG_OLD_SIGSUSPEND3=y +CONFIG_COMPAT_OLD_SIGACTION=y +CONFIG_COMPAT_32BIT_TIME=y +CONFIG_HAVE_ARCH_VMAP_STACK=y +CONFIG_VMAP_STACK=y +CONFIG_ARCH_HAS_STRICT_KERNEL_RWX=y +CONFIG_STRICT_KERNEL_RWX=y +CONFIG_ARCH_HAS_STRICT_MODULE_RWX=y +CONFIG_STRICT_MODULE_RWX=y +CONFIG_HAVE_ARCH_PREL32_RELOCATIONS=y +CONFIG_ARCH_USE_MEMREMAP_PROT=y +# CONFIG_LOCK_EVENT_COUNTS is not set +CONFIG_ARCH_HAS_MEM_ENCRYPT=y + +# +# GCOV-based kernel profiling +# +# CONFIG_GCOV_KERNEL is not set +CONFIG_ARCH_HAS_GCOV_PROFILE_ALL=y +# end of GCOV-based kernel profiling + +CONFIG_PLUGIN_HOSTCC="" +CONFIG_HAVE_GCC_PLUGINS=y +# end of General architecture-dependent options + +CONFIG_RT_MUTEXES=y +CONFIG_BASE_SMALL=0 +CONFIG_MODULES=y +# CONFIG_MODULE_FORCE_LOAD is not set +CONFIG_MODULE_UNLOAD=y +CONFIG_MODULE_FORCE_UNLOAD=y +# CONFIG_MODVERSIONS is not set +# CONFIG_MODULE_SRCVERSION_ALL is not set +# CONFIG_MODULE_SIG is not set +# CONFIG_MODULE_COMPRESS is not set +# CONFIG_MODULE_ALLOW_MISSING_NAMESPACE_IMPORTS is not set +# CONFIG_UNUSED_SYMBOLS is not set +# CONFIG_TRIM_UNUSED_KSYMS is not set +CONFIG_MODULES_TREE_LOOKUP=y +CONFIG_BLOCK=y +CONFIG_BLK_SCSI_REQUEST=y +CONFIG_BLK_DEV_BSG=y +# CONFIG_BLK_DEV_BSGLIB is not set +# CONFIG_BLK_DEV_INTEGRITY is not set +# CONFIG_BLK_DEV_ZONED is not set +# CONFIG_BLK_CMDLINE_PARSER is not set +# CONFIG_BLK_WBT is not set +CONFIG_BLK_DEBUG_FS=y +# CONFIG_BLK_SED_OPAL is not set + +# +# Partition Types +# +# CONFIG_PARTITION_ADVANCED is not set +CONFIG_MSDOS_PARTITION=y +CONFIG_EFI_PARTITION=y +# end of Partition Types + +CONFIG_BLOCK_COMPAT=y +CONFIG_BLK_MQ_PCI=y +CONFIG_BLK_PM=y + +# +# IO Schedulers +# +CONFIG_MQ_IOSCHED_DEADLINE=y +CONFIG_MQ_IOSCHED_KYBER=y +# CONFIG_IOSCHED_BFQ is not set +# end of IO Schedulers + +CONFIG_ASN1=y +CONFIG_INLINE_SPIN_UNLOCK_IRQ=y +CONFIG_INLINE_READ_UNLOCK=y +CONFIG_INLINE_READ_UNLOCK_IRQ=y +CONFIG_INLINE_WRITE_UNLOCK=y +CONFIG_INLINE_WRITE_UNLOCK_IRQ=y +CONFIG_ARCH_SUPPORTS_ATOMIC_RMW=y +CONFIG_MUTEX_SPIN_ON_OWNER=y +CONFIG_RWSEM_SPIN_ON_OWNER=y +CONFIG_LOCK_SPIN_ON_OWNER=y +CONFIG_ARCH_USE_QUEUED_SPINLOCKS=y +CONFIG_QUEUED_SPINLOCKS=y +CONFIG_ARCH_USE_QUEUED_RWLOCKS=y +CONFIG_QUEUED_RWLOCKS=y +CONFIG_ARCH_HAS_SYNC_CORE_BEFORE_USERMODE=y +CONFIG_ARCH_HAS_SYSCALL_WRAPPER=y +CONFIG_FREEZER=y + +# +# Executable file formats +# +CONFIG_BINFMT_ELF=y +CONFIG_COMPAT_BINFMT_ELF=y +CONFIG_ELFCORE=y +CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS=y +CONFIG_BINFMT_SCRIPT=y +CONFIG_BINFMT_MISC=y +CONFIG_COREDUMP=y +# end of Executable file formats + +# +# Memory Management options +# +CONFIG_SELECT_MEMORY_MODEL=y +CONFIG_SPARSEMEM_MANUAL=y +CONFIG_SPARSEMEM=y +CONFIG_NEED_MULTIPLE_NODES=y +CONFIG_HAVE_MEMORY_PRESENT=y +CONFIG_SPARSEMEM_EXTREME=y +CONFIG_SPARSEMEM_VMEMMAP_ENABLE=y +CONFIG_SPARSEMEM_VMEMMAP=y +CONFIG_HAVE_MEMBLOCK_NODE_MAP=y +CONFIG_HAVE_FAST_GUP=y +# CONFIG_MEMORY_HOTPLUG is not set +CONFIG_SPLIT_PTLOCK_CPUS=4 +CONFIG_COMPACTION=y +CONFIG_MIGRATION=y +CONFIG_PHYS_ADDR_T_64BIT=y +CONFIG_BOUNCE=y +CONFIG_VIRT_TO_BUS=y +CONFIG_MMU_NOTIFIER=y +# CONFIG_KSM is not set +CONFIG_DEFAULT_MMAP_MIN_ADDR=4096 +CONFIG_ARCH_SUPPORTS_MEMORY_FAILURE=y +# CONFIG_MEMORY_FAILURE is not set +# CONFIG_TRANSPARENT_HUGEPAGE is not set +CONFIG_ARCH_WANTS_THP_SWAP=y +# CONFIG_CLEANCACHE is not set +# CONFIG_FRONTSWAP is not set +# CONFIG_CMA is not set +# CONFIG_ZPOOL is not set +# CONFIG_ZBUD is not set +# CONFIG_ZSMALLOC is not set +CONFIG_GENERIC_EARLY_IOREMAP=y +# CONFIG_DEFERRED_STRUCT_PAGE_INIT is not set +# CONFIG_IDLE_PAGE_TRACKING is not set +CONFIG_ARCH_HAS_PTE_DEVMAP=y +CONFIG_ARCH_USES_HIGH_VMA_FLAGS=y +CONFIG_ARCH_HAS_PKEYS=y +# CONFIG_PERCPU_STATS is not set +# CONFIG_GUP_BENCHMARK is not set +CONFIG_ARCH_HAS_PTE_SPECIAL=y +# end of Memory Management options + +CONFIG_NET=y +CONFIG_NET_INGRESS=y +CONFIG_SKB_EXTENSIONS=y + +# +# Networking options +# +CONFIG_PACKET=y +# CONFIG_PACKET_DIAG is not set +CONFIG_UNIX=y +CONFIG_UNIX_SCM=y +# CONFIG_UNIX_DIAG is not set +# CONFIG_TLS is not set +CONFIG_XFRM=y +CONFIG_XFRM_ALGO=y +CONFIG_XFRM_USER=y +# CONFIG_XFRM_INTERFACE is not set +# CONFIG_XFRM_SUB_POLICY is not set +# CONFIG_XFRM_MIGRATE is not set +# CONFIG_XFRM_STATISTICS is not set +# CONFIG_NET_KEY is not set +CONFIG_XDP_SOCKETS=y +CONFIG_XDP_SOCKETS_DIAG=y +CONFIG_INET=y +CONFIG_IP_MULTICAST=y +CONFIG_IP_ADVANCED_ROUTER=y +# CONFIG_IP_FIB_TRIE_STATS is not set +CONFIG_IP_MULTIPLE_TABLES=y +CONFIG_IP_ROUTE_MULTIPATH=y +CONFIG_IP_ROUTE_VERBOSE=y +CONFIG_IP_PNP=y +CONFIG_IP_PNP_DHCP=y +CONFIG_IP_PNP_BOOTP=y +CONFIG_IP_PNP_RARP=y +# CONFIG_NET_IPIP is not set +# CONFIG_NET_IPGRE_DEMUX is not set +CONFIG_NET_IP_TUNNEL=y +CONFIG_IP_MROUTE_COMMON=y +CONFIG_IP_MROUTE=y +# CONFIG_IP_MROUTE_MULTIPLE_TABLES is not set +CONFIG_IP_PIMSM_V1=y +CONFIG_IP_PIMSM_V2=y +CONFIG_SYN_COOKIES=y +# CONFIG_NET_IPVTI is not set +# CONFIG_NET_FOU is not set +# CONFIG_NET_FOU_IP_TUNNELS is not set +# CONFIG_INET_AH is not set +# CONFIG_INET_ESP is not set +# CONFIG_INET_IPCOMP is not set +CONFIG_INET_TUNNEL=y +# CONFIG_INET_DIAG is not set +CONFIG_TCP_CONG_ADVANCED=y +# CONFIG_TCP_CONG_BIC is not set +CONFIG_TCP_CONG_CUBIC=y +# CONFIG_TCP_CONG_WESTWOOD is not set +# CONFIG_TCP_CONG_HTCP is not set +# CONFIG_TCP_CONG_HSTCP is not set +# CONFIG_TCP_CONG_HYBLA is not set +# CONFIG_TCP_CONG_VEGAS is not set +# CONFIG_TCP_CONG_NV is not set +# CONFIG_TCP_CONG_SCALABLE is not set +# CONFIG_TCP_CONG_LP is not set +# CONFIG_TCP_CONG_VENO is not set +# CONFIG_TCP_CONG_YEAH is not set +# CONFIG_TCP_CONG_ILLINOIS is not set +# CONFIG_TCP_CONG_DCTCP is not set +# CONFIG_TCP_CONG_CDG is not set +# CONFIG_TCP_CONG_BBR is not set +CONFIG_DEFAULT_CUBIC=y +# CONFIG_DEFAULT_RENO is not set +CONFIG_DEFAULT_TCP_CONG="cubic" +CONFIG_TCP_MD5SIG=y +CONFIG_IPV6=y +# CONFIG_IPV6_ROUTER_PREF is not set +# CONFIG_IPV6_OPTIMISTIC_DAD is not set +CONFIG_INET6_AH=y +CONFIG_INET6_ESP=y +# CONFIG_INET6_ESP_OFFLOAD is not set +# CONFIG_INET6_IPCOMP is not set +# CONFIG_IPV6_MIP6 is not set +# CONFIG_IPV6_ILA is not set +# CONFIG_IPV6_VTI is not set +CONFIG_IPV6_SIT=y +# CONFIG_IPV6_SIT_6RD is not set +CONFIG_IPV6_NDISC_NODETYPE=y +# CONFIG_IPV6_TUNNEL is not set +CONFIG_IPV6_MULTIPLE_TABLES=y +# CONFIG_IPV6_SUBTREES is not set +# CONFIG_IPV6_MROUTE is not set +CONFIG_IPV6_SEG6_LWTUNNEL=y +# CONFIG_IPV6_SEG6_HMAC is not set +CONFIG_IPV6_SEG6_BPF=y +CONFIG_NETLABEL=y +CONFIG_NETWORK_SECMARK=y +CONFIG_NET_PTP_CLASSIFY=y +# CONFIG_NETWORK_PHY_TIMESTAMPING is not set +CONFIG_NETFILTER=y +CONFIG_NETFILTER_ADVANCED=y + +# +# Core Netfilter Configuration +# +CONFIG_NETFILTER_INGRESS=y +CONFIG_NETFILTER_NETLINK=y +# CONFIG_NETFILTER_NETLINK_ACCT is not set +# CONFIG_NETFILTER_NETLINK_QUEUE is not set +CONFIG_NETFILTER_NETLINK_LOG=y +# CONFIG_NETFILTER_NETLINK_OSF is not set +CONFIG_NF_CONNTRACK=y +CONFIG_NF_LOG_COMMON=m +# CONFIG_NF_LOG_NETDEV is not set +# CONFIG_NF_CONNTRACK_MARK is not set +CONFIG_NF_CONNTRACK_SECMARK=y +# CONFIG_NF_CONNTRACK_ZONES is not set +CONFIG_NF_CONNTRACK_PROCFS=y +# CONFIG_NF_CONNTRACK_EVENTS is not set +# CONFIG_NF_CONNTRACK_TIMEOUT is not set +# CONFIG_NF_CONNTRACK_TIMESTAMP is not set +# CONFIG_NF_CONNTRACK_LABELS is not set +CONFIG_NF_CT_PROTO_DCCP=y +CONFIG_NF_CT_PROTO_SCTP=y +CONFIG_NF_CT_PROTO_UDPLITE=y +# CONFIG_NF_CONNTRACK_AMANDA is not set +CONFIG_NF_CONNTRACK_FTP=y +# CONFIG_NF_CONNTRACK_H323 is not set +CONFIG_NF_CONNTRACK_IRC=y +# CONFIG_NF_CONNTRACK_NETBIOS_NS is not set +# CONFIG_NF_CONNTRACK_SNMP is not set +# CONFIG_NF_CONNTRACK_PPTP is not set +# CONFIG_NF_CONNTRACK_SANE is not set +CONFIG_NF_CONNTRACK_SIP=y +# CONFIG_NF_CONNTRACK_TFTP is not set +CONFIG_NF_CT_NETLINK=y +# CONFIG_NETFILTER_NETLINK_GLUE_CT is not set +CONFIG_NF_NAT=y +CONFIG_NF_NAT_FTP=y +CONFIG_NF_NAT_IRC=y +CONFIG_NF_NAT_SIP=y +CONFIG_NF_NAT_MASQUERADE=y +# CONFIG_NF_TABLES is not set +CONFIG_NETFILTER_XTABLES=y + +# +# Xtables combined modules +# +CONFIG_NETFILTER_XT_MARK=m +# CONFIG_NETFILTER_XT_CONNMARK is not set + +# +# Xtables targets +# +# CONFIG_NETFILTER_XT_TARGET_AUDIT is not set +# CONFIG_NETFILTER_XT_TARGET_CHECKSUM is not set +# CONFIG_NETFILTER_XT_TARGET_CLASSIFY is not set +# CONFIG_NETFILTER_XT_TARGET_CONNMARK is not set +CONFIG_NETFILTER_XT_TARGET_CONNSECMARK=y +# CONFIG_NETFILTER_XT_TARGET_DSCP is not set +# CONFIG_NETFILTER_XT_TARGET_HL is not set +# CONFIG_NETFILTER_XT_TARGET_HMARK is not set +# CONFIG_NETFILTER_XT_TARGET_IDLETIMER is not set +# CONFIG_NETFILTER_XT_TARGET_LED is not set +CONFIG_NETFILTER_XT_TARGET_LOG=m +# CONFIG_NETFILTER_XT_TARGET_MARK is not set +CONFIG_NETFILTER_XT_NAT=m +# CONFIG_NETFILTER_XT_TARGET_NETMAP is not set +CONFIG_NETFILTER_XT_TARGET_NFLOG=y +# CONFIG_NETFILTER_XT_TARGET_NFQUEUE is not set +# CONFIG_NETFILTER_XT_TARGET_RATEEST is not set +# CONFIG_NETFILTER_XT_TARGET_REDIRECT is not set +CONFIG_NETFILTER_XT_TARGET_MASQUERADE=m +# CONFIG_NETFILTER_XT_TARGET_TEE is not set +# CONFIG_NETFILTER_XT_TARGET_TPROXY is not set +CONFIG_NETFILTER_XT_TARGET_SECMARK=y +CONFIG_NETFILTER_XT_TARGET_TCPMSS=y +# CONFIG_NETFILTER_XT_TARGET_TCPOPTSTRIP is not set + +# +# Xtables matches +# +CONFIG_NETFILTER_XT_MATCH_ADDRTYPE=m +CONFIG_NETFILTER_XT_MATCH_BPF=y +# CONFIG_NETFILTER_XT_MATCH_CGROUP is not set +# CONFIG_NETFILTER_XT_MATCH_CLUSTER is not set +# CONFIG_NETFILTER_XT_MATCH_COMMENT is not set +# CONFIG_NETFILTER_XT_MATCH_CONNBYTES is not set +# CONFIG_NETFILTER_XT_MATCH_CONNLABEL is not set +# CONFIG_NETFILTER_XT_MATCH_CONNLIMIT is not set +# CONFIG_NETFILTER_XT_MATCH_CONNMARK is not set +CONFIG_NETFILTER_XT_MATCH_CONNTRACK=y +# CONFIG_NETFILTER_XT_MATCH_CPU is not set +# CONFIG_NETFILTER_XT_MATCH_DCCP is not set +# CONFIG_NETFILTER_XT_MATCH_DEVGROUP is not set +# CONFIG_NETFILTER_XT_MATCH_DSCP is not set +# CONFIG_NETFILTER_XT_MATCH_ECN is not set +# CONFIG_NETFILTER_XT_MATCH_ESP is not set +# CONFIG_NETFILTER_XT_MATCH_HASHLIMIT is not set +# CONFIG_NETFILTER_XT_MATCH_HELPER is not set +# CONFIG_NETFILTER_XT_MATCH_HL is not set +# CONFIG_NETFILTER_XT_MATCH_IPCOMP is not set +# CONFIG_NETFILTER_XT_MATCH_IPRANGE is not set +# CONFIG_NETFILTER_XT_MATCH_L2TP is not set +# CONFIG_NETFILTER_XT_MATCH_LENGTH is not set +# CONFIG_NETFILTER_XT_MATCH_LIMIT is not set +# CONFIG_NETFILTER_XT_MATCH_MAC is not set +# CONFIG_NETFILTER_XT_MATCH_MARK is not set +# CONFIG_NETFILTER_XT_MATCH_MULTIPORT is not set +# CONFIG_NETFILTER_XT_MATCH_NFACCT is not set +# CONFIG_NETFILTER_XT_MATCH_OSF is not set +# CONFIG_NETFILTER_XT_MATCH_OWNER is not set +CONFIG_NETFILTER_XT_MATCH_POLICY=y +# CONFIG_NETFILTER_XT_MATCH_PKTTYPE is not set +# CONFIG_NETFILTER_XT_MATCH_QUOTA is not set +# CONFIG_NETFILTER_XT_MATCH_RATEEST is not set +# CONFIG_NETFILTER_XT_MATCH_REALM is not set +# CONFIG_NETFILTER_XT_MATCH_RECENT is not set +# CONFIG_NETFILTER_XT_MATCH_SCTP is not set +# CONFIG_NETFILTER_XT_MATCH_SOCKET is not set +CONFIG_NETFILTER_XT_MATCH_STATE=y +# CONFIG_NETFILTER_XT_MATCH_STATISTIC is not set +# CONFIG_NETFILTER_XT_MATCH_STRING is not set +# CONFIG_NETFILTER_XT_MATCH_TCPMSS is not set +# CONFIG_NETFILTER_XT_MATCH_TIME is not set +# CONFIG_NETFILTER_XT_MATCH_U32 is not set +# end of Core Netfilter Configuration + +# CONFIG_IP_SET is not set +# CONFIG_IP_VS is not set + +# +# IP: Netfilter Configuration +# +CONFIG_NF_DEFRAG_IPV4=y +# CONFIG_NF_SOCKET_IPV4 is not set +# CONFIG_NF_TPROXY_IPV4 is not set +# CONFIG_NF_DUP_IPV4 is not set +CONFIG_NF_LOG_ARP=m +CONFIG_NF_LOG_IPV4=m +CONFIG_NF_REJECT_IPV4=y +CONFIG_IP_NF_IPTABLES=y +# CONFIG_IP_NF_MATCH_AH is not set +# CONFIG_IP_NF_MATCH_ECN is not set +# CONFIG_IP_NF_MATCH_RPFILTER is not set +# CONFIG_IP_NF_MATCH_TTL is not set +CONFIG_IP_NF_FILTER=y +CONFIG_IP_NF_TARGET_REJECT=y +# CONFIG_IP_NF_TARGET_SYNPROXY is not set +CONFIG_IP_NF_NAT=m +CONFIG_IP_NF_TARGET_MASQUERADE=m +# CONFIG_IP_NF_TARGET_NETMAP is not set +# CONFIG_IP_NF_TARGET_REDIRECT is not set +CONFIG_IP_NF_MANGLE=y +# CONFIG_IP_NF_TARGET_CLUSTERIP is not set +# CONFIG_IP_NF_TARGET_ECN is not set +# CONFIG_IP_NF_TARGET_TTL is not set +# CONFIG_IP_NF_RAW is not set +# CONFIG_IP_NF_SECURITY is not set +# CONFIG_IP_NF_ARPTABLES is not set +# end of IP: Netfilter Configuration + +# +# IPv6: Netfilter Configuration +# +# CONFIG_NF_SOCKET_IPV6 is not set +# CONFIG_NF_TPROXY_IPV6 is not set +# CONFIG_NF_DUP_IPV6 is not set +CONFIG_NF_REJECT_IPV6=y +CONFIG_NF_LOG_IPV6=m +CONFIG_IP6_NF_IPTABLES=y +# CONFIG_IP6_NF_MATCH_AH is not set +# CONFIG_IP6_NF_MATCH_EUI64 is not set +# CONFIG_IP6_NF_MATCH_FRAG is not set +# CONFIG_IP6_NF_MATCH_OPTS is not set +# CONFIG_IP6_NF_MATCH_HL is not set +CONFIG_IP6_NF_MATCH_IPV6HEADER=y +# CONFIG_IP6_NF_MATCH_MH is not set +# CONFIG_IP6_NF_MATCH_RPFILTER is not set +# CONFIG_IP6_NF_MATCH_RT is not set +# CONFIG_IP6_NF_MATCH_SRH is not set +# CONFIG_IP6_NF_TARGET_HL is not set +CONFIG_IP6_NF_FILTER=y +CONFIG_IP6_NF_TARGET_REJECT=y +# CONFIG_IP6_NF_TARGET_SYNPROXY is not set +CONFIG_IP6_NF_MANGLE=y +# CONFIG_IP6_NF_RAW is not set +# CONFIG_IP6_NF_SECURITY is not set +# CONFIG_IP6_NF_NAT is not set +# end of IPv6: Netfilter Configuration + +CONFIG_NF_DEFRAG_IPV6=y +# CONFIG_NF_CONNTRACK_BRIDGE is not set +CONFIG_BPFILTER=y +CONFIG_BPFILTER_UMH=m +# CONFIG_IP_DCCP is not set +# CONFIG_IP_SCTP is not set +# CONFIG_RDS is not set +# CONFIG_TIPC is not set +# CONFIG_ATM is not set +# CONFIG_L2TP is not set +# CONFIG_BRIDGE is not set +CONFIG_HAVE_NET_DSA=y +# CONFIG_NET_DSA is not set +# CONFIG_VLAN_8021Q is not set +# CONFIG_DECNET is not set +# CONFIG_LLC2 is not set +# CONFIG_ATALK is not set +# CONFIG_X25 is not set +# CONFIG_LAPB is not set +# CONFIG_PHONET is not set +# CONFIG_6LOWPAN is not set +# CONFIG_IEEE802154 is not set +CONFIG_NET_SCHED=y + +# +# Queueing/Scheduling +# +# CONFIG_NET_SCH_CBQ is not set +# CONFIG_NET_SCH_HTB is not set +# CONFIG_NET_SCH_HFSC is not set +# CONFIG_NET_SCH_PRIO is not set +# CONFIG_NET_SCH_MULTIQ is not set +# CONFIG_NET_SCH_RED is not set +# CONFIG_NET_SCH_SFB is not set +# CONFIG_NET_SCH_SFQ is not set +# CONFIG_NET_SCH_TEQL is not set +# CONFIG_NET_SCH_TBF is not set +# CONFIG_NET_SCH_CBS is not set +# CONFIG_NET_SCH_ETF is not set +# CONFIG_NET_SCH_TAPRIO is not set +# CONFIG_NET_SCH_GRED is not set +# CONFIG_NET_SCH_DSMARK is not set +# CONFIG_NET_SCH_NETEM is not set +# CONFIG_NET_SCH_DRR is not set +# CONFIG_NET_SCH_MQPRIO is not set +# CONFIG_NET_SCH_SKBPRIO is not set +# CONFIG_NET_SCH_CHOKE is not set +# CONFIG_NET_SCH_QFQ is not set +# CONFIG_NET_SCH_CODEL is not set +# CONFIG_NET_SCH_FQ_CODEL is not set +# CONFIG_NET_SCH_CAKE is not set +# CONFIG_NET_SCH_FQ is not set +# CONFIG_NET_SCH_HHF is not set +# CONFIG_NET_SCH_PIE is not set +# CONFIG_NET_SCH_INGRESS is not set +# CONFIG_NET_SCH_PLUG is not set +# CONFIG_NET_SCH_DEFAULT is not set + +# +# Classification +# +CONFIG_NET_CLS=y +# CONFIG_NET_CLS_BASIC is not set +# CONFIG_NET_CLS_TCINDEX is not set +# CONFIG_NET_CLS_ROUTE4 is not set +# CONFIG_NET_CLS_FW is not set +# CONFIG_NET_CLS_U32 is not set +# CONFIG_NET_CLS_RSVP is not set +# CONFIG_NET_CLS_RSVP6 is not set +# CONFIG_NET_CLS_FLOW is not set +# CONFIG_NET_CLS_CGROUP is not set +CONFIG_NET_CLS_BPF=y +# CONFIG_NET_CLS_FLOWER is not set +# CONFIG_NET_CLS_MATCHALL is not set +CONFIG_NET_EMATCH=y +CONFIG_NET_EMATCH_STACK=32 +# CONFIG_NET_EMATCH_CMP is not set +# CONFIG_NET_EMATCH_NBYTE is not set +# CONFIG_NET_EMATCH_U32 is not set +# CONFIG_NET_EMATCH_META is not set +# CONFIG_NET_EMATCH_TEXT is not set +# CONFIG_NET_EMATCH_IPT is not set +CONFIG_NET_CLS_ACT=y +# CONFIG_NET_ACT_POLICE is not set +# CONFIG_NET_ACT_GACT is not set +# CONFIG_NET_ACT_MIRRED is not set +# CONFIG_NET_ACT_SAMPLE is not set +# CONFIG_NET_ACT_IPT is not set +# CONFIG_NET_ACT_NAT is not set +# CONFIG_NET_ACT_PEDIT is not set +# CONFIG_NET_ACT_SIMP is not set +# CONFIG_NET_ACT_SKBEDIT is not set +# CONFIG_NET_ACT_CSUM is not set +# CONFIG_NET_ACT_MPLS is not set +# CONFIG_NET_ACT_VLAN is not set +CONFIG_NET_ACT_BPF=y +# CONFIG_NET_ACT_SKBMOD is not set +# CONFIG_NET_ACT_IFE is not set +# CONFIG_NET_ACT_TUNNEL_KEY is not set +# CONFIG_NET_ACT_CT is not set +# CONFIG_NET_TC_SKB_EXT is not set +CONFIG_NET_SCH_FIFO=y +# CONFIG_DCB is not set +CONFIG_DNS_RESOLVER=y +# CONFIG_BATMAN_ADV is not set +# CONFIG_OPENVSWITCH is not set +# CONFIG_VSOCKETS is not set +# CONFIG_NETLINK_DIAG is not set +# CONFIG_MPLS is not set +# CONFIG_NET_NSH is not set +# CONFIG_HSR is not set +# CONFIG_NET_SWITCHDEV is not set +# CONFIG_NET_L3_MASTER_DEV is not set +# CONFIG_NET_NCSI is not set +CONFIG_RPS=y +CONFIG_RFS_ACCEL=y +CONFIG_XPS=y +# CONFIG_CGROUP_NET_PRIO is not set +# CONFIG_CGROUP_NET_CLASSID is not set +CONFIG_NET_RX_BUSY_POLL=y +CONFIG_BQL=y +CONFIG_BPF_JIT=y +CONFIG_BPF_STREAM_PARSER=y +CONFIG_NET_FLOW_LIMIT=y + +# +# Network testing +# +# CONFIG_NET_PKTGEN is not set +# CONFIG_NET_DROP_MONITOR is not set +# end of Network testing +# end of Networking options + +CONFIG_HAMRADIO=y + +# +# Packet Radio protocols +# +# CONFIG_AX25 is not set +# CONFIG_CAN is not set +# CONFIG_BT is not set +# CONFIG_AF_RXRPC is not set +# CONFIG_AF_KCM is not set +CONFIG_STREAM_PARSER=y +CONFIG_FIB_RULES=y +CONFIG_WIRELESS=y +CONFIG_CFG80211=y +# CONFIG_NL80211_TESTMODE is not set +# CONFIG_CFG80211_DEVELOPER_WARNINGS is not set +CONFIG_CFG80211_REQUIRE_SIGNED_REGDB=y +CONFIG_CFG80211_USE_KERNEL_REGDB_KEYS=y +CONFIG_CFG80211_DEFAULT_PS=y +# CONFIG_CFG80211_DEBUGFS is not set +CONFIG_CFG80211_CRDA_SUPPORT=y +# CONFIG_CFG80211_WEXT is not set +CONFIG_MAC80211=y +CONFIG_MAC80211_HAS_RC=y +CONFIG_MAC80211_RC_MINSTREL=y +CONFIG_MAC80211_RC_DEFAULT_MINSTREL=y +CONFIG_MAC80211_RC_DEFAULT="minstrel_ht" +# CONFIG_MAC80211_MESH is not set +CONFIG_MAC80211_LEDS=y +# CONFIG_MAC80211_DEBUGFS is not set +# CONFIG_MAC80211_MESSAGE_TRACING is not set +# CONFIG_MAC80211_DEBUG_MENU is not set +CONFIG_MAC80211_STA_HASH_MAX_SIZE=0 +# CONFIG_WIMAX is not set +CONFIG_RFKILL=y +CONFIG_RFKILL_LEDS=y +CONFIG_RFKILL_INPUT=y +# CONFIG_NET_9P is not set +# CONFIG_CAIF is not set +# CONFIG_CEPH_LIB is not set +# CONFIG_NFC is not set +# CONFIG_PSAMPLE is not set +# CONFIG_NET_IFE is not set +CONFIG_LWTUNNEL=y +CONFIG_LWTUNNEL_BPF=y +CONFIG_DST_CACHE=y +CONFIG_GRO_CELLS=y +CONFIG_NET_SOCK_MSG=y +# CONFIG_FAILOVER is not set +CONFIG_HAVE_EBPF_JIT=y + +# +# Device Drivers +# +CONFIG_HAVE_EISA=y +# CONFIG_EISA is not set +CONFIG_HAVE_PCI=y +CONFIG_PCI=y +CONFIG_PCI_DOMAINS=y +CONFIG_PCIEPORTBUS=y +# CONFIG_HOTPLUG_PCI_PCIE is not set +CONFIG_PCIEAER=y +# CONFIG_PCIEAER_INJECT is not set +# CONFIG_PCIE_ECRC is not set +CONFIG_PCIEASPM=y +CONFIG_PCIEASPM_DEFAULT=y +# CONFIG_PCIEASPM_POWERSAVE is not set +# CONFIG_PCIEASPM_POWER_SUPERSAVE is not set +# CONFIG_PCIEASPM_PERFORMANCE is not set +CONFIG_PCIE_PME=y +# CONFIG_PCIE_DPC is not set +# CONFIG_PCIE_PTM is not set +# CONFIG_PCIE_BW is not set +CONFIG_PCI_MSI=y +CONFIG_PCI_MSI_IRQ_DOMAIN=y +CONFIG_PCI_QUIRKS=y +# CONFIG_PCI_DEBUG is not set +# CONFIG_PCI_STUB is not set +CONFIG_PCI_ATS=y +CONFIG_PCI_LOCKLESS_CONFIG=y +# CONFIG_PCI_IOV is not set +CONFIG_PCI_PRI=y +CONFIG_PCI_PASID=y +CONFIG_PCI_LABEL=y +CONFIG_HOTPLUG_PCI=y +# CONFIG_HOTPLUG_PCI_ACPI is not set +# CONFIG_HOTPLUG_PCI_CPCI is not set +# CONFIG_HOTPLUG_PCI_SHPC is not set + +# +# PCI controller drivers +# +# CONFIG_VMD is not set + +# +# DesignWare PCI Core Support +# +# CONFIG_PCIE_DW_PLAT_HOST is not set +# CONFIG_PCI_MESON is not set +# end of DesignWare PCI Core Support + +# +# Cadence PCIe controllers support +# +# end of Cadence PCIe controllers support +# end of PCI controller drivers + +# +# PCI Endpoint +# +# CONFIG_PCI_ENDPOINT is not set +# end of PCI Endpoint + +# +# PCI switch controller drivers +# +# CONFIG_PCI_SW_SWITCHTEC is not set +# end of PCI switch controller drivers + +CONFIG_PCCARD=y +CONFIG_PCMCIA=y +CONFIG_PCMCIA_LOAD_CIS=y +CONFIG_CARDBUS=y + +# +# PC-card bridges +# +CONFIG_YENTA=y +CONFIG_YENTA_O2=y +CONFIG_YENTA_RICOH=y +CONFIG_YENTA_TI=y +CONFIG_YENTA_ENE_TUNE=y +CONFIG_YENTA_TOSHIBA=y +# CONFIG_PD6729 is not set +# CONFIG_I82092 is not set +CONFIG_PCCARD_NONSTATIC=y +# CONFIG_RAPIDIO is not set + +# +# Generic Driver Options +# +# CONFIG_UEVENT_HELPER is not set +CONFIG_DEVTMPFS=y +CONFIG_DEVTMPFS_MOUNT=y +CONFIG_STANDALONE=y +CONFIG_PREVENT_FIRMWARE_BUILD=y + +# +# Firmware loader +# +CONFIG_FW_LOADER=y +CONFIG_EXTRA_FIRMWARE="" +# CONFIG_FW_LOADER_USER_HELPER is not set +# CONFIG_FW_LOADER_COMPRESS is not set +CONFIG_FW_CACHE=y +# end of Firmware loader + +CONFIG_ALLOW_DEV_COREDUMP=y +# CONFIG_DEBUG_DRIVER is not set +CONFIG_DEBUG_DEVRES=y +# CONFIG_DEBUG_TEST_DRIVER_REMOVE is not set +# CONFIG_TEST_ASYNC_DRIVER_PROBE is not set +CONFIG_GENERIC_CPU_AUTOPROBE=y +CONFIG_GENERIC_CPU_VULNERABILITIES=y +CONFIG_REGMAP=y +CONFIG_REGMAP_I2C=y +CONFIG_DMA_SHARED_BUFFER=y +# CONFIG_DMA_FENCE_TRACE is not set +# end of Generic Driver Options + +# +# Bus devices +# +# end of Bus devices + +CONFIG_CONNECTOR=y +CONFIG_PROC_EVENTS=y +# CONFIG_GNSS is not set +# CONFIG_MTD is not set +# CONFIG_OF is not set +CONFIG_ARCH_MIGHT_HAVE_PC_PARPORT=y +# CONFIG_PARPORT is not set +CONFIG_PNP=y +CONFIG_PNP_DEBUG_MESSAGES=y + +# +# Protocols +# +CONFIG_PNPACPI=y +CONFIG_BLK_DEV=y +# CONFIG_BLK_DEV_NULL_BLK is not set +# CONFIG_BLK_DEV_FD is not set +CONFIG_CDROM=y +# CONFIG_BLK_DEV_PCIESSD_MTIP32XX is not set +# CONFIG_BLK_DEV_UMEM is not set +CONFIG_BLK_DEV_LOOP=y +CONFIG_BLK_DEV_LOOP_MIN_COUNT=8 +# CONFIG_BLK_DEV_CRYPTOLOOP is not set +# CONFIG_BLK_DEV_DRBD is not set +# CONFIG_BLK_DEV_NBD is not set +# CONFIG_BLK_DEV_SKD is not set +# CONFIG_BLK_DEV_SX8 is not set +# CONFIG_BLK_DEV_RAM is not set +# CONFIG_CDROM_PKTCDVD is not set +# CONFIG_ATA_OVER_ETH is not set +# CONFIG_BLK_DEV_RBD is not set +# CONFIG_BLK_DEV_RSXX is not set + +# +# NVME Support +# +# CONFIG_BLK_DEV_NVME is not set +# CONFIG_NVME_FC is not set +# end of NVME Support + +# +# Misc devices +# +# CONFIG_AD525X_DPOT is not set +# CONFIG_DUMMY_IRQ is not set +# CONFIG_IBM_ASM is not set +# CONFIG_PHANTOM is not set +# CONFIG_TIFM_CORE is not set +# CONFIG_ICS932S401 is not set +# CONFIG_ENCLOSURE_SERVICES is not set +# CONFIG_HP_ILO is not set +# CONFIG_APDS9802ALS is not set +# CONFIG_ISL29003 is not set +# CONFIG_ISL29020 is not set +# CONFIG_SENSORS_TSL2550 is not set +# CONFIG_SENSORS_BH1770 is not set +# CONFIG_SENSORS_APDS990X is not set +# CONFIG_HMC6352 is not set +# CONFIG_DS1682 is not set +# CONFIG_SRAM is not set +# CONFIG_PCI_ENDPOINT_TEST is not set +# CONFIG_XILINX_SDFEC is not set +# CONFIG_PVPANIC is not set +# CONFIG_C2PORT is not set + +# +# EEPROM support +# +# CONFIG_EEPROM_AT24 is not set +# CONFIG_EEPROM_LEGACY is not set +# CONFIG_EEPROM_MAX6875 is not set +# CONFIG_EEPROM_93CX6 is not set +# CONFIG_EEPROM_IDT_89HPESX is not set +# CONFIG_EEPROM_EE1004 is not set +# end of EEPROM support + +# CONFIG_CB710_CORE is not set + +# +# Texas Instruments shared transport line discipline +# +# end of Texas Instruments shared transport line discipline + +# CONFIG_SENSORS_LIS3_I2C is not set +# CONFIG_ALTERA_STAPL is not set +# CONFIG_INTEL_MEI is not set +# CONFIG_INTEL_MEI_ME is not set +# CONFIG_INTEL_MEI_TXE is not set +# CONFIG_INTEL_MEI_HDCP is not set +# CONFIG_VMWARE_VMCI is not set + +# +# Intel MIC & related support +# +# CONFIG_INTEL_MIC_BUS is not set +# CONFIG_SCIF_BUS is not set +# CONFIG_VOP_BUS is not set +# end of Intel MIC & related support + +# CONFIG_GENWQE is not set +# CONFIG_ECHO is not set +# CONFIG_MISC_ALCOR_PCI is not set +# CONFIG_MISC_RTSX_PCI is not set +# CONFIG_MISC_RTSX_USB is not set +# CONFIG_HABANA_AI is not set +# end of Misc devices + +CONFIG_HAVE_IDE=y +# CONFIG_IDE is not set + +# +# SCSI device support +# +CONFIG_SCSI_MOD=y +# CONFIG_RAID_ATTRS is not set +CONFIG_SCSI=y +CONFIG_SCSI_DMA=y +CONFIG_SCSI_PROC_FS=y + +# +# SCSI support type (disk, tape, CD-ROM) +# +CONFIG_BLK_DEV_SD=y +# CONFIG_CHR_DEV_ST is not set +CONFIG_BLK_DEV_SR=y +CONFIG_BLK_DEV_SR_VENDOR=y +CONFIG_CHR_DEV_SG=y +# CONFIG_CHR_DEV_SCH is not set +CONFIG_SCSI_CONSTANTS=y +# CONFIG_SCSI_LOGGING is not set +# CONFIG_SCSI_SCAN_ASYNC is not set + +# +# SCSI Transports +# +CONFIG_SCSI_SPI_ATTRS=y +# CONFIG_SCSI_FC_ATTRS is not set +# CONFIG_SCSI_ISCSI_ATTRS is not set +# CONFIG_SCSI_SAS_ATTRS is not set +# CONFIG_SCSI_SAS_LIBSAS is not set +# CONFIG_SCSI_SRP_ATTRS is not set +# end of SCSI Transports + +# CONFIG_SCSI_LOWLEVEL is not set +# CONFIG_SCSI_DH is not set +# end of SCSI device support + +CONFIG_ATA=y +CONFIG_ATA_VERBOSE_ERROR=y +CONFIG_ATA_ACPI=y +# CONFIG_SATA_ZPODD is not set +CONFIG_SATA_PMP=y + +# +# Controllers with non-SFF native interface +# +CONFIG_SATA_AHCI=y +CONFIG_SATA_MOBILE_LPM_POLICY=0 +# CONFIG_SATA_AHCI_PLATFORM is not set +# CONFIG_SATA_INIC162X is not set +# CONFIG_SATA_ACARD_AHCI is not set +# CONFIG_SATA_SIL24 is not set +CONFIG_ATA_SFF=y + +# +# SFF controllers with custom DMA interface +# +# CONFIG_PDC_ADMA is not set +# CONFIG_SATA_QSTOR is not set +# CONFIG_SATA_SX4 is not set +CONFIG_ATA_BMDMA=y + +# +# SATA SFF controllers with BMDMA +# +CONFIG_ATA_PIIX=y +# CONFIG_SATA_DWC is not set +# CONFIG_SATA_MV is not set +# CONFIG_SATA_NV is not set +# CONFIG_SATA_PROMISE is not set +# CONFIG_SATA_SIL is not set +# CONFIG_SATA_SIS is not set +# CONFIG_SATA_SVW is not set +# CONFIG_SATA_ULI is not set +# CONFIG_SATA_VIA is not set +# CONFIG_SATA_VITESSE is not set + +# +# PATA SFF controllers with BMDMA +# +# CONFIG_PATA_ALI is not set +CONFIG_PATA_AMD=y +# CONFIG_PATA_ARTOP is not set +# CONFIG_PATA_ATIIXP is not set +# CONFIG_PATA_ATP867X is not set +# CONFIG_PATA_CMD64X is not set +# CONFIG_PATA_CYPRESS is not set +# CONFIG_PATA_EFAR is not set +# CONFIG_PATA_HPT366 is not set +# CONFIG_PATA_HPT37X is not set +# CONFIG_PATA_HPT3X2N is not set +# CONFIG_PATA_HPT3X3 is not set +# CONFIG_PATA_IT8213 is not set +# CONFIG_PATA_IT821X is not set +# CONFIG_PATA_JMICRON is not set +# CONFIG_PATA_MARVELL is not set +# CONFIG_PATA_NETCELL is not set +# CONFIG_PATA_NINJA32 is not set +# CONFIG_PATA_NS87415 is not set +CONFIG_PATA_OLDPIIX=y +# CONFIG_PATA_OPTIDMA is not set +# CONFIG_PATA_PDC2027X is not set +# CONFIG_PATA_PDC_OLD is not set +# CONFIG_PATA_RADISYS is not set +# CONFIG_PATA_RDC is not set +CONFIG_PATA_SCH=y +# CONFIG_PATA_SERVERWORKS is not set +# CONFIG_PATA_SIL680 is not set +# CONFIG_PATA_SIS is not set +# CONFIG_PATA_TOSHIBA is not set +# CONFIG_PATA_TRIFLEX is not set +# CONFIG_PATA_VIA is not set +# CONFIG_PATA_WINBOND is not set + +# +# PIO-only SFF controllers +# +# CONFIG_PATA_CMD640_PCI is not set +# CONFIG_PATA_MPIIX is not set +# CONFIG_PATA_NS87410 is not set +# CONFIG_PATA_OPTI is not set +# CONFIG_PATA_PCMCIA is not set +# CONFIG_PATA_RZ1000 is not set + +# +# Generic fallback / legacy drivers +# +# CONFIG_PATA_ACPI is not set +# CONFIG_ATA_GENERIC is not set +# CONFIG_PATA_LEGACY is not set +CONFIG_MD=y +CONFIG_BLK_DEV_MD=y +CONFIG_MD_AUTODETECT=y +# CONFIG_MD_LINEAR is not set +# CONFIG_MD_RAID0 is not set +# CONFIG_MD_RAID1 is not set +# CONFIG_MD_RAID10 is not set +# CONFIG_MD_RAID456 is not set +# CONFIG_MD_MULTIPATH is not set +# CONFIG_MD_FAULTY is not set +# CONFIG_BCACHE is not set +CONFIG_BLK_DEV_DM_BUILTIN=y +CONFIG_BLK_DEV_DM=y +# CONFIG_DM_DEBUG is not set +# CONFIG_DM_UNSTRIPED is not set +# CONFIG_DM_CRYPT is not set +# CONFIG_DM_SNAPSHOT is not set +# CONFIG_DM_THIN_PROVISIONING is not set +# CONFIG_DM_CACHE is not set +# CONFIG_DM_WRITECACHE is not set +# CONFIG_DM_ERA is not set +# CONFIG_DM_CLONE is not set +CONFIG_DM_MIRROR=y +# CONFIG_DM_LOG_USERSPACE is not set +# CONFIG_DM_RAID is not set +CONFIG_DM_ZERO=y +# CONFIG_DM_MULTIPATH is not set +# CONFIG_DM_DELAY is not set +# CONFIG_DM_DUST is not set +# CONFIG_DM_INIT is not set +# CONFIG_DM_UEVENT is not set +# CONFIG_DM_FLAKEY is not set +# CONFIG_DM_VERITY is not set +# CONFIG_DM_SWITCH is not set +# CONFIG_DM_LOG_WRITES is not set +# CONFIG_DM_INTEGRITY is not set +# CONFIG_TARGET_CORE is not set +# CONFIG_FUSION is not set + +# +# IEEE 1394 (FireWire) support +# +# CONFIG_FIREWIRE is not set +# CONFIG_FIREWIRE_NOSY is not set +# end of IEEE 1394 (FireWire) support + +CONFIG_MACINTOSH_DRIVERS=y +CONFIG_MAC_EMUMOUSEBTN=y +CONFIG_NETDEVICES=y +CONFIG_MII=y +CONFIG_NET_CORE=y +# CONFIG_BONDING is not set +# CONFIG_DUMMY is not set +# CONFIG_EQUALIZER is not set +# CONFIG_NET_FC is not set +# CONFIG_IFB is not set +# CONFIG_NET_TEAM is not set +# CONFIG_MACVLAN is not set +# CONFIG_IPVLAN is not set +# CONFIG_VXLAN is not set +# CONFIG_GENEVE is not set +# CONFIG_GTP is not set +# CONFIG_MACSEC is not set +CONFIG_NETCONSOLE=y +CONFIG_NETPOLL=y +CONFIG_NET_POLL_CONTROLLER=y +# CONFIG_TUN is not set +# CONFIG_TUN_VNET_CROSS_LE is not set +# CONFIG_VETH is not set +# CONFIG_NLMON is not set +# CONFIG_ARCNET is not set + +# +# Distributed Switch Architecture drivers +# +# end of Distributed Switch Architecture drivers + +CONFIG_ETHERNET=y +CONFIG_NET_VENDOR_3COM=y +# CONFIG_PCMCIA_3C574 is not set +# CONFIG_PCMCIA_3C589 is not set +# CONFIG_VORTEX is not set +# CONFIG_TYPHOON is not set +CONFIG_NET_VENDOR_ADAPTEC=y +# CONFIG_ADAPTEC_STARFIRE is not set +CONFIG_NET_VENDOR_AGERE=y +# CONFIG_ET131X is not set +CONFIG_NET_VENDOR_ALACRITECH=y +# CONFIG_SLICOSS is not set +CONFIG_NET_VENDOR_ALTEON=y +# CONFIG_ACENIC is not set +# CONFIG_ALTERA_TSE is not set +CONFIG_NET_VENDOR_AMAZON=y +# CONFIG_ENA_ETHERNET is not set +CONFIG_NET_VENDOR_AMD=y +# CONFIG_AMD8111_ETH is not set +# CONFIG_PCNET32 is not set +# CONFIG_PCMCIA_NMCLAN is not set +# CONFIG_AMD_XGBE is not set +CONFIG_NET_VENDOR_AQUANTIA=y +# CONFIG_AQTION is not set +CONFIG_NET_VENDOR_ARC=y +CONFIG_NET_VENDOR_ATHEROS=y +# CONFIG_ATL2 is not set +# CONFIG_ATL1 is not set +# CONFIG_ATL1E is not set +# CONFIG_ATL1C is not set +# CONFIG_ALX is not set +CONFIG_NET_VENDOR_AURORA=y +# CONFIG_AURORA_NB8800 is not set +CONFIG_NET_VENDOR_BROADCOM=y +# CONFIG_B44 is not set +# CONFIG_BCMGENET is not set +# CONFIG_BNX2 is not set +# CONFIG_CNIC is not set +CONFIG_TIGON3=y +CONFIG_TIGON3_HWMON=y +# CONFIG_BNX2X is not set +# CONFIG_SYSTEMPORT is not set +# CONFIG_BNXT is not set +CONFIG_NET_VENDOR_BROCADE=y +# CONFIG_BNA is not set +CONFIG_NET_VENDOR_CADENCE=y +# CONFIG_MACB is not set +CONFIG_NET_VENDOR_CAVIUM=y +# CONFIG_THUNDER_NIC_PF is not set +# CONFIG_THUNDER_NIC_VF is not set +# CONFIG_THUNDER_NIC_BGX is not set +# CONFIG_THUNDER_NIC_RGX is not set +# CONFIG_CAVIUM_PTP is not set +# CONFIG_LIQUIDIO is not set +# CONFIG_LIQUIDIO_VF is not set +CONFIG_NET_VENDOR_CHELSIO=y +# CONFIG_CHELSIO_T1 is not set +# CONFIG_CHELSIO_T3 is not set +# CONFIG_CHELSIO_T4 is not set +# CONFIG_CHELSIO_T4VF is not set +CONFIG_NET_VENDOR_CISCO=y +# CONFIG_ENIC is not set +CONFIG_NET_VENDOR_CORTINA=y +# CONFIG_CX_ECAT is not set +# CONFIG_DNET is not set +CONFIG_NET_VENDOR_DEC=y +CONFIG_NET_TULIP=y +# CONFIG_DE2104X is not set +# CONFIG_TULIP is not set +# CONFIG_DE4X5 is not set +# CONFIG_WINBOND_840 is not set +# CONFIG_DM9102 is not set +# CONFIG_ULI526X is not set +# CONFIG_PCMCIA_XIRCOM is not set +CONFIG_NET_VENDOR_DLINK=y +# CONFIG_DL2K is not set +# CONFIG_SUNDANCE is not set +CONFIG_NET_VENDOR_EMULEX=y +# CONFIG_BE2NET is not set +CONFIG_NET_VENDOR_EZCHIP=y +CONFIG_NET_VENDOR_FUJITSU=y +# CONFIG_PCMCIA_FMVJ18X is not set +CONFIG_NET_VENDOR_GOOGLE=y +# CONFIG_GVE is not set +CONFIG_NET_VENDOR_HUAWEI=y +# CONFIG_HINIC is not set +CONFIG_NET_VENDOR_I825XX=y +CONFIG_NET_VENDOR_INTEL=y +CONFIG_E100=y +CONFIG_E1000=y +CONFIG_E1000E=y +CONFIG_E1000E_HWTS=y +# CONFIG_IGB is not set +# CONFIG_IGBVF is not set +# CONFIG_IXGB is not set +# CONFIG_IXGBE is not set +# CONFIG_IXGBEVF is not set +# CONFIG_I40E is not set +# CONFIG_I40EVF is not set +# CONFIG_ICE is not set +# CONFIG_FM10K is not set +# CONFIG_IGC is not set +# CONFIG_JME is not set +CONFIG_NET_VENDOR_MARVELL=y +# CONFIG_MVMDIO is not set +# CONFIG_SKGE is not set +CONFIG_SKY2=y +# CONFIG_SKY2_DEBUG is not set +CONFIG_NET_VENDOR_MELLANOX=y +# CONFIG_MLX4_EN is not set +# CONFIG_MLX5_CORE is not set +# CONFIG_MLXSW_CORE is not set +# CONFIG_MLXFW is not set +CONFIG_NET_VENDOR_MICREL=y +# CONFIG_KS8842 is not set +# CONFIG_KS8851_MLL is not set +# CONFIG_KSZ884X_PCI is not set +CONFIG_NET_VENDOR_MICROCHIP=y +# CONFIG_LAN743X is not set +CONFIG_NET_VENDOR_MICROSEMI=y +CONFIG_NET_VENDOR_MYRI=y +# CONFIG_MYRI10GE is not set +# CONFIG_FEALNX is not set +CONFIG_NET_VENDOR_NATSEMI=y +# CONFIG_NATSEMI is not set +# CONFIG_NS83820 is not set +CONFIG_NET_VENDOR_NETERION=y +# CONFIG_S2IO is not set +# CONFIG_VXGE is not set +CONFIG_NET_VENDOR_NETRONOME=y +# CONFIG_NFP is not set +CONFIG_NET_VENDOR_NI=y +# CONFIG_NI_XGE_MANAGEMENT_ENET is not set +CONFIG_NET_VENDOR_8390=y +# CONFIG_PCMCIA_AXNET is not set +# CONFIG_NE2K_PCI is not set +# CONFIG_PCMCIA_PCNET is not set +CONFIG_NET_VENDOR_NVIDIA=y +CONFIG_FORCEDETH=y +CONFIG_NET_VENDOR_OKI=y +# CONFIG_ETHOC is not set +CONFIG_NET_VENDOR_PACKET_ENGINES=y +# CONFIG_HAMACHI is not set +# CONFIG_YELLOWFIN is not set +CONFIG_NET_VENDOR_PENSANDO=y +# CONFIG_IONIC is not set +CONFIG_NET_VENDOR_QLOGIC=y +# CONFIG_QLA3XXX is not set +# CONFIG_QLCNIC is not set +# CONFIG_NETXEN_NIC is not set +# CONFIG_QED is not set +CONFIG_NET_VENDOR_QUALCOMM=y +# CONFIG_QCOM_EMAC is not set +# CONFIG_RMNET is not set +CONFIG_NET_VENDOR_RDC=y +# CONFIG_R6040 is not set +CONFIG_NET_VENDOR_REALTEK=y +# CONFIG_8139CP is not set +CONFIG_8139TOO=y +CONFIG_8139TOO_PIO=y +# CONFIG_8139TOO_TUNE_TWISTER is not set +# CONFIG_8139TOO_8129 is not set +# CONFIG_8139_OLD_RX_RESET is not set +CONFIG_R8169=y +CONFIG_NET_VENDOR_RENESAS=y +CONFIG_NET_VENDOR_ROCKER=y +CONFIG_NET_VENDOR_SAMSUNG=y +# CONFIG_SXGBE_ETH is not set +CONFIG_NET_VENDOR_SEEQ=y +CONFIG_NET_VENDOR_SOLARFLARE=y +# CONFIG_SFC is not set +# CONFIG_SFC_FALCON is not set +CONFIG_NET_VENDOR_SILAN=y +# CONFIG_SC92031 is not set +CONFIG_NET_VENDOR_SIS=y +# CONFIG_SIS900 is not set +# CONFIG_SIS190 is not set +CONFIG_NET_VENDOR_SMSC=y +# CONFIG_PCMCIA_SMC91C92 is not set +# CONFIG_EPIC100 is not set +# CONFIG_SMSC911X is not set +# CONFIG_SMSC9420 is not set +CONFIG_NET_VENDOR_SOCIONEXT=y +CONFIG_NET_VENDOR_STMICRO=y +# CONFIG_STMMAC_ETH is not set +CONFIG_NET_VENDOR_SUN=y +# CONFIG_HAPPYMEAL is not set +# CONFIG_SUNGEM is not set +# CONFIG_CASSINI is not set +# CONFIG_NIU is not set +CONFIG_NET_VENDOR_SYNOPSYS=y +# CONFIG_DWC_XLGMAC is not set +CONFIG_NET_VENDOR_TEHUTI=y +# CONFIG_TEHUTI is not set +CONFIG_NET_VENDOR_TI=y +# CONFIG_TI_CPSW_PHY_SEL is not set +# CONFIG_TLAN is not set +CONFIG_NET_VENDOR_VIA=y +# CONFIG_VIA_RHINE is not set +# CONFIG_VIA_VELOCITY is not set +CONFIG_NET_VENDOR_WIZNET=y +# CONFIG_WIZNET_W5100 is not set +# CONFIG_WIZNET_W5300 is not set +CONFIG_NET_VENDOR_XILINX=y +# CONFIG_XILINX_AXI_EMAC is not set +# CONFIG_XILINX_LL_TEMAC is not set +CONFIG_NET_VENDOR_XIRCOM=y +# CONFIG_PCMCIA_XIRC2PS is not set +CONFIG_FDDI=y +# CONFIG_DEFXX is not set +# CONFIG_SKFP is not set +# CONFIG_HIPPI is not set +# CONFIG_NET_SB1000 is not set +CONFIG_MDIO_DEVICE=y +CONFIG_MDIO_BUS=y +# CONFIG_MDIO_BCM_UNIMAC is not set +# CONFIG_MDIO_BITBANG is not set +# CONFIG_MDIO_MSCC_MIIM is not set +# CONFIG_MDIO_THUNDER is not set +CONFIG_PHYLIB=y +# CONFIG_LED_TRIGGER_PHY is not set + +# +# MII PHY device drivers +# +# CONFIG_ADIN_PHY is not set +# CONFIG_AMD_PHY is not set +# CONFIG_AQUANTIA_PHY is not set +# CONFIG_AX88796B_PHY is not set +# CONFIG_BCM7XXX_PHY is not set +# CONFIG_BCM87XX_PHY is not set +# CONFIG_BROADCOM_PHY is not set +# CONFIG_CICADA_PHY is not set +# CONFIG_CORTINA_PHY is not set +# CONFIG_DAVICOM_PHY is not set +# CONFIG_DP83822_PHY is not set +# CONFIG_DP83TC811_PHY is not set +# CONFIG_DP83848_PHY is not set +# CONFIG_DP83867_PHY is not set +# CONFIG_DP83869_PHY is not set +# CONFIG_FIXED_PHY is not set +# CONFIG_ICPLUS_PHY is not set +# CONFIG_INTEL_XWAY_PHY is not set +# CONFIG_LSI_ET1011C_PHY is not set +# CONFIG_LXT_PHY is not set +# CONFIG_MARVELL_PHY is not set +# CONFIG_MARVELL_10G_PHY is not set +# CONFIG_MICREL_PHY is not set +# CONFIG_MICROCHIP_PHY is not set +# CONFIG_MICROCHIP_T1_PHY is not set +# CONFIG_MICROSEMI_PHY is not set +# CONFIG_NATIONAL_PHY is not set +# CONFIG_NXP_TJA11XX_PHY is not set +# CONFIG_QSEMI_PHY is not set +CONFIG_REALTEK_PHY=y +# CONFIG_RENESAS_PHY is not set +# CONFIG_ROCKCHIP_PHY is not set +# CONFIG_SMSC_PHY is not set +# CONFIG_STE10XP is not set +# CONFIG_TERANETICS_PHY is not set +# CONFIG_VITESSE_PHY is not set +# CONFIG_XILINX_GMII2RGMII is not set +# CONFIG_PPP is not set +# CONFIG_SLIP is not set +CONFIG_USB_NET_DRIVERS=y +# CONFIG_USB_CATC is not set +# CONFIG_USB_KAWETH is not set +# CONFIG_USB_PEGASUS is not set +# CONFIG_USB_RTL8150 is not set +# CONFIG_USB_RTL8152 is not set +# CONFIG_USB_LAN78XX is not set +# CONFIG_USB_USBNET is not set +# CONFIG_USB_HSO is not set +# CONFIG_USB_IPHETH is not set +CONFIG_WLAN=y +CONFIG_WLAN_VENDOR_ADMTEK=y +# CONFIG_ADM8211 is not set +CONFIG_WLAN_VENDOR_ATH=y +# CONFIG_ATH_DEBUG is not set +# CONFIG_ATH5K is not set +# CONFIG_ATH5K_PCI is not set +# CONFIG_ATH9K is not set +# CONFIG_ATH9K_HTC is not set +# CONFIG_CARL9170 is not set +# CONFIG_ATH6KL is not set +# CONFIG_AR5523 is not set +# CONFIG_WIL6210 is not set +# CONFIG_ATH10K is not set +# CONFIG_WCN36XX is not set +CONFIG_WLAN_VENDOR_ATMEL=y +# CONFIG_ATMEL is not set +# CONFIG_AT76C50X_USB is not set +CONFIG_WLAN_VENDOR_BROADCOM=y +# CONFIG_B43 is not set +# CONFIG_B43LEGACY is not set +# CONFIG_BRCMSMAC is not set +# CONFIG_BRCMFMAC is not set +CONFIG_WLAN_VENDOR_CISCO=y +# CONFIG_AIRO is not set +# CONFIG_AIRO_CS is not set +CONFIG_WLAN_VENDOR_INTEL=y +# CONFIG_IPW2100 is not set +# CONFIG_IPW2200 is not set +# CONFIG_IWL4965 is not set +# CONFIG_IWL3945 is not set +# CONFIG_IWLWIFI is not set +CONFIG_WLAN_VENDOR_INTERSIL=y +# CONFIG_HOSTAP is not set +# CONFIG_HERMES is not set +# CONFIG_P54_COMMON is not set +# CONFIG_PRISM54 is not set +CONFIG_WLAN_VENDOR_MARVELL=y +# CONFIG_LIBERTAS is not set +# CONFIG_LIBERTAS_THINFIRM is not set +# CONFIG_MWIFIEX is not set +# CONFIG_MWL8K is not set +CONFIG_WLAN_VENDOR_MEDIATEK=y +# CONFIG_MT7601U is not set +# CONFIG_MT76x0U is not set +# CONFIG_MT76x0E is not set +# CONFIG_MT76x2E is not set +# CONFIG_MT76x2U is not set +# CONFIG_MT7603E is not set +# CONFIG_MT7615E is not set +CONFIG_WLAN_VENDOR_RALINK=y +# CONFIG_RT2X00 is not set +CONFIG_WLAN_VENDOR_REALTEK=y +# CONFIG_RTL8180 is not set +# CONFIG_RTL8187 is not set +CONFIG_RTL_CARDS=y +# CONFIG_RTL8192CE is not set +# CONFIG_RTL8192SE is not set +# CONFIG_RTL8192DE is not set +# CONFIG_RTL8723AE is not set +# CONFIG_RTL8723BE is not set +# CONFIG_RTL8188EE is not set +# CONFIG_RTL8192EE is not set +# CONFIG_RTL8821AE is not set +# CONFIG_RTL8192CU is not set +# CONFIG_RTL8XXXU is not set +# CONFIG_RTW88 is not set +CONFIG_WLAN_VENDOR_RSI=y +# CONFIG_RSI_91X is not set +CONFIG_WLAN_VENDOR_ST=y +# CONFIG_CW1200 is not set +CONFIG_WLAN_VENDOR_TI=y +# CONFIG_WL1251 is not set +# CONFIG_WL12XX is not set +# CONFIG_WL18XX is not set +# CONFIG_WLCORE is not set +CONFIG_WLAN_VENDOR_ZYDAS=y +# CONFIG_USB_ZD1201 is not set +# CONFIG_ZD1211RW is not set +CONFIG_WLAN_VENDOR_QUANTENNA=y +# CONFIG_QTNFMAC_PCIE is not set +# CONFIG_PCMCIA_RAYCS is not set +# CONFIG_PCMCIA_WL3501 is not set +# CONFIG_MAC80211_HWSIM is not set +# CONFIG_USB_NET_RNDIS_WLAN is not set +# CONFIG_VIRT_WIFI is not set + +# +# Enable WiMAX (Networking options) to see the WiMAX drivers +# +# CONFIG_WAN is not set +# CONFIG_VMXNET3 is not set +# CONFIG_FUJITSU_ES is not set +# CONFIG_NETDEVSIM is not set +# CONFIG_NET_FAILOVER is not set +# CONFIG_ISDN is not set +# CONFIG_NVM is not set + +# +# Input device support +# +CONFIG_INPUT=y +CONFIG_INPUT_LEDS=y +CONFIG_INPUT_FF_MEMLESS=y +CONFIG_INPUT_POLLDEV=y +CONFIG_INPUT_SPARSEKMAP=y +# CONFIG_INPUT_MATRIXKMAP is not set + +# +# Userland interfaces +# +# CONFIG_INPUT_MOUSEDEV is not set +# CONFIG_INPUT_JOYDEV is not set +CONFIG_INPUT_EVDEV=y +# CONFIG_INPUT_EVBUG is not set + +# +# Input Device Drivers +# +CONFIG_INPUT_KEYBOARD=y +# CONFIG_KEYBOARD_ADP5588 is not set +# CONFIG_KEYBOARD_ADP5589 is not set +CONFIG_KEYBOARD_ATKBD=y +# CONFIG_KEYBOARD_QT1050 is not set +# CONFIG_KEYBOARD_QT1070 is not set +# CONFIG_KEYBOARD_QT2160 is not set +# CONFIG_KEYBOARD_DLINK_DIR685 is not set +# CONFIG_KEYBOARD_LKKBD is not set +# CONFIG_KEYBOARD_TCA6416 is not set +# CONFIG_KEYBOARD_TCA8418 is not set +# CONFIG_KEYBOARD_LM8323 is not set +# CONFIG_KEYBOARD_LM8333 is not set +# CONFIG_KEYBOARD_MAX7359 is not set +# CONFIG_KEYBOARD_MCS is not set +# CONFIG_KEYBOARD_MPR121 is not set +# CONFIG_KEYBOARD_NEWTON is not set +# CONFIG_KEYBOARD_OPENCORES is not set +# CONFIG_KEYBOARD_SAMSUNG is not set +# CONFIG_KEYBOARD_STOWAWAY is not set +# CONFIG_KEYBOARD_SUNKBD is not set +# CONFIG_KEYBOARD_TM2_TOUCHKEY is not set +# CONFIG_KEYBOARD_XTKBD is not set +CONFIG_INPUT_MOUSE=y +CONFIG_MOUSE_PS2=y +CONFIG_MOUSE_PS2_ALPS=y +CONFIG_MOUSE_PS2_BYD=y +CONFIG_MOUSE_PS2_LOGIPS2PP=y +CONFIG_MOUSE_PS2_SYNAPTICS=y +CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS=y +CONFIG_MOUSE_PS2_CYPRESS=y +CONFIG_MOUSE_PS2_LIFEBOOK=y +CONFIG_MOUSE_PS2_TRACKPOINT=y +# CONFIG_MOUSE_PS2_ELANTECH is not set +# CONFIG_MOUSE_PS2_SENTELIC is not set +# CONFIG_MOUSE_PS2_TOUCHKIT is not set +CONFIG_MOUSE_PS2_FOCALTECH=y +CONFIG_MOUSE_PS2_SMBUS=y +# CONFIG_MOUSE_SERIAL is not set +# CONFIG_MOUSE_APPLETOUCH is not set +# CONFIG_MOUSE_BCM5974 is not set +# CONFIG_MOUSE_CYAPA is not set +# CONFIG_MOUSE_ELAN_I2C is not set +# CONFIG_MOUSE_VSXXXAA is not set +# CONFIG_MOUSE_SYNAPTICS_I2C is not set +# CONFIG_MOUSE_SYNAPTICS_USB is not set +CONFIG_INPUT_JOYSTICK=y +# CONFIG_JOYSTICK_ANALOG is not set +# CONFIG_JOYSTICK_A3D is not set +# CONFIG_JOYSTICK_ADI is not set +# CONFIG_JOYSTICK_COBRA is not set +# CONFIG_JOYSTICK_GF2K is not set +# CONFIG_JOYSTICK_GRIP is not set +# CONFIG_JOYSTICK_GRIP_MP is not set +# CONFIG_JOYSTICK_GUILLEMOT is not set +# CONFIG_JOYSTICK_INTERACT is not set +# CONFIG_JOYSTICK_SIDEWINDER is not set +# CONFIG_JOYSTICK_TMDC is not set +# CONFIG_JOYSTICK_IFORCE is not set +# CONFIG_JOYSTICK_WARRIOR is not set +# CONFIG_JOYSTICK_MAGELLAN is not set +# CONFIG_JOYSTICK_SPACEORB is not set +# CONFIG_JOYSTICK_SPACEBALL is not set +# CONFIG_JOYSTICK_STINGER is not set +# CONFIG_JOYSTICK_TWIDJOY is not set +# CONFIG_JOYSTICK_ZHENHUA is not set +# CONFIG_JOYSTICK_AS5011 is not set +# CONFIG_JOYSTICK_JOYDUMP is not set +# CONFIG_JOYSTICK_XPAD is not set +# CONFIG_JOYSTICK_PXRC is not set +# CONFIG_JOYSTICK_FSIA6B is not set +CONFIG_INPUT_TABLET=y +# CONFIG_TABLET_USB_ACECAD is not set +# CONFIG_TABLET_USB_AIPTEK is not set +# CONFIG_TABLET_USB_GTCO is not set +# CONFIG_TABLET_USB_HANWANG is not set +# CONFIG_TABLET_USB_KBTAB is not set +# CONFIG_TABLET_USB_PEGASUS is not set +# CONFIG_TABLET_SERIAL_WACOM4 is not set +CONFIG_INPUT_TOUCHSCREEN=y +CONFIG_TOUCHSCREEN_PROPERTIES=y +# CONFIG_TOUCHSCREEN_AD7879 is not set +# CONFIG_TOUCHSCREEN_ATMEL_MXT is not set +# CONFIG_TOUCHSCREEN_BU21013 is not set +# CONFIG_TOUCHSCREEN_BU21029 is not set +# CONFIG_TOUCHSCREEN_CHIPONE_ICN8505 is not set +# CONFIG_TOUCHSCREEN_CYTTSP_CORE is not set +# CONFIG_TOUCHSCREEN_CYTTSP4_CORE is not set +# CONFIG_TOUCHSCREEN_DYNAPRO is not set +# CONFIG_TOUCHSCREEN_HAMPSHIRE is not set +# CONFIG_TOUCHSCREEN_EETI is not set +# CONFIG_TOUCHSCREEN_EGALAX_SERIAL is not set +# CONFIG_TOUCHSCREEN_EXC3000 is not set +# CONFIG_TOUCHSCREEN_FUJITSU is not set +# CONFIG_TOUCHSCREEN_HIDEEP is not set +# CONFIG_TOUCHSCREEN_ILI210X is not set +# CONFIG_TOUCHSCREEN_S6SY761 is not set +# CONFIG_TOUCHSCREEN_GUNZE is not set +# CONFIG_TOUCHSCREEN_EKTF2127 is not set +# CONFIG_TOUCHSCREEN_ELAN is not set +# CONFIG_TOUCHSCREEN_ELO is not set +# CONFIG_TOUCHSCREEN_WACOM_W8001 is not set +# CONFIG_TOUCHSCREEN_WACOM_I2C is not set +# CONFIG_TOUCHSCREEN_MAX11801 is not set +# CONFIG_TOUCHSCREEN_MCS5000 is not set +# CONFIG_TOUCHSCREEN_MMS114 is not set +# CONFIG_TOUCHSCREEN_MELFAS_MIP4 is not set +# CONFIG_TOUCHSCREEN_MTOUCH is not set +# CONFIG_TOUCHSCREEN_INEXIO is not set +# CONFIG_TOUCHSCREEN_MK712 is not set +# CONFIG_TOUCHSCREEN_PENMOUNT is not set +# CONFIG_TOUCHSCREEN_EDT_FT5X06 is not set +# CONFIG_TOUCHSCREEN_TOUCHRIGHT is not set +# CONFIG_TOUCHSCREEN_TOUCHWIN is not set +# CONFIG_TOUCHSCREEN_PIXCIR is not set +# CONFIG_TOUCHSCREEN_WDT87XX_I2C is not set +# CONFIG_TOUCHSCREEN_USB_COMPOSITE is not set +# CONFIG_TOUCHSCREEN_TOUCHIT213 is not set +# CONFIG_TOUCHSCREEN_TSC_SERIO is not set +# CONFIG_TOUCHSCREEN_TSC2004 is not set +# CONFIG_TOUCHSCREEN_TSC2007 is not set +# CONFIG_TOUCHSCREEN_SILEAD is not set +# CONFIG_TOUCHSCREEN_ST1232 is not set +# CONFIG_TOUCHSCREEN_STMFTS is not set +# CONFIG_TOUCHSCREEN_SX8654 is not set +# CONFIG_TOUCHSCREEN_TPS6507X is not set +# CONFIG_TOUCHSCREEN_ZET6223 is not set +# CONFIG_TOUCHSCREEN_ROHM_BU21023 is not set +# CONFIG_TOUCHSCREEN_IQS5XX is not set +CONFIG_INPUT_MISC=y +# CONFIG_INPUT_AD714X is not set +# CONFIG_INPUT_BMA150 is not set +# CONFIG_INPUT_E3X0_BUTTON is not set +# CONFIG_INPUT_MSM_VIBRATOR is not set +# CONFIG_INPUT_PCSPKR is not set +# CONFIG_INPUT_MMA8450 is not set +# CONFIG_INPUT_APANEL is not set +# CONFIG_INPUT_ATLAS_BTNS is not set +# CONFIG_INPUT_ATI_REMOTE2 is not set +# CONFIG_INPUT_KEYSPAN_REMOTE is not set +# CONFIG_INPUT_KXTJ9 is not set +# CONFIG_INPUT_POWERMATE is not set +# CONFIG_INPUT_YEALINK is not set +# CONFIG_INPUT_CM109 is not set +# CONFIG_INPUT_UINPUT is not set +# CONFIG_INPUT_PCF8574 is not set +# CONFIG_INPUT_ADXL34X is not set +# CONFIG_INPUT_IMS_PCU is not set +# CONFIG_INPUT_CMA3000 is not set +# CONFIG_INPUT_IDEAPAD_SLIDEBAR is not set +# CONFIG_INPUT_DRV2665_HAPTICS is not set +# CONFIG_INPUT_DRV2667_HAPTICS is not set +# CONFIG_RMI4_CORE is not set + +# +# Hardware I/O ports +# +CONFIG_SERIO=y +CONFIG_ARCH_MIGHT_HAVE_PC_SERIO=y +CONFIG_SERIO_I8042=y +CONFIG_SERIO_SERPORT=y +# CONFIG_SERIO_CT82C710 is not set +# CONFIG_SERIO_PCIPS2 is not set +CONFIG_SERIO_LIBPS2=y +# CONFIG_SERIO_RAW is not set +# CONFIG_SERIO_ALTERA_PS2 is not set +# CONFIG_SERIO_PS2MULT is not set +# CONFIG_SERIO_ARC_PS2 is not set +# CONFIG_USERIO is not set +# CONFIG_GAMEPORT is not set +# end of Hardware I/O ports +# end of Input device support + +# +# Character devices +# +CONFIG_TTY=y +CONFIG_VT=y +CONFIG_CONSOLE_TRANSLATIONS=y +CONFIG_VT_CONSOLE=y +CONFIG_VT_CONSOLE_SLEEP=y +CONFIG_HW_CONSOLE=y +CONFIG_VT_HW_CONSOLE_BINDING=y +CONFIG_UNIX98_PTYS=y +# CONFIG_LEGACY_PTYS is not set +CONFIG_SERIAL_NONSTANDARD=y +# CONFIG_ROCKETPORT is not set +# CONFIG_CYCLADES is not set +# CONFIG_MOXA_INTELLIO is not set +# CONFIG_MOXA_SMARTIO is not set +# CONFIG_SYNCLINK is not set +# CONFIG_SYNCLINKMP is not set +# CONFIG_SYNCLINK_GT is not set +# CONFIG_NOZOMI is not set +# CONFIG_ISI is not set +# CONFIG_N_HDLC is not set +# CONFIG_N_GSM is not set +# CONFIG_TRACE_SINK is not set +# CONFIG_NULL_TTY is not set +CONFIG_LDISC_AUTOLOAD=y +CONFIG_DEVMEM=y +# CONFIG_DEVKMEM is not set + +# +# Serial drivers +# +CONFIG_SERIAL_EARLYCON=y +CONFIG_SERIAL_8250=y +CONFIG_SERIAL_8250_DEPRECATED_OPTIONS=y +CONFIG_SERIAL_8250_PNP=y +# CONFIG_SERIAL_8250_FINTEK is not set +CONFIG_SERIAL_8250_CONSOLE=y +CONFIG_SERIAL_8250_DMA=y +CONFIG_SERIAL_8250_PCI=y +CONFIG_SERIAL_8250_EXAR=y +# CONFIG_SERIAL_8250_CS is not set +CONFIG_SERIAL_8250_NR_UARTS=32 +CONFIG_SERIAL_8250_RUNTIME_UARTS=4 +CONFIG_SERIAL_8250_EXTENDED=y +CONFIG_SERIAL_8250_MANY_PORTS=y +CONFIG_SERIAL_8250_SHARE_IRQ=y +CONFIG_SERIAL_8250_DETECT_IRQ=y +CONFIG_SERIAL_8250_RSA=y +CONFIG_SERIAL_8250_DWLIB=y +# CONFIG_SERIAL_8250_DW is not set +# CONFIG_SERIAL_8250_RT288X is not set +CONFIG_SERIAL_8250_LPSS=y +CONFIG_SERIAL_8250_MID=y + +# +# Non-8250 serial port support +# +# CONFIG_SERIAL_UARTLITE is not set +CONFIG_SERIAL_CORE=y +CONFIG_SERIAL_CORE_CONSOLE=y +# CONFIG_SERIAL_JSM is not set +# CONFIG_SERIAL_SCCNXP is not set +# CONFIG_SERIAL_SC16IS7XX is not set +# CONFIG_SERIAL_ALTERA_JTAGUART is not set +# CONFIG_SERIAL_ALTERA_UART is not set +# CONFIG_SERIAL_ARC is not set +# CONFIG_SERIAL_RP2 is not set +# CONFIG_SERIAL_FSL_LPUART is not set +# CONFIG_SERIAL_FSL_LINFLEXUART is not set +# end of Serial drivers + +# CONFIG_SERIAL_DEV_BUS is not set +# CONFIG_IPMI_HANDLER is not set +CONFIG_HW_RANDOM=y +# CONFIG_HW_RANDOM_TIMERIOMEM is not set +# CONFIG_HW_RANDOM_INTEL is not set +# CONFIG_HW_RANDOM_AMD is not set +CONFIG_HW_RANDOM_VIA=y +CONFIG_NVRAM=y +# CONFIG_APPLICOM is not set + +# +# PCMCIA character devices +# +# CONFIG_SYNCLINK_CS is not set +# CONFIG_CARDMAN_4000 is not set +# CONFIG_CARDMAN_4040 is not set +# CONFIG_SCR24X is not set +# CONFIG_IPWIRELESS is not set +# end of PCMCIA character devices + +# CONFIG_MWAVE is not set +# CONFIG_RAW_DRIVER is not set +CONFIG_HPET=y +# CONFIG_HPET_MMAP is not set +# CONFIG_HANGCHECK_TIMER is not set +# CONFIG_TCG_TPM is not set +# CONFIG_TELCLOCK is not set +CONFIG_DEVPORT=y +# CONFIG_XILLYBUS is not set +# end of Character devices + +# CONFIG_RANDOM_TRUST_CPU is not set +# CONFIG_RANDOM_TRUST_BOOTLOADER is not set + +# +# I2C support +# +CONFIG_I2C=y +CONFIG_ACPI_I2C_OPREGION=y +CONFIG_I2C_BOARDINFO=y +CONFIG_I2C_COMPAT=y +# CONFIG_I2C_CHARDEV is not set +# CONFIG_I2C_MUX is not set +CONFIG_I2C_HELPER_AUTO=y +CONFIG_I2C_SMBUS=y +CONFIG_I2C_ALGOBIT=y + +# +# I2C Hardware Bus support +# + +# +# PC SMBus host controller drivers +# +# CONFIG_I2C_ALI1535 is not set +# CONFIG_I2C_ALI1563 is not set +# CONFIG_I2C_ALI15X3 is not set +# CONFIG_I2C_AMD756 is not set +# CONFIG_I2C_AMD8111 is not set +# CONFIG_I2C_AMD_MP2 is not set +CONFIG_I2C_I801=y +# CONFIG_I2C_ISCH is not set +# CONFIG_I2C_ISMT is not set +# CONFIG_I2C_PIIX4 is not set +# CONFIG_I2C_NFORCE2 is not set +# CONFIG_I2C_NVIDIA_GPU is not set +# CONFIG_I2C_SIS5595 is not set +# CONFIG_I2C_SIS630 is not set +# CONFIG_I2C_SIS96X is not set +# CONFIG_I2C_VIA is not set +# CONFIG_I2C_VIAPRO is not set + +# +# ACPI drivers +# +# CONFIG_I2C_SCMI is not set + +# +# I2C system bus drivers (mostly embedded / system-on-chip) +# +# CONFIG_I2C_DESIGNWARE_PLATFORM is not set +# CONFIG_I2C_DESIGNWARE_PCI is not set +# CONFIG_I2C_EMEV2 is not set +# CONFIG_I2C_OCORES is not set +# CONFIG_I2C_PCA_PLATFORM is not set +# CONFIG_I2C_SIMTEC is not set +# CONFIG_I2C_XILINX is not set + +# +# External I2C/SMBus adapter drivers +# +# CONFIG_I2C_DIOLAN_U2C is not set +# CONFIG_I2C_PARPORT_LIGHT is not set +# CONFIG_I2C_ROBOTFUZZ_OSIF is not set +# CONFIG_I2C_TAOS_EVM is not set +# CONFIG_I2C_TINY_USB is not set + +# +# Other I2C/SMBus bus drivers +# +# CONFIG_I2C_MLXCPLD is not set +# end of I2C Hardware Bus support + +# CONFIG_I2C_STUB is not set +# CONFIG_I2C_SLAVE is not set +# CONFIG_I2C_DEBUG_CORE is not set +# CONFIG_I2C_DEBUG_ALGO is not set +# CONFIG_I2C_DEBUG_BUS is not set +# end of I2C support + +# CONFIG_I3C is not set +# CONFIG_SPI is not set +# CONFIG_SPMI is not set +# CONFIG_HSI is not set +CONFIG_PPS=y +# CONFIG_PPS_DEBUG is not set + +# +# PPS clients support +# +# CONFIG_PPS_CLIENT_KTIMER is not set +# CONFIG_PPS_CLIENT_LDISC is not set +# CONFIG_PPS_CLIENT_GPIO is not set + +# +# PPS generators support +# + +# +# PTP clock support +# +CONFIG_PTP_1588_CLOCK=y + +# +# Enable PHYLIB and NETWORK_PHY_TIMESTAMPING to see the additional clocks. +# +# CONFIG_PTP_1588_CLOCK_IDTCM is not set +# end of PTP clock support + +# CONFIG_PINCTRL is not set +# CONFIG_GPIOLIB is not set +# CONFIG_W1 is not set +# CONFIG_POWER_AVS is not set +# CONFIG_POWER_RESET is not set +CONFIG_POWER_SUPPLY=y +# CONFIG_POWER_SUPPLY_DEBUG is not set +CONFIG_POWER_SUPPLY_HWMON=y +# CONFIG_PDA_POWER is not set +# CONFIG_TEST_POWER is not set +# CONFIG_CHARGER_ADP5061 is not set +# CONFIG_BATTERY_DS2780 is not set +# CONFIG_BATTERY_DS2781 is not set +# CONFIG_BATTERY_DS2782 is not set +# CONFIG_BATTERY_SBS is not set +# CONFIG_CHARGER_SBS is not set +# CONFIG_BATTERY_BQ27XXX is not set +# CONFIG_BATTERY_MAX17040 is not set +# CONFIG_BATTERY_MAX17042 is not set +# CONFIG_CHARGER_MAX8903 is not set +# CONFIG_CHARGER_LP8727 is not set +# CONFIG_CHARGER_BQ2415X is not set +# CONFIG_CHARGER_SMB347 is not set +# CONFIG_BATTERY_GAUGE_LTC2941 is not set +CONFIG_HWMON=y +# CONFIG_HWMON_DEBUG_CHIP is not set + +# +# Native drivers +# +# CONFIG_SENSORS_ABITUGURU is not set +# CONFIG_SENSORS_ABITUGURU3 is not set +# CONFIG_SENSORS_AD7414 is not set +# CONFIG_SENSORS_AD7418 is not set +# CONFIG_SENSORS_ADM1021 is not set +# CONFIG_SENSORS_ADM1025 is not set +# CONFIG_SENSORS_ADM1026 is not set +# CONFIG_SENSORS_ADM1029 is not set +# CONFIG_SENSORS_ADM1031 is not set +# CONFIG_SENSORS_ADM9240 is not set +# CONFIG_SENSORS_ADT7410 is not set +# CONFIG_SENSORS_ADT7411 is not set +# CONFIG_SENSORS_ADT7462 is not set +# CONFIG_SENSORS_ADT7470 is not set +# CONFIG_SENSORS_ADT7475 is not set +# CONFIG_SENSORS_AS370 is not set +# CONFIG_SENSORS_ASC7621 is not set +# CONFIG_SENSORS_K8TEMP is not set +# CONFIG_SENSORS_K10TEMP is not set +# CONFIG_SENSORS_FAM15H_POWER is not set +# CONFIG_SENSORS_APPLESMC is not set +# CONFIG_SENSORS_ASB100 is not set +# CONFIG_SENSORS_ASPEED is not set +# CONFIG_SENSORS_ATXP1 is not set +# CONFIG_SENSORS_DS620 is not set +# CONFIG_SENSORS_DS1621 is not set +# CONFIG_SENSORS_DELL_SMM is not set +# CONFIG_SENSORS_I5K_AMB is not set +# CONFIG_SENSORS_F71805F is not set +# CONFIG_SENSORS_F71882FG is not set +# CONFIG_SENSORS_F75375S is not set +# CONFIG_SENSORS_FSCHMD is not set +# CONFIG_SENSORS_FTSTEUTATES is not set +# CONFIG_SENSORS_GL518SM is not set +# CONFIG_SENSORS_GL520SM is not set +# CONFIG_SENSORS_G760A is not set +# CONFIG_SENSORS_G762 is not set +# CONFIG_SENSORS_HIH6130 is not set +# CONFIG_SENSORS_I5500 is not set +# CONFIG_SENSORS_CORETEMP is not set +# CONFIG_SENSORS_IT87 is not set +# CONFIG_SENSORS_JC42 is not set +# CONFIG_SENSORS_POWR1220 is not set +# CONFIG_SENSORS_LINEAGE is not set +# CONFIG_SENSORS_LTC2945 is not set +# CONFIG_SENSORS_LTC2947_I2C is not set +# CONFIG_SENSORS_LTC2990 is not set +# CONFIG_SENSORS_LTC4151 is not set +# CONFIG_SENSORS_LTC4215 is not set +# CONFIG_SENSORS_LTC4222 is not set +# CONFIG_SENSORS_LTC4245 is not set +# CONFIG_SENSORS_LTC4260 is not set +# CONFIG_SENSORS_LTC4261 is not set +# CONFIG_SENSORS_MAX16065 is not set +# CONFIG_SENSORS_MAX1619 is not set +# CONFIG_SENSORS_MAX1668 is not set +# CONFIG_SENSORS_MAX197 is not set +# CONFIG_SENSORS_MAX6621 is not set +# CONFIG_SENSORS_MAX6639 is not set +# CONFIG_SENSORS_MAX6642 is not set +# CONFIG_SENSORS_MAX6650 is not set +# CONFIG_SENSORS_MAX6697 is not set +# CONFIG_SENSORS_MAX31790 is not set +# CONFIG_SENSORS_MCP3021 is not set +# CONFIG_SENSORS_TC654 is not set +# CONFIG_SENSORS_LM63 is not set +# CONFIG_SENSORS_LM73 is not set +# CONFIG_SENSORS_LM75 is not set +# CONFIG_SENSORS_LM77 is not set +# CONFIG_SENSORS_LM78 is not set +# CONFIG_SENSORS_LM80 is not set +# CONFIG_SENSORS_LM83 is not set +# CONFIG_SENSORS_LM85 is not set +# CONFIG_SENSORS_LM87 is not set +# CONFIG_SENSORS_LM90 is not set +# CONFIG_SENSORS_LM92 is not set +# CONFIG_SENSORS_LM93 is not set +# CONFIG_SENSORS_LM95234 is not set +# CONFIG_SENSORS_LM95241 is not set +# CONFIG_SENSORS_LM95245 is not set +# CONFIG_SENSORS_PC87360 is not set +# CONFIG_SENSORS_PC87427 is not set +# CONFIG_SENSORS_NTC_THERMISTOR is not set +# CONFIG_SENSORS_NCT6683 is not set +# CONFIG_SENSORS_NCT6775 is not set +# CONFIG_SENSORS_NCT7802 is not set +# CONFIG_SENSORS_NCT7904 is not set +# CONFIG_SENSORS_NPCM7XX is not set +# CONFIG_SENSORS_PCF8591 is not set +# CONFIG_PMBUS is not set +# CONFIG_SENSORS_SHT21 is not set +# CONFIG_SENSORS_SHT3x is not set +# CONFIG_SENSORS_SHTC1 is not set +# CONFIG_SENSORS_SIS5595 is not set +# CONFIG_SENSORS_DME1737 is not set +# CONFIG_SENSORS_EMC1403 is not set +# CONFIG_SENSORS_EMC2103 is not set +# CONFIG_SENSORS_EMC6W201 is not set +# CONFIG_SENSORS_SMSC47M1 is not set +# CONFIG_SENSORS_SMSC47M192 is not set +# CONFIG_SENSORS_SMSC47B397 is not set +# CONFIG_SENSORS_SCH5627 is not set +# CONFIG_SENSORS_SCH5636 is not set +# CONFIG_SENSORS_STTS751 is not set +# CONFIG_SENSORS_SMM665 is not set +# CONFIG_SENSORS_ADC128D818 is not set +# CONFIG_SENSORS_ADS7828 is not set +# CONFIG_SENSORS_AMC6821 is not set +# CONFIG_SENSORS_INA209 is not set +# CONFIG_SENSORS_INA2XX is not set +# CONFIG_SENSORS_INA3221 is not set +# CONFIG_SENSORS_TC74 is not set +# CONFIG_SENSORS_THMC50 is not set +# CONFIG_SENSORS_TMP102 is not set +# CONFIG_SENSORS_TMP103 is not set +# CONFIG_SENSORS_TMP108 is not set +# CONFIG_SENSORS_TMP401 is not set +# CONFIG_SENSORS_TMP421 is not set +# CONFIG_SENSORS_TMP513 is not set +# CONFIG_SENSORS_VIA_CPUTEMP is not set +# CONFIG_SENSORS_VIA686A is not set +# CONFIG_SENSORS_VT1211 is not set +# CONFIG_SENSORS_VT8231 is not set +# CONFIG_SENSORS_W83773G is not set +# CONFIG_SENSORS_W83781D is not set +# CONFIG_SENSORS_W83791D is not set +# CONFIG_SENSORS_W83792D is not set +# CONFIG_SENSORS_W83793 is not set +# CONFIG_SENSORS_W83795 is not set +# CONFIG_SENSORS_W83L785TS is not set +# CONFIG_SENSORS_W83L786NG is not set +# CONFIG_SENSORS_W83627HF is not set +# CONFIG_SENSORS_W83627EHF is not set +# CONFIG_SENSORS_XGENE is not set + +# +# ACPI drivers +# +# CONFIG_SENSORS_ACPI_POWER is not set +# CONFIG_SENSORS_ATK0110 is not set +CONFIG_THERMAL=y +# CONFIG_THERMAL_STATISTICS is not set +CONFIG_THERMAL_EMERGENCY_POWEROFF_DELAY_MS=0 +CONFIG_THERMAL_HWMON=y +CONFIG_THERMAL_WRITABLE_TRIPS=y +CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE=y +# CONFIG_THERMAL_DEFAULT_GOV_FAIR_SHARE is not set +# CONFIG_THERMAL_DEFAULT_GOV_USER_SPACE is not set +# CONFIG_THERMAL_GOV_FAIR_SHARE is not set +CONFIG_THERMAL_GOV_STEP_WISE=y +# CONFIG_THERMAL_GOV_BANG_BANG is not set +CONFIG_THERMAL_GOV_USER_SPACE=y +# CONFIG_THERMAL_EMULATION is not set + +# +# Intel thermal drivers +# +# CONFIG_INTEL_POWERCLAMP is not set +CONFIG_X86_PKG_TEMP_THERMAL=m +# CONFIG_INTEL_SOC_DTS_THERMAL is not set + +# +# ACPI INT340X thermal drivers +# +# CONFIG_INT340X_THERMAL is not set +# end of ACPI INT340X thermal drivers + +# CONFIG_INTEL_PCH_THERMAL is not set +# end of Intel thermal drivers + +CONFIG_WATCHDOG=y +# CONFIG_WATCHDOG_CORE is not set +# CONFIG_WATCHDOG_NOWAYOUT is not set +CONFIG_WATCHDOG_HANDLE_BOOT_ENABLED=y +CONFIG_WATCHDOG_OPEN_TIMEOUT=0 +# CONFIG_WATCHDOG_SYSFS is not set + +# +# Watchdog Pretimeout Governors +# + +# +# Watchdog Device Drivers +# +# CONFIG_SOFT_WATCHDOG is not set +# CONFIG_WDAT_WDT is not set +# CONFIG_XILINX_WATCHDOG is not set +# CONFIG_ZIIRAVE_WATCHDOG is not set +# CONFIG_CADENCE_WATCHDOG is not set +# CONFIG_DW_WATCHDOG is not set +# CONFIG_MAX63XX_WATCHDOG is not set +# CONFIG_ACQUIRE_WDT is not set +# CONFIG_ADVANTECH_WDT is not set +# CONFIG_ALIM1535_WDT is not set +# CONFIG_ALIM7101_WDT is not set +# CONFIG_EBC_C384_WDT is not set +# CONFIG_F71808E_WDT is not set +# CONFIG_SP5100_TCO is not set +# CONFIG_SBC_FITPC2_WATCHDOG is not set +# CONFIG_EUROTECH_WDT is not set +# CONFIG_IB700_WDT is not set +# CONFIG_IBMASR is not set +# CONFIG_WAFER_WDT is not set +# CONFIG_I6300ESB_WDT is not set +# CONFIG_IE6XX_WDT is not set +# CONFIG_ITCO_WDT is not set +# CONFIG_IT8712F_WDT is not set +# CONFIG_IT87_WDT is not set +# CONFIG_HP_WATCHDOG is not set +# CONFIG_SC1200_WDT is not set +# CONFIG_PC87413_WDT is not set +# CONFIG_NV_TCO is not set +# CONFIG_60XX_WDT is not set +# CONFIG_CPU5_WDT is not set +# CONFIG_SMSC_SCH311X_WDT is not set +# CONFIG_SMSC37B787_WDT is not set +# CONFIG_TQMX86_WDT is not set +# CONFIG_VIA_WDT is not set +# CONFIG_W83627HF_WDT is not set +# CONFIG_W83877F_WDT is not set +# CONFIG_W83977F_WDT is not set +# CONFIG_MACHZ_WDT is not set +# CONFIG_SBC_EPX_C3_WATCHDOG is not set +# CONFIG_NI903X_WDT is not set +# CONFIG_NIC7018_WDT is not set + +# +# PCI-based Watchdog Cards +# +# CONFIG_PCIPCWATCHDOG is not set +# CONFIG_WDTPCI is not set + +# +# USB-based Watchdog Cards +# +# CONFIG_USBPCWATCHDOG is not set +CONFIG_SSB_POSSIBLE=y +# CONFIG_SSB is not set +CONFIG_BCMA_POSSIBLE=y +# CONFIG_BCMA is not set + +# +# Multifunction device drivers +# +# CONFIG_MFD_AS3711 is not set +# CONFIG_PMIC_ADP5520 is not set +# CONFIG_MFD_BCM590XX is not set +# CONFIG_MFD_BD9571MWV is not set +# CONFIG_MFD_AXP20X_I2C is not set +# CONFIG_MFD_MADERA is not set +# CONFIG_PMIC_DA903X is not set +# CONFIG_MFD_DA9052_I2C is not set +# CONFIG_MFD_DA9055 is not set +# CONFIG_MFD_DA9062 is not set +# CONFIG_MFD_DA9063 is not set +# CONFIG_MFD_DA9150 is not set +# CONFIG_MFD_DLN2 is not set +# CONFIG_MFD_MC13XXX_I2C is not set +# CONFIG_HTC_PASIC3 is not set +# CONFIG_MFD_INTEL_QUARK_I2C_GPIO is not set +# CONFIG_LPC_ICH is not set +# CONFIG_LPC_SCH is not set +# CONFIG_MFD_INTEL_LPSS_ACPI is not set +# CONFIG_MFD_INTEL_LPSS_PCI is not set +# CONFIG_MFD_JANZ_CMODIO is not set +# CONFIG_MFD_KEMPLD is not set +# CONFIG_MFD_88PM800 is not set +# CONFIG_MFD_88PM805 is not set +# CONFIG_MFD_88PM860X is not set +# CONFIG_MFD_MAX14577 is not set +# CONFIG_MFD_MAX77693 is not set +# CONFIG_MFD_MAX77843 is not set +# CONFIG_MFD_MAX8907 is not set +# CONFIG_MFD_MAX8925 is not set +# CONFIG_MFD_MAX8997 is not set +# CONFIG_MFD_MAX8998 is not set +# CONFIG_MFD_MT6397 is not set +# CONFIG_MFD_MENF21BMC is not set +# CONFIG_MFD_VIPERBOARD is not set +# CONFIG_MFD_RETU is not set +# CONFIG_MFD_PCF50633 is not set +# CONFIG_MFD_RDC321X is not set +# CONFIG_MFD_RT5033 is not set +# CONFIG_MFD_RC5T583 is not set +# CONFIG_MFD_SEC_CORE is not set +# CONFIG_MFD_SI476X_CORE is not set +# CONFIG_MFD_SM501 is not set +# CONFIG_MFD_SKY81452 is not set +# CONFIG_MFD_SMSC is not set +# CONFIG_ABX500_CORE is not set +# CONFIG_MFD_SYSCON is not set +# CONFIG_MFD_TI_AM335X_TSCADC is not set +# CONFIG_MFD_LP3943 is not set +# CONFIG_MFD_LP8788 is not set +# CONFIG_MFD_TI_LMU is not set +# CONFIG_MFD_PALMAS is not set +# CONFIG_TPS6105X is not set +# CONFIG_TPS6507X is not set +# CONFIG_MFD_TPS65086 is not set +# CONFIG_MFD_TPS65090 is not set +# CONFIG_MFD_TI_LP873X is not set +# CONFIG_MFD_TPS6586X is not set +# CONFIG_MFD_TPS65912_I2C is not set +# CONFIG_MFD_TPS80031 is not set +# CONFIG_TWL4030_CORE is not set +# CONFIG_TWL6040_CORE is not set +# CONFIG_MFD_WL1273_CORE is not set +# CONFIG_MFD_LM3533 is not set +# CONFIG_MFD_TQMX86 is not set +# CONFIG_MFD_VX855 is not set +# CONFIG_MFD_ARIZONA_I2C is not set +# CONFIG_MFD_WM8400 is not set +# CONFIG_MFD_WM831X_I2C is not set +# CONFIG_MFD_WM8350_I2C is not set +# CONFIG_MFD_WM8994 is not set +# end of Multifunction device drivers + +# CONFIG_REGULATOR is not set +# CONFIG_RC_CORE is not set +# CONFIG_MEDIA_SUPPORT is not set + +# +# Graphics support +# +CONFIG_AGP=y +CONFIG_AGP_AMD64=y +CONFIG_AGP_INTEL=y +# CONFIG_AGP_SIS is not set +# CONFIG_AGP_VIA is not set +CONFIG_INTEL_GTT=y +CONFIG_VGA_ARB=y +CONFIG_VGA_ARB_MAX_GPUS=16 +# CONFIG_VGA_SWITCHEROO is not set +CONFIG_DRM=y +CONFIG_DRM_MIPI_DSI=y +# CONFIG_DRM_DP_AUX_CHARDEV is not set +# CONFIG_DRM_DEBUG_MM is not set +# CONFIG_DRM_DEBUG_SELFTEST is not set +CONFIG_DRM_KMS_HELPER=y +CONFIG_DRM_KMS_FB_HELPER=y +CONFIG_DRM_FBDEV_EMULATION=y +CONFIG_DRM_FBDEV_OVERALLOC=100 +# CONFIG_DRM_LOAD_EDID_FIRMWARE is not set +# CONFIG_DRM_DP_CEC is not set + +# +# I2C encoder or helper chips +# +# CONFIG_DRM_I2C_CH7006 is not set +# CONFIG_DRM_I2C_SIL164 is not set +# CONFIG_DRM_I2C_NXP_TDA998X is not set +# CONFIG_DRM_I2C_NXP_TDA9950 is not set +# end of I2C encoder or helper chips + +# +# ARM devices +# +# end of ARM devices + +# CONFIG_DRM_RADEON is not set +# CONFIG_DRM_AMDGPU is not set + +# +# ACP (Audio CoProcessor) Configuration +# +# end of ACP (Audio CoProcessor) Configuration + +# CONFIG_DRM_NOUVEAU is not set +CONFIG_DRM_I915=y +# CONFIG_DRM_I915_ALPHA_SUPPORT is not set +CONFIG_DRM_I915_FORCE_PROBE="" +CONFIG_DRM_I915_CAPTURE_ERROR=y +CONFIG_DRM_I915_COMPRESS_ERROR=y +CONFIG_DRM_I915_USERPTR=y +# CONFIG_DRM_I915_GVT is not set +CONFIG_DRM_I915_USERFAULT_AUTOSUSPEND=250 +CONFIG_DRM_I915_HEARTBEAT_INTERVAL=2500 +CONFIG_DRM_I915_PREEMPT_TIMEOUT=640 +CONFIG_DRM_I915_SPIN_REQUEST=5 +CONFIG_DRM_I915_STOP_TIMEOUT=100 +CONFIG_DRM_I915_TIMESLICE_DURATION=1 +# CONFIG_DRM_VGEM is not set +# CONFIG_DRM_VKMS is not set +# CONFIG_DRM_VMWGFX is not set +# CONFIG_DRM_GMA500 is not set +# CONFIG_DRM_UDL is not set +# CONFIG_DRM_AST is not set +# CONFIG_DRM_MGAG200 is not set +# CONFIG_DRM_CIRRUS_QEMU is not set +# CONFIG_DRM_QXL is not set +# CONFIG_DRM_BOCHS is not set +CONFIG_DRM_PANEL=y + +# +# Display Panels +# +# CONFIG_DRM_PANEL_RASPBERRYPI_TOUCHSCREEN is not set +# end of Display Panels + +CONFIG_DRM_BRIDGE=y +CONFIG_DRM_PANEL_BRIDGE=y + +# +# Display Interface Bridges +# +# CONFIG_DRM_ANALOGIX_ANX78XX is not set +# end of Display Interface Bridges + +# CONFIG_DRM_ETNAVIV is not set +# CONFIG_DRM_GM12U320 is not set +# CONFIG_DRM_VBOXVIDEO is not set +# CONFIG_DRM_LEGACY is not set +CONFIG_DRM_PANEL_ORIENTATION_QUIRKS=y + +# +# Frame buffer Devices +# +CONFIG_FB_CMDLINE=y +CONFIG_FB_NOTIFY=y +CONFIG_FB=y +# CONFIG_FIRMWARE_EDID is not set +CONFIG_FB_CFB_FILLRECT=y +CONFIG_FB_CFB_COPYAREA=y +CONFIG_FB_CFB_IMAGEBLIT=y +CONFIG_FB_SYS_FILLRECT=y +CONFIG_FB_SYS_COPYAREA=y +CONFIG_FB_SYS_IMAGEBLIT=y +# CONFIG_FB_FOREIGN_ENDIAN is not set +CONFIG_FB_SYS_FOPS=y +CONFIG_FB_DEFERRED_IO=y +CONFIG_FB_MODE_HELPERS=y +CONFIG_FB_TILEBLITTING=y + +# +# Frame buffer hardware drivers +# +# CONFIG_FB_CIRRUS is not set +# CONFIG_FB_PM2 is not set +# CONFIG_FB_CYBER2000 is not set +# CONFIG_FB_ARC is not set +# CONFIG_FB_ASILIANT is not set +# CONFIG_FB_IMSTT is not set +# CONFIG_FB_VGA16 is not set +# CONFIG_FB_UVESA is not set +# CONFIG_FB_VESA is not set +CONFIG_FB_EFI=y +# CONFIG_FB_N411 is not set +# CONFIG_FB_HGA is not set +# CONFIG_FB_OPENCORES is not set +# CONFIG_FB_S1D13XXX is not set +# CONFIG_FB_NVIDIA is not set +# CONFIG_FB_RIVA is not set +# CONFIG_FB_I740 is not set +# CONFIG_FB_LE80578 is not set +# CONFIG_FB_MATROX is not set +# CONFIG_FB_RADEON is not set +# CONFIG_FB_ATY128 is not set +# CONFIG_FB_ATY is not set +# CONFIG_FB_S3 is not set +# CONFIG_FB_SAVAGE is not set +# CONFIG_FB_SIS is not set +# CONFIG_FB_NEOMAGIC is not set +# CONFIG_FB_KYRO is not set +# CONFIG_FB_3DFX is not set +# CONFIG_FB_VOODOO1 is not set +# CONFIG_FB_VT8623 is not set +# CONFIG_FB_TRIDENT is not set +# CONFIG_FB_ARK is not set +# CONFIG_FB_PM3 is not set +# CONFIG_FB_CARMINE is not set +# CONFIG_FB_SMSCUFX is not set +# CONFIG_FB_UDL is not set +# CONFIG_FB_IBM_GXT4500 is not set +# CONFIG_FB_VIRTUAL is not set +# CONFIG_FB_METRONOME is not set +# CONFIG_FB_MB862XX is not set +# CONFIG_FB_SIMPLE is not set +# CONFIG_FB_SM712 is not set +# end of Frame buffer Devices + +# +# Backlight & LCD device support +# +# CONFIG_LCD_CLASS_DEVICE is not set +CONFIG_BACKLIGHT_CLASS_DEVICE=y +CONFIG_BACKLIGHT_GENERIC=y +# CONFIG_BACKLIGHT_APPLE is not set +# CONFIG_BACKLIGHT_QCOM_WLED is not set +# CONFIG_BACKLIGHT_SAHARA is not set +# CONFIG_BACKLIGHT_ADP8860 is not set +# CONFIG_BACKLIGHT_ADP8870 is not set +# CONFIG_BACKLIGHT_LM3639 is not set +# CONFIG_BACKLIGHT_LV5207LP is not set +# CONFIG_BACKLIGHT_BD6107 is not set +# CONFIG_BACKLIGHT_ARCXCNN is not set +# end of Backlight & LCD device support + +CONFIG_HDMI=y + +# +# Console display driver support +# +CONFIG_VGA_CONSOLE=y +CONFIG_VGACON_SOFT_SCROLLBACK=y +CONFIG_VGACON_SOFT_SCROLLBACK_SIZE=64 +# CONFIG_VGACON_SOFT_SCROLLBACK_PERSISTENT_ENABLE_BY_DEFAULT is not set +CONFIG_DUMMY_CONSOLE=y +CONFIG_DUMMY_CONSOLE_COLUMNS=80 +CONFIG_DUMMY_CONSOLE_ROWS=25 +CONFIG_FRAMEBUFFER_CONSOLE=y +CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y +# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set +# CONFIG_FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER is not set +# end of Console display driver support + +CONFIG_LOGO=y +# CONFIG_LOGO_LINUX_MONO is not set +# CONFIG_LOGO_LINUX_VGA16 is not set +CONFIG_LOGO_LINUX_CLUT224=y +# end of Graphics support + +CONFIG_SOUND=y +CONFIG_SND=y +CONFIG_SND_TIMER=y +CONFIG_SND_PCM=y +CONFIG_SND_HWDEP=y +CONFIG_SND_SEQ_DEVICE=y +CONFIG_SND_JACK=y +CONFIG_SND_JACK_INPUT_DEV=y +# CONFIG_SND_OSSEMUL is not set +CONFIG_SND_PCM_TIMER=y +CONFIG_SND_HRTIMER=y +# CONFIG_SND_DYNAMIC_MINORS is not set +CONFIG_SND_SUPPORT_OLD_API=y +CONFIG_SND_PROC_FS=y +CONFIG_SND_VERBOSE_PROCFS=y +# CONFIG_SND_VERBOSE_PRINTK is not set +# CONFIG_SND_DEBUG is not set +CONFIG_SND_VMASTER=y +CONFIG_SND_DMA_SGBUF=y +CONFIG_SND_SEQUENCER=y +CONFIG_SND_SEQ_DUMMY=y +CONFIG_SND_SEQ_HRTIMER_DEFAULT=y +CONFIG_SND_DRIVERS=y +# CONFIG_SND_PCSP is not set +# CONFIG_SND_DUMMY is not set +# CONFIG_SND_ALOOP is not set +# CONFIG_SND_VIRMIDI is not set +# CONFIG_SND_MTPAV is not set +# CONFIG_SND_SERIAL_U16550 is not set +# CONFIG_SND_MPU401 is not set +CONFIG_SND_PCI=y +# CONFIG_SND_AD1889 is not set +# CONFIG_SND_ALS300 is not set +# CONFIG_SND_ALS4000 is not set +# CONFIG_SND_ALI5451 is not set +# CONFIG_SND_ASIHPI is not set +# CONFIG_SND_ATIIXP is not set +# CONFIG_SND_ATIIXP_MODEM is not set +# CONFIG_SND_AU8810 is not set +# CONFIG_SND_AU8820 is not set +# CONFIG_SND_AU8830 is not set +# CONFIG_SND_AW2 is not set +# CONFIG_SND_AZT3328 is not set +# CONFIG_SND_BT87X is not set +# CONFIG_SND_CA0106 is not set +# CONFIG_SND_CMIPCI is not set +# CONFIG_SND_OXYGEN is not set +# CONFIG_SND_CS4281 is not set +# CONFIG_SND_CS46XX is not set +# CONFIG_SND_CTXFI is not set +# CONFIG_SND_DARLA20 is not set +# CONFIG_SND_GINA20 is not set +# CONFIG_SND_LAYLA20 is not set +# CONFIG_SND_DARLA24 is not set +# CONFIG_SND_GINA24 is not set +# CONFIG_SND_LAYLA24 is not set +# CONFIG_SND_MONA is not set +# CONFIG_SND_MIA is not set +# CONFIG_SND_ECHO3G is not set +# CONFIG_SND_INDIGO is not set +# CONFIG_SND_INDIGOIO is not set +# CONFIG_SND_INDIGODJ is not set +# CONFIG_SND_INDIGOIOX is not set +# CONFIG_SND_INDIGODJX is not set +# CONFIG_SND_EMU10K1 is not set +# CONFIG_SND_EMU10K1X is not set +# CONFIG_SND_ENS1370 is not set +# CONFIG_SND_ENS1371 is not set +# CONFIG_SND_ES1938 is not set +# CONFIG_SND_ES1968 is not set +# CONFIG_SND_FM801 is not set +# CONFIG_SND_HDSP is not set +# CONFIG_SND_HDSPM is not set +# CONFIG_SND_ICE1712 is not set +# CONFIG_SND_ICE1724 is not set +# CONFIG_SND_INTEL8X0 is not set +# CONFIG_SND_INTEL8X0M is not set +# CONFIG_SND_KORG1212 is not set +# CONFIG_SND_LOLA is not set +# CONFIG_SND_LX6464ES is not set +# CONFIG_SND_MAESTRO3 is not set +# CONFIG_SND_MIXART is not set +# CONFIG_SND_NM256 is not set +# CONFIG_SND_PCXHR is not set +# CONFIG_SND_RIPTIDE is not set +# CONFIG_SND_RME32 is not set +# CONFIG_SND_RME96 is not set +# CONFIG_SND_RME9652 is not set +# CONFIG_SND_SE6X is not set +# CONFIG_SND_SONICVIBES is not set +# CONFIG_SND_TRIDENT is not set +# CONFIG_SND_VIA82XX is not set +# CONFIG_SND_VIA82XX_MODEM is not set +# CONFIG_SND_VIRTUOSO is not set +# CONFIG_SND_VX222 is not set +# CONFIG_SND_YMFPCI is not set + +# +# HD-Audio +# +CONFIG_SND_HDA=y +CONFIG_SND_HDA_INTEL=y +CONFIG_SND_HDA_HWDEP=y +# CONFIG_SND_HDA_RECONFIG is not set +# CONFIG_SND_HDA_INPUT_BEEP is not set +# CONFIG_SND_HDA_PATCH_LOADER is not set +# CONFIG_SND_HDA_CODEC_REALTEK is not set +# CONFIG_SND_HDA_CODEC_ANALOG is not set +# CONFIG_SND_HDA_CODEC_SIGMATEL is not set +# CONFIG_SND_HDA_CODEC_VIA is not set +# CONFIG_SND_HDA_CODEC_HDMI is not set +# CONFIG_SND_HDA_CODEC_CIRRUS is not set +# CONFIG_SND_HDA_CODEC_CONEXANT is not set +# CONFIG_SND_HDA_CODEC_CA0110 is not set +# CONFIG_SND_HDA_CODEC_CA0132 is not set +# CONFIG_SND_HDA_CODEC_CMEDIA is not set +# CONFIG_SND_HDA_CODEC_SI3054 is not set +# CONFIG_SND_HDA_GENERIC is not set +CONFIG_SND_HDA_POWER_SAVE_DEFAULT=0 +# end of HD-Audio + +CONFIG_SND_HDA_CORE=y +CONFIG_SND_HDA_COMPONENT=y +CONFIG_SND_HDA_I915=y +CONFIG_SND_HDA_PREALLOC_SIZE=64 +CONFIG_SND_INTEL_NHLT=y +CONFIG_SND_INTEL_DSP_CONFIG=y +CONFIG_SND_USB=y +# CONFIG_SND_USB_AUDIO is not set +# CONFIG_SND_USB_UA101 is not set +# CONFIG_SND_USB_USX2Y is not set +# CONFIG_SND_USB_CAIAQ is not set +# CONFIG_SND_USB_US122L is not set +# CONFIG_SND_USB_6FIRE is not set +# CONFIG_SND_USB_HIFACE is not set +# CONFIG_SND_BCD2000 is not set +# CONFIG_SND_USB_POD is not set +# CONFIG_SND_USB_PODHD is not set +# CONFIG_SND_USB_TONEPORT is not set +# CONFIG_SND_USB_VARIAX is not set +CONFIG_SND_PCMCIA=y +# CONFIG_SND_VXPOCKET is not set +# CONFIG_SND_PDAUDIOCF is not set +# CONFIG_SND_SOC is not set +CONFIG_SND_X86=y +# CONFIG_HDMI_LPE_AUDIO is not set + +# +# HID support +# +CONFIG_HID=y +# CONFIG_HID_BATTERY_STRENGTH is not set +CONFIG_HIDRAW=y +# CONFIG_UHID is not set +CONFIG_HID_GENERIC=y + +# +# Special HID drivers +# +CONFIG_HID_A4TECH=y +# CONFIG_HID_ACCUTOUCH is not set +# CONFIG_HID_ACRUX is not set +CONFIG_HID_APPLE=y +# CONFIG_HID_APPLEIR is not set +# CONFIG_HID_ASUS is not set +# CONFIG_HID_AUREAL is not set +CONFIG_HID_BELKIN=y +# CONFIG_HID_BETOP_FF is not set +# CONFIG_HID_BIGBEN_FF is not set +CONFIG_HID_CHERRY=y +CONFIG_HID_CHICONY=y +# CONFIG_HID_CORSAIR is not set +# CONFIG_HID_COUGAR is not set +# CONFIG_HID_MACALLY is not set +# CONFIG_HID_PRODIKEYS is not set +# CONFIG_HID_CMEDIA is not set +# CONFIG_HID_CREATIVE_SB0540 is not set +CONFIG_HID_CYPRESS=y +# CONFIG_HID_DRAGONRISE is not set +# CONFIG_HID_EMS_FF is not set +# CONFIG_HID_ELAN is not set +# CONFIG_HID_ELECOM is not set +# CONFIG_HID_ELO is not set +CONFIG_HID_EZKEY=y +# CONFIG_HID_GEMBIRD is not set +# CONFIG_HID_GFRM is not set +# CONFIG_HID_HOLTEK is not set +# CONFIG_HID_GT683R is not set +# CONFIG_HID_KEYTOUCH is not set +# CONFIG_HID_KYE is not set +# CONFIG_HID_UCLOGIC is not set +# CONFIG_HID_WALTOP is not set +# CONFIG_HID_VIEWSONIC is not set +CONFIG_HID_GYRATION=y +# CONFIG_HID_ICADE is not set +CONFIG_HID_ITE=y +# CONFIG_HID_JABRA is not set +# CONFIG_HID_TWINHAN is not set +CONFIG_HID_KENSINGTON=y +# CONFIG_HID_LCPOWER is not set +# CONFIG_HID_LED is not set +# CONFIG_HID_LENOVO is not set +CONFIG_HID_LOGITECH=y +# CONFIG_HID_LOGITECH_DJ is not set +# CONFIG_HID_LOGITECH_HIDPP is not set +CONFIG_LOGITECH_FF=y +# CONFIG_LOGIRUMBLEPAD2_FF is not set +# CONFIG_LOGIG940_FF is not set +CONFIG_LOGIWHEELS_FF=y +# CONFIG_HID_MAGICMOUSE is not set +# CONFIG_HID_MALTRON is not set +# CONFIG_HID_MAYFLASH is not set +CONFIG_HID_REDRAGON=y +CONFIG_HID_MICROSOFT=y +CONFIG_HID_MONTEREY=y +# CONFIG_HID_MULTITOUCH is not set +# CONFIG_HID_NTI is not set +CONFIG_HID_NTRIG=y +# CONFIG_HID_ORTEK is not set +CONFIG_HID_PANTHERLORD=y +CONFIG_PANTHERLORD_FF=y +# CONFIG_HID_PENMOUNT is not set +CONFIG_HID_PETALYNX=y +# CONFIG_HID_PICOLCD is not set +# CONFIG_HID_PLANTRONICS is not set +# CONFIG_HID_PRIMAX is not set +# CONFIG_HID_RETRODE is not set +# CONFIG_HID_ROCCAT is not set +# CONFIG_HID_SAITEK is not set +CONFIG_HID_SAMSUNG=y +CONFIG_HID_SONY=y +# CONFIG_SONY_FF is not set +# CONFIG_HID_SPEEDLINK is not set +# CONFIG_HID_STEAM is not set +# CONFIG_HID_STEELSERIES is not set +CONFIG_HID_SUNPLUS=y +# CONFIG_HID_RMI is not set +# CONFIG_HID_GREENASIA is not set +# CONFIG_HID_SMARTJOYPLUS is not set +# CONFIG_HID_TIVO is not set +CONFIG_HID_TOPSEED=y +# CONFIG_HID_THINGM is not set +# CONFIG_HID_THRUSTMASTER is not set +# CONFIG_HID_UDRAW_PS3 is not set +# CONFIG_HID_U2FZERO is not set +# CONFIG_HID_WACOM is not set +# CONFIG_HID_WIIMOTE is not set +# CONFIG_HID_XINMO is not set +# CONFIG_HID_ZEROPLUS is not set +# CONFIG_HID_ZYDACRON is not set +# CONFIG_HID_SENSOR_HUB is not set +# CONFIG_HID_ALPS is not set +# end of Special HID drivers + +# +# USB HID support +# +CONFIG_USB_HID=y +CONFIG_HID_PID=y +CONFIG_USB_HIDDEV=y +# end of USB HID support + +# +# I2C HID support +# +# CONFIG_I2C_HID is not set +# end of I2C HID support + +# +# Intel ISH HID support +# +# CONFIG_INTEL_ISH_HID is not set +# end of Intel ISH HID support +# end of HID support + +CONFIG_USB_OHCI_LITTLE_ENDIAN=y +CONFIG_USB_SUPPORT=y +CONFIG_USB_COMMON=y +# CONFIG_USB_LED_TRIG is not set +# CONFIG_USB_ULPI_BUS is not set +CONFIG_USB_ARCH_HAS_HCD=y +CONFIG_USB=y +CONFIG_USB_PCI=y +CONFIG_USB_ANNOUNCE_NEW_DEVICES=y + +# +# Miscellaneous USB options +# +CONFIG_USB_DEFAULT_PERSIST=y +# CONFIG_USB_DYNAMIC_MINORS is not set +# CONFIG_USB_OTG is not set +# CONFIG_USB_OTG_WHITELIST is not set +# CONFIG_USB_LEDS_TRIGGER_USBPORT is not set +CONFIG_USB_AUTOSUSPEND_DELAY=2 +CONFIG_USB_MON=y + +# +# USB Host Controller Drivers +# +# CONFIG_USB_C67X00_HCD is not set +CONFIG_USB_XHCI_HCD=y +# CONFIG_USB_XHCI_DBGCAP is not set +CONFIG_USB_XHCI_PCI=y +# CONFIG_USB_XHCI_PLATFORM is not set +CONFIG_USB_EHCI_HCD=y +# CONFIG_USB_EHCI_ROOT_HUB_TT is not set +CONFIG_USB_EHCI_TT_NEWSCHED=y +CONFIG_USB_EHCI_PCI=y +# CONFIG_USB_EHCI_FSL is not set +# CONFIG_USB_EHCI_HCD_PLATFORM is not set +# CONFIG_USB_OXU210HP_HCD is not set +# CONFIG_USB_ISP116X_HCD is not set +# CONFIG_USB_FOTG210_HCD is not set +CONFIG_USB_OHCI_HCD=y +CONFIG_USB_OHCI_HCD_PCI=y +# CONFIG_USB_OHCI_HCD_PLATFORM is not set +CONFIG_USB_UHCI_HCD=y +# CONFIG_USB_SL811_HCD is not set +# CONFIG_USB_R8A66597_HCD is not set +# CONFIG_USB_HCD_TEST_MODE is not set + +# +# USB Device Class drivers +# +# CONFIG_USB_ACM is not set +CONFIG_USB_PRINTER=y +# CONFIG_USB_WDM is not set +# CONFIG_USB_TMC is not set + +# +# NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may +# + +# +# also be needed; see USB_STORAGE Help for more info +# +CONFIG_USB_STORAGE=y +# CONFIG_USB_STORAGE_DEBUG is not set +# CONFIG_USB_STORAGE_REALTEK is not set +# CONFIG_USB_STORAGE_DATAFAB is not set +# CONFIG_USB_STORAGE_FREECOM is not set +# CONFIG_USB_STORAGE_ISD200 is not set +# CONFIG_USB_STORAGE_USBAT is not set +# CONFIG_USB_STORAGE_SDDR09 is not set +# CONFIG_USB_STORAGE_SDDR55 is not set +# CONFIG_USB_STORAGE_JUMPSHOT is not set +# CONFIG_USB_STORAGE_ALAUDA is not set +# CONFIG_USB_STORAGE_ONETOUCH is not set +# CONFIG_USB_STORAGE_KARMA is not set +# CONFIG_USB_STORAGE_CYPRESS_ATACB is not set +# CONFIG_USB_STORAGE_ENE_UB6250 is not set +# CONFIG_USB_UAS is not set + +# +# USB Imaging devices +# +# CONFIG_USB_MDC800 is not set +# CONFIG_USB_MICROTEK is not set +# CONFIG_USBIP_CORE is not set +# CONFIG_USB_CDNS3 is not set +# CONFIG_USB_MUSB_HDRC is not set +# CONFIG_USB_DWC3 is not set +# CONFIG_USB_DWC2 is not set +# CONFIG_USB_CHIPIDEA is not set +# CONFIG_USB_ISP1760 is not set + +# +# USB port drivers +# +# CONFIG_USB_SERIAL is not set + +# +# USB Miscellaneous drivers +# +# CONFIG_USB_EMI62 is not set +# CONFIG_USB_EMI26 is not set +# CONFIG_USB_ADUTUX is not set +# CONFIG_USB_SEVSEG is not set +# CONFIG_USB_LEGOTOWER is not set +# CONFIG_USB_LCD is not set +# CONFIG_USB_CYPRESS_CY7C63 is not set +# CONFIG_USB_CYTHERM is not set +# CONFIG_USB_IDMOUSE is not set +# CONFIG_USB_FTDI_ELAN is not set +# CONFIG_USB_APPLEDISPLAY is not set +# CONFIG_USB_SISUSBVGA is not set +# CONFIG_USB_LD is not set +# CONFIG_USB_TRANCEVIBRATOR is not set +# CONFIG_USB_IOWARRIOR is not set +# CONFIG_USB_TEST is not set +# CONFIG_USB_EHSET_TEST_FIXTURE is not set +# CONFIG_USB_ISIGHTFW is not set +# CONFIG_USB_YUREX is not set +# CONFIG_USB_EZUSB_FX2 is not set +# CONFIG_USB_HUB_USB251XB is not set +# CONFIG_USB_HSIC_USB3503 is not set +# CONFIG_USB_HSIC_USB4604 is not set +# CONFIG_USB_LINK_LAYER_TEST is not set +# CONFIG_USB_CHAOSKEY is not set + +# +# USB Physical Layer drivers +# +# CONFIG_NOP_USB_XCEIV is not set +# CONFIG_USB_ISP1301 is not set +# end of USB Physical Layer drivers + +# CONFIG_USB_GADGET is not set +# CONFIG_TYPEC is not set +# CONFIG_USB_ROLE_SWITCH is not set +# CONFIG_MMC is not set +# CONFIG_MEMSTICK is not set +CONFIG_NEW_LEDS=y +CONFIG_LEDS_CLASS=y +# CONFIG_LEDS_CLASS_FLASH is not set +# CONFIG_LEDS_BRIGHTNESS_HW_CHANGED is not set + +# +# LED drivers +# +# CONFIG_LEDS_APU is not set +# CONFIG_LEDS_LM3530 is not set +# CONFIG_LEDS_LM3532 is not set +# CONFIG_LEDS_LM3642 is not set +# CONFIG_LEDS_PCA9532 is not set +# CONFIG_LEDS_LP3944 is not set +# CONFIG_LEDS_LP5521 is not set +# CONFIG_LEDS_LP5523 is not set +# CONFIG_LEDS_LP5562 is not set +# CONFIG_LEDS_LP8501 is not set +# CONFIG_LEDS_CLEVO_MAIL is not set +# CONFIG_LEDS_PCA955X is not set +# CONFIG_LEDS_PCA963X is not set +# CONFIG_LEDS_BD2802 is not set +# CONFIG_LEDS_INTEL_SS4200 is not set +# CONFIG_LEDS_TCA6507 is not set +# CONFIG_LEDS_TLC591XX is not set +# CONFIG_LEDS_LM355x is not set + +# +# LED driver for blink(1) USB RGB LED is under Special HID drivers (HID_THINGM) +# +# CONFIG_LEDS_BLINKM is not set +# CONFIG_LEDS_MLXCPLD is not set +# CONFIG_LEDS_MLXREG is not set +# CONFIG_LEDS_USER is not set +# CONFIG_LEDS_NIC78BX is not set +# CONFIG_LEDS_TI_LMU_COMMON is not set + +# +# LED Triggers +# +CONFIG_LEDS_TRIGGERS=y +# CONFIG_LEDS_TRIGGER_TIMER is not set +# CONFIG_LEDS_TRIGGER_ONESHOT is not set +# CONFIG_LEDS_TRIGGER_DISK is not set +# CONFIG_LEDS_TRIGGER_HEARTBEAT is not set +# CONFIG_LEDS_TRIGGER_BACKLIGHT is not set +# CONFIG_LEDS_TRIGGER_CPU is not set +# CONFIG_LEDS_TRIGGER_ACTIVITY is not set +# CONFIG_LEDS_TRIGGER_DEFAULT_ON is not set + +# +# iptables trigger is under Netfilter config (LED target) +# +# CONFIG_LEDS_TRIGGER_TRANSIENT is not set +# CONFIG_LEDS_TRIGGER_CAMERA is not set +# CONFIG_LEDS_TRIGGER_PANIC is not set +# CONFIG_LEDS_TRIGGER_NETDEV is not set +# CONFIG_LEDS_TRIGGER_PATTERN is not set +# CONFIG_LEDS_TRIGGER_AUDIO is not set +# CONFIG_ACCESSIBILITY is not set +# CONFIG_INFINIBAND is not set +CONFIG_EDAC_ATOMIC_SCRUB=y +CONFIG_EDAC_SUPPORT=y +CONFIG_EDAC=y +CONFIG_EDAC_LEGACY_SYSFS=y +# CONFIG_EDAC_DEBUG is not set +CONFIG_EDAC_DECODE_MCE=y +# CONFIG_EDAC_AMD64 is not set +# CONFIG_EDAC_E752X is not set +# CONFIG_EDAC_I82975X is not set +# CONFIG_EDAC_I3000 is not set +# CONFIG_EDAC_I3200 is not set +# CONFIG_EDAC_IE31200 is not set +# CONFIG_EDAC_X38 is not set +# CONFIG_EDAC_I5400 is not set +# CONFIG_EDAC_I7CORE is not set +# CONFIG_EDAC_I5000 is not set +# CONFIG_EDAC_I5100 is not set +# CONFIG_EDAC_I7300 is not set +# CONFIG_EDAC_SBRIDGE is not set +# CONFIG_EDAC_SKX is not set +# CONFIG_EDAC_I10NM is not set +# CONFIG_EDAC_PND2 is not set +CONFIG_RTC_LIB=y +CONFIG_RTC_MC146818_LIB=y +CONFIG_RTC_CLASS=y +# CONFIG_RTC_HCTOSYS is not set +CONFIG_RTC_SYSTOHC=y +CONFIG_RTC_SYSTOHC_DEVICE="rtc0" +# CONFIG_RTC_DEBUG is not set +CONFIG_RTC_NVMEM=y + +# +# RTC interfaces +# +CONFIG_RTC_INTF_SYSFS=y +CONFIG_RTC_INTF_PROC=y +CONFIG_RTC_INTF_DEV=y +# CONFIG_RTC_INTF_DEV_UIE_EMUL is not set +# CONFIG_RTC_DRV_TEST is not set + +# +# I2C RTC drivers +# +# CONFIG_RTC_DRV_ABB5ZES3 is not set +# CONFIG_RTC_DRV_ABEOZ9 is not set +# CONFIG_RTC_DRV_ABX80X is not set +# CONFIG_RTC_DRV_DS1307 is not set +# CONFIG_RTC_DRV_DS1374 is not set +# CONFIG_RTC_DRV_DS1672 is not set +# CONFIG_RTC_DRV_MAX6900 is not set +# CONFIG_RTC_DRV_RS5C372 is not set +# CONFIG_RTC_DRV_ISL1208 is not set +# CONFIG_RTC_DRV_ISL12022 is not set +# CONFIG_RTC_DRV_X1205 is not set +# CONFIG_RTC_DRV_PCF8523 is not set +# CONFIG_RTC_DRV_PCF85063 is not set +# CONFIG_RTC_DRV_PCF85363 is not set +# CONFIG_RTC_DRV_PCF8563 is not set +# CONFIG_RTC_DRV_PCF8583 is not set +# CONFIG_RTC_DRV_M41T80 is not set +# CONFIG_RTC_DRV_BQ32K is not set +# CONFIG_RTC_DRV_S35390A is not set +# CONFIG_RTC_DRV_FM3130 is not set +# CONFIG_RTC_DRV_RX8010 is not set +# CONFIG_RTC_DRV_RX8581 is not set +# CONFIG_RTC_DRV_RX8025 is not set +# CONFIG_RTC_DRV_EM3027 is not set +# CONFIG_RTC_DRV_RV3028 is not set +# CONFIG_RTC_DRV_RV8803 is not set +# CONFIG_RTC_DRV_SD3078 is not set + +# +# SPI RTC drivers +# +CONFIG_RTC_I2C_AND_SPI=y + +# +# SPI and I2C RTC drivers +# +# CONFIG_RTC_DRV_DS3232 is not set +# CONFIG_RTC_DRV_PCF2127 is not set +# CONFIG_RTC_DRV_RV3029C2 is not set + +# +# Platform RTC drivers +# +CONFIG_RTC_DRV_CMOS=y +# CONFIG_RTC_DRV_DS1286 is not set +# CONFIG_RTC_DRV_DS1511 is not set +# CONFIG_RTC_DRV_DS1553 is not set +# CONFIG_RTC_DRV_DS1685_FAMILY is not set +# CONFIG_RTC_DRV_DS1742 is not set +# CONFIG_RTC_DRV_DS2404 is not set +# CONFIG_RTC_DRV_STK17TA8 is not set +# CONFIG_RTC_DRV_M48T86 is not set +# CONFIG_RTC_DRV_M48T35 is not set +# CONFIG_RTC_DRV_M48T59 is not set +# CONFIG_RTC_DRV_MSM6242 is not set +# CONFIG_RTC_DRV_BQ4802 is not set +# CONFIG_RTC_DRV_RP5C01 is not set +# CONFIG_RTC_DRV_V3020 is not set + +# +# on-CPU RTC drivers +# +# CONFIG_RTC_DRV_FTRTC010 is not set + +# +# HID Sensor RTC drivers +# +CONFIG_DMADEVICES=y +# CONFIG_DMADEVICES_DEBUG is not set + +# +# DMA Devices +# +CONFIG_DMA_ENGINE=y +CONFIG_DMA_VIRTUAL_CHANNELS=y +CONFIG_DMA_ACPI=y +# CONFIG_ALTERA_MSGDMA is not set +# CONFIG_INTEL_IDMA64 is not set +# CONFIG_INTEL_IOATDMA is not set +# CONFIG_QCOM_HIDMA_MGMT is not set +# CONFIG_QCOM_HIDMA is not set +CONFIG_DW_DMAC_CORE=y +# CONFIG_DW_DMAC is not set +# CONFIG_DW_DMAC_PCI is not set +# CONFIG_DW_EDMA is not set +# CONFIG_DW_EDMA_PCIE is not set +CONFIG_HSU_DMA=y +# CONFIG_SF_PDMA is not set + +# +# DMA Clients +# +# CONFIG_ASYNC_TX_DMA is not set +# CONFIG_DMATEST is not set + +# +# DMABUF options +# +CONFIG_SYNC_FILE=y +# CONFIG_SW_SYNC is not set +# CONFIG_UDMABUF is not set +# CONFIG_DMABUF_SELFTESTS is not set +# end of DMABUF options + +# CONFIG_AUXDISPLAY is not set +# CONFIG_UIO is not set +# CONFIG_VFIO is not set +# CONFIG_VIRT_DRIVERS is not set +CONFIG_VIRTIO_MENU=y +# CONFIG_VIRTIO_PCI is not set +# CONFIG_VIRTIO_MMIO is not set + +# +# Microsoft Hyper-V guest support +# +# end of Microsoft Hyper-V guest support + +# CONFIG_GREYBUS is not set +# CONFIG_STAGING is not set +CONFIG_X86_PLATFORM_DEVICES=y +# CONFIG_ACER_WIRELESS is not set +# CONFIG_ACERHDF is not set +# CONFIG_ASUS_LAPTOP is not set +# CONFIG_DCDBAS is not set +# CONFIG_DELL_SMBIOS is not set +# CONFIG_DELL_SMO8800 is not set +# CONFIG_DELL_RBTN is not set +# CONFIG_DELL_RBU is not set +# CONFIG_FUJITSU_LAPTOP is not set +# CONFIG_FUJITSU_TABLET is not set +# CONFIG_AMILO_RFKILL is not set +# CONFIG_GPD_POCKET_FAN is not set +# CONFIG_HP_ACCEL is not set +# CONFIG_HP_WIRELESS is not set +# CONFIG_MSI_LAPTOP is not set +# CONFIG_PANASONIC_LAPTOP is not set +# CONFIG_COMPAL_LAPTOP is not set +# CONFIG_SONY_LAPTOP is not set +# CONFIG_IDEAPAD_LAPTOP is not set +# CONFIG_THINKPAD_ACPI is not set +# CONFIG_SENSORS_HDAPS is not set +# CONFIG_INTEL_MENLOW is not set +CONFIG_EEEPC_LAPTOP=y +# CONFIG_ASUS_WIRELESS is not set +# CONFIG_ACPI_WMI is not set +# CONFIG_TOPSTAR_LAPTOP is not set +# CONFIG_TOSHIBA_BT_RFKILL is not set +# CONFIG_TOSHIBA_HAPS is not set +# CONFIG_ACPI_CMPC is not set +# CONFIG_INTEL_HID_EVENT is not set +# CONFIG_INTEL_VBTN is not set +# CONFIG_INTEL_IPS is not set +# CONFIG_INTEL_PMC_CORE is not set +# CONFIG_IBM_RTL is not set +# CONFIG_SAMSUNG_LAPTOP is not set +# CONFIG_INTEL_OAKTRAIL is not set +# CONFIG_SAMSUNG_Q10 is not set +# CONFIG_APPLE_GMUX is not set +# CONFIG_INTEL_RST is not set +# CONFIG_INTEL_SMARTCONNECT is not set +# CONFIG_INTEL_PMC_IPC is not set +# CONFIG_SURFACE_PRO3_BUTTON is not set +# CONFIG_INTEL_PUNIT_IPC is not set +# CONFIG_MLX_PLATFORM is not set +# CONFIG_INTEL_TURBO_MAX_3 is not set +# CONFIG_I2C_MULTI_INSTANTIATE is not set +# CONFIG_INTEL_ATOMISP2_PM is not set + +# +# Intel Speed Select Technology interface support +# +# CONFIG_INTEL_SPEED_SELECT_INTERFACE is not set +# end of Intel Speed Select Technology interface support + +# CONFIG_SYSTEM76_ACPI is not set +CONFIG_PMC_ATOM=y +# CONFIG_MFD_CROS_EC is not set +# CONFIG_CHROME_PLATFORMS is not set +# CONFIG_MELLANOX_PLATFORM is not set +CONFIG_CLKDEV_LOOKUP=y +CONFIG_HAVE_CLK_PREPARE=y +CONFIG_COMMON_CLK=y + +# +# Common Clock Framework +# +# CONFIG_COMMON_CLK_MAX9485 is not set +# CONFIG_COMMON_CLK_SI5341 is not set +# CONFIG_COMMON_CLK_SI5351 is not set +# CONFIG_COMMON_CLK_SI544 is not set +# CONFIG_COMMON_CLK_CDCE706 is not set +# CONFIG_COMMON_CLK_CS2000_CP is not set +# end of Common Clock Framework + +# CONFIG_HWSPINLOCK is not set + +# +# Clock Source drivers +# +CONFIG_CLKEVT_I8253=y +CONFIG_I8253_LOCK=y +CONFIG_CLKBLD_I8253=y +# end of Clock Source drivers + +CONFIG_MAILBOX=y +CONFIG_PCC=y +# CONFIG_ALTERA_MBOX is not set +CONFIG_IOMMU_IOVA=y +CONFIG_IOMMU_API=y +CONFIG_IOMMU_SUPPORT=y + +# +# Generic IOMMU Pagetable Support +# +# end of Generic IOMMU Pagetable Support + +# CONFIG_IOMMU_DEBUGFS is not set +# CONFIG_IOMMU_DEFAULT_PASSTHROUGH is not set +CONFIG_IOMMU_DMA=y +CONFIG_AMD_IOMMU=y +# CONFIG_AMD_IOMMU_V2 is not set +CONFIG_DMAR_TABLE=y +CONFIG_INTEL_IOMMU=y +# CONFIG_INTEL_IOMMU_SVM is not set +# CONFIG_INTEL_IOMMU_DEFAULT_ON is not set +CONFIG_INTEL_IOMMU_FLOPPY_WA=y +# CONFIG_IRQ_REMAP is not set + +# +# Remoteproc drivers +# +# CONFIG_REMOTEPROC is not set +# end of Remoteproc drivers + +# +# Rpmsg drivers +# +# CONFIG_RPMSG_QCOM_GLINK_RPM is not set +# CONFIG_RPMSG_VIRTIO is not set +# end of Rpmsg drivers + +# CONFIG_SOUNDWIRE is not set + +# +# SOC (System On Chip) specific Drivers +# + +# +# Amlogic SoC drivers +# +# end of Amlogic SoC drivers + +# +# Aspeed SoC drivers +# +# end of Aspeed SoC drivers + +# +# Broadcom SoC drivers +# +# end of Broadcom SoC drivers + +# +# NXP/Freescale QorIQ SoC drivers +# +# end of NXP/Freescale QorIQ SoC drivers + +# +# i.MX SoC drivers +# +# end of i.MX SoC drivers + +# +# Qualcomm SoC drivers +# +# end of Qualcomm SoC drivers + +# CONFIG_SOC_TI is not set + +# +# Xilinx SoC drivers +# +# CONFIG_XILINX_VCU is not set +# end of Xilinx SoC drivers +# end of SOC (System On Chip) specific Drivers + +# CONFIG_PM_DEVFREQ is not set +# CONFIG_EXTCON is not set +# CONFIG_MEMORY is not set +# CONFIG_IIO is not set +# CONFIG_NTB is not set +# CONFIG_VME_BUS is not set +# CONFIG_PWM is not set + +# +# IRQ chip support +# +# end of IRQ chip support + +# CONFIG_IPACK_BUS is not set +# CONFIG_RESET_CONTROLLER is not set + +# +# PHY Subsystem +# +# CONFIG_GENERIC_PHY is not set +# CONFIG_BCM_KONA_USB2_PHY is not set +# CONFIG_PHY_PXA_28NM_HSIC is not set +# CONFIG_PHY_PXA_28NM_USB2 is not set +# end of PHY Subsystem + +# CONFIG_POWERCAP is not set +# CONFIG_MCB is not set + +# +# Performance monitor support +# +# end of Performance monitor support + +CONFIG_RAS=y +# CONFIG_THUNDERBOLT is not set + +# +# Android +# +# CONFIG_ANDROID is not set +# end of Android + +# CONFIG_LIBNVDIMM is not set +# CONFIG_DAX is not set +CONFIG_NVMEM=y +CONFIG_NVMEM_SYSFS=y + +# +# HW tracing support +# +# CONFIG_STM is not set +# CONFIG_INTEL_TH is not set +# end of HW tracing support + +# CONFIG_FPGA is not set +# CONFIG_UNISYS_VISORBUS is not set +# CONFIG_SIOX is not set +# CONFIG_SLIMBUS is not set +# CONFIG_INTERCONNECT is not set +# CONFIG_COUNTER is not set +# end of Device Drivers + +# +# File systems +# +CONFIG_DCACHE_WORD_ACCESS=y +# CONFIG_VALIDATE_FS_PARSER is not set +CONFIG_FS_IOMAP=y +# CONFIG_EXT2_FS is not set +# CONFIG_EXT3_FS is not set +CONFIG_EXT4_FS=y +CONFIG_EXT4_USE_FOR_EXT2=y +CONFIG_EXT4_FS_POSIX_ACL=y +CONFIG_EXT4_FS_SECURITY=y +# CONFIG_EXT4_DEBUG is not set +CONFIG_JBD2=y +# CONFIG_JBD2_DEBUG is not set +CONFIG_FS_MBCACHE=y +# CONFIG_REISERFS_FS is not set +# CONFIG_JFS_FS is not set +# CONFIG_XFS_FS is not set +# CONFIG_GFS2_FS is not set +# CONFIG_BTRFS_FS is not set +# CONFIG_NILFS2_FS is not set +# CONFIG_F2FS_FS is not set +# CONFIG_FS_DAX is not set +CONFIG_FS_POSIX_ACL=y +CONFIG_EXPORTFS=y +# CONFIG_EXPORTFS_BLOCK_OPS is not set +CONFIG_FILE_LOCKING=y +CONFIG_MANDATORY_FILE_LOCKING=y +# CONFIG_FS_ENCRYPTION is not set +# CONFIG_FS_VERITY is not set +CONFIG_FSNOTIFY=y +CONFIG_DNOTIFY=y +CONFIG_INOTIFY_USER=y +# CONFIG_FANOTIFY is not set +CONFIG_QUOTA=y +CONFIG_QUOTA_NETLINK_INTERFACE=y +# CONFIG_PRINT_QUOTA_WARNING is not set +# CONFIG_QUOTA_DEBUG is not set +CONFIG_QUOTA_TREE=y +# CONFIG_QFMT_V1 is not set +CONFIG_QFMT_V2=y +CONFIG_QUOTACTL=y +CONFIG_QUOTACTL_COMPAT=y +CONFIG_AUTOFS4_FS=y +CONFIG_AUTOFS_FS=y +# CONFIG_FUSE_FS is not set +# CONFIG_OVERLAY_FS is not set + +# +# Caches +# +# CONFIG_FSCACHE is not set +# end of Caches + +# +# CD-ROM/DVD Filesystems +# +CONFIG_ISO9660_FS=y +CONFIG_JOLIET=y +CONFIG_ZISOFS=y +# CONFIG_UDF_FS is not set +# end of CD-ROM/DVD Filesystems + +# +# DOS/FAT/NT Filesystems +# +CONFIG_FAT_FS=y +CONFIG_MSDOS_FS=y +CONFIG_VFAT_FS=y +CONFIG_FAT_DEFAULT_CODEPAGE=437 +CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1" +# CONFIG_FAT_DEFAULT_UTF8 is not set +# CONFIG_NTFS_FS is not set +# end of DOS/FAT/NT Filesystems + +# +# Pseudo filesystems +# +CONFIG_PROC_FS=y +CONFIG_PROC_KCORE=y +CONFIG_PROC_VMCORE=y +# CONFIG_PROC_VMCORE_DEVICE_DUMP is not set +CONFIG_PROC_SYSCTL=y +CONFIG_PROC_PAGE_MONITOR=y +# CONFIG_PROC_CHILDREN is not set +CONFIG_PROC_PID_ARCH_STATUS=y +CONFIG_KERNFS=y +CONFIG_SYSFS=y +CONFIG_TMPFS=y +CONFIG_TMPFS_POSIX_ACL=y +CONFIG_TMPFS_XATTR=y +CONFIG_HUGETLBFS=y +CONFIG_HUGETLB_PAGE=y +CONFIG_MEMFD_CREATE=y +CONFIG_ARCH_HAS_GIGANTIC_PAGE=y +# CONFIG_CONFIGFS_FS is not set +CONFIG_EFIVAR_FS=m +# end of Pseudo filesystems + +CONFIG_MISC_FILESYSTEMS=y +# CONFIG_ORANGEFS_FS is not set +# CONFIG_ADFS_FS is not set +# CONFIG_AFFS_FS is not set +# CONFIG_ECRYPT_FS is not set +# CONFIG_HFS_FS is not set +# CONFIG_HFSPLUS_FS is not set +# CONFIG_BEFS_FS is not set +# CONFIG_BFS_FS is not set +# CONFIG_EFS_FS is not set +# CONFIG_CRAMFS is not set +# CONFIG_SQUASHFS is not set +# CONFIG_VXFS_FS is not set +# CONFIG_MINIX_FS is not set +# CONFIG_OMFS_FS is not set +# CONFIG_HPFS_FS is not set +# CONFIG_QNX4FS_FS is not set +# CONFIG_QNX6FS_FS is not set +# CONFIG_ROMFS_FS is not set +# CONFIG_PSTORE is not set +# CONFIG_SYSV_FS is not set +# CONFIG_UFS_FS is not set +# CONFIG_EROFS_FS is not set +CONFIG_NETWORK_FILESYSTEMS=y +CONFIG_NFS_FS=y +CONFIG_NFS_V2=y +CONFIG_NFS_V3=y +CONFIG_NFS_V3_ACL=y +CONFIG_NFS_V4=y +# CONFIG_NFS_SWAP is not set +# CONFIG_NFS_V4_1 is not set +CONFIG_ROOT_NFS=y +# CONFIG_NFS_USE_LEGACY_DNS is not set +CONFIG_NFS_USE_KERNEL_DNS=y +# CONFIG_NFSD is not set +CONFIG_GRACE_PERIOD=y +CONFIG_LOCKD=y +CONFIG_LOCKD_V4=y +CONFIG_NFS_ACL_SUPPORT=y +CONFIG_NFS_COMMON=y +CONFIG_SUNRPC=y +CONFIG_SUNRPC_GSS=y +# CONFIG_SUNRPC_DEBUG is not set +# CONFIG_CEPH_FS is not set +# CONFIG_CIFS is not set +# CONFIG_CODA_FS is not set +# CONFIG_AFS_FS is not set +CONFIG_NLS=y +CONFIG_NLS_DEFAULT="utf8" +CONFIG_NLS_CODEPAGE_437=y +# CONFIG_NLS_CODEPAGE_737 is not set +# CONFIG_NLS_CODEPAGE_775 is not set +# CONFIG_NLS_CODEPAGE_850 is not set +# CONFIG_NLS_CODEPAGE_852 is not set +# CONFIG_NLS_CODEPAGE_855 is not set +# CONFIG_NLS_CODEPAGE_857 is not set +# CONFIG_NLS_CODEPAGE_860 is not set +# CONFIG_NLS_CODEPAGE_861 is not set +# CONFIG_NLS_CODEPAGE_862 is not set +# CONFIG_NLS_CODEPAGE_863 is not set +# CONFIG_NLS_CODEPAGE_864 is not set +# CONFIG_NLS_CODEPAGE_865 is not set +# CONFIG_NLS_CODEPAGE_866 is not set +# CONFIG_NLS_CODEPAGE_869 is not set +# CONFIG_NLS_CODEPAGE_936 is not set +# CONFIG_NLS_CODEPAGE_950 is not set +# CONFIG_NLS_CODEPAGE_932 is not set +# CONFIG_NLS_CODEPAGE_949 is not set +# CONFIG_NLS_CODEPAGE_874 is not set +# CONFIG_NLS_ISO8859_8 is not set +# CONFIG_NLS_CODEPAGE_1250 is not set +# CONFIG_NLS_CODEPAGE_1251 is not set +CONFIG_NLS_ASCII=y +CONFIG_NLS_ISO8859_1=y +# CONFIG_NLS_ISO8859_2 is not set +# CONFIG_NLS_ISO8859_3 is not set +# CONFIG_NLS_ISO8859_4 is not set +# CONFIG_NLS_ISO8859_5 is not set +# CONFIG_NLS_ISO8859_6 is not set +# CONFIG_NLS_ISO8859_7 is not set +# CONFIG_NLS_ISO8859_9 is not set +# CONFIG_NLS_ISO8859_13 is not set +# CONFIG_NLS_ISO8859_14 is not set +# CONFIG_NLS_ISO8859_15 is not set +# CONFIG_NLS_KOI8_R is not set +# CONFIG_NLS_KOI8_U is not set +# CONFIG_NLS_MAC_ROMAN is not set +# CONFIG_NLS_MAC_CELTIC is not set +# CONFIG_NLS_MAC_CENTEURO is not set +# CONFIG_NLS_MAC_CROATIAN is not set +# CONFIG_NLS_MAC_CYRILLIC is not set +# CONFIG_NLS_MAC_GAELIC is not set +# CONFIG_NLS_MAC_GREEK is not set +# CONFIG_NLS_MAC_ICELAND is not set +# CONFIG_NLS_MAC_INUIT is not set +# CONFIG_NLS_MAC_ROMANIAN is not set +# CONFIG_NLS_MAC_TURKISH is not set +CONFIG_NLS_UTF8=y +# CONFIG_UNICODE is not set +CONFIG_IO_WQ=y +# end of File systems + +# +# Security options +# +CONFIG_KEYS=y +# CONFIG_KEYS_REQUEST_CACHE is not set +# CONFIG_PERSISTENT_KEYRINGS is not set +# CONFIG_BIG_KEYS is not set +# CONFIG_ENCRYPTED_KEYS is not set +# CONFIG_KEY_DH_OPERATIONS is not set +# CONFIG_SECURITY_DMESG_RESTRICT is not set +CONFIG_SECURITY=y +CONFIG_SECURITY_WRITABLE_HOOKS=y +# CONFIG_SECURITYFS is not set +CONFIG_SECURITY_NETWORK=y +CONFIG_PAGE_TABLE_ISOLATION=y +# CONFIG_SECURITY_NETWORK_XFRM is not set +# CONFIG_SECURITY_PATH is not set +# CONFIG_INTEL_TXT is not set +CONFIG_LSM_MMAP_MIN_ADDR=65536 +CONFIG_HAVE_HARDENED_USERCOPY_ALLOCATOR=y +# CONFIG_HARDENED_USERCOPY is not set +# CONFIG_FORTIFY_SOURCE is not set +# CONFIG_STATIC_USERMODEHELPER is not set +CONFIG_SECURITY_SELINUX=y +CONFIG_SECURITY_SELINUX_BOOTPARAM=y +CONFIG_SECURITY_SELINUX_DISABLE=y +CONFIG_SECURITY_SELINUX_DEVELOP=y +CONFIG_SECURITY_SELINUX_AVC_STATS=y +CONFIG_SECURITY_SELINUX_CHECKREQPROT_VALUE=0 +# CONFIG_SECURITY_SMACK is not set +# CONFIG_SECURITY_TOMOYO is not set +# CONFIG_SECURITY_APPARMOR is not set +# CONFIG_SECURITY_LOADPIN is not set +# CONFIG_SECURITY_YAMA is not set +# CONFIG_SECURITY_SAFESETID is not set +# CONFIG_SECURITY_LOCKDOWN_LSM is not set +CONFIG_INTEGRITY=y +# CONFIG_INTEGRITY_SIGNATURE is not set +CONFIG_INTEGRITY_AUDIT=y +# CONFIG_IMA is not set +# CONFIG_EVM is not set +CONFIG_DEFAULT_SECURITY_SELINUX=y +# CONFIG_DEFAULT_SECURITY_DAC is not set +CONFIG_LSM="lockdown,yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor" + +# +# Kernel hardening options +# + +# +# Memory initialization +# +CONFIG_INIT_STACK_NONE=y +# CONFIG_INIT_ON_ALLOC_DEFAULT_ON is not set +# CONFIG_INIT_ON_FREE_DEFAULT_ON is not set +# end of Memory initialization +# end of Kernel hardening options +# end of Security options + +CONFIG_CRYPTO=y + +# +# Crypto core or helper +# +CONFIG_CRYPTO_ALGAPI=y +CONFIG_CRYPTO_ALGAPI2=y +CONFIG_CRYPTO_AEAD=y +CONFIG_CRYPTO_AEAD2=y +CONFIG_CRYPTO_SKCIPHER=y +CONFIG_CRYPTO_SKCIPHER2=y +CONFIG_CRYPTO_HASH=y +CONFIG_CRYPTO_HASH2=y +CONFIG_CRYPTO_RNG=y +CONFIG_CRYPTO_RNG2=y +CONFIG_CRYPTO_RNG_DEFAULT=y +CONFIG_CRYPTO_AKCIPHER2=y +CONFIG_CRYPTO_AKCIPHER=y +CONFIG_CRYPTO_KPP2=y +CONFIG_CRYPTO_ACOMP2=y +CONFIG_CRYPTO_MANAGER=y +CONFIG_CRYPTO_MANAGER2=y +# CONFIG_CRYPTO_USER is not set +CONFIG_CRYPTO_MANAGER_DISABLE_TESTS=y +CONFIG_CRYPTO_GF128MUL=y +CONFIG_CRYPTO_NULL=y +CONFIG_CRYPTO_NULL2=y +# CONFIG_CRYPTO_PCRYPT is not set +# CONFIG_CRYPTO_CRYPTD is not set +CONFIG_CRYPTO_AUTHENC=y +# CONFIG_CRYPTO_TEST is not set + +# +# Public-key cryptography +# +CONFIG_CRYPTO_RSA=y +# CONFIG_CRYPTO_DH is not set +# CONFIG_CRYPTO_ECDH is not set +# CONFIG_CRYPTO_ECRDSA is not set +# CONFIG_CRYPTO_CURVE25519 is not set +# CONFIG_CRYPTO_CURVE25519_X86 is not set + +# +# Authenticated Encryption with Associated Data +# +CONFIG_CRYPTO_CCM=y +CONFIG_CRYPTO_GCM=y +# CONFIG_CRYPTO_CHACHA20POLY1305 is not set +# CONFIG_CRYPTO_AEGIS128 is not set +# CONFIG_CRYPTO_AEGIS128_AESNI_SSE2 is not set +CONFIG_CRYPTO_SEQIV=y +CONFIG_CRYPTO_ECHAINIV=y + +# +# Block modes +# +CONFIG_CRYPTO_CBC=y +# CONFIG_CRYPTO_CFB is not set +CONFIG_CRYPTO_CTR=y +# CONFIG_CRYPTO_CTS is not set +# CONFIG_CRYPTO_ECB is not set +# CONFIG_CRYPTO_LRW is not set +# CONFIG_CRYPTO_OFB is not set +# CONFIG_CRYPTO_PCBC is not set +# CONFIG_CRYPTO_XTS is not set +# CONFIG_CRYPTO_KEYWRAP is not set +# CONFIG_CRYPTO_NHPOLY1305_SSE2 is not set +# CONFIG_CRYPTO_NHPOLY1305_AVX2 is not set +# CONFIG_CRYPTO_ADIANTUM is not set +# CONFIG_CRYPTO_ESSIV is not set + +# +# Hash modes +# +CONFIG_CRYPTO_CMAC=y +CONFIG_CRYPTO_HMAC=y +# CONFIG_CRYPTO_XCBC is not set +# CONFIG_CRYPTO_VMAC is not set + +# +# Digest +# +CONFIG_CRYPTO_CRC32C=y +# CONFIG_CRYPTO_CRC32C_INTEL is not set +# CONFIG_CRYPTO_CRC32 is not set +# CONFIG_CRYPTO_CRC32_PCLMUL is not set +# CONFIG_CRYPTO_XXHASH is not set +# CONFIG_CRYPTO_BLAKE2B is not set +# CONFIG_CRYPTO_BLAKE2S is not set +# CONFIG_CRYPTO_BLAKE2S_X86 is not set +# CONFIG_CRYPTO_CRCT10DIF is not set +CONFIG_CRYPTO_GHASH=y +# CONFIG_CRYPTO_POLY1305 is not set +# CONFIG_CRYPTO_POLY1305_X86_64 is not set +# CONFIG_CRYPTO_MD4 is not set +CONFIG_CRYPTO_MD5=y +# CONFIG_CRYPTO_MICHAEL_MIC is not set +# CONFIG_CRYPTO_RMD128 is not set +# CONFIG_CRYPTO_RMD160 is not set +# CONFIG_CRYPTO_RMD256 is not set +# CONFIG_CRYPTO_RMD320 is not set +CONFIG_CRYPTO_SHA1=y +# CONFIG_CRYPTO_SHA1_SSSE3 is not set +# CONFIG_CRYPTO_SHA256_SSSE3 is not set +# CONFIG_CRYPTO_SHA512_SSSE3 is not set +CONFIG_CRYPTO_SHA256=y +# CONFIG_CRYPTO_SHA512 is not set +# CONFIG_CRYPTO_SHA3 is not set +# CONFIG_CRYPTO_SM3 is not set +# CONFIG_CRYPTO_STREEBOG is not set +# CONFIG_CRYPTO_TGR192 is not set +# CONFIG_CRYPTO_WP512 is not set +# CONFIG_CRYPTO_GHASH_CLMUL_NI_INTEL is not set + +# +# Ciphers +# +CONFIG_CRYPTO_AES=y +# CONFIG_CRYPTO_AES_TI is not set +# CONFIG_CRYPTO_AES_NI_INTEL is not set +# CONFIG_CRYPTO_ANUBIS is not set +# CONFIG_CRYPTO_ARC4 is not set +# CONFIG_CRYPTO_BLOWFISH is not set +# CONFIG_CRYPTO_BLOWFISH_X86_64 is not set +# CONFIG_CRYPTO_CAMELLIA is not set +# CONFIG_CRYPTO_CAMELLIA_X86_64 is not set +# CONFIG_CRYPTO_CAMELLIA_AESNI_AVX_X86_64 is not set +# CONFIG_CRYPTO_CAMELLIA_AESNI_AVX2_X86_64 is not set +# CONFIG_CRYPTO_CAST5 is not set +# CONFIG_CRYPTO_CAST5_AVX_X86_64 is not set +# CONFIG_CRYPTO_CAST6 is not set +# CONFIG_CRYPTO_CAST6_AVX_X86_64 is not set +CONFIG_CRYPTO_DES=y +# CONFIG_CRYPTO_DES3_EDE_X86_64 is not set +# CONFIG_CRYPTO_FCRYPT is not set +# CONFIG_CRYPTO_KHAZAD is not set +# CONFIG_CRYPTO_SALSA20 is not set +# CONFIG_CRYPTO_CHACHA20 is not set +# CONFIG_CRYPTO_CHACHA20_X86_64 is not set +# CONFIG_CRYPTO_SEED is not set +# CONFIG_CRYPTO_SERPENT is not set +# CONFIG_CRYPTO_SERPENT_SSE2_X86_64 is not set +# CONFIG_CRYPTO_SERPENT_AVX_X86_64 is not set +# CONFIG_CRYPTO_SERPENT_AVX2_X86_64 is not set +# CONFIG_CRYPTO_SM4 is not set +# CONFIG_CRYPTO_TEA is not set +# CONFIG_CRYPTO_TWOFISH is not set +# CONFIG_CRYPTO_TWOFISH_X86_64 is not set +# CONFIG_CRYPTO_TWOFISH_X86_64_3WAY is not set +# CONFIG_CRYPTO_TWOFISH_AVX_X86_64 is not set + +# +# Compression +# +# CONFIG_CRYPTO_DEFLATE is not set +# CONFIG_CRYPTO_LZO is not set +# CONFIG_CRYPTO_842 is not set +# CONFIG_CRYPTO_LZ4 is not set +# CONFIG_CRYPTO_LZ4HC is not set +# CONFIG_CRYPTO_ZSTD is not set + +# +# Random Number Generation +# +# CONFIG_CRYPTO_ANSI_CPRNG is not set +CONFIG_CRYPTO_DRBG_MENU=y +CONFIG_CRYPTO_DRBG_HMAC=y +# CONFIG_CRYPTO_DRBG_HASH is not set +# CONFIG_CRYPTO_DRBG_CTR is not set +CONFIG_CRYPTO_DRBG=y +CONFIG_CRYPTO_JITTERENTROPY=y +# CONFIG_CRYPTO_USER_API_HASH is not set +# CONFIG_CRYPTO_USER_API_SKCIPHER is not set +# CONFIG_CRYPTO_USER_API_RNG is not set +# CONFIG_CRYPTO_USER_API_AEAD is not set +CONFIG_CRYPTO_HASH_INFO=y + +# +# Crypto library routines +# +CONFIG_CRYPTO_LIB_AES=y +CONFIG_CRYPTO_LIB_ARC4=y +# CONFIG_CRYPTO_LIB_BLAKE2S is not set +# CONFIG_CRYPTO_LIB_CHACHA is not set +# CONFIG_CRYPTO_LIB_CURVE25519 is not set +CONFIG_CRYPTO_LIB_DES=y +CONFIG_CRYPTO_LIB_POLY1305_RSIZE=4 +# CONFIG_CRYPTO_LIB_POLY1305 is not set +# CONFIG_CRYPTO_LIB_CHACHA20POLY1305 is not set +CONFIG_CRYPTO_LIB_SHA256=y +CONFIG_CRYPTO_HW=y +# CONFIG_CRYPTO_DEV_PADLOCK is not set +# CONFIG_CRYPTO_DEV_ATMEL_ECC is not set +# CONFIG_CRYPTO_DEV_ATMEL_SHA204A is not set +# CONFIG_CRYPTO_DEV_CCP is not set +# CONFIG_CRYPTO_DEV_QAT_DH895xCC is not set +# CONFIG_CRYPTO_DEV_QAT_C3XXX is not set +# CONFIG_CRYPTO_DEV_QAT_C62X is not set +# CONFIG_CRYPTO_DEV_QAT_DH895xCCVF is not set +# CONFIG_CRYPTO_DEV_QAT_C3XXXVF is not set +# CONFIG_CRYPTO_DEV_QAT_C62XVF is not set +# CONFIG_CRYPTO_DEV_NITROX_CNN55XX is not set +# CONFIG_CRYPTO_DEV_SAFEXCEL is not set +# CONFIG_CRYPTO_DEV_AMLOGIC_GXL is not set +CONFIG_ASYMMETRIC_KEY_TYPE=y +CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE=y +CONFIG_X509_CERTIFICATE_PARSER=y +# CONFIG_PKCS8_PRIVATE_KEY_PARSER is not set +CONFIG_PKCS7_MESSAGE_PARSER=y +# CONFIG_PKCS7_TEST_KEY is not set +# CONFIG_SIGNED_PE_FILE_VERIFICATION is not set + +# +# Certificates for signature checking +# +CONFIG_SYSTEM_TRUSTED_KEYRING=y +CONFIG_SYSTEM_TRUSTED_KEYS="" +# CONFIG_SYSTEM_EXTRA_CERTIFICATE is not set +# CONFIG_SECONDARY_TRUSTED_KEYRING is not set +# CONFIG_SYSTEM_BLACKLIST_KEYRING is not set +# end of Certificates for signature checking + +CONFIG_BINARY_PRINTF=y + +# +# Library routines +# +# CONFIG_PACKING is not set +CONFIG_BITREVERSE=y +CONFIG_GENERIC_STRNCPY_FROM_USER=y +CONFIG_GENERIC_STRNLEN_USER=y +CONFIG_GENERIC_NET_UTILS=y +CONFIG_GENERIC_FIND_FIRST_BIT=y +# CONFIG_CORDIC is not set +CONFIG_RATIONAL=y +CONFIG_GENERIC_PCI_IOMAP=y +CONFIG_GENERIC_IOMAP=y +CONFIG_ARCH_USE_CMPXCHG_LOCKREF=y +CONFIG_ARCH_HAS_FAST_MULTIPLIER=y +CONFIG_CRC_CCITT=y +CONFIG_CRC16=y +# CONFIG_CRC_T10DIF is not set +# CONFIG_CRC_ITU_T is not set +CONFIG_CRC32=y +# CONFIG_CRC32_SELFTEST is not set +CONFIG_CRC32_SLICEBY8=y +# CONFIG_CRC32_SLICEBY4 is not set +# CONFIG_CRC32_SARWATE is not set +# CONFIG_CRC32_BIT is not set +# CONFIG_CRC64 is not set +# CONFIG_CRC4 is not set +# CONFIG_CRC7 is not set +CONFIG_LIBCRC32C=y +# CONFIG_CRC8 is not set +# CONFIG_RANDOM32_SELFTEST is not set +CONFIG_ZLIB_INFLATE=y +CONFIG_ZLIB_DEFLATE=y +CONFIG_LZO_COMPRESS=y +CONFIG_LZO_DECOMPRESS=y +CONFIG_LZ4_DECOMPRESS=y +CONFIG_XZ_DEC=y +CONFIG_XZ_DEC_X86=y +CONFIG_XZ_DEC_POWERPC=y +CONFIG_XZ_DEC_IA64=y +CONFIG_XZ_DEC_ARM=y +CONFIG_XZ_DEC_ARMTHUMB=y +CONFIG_XZ_DEC_SPARC=y +CONFIG_XZ_DEC_BCJ=y +# CONFIG_XZ_DEC_TEST is not set +CONFIG_DECOMPRESS_GZIP=y +CONFIG_DECOMPRESS_BZIP2=y +CONFIG_DECOMPRESS_LZMA=y +CONFIG_DECOMPRESS_XZ=y +CONFIG_DECOMPRESS_LZO=y +CONFIG_DECOMPRESS_LZ4=y +CONFIG_GENERIC_ALLOCATOR=y +CONFIG_INTERVAL_TREE=y +CONFIG_ASSOCIATIVE_ARRAY=y +CONFIG_HAS_IOMEM=y +CONFIG_HAS_IOPORT_MAP=y +CONFIG_HAS_DMA=y +CONFIG_NEED_SG_DMA_LENGTH=y +CONFIG_NEED_DMA_MAP_STATE=y +CONFIG_ARCH_DMA_ADDR_T_64BIT=y +CONFIG_SWIOTLB=y +# CONFIG_DMA_API_DEBUG is not set +CONFIG_SGL_ALLOC=y +CONFIG_CHECK_SIGNATURE=y +CONFIG_CPU_RMAP=y +CONFIG_DQL=y +CONFIG_GLOB=y +# CONFIG_GLOB_SELFTEST is not set +CONFIG_NLATTR=y +CONFIG_CLZ_TAB=y +# CONFIG_IRQ_POLL is not set +CONFIG_MPILIB=y +CONFIG_OID_REGISTRY=y +CONFIG_UCS2_STRING=y +CONFIG_HAVE_GENERIC_VDSO=y +CONFIG_GENERIC_GETTIMEOFDAY=y +CONFIG_FONT_SUPPORT=y +# CONFIG_FONTS is not set +CONFIG_FONT_8x8=y +CONFIG_FONT_8x16=y +CONFIG_SG_POOL=y +CONFIG_ARCH_HAS_PMEM_API=y +CONFIG_ARCH_HAS_UACCESS_FLUSHCACHE=y +CONFIG_ARCH_HAS_UACCESS_MCSAFE=y +CONFIG_ARCH_STACKWALK=y +CONFIG_SBITMAP=y +# CONFIG_STRING_SELFTEST is not set +# end of Library routines + +# +# Kernel hacking +# + +# +# printk and dmesg options +# +CONFIG_PRINTK_TIME=y +# CONFIG_PRINTK_CALLER is not set +CONFIG_CONSOLE_LOGLEVEL_DEFAULT=7 +CONFIG_CONSOLE_LOGLEVEL_QUIET=4 +CONFIG_MESSAGE_LOGLEVEL_DEFAULT=4 +# CONFIG_BOOT_PRINTK_DELAY is not set +# CONFIG_DYNAMIC_DEBUG is not set +CONFIG_SYMBOLIC_ERRNAME=y +CONFIG_DEBUG_BUGVERBOSE=y +# end of printk and dmesg options + +# +# Compile-time checks and compiler options +# +CONFIG_DEBUG_INFO=y +# CONFIG_DEBUG_INFO_REDUCED is not set +# CONFIG_DEBUG_INFO_SPLIT is not set +# CONFIG_DEBUG_INFO_DWARF4 is not set +CONFIG_DEBUG_INFO_BTF=y +# CONFIG_GDB_SCRIPTS is not set +CONFIG_ENABLE_MUST_CHECK=y +CONFIG_FRAME_WARN=2048 +# CONFIG_STRIP_ASM_SYMS is not set +# CONFIG_READABLE_ASM is not set +# CONFIG_HEADERS_INSTALL is not set +CONFIG_OPTIMIZE_INLINING=y +# CONFIG_DEBUG_SECTION_MISMATCH is not set +CONFIG_SECTION_MISMATCH_WARN_ONLY=y +CONFIG_STACK_VALIDATION=y +# CONFIG_DEBUG_FORCE_WEAK_PER_CPU is not set +# end of Compile-time checks and compiler options + +# +# Generic Kernel Debugging Instruments +# +CONFIG_MAGIC_SYSRQ=y +CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE=0x1 +CONFIG_MAGIC_SYSRQ_SERIAL=y +CONFIG_DEBUG_FS=y +CONFIG_HAVE_ARCH_KGDB=y +# CONFIG_KGDB is not set +CONFIG_ARCH_HAS_UBSAN_SANITIZE_ALL=y +# CONFIG_UBSAN is not set +CONFIG_UBSAN_ALIGNMENT=y +# end of Generic Kernel Debugging Instruments + +CONFIG_DEBUG_KERNEL=y +CONFIG_DEBUG_MISC=y + +# +# Memory Debugging +# +# CONFIG_PAGE_EXTENSION is not set +# CONFIG_DEBUG_PAGEALLOC is not set +# CONFIG_PAGE_OWNER is not set +# CONFIG_PAGE_POISONING is not set +# CONFIG_DEBUG_PAGE_REF is not set +# CONFIG_DEBUG_RODATA_TEST is not set +# CONFIG_DEBUG_OBJECTS is not set +# CONFIG_SLUB_DEBUG_ON is not set +# CONFIG_SLUB_STATS is not set +CONFIG_HAVE_DEBUG_KMEMLEAK=y +# CONFIG_DEBUG_KMEMLEAK is not set +CONFIG_DEBUG_STACK_USAGE=y +# CONFIG_SCHED_STACK_END_CHECK is not set +# CONFIG_DEBUG_VM is not set +CONFIG_ARCH_HAS_DEBUG_VIRTUAL=y +# CONFIG_DEBUG_VIRTUAL is not set +CONFIG_DEBUG_MEMORY_INIT=y +# CONFIG_DEBUG_PER_CPU_MAPS is not set +CONFIG_HAVE_ARCH_KASAN=y +CONFIG_HAVE_ARCH_KASAN_VMALLOC=y +CONFIG_CC_HAS_KASAN_GENERIC=y +# CONFIG_KASAN is not set +CONFIG_KASAN_STACK=1 +# end of Memory Debugging + +# CONFIG_DEBUG_SHIRQ is not set + +# +# Debug Oops, Lockups and Hangs +# +# CONFIG_PANIC_ON_OOPS is not set +CONFIG_PANIC_ON_OOPS_VALUE=0 +CONFIG_PANIC_TIMEOUT=0 +# CONFIG_SOFTLOCKUP_DETECTOR is not set +CONFIG_HARDLOCKUP_CHECK_TIMESTAMP=y +# CONFIG_HARDLOCKUP_DETECTOR is not set +# CONFIG_DETECT_HUNG_TASK is not set +# CONFIG_WQ_WATCHDOG is not set +# end of Debug Oops, Lockups and Hangs + +# +# Scheduler Debugging +# +# CONFIG_SCHED_DEBUG is not set +CONFIG_SCHED_INFO=y +CONFIG_SCHEDSTATS=y +# end of Scheduler Debugging + +# CONFIG_DEBUG_TIMEKEEPING is not set + +# +# Lock Debugging (spinlocks, mutexes, etc...) +# +CONFIG_LOCK_DEBUGGING_SUPPORT=y +# CONFIG_PROVE_LOCKING is not set +# CONFIG_LOCK_STAT is not set +# CONFIG_DEBUG_RT_MUTEXES is not set +# CONFIG_DEBUG_SPINLOCK is not set +# CONFIG_DEBUG_MUTEXES is not set +# CONFIG_DEBUG_WW_MUTEX_SLOWPATH is not set +# CONFIG_DEBUG_RWSEMS is not set +# CONFIG_DEBUG_LOCK_ALLOC is not set +# CONFIG_DEBUG_ATOMIC_SLEEP is not set +# CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set +# CONFIG_LOCK_TORTURE_TEST is not set +# CONFIG_WW_MUTEX_SELFTEST is not set +# end of Lock Debugging (spinlocks, mutexes, etc...) + +CONFIG_STACKTRACE=y +# CONFIG_WARN_ALL_UNSEEDED_RANDOM is not set +# CONFIG_DEBUG_KOBJECT is not set + +# +# Debug kernel data structures +# +# CONFIG_DEBUG_LIST is not set +# CONFIG_DEBUG_PLIST is not set +# CONFIG_DEBUG_SG is not set +# CONFIG_DEBUG_NOTIFIERS is not set +# CONFIG_BUG_ON_DATA_CORRUPTION is not set +# end of Debug kernel data structures + +# CONFIG_DEBUG_CREDENTIALS is not set + +# +# RCU Debugging +# +# CONFIG_RCU_PERF_TEST is not set +# CONFIG_RCU_TORTURE_TEST is not set +CONFIG_RCU_CPU_STALL_TIMEOUT=21 +CONFIG_RCU_TRACE=y +# CONFIG_RCU_EQS_DEBUG is not set +# end of RCU Debugging + +# CONFIG_DEBUG_WQ_FORCE_RR_CPU is not set +# CONFIG_DEBUG_BLOCK_EXT_DEVT is not set +# CONFIG_CPU_HOTPLUG_STATE_CONTROL is not set +# CONFIG_LATENCYTOP is not set +CONFIG_USER_STACKTRACE_SUPPORT=y +CONFIG_NOP_TRACER=y +CONFIG_HAVE_FUNCTION_TRACER=y +CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y +CONFIG_HAVE_DYNAMIC_FTRACE=y +CONFIG_HAVE_DYNAMIC_FTRACE_WITH_REGS=y +CONFIG_HAVE_DYNAMIC_FTRACE_WITH_DIRECT_CALLS=y +CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y +CONFIG_HAVE_SYSCALL_TRACEPOINTS=y +CONFIG_HAVE_FENTRY=y +CONFIG_HAVE_C_RECORDMCOUNT=y +CONFIG_TRACE_CLOCK=y +CONFIG_RING_BUFFER=y +CONFIG_EVENT_TRACING=y +CONFIG_CONTEXT_SWITCH_TRACER=y +CONFIG_TRACING=y +CONFIG_GENERIC_TRACER=y +CONFIG_TRACING_SUPPORT=y +CONFIG_FTRACE=y +# CONFIG_FUNCTION_TRACER is not set +# CONFIG_PREEMPTIRQ_EVENTS is not set +# CONFIG_IRQSOFF_TRACER is not set +# CONFIG_SCHED_TRACER is not set +# CONFIG_HWLAT_TRACER is not set +# CONFIG_FTRACE_SYSCALLS is not set +# CONFIG_TRACER_SNAPSHOT is not set +CONFIG_BRANCH_PROFILE_NONE=y +# CONFIG_PROFILE_ANNOTATED_BRANCHES is not set +# CONFIG_PROFILE_ALL_BRANCHES is not set +# CONFIG_STACK_TRACER is not set +CONFIG_BLK_DEV_IO_TRACE=y +CONFIG_KPROBE_EVENTS=y +CONFIG_UPROBE_EVENTS=y +CONFIG_BPF_EVENTS=y +CONFIG_DYNAMIC_EVENTS=y +CONFIG_PROBE_EVENTS=y +CONFIG_BPF_KPROBE_OVERRIDE=y +# CONFIG_FTRACE_STARTUP_TEST is not set +# CONFIG_MMIOTRACE is not set +# CONFIG_HIST_TRIGGERS is not set +# CONFIG_TRACE_EVENT_INJECT is not set +# CONFIG_TRACEPOINT_BENCHMARK is not set +# CONFIG_RING_BUFFER_BENCHMARK is not set +# CONFIG_RING_BUFFER_STARTUP_TEST is not set +# CONFIG_PREEMPTIRQ_DELAY_TEST is not set +# CONFIG_TRACE_EVAL_MAP_FILE is not set +CONFIG_PROVIDE_OHCI1394_DMA_INIT=y +# CONFIG_SAMPLES is not set +CONFIG_ARCH_HAS_DEVMEM_IS_ALLOWED=y +CONFIG_STRICT_DEVMEM=y +# CONFIG_IO_STRICT_DEVMEM is not set + +# +# x86 Debugging +# +CONFIG_TRACE_IRQFLAGS_SUPPORT=y +CONFIG_EARLY_PRINTK_USB=y +CONFIG_X86_VERBOSE_BOOTUP=y +CONFIG_EARLY_PRINTK=y +CONFIG_EARLY_PRINTK_DBGP=y +# CONFIG_EARLY_PRINTK_USB_XDBC is not set +# CONFIG_X86_PTDUMP is not set +# CONFIG_EFI_PGT_DUMP is not set +# CONFIG_DEBUG_WX is not set +CONFIG_DOUBLEFAULT=y +# CONFIG_DEBUG_TLBFLUSH is not set +CONFIG_HAVE_MMIOTRACE_SUPPORT=y +# CONFIG_X86_DECODER_SELFTEST is not set +CONFIG_IO_DELAY_0X80=y +# CONFIG_IO_DELAY_0XED is not set +# CONFIG_IO_DELAY_UDELAY is not set +# CONFIG_IO_DELAY_NONE is not set +CONFIG_DEBUG_BOOT_PARAMS=y +# CONFIG_CPA_DEBUG is not set +# CONFIG_DEBUG_ENTRY is not set +# CONFIG_DEBUG_NMI_SELFTEST is not set +CONFIG_X86_DEBUG_FPU=y +# CONFIG_PUNIT_ATOM_DEBUG is not set +CONFIG_UNWINDER_ORC=y +# CONFIG_UNWINDER_FRAME_POINTER is not set +# end of x86 Debugging + +# +# Kernel Testing and Coverage +# +# CONFIG_KUNIT is not set +# CONFIG_NOTIFIER_ERROR_INJECTION is not set +CONFIG_FUNCTION_ERROR_INJECTION=y +# CONFIG_FAULT_INJECTION is not set +CONFIG_ARCH_HAS_KCOV=y +CONFIG_CC_HAS_SANCOV_TRACE_PC=y +# CONFIG_KCOV is not set +CONFIG_RUNTIME_TESTING_MENU=y +# CONFIG_LKDTM is not set +# CONFIG_TEST_LIST_SORT is not set +# CONFIG_TEST_SORT is not set +# CONFIG_KPROBES_SANITY_TEST is not set +# CONFIG_BACKTRACE_SELF_TEST is not set +# CONFIG_RBTREE_TEST is not set +# CONFIG_REED_SOLOMON_TEST is not set +# CONFIG_INTERVAL_TREE_TEST is not set +# CONFIG_PERCPU_TEST is not set +# CONFIG_ATOMIC64_SELFTEST is not set +# CONFIG_TEST_HEXDUMP is not set +# CONFIG_TEST_STRING_HELPERS is not set +# CONFIG_TEST_STRSCPY is not set +# CONFIG_TEST_KSTRTOX is not set +# CONFIG_TEST_PRINTF is not set +# CONFIG_TEST_BITMAP is not set +# CONFIG_TEST_BITFIELD is not set +# CONFIG_TEST_UUID is not set +# CONFIG_TEST_XARRAY is not set +# CONFIG_TEST_OVERFLOW is not set +# CONFIG_TEST_RHASHTABLE is not set +# CONFIG_TEST_HASH is not set +# CONFIG_TEST_IDA is not set +# CONFIG_TEST_LKM is not set +# CONFIG_TEST_VMALLOC is not set +# CONFIG_TEST_USER_COPY is not set +# CONFIG_TEST_BPF is not set +# CONFIG_TEST_BLACKHOLE_DEV is not set +# CONFIG_FIND_BIT_BENCHMARK is not set +# CONFIG_TEST_FIRMWARE is not set +# CONFIG_TEST_SYSCTL is not set +# CONFIG_TEST_UDELAY is not set +# CONFIG_TEST_STATIC_KEYS is not set +# CONFIG_TEST_KMOD is not set +# CONFIG_TEST_MEMCAT_P is not set +# CONFIG_TEST_STACKINIT is not set +# CONFIG_TEST_MEMINIT is not set +# CONFIG_MEMTEST is not set +# end of Kernel Testing and Coverage +# end of Kernel hacking diff --git a/libbpf-tools/vmlinux_505.h b/libbpf-tools/vmlinux_505.h index 092bd646d..7c2aaa742 100644 --- a/libbpf-tools/vmlinux_505.h +++ b/libbpf-tools/vmlinux_505.h @@ -139,6 +139,149 @@ struct callback_head { void (*func)(struct callback_head *); }; +typedef int initcall_entry_t; + +struct lock_class_key {}; + +struct fs_context; + +struct fs_parameter_description; + +struct dentry; + +struct super_block; + +struct module; + +struct file_system_type { + const char *name; + int fs_flags; + int (*init_fs_context)(struct fs_context *); + const struct fs_parameter_description *parameters; + struct dentry * (*mount)(struct file_system_type *, int, const char *, void *); + void (*kill_sb)(struct super_block *); + struct module *owner; + struct file_system_type *next; + struct hlist_head fs_supers; + struct lock_class_key s_lock_key; + struct lock_class_key s_umount_key; + struct lock_class_key s_vfs_rename_key; + struct lock_class_key s_writers_key[3]; + struct lock_class_key i_lock_key; + struct lock_class_key i_mutex_key; + struct lock_class_key i_mutex_dir_key; +}; + +typedef void *fl_owner_t; + +struct file; + +struct kiocb; + +struct iov_iter; + +struct dir_context; + +struct poll_table_struct; + +struct vm_area_struct; + +struct inode; + +struct file_lock; + +struct page; + +struct pipe_inode_info; + +struct seq_file; + +struct file_operations { + struct module *owner; + loff_t (*llseek)(struct file *, loff_t, int); + ssize_t (*read)(struct file *, char *, size_t, loff_t *); + ssize_t (*write)(struct file *, const char *, size_t, loff_t *); + ssize_t (*read_iter)(struct kiocb *, struct iov_iter *); + ssize_t (*write_iter)(struct kiocb *, struct iov_iter *); + int (*iopoll)(struct kiocb *, bool); + int (*iterate)(struct file *, struct dir_context *); + int (*iterate_shared)(struct file *, struct dir_context *); + __poll_t (*poll)(struct file *, struct poll_table_struct *); + long int (*unlocked_ioctl)(struct file *, unsigned int, long unsigned int); + long int (*compat_ioctl)(struct file *, unsigned int, long unsigned int); + int (*mmap)(struct file *, struct vm_area_struct *); + long unsigned int mmap_supported_flags; + int (*open)(struct inode *, struct file *); + int (*flush)(struct file *, fl_owner_t); + int (*release)(struct inode *, struct file *); + int (*fsync)(struct file *, loff_t, loff_t, int); + int (*fasync)(int, struct file *, int); + int (*lock)(struct file *, int, struct file_lock *); + ssize_t (*sendpage)(struct file *, struct page *, int, size_t, loff_t *, int); + long unsigned int (*get_unmapped_area)(struct file *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); + int (*check_flags)(int); + int (*flock)(struct file *, int, struct file_lock *); + ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int); + ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); + int (*setlease)(struct file *, long int, struct file_lock **, void **); + long int (*fallocate)(struct file *, int, loff_t, loff_t); + void (*show_fdinfo)(struct seq_file *, struct file *); + ssize_t (*copy_file_range)(struct file *, loff_t, struct file *, loff_t, size_t, unsigned int); + loff_t (*remap_file_range)(struct file *, loff_t, struct file *, loff_t, loff_t, unsigned int); + int (*fadvise)(struct file *, loff_t, loff_t, int); +}; + +struct qspinlock { + union { + atomic_t val; + struct { + u8 locked; + u8 pending; + }; + struct { + u16 locked_pending; + u16 tail; + }; + }; +}; + +typedef struct qspinlock arch_spinlock_t; + +struct raw_spinlock { + arch_spinlock_t raw_lock; +}; + +struct spinlock { + union { + struct raw_spinlock rlock; + }; +}; + +typedef struct spinlock spinlock_t; + +struct notifier_block; + +struct atomic_notifier_head { + spinlock_t lock; + struct notifier_block *head; +}; + +enum system_states { + SYSTEM_BOOTING = 0, + SYSTEM_SCHEDULING = 1, + SYSTEM_RUNNING = 2, + SYSTEM_HALT = 3, + SYSTEM_POWER_OFF = 4, + SYSTEM_RESTART = 5, + SYSTEM_SUSPEND = 6, +}; + +struct taint_flag { + char c_true; + char c_false; + bool module; +}; + struct jump_entry { s32 code; s32 target; @@ -156,6 +299,10 @@ struct static_key { }; }; +struct static_key_true { + struct static_key key; +}; + struct static_key_false { struct static_key key; }; @@ -167,6 +314,11 @@ struct __kernel_timespec { long long int tv_nsec; }; +struct timezone { + int tz_minuteswest; + int tz_dsttime; +}; + struct timespec64 { time64_t tv_sec; long int tv_nsec; @@ -217,494 +369,299 @@ struct restart_block { }; }; -struct screen_info { - __u8 orig_x; - __u8 orig_y; - __u16 ext_mem_k; - __u16 orig_video_page; - __u8 orig_video_mode; - __u8 orig_video_cols; - __u8 flags; - __u8 unused2; - __u16 orig_video_ega_bx; - __u16 unused3; - __u8 orig_video_lines; - __u8 orig_video_isVGA; - __u16 orig_video_points; - __u16 lfb_width; - __u16 lfb_height; - __u16 lfb_depth; - __u32 lfb_base; - __u32 lfb_size; - __u16 cl_magic; - __u16 cl_offset; - __u16 lfb_linelength; - __u8 red_size; - __u8 red_pos; - __u8 green_size; - __u8 green_pos; - __u8 blue_size; - __u8 blue_pos; - __u8 rsvd_size; - __u8 rsvd_pos; - __u16 vesapm_seg; - __u16 vesapm_off; - __u16 pages; - __u16 vesa_attributes; - __u32 capabilities; - __u32 ext_lfb_base; - __u8 _reserved[2]; -} __attribute__((packed)); - -struct apm_bios_info { - __u16 version; - __u16 cseg; - __u32 offset; - __u16 cseg_16; - __u16 dseg; - __u16 flags; - __u16 cseg_len; - __u16 cseg_16_len; - __u16 dseg_len; +struct thread_info { + long unsigned int flags; + u32 status; }; -struct edd_device_params { - __u16 length; - __u16 info_flags; - __u32 num_default_cylinders; - __u32 num_default_heads; - __u32 sectors_per_track; - __u64 number_of_sectors; - __u16 bytes_per_sector; - __u32 dpte_ptr; - __u16 key; - __u8 device_path_info_length; - __u8 reserved2; - __u16 reserved3; - __u8 host_bus_type[4]; - __u8 interface_type[8]; - union { - struct { - __u16 base_address; - __u16 reserved1; - __u32 reserved2; - } isa; - struct { - __u8 bus; - __u8 slot; - __u8 function; - __u8 channel; - __u32 reserved; - } pci; - struct { - __u64 reserved; - } ibnd; - struct { - __u64 reserved; - } xprs; - struct { - __u64 reserved; - } htpt; - struct { - __u64 reserved; - } unknown; - } interface_path; - union { - struct { - __u8 device; - __u8 reserved1; - __u16 reserved2; - __u32 reserved3; - __u64 reserved4; - } ata; - struct { - __u8 device; - __u8 lun; - __u8 reserved1; - __u8 reserved2; - __u32 reserved3; - __u64 reserved4; - } atapi; - struct { - __u16 id; - __u64 lun; - __u16 reserved1; - __u32 reserved2; - } __attribute__((packed)) scsi; - struct { - __u64 serial_number; - __u64 reserved; - } usb; - struct { - __u64 eui; - __u64 reserved; - } i1394; - struct { - __u64 wwid; - __u64 lun; - } fibre; - struct { - __u64 identity_tag; - __u64 reserved; - } i2o; - struct { - __u32 array_number; - __u32 reserved1; - __u64 reserved2; - } raid; - struct { - __u8 device; - __u8 reserved1; - __u16 reserved2; - __u32 reserved3; - __u64 reserved4; - } sata; - struct { - __u64 reserved1; - __u64 reserved2; - } unknown; - } device_path; - __u8 reserved4; - __u8 checksum; -} __attribute__((packed)); +struct refcount_struct { + atomic_t refs; +}; -struct edd_info { - __u8 device; - __u8 version; - __u16 interface_support; - __u16 legacy_max_cylinder; - __u8 legacy_max_head; - __u8 legacy_sectors_per_track; - struct edd_device_params params; -} __attribute__((packed)); +typedef struct refcount_struct refcount_t; -struct ist_info { - __u32 signature; - __u32 command; - __u32 event; - __u32 perf_level; +struct llist_node { + struct llist_node *next; }; -struct edid_info { - unsigned char dummy[128]; +struct load_weight { + long unsigned int weight; + u32 inv_weight; }; -struct setup_header { - __u8 setup_sects; - __u16 root_flags; - __u32 syssize; - __u16 ram_size; - __u16 vid_mode; - __u16 root_dev; - __u16 boot_flag; - __u16 jump; - __u32 header; - __u16 version; - __u32 realmode_swtch; - __u16 start_sys_seg; - __u16 kernel_version; - __u8 type_of_loader; - __u8 loadflags; - __u16 setup_move_size; - __u32 code32_start; - __u32 ramdisk_image; - __u32 ramdisk_size; - __u32 bootsect_kludge; - __u16 heap_end_ptr; - __u8 ext_loader_ver; - __u8 ext_loader_type; - __u32 cmd_line_ptr; - __u32 initrd_addr_max; - __u32 kernel_alignment; - __u8 relocatable_kernel; - __u8 min_alignment; - __u16 xloadflags; - __u32 cmdline_size; - __u32 hardware_subarch; - __u64 hardware_subarch_data; - __u32 payload_offset; - __u32 payload_length; - __u64 setup_data; - __u64 pref_address; - __u32 init_size; - __u32 handover_offset; - __u32 kernel_info_offset; -} __attribute__((packed)); +struct rb_node { + long unsigned int __rb_parent_color; + struct rb_node *rb_right; + struct rb_node *rb_left; +}; -struct sys_desc_table { - __u16 length; - __u8 table[14]; +struct sched_statistics { + u64 wait_start; + u64 wait_max; + u64 wait_count; + u64 wait_sum; + u64 iowait_count; + u64 iowait_sum; + u64 sleep_start; + u64 sleep_max; + s64 sum_sleep_runtime; + u64 block_start; + u64 block_max; + u64 exec_max; + u64 slice_max; + u64 nr_migrations_cold; + u64 nr_failed_migrations_affine; + u64 nr_failed_migrations_running; + u64 nr_failed_migrations_hot; + u64 nr_forced_migrations; + u64 nr_wakeups; + u64 nr_wakeups_sync; + u64 nr_wakeups_migrate; + u64 nr_wakeups_local; + u64 nr_wakeups_remote; + u64 nr_wakeups_affine; + u64 nr_wakeups_affine_attempts; + u64 nr_wakeups_passive; + u64 nr_wakeups_idle; }; -struct olpc_ofw_header { - __u32 ofw_magic; - __u32 ofw_version; - __u32 cif_handler; - __u32 irq_desc_table; +struct util_est { + unsigned int enqueued; + unsigned int ewma; }; -struct efi_info { - __u32 efi_loader_signature; - __u32 efi_systab; - __u32 efi_memdesc_size; - __u32 efi_memdesc_version; - __u32 efi_memmap; - __u32 efi_memmap_size; - __u32 efi_systab_hi; - __u32 efi_memmap_hi; +struct sched_avg { + u64 last_update_time; + u64 load_sum; + u64 runnable_load_sum; + u32 util_sum; + u32 period_contrib; + long unsigned int load_avg; + long unsigned int runnable_load_avg; + long unsigned int util_avg; + struct util_est util_est; }; -struct boot_e820_entry { - __u64 addr; - __u64 size; - __u32 type; -} __attribute__((packed)); +struct cfs_rq; -struct boot_params { - struct screen_info screen_info; - struct apm_bios_info apm_bios_info; - __u8 _pad2[4]; - __u64 tboot_addr; - struct ist_info ist_info; - __u64 acpi_rsdp_addr; - __u8 _pad3[8]; - __u8 hd0_info[16]; - __u8 hd1_info[16]; - struct sys_desc_table sys_desc_table; - struct olpc_ofw_header olpc_ofw_header; - __u32 ext_ramdisk_image; - __u32 ext_ramdisk_size; - __u32 ext_cmd_line_ptr; - __u8 _pad4[116]; - struct edid_info edid_info; - struct efi_info efi_info; - __u32 alt_mem_k; - __u32 scratch; - __u8 e820_entries; - __u8 eddbuf_entries; - __u8 edd_mbr_sig_buf_entries; - __u8 kbd_status; - __u8 secure_boot; - __u8 _pad5[2]; - __u8 sentinel; - __u8 _pad6[1]; - struct setup_header hdr; - __u8 _pad7[36]; - __u32 edd_mbr_sig_buffer[16]; - struct boot_e820_entry e820_table[128]; - __u8 _pad8[48]; - struct edd_info eddbuf[6]; - __u8 _pad9[276]; -} __attribute__((packed)); +struct sched_entity { + struct load_weight load; + long unsigned int runnable_weight; + struct rb_node run_node; + struct list_head group_node; + unsigned int on_rq; + u64 exec_start; + u64 sum_exec_runtime; + u64 vruntime; + u64 prev_sum_exec_runtime; + u64 nr_migrations; + struct sched_statistics statistics; + int depth; + struct sched_entity *parent; + struct cfs_rq *cfs_rq; + struct cfs_rq *my_q; + long: 64; + long: 64; + long: 64; + struct sched_avg avg; +}; -enum x86_hardware_subarch { - X86_SUBARCH_PC = 0, - X86_SUBARCH_LGUEST = 1, - X86_SUBARCH_XEN = 2, - X86_SUBARCH_INTEL_MID = 3, - X86_SUBARCH_CE4100 = 4, - X86_NR_SUBARCHS = 5, +struct sched_rt_entity { + struct list_head run_list; + long unsigned int timeout; + long unsigned int watchdog_stamp; + unsigned int time_slice; + short unsigned int on_rq; + short unsigned int on_list; + struct sched_rt_entity *back; }; -struct pt_regs { - long unsigned int r15; - long unsigned int r14; - long unsigned int r13; - long unsigned int r12; - long unsigned int bp; - long unsigned int bx; - long unsigned int r11; - long unsigned int r10; - long unsigned int r9; - long unsigned int r8; - long unsigned int ax; - long unsigned int cx; - long unsigned int dx; - long unsigned int si; - long unsigned int di; - long unsigned int orig_ax; - long unsigned int ip; - long unsigned int cs; - long unsigned int flags; - long unsigned int sp; - long unsigned int ss; +typedef s64 ktime_t; + +struct timerqueue_node { + struct rb_node node; + ktime_t expires; }; -struct math_emu_info { - long int ___orig_eip; - struct pt_regs *regs; +enum hrtimer_restart { + HRTIMER_NORESTART = 0, + HRTIMER_RESTART = 1, }; -typedef long unsigned int pteval_t; +struct hrtimer_clock_base; -typedef long unsigned int pmdval_t; +struct hrtimer { + struct timerqueue_node node; + ktime_t _softexpires; + enum hrtimer_restart (*function)(struct hrtimer *); + struct hrtimer_clock_base *base; + u8 state; + u8 is_rel; + u8 is_soft; + u8 is_hard; +}; -typedef long unsigned int pudval_t; +struct sched_dl_entity { + struct rb_node rb_node; + u64 dl_runtime; + u64 dl_deadline; + u64 dl_period; + u64 dl_bw; + u64 dl_density; + s64 runtime; + u64 deadline; + unsigned int flags; + unsigned int dl_throttled: 1; + unsigned int dl_boosted: 1; + unsigned int dl_yielded: 1; + unsigned int dl_non_contending: 1; + unsigned int dl_overrun: 1; + struct hrtimer dl_timer; + struct hrtimer inactive_timer; +}; -typedef long unsigned int p4dval_t; +struct cpumask { + long unsigned int bits[1]; +}; -typedef long unsigned int pgdval_t; +typedef struct cpumask cpumask_t; -typedef long unsigned int pgprotval_t; +struct sched_info { + long unsigned int pcount; + long long unsigned int run_delay; + long long unsigned int last_arrival; + long long unsigned int last_queued; +}; -typedef struct { - pteval_t pte; -} pte_t; +struct plist_node { + int prio; + struct list_head prio_list; + struct list_head node_list; +}; -struct pgprot { - pgprotval_t pgprot; +struct vmacache { + u64 seqnum; + struct vm_area_struct *vmas[4]; }; -typedef struct pgprot pgprot_t; +struct task_rss_stat { + int events; + int count[4]; +}; -typedef struct { - pgdval_t pgd; -} pgd_t; +typedef struct raw_spinlock raw_spinlock_t; -typedef struct { - p4dval_t p4d; -} p4d_t; +struct prev_cputime { + u64 utime; + u64 stime; + raw_spinlock_t lock; +}; -typedef struct { - pudval_t pud; -} pud_t; +struct rb_root { + struct rb_node *rb_node; +}; -typedef struct { - pmdval_t pmd; -} pmd_t; +struct rb_root_cached { + struct rb_root rb_root; + struct rb_node *rb_leftmost; +}; -struct page; +struct timerqueue_head { + struct rb_root_cached rb_root; +}; -typedef struct page *pgtable_t; +struct posix_cputimer_base { + u64 nextevt; + struct timerqueue_head tqhead; +}; -struct qspinlock { - union { - atomic_t val; - struct { - u8 locked; - u8 pending; - }; - struct { - u16 locked_pending; - u16 tail; - }; - }; +struct posix_cputimers { + struct posix_cputimer_base bases[3]; + unsigned int timers_active; + unsigned int expiry_active; }; -typedef struct qspinlock arch_spinlock_t; +struct sem_undo_list; -struct raw_spinlock { - arch_spinlock_t raw_lock; +struct sysv_sem { + struct sem_undo_list *undo_list; }; -struct spinlock { - union { - struct raw_spinlock rlock; - }; +struct sysv_shm { + struct list_head shm_clist; }; -typedef struct spinlock spinlock_t; +typedef struct { + long unsigned int sig[1]; +} sigset_t; -struct address_space; +struct sigpending { + struct list_head list; + sigset_t signal; +}; -struct kmem_cache; +typedef struct { + uid_t val; +} kuid_t; -struct mm_struct; +struct seccomp_filter; -struct dev_pagemap; +struct seccomp { + int mode; + struct seccomp_filter *filter; +}; -struct page { - long unsigned int flags; - union { - struct { - struct list_head lru; - struct address_space *mapping; - long unsigned int index; - long unsigned int private; - }; - struct { - dma_addr_t dma_addr; - }; - struct { - union { - struct list_head slab_list; - struct { - struct page *next; - int pages; - int pobjects; - }; - }; - struct kmem_cache *slab_cache; - void *freelist; - union { - void *s_mem; - long unsigned int counters; - struct { - unsigned int inuse: 16; - unsigned int objects: 15; - unsigned int frozen: 1; - }; - }; - }; - struct { - long unsigned int compound_head; - unsigned char compound_dtor; - unsigned char compound_order; - atomic_t compound_mapcount; - }; - struct { - long unsigned int _compound_pad_1; - long unsigned int _compound_pad_2; - struct list_head deferred_list; - }; - struct { - long unsigned int _pt_pad_1; - pgtable_t pmd_huge_pte; - long unsigned int _pt_pad_2; - union { - struct mm_struct *pt_mm; - atomic_t pt_frag_refcount; - }; - spinlock_t ptl; - }; - struct { - struct dev_pagemap *pgmap; - void *zone_device_data; - }; - struct callback_head callback_head; - }; - union { - atomic_t _mapcount; - unsigned int page_type; - unsigned int active; - int units; - }; - atomic_t _refcount; - long: 64; +struct wake_q_node { + struct wake_q_node *next; }; -typedef atomic64_t atomic_long_t; +struct task_io_accounting { + u64 rchar; + u64 wchar; + u64 syscr; + u64 syscw; + u64 read_bytes; + u64 write_bytes; + u64 cancelled_write_bytes; +}; -struct cpumask { +typedef struct { long unsigned int bits[1]; +} nodemask_t; + +struct seqcount { + unsigned int sequence; }; -typedef struct cpumask cpumask_t; +typedef struct seqcount seqcount_t; -typedef struct cpumask cpumask_var_t[1]; +typedef atomic64_t atomic_long_t; -struct tracepoint_func { - void *func; - void *data; - int prio; +struct optimistic_spin_queue { + atomic_t tail; }; -struct tracepoint { - const char *name; - struct static_key key; - int (*regfunc)(); - void (*unregfunc)(); - struct tracepoint_func *funcs; +struct mutex { + atomic_long_t owner; + spinlock_t wait_lock; + struct optimistic_spin_queue osq; + struct list_head wait_list; +}; + +struct arch_tlbflush_unmap_batch { + struct cpumask cpumask; +}; + +struct tlbflush_unmap_batch { + struct arch_tlbflush_unmap_batch arch; + bool flush_required; + bool writable; +}; + +struct page_frag { + struct page *page; + __u32 offset; + __u32 size; }; struct desc_struct { @@ -723,10 +680,9 @@ struct desc_struct { u16 base2: 8; }; -struct desc_ptr { - short unsigned int size; - long unsigned int address; -} __attribute__((packed)); +typedef struct { + long unsigned int seg; +} mm_segment_t; struct fregs_state { u32 cwd; @@ -768,6 +724,8 @@ struct fxregs_state { }; }; +struct math_emu_info; + struct swregs_state { u32 cwd; u32 swd; @@ -819,1116 +777,75 @@ struct fpu { union fpregs_state state; }; -struct cpuinfo_x86 { - __u8 x86; - __u8 x86_vendor; - __u8 x86_model; - __u8 x86_stepping; - int x86_tlbsize; - __u8 x86_virt_bits; - __u8 x86_phys_bits; - __u8 x86_coreid_bits; - __u8 cu_id; - __u32 extended_cpuid_level; - int cpuid_level; - union { - __u32 x86_capability[20]; - long unsigned int x86_capability_alignment; - }; - char x86_vendor_id[16]; - char x86_model_id[64]; - unsigned int x86_cache_size; - int x86_cache_alignment; - int x86_cache_max_rmid; - int x86_cache_occ_scale; - int x86_power; - long unsigned int loops_per_jiffy; - u16 x86_max_cores; - u16 apicid; - u16 initial_apicid; - u16 x86_clflush_size; - u16 booted_cores; - u16 phys_proc_id; - u16 logical_proc_id; - u16 cpu_core_id; - u16 cpu_die_id; - u16 logical_die_id; - u16 cpu_index; - u32 microcode; - u8 x86_cache_bits; - unsigned int initialized: 1; -}; - -struct x86_hw_tss { - u32 reserved1; - u64 sp0; - u64 sp1; - u64 sp2; - u64 reserved2; - u64 ist[7]; - u32 reserved3; - u32 reserved4; - u16 reserved5; - u16 io_bitmap_base; -} __attribute__((packed)); +struct perf_event; -struct x86_io_bitmap { - u64 prev_sequence; - unsigned int prev_max; - long unsigned int bitmap[1025]; - long unsigned int mapall[1025]; -}; +struct io_bitmap; -struct tss_struct { - struct x86_hw_tss x86_tss; - struct x86_io_bitmap io_bitmap; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +struct thread_struct { + struct desc_struct tls_array[3]; + long unsigned int sp; + short unsigned int es; + short unsigned int ds; + short unsigned int fsindex; + short unsigned int gsindex; + long unsigned int fsbase; + long unsigned int gsbase; + struct perf_event *ptrace_bps[4]; + long unsigned int debugreg6; + long unsigned int ptrace_dr7; + long unsigned int cr2; + long unsigned int trap_nr; + long unsigned int error_code; + struct io_bitmap *io_bitmap; + long unsigned int iopl_emul; + mm_segment_t addr_limit; + unsigned int sig_on_uaccess_err: 1; + unsigned int uaccess_err: 1; + long: 62; long: 64; long: 64; long: 64; long: 64; + struct fpu fpu; }; -struct fixed_percpu_data { - char gs_base[40]; - long unsigned int stack_canary; -}; +struct sched_class; -typedef struct { - long unsigned int seg; -} mm_segment_t; +struct task_group; -struct perf_event; +struct mm_struct; -struct io_bitmap; +struct pid; -struct thread_struct { - struct desc_struct tls_array[3]; - long unsigned int sp; - short unsigned int es; - short unsigned int ds; - short unsigned int fsindex; - short unsigned int gsindex; - long unsigned int fsbase; - long unsigned int gsbase; - struct perf_event *ptrace_bps[4]; - long unsigned int debugreg6; - long unsigned int ptrace_dr7; - long unsigned int cr2; - long unsigned int trap_nr; - long unsigned int error_code; - struct io_bitmap *io_bitmap; - long unsigned int iopl_emul; - mm_segment_t addr_limit; - unsigned int sig_on_uaccess_err: 1; - unsigned int uaccess_err: 1; - long: 62; - long: 64; - long: 64; - long: 64; - long: 64; - struct fpu fpu; -}; +struct completion; -struct thread_info { - long unsigned int flags; - u32 status; -}; +struct cred; -struct llist_node { - struct llist_node *next; -}; +struct key; -struct mpc_table { - char signature[4]; - short unsigned int length; - char spec; - char checksum; - char oem[8]; - char productid[12]; - unsigned int oemptr; - short unsigned int oemsize; - short unsigned int oemcount; - unsigned int lapic; - unsigned int reserved; -}; +struct nameidata; -struct mpc_cpu { - unsigned char type; - unsigned char apicid; - unsigned char apicver; - unsigned char cpuflag; - unsigned int cpufeature; - unsigned int featureflag; - unsigned int reserved[2]; -}; +struct fs_struct; -struct mpc_bus { - unsigned char type; - unsigned char busid; - unsigned char bustype[6]; -}; +struct files_struct; -struct x86_init_mpparse { - void (*mpc_record)(unsigned int); - void (*setup_ioapic_ids)(); - int (*mpc_apic_id)(struct mpc_cpu *); - void (*smp_read_mpc_oem)(struct mpc_table *); - void (*mpc_oem_pci_bus)(struct mpc_bus *); - void (*mpc_oem_bus_info)(struct mpc_bus *, char *); - void (*find_smp_config)(); - void (*get_smp_config)(unsigned int); -}; +struct nsproxy; -struct x86_init_resources { - void (*probe_roms)(); - void (*reserve_resources)(); - char * (*memory_setup)(); -}; +struct signal_struct; -struct x86_init_irqs { - void (*pre_vector_init)(); - void (*intr_init)(); - void (*trap_init)(); - void (*intr_mode_init)(); -}; +struct sighand_struct; -struct x86_init_oem { - void (*arch_setup)(); - void (*banner)(); -}; +struct audit_context; -struct x86_init_paging { - void (*pagetable_init)(); -}; +struct rt_mutex_waiter; -struct x86_init_timers { - void (*setup_percpu_clockev)(); - void (*timer_init)(); - void (*wallclock_init)(); -}; +struct bio_list; -struct x86_init_iommu { - int (*iommu_init)(); -}; +struct blk_plug; -struct x86_init_pci { - int (*arch_init)(); - int (*init)(); - void (*init_irq)(); - void (*fixup_irqs)(); -}; +struct reclaim_state; -struct x86_hyper_init { - void (*init_platform)(); - void (*guest_late_init)(); - bool (*x2apic_available)(); - void (*init_mem_mapping)(); - void (*init_after_bootmem)(); -}; - -struct x86_init_acpi { - void (*set_root_pointer)(u64); - u64 (*get_root_pointer)(); - void (*reduced_hw_early_init)(); -}; - -struct x86_init_ops { - struct x86_init_resources resources; - struct x86_init_mpparse mpparse; - struct x86_init_irqs irqs; - struct x86_init_oem oem; - struct x86_init_paging paging; - struct x86_init_timers timers; - struct x86_init_iommu iommu; - struct x86_init_pci pci; - struct x86_hyper_init hyper; - struct x86_init_acpi acpi; -}; - -struct x86_legacy_devices { - int pnpbios; -}; - -enum x86_legacy_i8042_state { - X86_LEGACY_I8042_PLATFORM_ABSENT = 0, - X86_LEGACY_I8042_FIRMWARE_ABSENT = 1, - X86_LEGACY_I8042_EXPECTED_PRESENT = 2, -}; - -struct x86_legacy_features { - enum x86_legacy_i8042_state i8042; - int rtc; - int warm_reset; - int no_vga; - int reserve_bios_regions; - struct x86_legacy_devices devices; -}; - -struct x86_hyper_runtime { - void (*pin_vcpu)(int); -}; - -struct x86_platform_ops { - long unsigned int (*calibrate_cpu)(); - long unsigned int (*calibrate_tsc)(); - void (*get_wallclock)(struct timespec64 *); - int (*set_wallclock)(const struct timespec64 *); - void (*iommu_shutdown)(); - bool (*is_untracked_pat_range)(u64, u64); - void (*nmi_init)(); - unsigned char (*get_nmi_reason)(); - void (*save_sched_clock_state)(); - void (*restore_sched_clock_state)(); - void (*apic_post_init)(); - struct x86_legacy_features legacy; - void (*set_legacy_features)(); - struct x86_hyper_runtime hyper; -}; - -struct x86_apic_ops { - unsigned int (*io_apic_read)(unsigned int, unsigned int); - void (*restore)(); -}; - -struct physid_mask { - long unsigned int mask[512]; -}; - -typedef struct physid_mask physid_mask_t; - -typedef struct { - long unsigned int bits[1]; -} nodemask_t; - -struct qrwlock { - union { - atomic_t cnts; - struct { - u8 wlocked; - u8 __lstate[3]; - }; - }; - arch_spinlock_t wait_lock; -}; - -typedef struct qrwlock arch_rwlock_t; - -struct lock_class_key {}; - -typedef struct raw_spinlock raw_spinlock_t; - -typedef struct { - arch_rwlock_t raw_lock; -} rwlock_t; - -struct optimistic_spin_queue { - atomic_t tail; -}; - -struct rw_semaphore { - atomic_long_t count; - atomic_long_t owner; - struct optimistic_spin_queue osq; - raw_spinlock_t wait_lock; - struct list_head wait_list; -}; - -struct mutex { - atomic_long_t owner; - spinlock_t wait_lock; - struct optimistic_spin_queue osq; - struct list_head wait_list; -}; - -struct refcount_struct { - atomic_t refs; -}; - -typedef struct refcount_struct refcount_t; - -struct load_weight { - long unsigned int weight; - u32 inv_weight; -}; - -struct rb_node { - long unsigned int __rb_parent_color; - struct rb_node *rb_right; - struct rb_node *rb_left; -}; - -struct sched_statistics { - u64 wait_start; - u64 wait_max; - u64 wait_count; - u64 wait_sum; - u64 iowait_count; - u64 iowait_sum; - u64 sleep_start; - u64 sleep_max; - s64 sum_sleep_runtime; - u64 block_start; - u64 block_max; - u64 exec_max; - u64 slice_max; - u64 nr_migrations_cold; - u64 nr_failed_migrations_affine; - u64 nr_failed_migrations_running; - u64 nr_failed_migrations_hot; - u64 nr_forced_migrations; - u64 nr_wakeups; - u64 nr_wakeups_sync; - u64 nr_wakeups_migrate; - u64 nr_wakeups_local; - u64 nr_wakeups_remote; - u64 nr_wakeups_affine; - u64 nr_wakeups_affine_attempts; - u64 nr_wakeups_passive; - u64 nr_wakeups_idle; -}; - -struct util_est { - unsigned int enqueued; - unsigned int ewma; -}; - -struct sched_avg { - u64 last_update_time; - u64 load_sum; - u64 runnable_load_sum; - u32 util_sum; - u32 period_contrib; - long unsigned int load_avg; - long unsigned int runnable_load_avg; - long unsigned int util_avg; - struct util_est util_est; -}; - -struct cfs_rq; - -struct sched_entity { - struct load_weight load; - long unsigned int runnable_weight; - struct rb_node run_node; - struct list_head group_node; - unsigned int on_rq; - u64 exec_start; - u64 sum_exec_runtime; - u64 vruntime; - u64 prev_sum_exec_runtime; - u64 nr_migrations; - struct sched_statistics statistics; - int depth; - struct sched_entity *parent; - struct cfs_rq *cfs_rq; - struct cfs_rq *my_q; - long: 64; - long: 64; - long: 64; - struct sched_avg avg; -}; - -struct sched_rt_entity { - struct list_head run_list; - long unsigned int timeout; - long unsigned int watchdog_stamp; - unsigned int time_slice; - short unsigned int on_rq; - short unsigned int on_list; - struct sched_rt_entity *back; -}; - -typedef s64 ktime_t; - -struct timerqueue_node { - struct rb_node node; - ktime_t expires; -}; - -enum hrtimer_restart { - HRTIMER_NORESTART = 0, - HRTIMER_RESTART = 1, -}; - -struct hrtimer_clock_base; - -struct hrtimer { - struct timerqueue_node node; - ktime_t _softexpires; - enum hrtimer_restart (*function)(struct hrtimer *); - struct hrtimer_clock_base *base; - u8 state; - u8 is_rel; - u8 is_soft; - u8 is_hard; -}; - -struct sched_dl_entity { - struct rb_node rb_node; - u64 dl_runtime; - u64 dl_deadline; - u64 dl_period; - u64 dl_bw; - u64 dl_density; - s64 runtime; - u64 deadline; - unsigned int flags; - unsigned int dl_throttled: 1; - unsigned int dl_boosted: 1; - unsigned int dl_yielded: 1; - unsigned int dl_non_contending: 1; - unsigned int dl_overrun: 1; - struct hrtimer dl_timer; - struct hrtimer inactive_timer; -}; - -struct sched_info { - long unsigned int pcount; - long long unsigned int run_delay; - long long unsigned int last_arrival; - long long unsigned int last_queued; -}; - -struct plist_node { - int prio; - struct list_head prio_list; - struct list_head node_list; -}; - -struct vm_area_struct; - -struct vmacache { - u64 seqnum; - struct vm_area_struct *vmas[4]; -}; - -struct task_rss_stat { - int events; - int count[4]; -}; - -struct prev_cputime { - u64 utime; - u64 stime; - raw_spinlock_t lock; -}; - -struct rb_root { - struct rb_node *rb_node; -}; - -struct rb_root_cached { - struct rb_root rb_root; - struct rb_node *rb_leftmost; -}; - -struct timerqueue_head { - struct rb_root_cached rb_root; -}; - -struct posix_cputimer_base { - u64 nextevt; - struct timerqueue_head tqhead; -}; - -struct posix_cputimers { - struct posix_cputimer_base bases[3]; - unsigned int timers_active; - unsigned int expiry_active; -}; - -struct sem_undo_list; - -struct sysv_sem { - struct sem_undo_list *undo_list; -}; - -struct sysv_shm { - struct list_head shm_clist; -}; - -typedef struct { - long unsigned int sig[1]; -} sigset_t; - -struct sigpending { - struct list_head list; - sigset_t signal; -}; - -typedef struct { - uid_t val; -} kuid_t; - -struct seccomp_filter; - -struct seccomp { - int mode; - struct seccomp_filter *filter; -}; - -struct wake_q_node { - struct wake_q_node *next; -}; - -struct task_io_accounting { - u64 rchar; - u64 wchar; - u64 syscr; - u64 syscw; - u64 read_bytes; - u64 write_bytes; - u64 cancelled_write_bytes; -}; - -struct seqcount { - unsigned int sequence; -}; - -typedef struct seqcount seqcount_t; - -struct arch_tlbflush_unmap_batch { - struct cpumask cpumask; -}; - -struct tlbflush_unmap_batch { - struct arch_tlbflush_unmap_batch arch; - bool flush_required; - bool writable; -}; - -struct page_frag { - struct page *page; - __u32 offset; - __u32 size; -}; - -struct sched_class; - -struct task_group; - -struct pid; - -struct completion; - -struct cred; - -struct key; - -struct nameidata; - -struct fs_struct; - -struct files_struct; - -struct nsproxy; - -struct signal_struct; - -struct sighand_struct; - -struct audit_context; - -struct rt_mutex_waiter; - -struct bio_list; - -struct blk_plug; - -struct reclaim_state; - -struct backing_dev_info; +struct backing_dev_info; struct io_context; @@ -1952,8 +869,6 @@ struct mempolicy; struct rseq; -struct pipe_inode_info; - struct task_delay_info; struct uprobe_task; @@ -2138,743 +1053,997 @@ struct task_struct { struct thread_struct thread; }; -struct vdso_image { - void *data; - long unsigned int size; - long unsigned int alt; - long unsigned int alt_len; - long int sym_vvar_start; - long int sym_vvar_page; - long int sym_pvclock_page; - long int sym_hvclock_page; - long int sym_VDSO32_NOTE_MASK; - long int sym___kernel_sigreturn; - long int sym___kernel_rt_sigreturn; - long int sym___kernel_vsyscall; - long int sym_int80_landing_pad; -}; - -struct ldt_struct; - -typedef struct { - u64 ctx_id; - atomic64_t tlb_gen; - struct rw_semaphore ldt_usr_sem; - struct ldt_struct *ldt; - short unsigned int ia32_compat; - struct mutex lock; - void *vdso; - const struct vdso_image *vdso_image; - atomic_t perf_rdpmc_allowed; - u16 pkey_allocation_map; - s16 execute_only_pkey; -} mm_context_t; +struct screen_info { + __u8 orig_x; + __u8 orig_y; + __u16 ext_mem_k; + __u16 orig_video_page; + __u8 orig_video_mode; + __u8 orig_video_cols; + __u8 flags; + __u8 unused2; + __u16 orig_video_ega_bx; + __u16 unused3; + __u8 orig_video_lines; + __u8 orig_video_isVGA; + __u16 orig_video_points; + __u16 lfb_width; + __u16 lfb_height; + __u16 lfb_depth; + __u32 lfb_base; + __u32 lfb_size; + __u16 cl_magic; + __u16 cl_offset; + __u16 lfb_linelength; + __u8 red_size; + __u8 red_pos; + __u8 green_size; + __u8 green_pos; + __u8 blue_size; + __u8 blue_pos; + __u8 rsvd_size; + __u8 rsvd_pos; + __u16 vesapm_seg; + __u16 vesapm_off; + __u16 pages; + __u16 vesa_attributes; + __u32 capabilities; + __u32 ext_lfb_base; + __u8 _reserved[2]; +} __attribute__((packed)); -struct vm_struct { - struct vm_struct *next; - void *addr; - long unsigned int size; - long unsigned int flags; - struct page **pages; - unsigned int nr_pages; - phys_addr_t phys_addr; - const void *caller; +struct apm_bios_info { + __u16 version; + __u16 cseg; + __u32 offset; + __u16 cseg_16; + __u16 dseg; + __u16 flags; + __u16 cseg_len; + __u16 cseg_16_len; + __u16 dseg_len; }; -struct real_mode_header { - u32 text_start; - u32 ro_end; - u32 trampoline_start; - u32 trampoline_header; - u32 trampoline_pgd; - u32 wakeup_start; - u32 wakeup_header; - u32 machine_real_restart_asm; - u32 machine_real_restart_seg; +struct apm_info { + struct apm_bios_info bios; + short unsigned int connection_version; + int get_power_status_broken; + int get_power_status_swabinminutes; + int allow_ints; + int forbid_idle; + int realmode_power_off; + int disabled; }; -enum fixed_addresses { - VSYSCALL_PAGE = 511, - FIX_DBGP_BASE = 512, - FIX_EARLYCON_MEM_BASE = 513, - FIX_OHCI1394_BASE = 514, - FIX_APIC_BASE = 515, - FIX_IO_APIC_BASE_0 = 516, - FIX_IO_APIC_BASE_END = 643, - __end_of_permanent_fixed_addresses = 644, - FIX_BTMAP_END = 1024, - FIX_BTMAP_BEGIN = 1535, - __end_of_fixed_addresses = 1536, -}; +struct edd_device_params { + __u16 length; + __u16 info_flags; + __u32 num_default_cylinders; + __u32 num_default_heads; + __u32 sectors_per_track; + __u64 number_of_sectors; + __u16 bytes_per_sector; + __u32 dpte_ptr; + __u16 key; + __u8 device_path_info_length; + __u8 reserved2; + __u16 reserved3; + __u8 host_bus_type[4]; + __u8 interface_type[8]; + union { + struct { + __u16 base_address; + __u16 reserved1; + __u32 reserved2; + } isa; + struct { + __u8 bus; + __u8 slot; + __u8 function; + __u8 channel; + __u32 reserved; + } pci; + struct { + __u64 reserved; + } ibnd; + struct { + __u64 reserved; + } xprs; + struct { + __u64 reserved; + } htpt; + struct { + __u64 reserved; + } unknown; + } interface_path; + union { + struct { + __u8 device; + __u8 reserved1; + __u16 reserved2; + __u32 reserved3; + __u64 reserved4; + } ata; + struct { + __u8 device; + __u8 lun; + __u8 reserved1; + __u8 reserved2; + __u32 reserved3; + __u64 reserved4; + } atapi; + struct { + __u16 id; + __u64 lun; + __u16 reserved1; + __u32 reserved2; + } __attribute__((packed)) scsi; + struct { + __u64 serial_number; + __u64 reserved; + } usb; + struct { + __u64 eui; + __u64 reserved; + } i1394; + struct { + __u64 wwid; + __u64 lun; + } fibre; + struct { + __u64 identity_tag; + __u64 reserved; + } i2o; + struct { + __u32 array_number; + __u32 reserved1; + __u64 reserved2; + } raid; + struct { + __u8 device; + __u8 reserved1; + __u16 reserved2; + __u32 reserved3; + __u64 reserved4; + } sata; + struct { + __u64 reserved1; + __u64 reserved2; + } unknown; + } device_path; + __u8 reserved4; + __u8 checksum; +} __attribute__((packed)); -struct vm_userfaultfd_ctx {}; +struct edd_info { + __u8 device; + __u8 version; + __u16 interface_support; + __u16 legacy_max_cylinder; + __u8 legacy_max_head; + __u8 legacy_sectors_per_track; + struct edd_device_params params; +} __attribute__((packed)); -struct anon_vma; +struct edd { + unsigned int mbr_signature[16]; + struct edd_info edd_info[6]; + unsigned char mbr_signature_nr; + unsigned char edd_info_nr; +}; -struct vm_operations_struct; +struct ist_info { + __u32 signature; + __u32 command; + __u32 event; + __u32 perf_level; +}; -struct file; +struct edid_info { + unsigned char dummy[128]; +}; -struct vm_area_struct { - long unsigned int vm_start; - long unsigned int vm_end; - struct vm_area_struct *vm_next; - struct vm_area_struct *vm_prev; - struct rb_node vm_rb; - long unsigned int rb_subtree_gap; - struct mm_struct *vm_mm; - pgprot_t vm_page_prot; - long unsigned int vm_flags; - struct { - struct rb_node rb; - long unsigned int rb_subtree_last; - } shared; - struct list_head anon_vma_chain; - struct anon_vma *anon_vma; - const struct vm_operations_struct *vm_ops; - long unsigned int vm_pgoff; - struct file *vm_file; - void *vm_private_data; - atomic_long_t swap_readahead_info; - struct mempolicy *vm_policy; - struct vm_userfaultfd_ctx vm_userfaultfd_ctx; +struct setup_header { + __u8 setup_sects; + __u16 root_flags; + __u32 syssize; + __u16 ram_size; + __u16 vid_mode; + __u16 root_dev; + __u16 boot_flag; + __u16 jump; + __u32 header; + __u16 version; + __u32 realmode_swtch; + __u16 start_sys_seg; + __u16 kernel_version; + __u8 type_of_loader; + __u8 loadflags; + __u16 setup_move_size; + __u32 code32_start; + __u32 ramdisk_image; + __u32 ramdisk_size; + __u32 bootsect_kludge; + __u16 heap_end_ptr; + __u8 ext_loader_ver; + __u8 ext_loader_type; + __u32 cmd_line_ptr; + __u32 initrd_addr_max; + __u32 kernel_alignment; + __u8 relocatable_kernel; + __u8 min_alignment; + __u16 xloadflags; + __u32 cmdline_size; + __u32 hardware_subarch; + __u64 hardware_subarch_data; + __u32 payload_offset; + __u32 payload_length; + __u64 setup_data; + __u64 pref_address; + __u32 init_size; + __u32 handover_offset; + __u32 kernel_info_offset; +} __attribute__((packed)); + +struct sys_desc_table { + __u16 length; + __u8 table[14]; }; -struct mm_rss_stat { - atomic_long_t count[4]; +struct olpc_ofw_header { + __u32 ofw_magic; + __u32 ofw_version; + __u32 cif_handler; + __u32 irq_desc_table; }; -struct wait_queue_head { - spinlock_t lock; - struct list_head head; +struct efi_info { + __u32 efi_loader_signature; + __u32 efi_systab; + __u32 efi_memdesc_size; + __u32 efi_memdesc_version; + __u32 efi_memmap; + __u32 efi_memmap_size; + __u32 efi_systab_hi; + __u32 efi_memmap_hi; }; -typedef struct wait_queue_head wait_queue_head_t; +struct boot_e820_entry { + __u64 addr; + __u64 size; + __u32 type; +} __attribute__((packed)); -struct completion { - unsigned int done; - wait_queue_head_t wait; +struct boot_params { + struct screen_info screen_info; + struct apm_bios_info apm_bios_info; + __u8 _pad2[4]; + __u64 tboot_addr; + struct ist_info ist_info; + __u64 acpi_rsdp_addr; + __u8 _pad3[8]; + __u8 hd0_info[16]; + __u8 hd1_info[16]; + struct sys_desc_table sys_desc_table; + struct olpc_ofw_header olpc_ofw_header; + __u32 ext_ramdisk_image; + __u32 ext_ramdisk_size; + __u32 ext_cmd_line_ptr; + __u8 _pad4[116]; + struct edid_info edid_info; + struct efi_info efi_info; + __u32 alt_mem_k; + __u32 scratch; + __u8 e820_entries; + __u8 eddbuf_entries; + __u8 edd_mbr_sig_buf_entries; + __u8 kbd_status; + __u8 secure_boot; + __u8 _pad5[2]; + __u8 sentinel; + __u8 _pad6[1]; + struct setup_header hdr; + __u8 _pad7[36]; + __u32 edd_mbr_sig_buffer[16]; + struct boot_e820_entry e820_table[128]; + __u8 _pad8[48]; + struct edd_info eddbuf[6]; + __u8 _pad9[276]; +} __attribute__((packed)); + +enum x86_hardware_subarch { + X86_SUBARCH_PC = 0, + X86_SUBARCH_LGUEST = 1, + X86_SUBARCH_XEN = 2, + X86_SUBARCH_INTEL_MID = 3, + X86_SUBARCH_CE4100 = 4, + X86_NR_SUBARCHS = 5, }; -struct xol_area; +struct range { + u64 start; + u64 end; +}; -struct uprobes_state { - struct xol_area *xol_area; +struct pt_regs { + long unsigned int r15; + long unsigned int r14; + long unsigned int r13; + long unsigned int r12; + long unsigned int bp; + long unsigned int bx; + long unsigned int r11; + long unsigned int r10; + long unsigned int r9; + long unsigned int r8; + long unsigned int ax; + long unsigned int cx; + long unsigned int dx; + long unsigned int si; + long unsigned int di; + long unsigned int orig_ax; + long unsigned int ip; + long unsigned int cs; + long unsigned int flags; + long unsigned int sp; + long unsigned int ss; }; -struct work_struct; +struct math_emu_info { + long int ___orig_eip; + struct pt_regs *regs; +}; -typedef void (*work_func_t)(struct work_struct *); +typedef long unsigned int pteval_t; -struct work_struct { - atomic_long_t data; - struct list_head entry; - work_func_t func; -}; +typedef long unsigned int pmdval_t; -struct linux_binfmt; +typedef long unsigned int pudval_t; -struct core_state; +typedef long unsigned int p4dval_t; -struct kioctx_table; +typedef long unsigned int pgdval_t; -struct user_namespace; +typedef long unsigned int pgprotval_t; -struct mmu_notifier_mm; +typedef struct { + pteval_t pte; +} pte_t; -struct mm_struct { - struct { - struct vm_area_struct *mmap; - struct rb_root mm_rb; - u64 vmacache_seqnum; - long unsigned int (*get_unmapped_area)(struct file *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); - long unsigned int mmap_base; - long unsigned int mmap_legacy_base; - long unsigned int mmap_compat_base; - long unsigned int mmap_compat_legacy_base; - long unsigned int task_size; - long unsigned int highest_vm_end; - pgd_t *pgd; - atomic_t membarrier_state; - atomic_t mm_users; - atomic_t mm_count; - atomic_long_t pgtables_bytes; - int map_count; - spinlock_t page_table_lock; - struct rw_semaphore mmap_sem; - struct list_head mmlist; - long unsigned int hiwater_rss; - long unsigned int hiwater_vm; - long unsigned int total_vm; - long unsigned int locked_vm; - atomic64_t pinned_vm; - long unsigned int data_vm; - long unsigned int exec_vm; - long unsigned int stack_vm; - long unsigned int def_flags; - spinlock_t arg_lock; - long unsigned int start_code; - long unsigned int end_code; - long unsigned int start_data; - long unsigned int end_data; - long unsigned int start_brk; - long unsigned int brk; - long unsigned int start_stack; - long unsigned int arg_start; - long unsigned int arg_end; - long unsigned int env_start; - long unsigned int env_end; - long unsigned int saved_auxv[46]; - struct mm_rss_stat rss_stat; - struct linux_binfmt *binfmt; - mm_context_t context; - long unsigned int flags; - struct core_state *core_state; - spinlock_t ioctx_lock; - struct kioctx_table *ioctx_table; - struct user_namespace *user_ns; - struct file *exe_file; - struct mmu_notifier_mm *mmu_notifier_mm; - atomic_t tlb_flush_pending; - bool tlb_flush_batched; - struct uprobes_state uprobes_state; - atomic_long_t hugetlb_usage; - struct work_struct async_put_work; - }; - long unsigned int cpu_bitmap[0]; +struct pgprot { + pgprotval_t pgprot; }; -struct arch_uprobe_task { - long unsigned int saved_scratch_register; - unsigned int saved_trap_nr; - unsigned int saved_tf; -}; +typedef struct pgprot pgprot_t; -enum uprobe_task_state { - UTASK_RUNNING = 0, - UTASK_SSTEP = 1, - UTASK_SSTEP_ACK = 2, - UTASK_SSTEP_TRAPPED = 3, -}; +typedef struct { + pgdval_t pgd; +} pgd_t; -struct uprobe; +typedef struct { + p4dval_t p4d; +} p4d_t; -struct return_instance; +typedef struct { + pudval_t pud; +} pud_t; -struct uprobe_task { - enum uprobe_task_state state; +typedef struct { + pmdval_t pmd; +} pmd_t; + +typedef struct page *pgtable_t; + +struct address_space; + +struct kmem_cache; + +struct dev_pagemap; + +struct page { + long unsigned int flags; union { struct { - struct arch_uprobe_task autask; - long unsigned int vaddr; + struct list_head lru; + struct address_space *mapping; + long unsigned int index; + long unsigned int private; }; struct { - struct callback_head dup_xol_work; - long unsigned int dup_xol_addr; + dma_addr_t dma_addr; + }; + struct { + union { + struct list_head slab_list; + struct { + struct page *next; + int pages; + int pobjects; + }; + }; + struct kmem_cache *slab_cache; + void *freelist; + union { + void *s_mem; + long unsigned int counters; + struct { + unsigned int inuse: 16; + unsigned int objects: 15; + unsigned int frozen: 1; + }; + }; + }; + struct { + long unsigned int compound_head; + unsigned char compound_dtor; + unsigned char compound_order; + atomic_t compound_mapcount; + }; + struct { + long unsigned int _compound_pad_1; + long unsigned int _compound_pad_2; + struct list_head deferred_list; + }; + struct { + long unsigned int _pt_pad_1; + pgtable_t pmd_huge_pte; + long unsigned int _pt_pad_2; + union { + struct mm_struct *pt_mm; + atomic_t pt_frag_refcount; + }; + spinlock_t ptl; + }; + struct { + struct dev_pagemap *pgmap; + void *zone_device_data; }; + struct callback_head callback_head; }; - struct uprobe *active_uprobe; - long unsigned int xol_vaddr; - struct return_instance *return_instances; - unsigned int depth; + union { + atomic_t _mapcount; + unsigned int page_type; + unsigned int active; + int units; + }; + atomic_t _refcount; + long: 64; }; -struct return_instance { - struct uprobe *uprobe; - long unsigned int func; - long unsigned int stack; - long unsigned int orig_ret_vaddr; - bool chained; - struct return_instance *next; -}; +typedef struct cpumask cpumask_var_t[1]; -struct xarray { - spinlock_t xa_lock; - gfp_t xa_flags; - void *xa_head; +struct tracepoint_func { + void *func; + void *data; + int prio; }; -typedef u32 errseq_t; - -struct inode; - -struct address_space_operations; - -struct address_space { - struct inode *host; - struct xarray i_pages; - gfp_t gfp_mask; - atomic_t i_mmap_writable; - struct rb_root_cached i_mmap; - struct rw_semaphore i_mmap_rwsem; - long unsigned int nrpages; - long unsigned int nrexceptional; - long unsigned int writeback_index; - const struct address_space_operations *a_ops; - long unsigned int flags; - errseq_t wb_err; - spinlock_t private_lock; - struct list_head private_list; - void *private_data; -}; - -struct vmem_altmap { - const long unsigned int base_pfn; - const long unsigned int end_pfn; - const long unsigned int reserve; - long unsigned int free; - long unsigned int align; - long unsigned int alloc; -}; - -struct resource { - resource_size_t start; - resource_size_t end; +struct tracepoint { const char *name; - long unsigned int flags; - long unsigned int desc; - struct resource *parent; - struct resource *sibling; - struct resource *child; -}; - -struct percpu_ref; - -typedef void percpu_ref_func_t(struct percpu_ref *); - -struct percpu_ref { - atomic_long_t count; - long unsigned int percpu_count_ptr; - percpu_ref_func_t *release; - percpu_ref_func_t *confirm_switch; - bool force_atomic: 1; - bool allow_reinit: 1; - struct callback_head rcu; -}; - -enum memory_type { - MEMORY_DEVICE_PRIVATE = 1, - MEMORY_DEVICE_FS_DAX = 2, - MEMORY_DEVICE_DEVDAX = 3, - MEMORY_DEVICE_PCI_P2PDMA = 4, -}; - -struct dev_pagemap_ops; - -struct dev_pagemap { - struct vmem_altmap altmap; - struct resource res; - struct percpu_ref *ref; - struct percpu_ref internal_ref; - struct completion done; - enum memory_type type; - unsigned int flags; - const struct dev_pagemap_ops *ops; -}; - -struct vfsmount; - -struct dentry; - -struct path { - struct vfsmount *mnt; - struct dentry *dentry; -}; - -enum rw_hint { - WRITE_LIFE_NOT_SET = 0, - WRITE_LIFE_NONE = 1, - WRITE_LIFE_SHORT = 2, - WRITE_LIFE_MEDIUM = 3, - WRITE_LIFE_LONG = 4, - WRITE_LIFE_EXTREME = 5, -}; - -enum pid_type { - PIDTYPE_PID = 0, - PIDTYPE_TGID = 1, - PIDTYPE_PGID = 2, - PIDTYPE_SID = 3, - PIDTYPE_MAX = 4, -}; - -struct fown_struct { - rwlock_t lock; - struct pid *pid; - enum pid_type pid_type; - kuid_t uid; - kuid_t euid; - int signum; -}; - -struct file_ra_state { - long unsigned int start; - unsigned int size; - unsigned int async_size; - unsigned int ra_pages; - unsigned int mmap_miss; - loff_t prev_pos; -}; - -struct file_operations; - -struct file { - union { - struct llist_node fu_llist; - struct callback_head fu_rcuhead; - } f_u; - struct path f_path; - struct inode *f_inode; - const struct file_operations *f_op; - spinlock_t f_lock; - enum rw_hint f_write_hint; - atomic_long_t f_count; - unsigned int f_flags; - fmode_t f_mode; - struct mutex f_pos_lock; - loff_t f_pos; - struct fown_struct f_owner; - const struct cred *f_cred; - struct file_ra_state f_ra; - u64 f_version; - void *f_security; - void *private_data; - struct list_head f_ep_links; - struct list_head f_tfile_llink; - struct address_space *f_mapping; - errseq_t f_wb_err; -}; - -typedef unsigned int vm_fault_t; - -enum page_entry_size { - PE_SIZE_PTE = 0, - PE_SIZE_PMD = 1, - PE_SIZE_PUD = 2, -}; - -struct vm_fault; - -struct vm_operations_struct { - void (*open)(struct vm_area_struct *); - void (*close)(struct vm_area_struct *); - int (*split)(struct vm_area_struct *, long unsigned int); - int (*mremap)(struct vm_area_struct *); - vm_fault_t (*fault)(struct vm_fault *); - vm_fault_t (*huge_fault)(struct vm_fault *, enum page_entry_size); - void (*map_pages)(struct vm_fault *, long unsigned int, long unsigned int); - long unsigned int (*pagesize)(struct vm_area_struct *); - vm_fault_t (*page_mkwrite)(struct vm_fault *); - vm_fault_t (*pfn_mkwrite)(struct vm_fault *); - int (*access)(struct vm_area_struct *, long unsigned int, void *, int, int); - const char * (*name)(struct vm_area_struct *); - int (*set_policy)(struct vm_area_struct *, struct mempolicy *); - struct mempolicy * (*get_policy)(struct vm_area_struct *, long unsigned int); - struct page * (*find_special_page)(struct vm_area_struct *, long unsigned int); + struct static_key key; + int (*regfunc)(); + void (*unregfunc)(); + struct tracepoint_func *funcs; }; -struct core_thread { - struct task_struct *task; - struct core_thread *next; +struct idt_bits { + u16 ist: 3; + u16 zero: 5; + u16 type: 5; + u16 dpl: 2; + u16 p: 1; }; -struct core_state { - atomic_t nr_threads; - struct core_thread dumper; - struct completion startup; +struct gate_struct { + u16 offset_low; + u16 segment; + struct idt_bits bits; + u16 offset_middle; + u32 offset_high; + u32 reserved; }; -struct mem_cgroup; +typedef struct gate_struct gate_desc; -struct vm_fault { - struct vm_area_struct *vma; - unsigned int flags; - gfp_t gfp_mask; - long unsigned int pgoff; +struct desc_ptr { + short unsigned int size; long unsigned int address; - pmd_t *pmd; - pud_t *pud; - pte_t orig_pte; - struct page *cow_page; - struct mem_cgroup *memcg; - struct page *page; - pte_t *pte; - spinlock_t *ptl; - pgtable_t prealloc_pte; -}; - -struct apic { - void (*eoi_write)(u32, u32); - void (*native_eoi_write)(u32, u32); - void (*write)(u32, u32); - u32 (*read)(u32); - void (*wait_icr_idle)(); - u32 (*safe_wait_icr_idle)(); - void (*send_IPI)(int, int); - void (*send_IPI_mask)(const struct cpumask *, int); - void (*send_IPI_mask_allbutself)(const struct cpumask *, int); - void (*send_IPI_allbutself)(int); - void (*send_IPI_all)(int); - void (*send_IPI_self)(int); - u32 dest_logical; - u32 disable_esr; - u32 irq_delivery_mode; - u32 irq_dest_mode; - u32 (*calc_dest_apicid)(unsigned int); - u64 (*icr_read)(); - void (*icr_write)(u32, u32); - int (*probe)(); - int (*acpi_madt_oem_check)(char *, char *); - int (*apic_id_valid)(u32); - int (*apic_id_registered)(); - bool (*check_apicid_used)(physid_mask_t *, int); - void (*init_apic_ldr)(); - void (*ioapic_phys_id_map)(physid_mask_t *, physid_mask_t *); - void (*setup_apic_routing)(); - int (*cpu_present_to_apicid)(int); - void (*apicid_to_cpu_present)(int, physid_mask_t *); - int (*check_phys_apicid_present)(int); - int (*phys_pkg_id)(int, int); - u32 (*get_apic_id)(long unsigned int); - u32 (*set_apic_id)(unsigned int); - int (*wakeup_secondary_cpu)(int, long unsigned int); - void (*inquire_remote_apic)(int); - char *name; -}; - -struct smp_ops { - void (*smp_prepare_boot_cpu)(); - void (*smp_prepare_cpus)(unsigned int); - void (*smp_cpus_done)(unsigned int); - void (*stop_other_cpus)(int); - void (*crash_stop_other_cpus)(); - void (*smp_send_reschedule)(int); - int (*cpu_up)(unsigned int, struct task_struct *); - int (*cpu_disable)(); - void (*cpu_die)(unsigned int); - void (*play_dead)(); - void (*send_call_func_ipi)(const struct cpumask *); - void (*send_call_func_single_ipi)(int); -}; - -struct free_area { - struct list_head free_list[4]; - long unsigned int nr_free; -}; - -struct zone_padding { - char x[0]; -}; - -enum numa_stat_item { - NUMA_HIT = 0, - NUMA_MISS = 1, - NUMA_FOREIGN = 2, - NUMA_INTERLEAVE_HIT = 3, - NUMA_LOCAL = 4, - NUMA_OTHER = 5, - NR_VM_NUMA_STAT_ITEMS = 6, -}; - -enum zone_stat_item { - NR_FREE_PAGES = 0, - NR_ZONE_LRU_BASE = 1, - NR_ZONE_INACTIVE_ANON = 1, - NR_ZONE_ACTIVE_ANON = 2, - NR_ZONE_INACTIVE_FILE = 3, - NR_ZONE_ACTIVE_FILE = 4, - NR_ZONE_UNEVICTABLE = 5, - NR_ZONE_WRITE_PENDING = 6, - NR_MLOCK = 7, - NR_PAGETABLE = 8, - NR_KERNEL_STACK_KB = 9, - NR_BOUNCE = 10, - NR_FREE_CMA_PAGES = 11, - NR_VM_ZONE_STAT_ITEMS = 12, -}; - -enum node_stat_item { - NR_LRU_BASE = 0, - NR_INACTIVE_ANON = 0, - NR_ACTIVE_ANON = 1, - NR_INACTIVE_FILE = 2, - NR_ACTIVE_FILE = 3, - NR_UNEVICTABLE = 4, - NR_SLAB_RECLAIMABLE = 5, - NR_SLAB_UNRECLAIMABLE = 6, - NR_ISOLATED_ANON = 7, - NR_ISOLATED_FILE = 8, - WORKINGSET_NODES = 9, - WORKINGSET_REFAULT = 10, - WORKINGSET_ACTIVATE = 11, - WORKINGSET_RESTORE = 12, - WORKINGSET_NODERECLAIM = 13, - NR_ANON_MAPPED = 14, - NR_FILE_MAPPED = 15, - NR_FILE_PAGES = 16, - NR_FILE_DIRTY = 17, - NR_WRITEBACK = 18, - NR_WRITEBACK_TEMP = 19, - NR_SHMEM = 20, - NR_SHMEM_THPS = 21, - NR_SHMEM_PMDMAPPED = 22, - NR_FILE_THPS = 23, - NR_FILE_PMDMAPPED = 24, - NR_ANON_THPS = 25, - NR_UNSTABLE_NFS = 26, - NR_VMSCAN_WRITE = 27, - NR_VMSCAN_IMMEDIATE = 28, - NR_DIRTIED = 29, - NR_WRITTEN = 30, - NR_KERNEL_MISC_RECLAIMABLE = 31, - NR_VM_NODE_STAT_ITEMS = 32, -}; - -struct zone_reclaim_stat { - long unsigned int recent_rotated[2]; - long unsigned int recent_scanned[2]; -}; +} __attribute__((packed)); -struct lruvec { - struct list_head lists[5]; - struct zone_reclaim_stat reclaim_stat; - atomic_long_t inactive_age; - long unsigned int refaults; - long unsigned int flags; +struct cpuinfo_x86 { + __u8 x86; + __u8 x86_vendor; + __u8 x86_model; + __u8 x86_stepping; + int x86_tlbsize; + __u8 x86_virt_bits; + __u8 x86_phys_bits; + __u8 x86_coreid_bits; + __u8 cu_id; + __u32 extended_cpuid_level; + int cpuid_level; + union { + __u32 x86_capability[20]; + long unsigned int x86_capability_alignment; + }; + char x86_vendor_id[16]; + char x86_model_id[64]; + unsigned int x86_cache_size; + int x86_cache_alignment; + int x86_cache_max_rmid; + int x86_cache_occ_scale; + int x86_power; + long unsigned int loops_per_jiffy; + u16 x86_max_cores; + u16 apicid; + u16 initial_apicid; + u16 x86_clflush_size; + u16 booted_cores; + u16 phys_proc_id; + u16 logical_proc_id; + u16 cpu_core_id; + u16 cpu_die_id; + u16 logical_die_id; + u16 cpu_index; + u32 microcode; + u8 x86_cache_bits; + unsigned int initialized: 1; }; -typedef unsigned int isolate_mode_t; - -struct per_cpu_pages { - int count; - int high; - int batch; - struct list_head lists[3]; -}; +struct seq_file___2; -struct per_cpu_pageset { - struct per_cpu_pages pcp; - s8 expire; - u16 vm_numa_stat_diff[6]; - s8 stat_threshold; - s8 vm_stat_diff[12]; +struct seq_operations { + void * (*start)(struct seq_file___2 *, loff_t *); + void (*stop)(struct seq_file___2 *, void *); + void * (*next)(struct seq_file___2 *, void *, loff_t *); + int (*show)(struct seq_file___2 *, void *); }; -struct per_cpu_nodestat { - s8 stat_threshold; - s8 vm_node_stat_diff[32]; -}; +struct x86_hw_tss { + u32 reserved1; + u64 sp0; + u64 sp1; + u64 sp2; + u64 reserved2; + u64 ist[7]; + u32 reserved3; + u32 reserved4; + u16 reserved5; + u16 io_bitmap_base; +} __attribute__((packed)); -enum zone_type { - ZONE_DMA = 0, - ZONE_DMA32 = 1, - ZONE_NORMAL = 2, - ZONE_MOVABLE = 3, - __MAX_NR_ZONES = 4, +struct entry_stack { + long unsigned int words[64]; }; -struct pglist_data; - -struct zone { - long unsigned int _watermark[3]; - long unsigned int watermark_boost; - long unsigned int nr_reserved_highatomic; - long int lowmem_reserve[4]; - int node; - struct pglist_data *zone_pgdat; - struct per_cpu_pageset *pageset; - long unsigned int zone_start_pfn; - atomic_long_t managed_pages; - long unsigned int spanned_pages; - long unsigned int present_pages; - const char *name; - int initialized; - long: 32; +struct entry_stack_page { + struct entry_stack stack; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; long: 64; long: 64; long: 64; long: 64; long: 64; long: 64; - struct zone_padding _pad1_; - struct free_area free_area[11]; - long unsigned int flags; - spinlock_t lock; - long: 32; long: 64; long: 64; long: 64; - struct zone_padding _pad2_; - long unsigned int percpu_drift_mark; - long unsigned int compact_cached_free_pfn; - long unsigned int compact_cached_migrate_pfn[2]; - long unsigned int compact_init_migrate_pfn; - long unsigned int compact_init_free_pfn; - unsigned int compact_considered; - unsigned int compact_defer_shift; - int compact_order_failed; - bool compact_blockskip_flush; - bool contiguous; - short: 16; - struct zone_padding _pad3_; - atomic_long_t vm_stat[12]; - atomic_long_t vm_numa_stat[6]; long: 64; long: 64; long: 64; long: 64; long: 64; long: 64; -}; - -struct zoneref { - struct zone *zone; - int zone_idx; -}; - -struct zonelist { - struct zoneref _zonerefs[257]; -}; - -struct pglist_data { - struct zone node_zones[4]; - struct zonelist node_zonelists[2]; - int nr_zones; - long unsigned int node_start_pfn; - long unsigned int node_present_pages; - long unsigned int node_spanned_pages; - int node_id; - wait_queue_head_t kswapd_wait; - wait_queue_head_t pfmemalloc_wait; - struct task_struct *kswapd; - int kswapd_order; - enum zone_type kswapd_classzone_idx; - int kswapd_failures; - int kcompactd_max_order; - enum zone_type kcompactd_classzone_idx; - wait_queue_head_t kcompactd_wait; - struct task_struct *kcompactd; - long unsigned int totalreserve_pages; - long unsigned int min_unmapped_pages; - long unsigned int min_slab_pages; long: 64; long: 64; long: 64; long: 64; long: 64; long: 64; - struct zone_padding _pad1_; - spinlock_t lru_lock; - struct lruvec __lruvec; - long unsigned int flags; long: 64; long: 64; long: 64; long: 64; long: 64; - struct zone_padding _pad2_; - struct per_cpu_nodestat *per_cpu_nodestats; - atomic_long_t vm_stat[32]; long: 64; long: 64; long: 64; @@ -2882,3627 +2051,6049 @@ struct pglist_data { long: 64; long: 64; long: 64; -}; - -struct mem_section_usage { - long unsigned int subsection_map[1]; - long unsigned int pageblock_flags[0]; -}; - -struct mem_section { - long unsigned int section_mem_map; - struct mem_section_usage *usage; -}; - -struct shrink_control { - gfp_t gfp_mask; - int nid; - long unsigned int nr_to_scan; - long unsigned int nr_scanned; - struct mem_cgroup *memcg; -}; - -struct shrinker { - long unsigned int (*count_objects)(struct shrinker *, struct shrink_control *); - long unsigned int (*scan_objects)(struct shrinker *, struct shrink_control *); - long int batch; - int seeks; - unsigned int flags; - struct list_head list; - atomic_long_t *nr_deferred; -}; - -struct dev_pagemap_ops { - void (*page_free)(struct page *); - void (*kill)(struct dev_pagemap *); - void (*cleanup)(struct dev_pagemap *); - vm_fault_t (*migrate_to_ram)(struct vm_fault *); -}; - -struct pid_namespace; - -struct upid { - int nr; - struct pid_namespace *ns; -}; - -struct pid { - refcount_t count; - unsigned int level; - struct hlist_head tasks[4]; - wait_queue_head_t wait_pidfd; - struct callback_head rcu; - struct upid numbers[1]; -}; - -typedef struct { - gid_t val; -} kgid_t; - -struct hrtimer_cpu_base; - -struct hrtimer_clock_base { - struct hrtimer_cpu_base *cpu_base; - unsigned int index; - clockid_t clockid; - seqcount_t seq; - struct hrtimer *running; - struct timerqueue_head active; - ktime_t (*get_time)(); - ktime_t offset; -}; - -struct hrtimer_cpu_base { - raw_spinlock_t lock; - unsigned int cpu; - unsigned int active_bases; - unsigned int clock_was_set_seq; - unsigned int hres_active: 1; - unsigned int in_hrtirq: 1; - unsigned int hang_detected: 1; - unsigned int softirq_activated: 1; - unsigned int nr_events; - short unsigned int nr_retries; - short unsigned int nr_hangs; - unsigned int max_hang_time; - ktime_t expires_next; - struct hrtimer *next_timer; - ktime_t softirq_expires_next; - struct hrtimer *softirq_next_timer; - struct hrtimer_clock_base clock_base[8]; -}; - -union sigval { - int sival_int; - void *sival_ptr; -}; - -typedef union sigval sigval_t; - -union __sifields { - struct { - __kernel_pid_t _pid; - __kernel_uid32_t _uid; - } _kill; - struct { - __kernel_timer_t _tid; - int _overrun; - sigval_t _sigval; - int _sys_private; - } _timer; - struct { - __kernel_pid_t _pid; - __kernel_uid32_t _uid; - sigval_t _sigval; - } _rt; - struct { - __kernel_pid_t _pid; - __kernel_uid32_t _uid; - int _status; - __kernel_clock_t _utime; - __kernel_clock_t _stime; - } _sigchld; - struct { - void *_addr; - union { - short int _addr_lsb; - struct { - char _dummy_bnd[8]; - void *_lower; - void *_upper; - } _addr_bnd; - struct { - char _dummy_pkey[8]; - __u32 _pkey; - } _addr_pkey; - }; - } _sigfault; - struct { - long int _band; - int _fd; - } _sigpoll; - struct { - void *_call_addr; - int _syscall; - unsigned int _arch; - } _sigsys; -}; - -struct kernel_siginfo { - struct { - int si_signo; - int si_errno; - int si_code; - union __sifields _sifields; - }; -}; - -struct rseq { - __u32 cpu_id_start; - __u32 cpu_id; - union { - __u64 ptr64; - __u64 ptr; - } rseq_cs; - __u32 flags; - long: 32; long: 64; -}; - -struct rq; - -struct rq_flags; - -struct sched_class { - const struct sched_class *next; - void (*enqueue_task)(struct rq *, struct task_struct *, int); - void (*dequeue_task)(struct rq *, struct task_struct *, int); - void (*yield_task)(struct rq *); - bool (*yield_to_task)(struct rq *, struct task_struct *, bool); - void (*check_preempt_curr)(struct rq *, struct task_struct *, int); - struct task_struct * (*pick_next_task)(struct rq *); - void (*put_prev_task)(struct rq *, struct task_struct *); - void (*set_next_task)(struct rq *, struct task_struct *, bool); - int (*balance)(struct rq *, struct task_struct *, struct rq_flags *); - int (*select_task_rq)(struct task_struct *, int, int, int); - void (*migrate_task_rq)(struct task_struct *, int); - void (*task_woken)(struct rq *, struct task_struct *); - void (*set_cpus_allowed)(struct task_struct *, const struct cpumask *); - void (*rq_online)(struct rq *); - void (*rq_offline)(struct rq *); - void (*task_tick)(struct rq *, struct task_struct *, int); - void (*task_fork)(struct task_struct *); - void (*task_dead)(struct task_struct *); - void (*switched_from)(struct rq *, struct task_struct *); - void (*switched_to)(struct rq *, struct task_struct *); - void (*prio_changed)(struct rq *, struct task_struct *, int); - unsigned int (*get_rr_interval)(struct rq *, struct task_struct *); - void (*update_curr)(struct rq *); - void (*task_change_group)(struct task_struct *, int); -}; - -struct kernel_cap_struct { - __u32 cap[2]; -}; - -typedef struct kernel_cap_struct kernel_cap_t; - -struct user_struct; - -struct group_info; - -struct cred { - atomic_t usage; - kuid_t uid; - kgid_t gid; - kuid_t suid; - kgid_t sgid; - kuid_t euid; - kgid_t egid; - kuid_t fsuid; - kgid_t fsgid; - unsigned int securebits; - kernel_cap_t cap_inheritable; - kernel_cap_t cap_permitted; - kernel_cap_t cap_effective; - kernel_cap_t cap_bset; - kernel_cap_t cap_ambient; - unsigned char jit_keyring; - struct key *session_keyring; - struct key *process_keyring; - struct key *thread_keyring; - struct key *request_key_auth; - void *security; - struct user_struct *user; - struct user_namespace *user_ns; - struct group_info *group_info; - union { - int non_rcu; - struct callback_head rcu; - }; -}; - -struct io_cq; - -struct io_context { - atomic_long_t refcount; - atomic_t active_ref; - atomic_t nr_tasks; - spinlock_t lock; - short unsigned int ioprio; - int nr_batch_requests; - long unsigned int last_waited; - struct xarray icq_tree; - struct io_cq *icq_hint; - struct hlist_head icq_list; - struct work_struct release_work; -}; - -struct hlist_bl_node; - -struct hlist_bl_head { - struct hlist_bl_node *first; -}; - -struct hlist_bl_node { - struct hlist_bl_node *next; - struct hlist_bl_node **pprev; -}; - -struct lockref { - union { - __u64 lock_count; - struct { - spinlock_t lock; - int count; - }; - }; -}; - -struct qstr { - union { - struct { - u32 hash; - u32 len; - }; - u64 hash_len; - }; - const unsigned char *name; -}; - -struct dentry_operations; - -struct super_block; - -struct dentry { - unsigned int d_flags; - seqcount_t d_seq; - struct hlist_bl_node d_hash; - struct dentry *d_parent; - struct qstr d_name; - struct inode *d_inode; - unsigned char d_iname[32]; - struct lockref d_lockref; - const struct dentry_operations *d_op; - struct super_block *d_sb; - long unsigned int d_time; - void *d_fsdata; - union { - struct list_head d_lru; - wait_queue_head_t *d_wait; - }; - struct list_head d_child; - struct list_head d_subdirs; - union { - struct hlist_node d_alias; - struct hlist_bl_node d_in_lookup_hash; - struct callback_head d_rcu; - } d_u; -}; - -struct posix_acl; - -struct inode_operations; - -struct file_lock_context; - -struct block_device; - -struct cdev; - -struct fsnotify_mark_connector; - -struct inode { - umode_t i_mode; - short unsigned int i_opflags; - kuid_t i_uid; - kgid_t i_gid; - unsigned int i_flags; - struct posix_acl *i_acl; - struct posix_acl *i_default_acl; - const struct inode_operations *i_op; - struct super_block *i_sb; - struct address_space *i_mapping; - void *i_security; - long unsigned int i_ino; - union { - const unsigned int i_nlink; - unsigned int __i_nlink; - }; - dev_t i_rdev; - loff_t i_size; - struct timespec64 i_atime; - struct timespec64 i_mtime; - struct timespec64 i_ctime; - spinlock_t i_lock; - short unsigned int i_bytes; - u8 i_blkbits; - u8 i_write_hint; - blkcnt_t i_blocks; - long unsigned int i_state; - struct rw_semaphore i_rwsem; - long unsigned int dirtied_when; - long unsigned int dirtied_time_when; - struct hlist_node i_hash; - struct list_head i_io_list; - struct list_head i_lru; - struct list_head i_sb_list; - struct list_head i_wb_list; - union { - struct hlist_head i_dentry; - struct callback_head i_rcu; - }; - atomic64_t i_version; - atomic_t i_count; - atomic_t i_dio_count; - atomic_t i_writecount; - atomic_t i_readcount; - union { - const struct file_operations *i_fop; - void (*free_inode)(struct inode *); - }; - struct file_lock_context *i_flctx; - struct address_space i_data; - struct list_head i_devices; - union { - struct pipe_inode_info *i_pipe; - struct block_device *i_bdev; - struct cdev *i_cdev; - char *i_link; - unsigned int i_dir_seq; - }; - __u32 i_generation; - __u32 i_fsnotify_mask; - struct fsnotify_mark_connector *i_fsnotify_marks; - void *i_private; -}; - -struct dentry_operations { - int (*d_revalidate)(struct dentry *, unsigned int); - int (*d_weak_revalidate)(struct dentry *, unsigned int); - int (*d_hash)(const struct dentry *, struct qstr *); - int (*d_compare)(const struct dentry *, unsigned int, const char *, const struct qstr *); - int (*d_delete)(const struct dentry *); - int (*d_init)(struct dentry *); - void (*d_release)(struct dentry *); - void (*d_prune)(struct dentry *); - void (*d_iput)(struct dentry *, struct inode *); - char * (*d_dname)(struct dentry *, char *, int); - struct vfsmount * (*d_automount)(struct path *); - int (*d_manage)(const struct path *, bool); - struct dentry * (*d_real)(struct dentry *, const struct inode *); long: 64; long: 64; long: 64; -}; - -struct mtd_info; - -typedef long long int qsize_t; - -struct quota_format_type; - -struct mem_dqinfo { - struct quota_format_type *dqi_format; - int dqi_fmt_id; - struct list_head dqi_dirty_list; - long unsigned int dqi_flags; - unsigned int dqi_bgrace; - unsigned int dqi_igrace; - qsize_t dqi_max_spc_limit; - qsize_t dqi_max_ino_limit; - void *dqi_priv; -}; - -struct quota_format_ops; - -struct quota_info { - unsigned int flags; - struct rw_semaphore dqio_sem; - struct inode *files[3]; - struct mem_dqinfo info[3]; - const struct quota_format_ops *ops[3]; -}; - -struct rcu_sync { - int gp_state; - int gp_count; - wait_queue_head_t gp_wait; - struct callback_head cb_head; -}; - -struct rcuwait { - struct task_struct *task; -}; - -struct percpu_rw_semaphore { - struct rcu_sync rss; - unsigned int *read_count; - struct rw_semaphore rw_sem; - struct rcuwait writer; - int readers_block; -}; - -struct sb_writers { - int frozen; - wait_queue_head_t wait_unfrozen; - struct percpu_rw_semaphore rw_sem[3]; -}; - -typedef struct { - __u8 b[16]; -} uuid_t; - -struct list_lru_node; - -struct list_lru { - struct list_lru_node *node; -}; - -struct file_system_type; - -struct super_operations; - -struct dquot_operations; - -struct quotactl_ops; - -struct export_operations; - -struct xattr_handler; - -struct workqueue_struct; - -struct super_block { - struct list_head s_list; - dev_t s_dev; - unsigned char s_blocksize_bits; - long unsigned int s_blocksize; - loff_t s_maxbytes; - struct file_system_type *s_type; - const struct super_operations *s_op; - const struct dquot_operations *dq_op; - const struct quotactl_ops *s_qcop; - const struct export_operations *s_export_op; - long unsigned int s_flags; - long unsigned int s_iflags; - long unsigned int s_magic; - struct dentry *s_root; - struct rw_semaphore s_umount; - int s_count; - atomic_t s_active; - void *s_security; - const struct xattr_handler **s_xattr; - struct hlist_bl_head s_roots; - struct list_head s_mounts; - struct block_device *s_bdev; - struct backing_dev_info *s_bdi; - struct mtd_info *s_mtd; - struct hlist_node s_instances; - unsigned int s_quota_types; - struct quota_info s_dquot; - struct sb_writers s_writers; - void *s_fs_info; - u32 s_time_gran; - time64_t s_time_min; - time64_t s_time_max; - __u32 s_fsnotify_mask; - struct fsnotify_mark_connector *s_fsnotify_marks; - char s_id[32]; - uuid_t s_uuid; - unsigned int s_max_links; - fmode_t s_mode; - struct mutex s_vfs_rename_mutex; - const char *s_subtype; - const struct dentry_operations *s_d_op; - int cleancache_poolid; - struct shrinker s_shrink; - atomic_long_t s_remove_count; - atomic_long_t s_fsnotify_inode_refs; - int s_readonly_remount; - struct workqueue_struct *s_dio_done_wq; - struct hlist_head s_pins; - struct user_namespace *s_user_ns; - struct list_lru s_dentry_lru; - struct list_lru s_inode_lru; - struct callback_head rcu; - struct work_struct destroy_work; - struct mutex s_sync_lock; - int s_stack_depth; - long: 32; long: 64; long: 64; long: 64; long: 64; long: 64; long: 64; - spinlock_t s_inode_list_lock; - struct list_head s_inodes; - spinlock_t s_inode_wblist_lock; - struct list_head s_inodes_wb; long: 64; long: 64; -}; - -struct kstat { - u32 result_mask; - umode_t mode; - unsigned int nlink; - uint32_t blksize; - u64 attributes; - u64 attributes_mask; - u64 ino; - dev_t dev; - dev_t rdev; - kuid_t uid; - kgid_t gid; - loff_t size; - struct timespec64 atime; - struct timespec64 mtime; - struct timespec64 ctime; - struct timespec64 btime; - u64 blocks; -}; - -struct list_lru_one { - struct list_head list; - long int nr_items; -}; - -struct list_lru_node { - spinlock_t lock; - struct list_lru_one lru; - long int nr_items; long: 64; long: 64; long: 64; }; -struct fiemap_extent { - __u64 fe_logical; - __u64 fe_physical; - __u64 fe_length; - __u64 fe_reserved64[2]; - __u32 fe_flags; - __u32 fe_reserved[3]; -}; - -enum migrate_mode { - MIGRATE_ASYNC = 0, - MIGRATE_SYNC_LIGHT = 1, - MIGRATE_SYNC = 2, - MIGRATE_SYNC_NO_COPY = 3, -}; - -struct delayed_call { - void (*fn)(void *); - void *arg; +struct x86_io_bitmap { + u64 prev_sequence; + unsigned int prev_max; + long unsigned int bitmap[1025]; + long unsigned int mapall[1025]; }; -typedef struct { - __u8 b[16]; -} guid_t; - -struct request_queue; - -struct io_cq { - struct request_queue *q; - struct io_context *ioc; - union { - struct list_head q_node; - struct kmem_cache *__rcu_icq_cache; - }; - union { - struct hlist_node ioc_node; - struct callback_head __rcu_head; - }; - unsigned int flags; +struct tss_struct { + struct x86_hw_tss x86_tss; + struct x86_io_bitmap io_bitmap; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct kiocb { - struct file *ki_filp; - loff_t ki_pos; - void (*ki_complete)(struct kiocb *, long int, long int); - void *private; - int ki_flags; - u16 ki_hint; - u16 ki_ioprio; - unsigned int ki_cookie; +struct irq_stack { + char stack[16384]; }; -struct iattr { - unsigned int ia_valid; - umode_t ia_mode; - kuid_t ia_uid; - kgid_t ia_gid; - loff_t ia_size; - struct timespec64 ia_atime; - struct timespec64 ia_mtime; - struct timespec64 ia_ctime; - struct file *ia_file; +struct fixed_percpu_data { + char gs_base[40]; + long unsigned int stack_canary; }; -struct percpu_counter { - raw_spinlock_t lock; - s64 count; - struct list_head list; - s32 *counters; +enum l1tf_mitigations { + L1TF_MITIGATION_OFF = 0, + L1TF_MITIGATION_FLUSH_NOWARN = 1, + L1TF_MITIGATION_FLUSH = 2, + L1TF_MITIGATION_FLUSH_NOSMT = 3, + L1TF_MITIGATION_FULL = 4, + L1TF_MITIGATION_FULL_FORCE = 5, }; -typedef __kernel_uid32_t projid_t; - -typedef struct { - projid_t val; -} kprojid_t; - -enum quota_type { - USRQUOTA = 0, - GRPQUOTA = 1, - PRJQUOTA = 2, +struct mpc_table { + char signature[4]; + short unsigned int length; + char spec; + char checksum; + char oem[8]; + char productid[12]; + unsigned int oemptr; + short unsigned int oemsize; + short unsigned int oemcount; + unsigned int lapic; + unsigned int reserved; }; -struct kqid { - union { - kuid_t uid; - kgid_t gid; - kprojid_t projid; - }; - enum quota_type type; +struct mpc_cpu { + unsigned char type; + unsigned char apicid; + unsigned char apicver; + unsigned char cpuflag; + unsigned int cpufeature; + unsigned int featureflag; + unsigned int reserved[2]; }; -struct mem_dqblk { - qsize_t dqb_bhardlimit; - qsize_t dqb_bsoftlimit; - qsize_t dqb_curspace; - qsize_t dqb_rsvspace; - qsize_t dqb_ihardlimit; - qsize_t dqb_isoftlimit; - qsize_t dqb_curinodes; - time64_t dqb_btime; - time64_t dqb_itime; +struct mpc_bus { + unsigned char type; + unsigned char busid; + unsigned char bustype[6]; }; -struct dquot { - struct hlist_node dq_hash; - struct list_head dq_inuse; - struct list_head dq_free; - struct list_head dq_dirty; - struct mutex dq_lock; - spinlock_t dq_dqb_lock; - atomic_t dq_count; - struct super_block *dq_sb; - struct kqid dq_id; - loff_t dq_off; - long unsigned int dq_flags; - struct mem_dqblk dq_dqb; +struct mpc_intsrc { + unsigned char type; + unsigned char irqtype; + short unsigned int irqflag; + unsigned char srcbus; + unsigned char srcbusirq; + unsigned char dstapic; + unsigned char dstirq; }; -struct module; +struct x86_init_mpparse { + void (*mpc_record)(unsigned int); + void (*setup_ioapic_ids)(); + int (*mpc_apic_id)(struct mpc_cpu *); + void (*smp_read_mpc_oem)(struct mpc_table *); + void (*mpc_oem_pci_bus)(struct mpc_bus *); + void (*mpc_oem_bus_info)(struct mpc_bus *, char *); + void (*find_smp_config)(); + void (*get_smp_config)(unsigned int); +}; -struct quota_format_type { - int qf_fmt_id; - const struct quota_format_ops *qf_ops; - struct module *qf_owner; - struct quota_format_type *qf_next; +struct x86_init_resources { + void (*probe_roms)(); + void (*reserve_resources)(); + char * (*memory_setup)(); }; -struct dqstats { - long unsigned int stat[8]; - struct percpu_counter counter[8]; +struct x86_init_irqs { + void (*pre_vector_init)(); + void (*intr_init)(); + void (*trap_init)(); + void (*intr_mode_init)(); }; -struct quota_format_ops { - int (*check_quota_file)(struct super_block *, int); - int (*read_file_info)(struct super_block *, int); - int (*write_file_info)(struct super_block *, int); - int (*free_file_info)(struct super_block *, int); - int (*read_dqblk)(struct dquot *); - int (*commit_dqblk)(struct dquot *); - int (*release_dqblk)(struct dquot *); - int (*get_next_id)(struct super_block *, struct kqid *); +struct x86_init_oem { + void (*arch_setup)(); + void (*banner)(); }; -struct dquot_operations { - int (*write_dquot)(struct dquot *); - struct dquot * (*alloc_dquot)(struct super_block *, int); - void (*destroy_dquot)(struct dquot *); - int (*acquire_dquot)(struct dquot *); - int (*release_dquot)(struct dquot *); - int (*mark_dirty)(struct dquot *); - int (*write_info)(struct super_block *, int); - qsize_t * (*get_reserved_space)(struct inode *); - int (*get_projid)(struct inode *, kprojid_t *); - int (*get_inode_usage)(struct inode *, qsize_t *); - int (*get_next_id)(struct super_block *, struct kqid *); +struct x86_init_paging { + void (*pagetable_init)(); }; -struct qc_dqblk { - int d_fieldmask; - u64 d_spc_hardlimit; - u64 d_spc_softlimit; - u64 d_ino_hardlimit; - u64 d_ino_softlimit; - u64 d_space; - u64 d_ino_count; - s64 d_ino_timer; - s64 d_spc_timer; - int d_ino_warns; - int d_spc_warns; - u64 d_rt_spc_hardlimit; - u64 d_rt_spc_softlimit; - u64 d_rt_space; - s64 d_rt_spc_timer; - int d_rt_spc_warns; +struct x86_init_timers { + void (*setup_percpu_clockev)(); + void (*timer_init)(); + void (*wallclock_init)(); }; -struct qc_type_state { - unsigned int flags; - unsigned int spc_timelimit; - unsigned int ino_timelimit; - unsigned int rt_spc_timelimit; - unsigned int spc_warnlimit; - unsigned int ino_warnlimit; - unsigned int rt_spc_warnlimit; - long long unsigned int ino; - blkcnt_t blocks; - blkcnt_t nextents; +struct x86_init_iommu { + int (*iommu_init)(); }; -struct qc_state { - unsigned int s_incoredqs; - struct qc_type_state s_state[3]; +struct x86_init_pci { + int (*arch_init)(); + int (*init)(); + void (*init_irq)(); + void (*fixup_irqs)(); }; -struct qc_info { - int i_fieldmask; - unsigned int i_flags; - unsigned int i_spc_timelimit; - unsigned int i_ino_timelimit; - unsigned int i_rt_spc_timelimit; - unsigned int i_spc_warnlimit; - unsigned int i_ino_warnlimit; - unsigned int i_rt_spc_warnlimit; +struct x86_hyper_init { + void (*init_platform)(); + void (*guest_late_init)(); + bool (*x2apic_available)(); + void (*init_mem_mapping)(); + void (*init_after_bootmem)(); }; -struct quotactl_ops { - int (*quota_on)(struct super_block *, int, int, const struct path *); - int (*quota_off)(struct super_block *, int); - int (*quota_enable)(struct super_block *, unsigned int); - int (*quota_disable)(struct super_block *, unsigned int); - int (*quota_sync)(struct super_block *, int); - int (*set_info)(struct super_block *, int, struct qc_info *); - int (*get_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *); - int (*get_nextdqblk)(struct super_block *, struct kqid *, struct qc_dqblk *); - int (*set_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *); - int (*get_state)(struct super_block *, struct qc_state *); - int (*rm_xquota)(struct super_block *, unsigned int); +struct x86_init_acpi { + void (*set_root_pointer)(u64); + u64 (*get_root_pointer)(); + void (*reduced_hw_early_init)(); }; -struct writeback_control; +struct x86_init_ops { + struct x86_init_resources resources; + struct x86_init_mpparse mpparse; + struct x86_init_irqs irqs; + struct x86_init_oem oem; + struct x86_init_paging paging; + struct x86_init_timers timers; + struct x86_init_iommu iommu; + struct x86_init_pci pci; + struct x86_hyper_init hyper; + struct x86_init_acpi acpi; +}; -struct iov_iter; +struct x86_cpuinit_ops { + void (*setup_percpu_clockev)(); + void (*early_percpu_clock_init)(); + void (*fixup_cpu_id)(struct cpuinfo_x86 *, int); +}; -struct swap_info_struct; +struct x86_legacy_devices { + int pnpbios; +}; -struct address_space_operations { - int (*writepage)(struct page *, struct writeback_control *); - int (*readpage)(struct file *, struct page *); - int (*writepages)(struct address_space *, struct writeback_control *); - int (*set_page_dirty)(struct page *); - int (*readpages)(struct file *, struct address_space *, struct list_head *, unsigned int); - int (*write_begin)(struct file *, struct address_space *, loff_t, unsigned int, unsigned int, struct page **, void **); - int (*write_end)(struct file *, struct address_space *, loff_t, unsigned int, unsigned int, struct page *, void *); - sector_t (*bmap)(struct address_space *, sector_t); - void (*invalidatepage)(struct page *, unsigned int, unsigned int); - int (*releasepage)(struct page *, gfp_t); - void (*freepage)(struct page *); - ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *); - int (*migratepage)(struct address_space *, struct page *, struct page *, enum migrate_mode); - bool (*isolate_page)(struct page *, isolate_mode_t); - void (*putback_page)(struct page *); - int (*launder_page)(struct page *); - int (*is_partially_uptodate)(struct page *, long unsigned int, long unsigned int); - void (*is_dirty_writeback)(struct page *, bool *, bool *); - int (*error_remove_page)(struct address_space *, struct page *); - int (*swap_activate)(struct swap_info_struct *, struct file *, sector_t *); - void (*swap_deactivate)(struct file *); +enum x86_legacy_i8042_state { + X86_LEGACY_I8042_PLATFORM_ABSENT = 0, + X86_LEGACY_I8042_FIRMWARE_ABSENT = 1, + X86_LEGACY_I8042_EXPECTED_PRESENT = 2, }; -struct hd_struct; +struct x86_legacy_features { + enum x86_legacy_i8042_state i8042; + int rtc; + int warm_reset; + int no_vga; + int reserve_bios_regions; + struct x86_legacy_devices devices; +}; -struct gendisk; +struct x86_hyper_runtime { + void (*pin_vcpu)(int); +}; -struct block_device { - dev_t bd_dev; - int bd_openers; - struct inode *bd_inode; - struct super_block *bd_super; - struct mutex bd_mutex; - void *bd_claiming; - void *bd_holder; - int bd_holders; - bool bd_write_holder; - struct list_head bd_holder_disks; - struct block_device *bd_contains; - unsigned int bd_block_size; - u8 bd_partno; - struct hd_struct *bd_part; - unsigned int bd_part_count; - int bd_invalidated; - struct gendisk *bd_disk; - struct request_queue *bd_queue; - struct backing_dev_info *bd_bdi; - struct list_head bd_list; - long unsigned int bd_private; - int bd_fsfreeze_count; - struct mutex bd_fsfreeze_mutex; +struct x86_platform_ops { + long unsigned int (*calibrate_cpu)(); + long unsigned int (*calibrate_tsc)(); + void (*get_wallclock)(struct timespec64 *); + int (*set_wallclock)(const struct timespec64 *); + void (*iommu_shutdown)(); + bool (*is_untracked_pat_range)(u64, u64); + void (*nmi_init)(); + unsigned char (*get_nmi_reason)(); + void (*save_sched_clock_state)(); + void (*restore_sched_clock_state)(); + void (*apic_post_init)(); + struct x86_legacy_features legacy; + void (*set_legacy_features)(); + struct x86_hyper_runtime hyper; }; -typedef void *fl_owner_t; +struct pci_dev; -struct dir_context; +struct x86_msi_ops { + int (*setup_msi_irqs)(struct pci_dev *, int, int); + void (*teardown_msi_irq)(unsigned int); + void (*teardown_msi_irqs)(struct pci_dev *); + void (*restore_msi_irqs)(struct pci_dev *); +}; -struct poll_table_struct; +struct x86_apic_ops { + unsigned int (*io_apic_read)(unsigned int, unsigned int); + void (*restore)(); +}; -struct file_lock; +struct physid_mask { + long unsigned int mask[512]; +}; -struct seq_file; +typedef struct physid_mask physid_mask_t; -struct file_operations { - struct module *owner; - loff_t (*llseek)(struct file *, loff_t, int); - ssize_t (*read)(struct file *, char *, size_t, loff_t *); - ssize_t (*write)(struct file *, const char *, size_t, loff_t *); - ssize_t (*read_iter)(struct kiocb *, struct iov_iter *); - ssize_t (*write_iter)(struct kiocb *, struct iov_iter *); - int (*iopoll)(struct kiocb *, bool); - int (*iterate)(struct file *, struct dir_context *); - int (*iterate_shared)(struct file *, struct dir_context *); - __poll_t (*poll)(struct file *, struct poll_table_struct *); - long int (*unlocked_ioctl)(struct file *, unsigned int, long unsigned int); - long int (*compat_ioctl)(struct file *, unsigned int, long unsigned int); - int (*mmap)(struct file *, struct vm_area_struct *); - long unsigned int mmap_supported_flags; - int (*open)(struct inode *, struct file *); - int (*flush)(struct file *, fl_owner_t); - int (*release)(struct inode *, struct file *); - int (*fsync)(struct file *, loff_t, loff_t, int); - int (*fasync)(int, struct file *, int); - int (*lock)(struct file *, int, struct file_lock *); - ssize_t (*sendpage)(struct file *, struct page *, int, size_t, loff_t *, int); - long unsigned int (*get_unmapped_area)(struct file *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); - int (*check_flags)(int); - int (*flock)(struct file *, int, struct file_lock *); - ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int); - ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); - int (*setlease)(struct file *, long int, struct file_lock **, void **); - long int (*fallocate)(struct file *, int, loff_t, loff_t); - void (*show_fdinfo)(struct seq_file *, struct file *); - ssize_t (*copy_file_range)(struct file *, loff_t, struct file *, loff_t, size_t, unsigned int); - loff_t (*remap_file_range)(struct file *, loff_t, struct file *, loff_t, loff_t, unsigned int); - int (*fadvise)(struct file *, loff_t, loff_t, int); +struct qrwlock { + union { + atomic_t cnts; + struct { + u8 wlocked; + u8 __lstate[3]; + }; + }; + arch_spinlock_t wait_lock; }; -struct fiemap_extent_info; +typedef struct qrwlock arch_rwlock_t; -struct inode_operations { - struct dentry * (*lookup)(struct inode *, struct dentry *, unsigned int); - const char * (*get_link)(struct dentry *, struct inode *, struct delayed_call *); - int (*permission)(struct inode *, int); - struct posix_acl * (*get_acl)(struct inode *, int); - int (*readlink)(struct dentry *, char *, int); - int (*create)(struct inode *, struct dentry *, umode_t, bool); - int (*link)(struct dentry *, struct inode *, struct dentry *); - int (*unlink)(struct inode *, struct dentry *); - int (*symlink)(struct inode *, struct dentry *, const char *); - int (*mkdir)(struct inode *, struct dentry *, umode_t); - int (*rmdir)(struct inode *, struct dentry *); - int (*mknod)(struct inode *, struct dentry *, umode_t, dev_t); - int (*rename)(struct inode *, struct dentry *, struct inode *, struct dentry *, unsigned int); - int (*setattr)(struct dentry *, struct iattr *); - int (*getattr)(const struct path *, struct kstat *, u32, unsigned int); - ssize_t (*listxattr)(struct dentry *, char *, size_t); - int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64, u64); - int (*update_time)(struct inode *, struct timespec64 *, int); - int (*atomic_open)(struct inode *, struct dentry *, struct file *, unsigned int, umode_t); - int (*tmpfile)(struct inode *, struct dentry *, umode_t); - int (*set_acl)(struct inode *, struct posix_acl *, int); - long: 64; - long: 64; - long: 64; -}; +typedef struct { + arch_rwlock_t raw_lock; +} rwlock_t; -struct file_lock_context { - spinlock_t flc_lock; - struct list_head flc_flock; - struct list_head flc_posix; - struct list_head flc_lease; +struct rw_semaphore { + atomic_long_t count; + atomic_long_t owner; + struct optimistic_spin_queue osq; + raw_spinlock_t wait_lock; + struct list_head wait_list; }; -struct file_lock_operations { - void (*fl_copy_lock)(struct file_lock *, struct file_lock *); - void (*fl_release_private)(struct file_lock *); +struct vdso_image { + void *data; + long unsigned int size; + long unsigned int alt; + long unsigned int alt_len; + long int sym_vvar_start; + long int sym_vvar_page; + long int sym_pvclock_page; + long int sym_hvclock_page; + long int sym_VDSO32_NOTE_MASK; + long int sym___kernel_sigreturn; + long int sym___kernel_rt_sigreturn; + long int sym___kernel_vsyscall; + long int sym_int80_landing_pad; }; -struct nlm_lockowner; +struct ldt_struct; -struct nfs_lock_info { - u32 state; - struct nlm_lockowner *owner; - struct list_head list; +typedef struct { + u64 ctx_id; + atomic64_t tlb_gen; + struct rw_semaphore ldt_usr_sem; + struct ldt_struct *ldt; + short unsigned int ia32_compat; + struct mutex lock; + void *vdso; + const struct vdso_image *vdso_image; + atomic_t perf_rdpmc_allowed; + u16 pkey_allocation_map; + s16 execute_only_pkey; +} mm_context_t; + +struct fwnode_operations; + +struct device; + +struct fwnode_handle { + struct fwnode_handle *secondary; + const struct fwnode_operations *ops; + struct device *dev; }; -struct nfs4_lock_state; +struct fwnode_reference_args; -struct nfs4_lock_info { - struct nfs4_lock_state *owner; +struct fwnode_endpoint; + +struct fwnode_operations { + struct fwnode_handle * (*get)(struct fwnode_handle *); + void (*put)(struct fwnode_handle *); + bool (*device_is_available)(const struct fwnode_handle *); + const void * (*device_get_match_data)(const struct fwnode_handle *, const struct device *); + bool (*property_present)(const struct fwnode_handle *, const char *); + int (*property_read_int_array)(const struct fwnode_handle *, const char *, unsigned int, void *, size_t); + int (*property_read_string_array)(const struct fwnode_handle *, const char *, const char **, size_t); + const char * (*get_name)(const struct fwnode_handle *); + const char * (*get_name_prefix)(const struct fwnode_handle *); + struct fwnode_handle * (*get_parent)(const struct fwnode_handle *); + struct fwnode_handle * (*get_next_child_node)(const struct fwnode_handle *, struct fwnode_handle *); + struct fwnode_handle * (*get_named_child_node)(const struct fwnode_handle *, const char *); + int (*get_reference_args)(const struct fwnode_handle *, const char *, const char *, unsigned int, unsigned int, struct fwnode_reference_args *); + struct fwnode_handle * (*graph_get_next_endpoint)(const struct fwnode_handle *, struct fwnode_handle *); + struct fwnode_handle * (*graph_get_remote_endpoint)(const struct fwnode_handle *); + struct fwnode_handle * (*graph_get_port_parent)(struct fwnode_handle *); + int (*graph_parse_endpoint)(const struct fwnode_handle *, struct fwnode_endpoint *); + int (*add_links)(const struct fwnode_handle *, struct device *); }; -struct fasync_struct; +struct kref { + refcount_t refcount; +}; -struct lock_manager_operations; +struct kset; -struct file_lock { - struct file_lock *fl_blocker; - struct list_head fl_list; - struct hlist_node fl_link; - struct list_head fl_blocked_requests; - struct list_head fl_blocked_member; - fl_owner_t fl_owner; - unsigned int fl_flags; - unsigned char fl_type; - unsigned int fl_pid; - int fl_link_cpu; - wait_queue_head_t fl_wait; - struct file *fl_file; - loff_t fl_start; - loff_t fl_end; - struct fasync_struct *fl_fasync; - long unsigned int fl_break_time; - long unsigned int fl_downgrade_time; - const struct file_lock_operations *fl_ops; - const struct lock_manager_operations *fl_lmops; - union { - struct nfs_lock_info nfs_fl; - struct nfs4_lock_info nfs4_fl; - struct { - struct list_head link; - int state; - unsigned int debug_id; - } afs; - } fl_u; +struct kobj_type; + +struct kernfs_node; + +struct kobject { + const char *name; + struct list_head entry; + struct kobject *parent; + struct kset *kset; + struct kobj_type *ktype; + struct kernfs_node *sd; + struct kref kref; + unsigned int state_initialized: 1; + unsigned int state_in_sysfs: 1; + unsigned int state_add_uevent_sent: 1; + unsigned int state_remove_uevent_sent: 1; + unsigned int uevent_suppress: 1; }; -struct lock_manager_operations { - fl_owner_t (*lm_get_owner)(fl_owner_t); - void (*lm_put_owner)(fl_owner_t); - void (*lm_notify)(struct file_lock *); - int (*lm_grant)(struct file_lock *, int); - bool (*lm_break)(struct file_lock *); - int (*lm_change)(struct file_lock *, int, struct list_head *); - void (*lm_setup)(struct file_lock *, void **); +enum dl_dev_state { + DL_DEV_NO_DRIVER = 0, + DL_DEV_PROBING = 1, + DL_DEV_DRIVER_BOUND = 2, + DL_DEV_UNBINDING = 3, }; -struct fasync_struct { - rwlock_t fa_lock; - int magic; - int fa_fd; - struct fasync_struct *fa_next; - struct file *fa_file; - struct callback_head fa_rcu; +struct dev_links_info { + struct list_head suppliers; + struct list_head consumers; + struct list_head needs_suppliers; + struct list_head defer_sync; + bool need_for_probe; + enum dl_dev_state status; }; -struct fs_context; +struct pm_message { + int event; +}; -struct fs_parameter_description; +typedef struct pm_message pm_message_t; -struct file_system_type { - const char *name; - int fs_flags; - int (*init_fs_context)(struct fs_context *); - const struct fs_parameter_description *parameters; - struct dentry * (*mount)(struct file_system_type *, int, const char *, void *); - void (*kill_sb)(struct super_block *); - struct module *owner; - struct file_system_type *next; - struct hlist_head fs_supers; - struct lock_class_key s_lock_key; - struct lock_class_key s_umount_key; - struct lock_class_key s_vfs_rename_key; - struct lock_class_key s_writers_key[3]; - struct lock_class_key i_lock_key; - struct lock_class_key i_mutex_key; - struct lock_class_key i_mutex_dir_key; +struct wait_queue_head { + spinlock_t lock; + struct list_head head; }; -struct kstatfs; +typedef struct wait_queue_head wait_queue_head_t; -struct super_operations { - struct inode * (*alloc_inode)(struct super_block *); - void (*destroy_inode)(struct inode *); - void (*free_inode)(struct inode *); - void (*dirty_inode)(struct inode *, int); - int (*write_inode)(struct inode *, struct writeback_control *); - int (*drop_inode)(struct inode *); - void (*evict_inode)(struct inode *); - void (*put_super)(struct super_block *); - int (*sync_fs)(struct super_block *, int); - int (*freeze_super)(struct super_block *); - int (*freeze_fs)(struct super_block *); - int (*thaw_super)(struct super_block *); - int (*unfreeze_fs)(struct super_block *); - int (*statfs)(struct dentry *, struct kstatfs *); - int (*remount_fs)(struct super_block *, int *, char *); - void (*umount_begin)(struct super_block *); - int (*show_options)(struct seq_file *, struct dentry *); - int (*show_devname)(struct seq_file *, struct dentry *); - int (*show_path)(struct seq_file *, struct dentry *); - int (*show_stats)(struct seq_file *, struct dentry *); - ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t); - ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t); - struct dquot ** (*get_dquots)(struct inode *); - int (*bdev_try_to_free_page)(struct super_block *, struct page *, gfp_t); - long int (*nr_cached_objects)(struct super_block *, struct shrink_control *); - long int (*free_cached_objects)(struct super_block *, struct shrink_control *); +struct completion { + unsigned int done; + wait_queue_head_t wait; }; -struct iomap; - -struct inode___2; +struct work_struct; -struct dentry___2; +typedef void (*work_func_t)(struct work_struct *); -struct super_block___2; +struct work_struct { + atomic_long_t data; + struct list_head entry; + work_func_t func; +}; -struct fid; +enum rpm_request { + RPM_REQ_NONE = 0, + RPM_REQ_IDLE = 1, + RPM_REQ_SUSPEND = 2, + RPM_REQ_AUTOSUSPEND = 3, + RPM_REQ_RESUME = 4, +}; -struct export_operations { - int (*encode_fh)(struct inode___2 *, __u32 *, int *, struct inode___2 *); - struct dentry___2 * (*fh_to_dentry)(struct super_block___2 *, struct fid *, int, int); - struct dentry___2 * (*fh_to_parent)(struct super_block___2 *, struct fid *, int, int); - int (*get_name)(struct dentry___2 *, char *, struct dentry___2 *); - struct dentry___2 * (*get_parent)(struct dentry___2 *); - int (*commit_metadata)(struct inode___2 *); - int (*get_uuid)(struct super_block___2 *, u8 *, u32 *, u64 *); - int (*map_blocks)(struct inode___2 *, loff_t, u64, struct iomap *, bool, u32 *); - int (*commit_blocks)(struct inode___2 *, struct iomap *, int, struct iattr *); +enum rpm_status { + RPM_ACTIVE = 0, + RPM_RESUMING = 1, + RPM_SUSPENDED = 2, + RPM_SUSPENDING = 3, }; -struct xattr_handler { - const char *name; - const char *prefix; - int flags; - bool (*list)(struct dentry *); - int (*get)(const struct xattr_handler *, struct dentry *, struct inode *, const char *, void *, size_t); - int (*set)(const struct xattr_handler *, struct dentry *, struct inode *, const char *, const void *, size_t, int); +struct wakeup_source; + +struct wake_irq; + +struct pm_subsys_data; + +struct dev_pm_qos; + +struct dev_pm_info { + pm_message_t power_state; + unsigned int can_wakeup: 1; + unsigned int async_suspend: 1; + bool in_dpm_list: 1; + bool is_prepared: 1; + bool is_suspended: 1; + bool is_noirq_suspended: 1; + bool is_late_suspended: 1; + bool no_pm: 1; + bool early_init: 1; + bool direct_complete: 1; + u32 driver_flags; + spinlock_t lock; + struct list_head entry; + struct completion completion; + struct wakeup_source *wakeup; + bool wakeup_path: 1; + bool syscore: 1; + bool no_pm_callbacks: 1; + unsigned int must_resume: 1; + unsigned int may_skip_resume: 1; + struct hrtimer suspend_timer; + long unsigned int timer_expires; + struct work_struct work; + wait_queue_head_t wait_queue; + struct wake_irq *wakeirq; + atomic_t usage_count; + atomic_t child_count; + unsigned int disable_depth: 3; + unsigned int idle_notification: 1; + unsigned int request_pending: 1; + unsigned int deferred_resume: 1; + unsigned int runtime_auto: 1; + bool ignore_children: 1; + unsigned int no_callbacks: 1; + unsigned int irq_safe: 1; + unsigned int use_autosuspend: 1; + unsigned int timer_autosuspends: 1; + unsigned int memalloc_noio: 1; + unsigned int links_count; + enum rpm_request request; + enum rpm_status runtime_status; + int runtime_error; + int autosuspend_delay; + u64 last_busy; + u64 active_time; + u64 suspended_time; + u64 accounting_timestamp; + struct pm_subsys_data *subsys_data; + void (*set_latency_tolerance)(struct device *, s32); + struct dev_pm_qos *qos; }; -struct fiemap_extent_info { - unsigned int fi_flags; - unsigned int fi_extents_mapped; - unsigned int fi_extents_max; - struct fiemap_extent *fi_extents_start; +struct dev_archdata { + void *iommu; }; -typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64, unsigned int); +struct device_private; -struct dir_context { - filldir_t actor; - loff_t pos; -}; +struct device_type; -struct fs_parameter_spec; +struct bus_type; -struct fs_parameter_enum; +struct device_driver; -struct fs_parameter_description { - char name[16]; - const struct fs_parameter_spec *specs; - const struct fs_parameter_enum *enums; +struct dev_pm_domain; + +struct irq_domain; + +struct dma_map_ops; + +struct device_dma_parameters; + +struct device_node; + +struct class; + +struct attribute_group; + +struct iommu_group; + +struct iommu_fwspec; + +struct iommu_param; + +struct device { + struct kobject kobj; + struct device *parent; + struct device_private *p; + const char *init_name; + const struct device_type *type; + struct bus_type *bus; + struct device_driver *driver; + void *platform_data; + void *driver_data; + struct mutex mutex; + struct dev_links_info links; + struct dev_pm_info power; + struct dev_pm_domain *pm_domain; + struct irq_domain *msi_domain; + struct list_head msi_list; + const struct dma_map_ops *dma_ops; + u64 *dma_mask; + u64 coherent_dma_mask; + u64 bus_dma_limit; + long unsigned int dma_pfn_offset; + struct device_dma_parameters *dma_parms; + struct list_head dma_pools; + struct dev_archdata archdata; + struct device_node *of_node; + struct fwnode_handle *fwnode; + int numa_node; + dev_t devt; + u32 id; + spinlock_t devres_lock; + struct list_head devres_head; + struct class *class; + const struct attribute_group **groups; + void (*release)(struct device *); + struct iommu_group *iommu_group; + struct iommu_fwspec *iommu_fwspec; + struct iommu_param *iommu_param; + bool offline_disabled: 1; + bool offline: 1; + bool of_node_reused: 1; + bool state_synced: 1; }; -typedef void compound_page_dtor(struct page *); +struct fwnode_endpoint { + unsigned int port; + unsigned int id; + const struct fwnode_handle *local_fwnode; +}; -enum vm_event_item { - PGPGIN = 0, - PGPGOUT = 1, - PSWPIN = 2, - PSWPOUT = 3, - PGALLOC_DMA = 4, - PGALLOC_DMA32 = 5, - PGALLOC_NORMAL = 6, - PGALLOC_MOVABLE = 7, - ALLOCSTALL_DMA = 8, - ALLOCSTALL_DMA32 = 9, - ALLOCSTALL_NORMAL = 10, - ALLOCSTALL_MOVABLE = 11, - PGSCAN_SKIP_DMA = 12, - PGSCAN_SKIP_DMA32 = 13, - PGSCAN_SKIP_NORMAL = 14, - PGSCAN_SKIP_MOVABLE = 15, - PGFREE = 16, - PGACTIVATE = 17, - PGDEACTIVATE = 18, - PGLAZYFREE = 19, - PGFAULT = 20, - PGMAJFAULT = 21, - PGLAZYFREED = 22, - PGREFILL = 23, - PGSTEAL_KSWAPD = 24, - PGSTEAL_DIRECT = 25, - PGSCAN_KSWAPD = 26, - PGSCAN_DIRECT = 27, - PGSCAN_DIRECT_THROTTLE = 28, - PGSCAN_ZONE_RECLAIM_FAILED = 29, - PGINODESTEAL = 30, - SLABS_SCANNED = 31, - KSWAPD_INODESTEAL = 32, - KSWAPD_LOW_WMARK_HIT_QUICKLY = 33, - KSWAPD_HIGH_WMARK_HIT_QUICKLY = 34, - PAGEOUTRUN = 35, - PGROTATED = 36, - DROP_PAGECACHE = 37, - DROP_SLAB = 38, - OOM_KILL = 39, - PGMIGRATE_SUCCESS = 40, - PGMIGRATE_FAIL = 41, - COMPACTMIGRATE_SCANNED = 42, - COMPACTFREE_SCANNED = 43, - COMPACTISOLATED = 44, - COMPACTSTALL = 45, - COMPACTFAIL = 46, - COMPACTSUCCESS = 47, - KCOMPACTD_WAKE = 48, - KCOMPACTD_MIGRATE_SCANNED = 49, - KCOMPACTD_FREE_SCANNED = 50, - HTLB_BUDDY_PGALLOC = 51, - HTLB_BUDDY_PGALLOC_FAIL = 52, - UNEVICTABLE_PGCULLED = 53, - UNEVICTABLE_PGSCANNED = 54, - UNEVICTABLE_PGRESCUED = 55, - UNEVICTABLE_PGMLOCKED = 56, - UNEVICTABLE_PGMUNLOCKED = 57, - UNEVICTABLE_PGCLEARED = 58, - UNEVICTABLE_PGSTRANDED = 59, - SWAP_RA = 60, - SWAP_RA_HIT = 61, - NR_VM_EVENT_ITEMS = 62, +struct fwnode_reference_args { + struct fwnode_handle *fwnode; + unsigned int nargs; + u64 args[8]; }; -struct vm_event_state { - long unsigned int event[62]; +struct vm_struct { + struct vm_struct *next; + void *addr; + long unsigned int size; + long unsigned int flags; + struct page **pages; + unsigned int nr_pages; + phys_addr_t phys_addr; + const void *caller; }; -enum memblock_flags { - MEMBLOCK_NONE = 0, - MEMBLOCK_HOTPLUG = 1, - MEMBLOCK_MIRROR = 2, - MEMBLOCK_NOMAP = 4, +struct real_mode_header { + u32 text_start; + u32 ro_end; + u32 trampoline_start; + u32 trampoline_header; + u32 trampoline_pgd; + u32 wakeup_start; + u32 wakeup_header; + u32 machine_real_restart_asm; + u32 machine_real_restart_seg; }; -struct memblock_region { - phys_addr_t base; - phys_addr_t size; - enum memblock_flags flags; - int nid; +enum fixed_addresses { + VSYSCALL_PAGE = 511, + FIX_DBGP_BASE = 512, + FIX_EARLYCON_MEM_BASE = 513, + FIX_OHCI1394_BASE = 514, + FIX_APIC_BASE = 515, + FIX_IO_APIC_BASE_0 = 516, + FIX_IO_APIC_BASE_END = 643, + __end_of_permanent_fixed_addresses = 644, + FIX_BTMAP_END = 1024, + FIX_BTMAP_BEGIN = 1535, + __end_of_fixed_addresses = 1536, }; -struct memblock_type { - long unsigned int cnt; - long unsigned int max; - phys_addr_t total_size; - struct memblock_region *regions; - char *name; +struct vm_userfaultfd_ctx {}; + +struct anon_vma; + +struct vm_operations_struct; + +struct vm_area_struct { + long unsigned int vm_start; + long unsigned int vm_end; + struct vm_area_struct *vm_next; + struct vm_area_struct *vm_prev; + struct rb_node vm_rb; + long unsigned int rb_subtree_gap; + struct mm_struct *vm_mm; + pgprot_t vm_page_prot; + long unsigned int vm_flags; + struct { + struct rb_node rb; + long unsigned int rb_subtree_last; + } shared; + struct list_head anon_vma_chain; + struct anon_vma *anon_vma; + const struct vm_operations_struct *vm_ops; + long unsigned int vm_pgoff; + struct file *vm_file; + void *vm_private_data; + atomic_long_t swap_readahead_info; + struct mempolicy *vm_policy; + struct vm_userfaultfd_ctx vm_userfaultfd_ctx; }; -struct memblock { - bool bottom_up; - phys_addr_t current_limit; - struct memblock_type memory; - struct memblock_type reserved; +struct mm_rss_stat { + atomic_long_t count[4]; }; -struct gdt_page { - struct desc_struct gdt[16]; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; -}; - -struct tlb_context { - u64 ctx_id; - u64 tlb_gen; -}; - -struct tlb_state { - struct mm_struct *loaded_mm; - union { - struct mm_struct *last_user_mm; - long unsigned int last_user_mm_ibpb; - }; - u16 loaded_mm_asid; - u16 next_asid; - bool is_lazy; - bool invalidate_other; - short unsigned int user_pcid_flush_mask; - long unsigned int cr4; - struct tlb_context ctxs[6]; -}; - -struct boot_params_to_save { - unsigned int start; - unsigned int len; -}; - -typedef s32 int32_t; - -typedef long unsigned int irq_hw_number_t; +struct xol_area; -struct kernel_symbol { - int value_offset; - int name_offset; - int namespace_offset; +struct uprobes_state { + struct xol_area *xol_area; }; -typedef int (*initcall_t)(); +struct linux_binfmt; -typedef int initcall_entry_t; +struct core_state; -struct obs_kernel_param { - const char *str; - int (*setup_func)(char *); - int early; -}; +struct kioctx_table; -enum system_states { - SYSTEM_BOOTING = 0, - SYSTEM_SCHEDULING = 1, - SYSTEM_RUNNING = 2, - SYSTEM_HALT = 3, - SYSTEM_POWER_OFF = 4, - SYSTEM_RESTART = 5, - SYSTEM_SUSPEND = 6, -}; +struct user_namespace; -struct bug_entry { - int bug_addr_disp; - int file_disp; - short unsigned int line; - short unsigned int flags; -}; +struct mmu_notifier_mm; -struct pollfd { - int fd; - short int events; - short int revents; +struct mm_struct { + struct { + struct vm_area_struct *mmap; + struct rb_root mm_rb; + u64 vmacache_seqnum; + long unsigned int (*get_unmapped_area)(struct file *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); + long unsigned int mmap_base; + long unsigned int mmap_legacy_base; + long unsigned int mmap_compat_base; + long unsigned int mmap_compat_legacy_base; + long unsigned int task_size; + long unsigned int highest_vm_end; + pgd_t *pgd; + atomic_t membarrier_state; + atomic_t mm_users; + atomic_t mm_count; + atomic_long_t pgtables_bytes; + int map_count; + spinlock_t page_table_lock; + struct rw_semaphore mmap_sem; + struct list_head mmlist; + long unsigned int hiwater_rss; + long unsigned int hiwater_vm; + long unsigned int total_vm; + long unsigned int locked_vm; + atomic64_t pinned_vm; + long unsigned int data_vm; + long unsigned int exec_vm; + long unsigned int stack_vm; + long unsigned int def_flags; + spinlock_t arg_lock; + long unsigned int start_code; + long unsigned int end_code; + long unsigned int start_data; + long unsigned int end_data; + long unsigned int start_brk; + long unsigned int brk; + long unsigned int start_stack; + long unsigned int arg_start; + long unsigned int arg_end; + long unsigned int env_start; + long unsigned int env_end; + long unsigned int saved_auxv[46]; + struct mm_rss_stat rss_stat; + struct linux_binfmt *binfmt; + mm_context_t context; + long unsigned int flags; + struct core_state *core_state; + spinlock_t ioctx_lock; + struct kioctx_table *ioctx_table; + struct user_namespace *user_ns; + struct file *exe_file; + struct mmu_notifier_mm *mmu_notifier_mm; + atomic_t tlb_flush_pending; + bool tlb_flush_batched; + struct uprobes_state uprobes_state; + atomic_long_t hugetlb_usage; + struct work_struct async_put_work; + }; + long unsigned int cpu_bitmap[0]; }; -typedef const int tracepoint_ptr_t; - -struct orc_entry { - s16 sp_offset; - s16 bp_offset; - unsigned int sp_reg: 4; - unsigned int bp_reg: 4; - unsigned int type: 2; - unsigned int end: 1; -} __attribute__((packed)); +typedef struct { + struct seqcount seqcount; + spinlock_t lock; +} seqlock_t; -enum perf_event_state { - PERF_EVENT_STATE_DEAD = 4294967292, - PERF_EVENT_STATE_EXIT = 4294967293, - PERF_EVENT_STATE_ERROR = 4294967294, - PERF_EVENT_STATE_OFF = 4294967295, - PERF_EVENT_STATE_INACTIVE = 0, - PERF_EVENT_STATE_ACTIVE = 1, +struct timer_list { + struct hlist_node entry; + long unsigned int expires; + void (*function)(struct timer_list *); + u32 flags; }; -typedef struct { - atomic_long_t a; -} local_t; +typedef int (*notifier_fn_t)(struct notifier_block *, long unsigned int, void *); -typedef struct { - local_t a; -} local64_t; +struct notifier_block { + notifier_fn_t notifier_call; + struct notifier_block *next; + int priority; +}; -struct perf_event_attr { - __u32 type; - __u32 size; - __u64 config; - union { - __u64 sample_period; - __u64 sample_freq; - }; - __u64 sample_type; - __u64 read_format; - __u64 disabled: 1; - __u64 inherit: 1; - __u64 pinned: 1; - __u64 exclusive: 1; - __u64 exclude_user: 1; - __u64 exclude_kernel: 1; - __u64 exclude_hv: 1; - __u64 exclude_idle: 1; - __u64 mmap: 1; - __u64 comm: 1; - __u64 freq: 1; - __u64 inherit_stat: 1; - __u64 enable_on_exec: 1; - __u64 task: 1; - __u64 watermark: 1; - __u64 precise_ip: 2; - __u64 mmap_data: 1; - __u64 sample_id_all: 1; - __u64 exclude_host: 1; - __u64 exclude_guest: 1; - __u64 exclude_callchain_kernel: 1; - __u64 exclude_callchain_user: 1; - __u64 mmap2: 1; - __u64 comm_exec: 1; - __u64 use_clockid: 1; - __u64 context_switch: 1; - __u64 write_backward: 1; - __u64 namespaces: 1; - __u64 ksymbol: 1; - __u64 bpf_event: 1; - __u64 aux_output: 1; - __u64 __reserved_1: 32; - union { - __u32 wakeup_events; - __u32 wakeup_watermark; - }; - __u32 bp_type; - union { - __u64 bp_addr; - __u64 kprobe_func; - __u64 uprobe_path; - __u64 config1; - }; - union { - __u64 bp_len; - __u64 kprobe_addr; - __u64 probe_offset; - __u64 config2; - }; - __u64 branch_sample_type; - __u64 sample_regs_user; - __u32 sample_stack_user; - __s32 clockid; - __u64 sample_regs_intr; - __u32 aux_watermark; - __u16 sample_max_stack; - __u16 __reserved_2; - __u32 aux_sample_size; - __u32 __reserved_3; +struct blocking_notifier_head { + struct rw_semaphore rwsem; + struct notifier_block *head; }; -struct hw_perf_event_extra { - u64 config; - unsigned int reg; - int alloc; - int idx; +struct arch_uprobe_task { + long unsigned int saved_scratch_register; + unsigned int saved_trap_nr; + unsigned int saved_tf; }; -struct arch_hw_breakpoint { - long unsigned int address; - long unsigned int mask; - u8 len; - u8 type; +enum uprobe_task_state { + UTASK_RUNNING = 0, + UTASK_SSTEP = 1, + UTASK_SSTEP_ACK = 2, + UTASK_SSTEP_TRAPPED = 3, }; -struct hw_perf_event { +struct uprobe; + +struct return_instance; + +struct uprobe_task { + enum uprobe_task_state state; union { struct { - u64 config; - u64 last_tag; - long unsigned int config_base; - long unsigned int event_base; - int event_base_rdpmc; - int idx; - int last_cpu; - int flags; - struct hw_perf_event_extra extra_reg; - struct hw_perf_event_extra branch_reg; - }; - struct { - struct hrtimer hrtimer; - }; - struct { - struct list_head tp_list; - }; - struct { - u64 pwr_acc; - u64 ptsc; - }; - struct { - struct arch_hw_breakpoint info; - struct list_head bp_list; + struct arch_uprobe_task autask; + long unsigned int vaddr; }; struct { - u8 iommu_bank; - u8 iommu_cntr; - u16 padding; - u64 conf; - u64 conf1; + struct callback_head dup_xol_work; + long unsigned int dup_xol_addr; }; }; - struct task_struct *target; - void *addr_filters; - long unsigned int addr_filters_gen; - int state; - local64_t prev_count; - u64 sample_period; - u64 last_period; - local64_t period_left; - u64 interrupts_seq; - u64 interrupts; - u64 freq_time_stamp; - u64 freq_count_stamp; + struct uprobe *active_uprobe; + long unsigned int xol_vaddr; + struct return_instance *return_instances; + unsigned int depth; }; -struct irq_work { - atomic_t flags; - struct llist_node llnode; - void (*func)(struct irq_work *); +struct return_instance { + struct uprobe *uprobe; + long unsigned int func; + long unsigned int stack; + long unsigned int orig_ret_vaddr; + bool chained; + struct return_instance *next; }; -struct perf_addr_filters_head { - struct list_head list; - raw_spinlock_t lock; - unsigned int nr_file_filters; +struct xarray { + spinlock_t xa_lock; + gfp_t xa_flags; + void *xa_head; }; -struct perf_sample_data; +typedef u32 errseq_t; -typedef void (*perf_overflow_handler_t)(struct perf_event *, struct perf_sample_data *, struct pt_regs *); +struct address_space_operations; -struct pmu; +struct address_space { + struct inode *host; + struct xarray i_pages; + gfp_t gfp_mask; + atomic_t i_mmap_writable; + struct rb_root_cached i_mmap; + struct rw_semaphore i_mmap_rwsem; + long unsigned int nrpages; + long unsigned int nrexceptional; + long unsigned int writeback_index; + const struct address_space_operations *a_ops; + long unsigned int flags; + errseq_t wb_err; + spinlock_t private_lock; + struct list_head private_list; + void *private_data; +}; -struct ring_buffer; +struct vmem_altmap { + const long unsigned int base_pfn; + const long unsigned int end_pfn; + const long unsigned int reserve; + long unsigned int free; + long unsigned int align; + long unsigned int alloc; +}; -struct perf_addr_filter_range; +struct resource { + resource_size_t start; + resource_size_t end; + const char *name; + long unsigned int flags; + long unsigned int desc; + struct resource *parent; + struct resource *sibling; + struct resource *child; +}; -struct trace_event_call; +struct percpu_ref; -struct event_filter; +typedef void percpu_ref_func_t(struct percpu_ref *); -struct perf_event { - struct list_head event_entry; - struct list_head sibling_list; - struct list_head active_list; - struct rb_node group_node; - u64 group_index; - struct list_head migrate_entry; - struct hlist_node hlist_entry; - struct list_head active_entry; - int nr_siblings; - int event_caps; - int group_caps; - struct perf_event *group_leader; - struct pmu *pmu; - void *pmu_private; - enum perf_event_state state; - unsigned int attach_state; - local64_t count; - atomic64_t child_count; - u64 total_time_enabled; - u64 total_time_running; - u64 tstamp; - u64 shadow_ctx_time; - struct perf_event_attr attr; - u16 header_size; - u16 id_header_size; - u16 read_size; - struct hw_perf_event hw; - struct perf_event_context *ctx; - atomic_long_t refcount; - atomic64_t child_total_time_enabled; - atomic64_t child_total_time_running; - struct mutex child_mutex; - struct list_head child_list; - struct perf_event *parent; - int oncpu; - int cpu; - struct list_head owner_entry; - struct task_struct *owner; - struct mutex mmap_mutex; - atomic_t mmap_count; - struct ring_buffer *rb; - struct list_head rb_entry; - long unsigned int rcu_batches; - int rcu_pending; - wait_queue_head_t waitq; - struct fasync_struct *fasync; - int pending_wakeup; - int pending_kill; - int pending_disable; - struct irq_work pending; - atomic_t event_limit; - struct perf_addr_filters_head addr_filters; - struct perf_addr_filter_range *addr_filter_ranges; - long unsigned int addr_filters_gen; - struct perf_event *aux_event; - void (*destroy)(struct perf_event *); - struct callback_head callback_head; - struct pid_namespace *ns; - u64 id; - u64 (*clock)(); - perf_overflow_handler_t overflow_handler; - void *overflow_handler_context; - struct trace_event_call *tp_event; - struct event_filter *filter; - void *security; - struct list_head sb_list; +struct percpu_ref { + atomic_long_t count; + long unsigned int percpu_count_ptr; + percpu_ref_func_t *release; + percpu_ref_func_t *confirm_switch; + bool force_atomic: 1; + bool allow_reinit: 1; + struct callback_head rcu; }; -struct lockdep_map {}; +enum memory_type { + MEMORY_DEVICE_PRIVATE = 1, + MEMORY_DEVICE_FS_DAX = 2, + MEMORY_DEVICE_DEVDAX = 3, + MEMORY_DEVICE_PCI_P2PDMA = 4, +}; -typedef struct { - struct seqcount seqcount; - spinlock_t lock; -} seqlock_t; +struct dev_pagemap_ops; -enum node_states { - N_POSSIBLE = 0, - N_ONLINE = 1, - N_NORMAL_MEMORY = 2, - N_HIGH_MEMORY = 2, - N_MEMORY = 3, - N_CPU = 4, - NR_NODE_STATES = 5, +struct dev_pagemap { + struct vmem_altmap altmap; + struct resource res; + struct percpu_ref *ref; + struct percpu_ref internal_ref; + struct completion done; + enum memory_type type; + unsigned int flags; + const struct dev_pagemap_ops *ops; }; -struct timer_list { - struct hlist_node entry; - long unsigned int expires; - void (*function)(struct timer_list *); - u32 flags; -}; +struct vfsmount; -struct delayed_work { - struct work_struct work; - struct timer_list timer; - struct workqueue_struct *wq; - int cpu; +struct path { + struct vfsmount *mnt; + struct dentry *dentry; }; -struct rcu_work { - struct work_struct work; - struct callback_head rcu; - struct workqueue_struct *wq; +enum rw_hint { + WRITE_LIFE_NOT_SET = 0, + WRITE_LIFE_NONE = 1, + WRITE_LIFE_SHORT = 2, + WRITE_LIFE_MEDIUM = 3, + WRITE_LIFE_LONG = 4, + WRITE_LIFE_EXTREME = 5, }; -struct rcu_segcblist { - struct callback_head *head; - struct callback_head **tails[4]; - long unsigned int gp_seq[4]; - long int len; - long int len_lazy; - u8 enabled; - u8 offloaded; +enum pid_type { + PIDTYPE_PID = 0, + PIDTYPE_TGID = 1, + PIDTYPE_PGID = 2, + PIDTYPE_SID = 3, + PIDTYPE_MAX = 4, }; -struct srcu_node; - -struct srcu_struct; - -struct srcu_data { - long unsigned int srcu_lock_count[2]; - long unsigned int srcu_unlock_count[2]; - long: 64; - long: 64; - long: 64; - long: 64; - spinlock_t lock; - struct rcu_segcblist srcu_cblist; - long unsigned int srcu_gp_seq_needed; - long unsigned int srcu_gp_seq_needed_exp; - bool srcu_cblist_invoking; - struct timer_list delay_work; - struct work_struct work; - struct callback_head srcu_barrier_head; - struct srcu_node *mynode; - long unsigned int grpmask; - int cpu; - struct srcu_struct *ssp; - long: 64; +struct fown_struct { + rwlock_t lock; + struct pid *pid; + enum pid_type pid_type; + kuid_t uid; + kuid_t euid; + int signum; }; -struct srcu_node { - spinlock_t lock; - long unsigned int srcu_have_cbs[4]; - long unsigned int srcu_data_have_cbs[4]; - long unsigned int srcu_gp_seq_needed_exp; - struct srcu_node *srcu_parent; - int grplo; - int grphi; +struct file_ra_state { + long unsigned int start; + unsigned int size; + unsigned int async_size; + unsigned int ra_pages; + unsigned int mmap_miss; + loff_t prev_pos; }; -struct srcu_struct { - struct srcu_node node[5]; - struct srcu_node *level[3]; - struct mutex srcu_cb_mutex; - spinlock_t lock; - struct mutex srcu_gp_mutex; - unsigned int srcu_idx; - long unsigned int srcu_gp_seq; - long unsigned int srcu_gp_seq_needed; - long unsigned int srcu_gp_seq_needed_exp; - long unsigned int srcu_last_gp_end; - struct srcu_data *sda; - long unsigned int srcu_barrier_seq; - struct mutex srcu_barrier_mutex; - struct completion srcu_barrier_completion; - atomic_t srcu_barrier_cpu_cnt; - struct delayed_work work; +struct file { + union { + struct llist_node fu_llist; + struct callback_head fu_rcuhead; + } f_u; + struct path f_path; + struct inode *f_inode; + const struct file_operations *f_op; + spinlock_t f_lock; + enum rw_hint f_write_hint; + atomic_long_t f_count; + unsigned int f_flags; + fmode_t f_mode; + struct mutex f_pos_lock; + loff_t f_pos; + struct fown_struct f_owner; + const struct cred *f_cred; + struct file_ra_state f_ra; + u64 f_version; + void *f_security; + void *private_data; + struct list_head f_ep_links; + struct list_head f_tfile_llink; + struct address_space *f_mapping; + errseq_t f_wb_err; }; -struct anon_vma { - struct anon_vma *root; - struct rw_semaphore rwsem; - atomic_t refcount; - unsigned int degree; - struct anon_vma *parent; - struct rb_root_cached rb_root; -}; +typedef unsigned int vm_fault_t; -struct mempolicy { - atomic_t refcnt; - short unsigned int mode; - short unsigned int flags; - union { - short int preferred_node; - nodemask_t nodes; - } v; - union { - nodemask_t cpuset_mems_allowed; - nodemask_t user_nodemask; - } w; +enum page_entry_size { + PE_SIZE_PTE = 0, + PE_SIZE_PMD = 1, + PE_SIZE_PUD = 2, }; -struct linux_binprm; - -struct coredump_params; +struct vm_fault; -struct linux_binfmt { - struct list_head lh; - struct module *module; - int (*load_binary)(struct linux_binprm *); - int (*load_shlib)(struct file *); - int (*core_dump)(struct coredump_params *); - long unsigned int min_coredump; +struct vm_operations_struct { + void (*open)(struct vm_area_struct *); + void (*close)(struct vm_area_struct *); + int (*split)(struct vm_area_struct *, long unsigned int); + int (*mremap)(struct vm_area_struct *); + vm_fault_t (*fault)(struct vm_fault *); + vm_fault_t (*huge_fault)(struct vm_fault *, enum page_entry_size); + void (*map_pages)(struct vm_fault *, long unsigned int, long unsigned int); + long unsigned int (*pagesize)(struct vm_area_struct *); + vm_fault_t (*page_mkwrite)(struct vm_fault *); + vm_fault_t (*pfn_mkwrite)(struct vm_fault *); + int (*access)(struct vm_area_struct *, long unsigned int, void *, int, int); + const char * (*name)(struct vm_area_struct *); + int (*set_policy)(struct vm_area_struct *, struct mempolicy *); + struct mempolicy * (*get_policy)(struct vm_area_struct *, long unsigned int); + struct page * (*find_special_page)(struct vm_area_struct *, long unsigned int); }; -struct uid_gid_extent { - u32 first; - u32 lower_first; - u32 count; +struct core_thread { + struct task_struct *task; + struct core_thread *next; }; -struct uid_gid_map { - u32 nr_extents; - union { - struct uid_gid_extent extent[5]; - struct { - struct uid_gid_extent *forward; - struct uid_gid_extent *reverse; - }; - }; +struct core_state { + atomic_t nr_threads; + struct core_thread dumper; + struct completion startup; }; -struct proc_ns_operations; +struct mem_cgroup; -struct ns_common { - atomic_long_t stashed; - const struct proc_ns_operations *ops; - unsigned int inum; +struct vm_fault { + struct vm_area_struct *vma; + unsigned int flags; + gfp_t gfp_mask; + long unsigned int pgoff; + long unsigned int address; + pmd_t *pmd; + pud_t *pud; + pte_t orig_pte; + struct page *cow_page; + struct mem_cgroup *memcg; + struct page *page; + pte_t *pte; + spinlock_t *ptl; + pgtable_t prealloc_pte; }; -struct ctl_table; - -struct ctl_table_root; - -struct ctl_table_set; - -struct ctl_dir; - -struct ctl_node; +typedef struct { + u16 __softirq_pending; + unsigned int __nmi_count; + unsigned int apic_timer_irqs; + unsigned int irq_spurious_count; + unsigned int icr_read_retry_count; + unsigned int kvm_posted_intr_ipis; + unsigned int kvm_posted_intr_wakeup_ipis; + unsigned int kvm_posted_intr_nested_ipis; + unsigned int x86_platform_ipis; + unsigned int apic_perf_irqs; + unsigned int apic_irq_work_irqs; + unsigned int irq_resched_count; + unsigned int irq_call_count; + unsigned int irq_tlb_count; + unsigned int irq_thermal_count; + unsigned int irq_threshold_count; + unsigned int irq_deferred_error_count; + long: 32; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +} irq_cpustat_t; -struct ctl_table_header { - union { - struct { - struct ctl_table *ctl_table; - int used; - int count; - int nreg; - }; - struct callback_head rcu; - }; - struct completion *unregistering; - struct ctl_table *ctl_table_arg; - struct ctl_table_root *root; - struct ctl_table_set *set; - struct ctl_dir *parent; - struct ctl_node *node; - struct hlist_head inodes; +enum apic_intr_mode_id { + APIC_PIC = 0, + APIC_VIRTUAL_WIRE = 1, + APIC_VIRTUAL_WIRE_NO_CONFIG = 2, + APIC_SYMMETRIC_IO = 3, + APIC_SYMMETRIC_IO_NO_ROUTING = 4, }; -struct ctl_dir { - struct ctl_table_header header; - struct rb_root root; +struct apic { + void (*eoi_write)(u32, u32); + void (*native_eoi_write)(u32, u32); + void (*write)(u32, u32); + u32 (*read)(u32); + void (*wait_icr_idle)(); + u32 (*safe_wait_icr_idle)(); + void (*send_IPI)(int, int); + void (*send_IPI_mask)(const struct cpumask *, int); + void (*send_IPI_mask_allbutself)(const struct cpumask *, int); + void (*send_IPI_allbutself)(int); + void (*send_IPI_all)(int); + void (*send_IPI_self)(int); + u32 dest_logical; + u32 disable_esr; + u32 irq_delivery_mode; + u32 irq_dest_mode; + u32 (*calc_dest_apicid)(unsigned int); + u64 (*icr_read)(); + void (*icr_write)(u32, u32); + int (*probe)(); + int (*acpi_madt_oem_check)(char *, char *); + int (*apic_id_valid)(u32); + int (*apic_id_registered)(); + bool (*check_apicid_used)(physid_mask_t *, int); + void (*init_apic_ldr)(); + void (*ioapic_phys_id_map)(physid_mask_t *, physid_mask_t *); + void (*setup_apic_routing)(); + int (*cpu_present_to_apicid)(int); + void (*apicid_to_cpu_present)(int, physid_mask_t *); + int (*check_phys_apicid_present)(int); + int (*phys_pkg_id)(int, int); + u32 (*get_apic_id)(long unsigned int); + u32 (*set_apic_id)(unsigned int); + int (*wakeup_secondary_cpu)(int, long unsigned int); + void (*inquire_remote_apic)(int); + char *name; }; -struct ctl_table_set { - int (*is_seen)(struct ctl_table_set *); - struct ctl_dir dir; +struct smp_ops { + void (*smp_prepare_boot_cpu)(); + void (*smp_prepare_cpus)(unsigned int); + void (*smp_cpus_done)(unsigned int); + void (*stop_other_cpus)(int); + void (*crash_stop_other_cpus)(); + void (*smp_send_reschedule)(int); + int (*cpu_up)(unsigned int, struct task_struct *); + int (*cpu_disable)(); + void (*cpu_die)(unsigned int); + void (*play_dead)(); + void (*send_call_func_ipi)(const struct cpumask *); + void (*send_call_func_single_ipi)(int); }; -struct ucounts; - -struct user_namespace { - struct uid_gid_map uid_map; - struct uid_gid_map gid_map; - struct uid_gid_map projid_map; - atomic_t count; - struct user_namespace *parent; - int level; - kuid_t owner; - kgid_t group; - struct ns_common ns; - long unsigned int flags; - struct list_head keyring_name_list; - struct key *user_keyring_register; - struct rw_semaphore keyring_sem; - struct work_struct work; - struct ctl_table_set set; - struct ctl_table_header *sysctls; - struct ucounts *ucounts; - int ucount_max[9]; +enum pcpu_fc { + PCPU_FC_AUTO = 0, + PCPU_FC_EMBED = 1, + PCPU_FC_PAGE = 2, + PCPU_FC_NR = 3, }; -typedef struct pglist_data pg_data_t; - -struct fwnode_operations; - -struct device; - -struct fwnode_handle { - struct fwnode_handle *secondary; - const struct fwnode_operations *ops; - struct device *dev; +struct free_area { + struct list_head free_list[4]; + long unsigned int nr_free; }; -struct fwnode_reference_args; +struct zone_padding { + char x[0]; +}; -struct fwnode_endpoint; +enum numa_stat_item { + NUMA_HIT = 0, + NUMA_MISS = 1, + NUMA_FOREIGN = 2, + NUMA_INTERLEAVE_HIT = 3, + NUMA_LOCAL = 4, + NUMA_OTHER = 5, + NR_VM_NUMA_STAT_ITEMS = 6, +}; -struct fwnode_operations { - struct fwnode_handle * (*get)(struct fwnode_handle *); - void (*put)(struct fwnode_handle *); - bool (*device_is_available)(const struct fwnode_handle *); - const void * (*device_get_match_data)(const struct fwnode_handle *, const struct device *); - bool (*property_present)(const struct fwnode_handle *, const char *); - int (*property_read_int_array)(const struct fwnode_handle *, const char *, unsigned int, void *, size_t); - int (*property_read_string_array)(const struct fwnode_handle *, const char *, const char **, size_t); - const char * (*get_name)(const struct fwnode_handle *); - const char * (*get_name_prefix)(const struct fwnode_handle *); - struct fwnode_handle * (*get_parent)(const struct fwnode_handle *); - struct fwnode_handle * (*get_next_child_node)(const struct fwnode_handle *, struct fwnode_handle *); - struct fwnode_handle * (*get_named_child_node)(const struct fwnode_handle *, const char *); - int (*get_reference_args)(const struct fwnode_handle *, const char *, const char *, unsigned int, unsigned int, struct fwnode_reference_args *); - struct fwnode_handle * (*graph_get_next_endpoint)(const struct fwnode_handle *, struct fwnode_handle *); - struct fwnode_handle * (*graph_get_remote_endpoint)(const struct fwnode_handle *); - struct fwnode_handle * (*graph_get_port_parent)(struct fwnode_handle *); - int (*graph_parse_endpoint)(const struct fwnode_handle *, struct fwnode_endpoint *); - int (*add_links)(const struct fwnode_handle *, struct device *); +enum zone_stat_item { + NR_FREE_PAGES = 0, + NR_ZONE_LRU_BASE = 1, + NR_ZONE_INACTIVE_ANON = 1, + NR_ZONE_ACTIVE_ANON = 2, + NR_ZONE_INACTIVE_FILE = 3, + NR_ZONE_ACTIVE_FILE = 4, + NR_ZONE_UNEVICTABLE = 5, + NR_ZONE_WRITE_PENDING = 6, + NR_MLOCK = 7, + NR_PAGETABLE = 8, + NR_KERNEL_STACK_KB = 9, + NR_BOUNCE = 10, + NR_FREE_CMA_PAGES = 11, + NR_VM_ZONE_STAT_ITEMS = 12, }; -struct kref { - refcount_t refcount; +enum node_stat_item { + NR_LRU_BASE = 0, + NR_INACTIVE_ANON = 0, + NR_ACTIVE_ANON = 1, + NR_INACTIVE_FILE = 2, + NR_ACTIVE_FILE = 3, + NR_UNEVICTABLE = 4, + NR_SLAB_RECLAIMABLE = 5, + NR_SLAB_UNRECLAIMABLE = 6, + NR_ISOLATED_ANON = 7, + NR_ISOLATED_FILE = 8, + WORKINGSET_NODES = 9, + WORKINGSET_REFAULT = 10, + WORKINGSET_ACTIVATE = 11, + WORKINGSET_RESTORE = 12, + WORKINGSET_NODERECLAIM = 13, + NR_ANON_MAPPED = 14, + NR_FILE_MAPPED = 15, + NR_FILE_PAGES = 16, + NR_FILE_DIRTY = 17, + NR_WRITEBACK = 18, + NR_WRITEBACK_TEMP = 19, + NR_SHMEM = 20, + NR_SHMEM_THPS = 21, + NR_SHMEM_PMDMAPPED = 22, + NR_FILE_THPS = 23, + NR_FILE_PMDMAPPED = 24, + NR_ANON_THPS = 25, + NR_UNSTABLE_NFS = 26, + NR_VMSCAN_WRITE = 27, + NR_VMSCAN_IMMEDIATE = 28, + NR_DIRTIED = 29, + NR_WRITTEN = 30, + NR_KERNEL_MISC_RECLAIMABLE = 31, + NR_VM_NODE_STAT_ITEMS = 32, }; -struct kset; +struct zone_reclaim_stat { + long unsigned int recent_rotated[2]; + long unsigned int recent_scanned[2]; +}; -struct kobj_type; +struct lruvec { + struct list_head lists[5]; + struct zone_reclaim_stat reclaim_stat; + atomic_long_t inactive_age; + long unsigned int refaults; + long unsigned int flags; +}; -struct kernfs_node; +typedef unsigned int isolate_mode_t; -struct kobject { - const char *name; - struct list_head entry; - struct kobject *parent; - struct kset *kset; - struct kobj_type *ktype; - struct kernfs_node *sd; - struct kref kref; - unsigned int state_initialized: 1; - unsigned int state_in_sysfs: 1; - unsigned int state_add_uevent_sent: 1; - unsigned int state_remove_uevent_sent: 1; - unsigned int uevent_suppress: 1; +struct per_cpu_pages { + int count; + int high; + int batch; + struct list_head lists[3]; }; -enum dl_dev_state { - DL_DEV_NO_DRIVER = 0, - DL_DEV_PROBING = 1, - DL_DEV_DRIVER_BOUND = 2, - DL_DEV_UNBINDING = 3, +struct per_cpu_pageset { + struct per_cpu_pages pcp; + s8 expire; + u16 vm_numa_stat_diff[6]; + s8 stat_threshold; + s8 vm_stat_diff[12]; }; -struct dev_links_info { - struct list_head suppliers; - struct list_head consumers; - struct list_head needs_suppliers; - struct list_head defer_sync; - bool need_for_probe; - enum dl_dev_state status; +struct per_cpu_nodestat { + s8 stat_threshold; + s8 vm_node_stat_diff[32]; }; -struct pm_message { - int event; +enum zone_type { + ZONE_DMA = 0, + ZONE_DMA32 = 1, + ZONE_NORMAL = 2, + ZONE_MOVABLE = 3, + __MAX_NR_ZONES = 4, }; -typedef struct pm_message pm_message_t; +struct pglist_data; -enum rpm_request { - RPM_REQ_NONE = 0, - RPM_REQ_IDLE = 1, - RPM_REQ_SUSPEND = 2, - RPM_REQ_AUTOSUSPEND = 3, - RPM_REQ_RESUME = 4, +struct zone { + long unsigned int _watermark[3]; + long unsigned int watermark_boost; + long unsigned int nr_reserved_highatomic; + long int lowmem_reserve[4]; + int node; + struct pglist_data *zone_pgdat; + struct per_cpu_pageset *pageset; + long unsigned int zone_start_pfn; + atomic_long_t managed_pages; + long unsigned int spanned_pages; + long unsigned int present_pages; + const char *name; + int initialized; + long: 32; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct zone_padding _pad1_; + struct free_area free_area[11]; + long unsigned int flags; + spinlock_t lock; + long: 32; + long: 64; + long: 64; + long: 64; + struct zone_padding _pad2_; + long unsigned int percpu_drift_mark; + long unsigned int compact_cached_free_pfn; + long unsigned int compact_cached_migrate_pfn[2]; + long unsigned int compact_init_migrate_pfn; + long unsigned int compact_init_free_pfn; + unsigned int compact_considered; + unsigned int compact_defer_shift; + int compact_order_failed; + bool compact_blockskip_flush; + bool contiguous; + short: 16; + struct zone_padding _pad3_; + atomic_long_t vm_stat[12]; + atomic_long_t vm_numa_stat[6]; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -enum rpm_status { - RPM_ACTIVE = 0, - RPM_RESUMING = 1, - RPM_SUSPENDED = 2, - RPM_SUSPENDING = 3, +struct zoneref { + struct zone *zone; + int zone_idx; }; -struct wakeup_source; - -struct wake_irq; - -struct pm_subsys_data; - -struct dev_pm_qos; +struct zonelist { + struct zoneref _zonerefs[257]; +}; -struct dev_pm_info { - pm_message_t power_state; - unsigned int can_wakeup: 1; - unsigned int async_suspend: 1; - bool in_dpm_list: 1; - bool is_prepared: 1; - bool is_suspended: 1; - bool is_noirq_suspended: 1; - bool is_late_suspended: 1; - bool no_pm: 1; - bool early_init: 1; - bool direct_complete: 1; - u32 driver_flags; - spinlock_t lock; - struct list_head entry; - struct completion completion; - struct wakeup_source *wakeup; - bool wakeup_path: 1; - bool syscore: 1; - bool no_pm_callbacks: 1; - unsigned int must_resume: 1; - unsigned int may_skip_resume: 1; - struct hrtimer suspend_timer; - long unsigned int timer_expires; - struct work_struct work; - wait_queue_head_t wait_queue; - struct wake_irq *wakeirq; - atomic_t usage_count; - atomic_t child_count; - unsigned int disable_depth: 3; - unsigned int idle_notification: 1; - unsigned int request_pending: 1; - unsigned int deferred_resume: 1; - unsigned int runtime_auto: 1; - bool ignore_children: 1; - unsigned int no_callbacks: 1; - unsigned int irq_safe: 1; - unsigned int use_autosuspend: 1; - unsigned int timer_autosuspends: 1; - unsigned int memalloc_noio: 1; - unsigned int links_count; - enum rpm_request request; - enum rpm_status runtime_status; - int runtime_error; - int autosuspend_delay; - u64 last_busy; - u64 active_time; - u64 suspended_time; - u64 accounting_timestamp; - struct pm_subsys_data *subsys_data; - void (*set_latency_tolerance)(struct device *, s32); - struct dev_pm_qos *qos; +struct pglist_data { + struct zone node_zones[4]; + struct zonelist node_zonelists[2]; + int nr_zones; + long unsigned int node_start_pfn; + long unsigned int node_present_pages; + long unsigned int node_spanned_pages; + int node_id; + wait_queue_head_t kswapd_wait; + wait_queue_head_t pfmemalloc_wait; + struct task_struct *kswapd; + int kswapd_order; + enum zone_type kswapd_classzone_idx; + int kswapd_failures; + int kcompactd_max_order; + enum zone_type kcompactd_classzone_idx; + wait_queue_head_t kcompactd_wait; + struct task_struct *kcompactd; + long unsigned int totalreserve_pages; + long unsigned int min_unmapped_pages; + long unsigned int min_slab_pages; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct zone_padding _pad1_; + spinlock_t lru_lock; + struct lruvec __lruvec; + long unsigned int flags; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct zone_padding _pad2_; + struct per_cpu_nodestat *per_cpu_nodestats; + atomic_long_t vm_stat[32]; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct dev_archdata { - void *iommu; +struct mem_section_usage { + long unsigned int subsection_map[1]; + long unsigned int pageblock_flags[0]; }; -struct device_private; - -struct device_type; - -struct bus_type; - -struct device_driver; - -struct dev_pm_domain; - -struct irq_domain; - -struct dma_map_ops; - -struct device_dma_parameters; - -struct device_node; - -struct class; +struct mem_section { + long unsigned int section_mem_map; + struct mem_section_usage *usage; +}; -struct attribute_group; +struct shrink_control { + gfp_t gfp_mask; + int nid; + long unsigned int nr_to_scan; + long unsigned int nr_scanned; + struct mem_cgroup *memcg; +}; -struct iommu_group; +struct shrinker { + long unsigned int (*count_objects)(struct shrinker *, struct shrink_control *); + long unsigned int (*scan_objects)(struct shrinker *, struct shrink_control *); + long int batch; + int seeks; + unsigned int flags; + struct list_head list; + atomic_long_t *nr_deferred; +}; -struct iommu_fwspec; +struct dev_pagemap_ops { + void (*page_free)(struct page *); + void (*kill)(struct dev_pagemap *); + void (*cleanup)(struct dev_pagemap *); + vm_fault_t (*migrate_to_ram)(struct vm_fault *); +}; -struct iommu_param; +struct pid_namespace; -struct device { - struct kobject kobj; - struct device *parent; - struct device_private *p; - const char *init_name; - const struct device_type *type; - struct bus_type *bus; - struct device_driver *driver; - void *platform_data; - void *driver_data; - struct mutex mutex; - struct dev_links_info links; - struct dev_pm_info power; - struct dev_pm_domain *pm_domain; - struct irq_domain *msi_domain; - struct list_head msi_list; - const struct dma_map_ops *dma_ops; - u64 *dma_mask; - u64 coherent_dma_mask; - u64 bus_dma_limit; - long unsigned int dma_pfn_offset; - struct device_dma_parameters *dma_parms; - struct list_head dma_pools; - struct dev_archdata archdata; - struct device_node *of_node; - struct fwnode_handle *fwnode; - int numa_node; - dev_t devt; - u32 id; - spinlock_t devres_lock; - struct list_head devres_head; - struct class *class; - const struct attribute_group **groups; - void (*release)(struct device *); - struct iommu_group *iommu_group; - struct iommu_fwspec *iommu_fwspec; - struct iommu_param *iommu_param; - bool offline_disabled: 1; - bool offline: 1; - bool of_node_reused: 1; - bool state_synced: 1; +struct upid { + int nr; + struct pid_namespace *ns; }; -struct fwnode_endpoint { - unsigned int port; - unsigned int id; - const struct fwnode_handle *local_fwnode; +struct pid { + refcount_t count; + unsigned int level; + struct hlist_head tasks[4]; + wait_queue_head_t wait_pidfd; + struct callback_head rcu; + struct upid numbers[1]; }; -struct fwnode_reference_args { - struct fwnode_handle *fwnode; - unsigned int nargs; - u64 args[8]; -}; +typedef struct { + gid_t val; +} kgid_t; -typedef void (*smp_call_func_t)(void *); +struct hrtimer_cpu_base; -struct __call_single_data { - struct llist_node llist; - smp_call_func_t func; - void *info; - unsigned int flags; +struct hrtimer_clock_base { + struct hrtimer_cpu_base *cpu_base; + unsigned int index; + clockid_t clockid; + seqcount_t seq; + struct hrtimer *running; + struct timerqueue_head active; + ktime_t (*get_time)(); + ktime_t offset; }; -typedef int proc_handler(struct ctl_table *, int, void *, size_t *, loff_t *); +struct hrtimer_cpu_base { + raw_spinlock_t lock; + unsigned int cpu; + unsigned int active_bases; + unsigned int clock_was_set_seq; + unsigned int hres_active: 1; + unsigned int in_hrtirq: 1; + unsigned int hang_detected: 1; + unsigned int softirq_activated: 1; + unsigned int nr_events; + short unsigned int nr_retries; + short unsigned int nr_hangs; + unsigned int max_hang_time; + ktime_t expires_next; + struct hrtimer *next_timer; + ktime_t softirq_expires_next; + struct hrtimer *softirq_next_timer; + struct hrtimer_clock_base clock_base[8]; +}; -struct ctl_table_poll; +struct tick_device; -struct ctl_table { - const char *procname; - void *data; - int maxlen; - umode_t mode; - struct ctl_table *child; - proc_handler *proc_handler; - struct ctl_table_poll *poll; - void *extra1; - void *extra2; +union sigval { + int sival_int; + void *sival_ptr; }; -struct ctl_table_poll { - atomic_t event; - wait_queue_head_t wait; -}; +typedef union sigval sigval_t; -struct ctl_node { - struct rb_node node; - struct ctl_table_header *header; +union __sifields { + struct { + __kernel_pid_t _pid; + __kernel_uid32_t _uid; + } _kill; + struct { + __kernel_timer_t _tid; + int _overrun; + sigval_t _sigval; + int _sys_private; + } _timer; + struct { + __kernel_pid_t _pid; + __kernel_uid32_t _uid; + sigval_t _sigval; + } _rt; + struct { + __kernel_pid_t _pid; + __kernel_uid32_t _uid; + int _status; + __kernel_clock_t _utime; + __kernel_clock_t _stime; + } _sigchld; + struct { + void *_addr; + union { + short int _addr_lsb; + struct { + char _dummy_bnd[8]; + void *_lower; + void *_upper; + } _addr_bnd; + struct { + char _dummy_pkey[8]; + __u32 _pkey; + } _addr_pkey; + }; + } _sigfault; + struct { + long int _band; + int _fd; + } _sigpoll; + struct { + void *_call_addr; + int _syscall; + unsigned int _arch; + } _sigsys; }; -struct ctl_table_root { - struct ctl_table_set default_set; - struct ctl_table_set * (*lookup)(struct ctl_table_root *); - void (*set_ownership)(struct ctl_table_header *, struct ctl_table *, kuid_t *, kgid_t *); - int (*permissions)(struct ctl_table_header *, struct ctl_table *); +struct kernel_siginfo { + struct { + int si_signo; + int si_errno; + int si_code; + union __sifields _sifields; + }; }; -enum umh_disable_depth { - UMH_ENABLED = 0, - UMH_FREEZING = 1, - UMH_DISABLED = 2, +struct rseq { + __u32 cpu_id_start; + __u32 cpu_id; + union { + __u64 ptr64; + __u64 ptr; + } rseq_cs; + __u32 flags; + long: 32; + long: 64; }; -typedef __u64 Elf64_Addr; - -typedef __u16 Elf64_Half; +struct root_domain; -typedef __u32 Elf64_Word; +struct rq; -typedef __u64 Elf64_Xword; +struct rq_flags; -struct elf64_sym { - Elf64_Word st_name; - unsigned char st_info; - unsigned char st_other; - Elf64_Half st_shndx; - Elf64_Addr st_value; - Elf64_Xword st_size; +struct sched_class { + const struct sched_class *next; + void (*enqueue_task)(struct rq *, struct task_struct *, int); + void (*dequeue_task)(struct rq *, struct task_struct *, int); + void (*yield_task)(struct rq *); + bool (*yield_to_task)(struct rq *, struct task_struct *, bool); + void (*check_preempt_curr)(struct rq *, struct task_struct *, int); + struct task_struct * (*pick_next_task)(struct rq *); + void (*put_prev_task)(struct rq *, struct task_struct *); + void (*set_next_task)(struct rq *, struct task_struct *, bool); + int (*balance)(struct rq *, struct task_struct *, struct rq_flags *); + int (*select_task_rq)(struct task_struct *, int, int, int); + void (*migrate_task_rq)(struct task_struct *, int); + void (*task_woken)(struct rq *, struct task_struct *); + void (*set_cpus_allowed)(struct task_struct *, const struct cpumask *); + void (*rq_online)(struct rq *); + void (*rq_offline)(struct rq *); + void (*task_tick)(struct rq *, struct task_struct *, int); + void (*task_fork)(struct task_struct *); + void (*task_dead)(struct task_struct *); + void (*switched_from)(struct rq *, struct task_struct *); + void (*switched_to)(struct rq *, struct task_struct *); + void (*prio_changed)(struct rq *, struct task_struct *, int); + unsigned int (*get_rr_interval)(struct rq *, struct task_struct *); + void (*update_curr)(struct rq *); + void (*task_change_group)(struct task_struct *, int); }; -typedef struct elf64_sym Elf64_Sym; - -struct idr { - struct xarray idr_rt; - unsigned int idr_base; - unsigned int idr_next; +struct kernel_cap_struct { + __u32 cap[2]; }; -struct kernfs_root; +typedef struct kernel_cap_struct kernel_cap_t; -struct kernfs_elem_dir { - long unsigned int subdirs; - struct rb_root children; - struct kernfs_root *root; -}; +struct user_struct; -struct kernfs_syscall_ops; +struct group_info; -struct kernfs_root { - struct kernfs_node *kn; - unsigned int flags; - struct idr ino_idr; - u32 last_id_lowbits; - u32 id_highbits; - struct kernfs_syscall_ops *syscall_ops; - struct list_head supers; - wait_queue_head_t deactivate_waitq; +struct cred { + atomic_t usage; + kuid_t uid; + kgid_t gid; + kuid_t suid; + kgid_t sgid; + kuid_t euid; + kgid_t egid; + kuid_t fsuid; + kgid_t fsgid; + unsigned int securebits; + kernel_cap_t cap_inheritable; + kernel_cap_t cap_permitted; + kernel_cap_t cap_effective; + kernel_cap_t cap_bset; + kernel_cap_t cap_ambient; + unsigned char jit_keyring; + struct key *session_keyring; + struct key *process_keyring; + struct key *thread_keyring; + struct key *request_key_auth; + void *security; + struct user_struct *user; + struct user_namespace *user_ns; + struct group_info *group_info; + union { + int non_rcu; + struct callback_head rcu; + }; }; -struct kernfs_elem_symlink { - struct kernfs_node *target_kn; +struct io_cq; + +struct io_context { + atomic_long_t refcount; + atomic_t active_ref; + atomic_t nr_tasks; + spinlock_t lock; + short unsigned int ioprio; + int nr_batch_requests; + long unsigned int last_waited; + struct xarray icq_tree; + struct io_cq *icq_hint; + struct hlist_head icq_list; + struct work_struct release_work; }; -struct kernfs_ops; +struct hlist_bl_node; -struct kernfs_open_node; +struct hlist_bl_head { + struct hlist_bl_node *first; +}; -struct kernfs_elem_attr { - const struct kernfs_ops *ops; - struct kernfs_open_node *open; - loff_t size; - struct kernfs_node *notify_next; +struct hlist_bl_node { + struct hlist_bl_node *next; + struct hlist_bl_node **pprev; }; -struct kernfs_iattrs; +struct lockref { + union { + __u64 lock_count; + struct { + spinlock_t lock; + int count; + }; + }; +}; -struct kernfs_node { - atomic_t count; - atomic_t active; - struct kernfs_node *parent; - const char *name; - struct rb_node rb; - const void *ns; - unsigned int hash; +struct qstr { union { - struct kernfs_elem_dir dir; - struct kernfs_elem_symlink symlink; - struct kernfs_elem_attr attr; + struct { + u32 hash; + u32 len; + }; + u64 hash_len; }; - void *priv; - u64 id; - short unsigned int flags; - umode_t mode; - struct kernfs_iattrs *iattr; + const unsigned char *name; }; -struct kernfs_open_file; +struct dentry_stat_t { + long int nr_dentry; + long int nr_unused; + long int age_limit; + long int want_pages; + long int nr_negative; + long int dummy; +}; -struct kernfs_ops { - int (*open)(struct kernfs_open_file *); - void (*release)(struct kernfs_open_file *); - int (*seq_show)(struct seq_file *, void *); - void * (*seq_start)(struct seq_file *, loff_t *); - void * (*seq_next)(struct seq_file *, void *, loff_t *); - void (*seq_stop)(struct seq_file *, void *); - ssize_t (*read)(struct kernfs_open_file *, char *, size_t, loff_t); - size_t atomic_write_len; - bool prealloc; - ssize_t (*write)(struct kernfs_open_file *, char *, size_t, loff_t); - __poll_t (*poll)(struct kernfs_open_file *, struct poll_table_struct *); - int (*mmap)(struct kernfs_open_file *, struct vm_area_struct *); -}; +struct dentry_operations; -struct kernfs_syscall_ops { - int (*show_options)(struct seq_file *, struct kernfs_root *); - int (*mkdir)(struct kernfs_node *, const char *, umode_t); - int (*rmdir)(struct kernfs_node *); - int (*rename)(struct kernfs_node *, struct kernfs_node *, const char *); - int (*show_path)(struct seq_file *, struct kernfs_node *, struct kernfs_root *); +struct dentry { + unsigned int d_flags; + seqcount_t d_seq; + struct hlist_bl_node d_hash; + struct dentry *d_parent; + struct qstr d_name; + struct inode *d_inode; + unsigned char d_iname[32]; + struct lockref d_lockref; + const struct dentry_operations *d_op; + struct super_block *d_sb; + long unsigned int d_time; + void *d_fsdata; + union { + struct list_head d_lru; + wait_queue_head_t *d_wait; + }; + struct list_head d_child; + struct list_head d_subdirs; + union { + struct hlist_node d_alias; + struct hlist_bl_node d_in_lookup_hash; + struct callback_head d_rcu; + } d_u; }; -struct seq_operations; +struct posix_acl; -struct seq_file { - char *buf; - size_t size; - size_t from; - size_t count; - size_t pad_until; - loff_t index; - loff_t read_pos; - u64 version; - struct mutex lock; - const struct seq_operations *op; - int poll_event; - const struct file *file; - void *private; -}; +struct inode_operations; -struct kernfs_open_file { - struct kernfs_node *kn; - struct file *file; - struct seq_file *seq_file; - void *priv; - struct mutex mutex; - struct mutex prealloc_mutex; - int event; - struct list_head list; - char *prealloc_buf; - size_t atomic_write_len; - bool mmapped: 1; - bool released: 1; - const struct vm_operations_struct *vm_ops; -}; +struct file_lock_context; -typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *); +struct block_device; -struct poll_table_struct { - poll_queue_proc _qproc; - __poll_t _key; +struct cdev; + +struct fsnotify_mark_connector; + +struct inode { + umode_t i_mode; + short unsigned int i_opflags; + kuid_t i_uid; + kgid_t i_gid; + unsigned int i_flags; + struct posix_acl *i_acl; + struct posix_acl *i_default_acl; + const struct inode_operations *i_op; + struct super_block *i_sb; + struct address_space *i_mapping; + void *i_security; + long unsigned int i_ino; + union { + const unsigned int i_nlink; + unsigned int __i_nlink; + }; + dev_t i_rdev; + loff_t i_size; + struct timespec64 i_atime; + struct timespec64 i_mtime; + struct timespec64 i_ctime; + spinlock_t i_lock; + short unsigned int i_bytes; + u8 i_blkbits; + u8 i_write_hint; + blkcnt_t i_blocks; + long unsigned int i_state; + struct rw_semaphore i_rwsem; + long unsigned int dirtied_when; + long unsigned int dirtied_time_when; + struct hlist_node i_hash; + struct list_head i_io_list; + struct list_head i_lru; + struct list_head i_sb_list; + struct list_head i_wb_list; + union { + struct hlist_head i_dentry; + struct callback_head i_rcu; + }; + atomic64_t i_version; + atomic_t i_count; + atomic_t i_dio_count; + atomic_t i_writecount; + atomic_t i_readcount; + union { + const struct file_operations *i_fop; + void (*free_inode)(struct inode *); + }; + struct file_lock_context *i_flctx; + struct address_space i_data; + struct list_head i_devices; + union { + struct pipe_inode_info *i_pipe; + struct block_device *i_bdev; + struct cdev *i_cdev; + char *i_link; + unsigned int i_dir_seq; + }; + __u32 i_generation; + __u32 i_fsnotify_mask; + struct fsnotify_mark_connector *i_fsnotify_marks; + void *i_private; }; -enum kobj_ns_type { - KOBJ_NS_TYPE_NONE = 0, - KOBJ_NS_TYPE_NET = 1, - KOBJ_NS_TYPES = 2, +struct dentry_operations { + int (*d_revalidate)(struct dentry *, unsigned int); + int (*d_weak_revalidate)(struct dentry *, unsigned int); + int (*d_hash)(const struct dentry *, struct qstr *); + int (*d_compare)(const struct dentry *, unsigned int, const char *, const struct qstr *); + int (*d_delete)(const struct dentry *); + int (*d_init)(struct dentry *); + void (*d_release)(struct dentry *); + void (*d_prune)(struct dentry *); + void (*d_iput)(struct dentry *, struct inode *); + char * (*d_dname)(struct dentry *, char *, int); + struct vfsmount * (*d_automount)(struct path *); + int (*d_manage)(const struct path *, bool); + struct dentry * (*d_real)(struct dentry *, const struct inode *); + long: 64; + long: 64; + long: 64; }; -struct sock; +struct mtd_info; -struct kobj_ns_type_operations { - enum kobj_ns_type type; - bool (*current_may_mount)(); - void * (*grab_current_ns)(); - const void * (*netlink_ns)(struct sock *); - const void * (*initial_ns)(); - void (*drop_ns)(void *); -}; +typedef long long int qsize_t; -struct attribute { - const char *name; - umode_t mode; +struct quota_format_type; + +struct mem_dqinfo { + struct quota_format_type *dqi_format; + int dqi_fmt_id; + struct list_head dqi_dirty_list; + long unsigned int dqi_flags; + unsigned int dqi_bgrace; + unsigned int dqi_igrace; + qsize_t dqi_max_spc_limit; + qsize_t dqi_max_ino_limit; + void *dqi_priv; }; -struct bin_attribute; +struct quota_format_ops; -struct attribute_group { - const char *name; - umode_t (*is_visible)(struct kobject *, struct attribute *, int); - umode_t (*is_bin_visible)(struct kobject *, struct bin_attribute *, int); - struct attribute **attrs; - struct bin_attribute **bin_attrs; +struct quota_info { + unsigned int flags; + struct rw_semaphore dqio_sem; + struct inode *files[3]; + struct mem_dqinfo info[3]; + const struct quota_format_ops *ops[3]; }; -struct bin_attribute { - struct attribute attr; - size_t size; - void *private; - ssize_t (*read)(struct file *, struct kobject *, struct bin_attribute *, char *, loff_t, size_t); - ssize_t (*write)(struct file *, struct kobject *, struct bin_attribute *, char *, loff_t, size_t); - int (*mmap)(struct file *, struct kobject *, struct bin_attribute *, struct vm_area_struct *); +struct rcu_sync { + int gp_state; + int gp_count; + wait_queue_head_t gp_wait; + struct callback_head cb_head; }; -struct sysfs_ops { - ssize_t (*show)(struct kobject *, struct attribute *, char *); - ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t); +struct rcuwait { + struct task_struct *task; }; -struct kset_uevent_ops; - -struct kset { - struct list_head list; - spinlock_t list_lock; - struct kobject kobj; - const struct kset_uevent_ops *uevent_ops; +struct percpu_rw_semaphore { + struct rcu_sync rss; + unsigned int *read_count; + struct rw_semaphore rw_sem; + struct rcuwait writer; + int readers_block; }; -struct kobj_type { - void (*release)(struct kobject *); - const struct sysfs_ops *sysfs_ops; - struct attribute **default_attrs; - const struct attribute_group **default_groups; - const struct kobj_ns_type_operations * (*child_ns_type)(struct kobject *); - const void * (*namespace)(struct kobject *); - void (*get_ownership)(struct kobject *, kuid_t *, kgid_t *); +struct sb_writers { + int frozen; + wait_queue_head_t wait_unfrozen; + struct percpu_rw_semaphore rw_sem[3]; }; -struct kobj_uevent_env { - char *argv[3]; - char *envp[32]; - int envp_idx; - char buf[2048]; - int buflen; -}; +typedef struct { + __u8 b[16]; +} uuid_t; -struct kset_uevent_ops { - int (* const filter)(struct kset *, struct kobject *); - const char * (* const name)(struct kset *, struct kobject *); - int (* const uevent)(struct kset *, struct kobject *, struct kobj_uevent_env *); +struct list_lru_node; + +struct list_lru { + struct list_lru_node *node; }; -struct kernel_param; +struct super_operations; -struct kernel_param_ops { - unsigned int flags; - int (*set)(const char *, const struct kernel_param *); - int (*get)(char *, const struct kernel_param *); - void (*free)(void *); -}; +struct dquot_operations; -struct kparam_string; +struct quotactl_ops; -struct kparam_array; +struct export_operations; -struct kernel_param { - const char *name; - struct module *mod; - const struct kernel_param_ops *ops; - const u16 perm; - s8 level; - u8 flags; - union { - void *arg; - const struct kparam_string *str; - const struct kparam_array *arr; - }; -}; +struct xattr_handler; -struct kparam_string { - unsigned int maxlen; - char *string; +struct workqueue_struct; + +struct super_block { + struct list_head s_list; + dev_t s_dev; + unsigned char s_blocksize_bits; + long unsigned int s_blocksize; + loff_t s_maxbytes; + struct file_system_type *s_type; + const struct super_operations *s_op; + const struct dquot_operations *dq_op; + const struct quotactl_ops *s_qcop; + const struct export_operations *s_export_op; + long unsigned int s_flags; + long unsigned int s_iflags; + long unsigned int s_magic; + struct dentry *s_root; + struct rw_semaphore s_umount; + int s_count; + atomic_t s_active; + void *s_security; + const struct xattr_handler **s_xattr; + struct hlist_bl_head s_roots; + struct list_head s_mounts; + struct block_device *s_bdev; + struct backing_dev_info *s_bdi; + struct mtd_info *s_mtd; + struct hlist_node s_instances; + unsigned int s_quota_types; + struct quota_info s_dquot; + struct sb_writers s_writers; + void *s_fs_info; + u32 s_time_gran; + time64_t s_time_min; + time64_t s_time_max; + __u32 s_fsnotify_mask; + struct fsnotify_mark_connector *s_fsnotify_marks; + char s_id[32]; + uuid_t s_uuid; + unsigned int s_max_links; + fmode_t s_mode; + struct mutex s_vfs_rename_mutex; + const char *s_subtype; + const struct dentry_operations *s_d_op; + int cleancache_poolid; + struct shrinker s_shrink; + atomic_long_t s_remove_count; + atomic_long_t s_fsnotify_inode_refs; + int s_readonly_remount; + struct workqueue_struct *s_dio_done_wq; + struct hlist_head s_pins; + struct user_namespace *s_user_ns; + struct list_lru s_dentry_lru; + struct list_lru s_inode_lru; + struct callback_head rcu; + struct work_struct destroy_work; + struct mutex s_sync_lock; + int s_stack_depth; + long: 32; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + spinlock_t s_inode_list_lock; + struct list_head s_inodes; + spinlock_t s_inode_wblist_lock; + struct list_head s_inodes_wb; + long: 64; + long: 64; }; -struct kparam_array { - unsigned int max; - unsigned int elemsize; - unsigned int *num; - const struct kernel_param_ops *ops; - void *elem; +struct kstat { + u32 result_mask; + umode_t mode; + unsigned int nlink; + uint32_t blksize; + u64 attributes; + u64 attributes_mask; + u64 ino; + dev_t dev; + dev_t rdev; + kuid_t uid; + kgid_t gid; + loff_t size; + struct timespec64 atime; + struct timespec64 mtime; + struct timespec64 ctime; + struct timespec64 btime; + u64 blocks; }; -enum module_state { - MODULE_STATE_LIVE = 0, - MODULE_STATE_COMING = 1, - MODULE_STATE_GOING = 2, - MODULE_STATE_UNFORMED = 3, +struct list_lru_one { + struct list_head list; + long int nr_items; }; -struct module_param_attrs; +struct list_lru_node { + spinlock_t lock; + struct list_lru_one lru; + long int nr_items; + long: 64; + long: 64; + long: 64; +}; -struct module_kobject { - struct kobject kobj; - struct module *mod; - struct kobject *drivers_dir; - struct module_param_attrs *mp; - struct completion *kobj_completion; +struct fiemap_extent { + __u64 fe_logical; + __u64 fe_physical; + __u64 fe_length; + __u64 fe_reserved64[2]; + __u32 fe_flags; + __u32 fe_reserved[3]; }; -struct latch_tree_node { - struct rb_node node[2]; +enum migrate_mode { + MIGRATE_ASYNC = 0, + MIGRATE_SYNC_LIGHT = 1, + MIGRATE_SYNC = 2, + MIGRATE_SYNC_NO_COPY = 3, }; -struct mod_tree_node { - struct module *mod; - struct latch_tree_node node; +struct delayed_call { + void (*fn)(void *); + void *arg; }; -struct module_layout { - void *base; - unsigned int size; - unsigned int text_size; - unsigned int ro_size; - unsigned int ro_after_init_size; - struct mod_tree_node mtn; +typedef struct { + __u8 b[16]; +} guid_t; + +struct request_queue; + +struct io_cq { + struct request_queue *q; + struct io_context *ioc; + union { + struct list_head q_node; + struct kmem_cache *__rcu_icq_cache; + }; + union { + struct hlist_node ioc_node; + struct callback_head __rcu_head; + }; + unsigned int flags; }; -struct mod_arch_specific { - unsigned int num_orcs; - int *orc_unwind_ip; - struct orc_entry *orc_unwind; +struct files_stat_struct { + long unsigned int nr_files; + long unsigned int nr_free_files; + long unsigned int max_files; }; -struct mod_kallsyms { - Elf64_Sym *symtab; - unsigned int num_symtab; - char *strtab; - char *typetab; +struct inodes_stat_t { + long int nr_inodes; + long int nr_unused; + long int dummy[5]; }; -struct module_attribute; +struct kiocb { + struct file *ki_filp; + loff_t ki_pos; + void (*ki_complete)(struct kiocb *, long int, long int); + void *private; + int ki_flags; + u16 ki_hint; + u16 ki_ioprio; + unsigned int ki_cookie; +}; -struct exception_table_entry; +struct iattr { + unsigned int ia_valid; + umode_t ia_mode; + kuid_t ia_uid; + kgid_t ia_gid; + loff_t ia_size; + struct timespec64 ia_atime; + struct timespec64 ia_mtime; + struct timespec64 ia_ctime; + struct file *ia_file; +}; -struct module_sect_attrs; +struct percpu_counter { + raw_spinlock_t lock; + s64 count; + struct list_head list; + s32 *counters; +}; -struct module_notes_attrs; +typedef __kernel_uid32_t projid_t; -struct trace_eval_map; +typedef struct { + projid_t val; +} kprojid_t; -struct error_injection_entry; - -struct module { - enum module_state state; - struct list_head list; - char name[56]; - struct module_kobject mkobj; - struct module_attribute *modinfo_attrs; - const char *version; - const char *srcversion; - struct kobject *holders_dir; - const struct kernel_symbol *syms; - const s32 *crcs; - unsigned int num_syms; - struct mutex param_lock; - struct kernel_param *kp; - unsigned int num_kp; - unsigned int num_gpl_syms; - const struct kernel_symbol *gpl_syms; - const s32 *gpl_crcs; - bool async_probe_requested; - const struct kernel_symbol *gpl_future_syms; - const s32 *gpl_future_crcs; - unsigned int num_gpl_future_syms; - unsigned int num_exentries; - struct exception_table_entry *extable; - int (*init)(); - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - struct module_layout core_layout; - struct module_layout init_layout; - struct mod_arch_specific arch; - long unsigned int taints; - unsigned int num_bugs; - struct list_head bug_list; - struct bug_entry *bug_table; - struct mod_kallsyms *kallsyms; - struct mod_kallsyms core_kallsyms; - struct module_sect_attrs *sect_attrs; - struct module_notes_attrs *notes_attrs; - char *args; - void *percpu; - unsigned int percpu_size; - unsigned int num_tracepoints; - tracepoint_ptr_t *tracepoints_ptrs; - unsigned int num_srcu_structs; - struct srcu_struct **srcu_struct_ptrs; - struct jump_entry *jump_entries; - unsigned int num_jump_entries; - unsigned int num_trace_bprintk_fmt; - const char **trace_bprintk_fmt_start; - struct trace_event_call **trace_events; - unsigned int num_trace_events; - struct trace_eval_map **trace_evals; - unsigned int num_trace_evals; - struct list_head source_list; - struct list_head target_list; - void (*exit)(); - atomic_t refcnt; - struct error_injection_entry *ei_funcs; - unsigned int num_ei_funcs; +enum quota_type { + USRQUOTA = 0, + GRPQUOTA = 1, + PRJQUOTA = 2, }; -struct error_injection_entry { - long unsigned int addr; - int etype; +struct kqid { + union { + kuid_t uid; + kgid_t gid; + kprojid_t projid; + }; + enum quota_type type; }; -struct module_attribute { - struct attribute attr; - ssize_t (*show)(struct module_attribute *, struct module_kobject *, char *); - ssize_t (*store)(struct module_attribute *, struct module_kobject *, const char *, size_t); - void (*setup)(struct module *, const char *); - int (*test)(struct module *); - void (*free)(struct module *); +struct mem_dqblk { + qsize_t dqb_bhardlimit; + qsize_t dqb_bsoftlimit; + qsize_t dqb_curspace; + qsize_t dqb_rsvspace; + qsize_t dqb_ihardlimit; + qsize_t dqb_isoftlimit; + qsize_t dqb_curinodes; + time64_t dqb_btime; + time64_t dqb_itime; }; -struct exception_table_entry { - int insn; - int fixup; - int handler; +struct dquot { + struct hlist_node dq_hash; + struct list_head dq_inuse; + struct list_head dq_free; + struct list_head dq_dirty; + struct mutex dq_lock; + spinlock_t dq_dqb_lock; + atomic_t dq_count; + struct super_block *dq_sb; + struct kqid dq_id; + loff_t dq_off; + long unsigned int dq_flags; + struct mem_dqblk dq_dqb; }; -struct trace_event_functions; - -struct trace_event { - struct hlist_node node; - struct list_head list; - int type; - struct trace_event_functions *funcs; +struct quota_format_type { + int qf_fmt_id; + const struct quota_format_ops *qf_ops; + struct module *qf_owner; + struct quota_format_type *qf_next; }; -struct trace_event_class; - -struct bpf_prog_array; - -struct trace_event_call { - struct list_head list; - struct trace_event_class *class; - union { - char *name; - struct tracepoint *tp; - }; - struct trace_event event; - char *print_fmt; - struct event_filter *filter; - void *mod; - void *data; - int flags; - int perf_refcount; - struct hlist_head *perf_events; - struct bpf_prog_array *prog_array; - int (*perf_perm)(struct trace_event_call *, struct perf_event *); +struct dqstats { + long unsigned int stat[8]; + struct percpu_counter counter[8]; }; -struct trace_eval_map { - const char *system; - const char *eval_string; - long unsigned int eval_value; +struct quota_format_ops { + int (*check_quota_file)(struct super_block *, int); + int (*read_file_info)(struct super_block *, int); + int (*write_file_info)(struct super_block *, int); + int (*free_file_info)(struct super_block *, int); + int (*read_dqblk)(struct dquot *); + int (*commit_dqblk)(struct dquot *); + int (*release_dqblk)(struct dquot *); + int (*get_next_id)(struct super_block *, struct kqid *); }; -struct fs_pin; +struct dquot_operations { + int (*write_dquot)(struct dquot *); + struct dquot * (*alloc_dquot)(struct super_block *, int); + void (*destroy_dquot)(struct dquot *); + int (*acquire_dquot)(struct dquot *); + int (*release_dquot)(struct dquot *); + int (*mark_dirty)(struct dquot *); + int (*write_info)(struct super_block *, int); + qsize_t * (*get_reserved_space)(struct inode *); + int (*get_projid)(struct inode *, kprojid_t *); + int (*get_inode_usage)(struct inode *, qsize_t *); + int (*get_next_id)(struct super_block *, struct kqid *); +}; -struct pid_namespace { - struct kref kref; - struct idr idr; - struct callback_head rcu; - unsigned int pid_allocated; - struct task_struct *child_reaper; - struct kmem_cache *pid_cachep; - unsigned int level; - struct pid_namespace *parent; - struct vfsmount *proc_mnt; - struct dentry *proc_self; - struct dentry *proc_thread_self; - struct fs_pin *bacct; - struct user_namespace *user_ns; - struct ucounts *ucounts; - struct work_struct proc_work; - kgid_t pid_gid; - int hide_pid; - int reboot; - struct ns_common ns; +struct qc_dqblk { + int d_fieldmask; + u64 d_spc_hardlimit; + u64 d_spc_softlimit; + u64 d_ino_hardlimit; + u64 d_ino_softlimit; + u64 d_space; + u64 d_ino_count; + s64 d_ino_timer; + s64 d_spc_timer; + int d_ino_warns; + int d_spc_warns; + u64 d_rt_spc_hardlimit; + u64 d_rt_spc_softlimit; + u64 d_rt_space; + s64 d_rt_spc_timer; + int d_rt_spc_warns; }; -struct rlimit { - __kernel_ulong_t rlim_cur; - __kernel_ulong_t rlim_max; +struct qc_type_state { + unsigned int flags; + unsigned int spc_timelimit; + unsigned int ino_timelimit; + unsigned int rt_spc_timelimit; + unsigned int spc_warnlimit; + unsigned int ino_warnlimit; + unsigned int rt_spc_warnlimit; + long long unsigned int ino; + blkcnt_t blocks; + blkcnt_t nextents; }; -struct task_cputime { - u64 stime; - u64 utime; - long long unsigned int sum_exec_runtime; +struct qc_state { + unsigned int s_incoredqs; + struct qc_type_state s_state[3]; }; -typedef void __signalfn_t(int); +struct qc_info { + int i_fieldmask; + unsigned int i_flags; + unsigned int i_spc_timelimit; + unsigned int i_ino_timelimit; + unsigned int i_rt_spc_timelimit; + unsigned int i_spc_warnlimit; + unsigned int i_ino_warnlimit; + unsigned int i_rt_spc_warnlimit; +}; -typedef __signalfn_t *__sighandler_t; +struct quotactl_ops { + int (*quota_on)(struct super_block *, int, int, const struct path *); + int (*quota_off)(struct super_block *, int); + int (*quota_enable)(struct super_block *, unsigned int); + int (*quota_disable)(struct super_block *, unsigned int); + int (*quota_sync)(struct super_block *, int); + int (*set_info)(struct super_block *, int, struct qc_info *); + int (*get_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *); + int (*get_nextdqblk)(struct super_block *, struct kqid *, struct qc_dqblk *); + int (*set_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *); + int (*get_state)(struct super_block *, struct qc_state *); + int (*rm_xquota)(struct super_block *, unsigned int); +}; -typedef void __restorefn_t(); +struct writeback_control; -typedef __restorefn_t *__sigrestore_t; +struct swap_info_struct; -struct ratelimit_state { - raw_spinlock_t lock; - int interval; - int burst; - int printed; - int missed; - long unsigned int begin; - long unsigned int flags; +struct address_space_operations { + int (*writepage)(struct page *, struct writeback_control *); + int (*readpage)(struct file *, struct page *); + int (*writepages)(struct address_space *, struct writeback_control *); + int (*set_page_dirty)(struct page *); + int (*readpages)(struct file *, struct address_space *, struct list_head *, unsigned int); + int (*write_begin)(struct file *, struct address_space *, loff_t, unsigned int, unsigned int, struct page **, void **); + int (*write_end)(struct file *, struct address_space *, loff_t, unsigned int, unsigned int, struct page *, void *); + sector_t (*bmap)(struct address_space *, sector_t); + void (*invalidatepage)(struct page *, unsigned int, unsigned int); + int (*releasepage)(struct page *, gfp_t); + void (*freepage)(struct page *); + ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *); + int (*migratepage)(struct address_space *, struct page *, struct page *, enum migrate_mode); + bool (*isolate_page)(struct page *, isolate_mode_t); + void (*putback_page)(struct page *); + int (*launder_page)(struct page *); + int (*is_partially_uptodate)(struct page *, long unsigned int, long unsigned int); + void (*is_dirty_writeback)(struct page *, bool *, bool *); + int (*error_remove_page)(struct address_space *, struct page *); + int (*swap_activate)(struct swap_info_struct *, struct file *, sector_t *); + void (*swap_deactivate)(struct file *); }; -struct user_struct { - refcount_t __count; - atomic_t processes; - atomic_t sigpending; - atomic_long_t epoll_watches; - long unsigned int mq_bytes; - long unsigned int locked_shm; - long unsigned int unix_inflight; - atomic_long_t pipe_bufs; - struct hlist_node uidhash_node; - kuid_t uid; - atomic_long_t locked_vm; - struct ratelimit_state ratelimit; -}; +struct hd_struct; -struct sigaction { - __sighandler_t sa_handler; - long unsigned int sa_flags; - __sigrestore_t sa_restorer; - sigset_t sa_mask; -}; +struct gendisk; -struct k_sigaction { - struct sigaction sa; +struct block_device { + dev_t bd_dev; + int bd_openers; + struct inode *bd_inode; + struct super_block *bd_super; + struct mutex bd_mutex; + void *bd_claiming; + void *bd_holder; + int bd_holders; + bool bd_write_holder; + struct list_head bd_holder_disks; + struct block_device *bd_contains; + unsigned int bd_block_size; + u8 bd_partno; + struct hd_struct *bd_part; + unsigned int bd_part_count; + int bd_invalidated; + struct gendisk *bd_disk; + struct request_queue *bd_queue; + struct backing_dev_info *bd_bdi; + struct list_head bd_list; + long unsigned int bd_private; + int bd_fsfreeze_count; + struct mutex bd_fsfreeze_mutex; }; -struct cpu_itimer { - u64 expires; - u64 incr; -}; +struct fiemap_extent_info; -struct task_cputime_atomic { - atomic64_t utime; - atomic64_t stime; - atomic64_t sum_exec_runtime; +struct inode_operations { + struct dentry * (*lookup)(struct inode *, struct dentry *, unsigned int); + const char * (*get_link)(struct dentry *, struct inode *, struct delayed_call *); + int (*permission)(struct inode *, int); + struct posix_acl * (*get_acl)(struct inode *, int); + int (*readlink)(struct dentry *, char *, int); + int (*create)(struct inode *, struct dentry *, umode_t, bool); + int (*link)(struct dentry *, struct inode *, struct dentry *); + int (*unlink)(struct inode *, struct dentry *); + int (*symlink)(struct inode *, struct dentry *, const char *); + int (*mkdir)(struct inode *, struct dentry *, umode_t); + int (*rmdir)(struct inode *, struct dentry *); + int (*mknod)(struct inode *, struct dentry *, umode_t, dev_t); + int (*rename)(struct inode *, struct dentry *, struct inode *, struct dentry *, unsigned int); + int (*setattr)(struct dentry *, struct iattr *); + int (*getattr)(const struct path *, struct kstat *, u32, unsigned int); + ssize_t (*listxattr)(struct dentry *, char *, size_t); + int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64, u64); + int (*update_time)(struct inode *, struct timespec64 *, int); + int (*atomic_open)(struct inode *, struct dentry *, struct file *, unsigned int, umode_t); + int (*tmpfile)(struct inode *, struct dentry *, umode_t); + int (*set_acl)(struct inode *, struct posix_acl *, int); + long: 64; + long: 64; + long: 64; }; -struct thread_group_cputimer { - struct task_cputime_atomic cputime_atomic; +struct file_lock_context { + spinlock_t flc_lock; + struct list_head flc_flock; + struct list_head flc_posix; + struct list_head flc_lease; }; -struct pacct_struct { - int ac_flag; - long int ac_exitcode; - long unsigned int ac_mem; - u64 ac_utime; - u64 ac_stime; - long unsigned int ac_minflt; - long unsigned int ac_majflt; +struct file_lock_operations { + void (*fl_copy_lock)(struct file_lock *, struct file_lock *); + void (*fl_release_private)(struct file_lock *); }; -struct tty_struct; - -struct taskstats; - -struct tty_audit_buf; +struct nlm_lockowner; -struct signal_struct { - refcount_t sigcnt; - atomic_t live; - int nr_threads; - struct list_head thread_head; - wait_queue_head_t wait_chldexit; - struct task_struct *curr_target; - struct sigpending shared_pending; - struct hlist_head multiprocess; - int group_exit_code; - int notify_count; - struct task_struct *group_exit_task; - int group_stop_count; - unsigned int flags; - unsigned int is_child_subreaper: 1; - unsigned int has_child_subreaper: 1; - int posix_timer_id; - struct list_head posix_timers; - struct hrtimer real_timer; - ktime_t it_real_incr; - struct cpu_itimer it[2]; - struct thread_group_cputimer cputimer; - struct posix_cputimers posix_cputimers; - struct pid *pids[4]; - struct pid *tty_old_pgrp; - int leader; - struct tty_struct *tty; - seqlock_t stats_lock; - u64 utime; - u64 stime; - u64 cutime; - u64 cstime; - u64 gtime; - u64 cgtime; - struct prev_cputime prev_cputime; - long unsigned int nvcsw; - long unsigned int nivcsw; - long unsigned int cnvcsw; - long unsigned int cnivcsw; - long unsigned int min_flt; - long unsigned int maj_flt; - long unsigned int cmin_flt; - long unsigned int cmaj_flt; - long unsigned int inblock; - long unsigned int oublock; - long unsigned int cinblock; - long unsigned int coublock; - long unsigned int maxrss; - long unsigned int cmaxrss; - struct task_io_accounting ioac; - long long unsigned int sum_sched_runtime; - struct rlimit rlim[16]; - struct pacct_struct pacct; - struct taskstats *stats; - unsigned int audit_tty; - struct tty_audit_buf *tty_audit_buf; - bool oom_flag_origin; - short int oom_score_adj; - short int oom_score_adj_min; - struct mm_struct *oom_mm; - struct mutex cred_guard_mutex; +struct nfs_lock_info { + u32 state; + struct nlm_lockowner *owner; + struct list_head list; }; -typedef int32_t key_serial_t; +struct nfs4_lock_state; -typedef uint32_t key_perm_t; +struct nfs4_lock_info { + struct nfs4_lock_state *owner; +}; -struct key_type; +struct fasync_struct; -struct key_tag; +struct lock_manager_operations; -struct keyring_index_key { - long unsigned int hash; +struct file_lock { + struct file_lock *fl_blocker; + struct list_head fl_list; + struct hlist_node fl_link; + struct list_head fl_blocked_requests; + struct list_head fl_blocked_member; + fl_owner_t fl_owner; + unsigned int fl_flags; + unsigned char fl_type; + unsigned int fl_pid; + int fl_link_cpu; + wait_queue_head_t fl_wait; + struct file *fl_file; + loff_t fl_start; + loff_t fl_end; + struct fasync_struct *fl_fasync; + long unsigned int fl_break_time; + long unsigned int fl_downgrade_time; + const struct file_lock_operations *fl_ops; + const struct lock_manager_operations *fl_lmops; union { + struct nfs_lock_info nfs_fl; + struct nfs4_lock_info nfs4_fl; struct { - u16 desc_len; - char desc[6]; - }; - long unsigned int x; - }; - struct key_type *type; - struct key_tag *domain_tag; - const char *description; + struct list_head link; + int state; + unsigned int debug_id; + } afs; + } fl_u; }; -union key_payload { - void *rcu_data0; - void *data[4]; +struct lock_manager_operations { + fl_owner_t (*lm_get_owner)(fl_owner_t); + void (*lm_put_owner)(fl_owner_t); + void (*lm_notify)(struct file_lock *); + int (*lm_grant)(struct file_lock *, int); + bool (*lm_break)(struct file_lock *); + int (*lm_change)(struct file_lock *, int, struct list_head *); + void (*lm_setup)(struct file_lock *, void **); }; -struct assoc_array_ptr; - -struct assoc_array { - struct assoc_array_ptr *root; - long unsigned int nr_leaves_on_tree; +struct fasync_struct { + rwlock_t fa_lock; + int magic; + int fa_fd; + struct fasync_struct *fa_next; + struct file *fa_file; + struct callback_head fa_rcu; }; -struct key_user; - -struct key_restriction; +struct kstatfs; -struct key { - refcount_t usage; - key_serial_t serial; - union { - struct list_head graveyard_link; - struct rb_node serial_node; - }; - struct rw_semaphore sem; - struct key_user *user; - void *security; - union { - time64_t expiry; - time64_t revoked_at; - }; - time64_t last_used_at; - kuid_t uid; - kgid_t gid; - key_perm_t perm; - short unsigned int quotalen; - short unsigned int datalen; - short int state; - long unsigned int flags; - union { - struct keyring_index_key index_key; - struct { - long unsigned int hash; - long unsigned int len_desc; - struct key_type *type; - struct key_tag *domain_tag; - char *description; - }; - }; - union { - union key_payload payload; - struct { - struct list_head name_link; - struct assoc_array keys; - }; - }; - struct key_restriction *restrict_link; +struct super_operations { + struct inode * (*alloc_inode)(struct super_block *); + void (*destroy_inode)(struct inode *); + void (*free_inode)(struct inode *); + void (*dirty_inode)(struct inode *, int); + int (*write_inode)(struct inode *, struct writeback_control *); + int (*drop_inode)(struct inode *); + void (*evict_inode)(struct inode *); + void (*put_super)(struct super_block *); + int (*sync_fs)(struct super_block *, int); + int (*freeze_super)(struct super_block *); + int (*freeze_fs)(struct super_block *); + int (*thaw_super)(struct super_block *); + int (*unfreeze_fs)(struct super_block *); + int (*statfs)(struct dentry *, struct kstatfs *); + int (*remount_fs)(struct super_block *, int *, char *); + void (*umount_begin)(struct super_block *); + int (*show_options)(struct seq_file *, struct dentry *); + int (*show_devname)(struct seq_file *, struct dentry *); + int (*show_path)(struct seq_file *, struct dentry *); + int (*show_stats)(struct seq_file *, struct dentry *); + ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t); + ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t); + struct dquot ** (*get_dquots)(struct inode *); + int (*bdev_try_to_free_page)(struct super_block *, struct page *, gfp_t); + long int (*nr_cached_objects)(struct super_block *, struct shrink_control *); + long int (*free_cached_objects)(struct super_block *, struct shrink_control *); }; -struct uts_namespace; - -struct ipc_namespace; - -struct mnt_namespace; - -struct net; +struct iomap; -struct cgroup_namespace; +struct inode___2; -struct nsproxy { - atomic_t count; - struct uts_namespace *uts_ns; - struct ipc_namespace *ipc_ns; - struct mnt_namespace *mnt_ns; - struct pid_namespace *pid_ns_for_children; - struct net *net_ns; - struct cgroup_namespace *cgroup_ns; -}; +struct dentry___2; -struct sighand_struct { - spinlock_t siglock; - refcount_t count; - wait_queue_head_t signalfd_wqh; - struct k_sigaction action[64]; -}; +struct fid; -struct bio; +struct iattr___2; -struct bio_list { - struct bio *head; - struct bio *tail; +struct export_operations { + int (*encode_fh)(struct inode___2 *, __u32 *, int *, struct inode___2 *); + struct dentry___2 * (*fh_to_dentry)(struct super_block *, struct fid *, int, int); + struct dentry___2 * (*fh_to_parent)(struct super_block *, struct fid *, int, int); + int (*get_name)(struct dentry___2 *, char *, struct dentry___2 *); + struct dentry___2 * (*get_parent)(struct dentry___2 *); + int (*commit_metadata)(struct inode___2 *); + int (*get_uuid)(struct super_block *, u8 *, u32 *, u64 *); + int (*map_blocks)(struct inode___2 *, loff_t, u64, struct iomap *, bool, u32 *); + int (*commit_blocks)(struct inode___2 *, struct iomap *, int, struct iattr___2 *); }; -struct blk_plug { - struct list_head mq_list; - struct list_head cb_list; - short unsigned int rq_count; - bool multiple_queues; +struct xattr_handler { + const char *name; + const char *prefix; + int flags; + bool (*list)(struct dentry *); + int (*get)(const struct xattr_handler *, struct dentry *, struct inode *, const char *, void *, size_t); + int (*set)(const struct xattr_handler *, struct dentry *, struct inode *, const char *, const void *, size_t, int); }; -struct reclaim_state { - long unsigned int reclaimed_slab; +struct fiemap_extent_info { + unsigned int fi_flags; + unsigned int fi_extents_mapped; + unsigned int fi_extents_max; + struct fiemap_extent *fi_extents_start; }; -typedef int congested_fn(void *, int); +typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64, unsigned int); -struct fprop_local_percpu { - struct percpu_counter events; - unsigned int period; - raw_spinlock_t lock; +struct dir_context { + filldir_t actor; + loff_t pos; }; -enum wb_reason { - WB_REASON_BACKGROUND = 0, - WB_REASON_VMSCAN = 1, - WB_REASON_SYNC = 2, - WB_REASON_PERIODIC = 3, - WB_REASON_LAPTOP_TIMER = 4, - WB_REASON_FREE_MORE_MEM = 5, - WB_REASON_FS_FREE_SPACE = 6, - WB_REASON_FORKER_THREAD = 7, - WB_REASON_FOREIGN_FLUSH = 8, - WB_REASON_MAX = 9, -}; +struct fs_parameter_spec; -struct bdi_writeback_congested; +struct fs_parameter_enum; -struct bdi_writeback { - struct backing_dev_info *bdi; - long unsigned int state; - long unsigned int last_old_flush; - struct list_head b_dirty; - struct list_head b_io; - struct list_head b_more_io; - struct list_head b_dirty_time; - spinlock_t list_lock; - struct percpu_counter stat[4]; - struct bdi_writeback_congested *congested; - long unsigned int bw_time_stamp; - long unsigned int dirtied_stamp; - long unsigned int written_stamp; - long unsigned int write_bandwidth; - long unsigned int avg_write_bandwidth; - long unsigned int dirty_ratelimit; - long unsigned int balanced_dirty_ratelimit; - struct fprop_local_percpu completions; - int dirty_exceeded; - enum wb_reason start_all_reason; - spinlock_t work_lock; - struct list_head work_list; - struct delayed_work dwork; - long unsigned int dirty_sleep; - struct list_head bdi_node; +struct fs_parameter_description { + const char name[16]; + const struct fs_parameter_spec *specs; + const struct fs_parameter_enum *enums; }; -struct backing_dev_info { - u64 id; - struct rb_node rb_node; - struct list_head bdi_list; - long unsigned int ra_pages; - long unsigned int io_pages; - congested_fn *congested_fn; - void *congested_data; +struct attribute { const char *name; - struct kref refcnt; - unsigned int capabilities; - unsigned int min_ratio; - unsigned int max_ratio; - unsigned int max_prop_frac; - atomic_long_t tot_write_bandwidth; - struct bdi_writeback wb; - struct list_head wb_list; - struct bdi_writeback_congested *wb_congested; - wait_queue_head_t wb_waitq; - struct device *dev; - struct device *owner; - struct timer_list laptop_mode_wb_timer; - struct dentry *debug_dir; -}; - -struct cgroup_subsys_state; - -struct cgroup; - -struct css_set { - struct cgroup_subsys_state *subsys[4]; - refcount_t refcount; - struct css_set *dom_cset; - struct cgroup *dfl_cgrp; - int nr_tasks; - struct list_head tasks; - struct list_head mg_tasks; - struct list_head dying_tasks; - struct list_head task_iters; - struct list_head e_cset_node[4]; - struct list_head threaded_csets; - struct list_head threaded_csets_node; - struct hlist_node hlist; - struct list_head cgrp_links; - struct list_head mg_preload_node; - struct list_head mg_node; - struct cgroup *mg_src_cgrp; - struct cgroup *mg_dst_cgrp; - struct css_set *mg_dst_cset; - bool dead; - struct callback_head callback_head; -}; - -struct perf_event_groups { - struct rb_root tree; - u64 index; -}; - -struct perf_event_context { - struct pmu *pmu; - raw_spinlock_t lock; - struct mutex mutex; - struct list_head active_ctx_list; - struct perf_event_groups pinned_groups; - struct perf_event_groups flexible_groups; - struct list_head event_list; - struct list_head pinned_active; - struct list_head flexible_active; - int nr_events; - int nr_active; - int is_active; - int nr_stat; - int nr_freq; - int rotate_disable; - int rotate_necessary; - refcount_t refcount; - struct task_struct *task; - u64 time; - u64 timestamp; - struct perf_event_context *parent_ctx; - u64 parent_gen; - u64 generation; - int pin_count; - void *task_ctx_data; - struct callback_head callback_head; + umode_t mode; }; -struct task_delay_info { - raw_spinlock_t lock; - unsigned int flags; - u64 blkio_start; - u64 blkio_delay; - u64 swapin_delay; - u32 blkio_count; - u32 swapin_count; - u64 freepages_start; - u64 freepages_delay; - u64 thrashing_start; - u64 thrashing_delay; - u32 freepages_count; - u32 thrashing_count; +struct kobj_attribute { + struct attribute attr; + ssize_t (*show)(struct kobject *, struct kobj_attribute *, char *); + ssize_t (*store)(struct kobject *, struct kobj_attribute *, const char *, size_t); }; -typedef unsigned int blk_qc_t; - -typedef blk_qc_t make_request_fn(struct request_queue *, struct bio *); - -struct request; - -typedef int dma_drain_needed_fn(struct request *); +typedef void compound_page_dtor(struct page *); -struct blk_rq_stat { - u64 mean; - u64 min; - u64 max; - u32 nr_samples; - u64 batch; +enum vm_event_item { + PGPGIN = 0, + PGPGOUT = 1, + PSWPIN = 2, + PSWPOUT = 3, + PGALLOC_DMA = 4, + PGALLOC_DMA32 = 5, + PGALLOC_NORMAL = 6, + PGALLOC_MOVABLE = 7, + ALLOCSTALL_DMA = 8, + ALLOCSTALL_DMA32 = 9, + ALLOCSTALL_NORMAL = 10, + ALLOCSTALL_MOVABLE = 11, + PGSCAN_SKIP_DMA = 12, + PGSCAN_SKIP_DMA32 = 13, + PGSCAN_SKIP_NORMAL = 14, + PGSCAN_SKIP_MOVABLE = 15, + PGFREE = 16, + PGACTIVATE = 17, + PGDEACTIVATE = 18, + PGLAZYFREE = 19, + PGFAULT = 20, + PGMAJFAULT = 21, + PGLAZYFREED = 22, + PGREFILL = 23, + PGSTEAL_KSWAPD = 24, + PGSTEAL_DIRECT = 25, + PGSCAN_KSWAPD = 26, + PGSCAN_DIRECT = 27, + PGSCAN_DIRECT_THROTTLE = 28, + PGSCAN_ZONE_RECLAIM_FAILED = 29, + PGINODESTEAL = 30, + SLABS_SCANNED = 31, + KSWAPD_INODESTEAL = 32, + KSWAPD_LOW_WMARK_HIT_QUICKLY = 33, + KSWAPD_HIGH_WMARK_HIT_QUICKLY = 34, + PAGEOUTRUN = 35, + PGROTATED = 36, + DROP_PAGECACHE = 37, + DROP_SLAB = 38, + OOM_KILL = 39, + PGMIGRATE_SUCCESS = 40, + PGMIGRATE_FAIL = 41, + COMPACTMIGRATE_SCANNED = 42, + COMPACTFREE_SCANNED = 43, + COMPACTISOLATED = 44, + COMPACTSTALL = 45, + COMPACTFAIL = 46, + COMPACTSUCCESS = 47, + KCOMPACTD_WAKE = 48, + KCOMPACTD_MIGRATE_SCANNED = 49, + KCOMPACTD_FREE_SCANNED = 50, + HTLB_BUDDY_PGALLOC = 51, + HTLB_BUDDY_PGALLOC_FAIL = 52, + UNEVICTABLE_PGCULLED = 53, + UNEVICTABLE_PGSCANNED = 54, + UNEVICTABLE_PGRESCUED = 55, + UNEVICTABLE_PGMLOCKED = 56, + UNEVICTABLE_PGMUNLOCKED = 57, + UNEVICTABLE_PGCLEARED = 58, + UNEVICTABLE_PGSTRANDED = 59, + SWAP_RA = 60, + SWAP_RA_HIT = 61, + NR_VM_EVENT_ITEMS = 62, }; -enum blk_zoned_model { - BLK_ZONED_NONE = 0, - BLK_ZONED_HA = 1, - BLK_ZONED_HM = 2, +struct vm_event_state { + long unsigned int event[62]; }; -struct queue_limits { - long unsigned int bounce_pfn; - long unsigned int seg_boundary_mask; - long unsigned int virt_boundary_mask; - unsigned int max_hw_sectors; - unsigned int max_dev_sectors; - unsigned int chunk_sectors; - unsigned int max_sectors; - unsigned int max_segment_size; - unsigned int physical_block_size; - unsigned int logical_block_size; - unsigned int alignment_offset; - unsigned int io_min; - unsigned int io_opt; - unsigned int max_discard_sectors; - unsigned int max_hw_discard_sectors; - unsigned int max_write_same_sectors; - unsigned int max_write_zeroes_sectors; - unsigned int discard_granularity; - unsigned int discard_alignment; - short unsigned int max_segments; - short unsigned int max_integrity_segments; - short unsigned int max_discard_segments; - unsigned char misaligned; - unsigned char discard_misaligned; - unsigned char raid_partial_stripes_expensive; - enum blk_zoned_model zoned; +enum memblock_flags { + MEMBLOCK_NONE = 0, + MEMBLOCK_HOTPLUG = 1, + MEMBLOCK_MIRROR = 2, + MEMBLOCK_NOMAP = 4, }; -struct bsg_ops; - -struct bsg_class_device { - struct device *class_dev; - int minor; - struct request_queue *queue; - const struct bsg_ops *ops; +struct memblock_region { + phys_addr_t base; + phys_addr_t size; + enum memblock_flags flags; + int nid; }; -typedef void *mempool_alloc_t(gfp_t, void *); - -typedef void mempool_free_t(void *, void *); - -struct mempool_s { - spinlock_t lock; - int min_nr; - int curr_nr; - void **elements; - void *pool_data; - mempool_alloc_t *alloc; - mempool_free_t *free; - wait_queue_head_t wait; +struct memblock_type { + long unsigned int cnt; + long unsigned int max; + phys_addr_t total_size; + struct memblock_region *regions; + char *name; }; -typedef struct mempool_s mempool_t; - -struct bio_set { - struct kmem_cache *bio_slab; - unsigned int front_pad; - mempool_t bio_pool; - mempool_t bvec_pool; - spinlock_t rescue_lock; - struct bio_list rescue_list; - struct work_struct rescue_work; - struct workqueue_struct *rescue_workqueue; +struct memblock { + bool bottom_up; + phys_addr_t current_limit; + struct memblock_type memory; + struct memblock_type reserved; }; -struct elevator_queue; - -struct blk_queue_stats; - -struct rq_qos; - -struct blk_mq_ops; - -struct blk_mq_ctx; - -struct blk_mq_hw_ctx; - -struct blk_stat_callback; - -struct blk_trace; - -struct blk_flush_queue; - -struct blk_mq_tag_set; - -struct request_queue { - struct request *last_merge; - struct elevator_queue *elevator; - struct blk_queue_stats *stats; - struct rq_qos *rq_qos; - make_request_fn *make_request_fn; - dma_drain_needed_fn *dma_drain_needed; - const struct blk_mq_ops *mq_ops; - struct blk_mq_ctx *queue_ctx; - unsigned int queue_depth; - struct blk_mq_hw_ctx **queue_hw_ctx; - unsigned int nr_hw_queues; - struct backing_dev_info *backing_dev_info; - void *queuedata; - long unsigned int queue_flags; - atomic_t pm_only; - int id; - gfp_t bounce_gfp; - spinlock_t queue_lock; - struct kobject kobj; - struct kobject *mq_kobj; - struct device *dev; - int rpm_status; - unsigned int nr_pending; +struct debug_store { + u64 bts_buffer_base; + u64 bts_index; + u64 bts_absolute_maximum; + u64 bts_interrupt_threshold; + u64 pebs_buffer_base; + u64 pebs_index; + u64 pebs_absolute_maximum; + u64 pebs_interrupt_threshold; + u64 pebs_event_reset[12]; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct debug_store_buffers { + char bts_buffer[65536]; + char pebs_buffer[65536]; +}; + +struct cea_exception_stacks { + char DF_stack_guard[4096]; + char DF_stack[4096]; + char NMI_stack_guard[4096]; + char NMI_stack[4096]; + char DB2_stack_guard[4096]; + char DB2_stack[4096]; + char DB1_stack_guard[4096]; + char DB1_stack[4096]; + char DB_stack_guard[4096]; + char DB_stack[4096]; + char MCE_stack_guard[4096]; + char MCE_stack[4096]; + char IST_top_guard[4096]; +}; + +struct cpu_entry_area { + char gdt[4096]; + struct entry_stack_page entry_stack_page; + struct tss_struct tss; + struct cea_exception_stacks estacks; + struct debug_store cpu_debug_store; + struct debug_store_buffers cpu_debug_buffers; +}; + +struct gdt_page { + struct desc_struct gdt[16]; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct tlb_context { + u64 ctx_id; + u64 tlb_gen; +}; + +struct tlb_state { + struct mm_struct *loaded_mm; + union { + struct mm_struct *last_user_mm; + long unsigned int last_user_mm_ibpb; + }; + u16 loaded_mm_asid; + u16 next_asid; + bool is_lazy; + bool invalidate_other; + short unsigned int user_pcid_flush_mask; + long unsigned int cr4; + struct tlb_context ctxs[6]; +}; + +enum e820_type { + E820_TYPE_RAM = 1, + E820_TYPE_RESERVED = 2, + E820_TYPE_ACPI = 3, + E820_TYPE_NVS = 4, + E820_TYPE_UNUSABLE = 5, + E820_TYPE_PMEM = 7, + E820_TYPE_PRAM = 12, + E820_TYPE_SOFT_RESERVED = 4026531839, + E820_TYPE_RESERVED_KERN = 128, +}; + +struct e820_entry { + u64 addr; + u64 size; + enum e820_type type; +} __attribute__((packed)); + +struct e820_table { + __u32 nr_entries; + struct e820_entry entries[320]; +} __attribute__((packed)); + +struct boot_params_to_save { + unsigned int start; + unsigned int len; +}; + +struct idr { + struct xarray idr_rt; + unsigned int idr_base; + unsigned int idr_next; +}; + +struct kernfs_root; + +struct kernfs_elem_dir { + long unsigned int subdirs; + struct rb_root children; + struct kernfs_root *root; +}; + +struct kernfs_syscall_ops; + +struct kernfs_root { + struct kernfs_node *kn; + unsigned int flags; + struct idr ino_idr; + u32 last_id_lowbits; + u32 id_highbits; + struct kernfs_syscall_ops *syscall_ops; + struct list_head supers; + wait_queue_head_t deactivate_waitq; +}; + +struct kernfs_elem_symlink { + struct kernfs_node *target_kn; +}; + +struct kernfs_ops; + +struct kernfs_open_node; + +struct kernfs_elem_attr { + const struct kernfs_ops *ops; + struct kernfs_open_node *open; + loff_t size; + struct kernfs_node *notify_next; +}; + +struct kernfs_iattrs; + +struct kernfs_node { + atomic_t count; + atomic_t active; + struct kernfs_node *parent; + const char *name; + struct rb_node rb; + const void *ns; + unsigned int hash; + union { + struct kernfs_elem_dir dir; + struct kernfs_elem_symlink symlink; + struct kernfs_elem_attr attr; + }; + void *priv; + u64 id; + short unsigned int flags; + umode_t mode; + struct kernfs_iattrs *iattr; +}; + +struct kernfs_open_file; + +struct kernfs_ops { + int (*open)(struct kernfs_open_file *); + void (*release)(struct kernfs_open_file *); + int (*seq_show)(struct seq_file *, void *); + void * (*seq_start)(struct seq_file *, loff_t *); + void * (*seq_next)(struct seq_file *, void *, loff_t *); + void (*seq_stop)(struct seq_file *, void *); + ssize_t (*read)(struct kernfs_open_file *, char *, size_t, loff_t); + size_t atomic_write_len; + bool prealloc; + ssize_t (*write)(struct kernfs_open_file *, char *, size_t, loff_t); + __poll_t (*poll)(struct kernfs_open_file *, struct poll_table_struct *); + int (*mmap)(struct kernfs_open_file *, struct vm_area_struct *); +}; + +struct kernfs_syscall_ops { + int (*show_options)(struct seq_file *, struct kernfs_root *); + int (*mkdir)(struct kernfs_node *, const char *, umode_t); + int (*rmdir)(struct kernfs_node *); + int (*rename)(struct kernfs_node *, struct kernfs_node *, const char *); + int (*show_path)(struct seq_file *, struct kernfs_node *, struct kernfs_root *); +}; + +struct kernfs_open_file { + struct kernfs_node *kn; + struct file *file; + struct seq_file *seq_file; + void *priv; + struct mutex mutex; + struct mutex prealloc_mutex; + int event; + struct list_head list; + char *prealloc_buf; + size_t atomic_write_len; + bool mmapped: 1; + bool released: 1; + const struct vm_operations_struct *vm_ops; +}; + +enum kobj_ns_type { + KOBJ_NS_TYPE_NONE = 0, + KOBJ_NS_TYPE_NET = 1, + KOBJ_NS_TYPES = 2, +}; + +struct sock; + +struct kobj_ns_type_operations { + enum kobj_ns_type type; + bool (*current_may_mount)(); + void * (*grab_current_ns)(); + const void * (*netlink_ns)(struct sock *); + const void * (*initial_ns)(); + void (*drop_ns)(void *); +}; + +struct bin_attribute; + +struct attribute_group { + const char *name; + umode_t (*is_visible)(struct kobject *, struct attribute *, int); + umode_t (*is_bin_visible)(struct kobject *, struct bin_attribute *, int); + struct attribute **attrs; + struct bin_attribute **bin_attrs; +}; + +struct bin_attribute { + struct attribute attr; + size_t size; + void *private; + ssize_t (*read)(struct file *, struct kobject *, struct bin_attribute *, char *, loff_t, size_t); + ssize_t (*write)(struct file *, struct kobject *, struct bin_attribute *, char *, loff_t, size_t); + int (*mmap)(struct file *, struct kobject *, struct bin_attribute *, struct vm_area_struct *); +}; + +struct sysfs_ops { + ssize_t (*show)(struct kobject *, struct attribute *, char *); + ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t); +}; + +struct kset_uevent_ops; + +struct kset { + struct list_head list; + spinlock_t list_lock; + struct kobject kobj; + const struct kset_uevent_ops *uevent_ops; +}; + +struct kobj_type { + void (*release)(struct kobject *); + const struct sysfs_ops *sysfs_ops; + struct attribute **default_attrs; + const struct attribute_group **default_groups; + const struct kobj_ns_type_operations * (*child_ns_type)(struct kobject *); + const void * (*namespace)(struct kobject *); + void (*get_ownership)(struct kobject *, kuid_t *, kgid_t *); +}; + +struct kobj_uevent_env { + char *argv[3]; + char *envp[32]; + int envp_idx; + char buf[2048]; + int buflen; +}; + +struct kset_uevent_ops { + int (* const filter)(struct kset *, struct kobject *); + const char * (* const name)(struct kset *, struct kobject *); + int (* const uevent)(struct kset *, struct kobject *, struct kobj_uevent_env *); +}; + +struct dev_pm_ops { + int (*prepare)(struct device *); + void (*complete)(struct device *); + int (*suspend)(struct device *); + int (*resume)(struct device *); + int (*freeze)(struct device *); + int (*thaw)(struct device *); + int (*poweroff)(struct device *); + int (*restore)(struct device *); + int (*suspend_late)(struct device *); + int (*resume_early)(struct device *); + int (*freeze_late)(struct device *); + int (*thaw_early)(struct device *); + int (*poweroff_late)(struct device *); + int (*restore_early)(struct device *); + int (*suspend_noirq)(struct device *); + int (*resume_noirq)(struct device *); + int (*freeze_noirq)(struct device *); + int (*thaw_noirq)(struct device *); + int (*poweroff_noirq)(struct device *); + int (*restore_noirq)(struct device *); + int (*runtime_suspend)(struct device *); + int (*runtime_resume)(struct device *); + int (*runtime_idle)(struct device *); +}; + +struct pm_subsys_data { + spinlock_t lock; + unsigned int refcount; + struct list_head clock_list; +}; + +struct wakeup_source { + const char *name; + int id; + struct list_head entry; + spinlock_t lock; + struct wake_irq *wakeirq; + struct timer_list timer; + long unsigned int timer_expires; + ktime_t total_time; + ktime_t max_time; + ktime_t last_time; + ktime_t start_prevent_time; + ktime_t prevent_sleep_time; + long unsigned int event_count; + long unsigned int active_count; + long unsigned int relax_count; + long unsigned int expire_count; + long unsigned int wakeup_count; + struct device *dev; + bool active: 1; + bool autosleep_enabled: 1; +}; + +struct dev_pm_domain { + struct dev_pm_ops ops; + int (*start)(struct device *); + void (*detach)(struct device *, bool); + int (*activate)(struct device *); + void (*sync)(struct device *); + void (*dismiss)(struct device *); +}; + +struct ratelimit_state { + raw_spinlock_t lock; + int interval; + int burst; + int printed; + int missed; + long unsigned int begin; + long unsigned int flags; +}; + +struct iommu_ops; + +struct subsys_private; + +struct bus_type { + const char *name; + const char *dev_name; + struct device *dev_root; + const struct attribute_group **bus_groups; + const struct attribute_group **dev_groups; + const struct attribute_group **drv_groups; + int (*match)(struct device *, struct device_driver *); + int (*uevent)(struct device *, struct kobj_uevent_env *); + int (*probe)(struct device *); + void (*sync_state)(struct device *); + int (*remove)(struct device *); + void (*shutdown)(struct device *); + int (*online)(struct device *); + int (*offline)(struct device *); + int (*suspend)(struct device *, pm_message_t); + int (*resume)(struct device *); + int (*num_vf)(struct device *); + int (*dma_configure)(struct device *); + const struct dev_pm_ops *pm; + const struct iommu_ops *iommu_ops; + struct subsys_private *p; + struct lock_class_key lock_key; + bool need_parent_lock; +}; + +enum probe_type { + PROBE_DEFAULT_STRATEGY = 0, + PROBE_PREFER_ASYNCHRONOUS = 1, + PROBE_FORCE_SYNCHRONOUS = 2, +}; + +struct of_device_id; + +struct acpi_device_id; + +struct driver_private; + +struct device_driver { + const char *name; + struct bus_type *bus; + struct module *owner; + const char *mod_name; + bool suppress_bind_attrs; + enum probe_type probe_type; + const struct of_device_id *of_match_table; + const struct acpi_device_id *acpi_match_table; + int (*probe)(struct device *); + void (*sync_state)(struct device *); + int (*remove)(struct device *); + void (*shutdown)(struct device *); + int (*suspend)(struct device *, pm_message_t); + int (*resume)(struct device *); + const struct attribute_group **groups; + const struct attribute_group **dev_groups; + const struct dev_pm_ops *pm; + void (*coredump)(struct device *); + struct driver_private *p; +}; + +enum iommu_cap { + IOMMU_CAP_CACHE_COHERENCY = 0, + IOMMU_CAP_INTR_REMAP = 1, + IOMMU_CAP_NOEXEC = 2, +}; + +enum iommu_attr { + DOMAIN_ATTR_GEOMETRY = 0, + DOMAIN_ATTR_PAGING = 1, + DOMAIN_ATTR_WINDOWS = 2, + DOMAIN_ATTR_FSL_PAMU_STASH = 3, + DOMAIN_ATTR_FSL_PAMU_ENABLE = 4, + DOMAIN_ATTR_FSL_PAMUV1 = 5, + DOMAIN_ATTR_NESTING = 6, + DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE = 7, + DOMAIN_ATTR_MAX = 8, +}; + +enum iommu_dev_features { + IOMMU_DEV_FEAT_AUX = 0, + IOMMU_DEV_FEAT_SVA = 1, +}; + +struct iommu_domain; + +struct iommu_iotlb_gather; + +struct iommu_resv_region; + +struct of_phandle_args; + +struct iommu_sva; + +struct iommu_fault_event; + +struct iommu_page_response; + +struct iommu_cache_invalidate_info; + +struct iommu_gpasid_bind_data; + +struct iommu_ops { + bool (*capable)(enum iommu_cap); + struct iommu_domain * (*domain_alloc)(unsigned int); + void (*domain_free)(struct iommu_domain *); + int (*attach_dev)(struct iommu_domain *, struct device *); + void (*detach_dev)(struct iommu_domain *, struct device *); + int (*map)(struct iommu_domain *, long unsigned int, phys_addr_t, size_t, int, gfp_t); + size_t (*unmap)(struct iommu_domain *, long unsigned int, size_t, struct iommu_iotlb_gather *); + void (*flush_iotlb_all)(struct iommu_domain *); + void (*iotlb_sync_map)(struct iommu_domain *); + void (*iotlb_sync)(struct iommu_domain *, struct iommu_iotlb_gather *); + phys_addr_t (*iova_to_phys)(struct iommu_domain *, dma_addr_t); + int (*add_device)(struct device *); + void (*remove_device)(struct device *); + struct iommu_group * (*device_group)(struct device *); + int (*domain_get_attr)(struct iommu_domain *, enum iommu_attr, void *); + int (*domain_set_attr)(struct iommu_domain *, enum iommu_attr, void *); + void (*get_resv_regions)(struct device *, struct list_head *); + void (*put_resv_regions)(struct device *, struct list_head *); + void (*apply_resv_region)(struct device *, struct iommu_domain *, struct iommu_resv_region *); + int (*domain_window_enable)(struct iommu_domain *, u32, phys_addr_t, u64, int); + void (*domain_window_disable)(struct iommu_domain *, u32); + int (*of_xlate)(struct device *, struct of_phandle_args *); + bool (*is_attach_deferred)(struct iommu_domain *, struct device *); + bool (*dev_has_feat)(struct device *, enum iommu_dev_features); + bool (*dev_feat_enabled)(struct device *, enum iommu_dev_features); + int (*dev_enable_feat)(struct device *, enum iommu_dev_features); + int (*dev_disable_feat)(struct device *, enum iommu_dev_features); + int (*aux_attach_dev)(struct iommu_domain *, struct device *); + void (*aux_detach_dev)(struct iommu_domain *, struct device *); + int (*aux_get_pasid)(struct iommu_domain *, struct device *); + struct iommu_sva * (*sva_bind)(struct device *, struct mm_struct *, void *); + void (*sva_unbind)(struct iommu_sva *); + int (*sva_get_pasid)(struct iommu_sva *); + int (*page_response)(struct device *, struct iommu_fault_event *, struct iommu_page_response *); + int (*cache_invalidate)(struct iommu_domain *, struct device *, struct iommu_cache_invalidate_info *); + int (*sva_bind_gpasid)(struct iommu_domain *, struct device *, struct iommu_gpasid_bind_data *); + int (*sva_unbind_gpasid)(struct device *, int); + long unsigned int pgsize_bitmap; +}; + +struct device_type { + const char *name; + const struct attribute_group **groups; + int (*uevent)(struct device *, struct kobj_uevent_env *); + char * (*devnode)(struct device *, umode_t *, kuid_t *, kgid_t *); + void (*release)(struct device *); + const struct dev_pm_ops *pm; +}; + +struct of_device_id { + char name[32]; + char type[32]; + char compatible[128]; + const void *data; +}; + +typedef long unsigned int kernel_ulong_t; + +struct acpi_device_id { + __u8 id[9]; + kernel_ulong_t driver_data; + __u32 cls; + __u32 cls_msk; +}; + +struct class { + const char *name; + struct module *owner; + const struct attribute_group **class_groups; + const struct attribute_group **dev_groups; + struct kobject *dev_kobj; + int (*dev_uevent)(struct device *, struct kobj_uevent_env *); + char * (*devnode)(struct device *, umode_t *); + void (*class_release)(struct class *); + void (*dev_release)(struct device *); + int (*shutdown_pre)(struct device *); + const struct kobj_ns_type_operations *ns_type; + const void * (*namespace)(struct device *); + void (*get_ownership)(struct device *, kuid_t *, kgid_t *); + const struct dev_pm_ops *pm; + struct subsys_private *p; +}; + +struct device_dma_parameters { + unsigned int max_segment_size; + long unsigned int segment_boundary_mask; +}; + +enum dma_data_direction { + DMA_BIDIRECTIONAL = 0, + DMA_TO_DEVICE = 1, + DMA_FROM_DEVICE = 2, + DMA_NONE = 3, +}; + +struct sg_table; + +struct scatterlist; + +struct dma_map_ops { + void * (*alloc)(struct device *, size_t, dma_addr_t *, gfp_t, long unsigned int); + void (*free)(struct device *, size_t, void *, dma_addr_t, long unsigned int); + int (*mmap)(struct device *, struct vm_area_struct *, void *, dma_addr_t, size_t, long unsigned int); + int (*get_sgtable)(struct device *, struct sg_table *, void *, dma_addr_t, size_t, long unsigned int); + dma_addr_t (*map_page)(struct device *, struct page *, long unsigned int, size_t, enum dma_data_direction, long unsigned int); + void (*unmap_page)(struct device *, dma_addr_t, size_t, enum dma_data_direction, long unsigned int); + int (*map_sg)(struct device *, struct scatterlist *, int, enum dma_data_direction, long unsigned int); + void (*unmap_sg)(struct device *, struct scatterlist *, int, enum dma_data_direction, long unsigned int); + dma_addr_t (*map_resource)(struct device *, phys_addr_t, size_t, enum dma_data_direction, long unsigned int); + void (*unmap_resource)(struct device *, dma_addr_t, size_t, enum dma_data_direction, long unsigned int); + void (*sync_single_for_cpu)(struct device *, dma_addr_t, size_t, enum dma_data_direction); + void (*sync_single_for_device)(struct device *, dma_addr_t, size_t, enum dma_data_direction); + void (*sync_sg_for_cpu)(struct device *, struct scatterlist *, int, enum dma_data_direction); + void (*sync_sg_for_device)(struct device *, struct scatterlist *, int, enum dma_data_direction); + void (*cache_sync)(struct device *, void *, size_t, enum dma_data_direction); + int (*dma_supported)(struct device *, u64); + u64 (*get_required_mask)(struct device *); + size_t (*max_mapping_size)(struct device *); + long unsigned int (*get_merge_boundary)(struct device *); +}; + +struct node { + struct device dev; + struct list_head access_list; +}; + +enum cpuhp_smt_control { + CPU_SMT_ENABLED = 0, + CPU_SMT_DISABLED = 1, + CPU_SMT_FORCE_DISABLED = 2, + CPU_SMT_NOT_SUPPORTED = 3, + CPU_SMT_NOT_IMPLEMENTED = 4, +}; + +struct cpu_signature { + unsigned int sig; + unsigned int pf; + unsigned int rev; +}; + +struct ucode_cpu_info { + struct cpu_signature cpu_sig; + int valid; + void *mc; +}; + +typedef long unsigned int pto_T__; + +struct kobj_attribute___2; + +struct file_system_type___2; + +struct atomic_notifier_head___2; + +typedef s32 int32_t; + +typedef long unsigned int irq_hw_number_t; + +struct kernel_symbol { + int value_offset; + int name_offset; + int namespace_offset; +}; + +typedef int (*initcall_t)(); + +struct obs_kernel_param { + const char *str; + int (*setup_func)(char *); + int early; +}; + +enum ftrace_dump_mode { + DUMP_NONE = 0, + DUMP_ALL = 1, + DUMP_ORIG = 2, +}; + +struct bug_entry { + int bug_addr_disp; + int file_disp; + short unsigned int line; + short unsigned int flags; +}; + +struct pollfd { + int fd; + short int events; + short int revents; +}; + +typedef const int tracepoint_ptr_t; + +struct bpf_raw_event_map { + struct tracepoint *tp; + void *bpf_func; + u32 num_args; + u32 writable_size; + long: 64; +}; + +struct orc_entry { + s16 sp_offset; + s16 bp_offset; + unsigned int sp_reg: 4; + unsigned int bp_reg: 4; + unsigned int type: 2; + unsigned int end: 1; +} __attribute__((packed)); + +struct seq_operations___2 { + void * (*start)(struct seq_file *, loff_t *); + void (*stop)(struct seq_file *, void *); + void * (*next)(struct seq_file *, void *, loff_t *); + int (*show)(struct seq_file *, void *); +}; + +enum perf_event_state { + PERF_EVENT_STATE_DEAD = 4294967292, + PERF_EVENT_STATE_EXIT = 4294967293, + PERF_EVENT_STATE_ERROR = 4294967294, + PERF_EVENT_STATE_OFF = 4294967295, + PERF_EVENT_STATE_INACTIVE = 0, + PERF_EVENT_STATE_ACTIVE = 1, +}; + +typedef struct { + atomic_long_t a; +} local_t; + +typedef struct { + local_t a; +} local64_t; + +struct perf_event_attr { + __u32 type; + __u32 size; + __u64 config; + union { + __u64 sample_period; + __u64 sample_freq; + }; + __u64 sample_type; + __u64 read_format; + __u64 disabled: 1; + __u64 inherit: 1; + __u64 pinned: 1; + __u64 exclusive: 1; + __u64 exclude_user: 1; + __u64 exclude_kernel: 1; + __u64 exclude_hv: 1; + __u64 exclude_idle: 1; + __u64 mmap: 1; + __u64 comm: 1; + __u64 freq: 1; + __u64 inherit_stat: 1; + __u64 enable_on_exec: 1; + __u64 task: 1; + __u64 watermark: 1; + __u64 precise_ip: 2; + __u64 mmap_data: 1; + __u64 sample_id_all: 1; + __u64 exclude_host: 1; + __u64 exclude_guest: 1; + __u64 exclude_callchain_kernel: 1; + __u64 exclude_callchain_user: 1; + __u64 mmap2: 1; + __u64 comm_exec: 1; + __u64 use_clockid: 1; + __u64 context_switch: 1; + __u64 write_backward: 1; + __u64 namespaces: 1; + __u64 ksymbol: 1; + __u64 bpf_event: 1; + __u64 aux_output: 1; + __u64 __reserved_1: 32; + union { + __u32 wakeup_events; + __u32 wakeup_watermark; + }; + __u32 bp_type; + union { + __u64 bp_addr; + __u64 kprobe_func; + __u64 uprobe_path; + __u64 config1; + }; + union { + __u64 bp_len; + __u64 kprobe_addr; + __u64 probe_offset; + __u64 config2; + }; + __u64 branch_sample_type; + __u64 sample_regs_user; + __u32 sample_stack_user; + __s32 clockid; + __u64 sample_regs_intr; + __u32 aux_watermark; + __u16 sample_max_stack; + __u16 __reserved_2; + __u32 aux_sample_size; + __u32 __reserved_3; +}; + +struct hw_perf_event_extra { + u64 config; + unsigned int reg; + int alloc; + int idx; +}; + +struct arch_hw_breakpoint { + long unsigned int address; + long unsigned int mask; + u8 len; + u8 type; +}; + +struct hw_perf_event { + union { + struct { + u64 config; + u64 last_tag; + long unsigned int config_base; + long unsigned int event_base; + int event_base_rdpmc; + int idx; + int last_cpu; + int flags; + struct hw_perf_event_extra extra_reg; + struct hw_perf_event_extra branch_reg; + }; + struct { + struct hrtimer hrtimer; + }; + struct { + struct list_head tp_list; + }; + struct { + u64 pwr_acc; + u64 ptsc; + }; + struct { + struct arch_hw_breakpoint info; + struct list_head bp_list; + }; + struct { + u8 iommu_bank; + u8 iommu_cntr; + u16 padding; + u64 conf; + u64 conf1; + }; + }; + struct task_struct *target; + void *addr_filters; + long unsigned int addr_filters_gen; + int state; + local64_t prev_count; + u64 sample_period; + u64 last_period; + local64_t period_left; + u64 interrupts_seq; + u64 interrupts; + u64 freq_time_stamp; + u64 freq_count_stamp; +}; + +struct irq_work { + atomic_t flags; + struct llist_node llnode; + void (*func)(struct irq_work *); +}; + +struct perf_addr_filters_head { + struct list_head list; + raw_spinlock_t lock; + unsigned int nr_file_filters; +}; + +struct perf_sample_data; + +typedef void (*perf_overflow_handler_t)(struct perf_event *, struct perf_sample_data *, struct pt_regs *); + +struct pmu; + +struct ring_buffer; + +struct perf_addr_filter_range; + +struct bpf_prog; + +struct trace_event_call; + +struct event_filter; + +struct perf_event { + struct list_head event_entry; + struct list_head sibling_list; + struct list_head active_list; + struct rb_node group_node; + u64 group_index; + struct list_head migrate_entry; + struct hlist_node hlist_entry; + struct list_head active_entry; + int nr_siblings; + int event_caps; + int group_caps; + struct perf_event *group_leader; + struct pmu *pmu; + void *pmu_private; + enum perf_event_state state; + unsigned int attach_state; + local64_t count; + atomic64_t child_count; + u64 total_time_enabled; + u64 total_time_running; + u64 tstamp; + u64 shadow_ctx_time; + struct perf_event_attr attr; + u16 header_size; + u16 id_header_size; + u16 read_size; + struct hw_perf_event hw; + struct perf_event_context *ctx; + atomic_long_t refcount; + atomic64_t child_total_time_enabled; + atomic64_t child_total_time_running; + struct mutex child_mutex; + struct list_head child_list; + struct perf_event *parent; + int oncpu; + int cpu; + struct list_head owner_entry; + struct task_struct *owner; + struct mutex mmap_mutex; + atomic_t mmap_count; + struct ring_buffer *rb; + struct list_head rb_entry; + long unsigned int rcu_batches; + int rcu_pending; + wait_queue_head_t waitq; + struct fasync_struct *fasync; + int pending_wakeup; + int pending_kill; + int pending_disable; + struct irq_work pending; + atomic_t event_limit; + struct perf_addr_filters_head addr_filters; + struct perf_addr_filter_range *addr_filter_ranges; + long unsigned int addr_filters_gen; + struct perf_event *aux_event; + void (*destroy)(struct perf_event *); + struct callback_head callback_head; + struct pid_namespace *ns; + u64 id; + u64 (*clock)(); + perf_overflow_handler_t overflow_handler; + void *overflow_handler_context; + perf_overflow_handler_t orig_overflow_handler; + struct bpf_prog *prog; + struct trace_event_call *tp_event; + struct event_filter *filter; + void *security; + struct list_head sb_list; +}; + +struct lockdep_map {}; + +struct uid_gid_extent { + u32 first; + u32 lower_first; + u32 count; +}; + +struct uid_gid_map { + u32 nr_extents; + union { + struct uid_gid_extent extent[5]; + struct { + struct uid_gid_extent *forward; + struct uid_gid_extent *reverse; + }; + }; +}; + +struct proc_ns_operations; + +struct ns_common { + atomic_long_t stashed; + const struct proc_ns_operations *ops; + unsigned int inum; +}; + +struct ctl_table; + +struct ctl_table_root; + +struct ctl_table_set; + +struct ctl_dir; + +struct ctl_node; + +struct ctl_table_header { + union { + struct { + struct ctl_table *ctl_table; + int used; + int count; + int nreg; + }; + struct callback_head rcu; + }; + struct completion *unregistering; + struct ctl_table *ctl_table_arg; + struct ctl_table_root *root; + struct ctl_table_set *set; + struct ctl_dir *parent; + struct ctl_node *node; + struct hlist_head inodes; +}; + +struct ctl_dir { + struct ctl_table_header header; + struct rb_root root; +}; + +struct ctl_table_set { + int (*is_seen)(struct ctl_table_set *); + struct ctl_dir dir; +}; + +struct ucounts; + +struct user_namespace { + struct uid_gid_map uid_map; + struct uid_gid_map gid_map; + struct uid_gid_map projid_map; + atomic_t count; + struct user_namespace *parent; + int level; + kuid_t owner; + kgid_t group; + struct ns_common ns; + long unsigned int flags; + struct list_head keyring_name_list; + struct key *user_keyring_register; + struct rw_semaphore keyring_sem; + struct work_struct work; + struct ctl_table_set set; + struct ctl_table_header *sysctls; + struct ucounts *ucounts; + int ucount_max[9]; +}; + +enum node_states { + N_POSSIBLE = 0, + N_ONLINE = 1, + N_NORMAL_MEMORY = 2, + N_HIGH_MEMORY = 2, + N_MEMORY = 3, + N_CPU = 4, + NR_NODE_STATES = 5, +}; + +struct delayed_work { + struct work_struct work; + struct timer_list timer; + struct workqueue_struct *wq; + int cpu; +}; + +struct rcu_work { + struct work_struct work; + struct callback_head rcu; + struct workqueue_struct *wq; +}; + +struct rcu_segcblist { + struct callback_head *head; + struct callback_head **tails[4]; + long unsigned int gp_seq[4]; + long int len; + long int len_lazy; + u8 enabled; + u8 offloaded; +}; + +struct srcu_node; + +struct srcu_struct; + +struct srcu_data { + long unsigned int srcu_lock_count[2]; + long unsigned int srcu_unlock_count[2]; + long: 64; + long: 64; + long: 64; + long: 64; + spinlock_t lock; + struct rcu_segcblist srcu_cblist; + long unsigned int srcu_gp_seq_needed; + long unsigned int srcu_gp_seq_needed_exp; + bool srcu_cblist_invoking; + struct timer_list delay_work; + struct work_struct work; + struct callback_head srcu_barrier_head; + struct srcu_node *mynode; + long unsigned int grpmask; + int cpu; + struct srcu_struct *ssp; + long: 64; +}; + +struct srcu_node { + spinlock_t lock; + long unsigned int srcu_have_cbs[4]; + long unsigned int srcu_data_have_cbs[4]; + long unsigned int srcu_gp_seq_needed_exp; + struct srcu_node *srcu_parent; + int grplo; + int grphi; +}; + +struct srcu_struct { + struct srcu_node node[5]; + struct srcu_node *level[3]; + struct mutex srcu_cb_mutex; + spinlock_t lock; + struct mutex srcu_gp_mutex; + unsigned int srcu_idx; + long unsigned int srcu_gp_seq; + long unsigned int srcu_gp_seq_needed; + long unsigned int srcu_gp_seq_needed_exp; + long unsigned int srcu_last_gp_end; + struct srcu_data *sda; + long unsigned int srcu_barrier_seq; + struct mutex srcu_barrier_mutex; + struct completion srcu_barrier_completion; + atomic_t srcu_barrier_cpu_cnt; + struct delayed_work work; +}; + +struct anon_vma { + struct anon_vma *root; + struct rw_semaphore rwsem; + atomic_t refcount; + unsigned int degree; + struct anon_vma *parent; + struct rb_root_cached rb_root; +}; + +struct mempolicy { + atomic_t refcnt; + short unsigned int mode; + short unsigned int flags; + union { + short int preferred_node; + nodemask_t nodes; + } v; + union { + nodemask_t cpuset_mems_allowed; + nodemask_t user_nodemask; + } w; +}; + +struct linux_binprm; + +struct coredump_params; + +struct linux_binfmt { + struct list_head lh; + struct module *module; + int (*load_binary)(struct linux_binprm *); + int (*load_shlib)(struct file *); + int (*core_dump)(struct coredump_params *); + long unsigned int min_coredump; +}; + +typedef void (*smp_call_func_t)(void *); + +struct __call_single_data { + struct llist_node llist; + smp_call_func_t func; + void *info; + unsigned int flags; +}; + +typedef int proc_handler(struct ctl_table *, int, void *, size_t *, loff_t *); + +struct ctl_table_poll; + +struct ctl_table { + const char *procname; + void *data; + int maxlen; + umode_t mode; + struct ctl_table *child; + proc_handler *proc_handler; + struct ctl_table_poll *poll; + void *extra1; + void *extra2; +}; + +struct ctl_table_poll { + atomic_t event; + wait_queue_head_t wait; +}; + +struct ctl_node { + struct rb_node node; + struct ctl_table_header *header; +}; + +struct ctl_table_root { + struct ctl_table_set default_set; + struct ctl_table_set * (*lookup)(struct ctl_table_root *); + void (*set_ownership)(struct ctl_table_header *, struct ctl_table *, kuid_t *, kgid_t *); + int (*permissions)(struct ctl_table_header *, struct ctl_table *); +}; + +enum umh_disable_depth { + UMH_ENABLED = 0, + UMH_FREEZING = 1, + UMH_DISABLED = 2, +}; + +struct va_alignment { + int flags; + long unsigned int mask; + long unsigned int bits; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +typedef __u64 Elf64_Addr; + +typedef __u16 Elf64_Half; + +typedef __u32 Elf64_Word; + +typedef __u64 Elf64_Xword; + +typedef __s64 Elf64_Sxword; + +typedef struct { + Elf64_Sxword d_tag; + union { + Elf64_Xword d_val; + Elf64_Addr d_ptr; + } d_un; +} Elf64_Dyn; + +struct elf64_sym { + Elf64_Word st_name; + unsigned char st_info; + unsigned char st_other; + Elf64_Half st_shndx; + Elf64_Addr st_value; + Elf64_Xword st_size; +}; + +typedef struct elf64_sym Elf64_Sym; + +struct seq_file { + char *buf; + size_t size; + size_t from; + size_t count; + size_t pad_until; + loff_t index; + loff_t read_pos; + u64 version; + struct mutex lock; + const struct seq_operations___2 *op; + int poll_event; + const struct file *file; + void *private; +}; + +typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *); + +struct poll_table_struct { + poll_queue_proc _qproc; + __poll_t _key; +}; + +struct kernel_param; + +struct kernel_param_ops { + unsigned int flags; + int (*set)(const char *, const struct kernel_param *); + int (*get)(char *, const struct kernel_param *); + void (*free)(void *); +}; + +struct kparam_string; + +struct kparam_array; + +struct kernel_param { + const char *name; + struct module *mod; + const struct kernel_param_ops *ops; + const u16 perm; + s8 level; + u8 flags; + union { + void *arg; + const struct kparam_string *str; + const struct kparam_array *arr; + }; +}; + +struct kparam_string { + unsigned int maxlen; + char *string; +}; + +struct kparam_array { + unsigned int max; + unsigned int elemsize; + unsigned int *num; + const struct kernel_param_ops *ops; + void *elem; +}; + +enum module_state { + MODULE_STATE_LIVE = 0, + MODULE_STATE_COMING = 1, + MODULE_STATE_GOING = 2, + MODULE_STATE_UNFORMED = 3, +}; + +struct module_param_attrs; + +struct module_kobject { + struct kobject kobj; + struct module *mod; + struct kobject *drivers_dir; + struct module_param_attrs *mp; + struct completion *kobj_completion; +}; + +struct latch_tree_node { + struct rb_node node[2]; +}; + +struct mod_tree_node { + struct module *mod; + struct latch_tree_node node; +}; + +struct module_layout { + void *base; + unsigned int size; + unsigned int text_size; + unsigned int ro_size; + unsigned int ro_after_init_size; + struct mod_tree_node mtn; +}; + +struct mod_arch_specific { + unsigned int num_orcs; + int *orc_unwind_ip; + struct orc_entry *orc_unwind; +}; + +struct mod_kallsyms { + Elf64_Sym *symtab; + unsigned int num_symtab; + char *strtab; + char *typetab; +}; + +struct module_attribute; + +struct exception_table_entry; + +struct module_sect_attrs; + +struct module_notes_attrs; + +struct trace_eval_map; + +struct error_injection_entry; + +struct module { + enum module_state state; + struct list_head list; + char name[56]; + struct module_kobject mkobj; + struct module_attribute *modinfo_attrs; + const char *version; + const char *srcversion; + struct kobject *holders_dir; + const struct kernel_symbol *syms; + const s32 *crcs; + unsigned int num_syms; + struct mutex param_lock; + struct kernel_param *kp; + unsigned int num_kp; + unsigned int num_gpl_syms; + const struct kernel_symbol *gpl_syms; + const s32 *gpl_crcs; + bool async_probe_requested; + const struct kernel_symbol *gpl_future_syms; + const s32 *gpl_future_crcs; + unsigned int num_gpl_future_syms; + unsigned int num_exentries; + struct exception_table_entry *extable; + int (*init)(); + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct module_layout core_layout; + struct module_layout init_layout; + struct mod_arch_specific arch; + long unsigned int taints; + unsigned int num_bugs; + struct list_head bug_list; + struct bug_entry *bug_table; + struct mod_kallsyms *kallsyms; + struct mod_kallsyms core_kallsyms; + struct module_sect_attrs *sect_attrs; + struct module_notes_attrs *notes_attrs; + char *args; + void *percpu; + unsigned int percpu_size; + unsigned int num_tracepoints; + tracepoint_ptr_t *tracepoints_ptrs; + unsigned int num_srcu_structs; + struct srcu_struct **srcu_struct_ptrs; + unsigned int num_bpf_raw_events; + struct bpf_raw_event_map *bpf_raw_events; + struct jump_entry *jump_entries; + unsigned int num_jump_entries; + unsigned int num_trace_bprintk_fmt; + const char **trace_bprintk_fmt_start; + struct trace_event_call **trace_events; + unsigned int num_trace_events; + struct trace_eval_map **trace_evals; + unsigned int num_trace_evals; + struct list_head source_list; + struct list_head target_list; + void (*exit)(); + atomic_t refcnt; + struct error_injection_entry *ei_funcs; + unsigned int num_ei_funcs; + long: 32; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct error_injection_entry { + long unsigned int addr; + int etype; +}; + +struct module_attribute { + struct attribute attr; + ssize_t (*show)(struct module_attribute *, struct module_kobject *, char *); + ssize_t (*store)(struct module_attribute *, struct module_kobject *, const char *, size_t); + void (*setup)(struct module *, const char *); + int (*test)(struct module *); + void (*free)(struct module *); +}; + +struct exception_table_entry { + int insn; + int fixup; + int handler; +}; + +struct trace_event_functions; + +struct trace_event { + struct hlist_node node; + struct list_head list; + int type; + struct trace_event_functions *funcs; +}; + +struct trace_event_class; + +struct bpf_prog_array; + +struct trace_event_call { + struct list_head list; + struct trace_event_class *class; + union { + char *name; + struct tracepoint *tp; + }; + struct trace_event event; + char *print_fmt; + struct event_filter *filter; + void *mod; + void *data; + int flags; + int perf_refcount; + struct hlist_head *perf_events; + struct bpf_prog_array *prog_array; + int (*perf_perm)(struct trace_event_call *, struct perf_event *); +}; + +struct trace_eval_map { + const char *system; + const char *eval_string; + long unsigned int eval_value; +}; + +struct fs_pin; + +struct pid_namespace { + struct kref kref; + struct idr idr; + struct callback_head rcu; + unsigned int pid_allocated; + struct task_struct *child_reaper; + struct kmem_cache *pid_cachep; + unsigned int level; + struct pid_namespace *parent; + struct vfsmount *proc_mnt; + struct dentry *proc_self; + struct dentry *proc_thread_self; + struct fs_pin *bacct; + struct user_namespace *user_ns; + struct ucounts *ucounts; + struct work_struct proc_work; + kgid_t pid_gid; + int hide_pid; + int reboot; + struct ns_common ns; +}; + +struct rlimit { + __kernel_ulong_t rlim_cur; + __kernel_ulong_t rlim_max; +}; + +struct task_cputime { + u64 stime; + u64 utime; + long long unsigned int sum_exec_runtime; +}; + +typedef void __signalfn_t(int); + +typedef __signalfn_t *__sighandler_t; + +typedef void __restorefn_t(); + +typedef __restorefn_t *__sigrestore_t; + +struct user_struct { + refcount_t __count; + atomic_t processes; + atomic_t sigpending; + atomic_long_t epoll_watches; + long unsigned int mq_bytes; + long unsigned int locked_shm; + long unsigned int unix_inflight; + atomic_long_t pipe_bufs; + struct hlist_node uidhash_node; + kuid_t uid; + atomic_long_t locked_vm; + struct ratelimit_state ratelimit; +}; + +struct sigaction { + __sighandler_t sa_handler; + long unsigned int sa_flags; + __sigrestore_t sa_restorer; + sigset_t sa_mask; +}; + +struct k_sigaction { + struct sigaction sa; +}; + +struct cpu_itimer { + u64 expires; + u64 incr; +}; + +struct task_cputime_atomic { + atomic64_t utime; + atomic64_t stime; + atomic64_t sum_exec_runtime; +}; + +struct thread_group_cputimer { + struct task_cputime_atomic cputime_atomic; +}; + +struct pacct_struct { + int ac_flag; + long int ac_exitcode; + long unsigned int ac_mem; + u64 ac_utime; + u64 ac_stime; + long unsigned int ac_minflt; + long unsigned int ac_majflt; +}; + +struct tty_struct; + +struct taskstats; + +struct tty_audit_buf; + +struct signal_struct { + refcount_t sigcnt; + atomic_t live; + int nr_threads; + struct list_head thread_head; + wait_queue_head_t wait_chldexit; + struct task_struct *curr_target; + struct sigpending shared_pending; + struct hlist_head multiprocess; + int group_exit_code; + int notify_count; + struct task_struct *group_exit_task; + int group_stop_count; + unsigned int flags; + unsigned int is_child_subreaper: 1; + unsigned int has_child_subreaper: 1; + int posix_timer_id; + struct list_head posix_timers; + struct hrtimer real_timer; + ktime_t it_real_incr; + struct cpu_itimer it[2]; + struct thread_group_cputimer cputimer; + struct posix_cputimers posix_cputimers; + struct pid *pids[4]; + struct pid *tty_old_pgrp; + int leader; + struct tty_struct *tty; + seqlock_t stats_lock; + u64 utime; + u64 stime; + u64 cutime; + u64 cstime; + u64 gtime; + u64 cgtime; + struct prev_cputime prev_cputime; + long unsigned int nvcsw; + long unsigned int nivcsw; + long unsigned int cnvcsw; + long unsigned int cnivcsw; + long unsigned int min_flt; + long unsigned int maj_flt; + long unsigned int cmin_flt; + long unsigned int cmaj_flt; + long unsigned int inblock; + long unsigned int oublock; + long unsigned int cinblock; + long unsigned int coublock; + long unsigned int maxrss; + long unsigned int cmaxrss; + struct task_io_accounting ioac; + long long unsigned int sum_sched_runtime; + struct rlimit rlim[16]; + struct pacct_struct pacct; + struct taskstats *stats; + unsigned int audit_tty; + struct tty_audit_buf *tty_audit_buf; + bool oom_flag_origin; + short int oom_score_adj; + short int oom_score_adj_min; + struct mm_struct *oom_mm; + struct mutex cred_guard_mutex; +}; + +typedef int32_t key_serial_t; + +typedef uint32_t key_perm_t; + +struct key_type; + +struct key_tag; + +struct keyring_index_key { + long unsigned int hash; + union { + struct { + u16 desc_len; + char desc[6]; + }; + long unsigned int x; + }; + struct key_type *type; + struct key_tag *domain_tag; + const char *description; +}; + +union key_payload { + void *rcu_data0; + void *data[4]; +}; + +struct assoc_array_ptr; + +struct assoc_array { + struct assoc_array_ptr *root; + long unsigned int nr_leaves_on_tree; +}; + +struct key_user; + +struct key_restriction; + +struct key { + refcount_t usage; + key_serial_t serial; + union { + struct list_head graveyard_link; + struct rb_node serial_node; + }; + struct rw_semaphore sem; + struct key_user *user; + void *security; + union { + time64_t expiry; + time64_t revoked_at; + }; + time64_t last_used_at; + kuid_t uid; + kgid_t gid; + key_perm_t perm; + short unsigned int quotalen; + short unsigned int datalen; + short int state; + long unsigned int flags; + union { + struct keyring_index_key index_key; + struct { + long unsigned int hash; + long unsigned int len_desc; + struct key_type *type; + struct key_tag *domain_tag; + char *description; + }; + }; + union { + union key_payload payload; + struct { + struct list_head name_link; + struct assoc_array keys; + }; + }; + struct key_restriction *restrict_link; +}; + +struct uts_namespace; + +struct ipc_namespace; + +struct mnt_namespace; + +struct net; + +struct cgroup_namespace; + +struct nsproxy { + atomic_t count; + struct uts_namespace *uts_ns; + struct ipc_namespace *ipc_ns; + struct mnt_namespace *mnt_ns; + struct pid_namespace *pid_ns_for_children; + struct net *net_ns; + struct cgroup_namespace *cgroup_ns; +}; + +struct sighand_struct { + spinlock_t siglock; + refcount_t count; + wait_queue_head_t signalfd_wqh; + struct k_sigaction action[64]; +}; + +struct bio; + +struct bio_list { + struct bio *head; + struct bio *tail; +}; + +struct blk_plug { + struct list_head mq_list; + struct list_head cb_list; + short unsigned int rq_count; + bool multiple_queues; +}; + +struct reclaim_state { + long unsigned int reclaimed_slab; +}; + +typedef int congested_fn(void *, int); + +struct fprop_local_percpu { + struct percpu_counter events; + unsigned int period; + raw_spinlock_t lock; +}; + +enum wb_reason { + WB_REASON_BACKGROUND = 0, + WB_REASON_VMSCAN = 1, + WB_REASON_SYNC = 2, + WB_REASON_PERIODIC = 3, + WB_REASON_LAPTOP_TIMER = 4, + WB_REASON_FREE_MORE_MEM = 5, + WB_REASON_FS_FREE_SPACE = 6, + WB_REASON_FORKER_THREAD = 7, + WB_REASON_FOREIGN_FLUSH = 8, + WB_REASON_MAX = 9, +}; + +struct bdi_writeback_congested; + +struct bdi_writeback { + struct backing_dev_info *bdi; + long unsigned int state; + long unsigned int last_old_flush; + struct list_head b_dirty; + struct list_head b_io; + struct list_head b_more_io; + struct list_head b_dirty_time; + spinlock_t list_lock; + struct percpu_counter stat[4]; + struct bdi_writeback_congested *congested; + long unsigned int bw_time_stamp; + long unsigned int dirtied_stamp; + long unsigned int written_stamp; + long unsigned int write_bandwidth; + long unsigned int avg_write_bandwidth; + long unsigned int dirty_ratelimit; + long unsigned int balanced_dirty_ratelimit; + struct fprop_local_percpu completions; + int dirty_exceeded; + enum wb_reason start_all_reason; + spinlock_t work_lock; + struct list_head work_list; + struct delayed_work dwork; + long unsigned int dirty_sleep; + struct list_head bdi_node; +}; + +struct backing_dev_info { + u64 id; + struct rb_node rb_node; + struct list_head bdi_list; + long unsigned int ra_pages; + long unsigned int io_pages; + congested_fn *congested_fn; + void *congested_data; + const char *name; + struct kref refcnt; + unsigned int capabilities; + unsigned int min_ratio; + unsigned int max_ratio; + unsigned int max_prop_frac; + atomic_long_t tot_write_bandwidth; + struct bdi_writeback wb; + struct list_head wb_list; + struct bdi_writeback_congested *wb_congested; + wait_queue_head_t wb_waitq; + struct device *dev; + struct device *owner; + struct timer_list laptop_mode_wb_timer; + struct dentry *debug_dir; +}; + +struct cgroup_subsys_state; + +struct cgroup; + +struct css_set { + struct cgroup_subsys_state *subsys[4]; + refcount_t refcount; + struct css_set *dom_cset; + struct cgroup *dfl_cgrp; + int nr_tasks; + struct list_head tasks; + struct list_head mg_tasks; + struct list_head dying_tasks; + struct list_head task_iters; + struct list_head e_cset_node[4]; + struct list_head threaded_csets; + struct list_head threaded_csets_node; + struct hlist_node hlist; + struct list_head cgrp_links; + struct list_head mg_preload_node; + struct list_head mg_node; + struct cgroup *mg_src_cgrp; + struct cgroup *mg_dst_cgrp; + struct css_set *mg_dst_cset; + bool dead; + struct callback_head callback_head; +}; + +struct perf_event_groups { + struct rb_root tree; + u64 index; +}; + +struct perf_event_context { + struct pmu *pmu; + raw_spinlock_t lock; + struct mutex mutex; + struct list_head active_ctx_list; + struct perf_event_groups pinned_groups; + struct perf_event_groups flexible_groups; + struct list_head event_list; + struct list_head pinned_active; + struct list_head flexible_active; + int nr_events; + int nr_active; + int is_active; + int nr_stat; + int nr_freq; + int rotate_disable; + int rotate_necessary; + refcount_t refcount; + struct task_struct *task; + u64 time; + u64 timestamp; + struct perf_event_context *parent_ctx; + u64 parent_gen; + u64 generation; + int pin_count; + void *task_ctx_data; + struct callback_head callback_head; +}; + +struct task_delay_info { + raw_spinlock_t lock; + unsigned int flags; + u64 blkio_start; + u64 blkio_delay; + u64 swapin_delay; + u32 blkio_count; + u32 swapin_count; + u64 freepages_start; + u64 freepages_delay; + u64 thrashing_start; + u64 thrashing_delay; + u32 freepages_count; + u32 thrashing_count; +}; + +union thread_union { + struct task_struct task; + long unsigned int stack[2048]; +}; + +typedef unsigned int blk_qc_t; + +typedef blk_qc_t make_request_fn(struct request_queue *, struct bio *); + +struct request; + +typedef int dma_drain_needed_fn(struct request *); + +struct blk_rq_stat { + u64 mean; + u64 min; + u64 max; + u32 nr_samples; + u64 batch; +}; + +enum blk_zoned_model { + BLK_ZONED_NONE = 0, + BLK_ZONED_HA = 1, + BLK_ZONED_HM = 2, +}; + +struct queue_limits { + long unsigned int bounce_pfn; + long unsigned int seg_boundary_mask; + long unsigned int virt_boundary_mask; + unsigned int max_hw_sectors; + unsigned int max_dev_sectors; + unsigned int chunk_sectors; + unsigned int max_sectors; + unsigned int max_segment_size; + unsigned int physical_block_size; + unsigned int logical_block_size; + unsigned int alignment_offset; + unsigned int io_min; + unsigned int io_opt; + unsigned int max_discard_sectors; + unsigned int max_hw_discard_sectors; + unsigned int max_write_same_sectors; + unsigned int max_write_zeroes_sectors; + unsigned int discard_granularity; + unsigned int discard_alignment; + short unsigned int max_segments; + short unsigned int max_integrity_segments; + short unsigned int max_discard_segments; + unsigned char misaligned; + unsigned char discard_misaligned; + unsigned char raid_partial_stripes_expensive; + enum blk_zoned_model zoned; +}; + +struct bsg_ops; + +struct bsg_class_device { + struct device *class_dev; + int minor; + struct request_queue *queue; + const struct bsg_ops *ops; +}; + +typedef void *mempool_alloc_t(gfp_t, void *); + +typedef void mempool_free_t(void *, void *); + +struct mempool_s { + spinlock_t lock; + int min_nr; + int curr_nr; + void **elements; + void *pool_data; + mempool_alloc_t *alloc; + mempool_free_t *free; + wait_queue_head_t wait; +}; + +typedef struct mempool_s mempool_t; + +struct bio_set { + struct kmem_cache *bio_slab; + unsigned int front_pad; + mempool_t bio_pool; + mempool_t bvec_pool; + spinlock_t rescue_lock; + struct bio_list rescue_list; + struct work_struct rescue_work; + struct workqueue_struct *rescue_workqueue; +}; + +struct elevator_queue; + +struct blk_queue_stats; + +struct rq_qos; + +struct blk_mq_ops; + +struct blk_mq_ctx; + +struct blk_mq_hw_ctx; + +struct blk_stat_callback; + +struct blk_trace; + +struct blk_flush_queue; + +struct blk_mq_tag_set; + +struct request_queue { + struct request *last_merge; + struct elevator_queue *elevator; + struct blk_queue_stats *stats; + struct rq_qos *rq_qos; + make_request_fn *make_request_fn; + dma_drain_needed_fn *dma_drain_needed; + const struct blk_mq_ops *mq_ops; + struct blk_mq_ctx *queue_ctx; + unsigned int queue_depth; + struct blk_mq_hw_ctx **queue_hw_ctx; + unsigned int nr_hw_queues; + struct backing_dev_info *backing_dev_info; + void *queuedata; + long unsigned int queue_flags; + atomic_t pm_only; + int id; + gfp_t bounce_gfp; + spinlock_t queue_lock; + struct kobject kobj; + struct kobject *mq_kobj; + struct device *dev; + int rpm_status; + unsigned int nr_pending; long unsigned int nr_requests; unsigned int dma_drain_size; void *dma_drain_buffer; @@ -6545,5469 +8136,6732 @@ struct request_queue { bool mq_sysfs_init_done; size_t cmd_size; struct work_struct release_work; - u64 write_hints[5]; + u64 write_hints[5]; +}; + +enum writeback_sync_modes { + WB_SYNC_NONE = 0, + WB_SYNC_ALL = 1, +}; + +struct writeback_control { + long int nr_to_write; + long int pages_skipped; + loff_t range_start; + loff_t range_end; + enum writeback_sync_modes sync_mode; + unsigned int for_kupdate: 1; + unsigned int for_background: 1; + unsigned int tagged_writepages: 1; + unsigned int for_reclaim: 1; + unsigned int range_cyclic: 1; + unsigned int for_sync: 1; + unsigned int no_cgroup_owner: 1; + unsigned int punt_to_cgroup: 1; +}; + +struct swap_cluster_info { + spinlock_t lock; + unsigned int data: 24; + unsigned int flags: 8; +}; + +struct swap_cluster_list { + struct swap_cluster_info head; + struct swap_cluster_info tail; +}; + +struct percpu_cluster; + +struct swap_info_struct { + long unsigned int flags; + short int prio; + struct plist_node list; + signed char type; + unsigned int max; + unsigned char *swap_map; + struct swap_cluster_info *cluster_info; + struct swap_cluster_list free_clusters; + unsigned int lowest_bit; + unsigned int highest_bit; + unsigned int pages; + unsigned int inuse_pages; + unsigned int cluster_next; + unsigned int cluster_nr; + struct percpu_cluster *percpu_cluster; + struct rb_root swap_extent_root; + struct block_device *bdev; + struct file *swap_file; + unsigned int old_block_size; + spinlock_t lock; + spinlock_t cont_lock; + struct work_struct discard_work; + struct swap_cluster_list discard_clusters; + struct plist_node avail_lists[0]; +}; + +struct partition_meta_info; + +struct disk_stats; + +struct hd_struct { + sector_t start_sect; + sector_t nr_sects; + seqcount_t nr_sects_seq; + sector_t alignment_offset; + unsigned int discard_alignment; + struct device __dev; + struct kobject *holder_dir; + int policy; + int partno; + struct partition_meta_info *info; + long unsigned int stamp; + struct disk_stats *dkstats; + struct percpu_ref ref; + struct rcu_work rcu_work; +}; + +struct disk_part_tbl; + +struct block_device_operations; + +struct timer_rand_state; + +struct disk_events; + +struct badblocks; + +struct gendisk { + int major; + int first_minor; + int minors; + char disk_name[32]; + char * (*devnode)(struct gendisk *, umode_t *); + short unsigned int events; + short unsigned int event_flags; + struct disk_part_tbl *part_tbl; + struct hd_struct part0; + const struct block_device_operations *fops; + struct request_queue *queue; + void *private_data; + int flags; + struct rw_semaphore lookup_sem; + struct kobject *slave_dir; + struct timer_rand_state *random; + atomic_t sync_io; + struct disk_events *ev; + int node_id; + struct badblocks *bb; + struct lockdep_map lockdep_map; +}; + +struct cdev { + struct kobject kobj; + struct module *owner; + const struct file_operations *ops; + struct list_head list; + dev_t dev; + unsigned int count; +}; + +typedef u8 blk_status_t; + +struct bvec_iter { + sector_t bi_sector; + unsigned int bi_size; + unsigned int bi_idx; + unsigned int bi_bvec_done; +}; + +typedef void bio_end_io_t(struct bio *); + +struct bio_vec { + struct page *bv_page; + unsigned int bv_len; + unsigned int bv_offset; +}; + +struct bio { + struct bio *bi_next; + struct gendisk *bi_disk; + unsigned int bi_opf; + short unsigned int bi_flags; + short unsigned int bi_ioprio; + short unsigned int bi_write_hint; + blk_status_t bi_status; + u8 bi_partno; + atomic_t __bi_remaining; + struct bvec_iter bi_iter; + bio_end_io_t *bi_end_io; + void *bi_private; + union { }; + short unsigned int bi_vcnt; + short unsigned int bi_max_vecs; + atomic_t __bi_cnt; + struct bio_vec *bi_io_vec; + struct bio_set *bi_pool; + struct bio_vec bi_inline_vecs[0]; +}; + +struct linux_binprm { + struct vm_area_struct *vma; + long unsigned int vma_pages; + struct mm_struct *mm; + long unsigned int p; + long unsigned int argmin; + unsigned int called_set_creds: 1; + unsigned int cap_elevated: 1; + unsigned int secureexec: 1; + unsigned int recursion_depth; + struct file *file; + struct cred *cred; + int unsafe; + unsigned int per_clear; + int argc; + int envc; + const char *filename; + const char *interp; + unsigned int interp_flags; + unsigned int interp_data; + long unsigned int loader; + long unsigned int exec; + struct rlimit rlim_stack; + char buf[256]; +}; + +struct coredump_params { + const kernel_siginfo_t *siginfo; + struct pt_regs *regs; + struct file *file; + long unsigned int limit; + long unsigned int mm_flags; + loff_t written; + loff_t pos; +}; + +struct key_tag { + struct callback_head rcu; + refcount_t usage; + bool removed; +}; + +typedef int (*request_key_actor_t)(struct key *, void *); + +struct key_preparsed_payload; + +struct key_match_data; + +struct kernel_pkey_params; + +struct kernel_pkey_query; + +struct key_type { + const char *name; + size_t def_datalen; + unsigned int flags; + int (*vet_description)(const char *); + int (*preparse)(struct key_preparsed_payload *); + void (*free_preparse)(struct key_preparsed_payload *); + int (*instantiate)(struct key *, struct key_preparsed_payload *); + int (*update)(struct key *, struct key_preparsed_payload *); + int (*match_preparse)(struct key_match_data *); + void (*match_free)(struct key_match_data *); + void (*revoke)(struct key *); + void (*destroy)(struct key *); + void (*describe)(const struct key *, struct seq_file *); + long int (*read)(const struct key *, char *, size_t); + request_key_actor_t request_key; + struct key_restriction * (*lookup_restriction)(const char *); + int (*asym_query)(const struct kernel_pkey_params *, struct kernel_pkey_query *); + int (*asym_eds_op)(struct kernel_pkey_params *, const void *, void *); + int (*asym_verify_signature)(struct kernel_pkey_params *, const void *, const void *); + struct list_head link; + struct lock_class_key lock_class; +}; + +typedef int (*key_restrict_link_func_t)(struct key *, const struct key_type *, const union key_payload *, struct key *); + +struct key_restriction { + key_restrict_link_func_t check; + struct key *key; + struct key_type *keytype; +}; + +struct group_info { + atomic_t usage; + int ngroups; + kgid_t gid[0]; +}; + +struct ring_buffer_event { + u32 type_len: 5; + u32 time_delta: 27; + u32 array[0]; +}; + +struct seq_buf { + char *buffer; + size_t size; + size_t len; + loff_t readpos; +}; + +struct trace_seq { + unsigned char buffer[4096]; + struct seq_buf seq; + int full; +}; + +enum perf_sw_ids { + PERF_COUNT_SW_CPU_CLOCK = 0, + PERF_COUNT_SW_TASK_CLOCK = 1, + PERF_COUNT_SW_PAGE_FAULTS = 2, + PERF_COUNT_SW_CONTEXT_SWITCHES = 3, + PERF_COUNT_SW_CPU_MIGRATIONS = 4, + PERF_COUNT_SW_PAGE_FAULTS_MIN = 5, + PERF_COUNT_SW_PAGE_FAULTS_MAJ = 6, + PERF_COUNT_SW_ALIGNMENT_FAULTS = 7, + PERF_COUNT_SW_EMULATION_FAULTS = 8, + PERF_COUNT_SW_DUMMY = 9, + PERF_COUNT_SW_BPF_OUTPUT = 10, + PERF_COUNT_SW_MAX = 11, +}; + +union perf_mem_data_src { + __u64 val; + struct { + __u64 mem_op: 5; + __u64 mem_lvl: 14; + __u64 mem_snoop: 5; + __u64 mem_lock: 2; + __u64 mem_dtlb: 7; + __u64 mem_lvl_num: 4; + __u64 mem_remote: 1; + __u64 mem_snoopx: 2; + __u64 mem_rsvd: 24; + }; +}; + +struct perf_branch_entry { + __u64 from; + __u64 to; + __u64 mispred: 1; + __u64 predicted: 1; + __u64 in_tx: 1; + __u64 abort: 1; + __u64 cycles: 16; + __u64 type: 4; + __u64 reserved: 40; +}; + +struct taskstats { + __u16 version; + __u32 ac_exitcode; + __u8 ac_flag; + __u8 ac_nice; + __u64 cpu_count; + __u64 cpu_delay_total; + __u64 blkio_count; + __u64 blkio_delay_total; + __u64 swapin_count; + __u64 swapin_delay_total; + __u64 cpu_run_real_total; + __u64 cpu_run_virtual_total; + char ac_comm[32]; + __u8 ac_sched; + __u8 ac_pad[3]; + int: 32; + __u32 ac_uid; + __u32 ac_gid; + __u32 ac_pid; + __u32 ac_ppid; + __u32 ac_btime; + __u64 ac_etime; + __u64 ac_utime; + __u64 ac_stime; + __u64 ac_minflt; + __u64 ac_majflt; + __u64 coremem; + __u64 virtmem; + __u64 hiwater_rss; + __u64 hiwater_vm; + __u64 read_char; + __u64 write_char; + __u64 read_syscalls; + __u64 write_syscalls; + __u64 read_bytes; + __u64 write_bytes; + __u64 cancelled_write_bytes; + __u64 nvcsw; + __u64 nivcsw; + __u64 ac_utimescaled; + __u64 ac_stimescaled; + __u64 cpu_scaled_run_real_total; + __u64 freepages_count; + __u64 freepages_delay_total; + __u64 thrashing_count; + __u64 thrashing_delay_total; +}; + +struct new_utsname { + char sysname[65]; + char nodename[65]; + char release[65]; + char version[65]; + char machine[65]; + char domainname[65]; +}; + +struct uts_namespace { + struct kref kref; + struct new_utsname name; + struct user_namespace *user_ns; + struct ucounts *ucounts; + struct ns_common ns; +}; + +struct cgroup_namespace { + refcount_t count; + struct ns_common ns; + struct user_namespace *user_ns; + struct ucounts *ucounts; + struct css_set *root_cset; +}; + +struct proc_ns_operations { + const char *name; + const char *real_ns_name; + int type; + struct ns_common * (*get)(struct task_struct *); + void (*put)(struct ns_common *); + int (*install)(struct nsproxy *, struct ns_common *); + struct user_namespace * (*owner)(struct ns_common *); + struct ns_common * (*get_parent)(struct ns_common *); +}; + +struct ucounts { + struct hlist_node node; + struct user_namespace *ns; + kuid_t uid; + int count; + atomic_t ucount[9]; +}; + +struct perf_guest_info_callbacks { + int (*is_in_guest)(); + int (*is_user_mode)(); + long unsigned int (*get_guest_ip)(); + void (*handle_intel_pt_intr)(); +}; + +struct perf_cpu_context; + +struct perf_output_handle; + +struct pmu { + struct list_head entry; + struct module *module; + struct device *dev; + const struct attribute_group **attr_groups; + const struct attribute_group **attr_update; + const char *name; + int type; + int capabilities; + int *pmu_disable_count; + struct perf_cpu_context *pmu_cpu_context; + atomic_t exclusive_cnt; + int task_ctx_nr; + int hrtimer_interval_ms; + unsigned int nr_addr_filters; + void (*pmu_enable)(struct pmu *); + void (*pmu_disable)(struct pmu *); + int (*event_init)(struct perf_event *); + void (*event_mapped)(struct perf_event *, struct mm_struct *); + void (*event_unmapped)(struct perf_event *, struct mm_struct *); + int (*add)(struct perf_event *, int); + void (*del)(struct perf_event *, int); + void (*start)(struct perf_event *, int); + void (*stop)(struct perf_event *, int); + void (*read)(struct perf_event *); + void (*start_txn)(struct pmu *, unsigned int); + int (*commit_txn)(struct pmu *); + void (*cancel_txn)(struct pmu *); + int (*event_idx)(struct perf_event *); + void (*sched_task)(struct perf_event_context *, bool); + size_t task_ctx_size; + void (*swap_task_ctx)(struct perf_event_context *, struct perf_event_context *); + void * (*setup_aux)(struct perf_event *, void **, int, bool); + void (*free_aux)(void *); + long int (*snapshot_aux)(struct perf_event *, struct perf_output_handle *, long unsigned int); + int (*addr_filters_validate)(struct list_head *); + void (*addr_filters_sync)(struct perf_event *); + int (*aux_output_match)(struct perf_event *); + int (*filter_match)(struct perf_event *); + int (*check_period)(struct perf_event *, u64); +}; + +enum irq_domain_bus_token { + DOMAIN_BUS_ANY = 0, + DOMAIN_BUS_WIRED = 1, + DOMAIN_BUS_GENERIC_MSI = 2, + DOMAIN_BUS_PCI_MSI = 3, + DOMAIN_BUS_PLATFORM_MSI = 4, + DOMAIN_BUS_NEXUS = 5, + DOMAIN_BUS_IPI = 6, + DOMAIN_BUS_FSL_MC_MSI = 7, + DOMAIN_BUS_TI_SCI_INTA_MSI = 8, + DOMAIN_BUS_WAKEUP = 9, +}; + +struct irq_domain_ops; + +struct irq_domain_chip_generic; + +struct irq_domain { + struct list_head link; + const char *name; + const struct irq_domain_ops *ops; + void *host_data; + unsigned int flags; + unsigned int mapcount; + struct fwnode_handle *fwnode; + enum irq_domain_bus_token bus_token; + struct irq_domain_chip_generic *gc; + struct irq_domain *parent; + irq_hw_number_t hwirq_max; + unsigned int revmap_direct_max_irq; + unsigned int revmap_size; + struct xarray revmap_tree; + struct mutex revmap_tree_mutex; + unsigned int linear_revmap[0]; +}; + +typedef u32 phandle; + +struct property; + +struct device_node { + const char *name; + phandle phandle; + const char *full_name; + struct fwnode_handle fwnode; + struct property *properties; + struct property *deadprops; + struct device_node *parent; + struct device_node *child; + struct device_node *sibling; + long unsigned int _flags; + void *data; +}; + +enum cpuhp_state { + CPUHP_INVALID = 4294967295, + CPUHP_OFFLINE = 0, + CPUHP_CREATE_THREADS = 1, + CPUHP_PERF_PREPARE = 2, + CPUHP_PERF_X86_PREPARE = 3, + CPUHP_PERF_X86_AMD_UNCORE_PREP = 4, + CPUHP_PERF_POWER = 5, + CPUHP_PERF_SUPERH = 6, + CPUHP_X86_HPET_DEAD = 7, + CPUHP_X86_APB_DEAD = 8, + CPUHP_X86_MCE_DEAD = 9, + CPUHP_VIRT_NET_DEAD = 10, + CPUHP_SLUB_DEAD = 11, + CPUHP_MM_WRITEBACK_DEAD = 12, + CPUHP_MM_VMSTAT_DEAD = 13, + CPUHP_SOFTIRQ_DEAD = 14, + CPUHP_NET_MVNETA_DEAD = 15, + CPUHP_CPUIDLE_DEAD = 16, + CPUHP_ARM64_FPSIMD_DEAD = 17, + CPUHP_ARM_OMAP_WAKE_DEAD = 18, + CPUHP_IRQ_POLL_DEAD = 19, + CPUHP_BLOCK_SOFTIRQ_DEAD = 20, + CPUHP_ACPI_CPUDRV_DEAD = 21, + CPUHP_S390_PFAULT_DEAD = 22, + CPUHP_BLK_MQ_DEAD = 23, + CPUHP_FS_BUFF_DEAD = 24, + CPUHP_PRINTK_DEAD = 25, + CPUHP_MM_MEMCQ_DEAD = 26, + CPUHP_PERCPU_CNT_DEAD = 27, + CPUHP_RADIX_DEAD = 28, + CPUHP_PAGE_ALLOC_DEAD = 29, + CPUHP_NET_DEV_DEAD = 30, + CPUHP_PCI_XGENE_DEAD = 31, + CPUHP_IOMMU_INTEL_DEAD = 32, + CPUHP_LUSTRE_CFS_DEAD = 33, + CPUHP_AP_ARM_CACHE_B15_RAC_DEAD = 34, + CPUHP_WORKQUEUE_PREP = 35, + CPUHP_POWER_NUMA_PREPARE = 36, + CPUHP_HRTIMERS_PREPARE = 37, + CPUHP_PROFILE_PREPARE = 38, + CPUHP_X2APIC_PREPARE = 39, + CPUHP_SMPCFD_PREPARE = 40, + CPUHP_RELAY_PREPARE = 41, + CPUHP_SLAB_PREPARE = 42, + CPUHP_MD_RAID5_PREPARE = 43, + CPUHP_RCUTREE_PREP = 44, + CPUHP_CPUIDLE_COUPLED_PREPARE = 45, + CPUHP_POWERPC_PMAC_PREPARE = 46, + CPUHP_POWERPC_MMU_CTX_PREPARE = 47, + CPUHP_XEN_PREPARE = 48, + CPUHP_XEN_EVTCHN_PREPARE = 49, + CPUHP_ARM_SHMOBILE_SCU_PREPARE = 50, + CPUHP_SH_SH3X_PREPARE = 51, + CPUHP_NET_FLOW_PREPARE = 52, + CPUHP_TOPOLOGY_PREPARE = 53, + CPUHP_NET_IUCV_PREPARE = 54, + CPUHP_ARM_BL_PREPARE = 55, + CPUHP_TRACE_RB_PREPARE = 56, + CPUHP_MM_ZS_PREPARE = 57, + CPUHP_MM_ZSWP_MEM_PREPARE = 58, + CPUHP_MM_ZSWP_POOL_PREPARE = 59, + CPUHP_KVM_PPC_BOOK3S_PREPARE = 60, + CPUHP_ZCOMP_PREPARE = 61, + CPUHP_TIMERS_PREPARE = 62, + CPUHP_MIPS_SOC_PREPARE = 63, + CPUHP_BP_PREPARE_DYN = 64, + CPUHP_BP_PREPARE_DYN_END = 84, + CPUHP_BRINGUP_CPU = 85, + CPUHP_AP_IDLE_DEAD = 86, + CPUHP_AP_OFFLINE = 87, + CPUHP_AP_SCHED_STARTING = 88, + CPUHP_AP_RCUTREE_DYING = 89, + CPUHP_AP_IRQ_GIC_STARTING = 90, + CPUHP_AP_IRQ_HIP04_STARTING = 91, + CPUHP_AP_IRQ_ARMADA_XP_STARTING = 92, + CPUHP_AP_IRQ_BCM2836_STARTING = 93, + CPUHP_AP_IRQ_MIPS_GIC_STARTING = 94, + CPUHP_AP_ARM_MVEBU_COHERENCY = 95, + CPUHP_AP_MICROCODE_LOADER = 96, + CPUHP_AP_PERF_X86_AMD_UNCORE_STARTING = 97, + CPUHP_AP_PERF_X86_STARTING = 98, + CPUHP_AP_PERF_X86_AMD_IBS_STARTING = 99, + CPUHP_AP_PERF_X86_CQM_STARTING = 100, + CPUHP_AP_PERF_X86_CSTATE_STARTING = 101, + CPUHP_AP_PERF_XTENSA_STARTING = 102, + CPUHP_AP_MIPS_OP_LOONGSON3_STARTING = 103, + CPUHP_AP_ARM_SDEI_STARTING = 104, + CPUHP_AP_ARM_VFP_STARTING = 105, + CPUHP_AP_ARM64_DEBUG_MONITORS_STARTING = 106, + CPUHP_AP_PERF_ARM_HW_BREAKPOINT_STARTING = 107, + CPUHP_AP_PERF_ARM_ACPI_STARTING = 108, + CPUHP_AP_PERF_ARM_STARTING = 109, + CPUHP_AP_ARM_L2X0_STARTING = 110, + CPUHP_AP_EXYNOS4_MCT_TIMER_STARTING = 111, + CPUHP_AP_ARM_ARCH_TIMER_STARTING = 112, + CPUHP_AP_ARM_GLOBAL_TIMER_STARTING = 113, + CPUHP_AP_JCORE_TIMER_STARTING = 114, + CPUHP_AP_ARM_TWD_STARTING = 115, + CPUHP_AP_QCOM_TIMER_STARTING = 116, + CPUHP_AP_TEGRA_TIMER_STARTING = 117, + CPUHP_AP_ARMADA_TIMER_STARTING = 118, + CPUHP_AP_MARCO_TIMER_STARTING = 119, + CPUHP_AP_MIPS_GIC_TIMER_STARTING = 120, + CPUHP_AP_ARC_TIMER_STARTING = 121, + CPUHP_AP_RISCV_TIMER_STARTING = 122, + CPUHP_AP_CSKY_TIMER_STARTING = 123, + CPUHP_AP_HYPERV_TIMER_STARTING = 124, + CPUHP_AP_KVM_STARTING = 125, + CPUHP_AP_KVM_ARM_VGIC_INIT_STARTING = 126, + CPUHP_AP_KVM_ARM_VGIC_STARTING = 127, + CPUHP_AP_KVM_ARM_TIMER_STARTING = 128, + CPUHP_AP_DUMMY_TIMER_STARTING = 129, + CPUHP_AP_ARM_XEN_STARTING = 130, + CPUHP_AP_ARM_KVMPV_STARTING = 131, + CPUHP_AP_ARM_CORESIGHT_STARTING = 132, + CPUHP_AP_ARM64_ISNDEP_STARTING = 133, + CPUHP_AP_SMPCFD_DYING = 134, + CPUHP_AP_X86_TBOOT_DYING = 135, + CPUHP_AP_ARM_CACHE_B15_RAC_DYING = 136, + CPUHP_AP_ONLINE = 137, + CPUHP_TEARDOWN_CPU = 138, + CPUHP_AP_ONLINE_IDLE = 139, + CPUHP_AP_SMPBOOT_THREADS = 140, + CPUHP_AP_X86_VDSO_VMA_ONLINE = 141, + CPUHP_AP_IRQ_AFFINITY_ONLINE = 142, + CPUHP_AP_ARM_MVEBU_SYNC_CLOCKS = 143, + CPUHP_AP_X86_INTEL_EPB_ONLINE = 144, + CPUHP_AP_PERF_ONLINE = 145, + CPUHP_AP_PERF_X86_ONLINE = 146, + CPUHP_AP_PERF_X86_UNCORE_ONLINE = 147, + CPUHP_AP_PERF_X86_AMD_UNCORE_ONLINE = 148, + CPUHP_AP_PERF_X86_AMD_POWER_ONLINE = 149, + CPUHP_AP_PERF_X86_RAPL_ONLINE = 150, + CPUHP_AP_PERF_X86_CQM_ONLINE = 151, + CPUHP_AP_PERF_X86_CSTATE_ONLINE = 152, + CPUHP_AP_PERF_S390_CF_ONLINE = 153, + CPUHP_AP_PERF_S390_SF_ONLINE = 154, + CPUHP_AP_PERF_ARM_CCI_ONLINE = 155, + CPUHP_AP_PERF_ARM_CCN_ONLINE = 156, + CPUHP_AP_PERF_ARM_HISI_DDRC_ONLINE = 157, + CPUHP_AP_PERF_ARM_HISI_HHA_ONLINE = 158, + CPUHP_AP_PERF_ARM_HISI_L3_ONLINE = 159, + CPUHP_AP_PERF_ARM_L2X0_ONLINE = 160, + CPUHP_AP_PERF_ARM_QCOM_L2_ONLINE = 161, + CPUHP_AP_PERF_ARM_QCOM_L3_ONLINE = 162, + CPUHP_AP_PERF_ARM_APM_XGENE_ONLINE = 163, + CPUHP_AP_PERF_ARM_CAVIUM_TX2_UNCORE_ONLINE = 164, + CPUHP_AP_PERF_POWERPC_NEST_IMC_ONLINE = 165, + CPUHP_AP_PERF_POWERPC_CORE_IMC_ONLINE = 166, + CPUHP_AP_PERF_POWERPC_THREAD_IMC_ONLINE = 167, + CPUHP_AP_PERF_POWERPC_TRACE_IMC_ONLINE = 168, + CPUHP_AP_WATCHDOG_ONLINE = 169, + CPUHP_AP_WORKQUEUE_ONLINE = 170, + CPUHP_AP_RCUTREE_ONLINE = 171, + CPUHP_AP_BASE_CACHEINFO_ONLINE = 172, + CPUHP_AP_ONLINE_DYN = 173, + CPUHP_AP_ONLINE_DYN_END = 203, + CPUHP_AP_X86_HPET_ONLINE = 204, + CPUHP_AP_X86_KVM_CLK_ONLINE = 205, + CPUHP_AP_ACTIVE = 206, + CPUHP_ONLINE = 207, +}; + +struct perf_regs { + __u64 abi; + struct pt_regs *regs; +}; + +struct kernel_cpustat { + u64 cpustat[10]; +}; + +struct kernel_stat { + long unsigned int irqs_sum; + unsigned int softirqs[10]; +}; + +struct u64_stats_sync {}; + +struct bpf_insn { + __u8 code; + __u8 dst_reg: 4; + __u8 src_reg: 4; + __s16 off; + __s32 imm; +}; + +struct bpf_cgroup_storage_key { + __u64 cgroup_inode_id; + __u32 attach_type; +}; + +enum bpf_map_type { + BPF_MAP_TYPE_UNSPEC = 0, + BPF_MAP_TYPE_HASH = 1, + BPF_MAP_TYPE_ARRAY = 2, + BPF_MAP_TYPE_PROG_ARRAY = 3, + BPF_MAP_TYPE_PERF_EVENT_ARRAY = 4, + BPF_MAP_TYPE_PERCPU_HASH = 5, + BPF_MAP_TYPE_PERCPU_ARRAY = 6, + BPF_MAP_TYPE_STACK_TRACE = 7, + BPF_MAP_TYPE_CGROUP_ARRAY = 8, + BPF_MAP_TYPE_LRU_HASH = 9, + BPF_MAP_TYPE_LRU_PERCPU_HASH = 10, + BPF_MAP_TYPE_LPM_TRIE = 11, + BPF_MAP_TYPE_ARRAY_OF_MAPS = 12, + BPF_MAP_TYPE_HASH_OF_MAPS = 13, + BPF_MAP_TYPE_DEVMAP = 14, + BPF_MAP_TYPE_SOCKMAP = 15, + BPF_MAP_TYPE_CPUMAP = 16, + BPF_MAP_TYPE_XSKMAP = 17, + BPF_MAP_TYPE_SOCKHASH = 18, + BPF_MAP_TYPE_CGROUP_STORAGE = 19, + BPF_MAP_TYPE_REUSEPORT_SOCKARRAY = 20, + BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE = 21, + BPF_MAP_TYPE_QUEUE = 22, + BPF_MAP_TYPE_STACK = 23, + BPF_MAP_TYPE_SK_STORAGE = 24, + BPF_MAP_TYPE_DEVMAP_HASH = 25, +}; + +union bpf_attr { + struct { + __u32 map_type; + __u32 key_size; + __u32 value_size; + __u32 max_entries; + __u32 map_flags; + __u32 inner_map_fd; + __u32 numa_node; + char map_name[16]; + __u32 map_ifindex; + __u32 btf_fd; + __u32 btf_key_type_id; + __u32 btf_value_type_id; + }; + struct { + __u32 map_fd; + __u64 key; + union { + __u64 value; + __u64 next_key; + }; + __u64 flags; + }; + struct { + __u32 prog_type; + __u32 insn_cnt; + __u64 insns; + __u64 license; + __u32 log_level; + __u32 log_size; + __u64 log_buf; + __u32 kern_version; + __u32 prog_flags; + char prog_name[16]; + __u32 prog_ifindex; + __u32 expected_attach_type; + __u32 prog_btf_fd; + __u32 func_info_rec_size; + __u64 func_info; + __u32 func_info_cnt; + __u32 line_info_rec_size; + __u64 line_info; + __u32 line_info_cnt; + __u32 attach_btf_id; + __u32 attach_prog_fd; + }; + struct { + __u64 pathname; + __u32 bpf_fd; + __u32 file_flags; + }; + struct { + __u32 target_fd; + __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; + }; + struct { + __u32 prog_fd; + __u32 retval; + __u32 data_size_in; + __u32 data_size_out; + __u64 data_in; + __u64 data_out; + __u32 repeat; + __u32 duration; + __u32 ctx_size_in; + __u32 ctx_size_out; + __u64 ctx_in; + __u64 ctx_out; + } test; + struct { + union { + __u32 start_id; + __u32 prog_id; + __u32 map_id; + __u32 btf_id; + }; + __u32 next_id; + __u32 open_flags; + }; + struct { + __u32 bpf_fd; + __u32 info_len; + __u64 info; + } info; + struct { + __u32 target_fd; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __u64 prog_ids; + __u32 prog_cnt; + } query; + struct { + __u64 name; + __u32 prog_fd; + } raw_tracepoint; + struct { + __u64 btf; + __u64 btf_log_buf; + __u32 btf_size; + __u32 btf_log_size; + __u32 btf_log_level; + }; + struct { + __u32 pid; + __u32 fd; + __u32 flags; + __u32 buf_len; + __u64 buf; + __u32 prog_id; + __u32 fd_type; + __u64 probe_offset; + __u64 probe_addr; + } task_fd_query; +}; + +enum bpf_func_id { + BPF_FUNC_unspec = 0, + BPF_FUNC_map_lookup_elem = 1, + BPF_FUNC_map_update_elem = 2, + BPF_FUNC_map_delete_elem = 3, + BPF_FUNC_probe_read = 4, + BPF_FUNC_ktime_get_ns = 5, + BPF_FUNC_trace_printk = 6, + BPF_FUNC_get_prandom_u32 = 7, + BPF_FUNC_get_smp_processor_id = 8, + BPF_FUNC_skb_store_bytes = 9, + BPF_FUNC_l3_csum_replace = 10, + BPF_FUNC_l4_csum_replace = 11, + BPF_FUNC_tail_call = 12, + BPF_FUNC_clone_redirect = 13, + BPF_FUNC_get_current_pid_tgid = 14, + BPF_FUNC_get_current_uid_gid = 15, + BPF_FUNC_get_current_comm = 16, + BPF_FUNC_get_cgroup_classid = 17, + BPF_FUNC_skb_vlan_push = 18, + BPF_FUNC_skb_vlan_pop = 19, + BPF_FUNC_skb_get_tunnel_key = 20, + BPF_FUNC_skb_set_tunnel_key = 21, + BPF_FUNC_perf_event_read = 22, + BPF_FUNC_redirect = 23, + BPF_FUNC_get_route_realm = 24, + BPF_FUNC_perf_event_output = 25, + BPF_FUNC_skb_load_bytes = 26, + BPF_FUNC_get_stackid = 27, + BPF_FUNC_csum_diff = 28, + BPF_FUNC_skb_get_tunnel_opt = 29, + BPF_FUNC_skb_set_tunnel_opt = 30, + BPF_FUNC_skb_change_proto = 31, + BPF_FUNC_skb_change_type = 32, + BPF_FUNC_skb_under_cgroup = 33, + BPF_FUNC_get_hash_recalc = 34, + BPF_FUNC_get_current_task = 35, + BPF_FUNC_probe_write_user = 36, + BPF_FUNC_current_task_under_cgroup = 37, + BPF_FUNC_skb_change_tail = 38, + BPF_FUNC_skb_pull_data = 39, + BPF_FUNC_csum_update = 40, + BPF_FUNC_set_hash_invalid = 41, + BPF_FUNC_get_numa_node_id = 42, + BPF_FUNC_skb_change_head = 43, + BPF_FUNC_xdp_adjust_head = 44, + BPF_FUNC_probe_read_str = 45, + BPF_FUNC_get_socket_cookie = 46, + BPF_FUNC_get_socket_uid = 47, + BPF_FUNC_set_hash = 48, + BPF_FUNC_setsockopt = 49, + BPF_FUNC_skb_adjust_room = 50, + BPF_FUNC_redirect_map = 51, + BPF_FUNC_sk_redirect_map = 52, + BPF_FUNC_sock_map_update = 53, + BPF_FUNC_xdp_adjust_meta = 54, + BPF_FUNC_perf_event_read_value = 55, + BPF_FUNC_perf_prog_read_value = 56, + BPF_FUNC_getsockopt = 57, + BPF_FUNC_override_return = 58, + BPF_FUNC_sock_ops_cb_flags_set = 59, + BPF_FUNC_msg_redirect_map = 60, + BPF_FUNC_msg_apply_bytes = 61, + BPF_FUNC_msg_cork_bytes = 62, + BPF_FUNC_msg_pull_data = 63, + BPF_FUNC_bind = 64, + BPF_FUNC_xdp_adjust_tail = 65, + BPF_FUNC_skb_get_xfrm_state = 66, + BPF_FUNC_get_stack = 67, + BPF_FUNC_skb_load_bytes_relative = 68, + BPF_FUNC_fib_lookup = 69, + BPF_FUNC_sock_hash_update = 70, + BPF_FUNC_msg_redirect_hash = 71, + BPF_FUNC_sk_redirect_hash = 72, + BPF_FUNC_lwt_push_encap = 73, + BPF_FUNC_lwt_seg6_store_bytes = 74, + BPF_FUNC_lwt_seg6_adjust_srh = 75, + BPF_FUNC_lwt_seg6_action = 76, + BPF_FUNC_rc_repeat = 77, + BPF_FUNC_rc_keydown = 78, + BPF_FUNC_skb_cgroup_id = 79, + BPF_FUNC_get_current_cgroup_id = 80, + BPF_FUNC_get_local_storage = 81, + BPF_FUNC_sk_select_reuseport = 82, + BPF_FUNC_skb_ancestor_cgroup_id = 83, + BPF_FUNC_sk_lookup_tcp = 84, + BPF_FUNC_sk_lookup_udp = 85, + BPF_FUNC_sk_release = 86, + BPF_FUNC_map_push_elem = 87, + BPF_FUNC_map_pop_elem = 88, + BPF_FUNC_map_peek_elem = 89, + BPF_FUNC_msg_push_data = 90, + BPF_FUNC_msg_pop_data = 91, + BPF_FUNC_rc_pointer_rel = 92, + BPF_FUNC_spin_lock = 93, + BPF_FUNC_spin_unlock = 94, + BPF_FUNC_sk_fullsock = 95, + BPF_FUNC_tcp_sock = 96, + BPF_FUNC_skb_ecn_set_ce = 97, + BPF_FUNC_get_listener_sock = 98, + BPF_FUNC_skc_lookup_tcp = 99, + BPF_FUNC_tcp_check_syncookie = 100, + BPF_FUNC_sysctl_get_name = 101, + BPF_FUNC_sysctl_get_current_value = 102, + BPF_FUNC_sysctl_get_new_value = 103, + BPF_FUNC_sysctl_set_new_value = 104, + BPF_FUNC_strtol = 105, + BPF_FUNC_strtoul = 106, + BPF_FUNC_sk_storage_get = 107, + BPF_FUNC_sk_storage_delete = 108, + BPF_FUNC_send_signal = 109, + BPF_FUNC_tcp_gen_syncookie = 110, + BPF_FUNC_skb_output = 111, + BPF_FUNC_probe_read_user = 112, + BPF_FUNC_probe_read_kernel = 113, + BPF_FUNC_probe_read_user_str = 114, + BPF_FUNC_probe_read_kernel_str = 115, + __BPF_FUNC_MAX_ID = 116, +}; + +struct bpf_func_info { + __u32 insn_off; + __u32 type_id; +}; + +struct bpf_line_info { + __u32 insn_off; + __u32 file_name_off; + __u32 line_off; + __u32 line_col; +}; + +struct bpf_map; + +struct btf; + +struct btf_type; + +struct bpf_prog_aux; + +struct bpf_map_ops { + int (*map_alloc_check)(union bpf_attr *); + struct bpf_map * (*map_alloc)(union bpf_attr *); + void (*map_release)(struct bpf_map *, struct file *); + void (*map_free)(struct bpf_map *); + int (*map_get_next_key)(struct bpf_map *, void *, void *); + void (*map_release_uref)(struct bpf_map *); + void * (*map_lookup_elem_sys_only)(struct bpf_map *, void *); + void * (*map_lookup_elem)(struct bpf_map *, void *); + int (*map_update_elem)(struct bpf_map *, void *, void *, u64); + int (*map_delete_elem)(struct bpf_map *, void *); + int (*map_push_elem)(struct bpf_map *, void *, u64); + int (*map_pop_elem)(struct bpf_map *, void *); + int (*map_peek_elem)(struct bpf_map *, void *); + void * (*map_fd_get_ptr)(struct bpf_map *, struct file *, int); + void (*map_fd_put_ptr)(void *); + u32 (*map_gen_lookup)(struct bpf_map *, struct bpf_insn *); + u32 (*map_fd_sys_lookup_elem)(void *); + void (*map_seq_show_elem)(struct bpf_map *, void *, struct seq_file *); + int (*map_check_btf)(const struct bpf_map *, const struct btf *, const struct btf_type *, const struct btf_type *); + int (*map_poke_track)(struct bpf_map *, struct bpf_prog_aux *); + void (*map_poke_untrack)(struct bpf_map *, struct bpf_prog_aux *); + void (*map_poke_run)(struct bpf_map *, u32, struct bpf_prog *, struct bpf_prog *); + int (*map_direct_value_addr)(const struct bpf_map *, u64 *, u32); + int (*map_direct_value_meta)(const struct bpf_map *, u64, u32 *); + int (*map_mmap)(struct bpf_map *, struct vm_area_struct *); +}; + +struct bpf_map_memory { + u32 pages; + struct user_struct *user; +}; + +struct bpf_map { + const struct bpf_map_ops *ops; + struct bpf_map *inner_map_meta; + void *security; + enum bpf_map_type map_type; + u32 key_size; + u32 value_size; + u32 max_entries; + u32 map_flags; + int spin_lock_off; + u32 id; + int numa_node; + u32 btf_key_type_id; + u32 btf_value_type_id; + struct btf *btf; + struct bpf_map_memory memory; + char name[16]; + bool unpriv_array; + bool frozen; + long: 48; + long: 64; + long: 64; + atomic64_t refcnt; + atomic64_t usercnt; + struct work_struct work; + struct mutex freeze_mutex; + u64 writecnt; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct btf_header { + __u16 magic; + __u8 version; + __u8 flags; + __u32 hdr_len; + __u32 type_off; + __u32 type_len; + __u32 str_off; + __u32 str_len; +}; + +struct btf { + void *data; + struct btf_type **types; + u32 *resolved_ids; + u32 *resolved_sizes; + const char *strings; + void *nohdr_data; + struct btf_header hdr; + u32 nr_types; + u32 types_size; + u32 data_size; + refcount_t refcnt; + u32 id; + struct callback_head rcu; +}; + +struct btf_type { + __u32 name_off; + __u32 info; + union { + __u32 size; + __u32 type; + }; +}; + +enum bpf_tramp_prog_type { + BPF_TRAMP_FENTRY = 0, + BPF_TRAMP_FEXIT = 1, + BPF_TRAMP_MAX = 2, +}; + +struct bpf_trampoline; + +struct bpf_jit_poke_descriptor; + +struct bpf_prog_ops; + +struct bpf_prog_offload; + +struct bpf_func_info_aux; + +struct bpf_prog_stats; + +struct bpf_prog_aux { + atomic64_t refcnt; + u32 used_map_cnt; + u32 max_ctx_offset; + u32 max_pkt_offset; + u32 max_tp_access; + u32 stack_depth; + u32 id; + u32 func_cnt; + u32 func_idx; + u32 attach_btf_id; + struct bpf_prog *linked_prog; + bool verifier_zext; + bool offload_requested; + bool attach_btf_trace; + bool func_proto_unreliable; + enum bpf_tramp_prog_type trampoline_prog_type; + struct bpf_trampoline *trampoline; + struct hlist_node tramp_hlist; + const struct btf_type *attach_func_proto; + const char *attach_func_name; + struct bpf_prog **func; + void *jit_data; + struct bpf_jit_poke_descriptor *poke_tab; + u32 size_poke_tab; + struct latch_tree_node ksym_tnode; + struct list_head ksym_lnode; + const struct bpf_prog_ops *ops; + struct bpf_map **used_maps; + struct bpf_prog *prog; + struct user_struct *user; + u64 load_time; + struct bpf_map *cgroup_storage[2]; + char name[16]; + void *security; + struct bpf_prog_offload *offload; + struct btf *btf; + struct bpf_func_info *func_info; + struct bpf_func_info_aux *func_info_aux; + struct bpf_line_info *linfo; + void **jited_linfo; + u32 func_info_cnt; + u32 nr_linfo; + u32 linfo_idx; + u32 num_exentries; + struct exception_table_entry *extable; + struct bpf_prog_stats *stats; + union { + struct work_struct work; + struct callback_head rcu; + }; +}; + +enum bpf_prog_type { + BPF_PROG_TYPE_UNSPEC = 0, + BPF_PROG_TYPE_SOCKET_FILTER = 1, + BPF_PROG_TYPE_KPROBE = 2, + BPF_PROG_TYPE_SCHED_CLS = 3, + BPF_PROG_TYPE_SCHED_ACT = 4, + BPF_PROG_TYPE_TRACEPOINT = 5, + BPF_PROG_TYPE_XDP = 6, + BPF_PROG_TYPE_PERF_EVENT = 7, + BPF_PROG_TYPE_CGROUP_SKB = 8, + BPF_PROG_TYPE_CGROUP_SOCK = 9, + BPF_PROG_TYPE_LWT_IN = 10, + BPF_PROG_TYPE_LWT_OUT = 11, + BPF_PROG_TYPE_LWT_XMIT = 12, + BPF_PROG_TYPE_SOCK_OPS = 13, + BPF_PROG_TYPE_SK_SKB = 14, + BPF_PROG_TYPE_CGROUP_DEVICE = 15, + BPF_PROG_TYPE_SK_MSG = 16, + BPF_PROG_TYPE_RAW_TRACEPOINT = 17, + BPF_PROG_TYPE_CGROUP_SOCK_ADDR = 18, + BPF_PROG_TYPE_LWT_SEG6LOCAL = 19, + BPF_PROG_TYPE_LIRC_MODE2 = 20, + BPF_PROG_TYPE_SK_REUSEPORT = 21, + BPF_PROG_TYPE_FLOW_DISSECTOR = 22, + BPF_PROG_TYPE_CGROUP_SYSCTL = 23, + BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE = 24, + BPF_PROG_TYPE_CGROUP_SOCKOPT = 25, + BPF_PROG_TYPE_TRACING = 26, +}; + +enum bpf_attach_type { + BPF_CGROUP_INET_INGRESS = 0, + BPF_CGROUP_INET_EGRESS = 1, + BPF_CGROUP_INET_SOCK_CREATE = 2, + BPF_CGROUP_SOCK_OPS = 3, + BPF_SK_SKB_STREAM_PARSER = 4, + BPF_SK_SKB_STREAM_VERDICT = 5, + BPF_CGROUP_DEVICE = 6, + BPF_SK_MSG_VERDICT = 7, + BPF_CGROUP_INET4_BIND = 8, + BPF_CGROUP_INET6_BIND = 9, + BPF_CGROUP_INET4_CONNECT = 10, + BPF_CGROUP_INET6_CONNECT = 11, + BPF_CGROUP_INET4_POST_BIND = 12, + BPF_CGROUP_INET6_POST_BIND = 13, + BPF_CGROUP_UDP4_SENDMSG = 14, + BPF_CGROUP_UDP6_SENDMSG = 15, + BPF_LIRC_MODE2 = 16, + BPF_FLOW_DISSECTOR = 17, + BPF_CGROUP_SYSCTL = 18, + BPF_CGROUP_UDP4_RECVMSG = 19, + BPF_CGROUP_UDP6_RECVMSG = 20, + BPF_CGROUP_GETSOCKOPT = 21, + BPF_CGROUP_SETSOCKOPT = 22, + BPF_TRACE_RAW_TP = 23, + BPF_TRACE_FENTRY = 24, + BPF_TRACE_FEXIT = 25, + __MAX_BPF_ATTACH_TYPE = 26, +}; + +struct sock_filter { + __u16 code; + __u8 jt; + __u8 jf; + __u32 k; +}; + +struct sock_fprog_kern; + +struct bpf_prog { + u16 pages; + u16 jited: 1; + u16 jit_requested: 1; + u16 gpl_compatible: 1; + u16 cb_access: 1; + u16 dst_needed: 1; + u16 blinded: 1; + u16 is_func: 1; + u16 kprobe_override: 1; + u16 has_callchain_buf: 1; + u16 enforce_expected_attach_type: 1; + enum bpf_prog_type type; + enum bpf_attach_type expected_attach_type; + u32 len; + u32 jited_len; + u8 tag[8]; + struct bpf_prog_aux *aux; + struct sock_fprog_kern *orig_prog; + unsigned int (*bpf_func)(const void *, const struct bpf_insn *); + union { + struct sock_filter insns[0]; + struct bpf_insn insnsi[0]; + }; +}; + +enum bpf_arg_type { + ARG_DONTCARE = 0, + ARG_CONST_MAP_PTR = 1, + ARG_PTR_TO_MAP_KEY = 2, + ARG_PTR_TO_MAP_VALUE = 3, + ARG_PTR_TO_UNINIT_MAP_VALUE = 4, + ARG_PTR_TO_MAP_VALUE_OR_NULL = 5, + ARG_PTR_TO_MEM = 6, + ARG_PTR_TO_MEM_OR_NULL = 7, + ARG_PTR_TO_UNINIT_MEM = 8, + ARG_CONST_SIZE = 9, + ARG_CONST_SIZE_OR_ZERO = 10, + ARG_PTR_TO_CTX = 11, + ARG_ANYTHING = 12, + ARG_PTR_TO_SPIN_LOCK = 13, + ARG_PTR_TO_SOCK_COMMON = 14, + ARG_PTR_TO_INT = 15, + ARG_PTR_TO_LONG = 16, + ARG_PTR_TO_SOCKET = 17, + ARG_PTR_TO_BTF_ID = 18, +}; + +enum bpf_return_type { + RET_INTEGER = 0, + RET_VOID = 1, + RET_PTR_TO_MAP_VALUE = 2, + RET_PTR_TO_MAP_VALUE_OR_NULL = 3, + RET_PTR_TO_SOCKET_OR_NULL = 4, + RET_PTR_TO_TCP_SOCK_OR_NULL = 5, + RET_PTR_TO_SOCK_COMMON_OR_NULL = 6, +}; + +struct bpf_func_proto { + u64 (*func)(u64, u64, u64, u64, u64); + bool gpl_only; + bool pkt_access; + enum bpf_return_type ret_type; + union { + struct { + enum bpf_arg_type arg1_type; + enum bpf_arg_type arg2_type; + enum bpf_arg_type arg3_type; + enum bpf_arg_type arg4_type; + enum bpf_arg_type arg5_type; + }; + enum bpf_arg_type arg_type[5]; + }; + int *btf_id; +}; + +enum bpf_access_type { + BPF_READ = 1, + BPF_WRITE = 2, +}; + +enum bpf_reg_type { + NOT_INIT = 0, + SCALAR_VALUE = 1, + PTR_TO_CTX = 2, + CONST_PTR_TO_MAP = 3, + PTR_TO_MAP_VALUE = 4, + PTR_TO_MAP_VALUE_OR_NULL = 5, + PTR_TO_STACK = 6, + PTR_TO_PACKET_META = 7, + PTR_TO_PACKET = 8, + PTR_TO_PACKET_END = 9, + PTR_TO_FLOW_KEYS = 10, + PTR_TO_SOCKET = 11, + PTR_TO_SOCKET_OR_NULL = 12, + PTR_TO_SOCK_COMMON = 13, + PTR_TO_SOCK_COMMON_OR_NULL = 14, + PTR_TO_TCP_SOCK = 15, + PTR_TO_TCP_SOCK_OR_NULL = 16, + PTR_TO_TP_BUFFER = 17, + PTR_TO_XDP_SOCK = 18, + PTR_TO_BTF_ID = 19, +}; + +struct bpf_verifier_log; + +struct bpf_insn_access_aux { + enum bpf_reg_type reg_type; + union { + int ctx_field_size; + u32 btf_id; + }; + struct bpf_verifier_log *log; +}; + +struct bpf_prog_ops { + int (*test_run)(struct bpf_prog *, const union bpf_attr *, union bpf_attr *); +}; + +struct bpf_verifier_ops { + const struct bpf_func_proto * (*get_func_proto)(enum bpf_func_id, const struct bpf_prog *); + bool (*is_valid_access)(int, int, enum bpf_access_type, const struct bpf_prog *, struct bpf_insn_access_aux *); + int (*gen_prologue)(struct bpf_insn *, bool, const struct bpf_prog *); + int (*gen_ld_abs)(const struct bpf_insn *, struct bpf_insn *); + u32 (*convert_ctx_access)(enum bpf_access_type, const struct bpf_insn *, struct bpf_insn *, struct bpf_prog *, u32 *); +}; + +struct net_device; + +struct bpf_offload_dev; + +struct bpf_prog_offload { + struct bpf_prog *prog; + struct net_device *netdev; + struct bpf_offload_dev *offdev; + void *dev_priv; + struct list_head offloads; + bool dev_state; + bool opt_failed; + void *jited_image; + u32 jited_len; +}; + +struct bpf_prog_stats { + u64 cnt; + u64 nsecs; + struct u64_stats_sync syncp; +}; + +struct btf_func_model { + u8 ret_size; + u8 nr_args; + u8 arg_size[12]; +}; + +struct bpf_trampoline { + struct hlist_node hlist; + struct mutex mutex; + refcount_t refcnt; + u64 key; + struct { + struct btf_func_model model; + void *addr; + bool ftrace_managed; + } func; + struct hlist_head progs_hlist[2]; + int progs_cnt[2]; + void *image; + u64 selector; +}; + +struct bpf_func_info_aux { + bool unreliable; +}; + +struct bpf_jit_poke_descriptor { + void *ip; + union { + struct { + struct bpf_map *map; + u32 key; + } tail_call; + }; + bool ip_stable; + u8 adj_off; + u16 reason; +}; + +struct bpf_cgroup_storage; + +struct bpf_prog_array_item { + struct bpf_prog *prog; + struct bpf_cgroup_storage *cgroup_storage[2]; +}; + +struct bpf_storage_buffer; + +struct bpf_cgroup_storage_map; + +struct bpf_cgroup_storage { + union { + struct bpf_storage_buffer *buf; + void *percpu_buf; + }; + struct bpf_cgroup_storage_map *map; + struct bpf_cgroup_storage_key key; + struct list_head list; + struct rb_node node; + struct callback_head rcu; +}; + +struct bpf_prog_array { + struct callback_head rcu; + struct bpf_prog_array_item items[0]; +}; + +struct bpf_storage_buffer { + struct callback_head rcu; + char data[0]; +}; + +struct cgroup_bpf { + struct bpf_prog_array *effective[26]; + struct list_head progs[26]; + u32 flags[26]; + struct bpf_prog_array *inactive; + struct percpu_ref refcnt; + struct work_struct release_work; +}; + +struct psi_group {}; + +struct cgroup_file { + struct kernfs_node *kn; + long unsigned int notified_at; + struct timer_list notify_timer; +}; + +struct cgroup_subsys; + +struct cgroup_subsys_state { + struct cgroup *cgroup; + struct cgroup_subsys *ss; + struct percpu_ref refcnt; + struct list_head sibling; + struct list_head children; + struct list_head rstat_css_node; + int id; + unsigned int flags; + u64 serial_nr; + atomic_t online_cnt; + struct work_struct destroy_work; + struct rcu_work destroy_rwork; + struct cgroup_subsys_state *parent; +}; + +struct cgroup_base_stat { + struct task_cputime cputime; +}; + +struct cgroup_freezer_state { + bool freeze; + int e_freeze; + int nr_frozen_descendants; + int nr_frozen_tasks; +}; + +struct cgroup_root; + +struct cgroup_rstat_cpu; + +struct cgroup { + struct cgroup_subsys_state self; + long unsigned int flags; + int level; + int max_depth; + int nr_descendants; + int nr_dying_descendants; + int max_descendants; + int nr_populated_csets; + int nr_populated_domain_children; + int nr_populated_threaded_children; + int nr_threaded_children; + struct kernfs_node *kn; + struct cgroup_file procs_file; + struct cgroup_file events_file; + u16 subtree_control; + u16 subtree_ss_mask; + u16 old_subtree_control; + u16 old_subtree_ss_mask; + struct cgroup_subsys_state *subsys[4]; + struct cgroup_root *root; + struct list_head cset_links; + struct list_head e_csets[4]; + struct cgroup *dom_cgrp; + struct cgroup *old_dom_cgrp; + struct cgroup_rstat_cpu *rstat_cpu; + struct list_head rstat_css_list; + struct cgroup_base_stat last_bstat; + struct cgroup_base_stat bstat; + struct prev_cputime prev_cputime; + struct list_head pidlists; + struct mutex pidlist_mutex; + wait_queue_head_t offline_waitq; + struct work_struct release_agent_work; + struct psi_group psi; + struct cgroup_bpf bpf; + atomic_t congestion_count; + struct cgroup_freezer_state freezer; + u64 ancestor_ids[0]; +}; + +struct cgroup_taskset; + +struct cftype; + +struct cgroup_subsys { + struct cgroup_subsys_state * (*css_alloc)(struct cgroup_subsys_state *); + int (*css_online)(struct cgroup_subsys_state *); + void (*css_offline)(struct cgroup_subsys_state *); + void (*css_released)(struct cgroup_subsys_state *); + void (*css_free)(struct cgroup_subsys_state *); + void (*css_reset)(struct cgroup_subsys_state *); + void (*css_rstat_flush)(struct cgroup_subsys_state *, int); + int (*css_extra_stat_show)(struct seq_file *, struct cgroup_subsys_state *); + int (*can_attach)(struct cgroup_taskset *); + void (*cancel_attach)(struct cgroup_taskset *); + void (*attach)(struct cgroup_taskset *); + void (*post_attach)(); + int (*can_fork)(struct task_struct *); + void (*cancel_fork)(struct task_struct *); + void (*fork)(struct task_struct *); + void (*exit)(struct task_struct *); + void (*release)(struct task_struct *); + void (*bind)(struct cgroup_subsys_state *); + bool early_init: 1; + bool implicit_on_dfl: 1; + bool threaded: 1; + bool broken_hierarchy: 1; + bool warned_broken_hierarchy: 1; + int id; + const char *name; + const char *legacy_name; + struct cgroup_root *root; + struct idr css_idr; + struct list_head cfts; + struct cftype *dfl_cftypes; + struct cftype *legacy_cftypes; + unsigned int depends_on; }; -enum writeback_sync_modes { - WB_SYNC_NONE = 0, - WB_SYNC_ALL = 1, +struct cgroup_rstat_cpu { + struct u64_stats_sync bsync; + struct cgroup_base_stat bstat; + struct cgroup_base_stat last_bstat; + struct cgroup *updated_children; + struct cgroup *updated_next; }; -struct writeback_control { - long int nr_to_write; - long int pages_skipped; - loff_t range_start; - loff_t range_end; - enum writeback_sync_modes sync_mode; - unsigned int for_kupdate: 1; - unsigned int for_background: 1; - unsigned int tagged_writepages: 1; - unsigned int for_reclaim: 1; - unsigned int range_cyclic: 1; - unsigned int for_sync: 1; - unsigned int no_cgroup_owner: 1; - unsigned int punt_to_cgroup: 1; +struct cgroup_root { + struct kernfs_root *kf_root; + unsigned int subsys_mask; + int hierarchy_id; + struct cgroup cgrp; + u64 cgrp_ancestor_id_storage; + atomic_t nr_cgrps; + struct list_head root_list; + unsigned int flags; + char release_agent_path[4096]; + char name[64]; }; -struct swap_cluster_info { - spinlock_t lock; - unsigned int data: 24; - unsigned int flags: 8; +struct cftype { + char name[64]; + long unsigned int private; + size_t max_write_len; + unsigned int flags; + unsigned int file_offset; + struct cgroup_subsys *ss; + struct list_head node; + struct kernfs_ops *kf_ops; + int (*open)(struct kernfs_open_file *); + void (*release)(struct kernfs_open_file *); + u64 (*read_u64)(struct cgroup_subsys_state *, struct cftype *); + s64 (*read_s64)(struct cgroup_subsys_state *, struct cftype *); + int (*seq_show)(struct seq_file *, void *); + void * (*seq_start)(struct seq_file *, loff_t *); + void * (*seq_next)(struct seq_file *, void *, loff_t *); + void (*seq_stop)(struct seq_file *, void *); + int (*write_u64)(struct cgroup_subsys_state *, struct cftype *, u64); + int (*write_s64)(struct cgroup_subsys_state *, struct cftype *, s64); + ssize_t (*write)(struct kernfs_open_file *, char *, size_t, loff_t); + __poll_t (*poll)(struct kernfs_open_file *, struct poll_table_struct *); }; -struct swap_cluster_list { - struct swap_cluster_info head; - struct swap_cluster_info tail; +struct perf_callchain_entry { + __u64 nr; + __u64 ip[0]; }; -struct percpu_cluster; +typedef long unsigned int (*perf_copy_f)(void *, const void *, long unsigned int, long unsigned int); -struct swap_info_struct { - long unsigned int flags; - short int prio; - struct plist_node list; - signed char type; - unsigned int max; - unsigned char *swap_map; - struct swap_cluster_info *cluster_info; - struct swap_cluster_list free_clusters; - unsigned int lowest_bit; - unsigned int highest_bit; - unsigned int pages; - unsigned int inuse_pages; - unsigned int cluster_next; - unsigned int cluster_nr; - struct percpu_cluster *percpu_cluster; - struct rb_root swap_extent_root; - struct block_device *bdev; - struct file *swap_file; - unsigned int old_block_size; - spinlock_t lock; - spinlock_t cont_lock; - struct work_struct discard_work; - struct swap_cluster_list discard_clusters; - struct plist_node avail_lists[0]; +struct perf_raw_frag { + union { + struct perf_raw_frag *next; + long unsigned int pad; + }; + perf_copy_f copy; + void *data; + u32 size; +} __attribute__((packed)); + +struct perf_raw_record { + struct perf_raw_frag frag; + u32 size; }; -struct partition_meta_info; +struct perf_branch_stack { + __u64 nr; + struct perf_branch_entry entries[0]; +}; -struct disk_stats; +struct perf_cpu_context { + struct perf_event_context ctx; + struct perf_event_context *task_ctx; + int active_oncpu; + int exclusive; + raw_spinlock_t hrtimer_lock; + struct hrtimer hrtimer; + ktime_t hrtimer_interval; + unsigned int hrtimer_active; + struct list_head sched_cb_entry; + int sched_cb_usage; + int online; +}; -struct hd_struct { - sector_t start_sect; - sector_t nr_sects; - seqcount_t nr_sects_seq; - sector_t alignment_offset; - unsigned int discard_alignment; - struct device __dev; - struct kobject *holder_dir; - int policy; - int partno; - struct partition_meta_info *info; - long unsigned int stamp; - struct disk_stats *dkstats; - struct percpu_ref ref; - struct rcu_work rcu_work; +struct perf_output_handle { + struct perf_event *event; + struct ring_buffer *rb; + long unsigned int wakeup; + long unsigned int size; + u64 aux_flags; + union { + void *addr; + long unsigned int head; + }; + int page; }; -struct disk_part_tbl; +struct perf_addr_filter_range { + long unsigned int start; + long unsigned int size; +}; -struct block_device_operations; +struct perf_sample_data { + u64 addr; + struct perf_raw_record *raw; + struct perf_branch_stack *br_stack; + u64 period; + u64 weight; + u64 txn; + union perf_mem_data_src data_src; + u64 type; + u64 ip; + struct { + u32 pid; + u32 tid; + } tid_entry; + u64 time; + u64 id; + u64 stream_id; + struct { + u32 cpu; + u32 reserved; + } cpu_entry; + struct perf_callchain_entry *callchain; + u64 aux_size; + struct perf_regs regs_user; + struct pt_regs regs_user_copy; + struct perf_regs regs_intr; + u64 stack_user_size; + u64 phys_addr; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; -struct timer_rand_state; +struct trace_entry { + short unsigned int type; + unsigned char flags; + unsigned char preempt_count; + int pid; +}; -struct disk_events; +struct trace_array; -struct badblocks; +struct tracer; -struct gendisk { - int major; - int first_minor; - int minors; - char disk_name[32]; - char * (*devnode)(struct gendisk *, umode_t *); - short unsigned int events; - short unsigned int event_flags; - struct disk_part_tbl *part_tbl; - struct hd_struct part0; - const struct block_device_operations *fops; - struct request_queue *queue; - void *private_data; - int flags; - struct rw_semaphore lookup_sem; - struct kobject *slave_dir; - struct timer_rand_state *random; - atomic_t sync_io; - struct disk_events *ev; - int node_id; - struct badblocks *bb; - struct lockdep_map lockdep_map; +struct trace_buffer; + +struct ring_buffer_iter; + +struct trace_iterator { + struct trace_array *tr; + struct tracer *trace; + struct trace_buffer *trace_buffer; + void *private; + int cpu_file; + struct mutex mutex; + struct ring_buffer_iter **buffer_iter; + long unsigned int iter_flags; + struct trace_seq tmp_seq; + cpumask_var_t started; + bool snapshot; + struct trace_seq seq; + struct trace_entry *ent; + long unsigned int lost_events; + int leftover; + int ent_size; + int cpu; + u64 ts; + loff_t pos; + long int idx; }; -struct cdev { - struct kobject kobj; - struct module *owner; - const struct file_operations *ops; +enum print_line_t { + TRACE_TYPE_PARTIAL_LINE = 0, + TRACE_TYPE_HANDLED = 1, + TRACE_TYPE_UNHANDLED = 2, + TRACE_TYPE_NO_CONSUME = 3, +}; + +typedef enum print_line_t (*trace_print_func)(struct trace_iterator *, int, struct trace_event *); + +struct trace_event_functions { + trace_print_func trace; + trace_print_func raw; + trace_print_func hex; + trace_print_func binary; +}; + +enum trace_reg { + TRACE_REG_REGISTER = 0, + TRACE_REG_UNREGISTER = 1, + TRACE_REG_PERF_REGISTER = 2, + TRACE_REG_PERF_UNREGISTER = 3, + TRACE_REG_PERF_OPEN = 4, + TRACE_REG_PERF_CLOSE = 5, + TRACE_REG_PERF_ADD = 6, + TRACE_REG_PERF_DEL = 7, +}; + +struct trace_event_class { + const char *system; + void *probe; + void *perf_probe; + int (*reg)(struct trace_event_call *, enum trace_reg, void *); + int (*define_fields)(struct trace_event_call *); + struct list_head * (*get_fields)(struct trace_event_call *); + struct list_head fields; + int (*raw_init)(struct trace_event_call *); +}; + +struct trace_event_file; + +struct trace_event_buffer { + struct ring_buffer *buffer; + struct ring_buffer_event *event; + struct trace_event_file *trace_file; + void *entry; + long unsigned int flags; + int pc; +}; + +struct trace_subsystem_dir; + +struct trace_event_file { struct list_head list; - dev_t dev; - unsigned int count; + struct trace_event_call *event_call; + struct event_filter *filter; + struct dentry *dir; + struct trace_array *tr; + struct trace_subsystem_dir *system; + struct list_head triggers; + long unsigned int flags; + atomic_t sm_ref; + atomic_t tm_ref; }; -struct audit_names; +enum { + TRACE_EVENT_FL_FILTERED_BIT = 0, + TRACE_EVENT_FL_CAP_ANY_BIT = 1, + TRACE_EVENT_FL_NO_SET_FILTER_BIT = 2, + TRACE_EVENT_FL_IGNORE_ENABLE_BIT = 3, + TRACE_EVENT_FL_TRACEPOINT_BIT = 4, + TRACE_EVENT_FL_KPROBE_BIT = 5, + TRACE_EVENT_FL_UPROBE_BIT = 6, +}; -struct filename { - const char *name; - const char *uptr; - int refcnt; - struct audit_names *aname; - char iname[0]; +enum { + TRACE_EVENT_FL_FILTERED = 1, + TRACE_EVENT_FL_CAP_ANY = 2, + TRACE_EVENT_FL_NO_SET_FILTER = 4, + TRACE_EVENT_FL_IGNORE_ENABLE = 8, + TRACE_EVENT_FL_TRACEPOINT = 16, + TRACE_EVENT_FL_KPROBE = 32, + TRACE_EVENT_FL_UPROBE = 64, }; -typedef u8 blk_status_t; +enum { + EVENT_FILE_FL_ENABLED_BIT = 0, + EVENT_FILE_FL_RECORDED_CMD_BIT = 1, + EVENT_FILE_FL_RECORDED_TGID_BIT = 2, + EVENT_FILE_FL_FILTERED_BIT = 3, + EVENT_FILE_FL_NO_SET_FILTER_BIT = 4, + EVENT_FILE_FL_SOFT_MODE_BIT = 5, + EVENT_FILE_FL_SOFT_DISABLED_BIT = 6, + EVENT_FILE_FL_TRIGGER_MODE_BIT = 7, + EVENT_FILE_FL_TRIGGER_COND_BIT = 8, + EVENT_FILE_FL_PID_FILTER_BIT = 9, + EVENT_FILE_FL_WAS_ENABLED_BIT = 10, +}; -struct bvec_iter { - sector_t bi_sector; - unsigned int bi_size; - unsigned int bi_idx; - unsigned int bi_bvec_done; +enum { + EVENT_FILE_FL_ENABLED = 1, + EVENT_FILE_FL_RECORDED_CMD = 2, + EVENT_FILE_FL_RECORDED_TGID = 4, + EVENT_FILE_FL_FILTERED = 8, + EVENT_FILE_FL_NO_SET_FILTER = 16, + EVENT_FILE_FL_SOFT_MODE = 32, + EVENT_FILE_FL_SOFT_DISABLED = 64, + EVENT_FILE_FL_TRIGGER_MODE = 128, + EVENT_FILE_FL_TRIGGER_COND = 256, + EVENT_FILE_FL_PID_FILTER = 512, + EVENT_FILE_FL_WAS_ENABLED = 1024, }; -typedef void bio_end_io_t(struct bio *); +enum { + FILTER_OTHER = 0, + FILTER_STATIC_STRING = 1, + FILTER_DYN_STRING = 2, + FILTER_PTR_STRING = 3, + FILTER_TRACE_FN = 4, + FILTER_COMM = 5, + FILTER_CPU = 6, +}; -struct bio_vec { - struct page *bv_page; - unsigned int bv_len; - unsigned int bv_offset; +struct property { + char *name; + int length; + void *value; + struct property *next; }; -struct bio { - struct bio *bi_next; - struct gendisk *bi_disk; - unsigned int bi_opf; - short unsigned int bi_flags; - short unsigned int bi_ioprio; - short unsigned int bi_write_hint; - blk_status_t bi_status; - u8 bi_partno; - atomic_t __bi_remaining; - struct bvec_iter bi_iter; - bio_end_io_t *bi_end_io; - void *bi_private; - union { }; - short unsigned int bi_vcnt; - short unsigned int bi_max_vecs; - atomic_t __bi_cnt; - struct bio_vec *bi_io_vec; - struct bio_set *bi_pool; - struct bio_vec bi_inline_vecs[0]; +struct irq_fwspec { + struct fwnode_handle *fwnode; + int param_count; + u32 param[16]; }; -struct linux_binprm { - struct vm_area_struct *vma; - long unsigned int vma_pages; - struct mm_struct *mm; - long unsigned int p; - long unsigned int argmin; - unsigned int called_set_creds: 1; - unsigned int cap_elevated: 1; - unsigned int secureexec: 1; - unsigned int recursion_depth; - struct file *file; - struct cred *cred; - int unsafe; - unsigned int per_clear; - int argc; - int envc; - const char *filename; - const char *interp; - unsigned int interp_flags; - unsigned int interp_data; - long unsigned int loader; - long unsigned int exec; - struct rlimit rlim_stack; - char buf[256]; +struct irq_data; + +struct irq_domain_ops { + int (*match)(struct irq_domain *, struct device_node *, enum irq_domain_bus_token); + int (*select)(struct irq_domain *, struct irq_fwspec *, enum irq_domain_bus_token); + int (*map)(struct irq_domain *, unsigned int, irq_hw_number_t); + void (*unmap)(struct irq_domain *, unsigned int); + int (*xlate)(struct irq_domain *, struct device_node *, const u32 *, unsigned int, long unsigned int *, unsigned int *); + int (*alloc)(struct irq_domain *, unsigned int, unsigned int, void *); + void (*free)(struct irq_domain *, unsigned int, unsigned int); + int (*activate)(struct irq_domain *, struct irq_data *, bool); + void (*deactivate)(struct irq_domain *, struct irq_data *); + int (*translate)(struct irq_domain *, struct irq_fwspec *, long unsigned int *, unsigned int *); +}; + +struct acpi_table_header { + char signature[4]; + u32 length; + u8 revision; + u8 checksum; + char oem_id[6]; + char oem_table_id[8]; + u32 oem_revision; + char asl_compiler_id[4]; + u32 asl_compiler_revision; }; -struct coredump_params { - const kernel_siginfo_t *siginfo; - struct pt_regs *regs; - struct file *file; - long unsigned int limit; - long unsigned int mm_flags; - loff_t written; - loff_t pos; +struct acpi_generic_address { + u8 space_id; + u8 bit_width; + u8 bit_offset; + u8 access_width; + u64 address; +} __attribute__((packed)); + +struct acpi_table_fadt { + struct acpi_table_header header; + u32 facs; + u32 dsdt; + u8 model; + u8 preferred_profile; + u16 sci_interrupt; + u32 smi_command; + u8 acpi_enable; + u8 acpi_disable; + u8 s4_bios_request; + u8 pstate_control; + u32 pm1a_event_block; + u32 pm1b_event_block; + u32 pm1a_control_block; + u32 pm1b_control_block; + u32 pm2_control_block; + u32 pm_timer_block; + u32 gpe0_block; + u32 gpe1_block; + u8 pm1_event_length; + u8 pm1_control_length; + u8 pm2_control_length; + u8 pm_timer_length; + u8 gpe0_block_length; + u8 gpe1_block_length; + u8 gpe1_base; + u8 cst_control; + u16 c2_latency; + u16 c3_latency; + u16 flush_size; + u16 flush_stride; + u8 duty_offset; + u8 duty_width; + u8 day_alarm; + u8 month_alarm; + u8 century; + u16 boot_flags; + u8 reserved; + u32 flags; + struct acpi_generic_address reset_register; + u8 reset_value; + u16 arm_boot_flags; + u8 minor_revision; + u64 Xfacs; + u64 Xdsdt; + struct acpi_generic_address xpm1a_event_block; + struct acpi_generic_address xpm1b_event_block; + struct acpi_generic_address xpm1a_control_block; + struct acpi_generic_address xpm1b_control_block; + struct acpi_generic_address xpm2_control_block; + struct acpi_generic_address xpm_timer_block; + struct acpi_generic_address xgpe0_block; + struct acpi_generic_address xgpe1_block; + struct acpi_generic_address sleep_control; + struct acpi_generic_address sleep_status; + u64 hypervisor_id; +} __attribute__((packed)); + +enum acpi_irq_model_id { + ACPI_IRQ_MODEL_PIC = 0, + ACPI_IRQ_MODEL_IOAPIC = 1, + ACPI_IRQ_MODEL_IOSAPIC = 2, + ACPI_IRQ_MODEL_PLATFORM = 3, + ACPI_IRQ_MODEL_GIC = 4, + ACPI_IRQ_MODEL_COUNT = 5, }; -struct key_tag { - struct callback_head rcu; - refcount_t usage; - bool removed; +enum con_scroll { + SM_UP = 0, + SM_DOWN = 1, }; -typedef int (*key_restrict_link_func_t)(struct key *, const struct key_type *, const union key_payload *, struct key *); - -typedef int (*request_key_actor_t)(struct key *, void *); - -struct key_preparsed_payload; - -struct key_match_data; - -struct kernel_pkey_params; +struct vc_data; -struct kernel_pkey_query; +struct console_font; -struct key_type { - const char *name; - size_t def_datalen; - unsigned int flags; - int (*vet_description)(const char *); - int (*preparse)(struct key_preparsed_payload *); - void (*free_preparse)(struct key_preparsed_payload *); - int (*instantiate)(struct key *, struct key_preparsed_payload *); - int (*update)(struct key *, struct key_preparsed_payload *); - int (*match_preparse)(struct key_match_data *); - void (*match_free)(struct key_match_data *); - void (*revoke)(struct key *); - void (*destroy)(struct key *); - void (*describe)(const struct key *, struct seq_file *); - long int (*read)(const struct key *, char *, size_t); - request_key_actor_t request_key; - struct key_restriction * (*lookup_restriction)(const char *); - int (*asym_query)(const struct kernel_pkey_params *, struct kernel_pkey_query *); - int (*asym_eds_op)(struct kernel_pkey_params *, const void *, void *); - int (*asym_verify_signature)(struct kernel_pkey_params *, const void *, const void *); - struct list_head link; - struct lock_class_key lock_class; +struct consw { + struct module *owner; + const char * (*con_startup)(); + void (*con_init)(struct vc_data *, int); + void (*con_deinit)(struct vc_data *); + void (*con_clear)(struct vc_data *, int, int, int, int); + void (*con_putc)(struct vc_data *, int, int, int); + void (*con_putcs)(struct vc_data *, const short unsigned int *, int, int, int); + void (*con_cursor)(struct vc_data *, int); + bool (*con_scroll)(struct vc_data *, unsigned int, unsigned int, enum con_scroll, unsigned int); + int (*con_switch)(struct vc_data *); + int (*con_blank)(struct vc_data *, int, int); + int (*con_font_set)(struct vc_data *, struct console_font *, unsigned int); + int (*con_font_get)(struct vc_data *, struct console_font *); + int (*con_font_default)(struct vc_data *, struct console_font *, char *); + int (*con_font_copy)(struct vc_data *, int); + int (*con_resize)(struct vc_data *, unsigned int, unsigned int, unsigned int); + void (*con_set_palette)(struct vc_data *, const unsigned char *); + void (*con_scrolldelta)(struct vc_data *, int); + int (*con_set_origin)(struct vc_data *); + void (*con_save_screen)(struct vc_data *); + u8 (*con_build_attr)(struct vc_data *, u8, u8, u8, u8, u8, u8); + void (*con_invert_region)(struct vc_data *, u16 *, int); + u16 * (*con_screen_pos)(struct vc_data *, int); + long unsigned int (*con_getxy)(struct vc_data *, long unsigned int, int *, int *); + void (*con_flush_scrollback)(struct vc_data *); + int (*con_debug_enter)(struct vc_data *); + int (*con_debug_leave)(struct vc_data *); }; -struct key_restriction { - key_restrict_link_func_t check; - struct key *key; - struct key_type *keytype; -}; +struct tty_driver; -struct group_info { - atomic_t usage; - int ngroups; - kgid_t gid[0]; +struct console { + char name[16]; + void (*write)(struct console *, const char *, unsigned int); + int (*read)(struct console *, char *, unsigned int); + struct tty_driver * (*device)(struct console *, int *); + void (*unblank)(); + int (*setup)(struct console *, char *); + int (*match)(struct console *, char *, int, char *); + short int flags; + short int index; + int cflag; + void *data; + struct console *next; }; -struct seq_operations { - void * (*start)(struct seq_file *, loff_t *); - void (*stop)(struct seq_file *, void *); - void * (*next)(struct seq_file *, void *, loff_t *); - int (*show)(struct seq_file *, void *); +struct fprop_global { + struct percpu_counter events; + unsigned int period; + seqcount_t sequence; }; -struct ring_buffer_event { - u32 type_len: 5; - u32 time_delta: 27; - u32 array[0]; +enum wb_stat_item { + WB_RECLAIMABLE = 0, + WB_WRITEBACK = 1, + WB_DIRTIED = 2, + WB_WRITTEN = 3, + NR_WB_STAT_ITEMS = 4, }; -struct seq_buf { - char *buffer; - size_t size; - size_t len; - loff_t readpos; +struct bdi_writeback_congested { + long unsigned int state; + refcount_t refcnt; }; -struct trace_seq { - unsigned char buffer[4096]; - struct seq_buf seq; - int full; +enum stat_group { + STAT_READ = 0, + STAT_WRITE = 1, + STAT_DISCARD = 2, + STAT_FLUSH = 3, + NR_STAT_GROUPS = 4, }; -enum perf_sw_ids { - PERF_COUNT_SW_CPU_CLOCK = 0, - PERF_COUNT_SW_TASK_CLOCK = 1, - PERF_COUNT_SW_PAGE_FAULTS = 2, - PERF_COUNT_SW_CONTEXT_SWITCHES = 3, - PERF_COUNT_SW_CPU_MIGRATIONS = 4, - PERF_COUNT_SW_PAGE_FAULTS_MIN = 5, - PERF_COUNT_SW_PAGE_FAULTS_MAJ = 6, - PERF_COUNT_SW_ALIGNMENT_FAULTS = 7, - PERF_COUNT_SW_EMULATION_FAULTS = 8, - PERF_COUNT_SW_DUMMY = 9, - PERF_COUNT_SW_BPF_OUTPUT = 10, - PERF_COUNT_SW_MAX = 11, +struct disk_stats { + u64 nsecs[4]; + long unsigned int sectors[4]; + long unsigned int ios[4]; + long unsigned int merges[4]; + long unsigned int io_ticks; + long unsigned int time_in_queue; + local_t in_flight[2]; }; -union perf_mem_data_src { - __u64 val; - struct { - __u64 mem_op: 5; - __u64 mem_lvl: 14; - __u64 mem_snoop: 5; - __u64 mem_lock: 2; - __u64 mem_dtlb: 7; - __u64 mem_lvl_num: 4; - __u64 mem_remote: 1; - __u64 mem_snoopx: 2; - __u64 mem_rsvd: 24; - }; +struct partition_meta_info { + char uuid[37]; + u8 volname[64]; }; -struct perf_branch_entry { - __u64 from; - __u64 to; - __u64 mispred: 1; - __u64 predicted: 1; - __u64 in_tx: 1; - __u64 abort: 1; - __u64 cycles: 16; - __u64 type: 4; - __u64 reserved: 40; +struct disk_part_tbl { + struct callback_head callback_head; + int len; + struct hd_struct *last_lookup; + struct hd_struct *part[0]; }; -struct taskstats { - __u16 version; - __u32 ac_exitcode; - __u8 ac_flag; - __u8 ac_nice; - __u64 cpu_count; - __u64 cpu_delay_total; - __u64 blkio_count; - __u64 blkio_delay_total; - __u64 swapin_count; - __u64 swapin_delay_total; - __u64 cpu_run_real_total; - __u64 cpu_run_virtual_total; - char ac_comm[32]; - __u8 ac_sched; - __u8 ac_pad[3]; - int: 32; - __u32 ac_uid; - __u32 ac_gid; - __u32 ac_pid; - __u32 ac_ppid; - __u32 ac_btime; - __u64 ac_etime; - __u64 ac_utime; - __u64 ac_stime; - __u64 ac_minflt; - __u64 ac_majflt; - __u64 coremem; - __u64 virtmem; - __u64 hiwater_rss; - __u64 hiwater_vm; - __u64 read_char; - __u64 write_char; - __u64 read_syscalls; - __u64 write_syscalls; - __u64 read_bytes; - __u64 write_bytes; - __u64 cancelled_write_bytes; - __u64 nvcsw; - __u64 nivcsw; - __u64 ac_utimescaled; - __u64 ac_stimescaled; - __u64 cpu_scaled_run_real_total; - __u64 freepages_count; - __u64 freepages_delay_total; - __u64 thrashing_count; - __u64 thrashing_delay_total; -}; +struct blk_zone; -struct new_utsname { - char sysname[65]; - char nodename[65]; - char release[65]; - char version[65]; - char machine[65]; - char domainname[65]; -}; +typedef int (*report_zones_cb)(struct blk_zone *, unsigned int, void *); -struct uts_namespace { - struct kref kref; - struct new_utsname name; - struct user_namespace *user_ns; - struct ucounts *ucounts; - struct ns_common ns; -}; +struct hd_geometry; -struct cgroup_namespace { - refcount_t count; - struct ns_common ns; - struct user_namespace *user_ns; - struct ucounts *ucounts; - struct css_set *root_cset; -}; +struct pr_ops; -struct proc_ns_operations { - const char *name; - const char *real_ns_name; - int type; - struct ns_common * (*get)(struct task_struct *); - void (*put)(struct ns_common *); - int (*install)(struct nsproxy *, struct ns_common *); - struct user_namespace * (*owner)(struct ns_common *); - struct ns_common * (*get_parent)(struct ns_common *); +struct block_device_operations { + int (*open)(struct block_device *, fmode_t); + void (*release)(struct gendisk *, fmode_t); + int (*rw_page)(struct block_device *, sector_t, struct page *, unsigned int); + int (*ioctl)(struct block_device *, fmode_t, unsigned int, long unsigned int); + int (*compat_ioctl)(struct block_device *, fmode_t, unsigned int, long unsigned int); + unsigned int (*check_events)(struct gendisk *, unsigned int); + int (*media_changed)(struct gendisk *); + void (*unlock_native_capacity)(struct gendisk *); + int (*revalidate_disk)(struct gendisk *); + int (*getgeo)(struct block_device *, struct hd_geometry *); + void (*swap_slot_free_notify)(struct block_device *, long unsigned int); + int (*report_zones)(struct gendisk *, sector_t, unsigned int, report_zones_cb, void *); + struct module *owner; + const struct pr_ops *pr_ops; }; -struct ucounts { - struct hlist_node node; - struct user_namespace *ns; - kuid_t uid; - int count; - atomic_t ucount[9]; +struct sg_io_v4 { + __s32 guard; + __u32 protocol; + __u32 subprotocol; + __u32 request_len; + __u64 request; + __u64 request_tag; + __u32 request_attr; + __u32 request_priority; + __u32 request_extra; + __u32 max_response_len; + __u64 response; + __u32 dout_iovec_count; + __u32 dout_xfer_len; + __u32 din_iovec_count; + __u32 din_xfer_len; + __u64 dout_xferp; + __u64 din_xferp; + __u32 timeout; + __u32 flags; + __u64 usr_ptr; + __u32 spare_in; + __u32 driver_status; + __u32 transport_status; + __u32 device_status; + __u32 retry_delay; + __u32 info; + __u32 duration; + __u32 response_len; + __s32 din_resid; + __s32 dout_resid; + __u64 generated_tag; + __u32 spare_out; + __u32 padding; }; -struct dev_pm_ops { - int (*prepare)(struct device *); - void (*complete)(struct device *); - int (*suspend)(struct device *); - int (*resume)(struct device *); - int (*freeze)(struct device *); - int (*thaw)(struct device *); - int (*poweroff)(struct device *); - int (*restore)(struct device *); - int (*suspend_late)(struct device *); - int (*resume_early)(struct device *); - int (*freeze_late)(struct device *); - int (*thaw_early)(struct device *); - int (*poweroff_late)(struct device *); - int (*restore_early)(struct device *); - int (*suspend_noirq)(struct device *); - int (*resume_noirq)(struct device *); - int (*freeze_noirq)(struct device *); - int (*thaw_noirq)(struct device *); - int (*poweroff_noirq)(struct device *); - int (*restore_noirq)(struct device *); - int (*runtime_suspend)(struct device *); - int (*runtime_resume)(struct device *); - int (*runtime_idle)(struct device *); +struct bsg_ops { + int (*check_proto)(struct sg_io_v4 *); + int (*fill_hdr)(struct request *, struct sg_io_v4 *, fmode_t); + int (*complete_rq)(struct request *, struct sg_io_v4 *); + void (*free_rq)(struct request *); }; -struct pm_subsys_data { - spinlock_t lock; - unsigned int refcount; - struct list_head clock_list; -}; +typedef __u32 req_flags_t; -struct wakeup_source { - const char *name; - int id; - struct list_head entry; - spinlock_t lock; - struct wake_irq *wakeirq; - struct timer_list timer; - long unsigned int timer_expires; - ktime_t total_time; - ktime_t max_time; - ktime_t last_time; - ktime_t start_prevent_time; - ktime_t prevent_sleep_time; - long unsigned int event_count; - long unsigned int active_count; - long unsigned int relax_count; - long unsigned int expire_count; - long unsigned int wakeup_count; - struct device *dev; - bool active: 1; - bool autosleep_enabled: 1; -}; +typedef void rq_end_io_fn(struct request *, blk_status_t); -struct dev_pm_domain { - struct dev_pm_ops ops; - int (*start)(struct device *); - void (*detach)(struct device *, bool); - int (*activate)(struct device *); - void (*sync)(struct device *); - void (*dismiss)(struct device *); +enum mq_rq_state { + MQ_RQ_IDLE = 0, + MQ_RQ_IN_FLIGHT = 1, + MQ_RQ_COMPLETE = 2, }; -struct iommu_ops; - -struct subsys_private; - -struct bus_type { - const char *name; - const char *dev_name; - struct device *dev_root; - const struct attribute_group **bus_groups; - const struct attribute_group **dev_groups; - const struct attribute_group **drv_groups; - int (*match)(struct device *, struct device_driver *); - int (*uevent)(struct device *, struct kobj_uevent_env *); - int (*probe)(struct device *); - void (*sync_state)(struct device *); - int (*remove)(struct device *); - void (*shutdown)(struct device *); - int (*online)(struct device *); - int (*offline)(struct device *); - int (*suspend)(struct device *, pm_message_t); - int (*resume)(struct device *); - int (*num_vf)(struct device *); - int (*dma_configure)(struct device *); - const struct dev_pm_ops *pm; - const struct iommu_ops *iommu_ops; - struct subsys_private *p; - struct lock_class_key lock_key; - bool need_parent_lock; +struct request { + struct request_queue *q; + struct blk_mq_ctx *mq_ctx; + struct blk_mq_hw_ctx *mq_hctx; + unsigned int cmd_flags; + req_flags_t rq_flags; + int tag; + int internal_tag; + unsigned int __data_len; + sector_t __sector; + struct bio *bio; + struct bio *biotail; + struct list_head queuelist; + union { + struct hlist_node hash; + struct list_head ipi_list; + }; + union { + struct rb_node rb_node; + struct bio_vec special_vec; + void *completion_data; + int error_count; + }; + union { + struct { + struct io_cq *icq; + void *priv[2]; + } elv; + struct { + unsigned int seq; + struct list_head list; + rq_end_io_fn *saved_end_io; + } flush; + }; + struct gendisk *rq_disk; + struct hd_struct *part; + u64 start_time_ns; + u64 io_start_time_ns; + short unsigned int stats_sectors; + short unsigned int nr_phys_segments; + short unsigned int write_hint; + short unsigned int ioprio; + unsigned int extra_len; + enum mq_rq_state state; + refcount_t ref; + unsigned int timeout; + long unsigned int deadline; + union { + struct __call_single_data csd; + u64 fifo_time; + }; + rq_end_io_fn *end_io; + void *end_io_data; }; -enum probe_type { - PROBE_DEFAULT_STRATEGY = 0, - PROBE_PREFER_ASYNCHRONOUS = 1, - PROBE_FORCE_SYNCHRONOUS = 2, +struct blk_zone { + __u64 start; + __u64 len; + __u64 wp; + __u8 type; + __u8 cond; + __u8 non_seq; + __u8 reset; + __u8 reserved[36]; }; -struct of_device_id; +enum elv_merge { + ELEVATOR_NO_MERGE = 0, + ELEVATOR_FRONT_MERGE = 1, + ELEVATOR_BACK_MERGE = 2, + ELEVATOR_DISCARD_MERGE = 3, +}; -struct acpi_device_id; +struct elevator_type; -struct driver_private; +struct blk_mq_alloc_data; -struct device_driver { - const char *name; - struct bus_type *bus; - struct module *owner; - const char *mod_name; - bool suppress_bind_attrs; - enum probe_type probe_type; - const struct of_device_id *of_match_table; - const struct acpi_device_id *acpi_match_table; - int (*probe)(struct device *); - void (*sync_state)(struct device *); - int (*remove)(struct device *); - void (*shutdown)(struct device *); - int (*suspend)(struct device *, pm_message_t); - int (*resume)(struct device *); - const struct attribute_group **groups; - const struct attribute_group **dev_groups; - const struct dev_pm_ops *pm; - void (*coredump)(struct device *); - struct driver_private *p; +struct elevator_mq_ops { + int (*init_sched)(struct request_queue *, struct elevator_type *); + void (*exit_sched)(struct elevator_queue *); + int (*init_hctx)(struct blk_mq_hw_ctx *, unsigned int); + void (*exit_hctx)(struct blk_mq_hw_ctx *, unsigned int); + void (*depth_updated)(struct blk_mq_hw_ctx *); + bool (*allow_merge)(struct request_queue *, struct request *, struct bio *); + bool (*bio_merge)(struct blk_mq_hw_ctx *, struct bio *, unsigned int); + int (*request_merge)(struct request_queue *, struct request **, struct bio *); + void (*request_merged)(struct request_queue *, struct request *, enum elv_merge); + void (*requests_merged)(struct request_queue *, struct request *, struct request *); + void (*limit_depth)(unsigned int, struct blk_mq_alloc_data *); + void (*prepare_request)(struct request *, struct bio *); + void (*finish_request)(struct request *); + void (*insert_requests)(struct blk_mq_hw_ctx *, struct list_head *, bool); + struct request * (*dispatch_request)(struct blk_mq_hw_ctx *); + bool (*has_work)(struct blk_mq_hw_ctx *); + void (*completed_request)(struct request *, u64); + void (*requeue_request)(struct request *); + struct request * (*former_request)(struct request_queue *, struct request *); + struct request * (*next_request)(struct request_queue *, struct request *); + void (*init_icq)(struct io_cq *); + void (*exit_icq)(struct io_cq *); }; -enum iommu_cap { - IOMMU_CAP_CACHE_COHERENCY = 0, - IOMMU_CAP_INTR_REMAP = 1, - IOMMU_CAP_NOEXEC = 2, -}; +struct elv_fs_entry; -enum iommu_attr { - DOMAIN_ATTR_GEOMETRY = 0, - DOMAIN_ATTR_PAGING = 1, - DOMAIN_ATTR_WINDOWS = 2, - DOMAIN_ATTR_FSL_PAMU_STASH = 3, - DOMAIN_ATTR_FSL_PAMU_ENABLE = 4, - DOMAIN_ATTR_FSL_PAMUV1 = 5, - DOMAIN_ATTR_NESTING = 6, - DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE = 7, - DOMAIN_ATTR_MAX = 8, -}; +struct blk_mq_debugfs_attr; -enum iommu_dev_features { - IOMMU_DEV_FEAT_AUX = 0, - IOMMU_DEV_FEAT_SVA = 1, +struct elevator_type { + struct kmem_cache *icq_cache; + struct elevator_mq_ops ops; + size_t icq_size; + size_t icq_align; + struct elv_fs_entry *elevator_attrs; + const char *elevator_name; + const char *elevator_alias; + const unsigned int elevator_features; + struct module *elevator_owner; + const struct blk_mq_debugfs_attr *queue_debugfs_attrs; + const struct blk_mq_debugfs_attr *hctx_debugfs_attrs; + char icq_cache_name[22]; + struct list_head list; }; -struct iommu_domain; - -struct iommu_iotlb_gather; +struct elevator_queue { + struct elevator_type *type; + void *elevator_data; + struct kobject kobj; + struct mutex sysfs_lock; + unsigned int registered: 1; + struct hlist_head hash[64]; +}; -struct iommu_resv_region; +struct elv_fs_entry { + struct attribute attr; + ssize_t (*show)(struct elevator_queue *, char *); + ssize_t (*store)(struct elevator_queue *, const char *, size_t); +}; -struct of_phandle_args; +struct blk_mq_debugfs_attr { + const char *name; + umode_t mode; + int (*show)(void *, struct seq_file *); + ssize_t (*write)(void *, const char *, size_t, loff_t *); + const struct seq_operations___2 *seq_ops; +}; -struct iommu_sva; +struct blk_mq_queue_data; -struct iommu_fault_event; +typedef blk_status_t queue_rq_fn(struct blk_mq_hw_ctx *, const struct blk_mq_queue_data *); -struct iommu_page_response; +typedef void commit_rqs_fn(struct blk_mq_hw_ctx *); -struct iommu_cache_invalidate_info; +typedef bool get_budget_fn(struct blk_mq_hw_ctx *); -struct iommu_gpasid_bind_data; +typedef void put_budget_fn(struct blk_mq_hw_ctx *); -struct iommu_ops { - bool (*capable)(enum iommu_cap); - struct iommu_domain * (*domain_alloc)(unsigned int); - void (*domain_free)(struct iommu_domain *); - int (*attach_dev)(struct iommu_domain *, struct device *); - void (*detach_dev)(struct iommu_domain *, struct device *); - int (*map)(struct iommu_domain *, long unsigned int, phys_addr_t, size_t, int, gfp_t); - size_t (*unmap)(struct iommu_domain *, long unsigned int, size_t, struct iommu_iotlb_gather *); - void (*flush_iotlb_all)(struct iommu_domain *); - void (*iotlb_sync_map)(struct iommu_domain *); - void (*iotlb_sync)(struct iommu_domain *, struct iommu_iotlb_gather *); - phys_addr_t (*iova_to_phys)(struct iommu_domain *, dma_addr_t); - int (*add_device)(struct device *); - void (*remove_device)(struct device *); - struct iommu_group * (*device_group)(struct device *); - int (*domain_get_attr)(struct iommu_domain *, enum iommu_attr, void *); - int (*domain_set_attr)(struct iommu_domain *, enum iommu_attr, void *); - void (*get_resv_regions)(struct device *, struct list_head *); - void (*put_resv_regions)(struct device *, struct list_head *); - void (*apply_resv_region)(struct device *, struct iommu_domain *, struct iommu_resv_region *); - int (*domain_window_enable)(struct iommu_domain *, u32, phys_addr_t, u64, int); - void (*domain_window_disable)(struct iommu_domain *, u32); - int (*of_xlate)(struct device *, struct of_phandle_args *); - bool (*is_attach_deferred)(struct iommu_domain *, struct device *); - bool (*dev_has_feat)(struct device *, enum iommu_dev_features); - bool (*dev_feat_enabled)(struct device *, enum iommu_dev_features); - int (*dev_enable_feat)(struct device *, enum iommu_dev_features); - int (*dev_disable_feat)(struct device *, enum iommu_dev_features); - int (*aux_attach_dev)(struct iommu_domain *, struct device *); - void (*aux_detach_dev)(struct iommu_domain *, struct device *); - int (*aux_get_pasid)(struct iommu_domain *, struct device *); - struct iommu_sva * (*sva_bind)(struct device *, struct mm_struct *, void *); - void (*sva_unbind)(struct iommu_sva *); - int (*sva_get_pasid)(struct iommu_sva *); - int (*page_response)(struct device *, struct iommu_fault_event *, struct iommu_page_response *); - int (*cache_invalidate)(struct iommu_domain *, struct device *, struct iommu_cache_invalidate_info *); - int (*sva_bind_gpasid)(struct iommu_domain *, struct device *, struct iommu_gpasid_bind_data *); - int (*sva_unbind_gpasid)(struct device *, int); - long unsigned int pgsize_bitmap; +enum blk_eh_timer_return { + BLK_EH_DONE = 0, + BLK_EH_RESET_TIMER = 1, }; -struct device_type { - const char *name; - const struct attribute_group **groups; - int (*uevent)(struct device *, struct kobj_uevent_env *); - char * (*devnode)(struct device *, umode_t *, kuid_t *, kgid_t *); - void (*release)(struct device *); - const struct dev_pm_ops *pm; -}; +typedef enum blk_eh_timer_return timeout_fn(struct request *, bool); -struct of_device_id { - char name[32]; - char type[32]; - char compatible[128]; - const void *data; -}; +typedef int poll_fn(struct blk_mq_hw_ctx *); -typedef long unsigned int kernel_ulong_t; +typedef void complete_fn(struct request *); -struct acpi_device_id { - __u8 id[9]; - kernel_ulong_t driver_data; - __u32 cls; - __u32 cls_msk; -}; +typedef int init_hctx_fn(struct blk_mq_hw_ctx *, void *, unsigned int); -struct class { - const char *name; - struct module *owner; - const struct attribute_group **class_groups; - const struct attribute_group **dev_groups; - struct kobject *dev_kobj; - int (*dev_uevent)(struct device *, struct kobj_uevent_env *); - char * (*devnode)(struct device *, umode_t *); - void (*class_release)(struct class *); - void (*dev_release)(struct device *); - int (*shutdown_pre)(struct device *); - const struct kobj_ns_type_operations *ns_type; - const void * (*namespace)(struct device *); - void (*get_ownership)(struct device *, kuid_t *, kgid_t *); - const struct dev_pm_ops *pm; - struct subsys_private *p; -}; +typedef void exit_hctx_fn(struct blk_mq_hw_ctx *, unsigned int); -struct device_dma_parameters { - unsigned int max_segment_size; - long unsigned int segment_boundary_mask; -}; +typedef int init_request_fn(struct blk_mq_tag_set *, struct request *, unsigned int, unsigned int); -enum irq_domain_bus_token { - DOMAIN_BUS_ANY = 0, - DOMAIN_BUS_WIRED = 1, - DOMAIN_BUS_GENERIC_MSI = 2, - DOMAIN_BUS_PCI_MSI = 3, - DOMAIN_BUS_PLATFORM_MSI = 4, - DOMAIN_BUS_NEXUS = 5, - DOMAIN_BUS_IPI = 6, - DOMAIN_BUS_FSL_MC_MSI = 7, - DOMAIN_BUS_TI_SCI_INTA_MSI = 8, - DOMAIN_BUS_WAKEUP = 9, -}; +typedef void exit_request_fn(struct blk_mq_tag_set *, struct request *, unsigned int); -struct irq_domain_ops; +typedef void cleanup_rq_fn(struct request *); -struct irq_domain_chip_generic; +typedef bool busy_fn(struct request_queue *); -struct irq_domain { - struct list_head link; - const char *name; - const struct irq_domain_ops *ops; - void *host_data; - unsigned int flags; - unsigned int mapcount; - struct fwnode_handle *fwnode; - enum irq_domain_bus_token bus_token; - struct irq_domain_chip_generic *gc; - struct irq_domain *parent; - irq_hw_number_t hwirq_max; - unsigned int revmap_direct_max_irq; - unsigned int revmap_size; - struct xarray revmap_tree; - struct mutex revmap_tree_mutex; - unsigned int linear_revmap[0]; -}; +typedef int map_queues_fn(struct blk_mq_tag_set *); -enum dma_data_direction { - DMA_BIDIRECTIONAL = 0, - DMA_TO_DEVICE = 1, - DMA_FROM_DEVICE = 2, - DMA_NONE = 3, +struct blk_mq_ops { + queue_rq_fn *queue_rq; + commit_rqs_fn *commit_rqs; + get_budget_fn *get_budget; + put_budget_fn *put_budget; + timeout_fn *timeout; + poll_fn *poll; + complete_fn *complete; + init_hctx_fn *init_hctx; + exit_hctx_fn *exit_hctx; + init_request_fn *init_request; + exit_request_fn *exit_request; + void (*initialize_rq_fn)(struct request *); + cleanup_rq_fn *cleanup_rq; + busy_fn *busy; + map_queues_fn *map_queues; + void (*show_rq)(struct seq_file *, struct request *); }; -struct sg_table; - -struct scatterlist; - -struct dma_map_ops { - void * (*alloc)(struct device *, size_t, dma_addr_t *, gfp_t, long unsigned int); - void (*free)(struct device *, size_t, void *, dma_addr_t, long unsigned int); - int (*mmap)(struct device *, struct vm_area_struct *, void *, dma_addr_t, size_t, long unsigned int); - int (*get_sgtable)(struct device *, struct sg_table *, void *, dma_addr_t, size_t, long unsigned int); - dma_addr_t (*map_page)(struct device *, struct page *, long unsigned int, size_t, enum dma_data_direction, long unsigned int); - void (*unmap_page)(struct device *, dma_addr_t, size_t, enum dma_data_direction, long unsigned int); - int (*map_sg)(struct device *, struct scatterlist *, int, enum dma_data_direction, long unsigned int); - void (*unmap_sg)(struct device *, struct scatterlist *, int, enum dma_data_direction, long unsigned int); - dma_addr_t (*map_resource)(struct device *, phys_addr_t, size_t, enum dma_data_direction, long unsigned int); - void (*unmap_resource)(struct device *, dma_addr_t, size_t, enum dma_data_direction, long unsigned int); - void (*sync_single_for_cpu)(struct device *, dma_addr_t, size_t, enum dma_data_direction); - void (*sync_single_for_device)(struct device *, dma_addr_t, size_t, enum dma_data_direction); - void (*sync_sg_for_cpu)(struct device *, struct scatterlist *, int, enum dma_data_direction); - void (*sync_sg_for_device)(struct device *, struct scatterlist *, int, enum dma_data_direction); - void (*cache_sync)(struct device *, void *, size_t, enum dma_data_direction); - int (*dma_supported)(struct device *, u64); - u64 (*get_required_mask)(struct device *); - size_t (*max_mapping_size)(struct device *); - long unsigned int (*get_merge_boundary)(struct device *); +enum pr_type { + PR_WRITE_EXCLUSIVE = 1, + PR_EXCLUSIVE_ACCESS = 2, + PR_WRITE_EXCLUSIVE_REG_ONLY = 3, + PR_EXCLUSIVE_ACCESS_REG_ONLY = 4, + PR_WRITE_EXCLUSIVE_ALL_REGS = 5, + PR_EXCLUSIVE_ACCESS_ALL_REGS = 6, }; -typedef u32 phandle; - -struct property; - -struct device_node { - const char *name; - phandle phandle; - const char *full_name; - struct fwnode_handle fwnode; - struct property *properties; - struct property *deadprops; - struct device_node *parent; - struct device_node *child; - struct device_node *sibling; - long unsigned int _flags; - void *data; +struct pr_ops { + int (*pr_register)(struct block_device *, u64, u64, u32); + int (*pr_reserve)(struct block_device *, u64, enum pr_type, u32); + int (*pr_release)(struct block_device *, u64, enum pr_type); + int (*pr_preempt)(struct block_device *, u64, u64, enum pr_type, bool); + int (*pr_clear)(struct block_device *, u64); }; -enum cpuhp_state { - CPUHP_INVALID = 4294967295, - CPUHP_OFFLINE = 0, - CPUHP_CREATE_THREADS = 1, - CPUHP_PERF_PREPARE = 2, - CPUHP_PERF_X86_PREPARE = 3, - CPUHP_PERF_X86_AMD_UNCORE_PREP = 4, - CPUHP_PERF_POWER = 5, - CPUHP_PERF_SUPERH = 6, - CPUHP_X86_HPET_DEAD = 7, - CPUHP_X86_APB_DEAD = 8, - CPUHP_X86_MCE_DEAD = 9, - CPUHP_VIRT_NET_DEAD = 10, - CPUHP_SLUB_DEAD = 11, - CPUHP_MM_WRITEBACK_DEAD = 12, - CPUHP_MM_VMSTAT_DEAD = 13, - CPUHP_SOFTIRQ_DEAD = 14, - CPUHP_NET_MVNETA_DEAD = 15, - CPUHP_CPUIDLE_DEAD = 16, - CPUHP_ARM64_FPSIMD_DEAD = 17, - CPUHP_ARM_OMAP_WAKE_DEAD = 18, - CPUHP_IRQ_POLL_DEAD = 19, - CPUHP_BLOCK_SOFTIRQ_DEAD = 20, - CPUHP_ACPI_CPUDRV_DEAD = 21, - CPUHP_S390_PFAULT_DEAD = 22, - CPUHP_BLK_MQ_DEAD = 23, - CPUHP_FS_BUFF_DEAD = 24, - CPUHP_PRINTK_DEAD = 25, - CPUHP_MM_MEMCQ_DEAD = 26, - CPUHP_PERCPU_CNT_DEAD = 27, - CPUHP_RADIX_DEAD = 28, - CPUHP_PAGE_ALLOC_DEAD = 29, - CPUHP_NET_DEV_DEAD = 30, - CPUHP_PCI_XGENE_DEAD = 31, - CPUHP_IOMMU_INTEL_DEAD = 32, - CPUHP_LUSTRE_CFS_DEAD = 33, - CPUHP_AP_ARM_CACHE_B15_RAC_DEAD = 34, - CPUHP_WORKQUEUE_PREP = 35, - CPUHP_POWER_NUMA_PREPARE = 36, - CPUHP_HRTIMERS_PREPARE = 37, - CPUHP_PROFILE_PREPARE = 38, - CPUHP_X2APIC_PREPARE = 39, - CPUHP_SMPCFD_PREPARE = 40, - CPUHP_RELAY_PREPARE = 41, - CPUHP_SLAB_PREPARE = 42, - CPUHP_MD_RAID5_PREPARE = 43, - CPUHP_RCUTREE_PREP = 44, - CPUHP_CPUIDLE_COUPLED_PREPARE = 45, - CPUHP_POWERPC_PMAC_PREPARE = 46, - CPUHP_POWERPC_MMU_CTX_PREPARE = 47, - CPUHP_XEN_PREPARE = 48, - CPUHP_XEN_EVTCHN_PREPARE = 49, - CPUHP_ARM_SHMOBILE_SCU_PREPARE = 50, - CPUHP_SH_SH3X_PREPARE = 51, - CPUHP_NET_FLOW_PREPARE = 52, - CPUHP_TOPOLOGY_PREPARE = 53, - CPUHP_NET_IUCV_PREPARE = 54, - CPUHP_ARM_BL_PREPARE = 55, - CPUHP_TRACE_RB_PREPARE = 56, - CPUHP_MM_ZS_PREPARE = 57, - CPUHP_MM_ZSWP_MEM_PREPARE = 58, - CPUHP_MM_ZSWP_POOL_PREPARE = 59, - CPUHP_KVM_PPC_BOOK3S_PREPARE = 60, - CPUHP_ZCOMP_PREPARE = 61, - CPUHP_TIMERS_PREPARE = 62, - CPUHP_MIPS_SOC_PREPARE = 63, - CPUHP_BP_PREPARE_DYN = 64, - CPUHP_BP_PREPARE_DYN_END = 84, - CPUHP_BRINGUP_CPU = 85, - CPUHP_AP_IDLE_DEAD = 86, - CPUHP_AP_OFFLINE = 87, - CPUHP_AP_SCHED_STARTING = 88, - CPUHP_AP_RCUTREE_DYING = 89, - CPUHP_AP_IRQ_GIC_STARTING = 90, - CPUHP_AP_IRQ_HIP04_STARTING = 91, - CPUHP_AP_IRQ_ARMADA_XP_STARTING = 92, - CPUHP_AP_IRQ_BCM2836_STARTING = 93, - CPUHP_AP_IRQ_MIPS_GIC_STARTING = 94, - CPUHP_AP_ARM_MVEBU_COHERENCY = 95, - CPUHP_AP_MICROCODE_LOADER = 96, - CPUHP_AP_PERF_X86_AMD_UNCORE_STARTING = 97, - CPUHP_AP_PERF_X86_STARTING = 98, - CPUHP_AP_PERF_X86_AMD_IBS_STARTING = 99, - CPUHP_AP_PERF_X86_CQM_STARTING = 100, - CPUHP_AP_PERF_X86_CSTATE_STARTING = 101, - CPUHP_AP_PERF_XTENSA_STARTING = 102, - CPUHP_AP_MIPS_OP_LOONGSON3_STARTING = 103, - CPUHP_AP_ARM_SDEI_STARTING = 104, - CPUHP_AP_ARM_VFP_STARTING = 105, - CPUHP_AP_ARM64_DEBUG_MONITORS_STARTING = 106, - CPUHP_AP_PERF_ARM_HW_BREAKPOINT_STARTING = 107, - CPUHP_AP_PERF_ARM_ACPI_STARTING = 108, - CPUHP_AP_PERF_ARM_STARTING = 109, - CPUHP_AP_ARM_L2X0_STARTING = 110, - CPUHP_AP_EXYNOS4_MCT_TIMER_STARTING = 111, - CPUHP_AP_ARM_ARCH_TIMER_STARTING = 112, - CPUHP_AP_ARM_GLOBAL_TIMER_STARTING = 113, - CPUHP_AP_JCORE_TIMER_STARTING = 114, - CPUHP_AP_ARM_TWD_STARTING = 115, - CPUHP_AP_QCOM_TIMER_STARTING = 116, - CPUHP_AP_TEGRA_TIMER_STARTING = 117, - CPUHP_AP_ARMADA_TIMER_STARTING = 118, - CPUHP_AP_MARCO_TIMER_STARTING = 119, - CPUHP_AP_MIPS_GIC_TIMER_STARTING = 120, - CPUHP_AP_ARC_TIMER_STARTING = 121, - CPUHP_AP_RISCV_TIMER_STARTING = 122, - CPUHP_AP_CSKY_TIMER_STARTING = 123, - CPUHP_AP_HYPERV_TIMER_STARTING = 124, - CPUHP_AP_KVM_STARTING = 125, - CPUHP_AP_KVM_ARM_VGIC_INIT_STARTING = 126, - CPUHP_AP_KVM_ARM_VGIC_STARTING = 127, - CPUHP_AP_KVM_ARM_TIMER_STARTING = 128, - CPUHP_AP_DUMMY_TIMER_STARTING = 129, - CPUHP_AP_ARM_XEN_STARTING = 130, - CPUHP_AP_ARM_KVMPV_STARTING = 131, - CPUHP_AP_ARM_CORESIGHT_STARTING = 132, - CPUHP_AP_ARM64_ISNDEP_STARTING = 133, - CPUHP_AP_SMPCFD_DYING = 134, - CPUHP_AP_X86_TBOOT_DYING = 135, - CPUHP_AP_ARM_CACHE_B15_RAC_DYING = 136, - CPUHP_AP_ONLINE = 137, - CPUHP_TEARDOWN_CPU = 138, - CPUHP_AP_ONLINE_IDLE = 139, - CPUHP_AP_SMPBOOT_THREADS = 140, - CPUHP_AP_X86_VDSO_VMA_ONLINE = 141, - CPUHP_AP_IRQ_AFFINITY_ONLINE = 142, - CPUHP_AP_ARM_MVEBU_SYNC_CLOCKS = 143, - CPUHP_AP_X86_INTEL_EPB_ONLINE = 144, - CPUHP_AP_PERF_ONLINE = 145, - CPUHP_AP_PERF_X86_ONLINE = 146, - CPUHP_AP_PERF_X86_UNCORE_ONLINE = 147, - CPUHP_AP_PERF_X86_AMD_UNCORE_ONLINE = 148, - CPUHP_AP_PERF_X86_AMD_POWER_ONLINE = 149, - CPUHP_AP_PERF_X86_RAPL_ONLINE = 150, - CPUHP_AP_PERF_X86_CQM_ONLINE = 151, - CPUHP_AP_PERF_X86_CSTATE_ONLINE = 152, - CPUHP_AP_PERF_S390_CF_ONLINE = 153, - CPUHP_AP_PERF_S390_SF_ONLINE = 154, - CPUHP_AP_PERF_ARM_CCI_ONLINE = 155, - CPUHP_AP_PERF_ARM_CCN_ONLINE = 156, - CPUHP_AP_PERF_ARM_HISI_DDRC_ONLINE = 157, - CPUHP_AP_PERF_ARM_HISI_HHA_ONLINE = 158, - CPUHP_AP_PERF_ARM_HISI_L3_ONLINE = 159, - CPUHP_AP_PERF_ARM_L2X0_ONLINE = 160, - CPUHP_AP_PERF_ARM_QCOM_L2_ONLINE = 161, - CPUHP_AP_PERF_ARM_QCOM_L3_ONLINE = 162, - CPUHP_AP_PERF_ARM_APM_XGENE_ONLINE = 163, - CPUHP_AP_PERF_ARM_CAVIUM_TX2_UNCORE_ONLINE = 164, - CPUHP_AP_PERF_POWERPC_NEST_IMC_ONLINE = 165, - CPUHP_AP_PERF_POWERPC_CORE_IMC_ONLINE = 166, - CPUHP_AP_PERF_POWERPC_THREAD_IMC_ONLINE = 167, - CPUHP_AP_PERF_POWERPC_TRACE_IMC_ONLINE = 168, - CPUHP_AP_WATCHDOG_ONLINE = 169, - CPUHP_AP_WORKQUEUE_ONLINE = 170, - CPUHP_AP_RCUTREE_ONLINE = 171, - CPUHP_AP_BASE_CACHEINFO_ONLINE = 172, - CPUHP_AP_ONLINE_DYN = 173, - CPUHP_AP_ONLINE_DYN_END = 203, - CPUHP_AP_X86_HPET_ONLINE = 204, - CPUHP_AP_X86_KVM_CLK_ONLINE = 205, - CPUHP_AP_ACTIVE = 206, - CPUHP_ONLINE = 207, +struct wb_domain { + spinlock_t lock; + struct fprop_global completions; + struct timer_list period_timer; + long unsigned int period_time; + long unsigned int dirty_limit_tstamp; + long unsigned int dirty_limit; }; -struct perf_regs { - __u64 abi; - struct pt_regs *regs; +enum cpu_idle_type { + CPU_IDLE = 0, + CPU_NOT_IDLE = 1, + CPU_NEWLY_IDLE = 2, + CPU_MAX_IDLE_TYPES = 3, }; -struct kernel_cpustat { - u64 cpustat[10]; +enum reboot_mode { + REBOOT_UNDEFINED = 4294967295, + REBOOT_COLD = 0, + REBOOT_WARM = 1, + REBOOT_HARD = 2, + REBOOT_SOFT = 3, + REBOOT_GPIO = 4, }; -struct kernel_stat { - long unsigned int irqs_sum; - unsigned int softirqs[10]; +enum reboot_type { + BOOT_TRIPLE = 116, + BOOT_KBD = 107, + BOOT_BIOS = 98, + BOOT_ACPI = 97, + BOOT_EFI = 101, + BOOT_CF9_FORCE = 112, + BOOT_CF9_SAFE = 113, }; -struct u64_stats_sync {}; - -struct bpf_cgroup_storage; - -struct bpf_prog; +typedef long unsigned int efi_status_t; -struct bpf_prog_array_item { - struct bpf_prog *prog; - struct bpf_cgroup_storage *cgroup_storage[2]; -}; +typedef u8 efi_bool_t; -struct bpf_prog_array { - struct callback_head rcu; - struct bpf_prog_array_item items[0]; -}; +typedef u16 efi_char16_t; -struct cgroup_bpf {}; +typedef u64 efi_physical_addr_t; -struct psi_group {}; +typedef void *efi_handle_t; -struct cgroup_file { - struct kernfs_node *kn; - long unsigned int notified_at; - struct timer_list notify_timer; -}; +typedef guid_t efi_guid_t; -struct cgroup_subsys; +typedef struct { + u64 signature; + u32 revision; + u32 headersize; + u32 crc32; + u32 reserved; +} efi_table_hdr_t; -struct cgroup_subsys_state { - struct cgroup *cgroup; - struct cgroup_subsys *ss; - struct percpu_ref refcnt; - struct list_head sibling; - struct list_head children; - struct list_head rstat_css_node; - int id; - unsigned int flags; - u64 serial_nr; - atomic_t online_cnt; - struct work_struct destroy_work; - struct rcu_work destroy_rwork; - struct cgroup_subsys_state *parent; -}; +typedef struct { + u32 type; + u32 pad; + u64 phys_addr; + u64 virt_addr; + u64 num_pages; + u64 attribute; +} efi_memory_desc_t; -struct cgroup_base_stat { - struct task_cputime cputime; -}; +typedef struct { + efi_guid_t guid; + u32 headersize; + u32 flags; + u32 imagesize; +} efi_capsule_header_t; -struct cgroup_freezer_state { - bool freeze; - int e_freeze; - int nr_frozen_descendants; - int nr_frozen_tasks; -}; +typedef struct { + u16 year; + u8 month; + u8 day; + u8 hour; + u8 minute; + u8 second; + u8 pad1; + u32 nanosecond; + s16 timezone; + u8 daylight; + u8 pad2; +} efi_time_t; -struct cgroup_root; +typedef struct { + u32 resolution; + u32 accuracy; + u8 sets_to_zero; +} efi_time_cap_t; -struct cgroup_rstat_cpu; +typedef struct { + efi_table_hdr_t hdr; + void *raise_tpl; + void *restore_tpl; + efi_status_t (*allocate_pages)(int, int, long unsigned int, efi_physical_addr_t *); + efi_status_t (*free_pages)(efi_physical_addr_t, long unsigned int); + efi_status_t (*get_memory_map)(long unsigned int *, void *, long unsigned int *, long unsigned int *, u32 *); + efi_status_t (*allocate_pool)(int, long unsigned int, void **); + efi_status_t (*free_pool)(void *); + void *create_event; + void *set_timer; + void *wait_for_event; + void *signal_event; + void *close_event; + void *check_event; + void *install_protocol_interface; + void *reinstall_protocol_interface; + void *uninstall_protocol_interface; + efi_status_t (*handle_protocol)(efi_handle_t, efi_guid_t *, void **); + void *__reserved; + void *register_protocol_notify; + efi_status_t (*locate_handle)(int, efi_guid_t *, void *, long unsigned int *, efi_handle_t *); + void *locate_device_path; + efi_status_t (*install_configuration_table)(efi_guid_t *, void *); + void *load_image; + void *start_image; + void *exit; + void *unload_image; + efi_status_t (*exit_boot_services)(efi_handle_t, long unsigned int); + void *get_next_monotonic_count; + void *stall; + void *set_watchdog_timer; + void *connect_controller; + void *disconnect_controller; + void *open_protocol; + void *close_protocol; + void *open_protocol_information; + void *protocols_per_handle; + void *locate_handle_buffer; + efi_status_t (*locate_protocol)(efi_guid_t *, void *, void **); + void *install_multiple_protocol_interfaces; + void *uninstall_multiple_protocol_interfaces; + void *calculate_crc32; + void *copy_mem; + void *set_mem; + void *create_event_ex; +} efi_boot_services_t; -struct cgroup { - struct cgroup_subsys_state self; - long unsigned int flags; - int level; - int max_depth; - int nr_descendants; - int nr_dying_descendants; - int max_descendants; - int nr_populated_csets; - int nr_populated_domain_children; - int nr_populated_threaded_children; - int nr_threaded_children; - struct kernfs_node *kn; - struct cgroup_file procs_file; - struct cgroup_file events_file; - u16 subtree_control; - u16 subtree_ss_mask; - u16 old_subtree_control; - u16 old_subtree_ss_mask; - struct cgroup_subsys_state *subsys[4]; - struct cgroup_root *root; - struct list_head cset_links; - struct list_head e_csets[4]; - struct cgroup *dom_cgrp; - struct cgroup *old_dom_cgrp; - struct cgroup_rstat_cpu *rstat_cpu; - struct list_head rstat_css_list; - struct cgroup_base_stat last_bstat; - struct cgroup_base_stat bstat; - struct prev_cputime prev_cputime; - struct list_head pidlists; - struct mutex pidlist_mutex; - wait_queue_head_t offline_waitq; - struct work_struct release_agent_work; - struct psi_group psi; - struct cgroup_bpf bpf; - atomic_t congestion_count; - struct cgroup_freezer_state freezer; - u64 ancestor_ids[0]; -}; +typedef efi_status_t efi_get_time_t(efi_time_t *, efi_time_cap_t *); -struct cgroup_taskset; +typedef efi_status_t efi_set_time_t(efi_time_t *); -struct cftype; +typedef efi_status_t efi_get_wakeup_time_t(efi_bool_t *, efi_bool_t *, efi_time_t *); -struct cgroup_subsys { - struct cgroup_subsys_state * (*css_alloc)(struct cgroup_subsys_state *); - int (*css_online)(struct cgroup_subsys_state *); - void (*css_offline)(struct cgroup_subsys_state *); - void (*css_released)(struct cgroup_subsys_state *); - void (*css_free)(struct cgroup_subsys_state *); - void (*css_reset)(struct cgroup_subsys_state *); - void (*css_rstat_flush)(struct cgroup_subsys_state *, int); - int (*css_extra_stat_show)(struct seq_file *, struct cgroup_subsys_state *); - int (*can_attach)(struct cgroup_taskset *); - void (*cancel_attach)(struct cgroup_taskset *); - void (*attach)(struct cgroup_taskset *); - void (*post_attach)(); - int (*can_fork)(struct task_struct *); - void (*cancel_fork)(struct task_struct *); - void (*fork)(struct task_struct *); - void (*exit)(struct task_struct *); - void (*release)(struct task_struct *); - void (*bind)(struct cgroup_subsys_state *); - bool early_init: 1; - bool implicit_on_dfl: 1; - bool threaded: 1; - bool broken_hierarchy: 1; - bool warned_broken_hierarchy: 1; - int id; - const char *name; - const char *legacy_name; - struct cgroup_root *root; - struct idr css_idr; - struct list_head cfts; - struct cftype *dfl_cftypes; - struct cftype *legacy_cftypes; - unsigned int depends_on; -}; +typedef efi_status_t efi_set_wakeup_time_t(efi_bool_t, efi_time_t *); -struct cgroup_rstat_cpu { - struct u64_stats_sync bsync; - struct cgroup_base_stat bstat; - struct cgroup_base_stat last_bstat; - struct cgroup *updated_children; - struct cgroup *updated_next; -}; +typedef efi_status_t efi_get_variable_t(efi_char16_t *, efi_guid_t *, u32 *, long unsigned int *, void *); -struct cgroup_root { - struct kernfs_root *kf_root; - unsigned int subsys_mask; - int hierarchy_id; - struct cgroup cgrp; - u64 cgrp_ancestor_id_storage; - atomic_t nr_cgrps; - struct list_head root_list; - unsigned int flags; - char release_agent_path[4096]; - char name[64]; -}; +typedef efi_status_t efi_get_next_variable_t(long unsigned int *, efi_char16_t *, efi_guid_t *); -struct cftype { - char name[64]; - long unsigned int private; - size_t max_write_len; - unsigned int flags; - unsigned int file_offset; - struct cgroup_subsys *ss; - struct list_head node; - struct kernfs_ops *kf_ops; - int (*open)(struct kernfs_open_file *); - void (*release)(struct kernfs_open_file *); - u64 (*read_u64)(struct cgroup_subsys_state *, struct cftype *); - s64 (*read_s64)(struct cgroup_subsys_state *, struct cftype *); - int (*seq_show)(struct seq_file *, void *); - void * (*seq_start)(struct seq_file *, loff_t *); - void * (*seq_next)(struct seq_file *, void *, loff_t *); - void (*seq_stop)(struct seq_file *, void *); - int (*write_u64)(struct cgroup_subsys_state *, struct cftype *, u64); - int (*write_s64)(struct cgroup_subsys_state *, struct cftype *, s64); - ssize_t (*write)(struct kernfs_open_file *, char *, size_t, loff_t); - __poll_t (*poll)(struct kernfs_open_file *, struct poll_table_struct *); -}; +typedef efi_status_t efi_set_variable_t(efi_char16_t *, efi_guid_t *, u32, long unsigned int, void *); -struct perf_callchain_entry { - __u64 nr; - __u64 ip[0]; -}; +typedef efi_status_t efi_get_next_high_mono_count_t(u32 *); -typedef long unsigned int (*perf_copy_f)(void *, const void *, long unsigned int, long unsigned int); +typedef void efi_reset_system_t(int, efi_status_t, long unsigned int, efi_char16_t *); -struct perf_raw_frag { - union { - struct perf_raw_frag *next; - long unsigned int pad; - }; - perf_copy_f copy; - void *data; - u32 size; -} __attribute__((packed)); +typedef efi_status_t efi_set_virtual_address_map_t(long unsigned int, long unsigned int, u32, efi_memory_desc_t *); -struct perf_raw_record { - struct perf_raw_frag frag; - u32 size; -}; +typedef efi_status_t efi_query_variable_info_t(u32, u64 *, u64 *, u64 *); -struct perf_branch_stack { - __u64 nr; - struct perf_branch_entry entries[0]; -}; +typedef efi_status_t efi_update_capsule_t(efi_capsule_header_t **, long unsigned int, long unsigned int); -struct perf_cpu_context; +typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **, long unsigned int, u64 *, int *); -struct perf_output_handle; +typedef struct { + efi_table_hdr_t hdr; + efi_get_time_t *get_time; + efi_set_time_t *set_time; + efi_get_wakeup_time_t *get_wakeup_time; + efi_set_wakeup_time_t *set_wakeup_time; + efi_set_virtual_address_map_t *set_virtual_address_map; + void *convert_pointer; + efi_get_variable_t *get_variable; + efi_get_next_variable_t *get_next_variable; + efi_set_variable_t *set_variable; + efi_get_next_high_mono_count_t *get_next_high_mono_count; + efi_reset_system_t *reset_system; + efi_update_capsule_t *update_capsule; + efi_query_capsule_caps_t *query_capsule_caps; + efi_query_variable_info_t *query_variable_info; +} efi_runtime_services_t; -struct pmu { - struct list_head entry; - struct module *module; - struct device *dev; - const struct attribute_group **attr_groups; - const struct attribute_group **attr_update; - const char *name; - int type; - int capabilities; - int *pmu_disable_count; - struct perf_cpu_context *pmu_cpu_context; - atomic_t exclusive_cnt; - int task_ctx_nr; - int hrtimer_interval_ms; - unsigned int nr_addr_filters; - void (*pmu_enable)(struct pmu *); - void (*pmu_disable)(struct pmu *); - int (*event_init)(struct perf_event *); - void (*event_mapped)(struct perf_event *, struct mm_struct *); - void (*event_unmapped)(struct perf_event *, struct mm_struct *); - int (*add)(struct perf_event *, int); - void (*del)(struct perf_event *, int); - void (*start)(struct perf_event *, int); - void (*stop)(struct perf_event *, int); - void (*read)(struct perf_event *); - void (*start_txn)(struct pmu *, unsigned int); - int (*commit_txn)(struct pmu *); - void (*cancel_txn)(struct pmu *); - int (*event_idx)(struct perf_event *); - void (*sched_task)(struct perf_event_context *, bool); - size_t task_ctx_size; - void (*swap_task_ctx)(struct perf_event_context *, struct perf_event_context *); - void * (*setup_aux)(struct perf_event *, void **, int, bool); - void (*free_aux)(void *); - long int (*snapshot_aux)(struct perf_event *, struct perf_output_handle *, long unsigned int); - int (*addr_filters_validate)(struct list_head *); - void (*addr_filters_sync)(struct perf_event *); - int (*aux_output_match)(struct perf_event *); - int (*filter_match)(struct perf_event *); - int (*check_period)(struct perf_event *, u64); -}; +typedef struct { + efi_table_hdr_t hdr; + long unsigned int fw_vendor; + u32 fw_revision; + long unsigned int con_in_handle; + long unsigned int con_in; + long unsigned int con_out_handle; + long unsigned int con_out; + long unsigned int stderr_handle; + long unsigned int stderr; + efi_runtime_services_t *runtime; + efi_boot_services_t *boottime; + long unsigned int nr_tables; + long unsigned int tables; +} efi_system_table_t; -struct perf_cpu_context { - struct perf_event_context ctx; - struct perf_event_context *task_ctx; - int active_oncpu; - int exclusive; - raw_spinlock_t hrtimer_lock; - struct hrtimer hrtimer; - ktime_t hrtimer_interval; - unsigned int hrtimer_active; - struct list_head sched_cb_entry; - int sched_cb_usage; - int online; +struct efi_memory_map { + phys_addr_t phys_map; + void *map; + void *map_end; + int nr_map; + long unsigned int desc_version; + long unsigned int desc_size; + bool late; }; -struct perf_output_handle { - struct perf_event *event; - struct ring_buffer *rb; - long unsigned int wakeup; - long unsigned int size; - u64 aux_flags; - union { - void *addr; - long unsigned int head; - }; - int page; +struct efi { + efi_system_table_t *systab; + unsigned int runtime_version; + long unsigned int mps; + long unsigned int acpi; + long unsigned int acpi20; + long unsigned int smbios; + long unsigned int smbios3; + long unsigned int boot_info; + long unsigned int hcdp; + long unsigned int uga; + long unsigned int fw_vendor; + long unsigned int runtime; + long unsigned int config_table; + long unsigned int esrt; + long unsigned int properties_table; + long unsigned int mem_attr_table; + long unsigned int rng_seed; + long unsigned int tpm_log; + long unsigned int tpm_final_log; + long unsigned int mem_reserve; + efi_get_time_t *get_time; + efi_set_time_t *set_time; + efi_get_wakeup_time_t *get_wakeup_time; + efi_set_wakeup_time_t *set_wakeup_time; + efi_get_variable_t *get_variable; + efi_get_next_variable_t *get_next_variable; + efi_set_variable_t *set_variable; + efi_set_variable_t *set_variable_nonblocking; + efi_query_variable_info_t *query_variable_info; + efi_query_variable_info_t *query_variable_info_nonblocking; + efi_update_capsule_t *update_capsule; + efi_query_capsule_caps_t *query_capsule_caps; + efi_get_next_high_mono_count_t *get_next_high_mono_count; + efi_reset_system_t *reset_system; + efi_set_virtual_address_map_t *set_virtual_address_map; + struct efi_memory_map memmap; + long unsigned int flags; }; -struct perf_addr_filter_range { - long unsigned int start; - long unsigned int size; +enum efi_rts_ids { + EFI_NONE = 0, + EFI_GET_TIME = 1, + EFI_SET_TIME = 2, + EFI_GET_WAKEUP_TIME = 3, + EFI_SET_WAKEUP_TIME = 4, + EFI_GET_VARIABLE = 5, + EFI_GET_NEXT_VARIABLE = 6, + EFI_SET_VARIABLE = 7, + EFI_QUERY_VARIABLE_INFO = 8, + EFI_GET_NEXT_HIGH_MONO_COUNT = 9, + EFI_RESET_SYSTEM = 10, + EFI_UPDATE_CAPSULE = 11, + EFI_QUERY_CAPSULE_CAPS = 12, }; -struct perf_sample_data { - u64 addr; - struct perf_raw_record *raw; - struct perf_branch_stack *br_stack; - u64 period; - u64 weight; - u64 txn; - union perf_mem_data_src data_src; - u64 type; - u64 ip; - struct { - u32 pid; - u32 tid; - } tid_entry; - u64 time; - u64 id; - u64 stream_id; - struct { - u32 cpu; - u32 reserved; - } cpu_entry; - struct perf_callchain_entry *callchain; - u64 aux_size; - struct perf_regs regs_user; - struct pt_regs regs_user_copy; - struct perf_regs regs_intr; - u64 stack_user_size; - u64 phys_addr; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +struct efi_runtime_work { + void *arg1; + void *arg2; + void *arg3; + void *arg4; + void *arg5; + efi_status_t status; + struct work_struct work; + enum efi_rts_ids efi_rts_id; + struct completion efi_rts_comp; }; -struct trace_entry { - short unsigned int type; - unsigned char flags; - unsigned char preempt_count; - int pid; +struct percpu_cluster { + struct swap_cluster_info index; + unsigned int next; }; -struct trace_array; - -struct tracer; - -struct trace_buffer; - -struct ring_buffer_iter; - -struct trace_iterator { - struct trace_array *tr; - struct tracer *trace; - struct trace_buffer *trace_buffer; - void *private; - int cpu_file; - struct mutex mutex; - struct ring_buffer_iter **buffer_iter; - long unsigned int iter_flags; - struct trace_seq tmp_seq; - cpumask_var_t started; - bool snapshot; - struct trace_seq seq; - struct trace_entry *ent; - long unsigned int lost_events; - int leftover; - int ent_size; - int cpu; - u64 ts; - loff_t pos; - long int idx; +struct trace_event_raw_initcall_level { + struct trace_entry ent; + u32 __data_loc_level; + char __data[0]; }; -enum print_line_t { - TRACE_TYPE_PARTIAL_LINE = 0, - TRACE_TYPE_HANDLED = 1, - TRACE_TYPE_UNHANDLED = 2, - TRACE_TYPE_NO_CONSUME = 3, +struct trace_event_raw_initcall_start { + struct trace_entry ent; + initcall_t func; + char __data[0]; }; -typedef enum print_line_t (*trace_print_func)(struct trace_iterator *, int, struct trace_event *); - -struct trace_event_functions { - trace_print_func trace; - trace_print_func raw; - trace_print_func hex; - trace_print_func binary; +struct trace_event_raw_initcall_finish { + struct trace_entry ent; + initcall_t func; + int ret; + char __data[0]; }; -enum trace_reg { - TRACE_REG_REGISTER = 0, - TRACE_REG_UNREGISTER = 1, - TRACE_REG_PERF_REGISTER = 2, - TRACE_REG_PERF_UNREGISTER = 3, - TRACE_REG_PERF_OPEN = 4, - TRACE_REG_PERF_CLOSE = 5, - TRACE_REG_PERF_ADD = 6, - TRACE_REG_PERF_DEL = 7, +struct trace_event_data_offsets_initcall_level { + u32 level; }; -struct trace_event_class { - const char *system; - void *probe; - void *perf_probe; - int (*reg)(struct trace_event_call *, enum trace_reg, void *); - int (*define_fields)(struct trace_event_call *); - struct list_head * (*get_fields)(struct trace_event_call *); - struct list_head fields; - int (*raw_init)(struct trace_event_call *); -}; +struct trace_event_data_offsets_initcall_start {}; -struct trace_event_file; +struct trace_event_data_offsets_initcall_finish {}; -struct trace_event_buffer { - struct ring_buffer *buffer; - struct ring_buffer_event *event; - struct trace_event_file *trace_file; - void *entry; - long unsigned int flags; - int pc; -}; +typedef void (*btf_trace_initcall_level)(void *, const char *); -struct trace_subsystem_dir; +typedef void (*btf_trace_initcall_start)(void *, initcall_t); -struct trace_event_file { - struct list_head list; - struct trace_event_call *event_call; - struct event_filter *filter; - struct dentry *dir; - struct trace_array *tr; - struct trace_subsystem_dir *system; - struct list_head triggers; - long unsigned int flags; - atomic_t sm_ref; - atomic_t tm_ref; +typedef void (*btf_trace_initcall_finish)(void *, initcall_t, int); + +struct blacklist_entry { + struct list_head next; + char *buf; }; -enum { - TRACE_EVENT_FL_FILTERED_BIT = 0, - TRACE_EVENT_FL_CAP_ANY_BIT = 1, - TRACE_EVENT_FL_NO_SET_FILTER_BIT = 2, - TRACE_EVENT_FL_IGNORE_ENABLE_BIT = 3, - TRACE_EVENT_FL_TRACEPOINT_BIT = 4, - TRACE_EVENT_FL_KPROBE_BIT = 5, - TRACE_EVENT_FL_UPROBE_BIT = 6, +enum page_cache_mode { + _PAGE_CACHE_MODE_WB = 0, + _PAGE_CACHE_MODE_WC = 1, + _PAGE_CACHE_MODE_UC_MINUS = 2, + _PAGE_CACHE_MODE_UC = 3, + _PAGE_CACHE_MODE_WT = 4, + _PAGE_CACHE_MODE_WP = 5, + _PAGE_CACHE_MODE_NUM = 8, }; enum { - TRACE_EVENT_FL_FILTERED = 1, - TRACE_EVENT_FL_CAP_ANY = 2, - TRACE_EVENT_FL_NO_SET_FILTER = 4, - TRACE_EVENT_FL_IGNORE_ENABLE = 8, - TRACE_EVENT_FL_TRACEPOINT = 16, - TRACE_EVENT_FL_KPROBE = 32, - TRACE_EVENT_FL_UPROBE = 64, + UNAME26 = 131072, + ADDR_NO_RANDOMIZE = 262144, + FDPIC_FUNCPTRS = 524288, + MMAP_PAGE_ZERO = 1048576, + ADDR_COMPAT_LAYOUT = 2097152, + READ_IMPLIES_EXEC = 4194304, + ADDR_LIMIT_32BIT = 8388608, + SHORT_INODE = 16777216, + WHOLE_SECONDS = 33554432, + STICKY_TIMEOUTS = 67108864, + ADDR_LIMIT_3GB = 134217728, }; -enum { - EVENT_FILE_FL_ENABLED_BIT = 0, - EVENT_FILE_FL_RECORDED_CMD_BIT = 1, - EVENT_FILE_FL_RECORDED_TGID_BIT = 2, - EVENT_FILE_FL_FILTERED_BIT = 3, - EVENT_FILE_FL_NO_SET_FILTER_BIT = 4, - EVENT_FILE_FL_SOFT_MODE_BIT = 5, - EVENT_FILE_FL_SOFT_DISABLED_BIT = 6, - EVENT_FILE_FL_TRIGGER_MODE_BIT = 7, - EVENT_FILE_FL_TRIGGER_COND_BIT = 8, - EVENT_FILE_FL_PID_FILTER_BIT = 9, - EVENT_FILE_FL_WAS_ENABLED_BIT = 10, +enum tlb_infos { + ENTRIES = 0, + NR_INFO = 1, }; enum { - EVENT_FILE_FL_ENABLED = 1, - EVENT_FILE_FL_RECORDED_CMD = 2, - EVENT_FILE_FL_RECORDED_TGID = 4, - EVENT_FILE_FL_FILTERED = 8, - EVENT_FILE_FL_NO_SET_FILTER = 16, - EVENT_FILE_FL_SOFT_MODE = 32, - EVENT_FILE_FL_SOFT_DISABLED = 64, - EVENT_FILE_FL_TRIGGER_MODE = 128, - EVENT_FILE_FL_TRIGGER_COND = 256, - EVENT_FILE_FL_PID_FILTER = 512, - EVENT_FILE_FL_WAS_ENABLED = 1024, + MM_FILEPAGES = 0, + MM_ANONPAGES = 1, + MM_SWAPENTS = 2, + MM_SHMEMPAGES = 3, + NR_MM_COUNTERS = 4, }; -enum event_trigger_type { - ETT_NONE = 0, - ETT_TRACE_ONOFF = 1, - ETT_SNAPSHOT = 2, - ETT_STACKTRACE = 4, - ETT_EVENT_ENABLE = 8, - ETT_EVENT_HIST = 16, - ETT_HIST_ENABLE = 32, -}; +typedef __u32 Elf32_Word; -enum { - FILTER_OTHER = 0, - FILTER_STATIC_STRING = 1, - FILTER_DYN_STRING = 2, - FILTER_PTR_STRING = 3, - FILTER_TRACE_FN = 4, - FILTER_COMM = 5, - FILTER_CPU = 6, +struct elf32_note { + Elf32_Word n_namesz; + Elf32_Word n_descsz; + Elf32_Word n_type; }; -struct property { - char *name; - int length; - void *value; - struct property *next; +enum hrtimer_base_type { + HRTIMER_BASE_MONOTONIC = 0, + HRTIMER_BASE_REALTIME = 1, + HRTIMER_BASE_BOOTTIME = 2, + HRTIMER_BASE_TAI = 3, + HRTIMER_BASE_MONOTONIC_SOFT = 4, + HRTIMER_BASE_REALTIME_SOFT = 5, + HRTIMER_BASE_BOOTTIME_SOFT = 6, + HRTIMER_BASE_TAI_SOFT = 7, + HRTIMER_MAX_CLOCK_BASES = 8, }; -struct irq_fwspec { - struct fwnode_handle *fwnode; - int param_count; - u32 param[16]; +enum rseq_cs_flags_bit { + RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT_BIT = 0, + RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL_BIT = 1, + RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT = 2, }; -struct irq_data; +enum perf_event_task_context { + perf_invalid_context = 4294967295, + perf_hw_context = 0, + perf_sw_context = 1, + perf_nr_task_contexts = 2, +}; -struct irq_domain_ops { - int (*match)(struct irq_domain *, struct device_node *, enum irq_domain_bus_token); - int (*select)(struct irq_domain *, struct irq_fwspec *, enum irq_domain_bus_token); - int (*map)(struct irq_domain *, unsigned int, irq_hw_number_t); - void (*unmap)(struct irq_domain *, unsigned int); - int (*xlate)(struct irq_domain *, struct device_node *, const u32 *, unsigned int, long unsigned int *, unsigned int *); - int (*alloc)(struct irq_domain *, unsigned int, unsigned int, void *); - void (*free)(struct irq_domain *, unsigned int, unsigned int); - int (*activate)(struct irq_domain *, struct irq_data *, bool); - void (*deactivate)(struct irq_domain *, struct irq_data *); - int (*translate)(struct irq_domain *, struct irq_fwspec *, long unsigned int *, unsigned int *); +enum rseq_event_mask_bits { + RSEQ_EVENT_PREEMPT_BIT = 0, + RSEQ_EVENT_SIGNAL_BIT = 1, + RSEQ_EVENT_MIGRATE_BIT = 2, }; -struct acpi_table_header { - char signature[4]; - u32 length; - u8 revision; - u8 checksum; - char oem_id[6]; - char oem_table_id[8]; - u32 oem_revision; - char asl_compiler_id[4]; - u32 asl_compiler_revision; +enum { + PROC_ROOT_INO = 1, + PROC_IPC_INIT_INO = 4026531839, + PROC_UTS_INIT_INO = 4026531838, + PROC_USER_INIT_INO = 4026531837, + PROC_PID_INIT_INO = 4026531836, + PROC_CGROUP_INIT_INO = 4026531835, }; -struct acpi_generic_address { - u8 space_id; - u8 bit_width; - u8 bit_offset; - u8 access_width; - u64 address; -} __attribute__((packed)); +typedef __u16 __le16; -struct acpi_table_fadt { - struct acpi_table_header header; - u32 facs; - u32 dsdt; - u8 model; - u8 preferred_profile; - u16 sci_interrupt; - u32 smi_command; - u8 acpi_enable; - u8 acpi_disable; - u8 s4_bios_request; - u8 pstate_control; - u32 pm1a_event_block; - u32 pm1b_event_block; - u32 pm1a_control_block; - u32 pm1b_control_block; - u32 pm2_control_block; - u32 pm_timer_block; - u32 gpe0_block; - u32 gpe1_block; - u8 pm1_event_length; - u8 pm1_control_length; - u8 pm2_control_length; - u8 pm_timer_length; - u8 gpe0_block_length; - u8 gpe1_block_length; - u8 gpe1_base; - u8 cst_control; - u16 c2_latency; - u16 c3_latency; - u16 flush_size; - u16 flush_stride; - u8 duty_offset; - u8 duty_width; - u8 day_alarm; - u8 month_alarm; - u8 century; - u16 boot_flags; - u8 reserved; - u32 flags; - struct acpi_generic_address reset_register; - u8 reset_value; - u16 arm_boot_flags; - u8 minor_revision; - u64 Xfacs; - u64 Xdsdt; - struct acpi_generic_address xpm1a_event_block; - struct acpi_generic_address xpm1b_event_block; - struct acpi_generic_address xpm1a_control_block; - struct acpi_generic_address xpm1b_control_block; - struct acpi_generic_address xpm2_control_block; - struct acpi_generic_address xpm_timer_block; - struct acpi_generic_address xgpe0_block; - struct acpi_generic_address xgpe1_block; - struct acpi_generic_address sleep_control; - struct acpi_generic_address sleep_status; - u64 hypervisor_id; -} __attribute__((packed)); +typedef __u16 __be16; -enum wb_stat_item { - WB_RECLAIMABLE = 0, - WB_WRITEBACK = 1, - WB_DIRTIED = 2, - WB_WRITTEN = 3, - NR_WB_STAT_ITEMS = 4, -}; +typedef __u32 __be32; -struct bdi_writeback_congested { - long unsigned int state; - refcount_t refcnt; -}; +typedef __u64 __be64; -enum stat_group { - STAT_READ = 0, - STAT_WRITE = 1, - STAT_DISCARD = 2, - STAT_FLUSH = 3, - NR_STAT_GROUPS = 4, -}; +typedef __u32 __wsum; -struct disk_stats { - u64 nsecs[4]; - long unsigned int sectors[4]; - long unsigned int ios[4]; - long unsigned int merges[4]; - long unsigned int io_ticks; - long unsigned int time_in_queue; - local_t in_flight[2]; -}; +typedef u64 uint64_t; -struct partition_meta_info { - char uuid[37]; - u8 volname[64]; +typedef unsigned int slab_flags_t; + +struct raw_notifier_head { + struct notifier_block *head; }; -struct disk_part_tbl { - struct callback_head callback_head; - int len; - struct hd_struct *last_lookup; - struct hd_struct *part[0]; +struct llist_head { + struct llist_node *first; }; -struct blk_zone; +typedef struct __call_single_data call_single_data_t; -typedef int (*report_zones_cb)(struct blk_zone *, unsigned int, void *); +struct ida { + struct xarray xa; +}; -struct hd_geometry; +typedef __u64 __addrpair; -struct pr_ops; +typedef __u32 __portpair; -struct block_device_operations { - int (*open)(struct block_device *, fmode_t); - void (*release)(struct gendisk *, fmode_t); - int (*rw_page)(struct block_device *, sector_t, struct page *, unsigned int); - int (*ioctl)(struct block_device *, fmode_t, unsigned int, long unsigned int); - int (*compat_ioctl)(struct block_device *, fmode_t, unsigned int, long unsigned int); - unsigned int (*check_events)(struct gendisk *, unsigned int); - int (*media_changed)(struct gendisk *); - void (*unlock_native_capacity)(struct gendisk *); - int (*revalidate_disk)(struct gendisk *); - int (*getgeo)(struct block_device *, struct hd_geometry *); - void (*swap_slot_free_notify)(struct block_device *, long unsigned int); - int (*report_zones)(struct gendisk *, sector_t, unsigned int, report_zones_cb, void *); - struct module *owner; - const struct pr_ops *pr_ops; -}; +typedef struct { + struct net *net; +} possible_net_t; -struct sg_io_v4 { - __s32 guard; - __u32 protocol; - __u32 subprotocol; - __u32 request_len; - __u64 request; - __u64 request_tag; - __u32 request_attr; - __u32 request_priority; - __u32 request_extra; - __u32 max_response_len; - __u64 response; - __u32 dout_iovec_count; - __u32 dout_xfer_len; - __u32 din_iovec_count; - __u32 din_xfer_len; - __u64 dout_xferp; - __u64 din_xferp; - __u32 timeout; - __u32 flags; - __u64 usr_ptr; - __u32 spare_in; - __u32 driver_status; - __u32 transport_status; - __u32 device_status; - __u32 retry_delay; - __u32 info; - __u32 duration; - __u32 response_len; - __s32 din_resid; - __s32 dout_resid; - __u64 generated_tag; - __u32 spare_out; - __u32 padding; +struct in6_addr { + union { + __u8 u6_addr8[16]; + __be16 u6_addr16[8]; + __be32 u6_addr32[4]; + } in6_u; }; -struct bsg_ops { - int (*check_proto)(struct sg_io_v4 *); - int (*fill_hdr)(struct request *, struct sg_io_v4 *, fmode_t); - int (*complete_rq)(struct request *, struct sg_io_v4 *); - void (*free_rq)(struct request *); +struct hlist_nulls_node { + struct hlist_nulls_node *next; + struct hlist_nulls_node **pprev; }; -typedef __u32 req_flags_t; - -typedef void rq_end_io_fn(struct request *, blk_status_t); +struct proto; -enum mq_rq_state { - MQ_RQ_IDLE = 0, - MQ_RQ_IN_FLIGHT = 1, - MQ_RQ_COMPLETE = 2, -}; +struct inet_timewait_death_row; -struct request { - struct request_queue *q; - struct blk_mq_ctx *mq_ctx; - struct blk_mq_hw_ctx *mq_hctx; - unsigned int cmd_flags; - req_flags_t rq_flags; - int tag; - int internal_tag; - unsigned int __data_len; - sector_t __sector; - struct bio *bio; - struct bio *biotail; - struct list_head queuelist; +struct sock_common { union { - struct hlist_node hash; - struct list_head ipi_list; + __addrpair skc_addrpair; + struct { + __be32 skc_daddr; + __be32 skc_rcv_saddr; + }; + }; + union { + unsigned int skc_hash; + __u16 skc_u16hashes[2]; + }; + union { + __portpair skc_portpair; + struct { + __be16 skc_dport; + __u16 skc_num; + }; + }; + short unsigned int skc_family; + volatile unsigned char skc_state; + unsigned char skc_reuse: 4; + unsigned char skc_reuseport: 1; + unsigned char skc_ipv6only: 1; + unsigned char skc_net_refcnt: 1; + int skc_bound_dev_if; + union { + struct hlist_node skc_bind_node; + struct hlist_node skc_portaddr_node; + }; + struct proto *skc_prot; + possible_net_t skc_net; + struct in6_addr skc_v6_daddr; + struct in6_addr skc_v6_rcv_saddr; + atomic64_t skc_cookie; + union { + long unsigned int skc_flags; + struct sock *skc_listener; + struct inet_timewait_death_row *skc_tw_dr; }; + int skc_dontcopy_begin[0]; union { - struct rb_node rb_node; - struct bio_vec special_vec; - void *completion_data; - int error_count; + struct hlist_node skc_node; + struct hlist_nulls_node skc_nulls_node; }; + short unsigned int skc_tx_queue_mapping; + short unsigned int skc_rx_queue_mapping; union { - struct { - struct io_cq *icq; - void *priv[2]; - } elv; - struct { - unsigned int seq; - struct list_head list; - rq_end_io_fn *saved_end_io; - } flush; + int skc_incoming_cpu; + u32 skc_rcv_wnd; + u32 skc_tw_rcv_nxt; }; - struct gendisk *rq_disk; - struct hd_struct *part; - u64 start_time_ns; - u64 io_start_time_ns; - short unsigned int stats_sectors; - short unsigned int nr_phys_segments; - short unsigned int write_hint; - short unsigned int ioprio; - unsigned int extra_len; - enum mq_rq_state state; - refcount_t ref; - unsigned int timeout; - long unsigned int deadline; + refcount_t skc_refcnt; + int skc_dontcopy_end[0]; union { - struct __call_single_data csd; - u64 fifo_time; + u32 skc_rxhash; + u32 skc_window_clamp; + u32 skc_tw_snd_nxt; }; - rq_end_io_fn *end_io; - void *end_io_data; -}; - -struct blk_zone { - __u64 start; - __u64 len; - __u64 wp; - __u8 type; - __u8 cond; - __u8 non_seq; - __u8 reset; - __u8 reserved[36]; -}; - -enum elv_merge { - ELEVATOR_NO_MERGE = 0, - ELEVATOR_FRONT_MERGE = 1, - ELEVATOR_BACK_MERGE = 2, - ELEVATOR_DISCARD_MERGE = 3, }; -struct elevator_type; +typedef struct { + spinlock_t slock; + int owned; + wait_queue_head_t wq; +} socket_lock_t; -struct blk_mq_alloc_data; +struct sk_buff; -struct elevator_mq_ops { - int (*init_sched)(struct request_queue *, struct elevator_type *); - void (*exit_sched)(struct elevator_queue *); - int (*init_hctx)(struct blk_mq_hw_ctx *, unsigned int); - void (*exit_hctx)(struct blk_mq_hw_ctx *, unsigned int); - void (*depth_updated)(struct blk_mq_hw_ctx *); - bool (*allow_merge)(struct request_queue *, struct request *, struct bio *); - bool (*bio_merge)(struct blk_mq_hw_ctx *, struct bio *, unsigned int); - int (*request_merge)(struct request_queue *, struct request **, struct bio *); - void (*request_merged)(struct request_queue *, struct request *, enum elv_merge); - void (*requests_merged)(struct request_queue *, struct request *, struct request *); - void (*limit_depth)(unsigned int, struct blk_mq_alloc_data *); - void (*prepare_request)(struct request *, struct bio *); - void (*finish_request)(struct request *); - void (*insert_requests)(struct blk_mq_hw_ctx *, struct list_head *, bool); - struct request * (*dispatch_request)(struct blk_mq_hw_ctx *); - bool (*has_work)(struct blk_mq_hw_ctx *); - void (*completed_request)(struct request *, u64); - void (*requeue_request)(struct request *); - struct request * (*former_request)(struct request_queue *, struct request *); - struct request * (*next_request)(struct request_queue *, struct request *); - void (*init_icq)(struct io_cq *); - void (*exit_icq)(struct io_cq *); +struct sk_buff_head { + struct sk_buff *next; + struct sk_buff *prev; + __u32 qlen; + spinlock_t lock; }; -struct elv_fs_entry; - -struct blk_mq_debugfs_attr; - -struct elevator_type { - struct kmem_cache *icq_cache; - struct elevator_mq_ops ops; - size_t icq_size; - size_t icq_align; - struct elv_fs_entry *elevator_attrs; - const char *elevator_name; - const char *elevator_alias; - const unsigned int elevator_features; - struct module *elevator_owner; - const struct blk_mq_debugfs_attr *queue_debugfs_attrs; - const struct blk_mq_debugfs_attr *hctx_debugfs_attrs; - char icq_cache_name[22]; - struct list_head list; -}; +typedef u64 netdev_features_t; -struct elevator_queue { - struct elevator_type *type; - void *elevator_data; - struct kobject kobj; - struct mutex sysfs_lock; - unsigned int registered: 1; - struct hlist_head hash[64]; +struct sock_cgroup_data { + union { + struct { + u8 is_data; + u8 padding; + u16 prioidx; + u32 classid; + }; + u64 val; + }; }; -struct elv_fs_entry { - struct attribute attr; - ssize_t (*show)(struct elevator_queue *, char *); - ssize_t (*store)(struct elevator_queue *, const char *, size_t); -}; +struct sk_filter; -struct blk_mq_debugfs_attr { - const char *name; - umode_t mode; - int (*show)(void *, struct seq_file *); - ssize_t (*write)(void *, const char *, size_t, loff_t *); - const struct seq_operations *seq_ops; -}; +struct socket_wq; -struct blk_mq_queue_data; +struct xfrm_policy; -typedef blk_status_t queue_rq_fn(struct blk_mq_hw_ctx *, const struct blk_mq_queue_data *); +struct dst_entry; -typedef void commit_rqs_fn(struct blk_mq_hw_ctx *); +struct socket; -typedef bool get_budget_fn(struct blk_mq_hw_ctx *); +struct sock_reuseport; -typedef void put_budget_fn(struct blk_mq_hw_ctx *); +struct bpf_sk_storage; -enum blk_eh_timer_return { - BLK_EH_DONE = 0, - BLK_EH_RESET_TIMER = 1, +struct sock { + struct sock_common __sk_common; + socket_lock_t sk_lock; + atomic_t sk_drops; + int sk_rcvlowat; + struct sk_buff_head sk_error_queue; + struct sk_buff *sk_rx_skb_cache; + struct sk_buff_head sk_receive_queue; + struct { + atomic_t rmem_alloc; + int len; + struct sk_buff *head; + struct sk_buff *tail; + } sk_backlog; + int sk_forward_alloc; + unsigned int sk_ll_usec; + unsigned int sk_napi_id; + int sk_rcvbuf; + struct sk_filter *sk_filter; + union { + struct socket_wq *sk_wq; + struct socket_wq *sk_wq_raw; + }; + struct xfrm_policy *sk_policy[2]; + struct dst_entry *sk_rx_dst; + struct dst_entry *sk_dst_cache; + atomic_t sk_omem_alloc; + int sk_sndbuf; + int sk_wmem_queued; + refcount_t sk_wmem_alloc; + long unsigned int sk_tsq_flags; + union { + struct sk_buff *sk_send_head; + struct rb_root tcp_rtx_queue; + }; + struct sk_buff *sk_tx_skb_cache; + struct sk_buff_head sk_write_queue; + __s32 sk_peek_off; + int sk_write_pending; + __u32 sk_dst_pending_confirm; + u32 sk_pacing_status; + long int sk_sndtimeo; + struct timer_list sk_timer; + __u32 sk_priority; + __u32 sk_mark; + long unsigned int sk_pacing_rate; + long unsigned int sk_max_pacing_rate; + struct page_frag sk_frag; + netdev_features_t sk_route_caps; + netdev_features_t sk_route_nocaps; + netdev_features_t sk_route_forced_caps; + int sk_gso_type; + unsigned int sk_gso_max_size; + gfp_t sk_allocation; + __u32 sk_txhash; + unsigned int __sk_flags_offset[0]; + unsigned int sk_padding: 1; + unsigned int sk_kern_sock: 1; + unsigned int sk_no_check_tx: 1; + unsigned int sk_no_check_rx: 1; + unsigned int sk_userlocks: 4; + unsigned int sk_protocol: 8; + unsigned int sk_type: 16; + u16 sk_gso_max_segs; + u8 sk_pacing_shift; + long unsigned int sk_lingertime; + struct proto *sk_prot_creator; + rwlock_t sk_callback_lock; + int sk_err; + int sk_err_soft; + u32 sk_ack_backlog; + u32 sk_max_ack_backlog; + kuid_t sk_uid; + struct pid *sk_peer_pid; + const struct cred *sk_peer_cred; + long int sk_rcvtimeo; + ktime_t sk_stamp; + u16 sk_tsflags; + u8 sk_shutdown; + u32 sk_tskey; + atomic_t sk_zckey; + u8 sk_clockid; + u8 sk_txtime_deadline_mode: 1; + u8 sk_txtime_report_errors: 1; + u8 sk_txtime_unused: 6; + struct socket *sk_socket; + void *sk_user_data; + void *sk_security; + struct sock_cgroup_data sk_cgrp_data; + struct mem_cgroup *sk_memcg; + void (*sk_state_change)(struct sock *); + void (*sk_data_ready)(struct sock *); + void (*sk_write_space)(struct sock *); + void (*sk_error_report)(struct sock *); + int (*sk_backlog_rcv)(struct sock *, struct sk_buff *); + void (*sk_destruct)(struct sock *); + struct sock_reuseport *sk_reuseport_cb; + struct bpf_sk_storage *sk_bpf_storage; + struct callback_head sk_rcu; }; -typedef enum blk_eh_timer_return timeout_fn(struct request *, bool); - -typedef int poll_fn(struct blk_mq_hw_ctx *); - -typedef void complete_fn(struct request *); +struct rhash_head { + struct rhash_head *next; +}; -typedef int init_hctx_fn(struct blk_mq_hw_ctx *, void *, unsigned int); +struct rhashtable; -typedef void exit_hctx_fn(struct blk_mq_hw_ctx *, unsigned int); +struct rhashtable_compare_arg { + struct rhashtable *ht; + const void *key; +}; -typedef int init_request_fn(struct blk_mq_tag_set *, struct request *, unsigned int, unsigned int); +typedef u32 (*rht_hashfn_t)(const void *, u32, u32); -typedef void exit_request_fn(struct blk_mq_tag_set *, struct request *, unsigned int); +typedef u32 (*rht_obj_hashfn_t)(const void *, u32, u32); -typedef void cleanup_rq_fn(struct request *); +typedef int (*rht_obj_cmpfn_t)(struct rhashtable_compare_arg *, const void *); -typedef bool busy_fn(struct request_queue *); +struct rhashtable_params { + u16 nelem_hint; + u16 key_len; + u16 key_offset; + u16 head_offset; + unsigned int max_size; + u16 min_size; + bool automatic_shrinking; + rht_hashfn_t hashfn; + rht_obj_hashfn_t obj_hashfn; + rht_obj_cmpfn_t obj_cmpfn; +}; -typedef int map_queues_fn(struct blk_mq_tag_set *); +struct bucket_table; -struct blk_mq_ops { - queue_rq_fn *queue_rq; - commit_rqs_fn *commit_rqs; - get_budget_fn *get_budget; - put_budget_fn *put_budget; - timeout_fn *timeout; - poll_fn *poll; - complete_fn *complete; - init_hctx_fn *init_hctx; - exit_hctx_fn *exit_hctx; - init_request_fn *init_request; - exit_request_fn *exit_request; - void (*initialize_rq_fn)(struct request *); - cleanup_rq_fn *cleanup_rq; - busy_fn *busy; - map_queues_fn *map_queues; - void (*show_rq)(struct seq_file *, struct request *); +struct rhashtable { + struct bucket_table *tbl; + unsigned int key_len; + unsigned int max_elems; + struct rhashtable_params p; + bool rhlist; + struct work_struct run_work; + struct mutex mutex; + spinlock_t lock; + atomic_t nelems; }; -enum pr_type { - PR_WRITE_EXCLUSIVE = 1, - PR_EXCLUSIVE_ACCESS = 2, - PR_WRITE_EXCLUSIVE_REG_ONLY = 3, - PR_EXCLUSIVE_ACCESS_REG_ONLY = 4, - PR_WRITE_EXCLUSIVE_ALL_REGS = 5, - PR_EXCLUSIVE_ACCESS_ALL_REGS = 6, -}; +struct rhash_lock_head; -struct pr_ops { - int (*pr_register)(struct block_device *, u64, u64, u32); - int (*pr_reserve)(struct block_device *, u64, enum pr_type, u32); - int (*pr_release)(struct block_device *, u64, enum pr_type); - int (*pr_preempt)(struct block_device *, u64, u64, enum pr_type, bool); - int (*pr_clear)(struct block_device *, u64); +struct bucket_table { + unsigned int size; + unsigned int nest; + u32 hash_rnd; + struct list_head walkers; + struct callback_head rcu; + struct bucket_table *future_tbl; + struct lockdep_map dep_map; + long: 64; + struct rhash_lock_head *buckets[0]; }; -enum cpu_idle_type { - CPU_IDLE = 0, - CPU_NOT_IDLE = 1, - CPU_NEWLY_IDLE = 2, - CPU_MAX_IDLE_TYPES = 3, +struct fs_struct { + int users; + spinlock_t lock; + seqcount_t seq; + int umask; + int in_exec; + struct path root; + struct path pwd; }; -typedef long unsigned int efi_status_t; +typedef u32 compat_uptr_t; -typedef u8 efi_bool_t; +struct compat_robust_list { + compat_uptr_t next; +}; -typedef u16 efi_char16_t; +typedef s32 compat_long_t; -typedef u64 efi_physical_addr_t; +struct compat_robust_list_head { + struct compat_robust_list list; + compat_long_t futex_offset; + compat_uptr_t list_op_pending; +}; -typedef void *efi_handle_t; +struct pipe_buffer; -typedef guid_t efi_guid_t; +struct pipe_inode_info { + struct mutex mutex; + wait_queue_head_t wait; + unsigned int head; + unsigned int tail; + unsigned int max_usage; + unsigned int ring_size; + unsigned int readers; + unsigned int writers; + unsigned int files; + unsigned int r_counter; + unsigned int w_counter; + struct page *tmp_page; + struct fasync_struct *fasync_readers; + struct fasync_struct *fasync_writers; + struct pipe_buffer *bufs; + struct user_struct *user; +}; -typedef struct { - u64 signature; - u32 revision; - u32 headersize; - u32 crc32; - u32 reserved; -} efi_table_hdr_t; +struct scatterlist { + long unsigned int page_link; + unsigned int offset; + unsigned int length; + dma_addr_t dma_address; + unsigned int dma_length; +}; -typedef struct { - u32 type; - u32 pad; - u64 phys_addr; - u64 virt_addr; - u64 num_pages; - u64 attribute; -} efi_memory_desc_t; +struct iovec { + void *iov_base; + __kernel_size_t iov_len; +}; -typedef struct { - efi_guid_t guid; - u32 headersize; - u32 flags; - u32 imagesize; -} efi_capsule_header_t; +struct kvec { + void *iov_base; + size_t iov_len; +}; -typedef struct { - u16 year; - u8 month; - u8 day; - u8 hour; - u8 minute; - u8 second; - u8 pad1; - u32 nanosecond; - s16 timezone; - u8 daylight; - u8 pad2; -} efi_time_t; +struct iov_iter { + unsigned int type; + size_t iov_offset; + size_t count; + union { + const struct iovec *iov; + const struct kvec *kvec; + const struct bio_vec *bvec; + struct pipe_inode_info *pipe; + }; + union { + long unsigned int nr_segs; + struct { + unsigned int head; + unsigned int start_head; + }; + }; +}; -typedef struct { - u32 resolution; - u32 accuracy; - u8 sets_to_zero; -} efi_time_cap_t; +typedef short unsigned int __kernel_sa_family_t; -typedef struct { - efi_table_hdr_t hdr; - void *raise_tpl; - void *restore_tpl; - efi_status_t (*allocate_pages)(int, int, long unsigned int, efi_physical_addr_t *); - efi_status_t (*free_pages)(efi_physical_addr_t, long unsigned int); - efi_status_t (*get_memory_map)(long unsigned int *, void *, long unsigned int *, long unsigned int *, u32 *); - efi_status_t (*allocate_pool)(int, long unsigned int, void **); - efi_status_t (*free_pool)(void *); - void *create_event; - void *set_timer; - void *wait_for_event; - void *signal_event; - void *close_event; - void *check_event; - void *install_protocol_interface; - void *reinstall_protocol_interface; - void *uninstall_protocol_interface; - efi_status_t (*handle_protocol)(efi_handle_t, efi_guid_t *, void **); - void *__reserved; - void *register_protocol_notify; - efi_status_t (*locate_handle)(int, efi_guid_t *, void *, long unsigned int *, efi_handle_t *); - void *locate_device_path; - efi_status_t (*install_configuration_table)(efi_guid_t *, void *); - void *load_image; - void *start_image; - void *exit; - void *unload_image; - efi_status_t (*exit_boot_services)(efi_handle_t, long unsigned int); - void *get_next_monotonic_count; - void *stall; - void *set_watchdog_timer; - void *connect_controller; - void *disconnect_controller; - void *open_protocol; - void *close_protocol; - void *open_protocol_information; - void *protocols_per_handle; - void *locate_handle_buffer; - efi_status_t (*locate_protocol)(efi_guid_t *, void *, void **); - void *install_multiple_protocol_interfaces; - void *uninstall_multiple_protocol_interfaces; - void *calculate_crc32; - void *copy_mem; - void *set_mem; - void *create_event_ex; -} efi_boot_services_t; +struct __kernel_sockaddr_storage { + union { + struct { + __kernel_sa_family_t ss_family; + char __data[126]; + }; + void *__align; + }; +}; -typedef efi_status_t efi_get_time_t(efi_time_t *, efi_time_cap_t *); +typedef __kernel_sa_family_t sa_family_t; -typedef efi_status_t efi_set_time_t(efi_time_t *); +struct sockaddr { + sa_family_t sa_family; + char sa_data[14]; +}; -typedef efi_status_t efi_get_wakeup_time_t(efi_bool_t *, efi_bool_t *, efi_time_t *); +struct msghdr { + void *msg_name; + int msg_namelen; + struct iov_iter msg_iter; + void *msg_control; + __kernel_size_t msg_controllen; + unsigned int msg_flags; + struct kiocb *msg_iocb; +}; -typedef efi_status_t efi_set_wakeup_time_t(efi_bool_t, efi_time_t *); +typedef struct { + unsigned int clock_rate; + unsigned int clock_type; + short unsigned int loopback; +} sync_serial_settings; -typedef efi_status_t efi_get_variable_t(efi_char16_t *, efi_guid_t *, u32 *, long unsigned int *, void *); +typedef struct { + unsigned int clock_rate; + unsigned int clock_type; + short unsigned int loopback; + unsigned int slot_map; +} te1_settings; -typedef efi_status_t efi_get_next_variable_t(long unsigned int *, efi_char16_t *, efi_guid_t *); +typedef struct { + short unsigned int encoding; + short unsigned int parity; +} raw_hdlc_proto; -typedef efi_status_t efi_set_variable_t(efi_char16_t *, efi_guid_t *, u32, long unsigned int, void *); +typedef struct { + unsigned int t391; + unsigned int t392; + unsigned int n391; + unsigned int n392; + unsigned int n393; + short unsigned int lmi; + short unsigned int dce; +} fr_proto; -typedef efi_status_t efi_get_next_high_mono_count_t(u32 *); +typedef struct { + unsigned int dlci; +} fr_proto_pvc; -typedef void efi_reset_system_t(int, efi_status_t, long unsigned int, efi_char16_t *); +typedef struct { + unsigned int dlci; + char master[16]; +} fr_proto_pvc_info; -typedef efi_status_t efi_set_virtual_address_map_t(long unsigned int, long unsigned int, u32, efi_memory_desc_t *); +typedef struct { + unsigned int interval; + unsigned int timeout; +} cisco_proto; -typedef efi_status_t efi_query_variable_info_t(u32, u64 *, u64 *, u64 *); +struct ifmap { + long unsigned int mem_start; + long unsigned int mem_end; + short unsigned int base_addr; + unsigned char irq; + unsigned char dma; + unsigned char port; +}; -typedef efi_status_t efi_update_capsule_t(efi_capsule_header_t **, long unsigned int, long unsigned int); +struct if_settings { + unsigned int type; + unsigned int size; + union { + raw_hdlc_proto *raw_hdlc; + cisco_proto *cisco; + fr_proto *fr; + fr_proto_pvc *fr_pvc; + fr_proto_pvc_info *fr_pvc_info; + sync_serial_settings *sync; + te1_settings *te1; + } ifs_ifsu; +}; -typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **, long unsigned int, u64 *, int *); +struct ifreq { + union { + char ifrn_name[16]; + } ifr_ifrn; + union { + struct sockaddr ifru_addr; + struct sockaddr ifru_dstaddr; + struct sockaddr ifru_broadaddr; + struct sockaddr ifru_netmask; + struct sockaddr ifru_hwaddr; + short int ifru_flags; + int ifru_ivalue; + int ifru_mtu; + struct ifmap ifru_map; + char ifru_slave[16]; + char ifru_newname[16]; + void *ifru_data; + struct if_settings ifru_settings; + } ifr_ifru; +}; -typedef struct { - efi_table_hdr_t hdr; - efi_get_time_t *get_time; - efi_set_time_t *set_time; - efi_get_wakeup_time_t *get_wakeup_time; - efi_set_wakeup_time_t *set_wakeup_time; - efi_set_virtual_address_map_t *set_virtual_address_map; - void *convert_pointer; - efi_get_variable_t *get_variable; - efi_get_next_variable_t *get_next_variable; - efi_set_variable_t *set_variable; - efi_get_next_high_mono_count_t *get_next_high_mono_count; - efi_reset_system_t *reset_system; - efi_update_capsule_t *update_capsule; - efi_query_capsule_caps_t *query_capsule_caps; - efi_query_variable_info_t *query_variable_info; -} efi_runtime_services_t; +struct vfsmount { + struct dentry *mnt_root; + struct super_block *mnt_sb; + int mnt_flags; +}; typedef struct { - efi_table_hdr_t hdr; - long unsigned int fw_vendor; - u32 fw_revision; - long unsigned int con_in_handle; - long unsigned int con_in; - long unsigned int con_out_handle; - long unsigned int con_out; - long unsigned int stderr_handle; - long unsigned int stderr; - efi_runtime_services_t *runtime; - efi_boot_services_t *boottime; - long unsigned int nr_tables; - long unsigned int tables; -} efi_system_table_t; + size_t written; + size_t count; + union { + char *buf; + void *data; + } arg; + int error; +} read_descriptor_t; -struct efi_memory_map { - phys_addr_t phys_map; - void *map; - void *map_end; - int nr_map; - long unsigned int desc_version; - long unsigned int desc_size; - bool late; +struct posix_acl_entry { + short int e_tag; + short unsigned int e_perm; + union { + kuid_t e_uid; + kgid_t e_gid; + }; }; -struct efi { - efi_system_table_t *systab; - unsigned int runtime_version; - long unsigned int mps; - long unsigned int acpi; - long unsigned int acpi20; - long unsigned int smbios; - long unsigned int smbios3; - long unsigned int boot_info; - long unsigned int hcdp; - long unsigned int uga; - long unsigned int fw_vendor; - long unsigned int runtime; - long unsigned int config_table; - long unsigned int esrt; - long unsigned int properties_table; - long unsigned int mem_attr_table; - long unsigned int rng_seed; - long unsigned int tpm_log; - long unsigned int tpm_final_log; - long unsigned int mem_reserve; - efi_get_time_t *get_time; - efi_set_time_t *set_time; - efi_get_wakeup_time_t *get_wakeup_time; - efi_set_wakeup_time_t *set_wakeup_time; - efi_get_variable_t *get_variable; - efi_get_next_variable_t *get_next_variable; - efi_set_variable_t *set_variable; - efi_set_variable_t *set_variable_nonblocking; - efi_query_variable_info_t *query_variable_info; - efi_query_variable_info_t *query_variable_info_nonblocking; - efi_update_capsule_t *update_capsule; - efi_query_capsule_caps_t *query_capsule_caps; - efi_get_next_high_mono_count_t *get_next_high_mono_count; - efi_reset_system_t *reset_system; - efi_set_virtual_address_map_t *set_virtual_address_map; - struct efi_memory_map memmap; - long unsigned int flags; +struct posix_acl { + refcount_t a_refcount; + struct callback_head a_rcu; + unsigned int a_count; + struct posix_acl_entry a_entries[0]; }; -struct percpu_cluster { - struct swap_cluster_info index; - unsigned int next; +typedef unsigned char cc_t; + +typedef unsigned int speed_t; + +typedef unsigned int tcflag_t; + +struct ktermios { + tcflag_t c_iflag; + tcflag_t c_oflag; + tcflag_t c_cflag; + tcflag_t c_lflag; + cc_t c_line; + cc_t c_cc[19]; + speed_t c_ispeed; + speed_t c_ospeed; }; -struct trace_event_raw_initcall_level { - struct trace_entry ent; - u32 __data_loc_level; - char __data[0]; +struct winsize { + short unsigned int ws_row; + short unsigned int ws_col; + short unsigned int ws_xpixel; + short unsigned int ws_ypixel; }; -struct trace_event_raw_initcall_start { - struct trace_entry ent; - initcall_t func; - char __data[0]; +struct termiox { + __u16 x_hflag; + __u16 x_cflag; + __u16 x_rflag[5]; + __u16 x_sflag; }; -struct trace_event_raw_initcall_finish { - struct trace_entry ent; - initcall_t func; - int ret; - char __data[0]; +struct serial_icounter_struct; + +struct serial_struct; + +struct tty_operations { + struct tty_struct * (*lookup)(struct tty_driver *, struct file *, int); + int (*install)(struct tty_driver *, struct tty_struct *); + void (*remove)(struct tty_driver *, struct tty_struct *); + int (*open)(struct tty_struct *, struct file *); + void (*close)(struct tty_struct *, struct file *); + void (*shutdown)(struct tty_struct *); + void (*cleanup)(struct tty_struct *); + int (*write)(struct tty_struct *, const unsigned char *, int); + int (*put_char)(struct tty_struct *, unsigned char); + void (*flush_chars)(struct tty_struct *); + int (*write_room)(struct tty_struct *); + int (*chars_in_buffer)(struct tty_struct *); + int (*ioctl)(struct tty_struct *, unsigned int, long unsigned int); + long int (*compat_ioctl)(struct tty_struct *, unsigned int, long unsigned int); + void (*set_termios)(struct tty_struct *, struct ktermios *); + void (*throttle)(struct tty_struct *); + void (*unthrottle)(struct tty_struct *); + void (*stop)(struct tty_struct *); + void (*start)(struct tty_struct *); + void (*hangup)(struct tty_struct *); + int (*break_ctl)(struct tty_struct *, int); + void (*flush_buffer)(struct tty_struct *); + void (*set_ldisc)(struct tty_struct *); + void (*wait_until_sent)(struct tty_struct *, int); + void (*send_xchar)(struct tty_struct *, char); + int (*tiocmget)(struct tty_struct *); + int (*tiocmset)(struct tty_struct *, unsigned int, unsigned int); + int (*resize)(struct tty_struct *, struct winsize *); + int (*set_termiox)(struct tty_struct *, struct termiox *); + int (*get_icount)(struct tty_struct *, struct serial_icounter_struct *); + int (*get_serial)(struct tty_struct *, struct serial_struct *); + int (*set_serial)(struct tty_struct *, struct serial_struct *); + void (*show_fdinfo)(struct tty_struct *, struct seq_file *); + int (*proc_show)(struct seq_file *, void *); }; -struct trace_event_data_offsets_initcall_level { - u32 level; +struct ld_semaphore { + atomic_long_t count; + raw_spinlock_t wait_lock; + unsigned int wait_readers; + struct list_head read_wait; + struct list_head write_wait; }; -struct trace_event_data_offsets_initcall_start {}; +struct tty_ldisc; -struct trace_event_data_offsets_initcall_finish {}; +struct tty_port; -struct blacklist_entry { - struct list_head next; - char *buf; +struct tty_struct { + int magic; + struct kref kref; + struct device *dev; + struct tty_driver *driver; + const struct tty_operations *ops; + int index; + struct ld_semaphore ldisc_sem; + struct tty_ldisc *ldisc; + struct mutex atomic_write_lock; + struct mutex legacy_mutex; + struct mutex throttle_mutex; + struct rw_semaphore termios_rwsem; + struct mutex winsize_mutex; + spinlock_t ctrl_lock; + spinlock_t flow_lock; + struct ktermios termios; + struct ktermios termios_locked; + struct termiox *termiox; + char name[64]; + struct pid *pgrp; + struct pid *session; + long unsigned int flags; + int count; + struct winsize winsize; + long unsigned int stopped: 1; + long unsigned int flow_stopped: 1; + int: 30; + long unsigned int unused: 62; + int hw_stopped; + long unsigned int ctrl_status: 8; + long unsigned int packet: 1; + int: 23; + long unsigned int unused_ctrl: 55; + unsigned int receive_room; + int flow_change; + struct tty_struct *link; + struct fasync_struct *fasync; + wait_queue_head_t write_wait; + wait_queue_head_t read_wait; + struct work_struct hangup_work; + void *disc_data; + void *driver_data; + spinlock_t files_lock; + struct list_head tty_files; + int closing; + unsigned char *write_buf; + int write_cnt; + struct work_struct SAK_work; + struct tty_port *port; }; -enum page_cache_mode { - _PAGE_CACHE_MODE_WB = 0, - _PAGE_CACHE_MODE_WC = 1, - _PAGE_CACHE_MODE_UC_MINUS = 2, - _PAGE_CACHE_MODE_UC = 3, - _PAGE_CACHE_MODE_WT = 4, - _PAGE_CACHE_MODE_WP = 5, - _PAGE_CACHE_MODE_NUM = 8, -}; +struct proc_dir_entry; -enum { - UNAME26 = 131072, - ADDR_NO_RANDOMIZE = 262144, - FDPIC_FUNCPTRS = 524288, - MMAP_PAGE_ZERO = 1048576, - ADDR_COMPAT_LAYOUT = 2097152, - READ_IMPLIES_EXEC = 4194304, - ADDR_LIMIT_32BIT = 8388608, - SHORT_INODE = 16777216, - WHOLE_SECONDS = 33554432, - STICKY_TIMEOUTS = 67108864, - ADDR_LIMIT_3GB = 134217728, +struct tty_driver { + int magic; + struct kref kref; + struct cdev **cdevs; + struct module *owner; + const char *driver_name; + const char *name; + int name_base; + int major; + int minor_start; + unsigned int num; + short int type; + short int subtype; + struct ktermios init_termios; + long unsigned int flags; + struct proc_dir_entry *proc_entry; + struct tty_driver *other; + struct tty_struct **ttys; + struct tty_port **ports; + struct ktermios **termios; + void *driver_state; + const struct tty_operations *ops; + struct list_head tty_drivers; }; -enum tlb_infos { - ENTRIES = 0, - NR_INFO = 1, +struct tty_buffer { + union { + struct tty_buffer *next; + struct llist_node free; + }; + int used; + int size; + int commit; + int read; + int flags; + long unsigned int data[0]; }; -enum { - MM_FILEPAGES = 0, - MM_ANONPAGES = 1, - MM_SWAPENTS = 2, - MM_SHMEMPAGES = 3, - NR_MM_COUNTERS = 4, +struct tty_bufhead { + struct tty_buffer *head; + struct work_struct work; + struct mutex lock; + atomic_t priority; + struct tty_buffer sentinel; + struct llist_head free; + atomic_t mem_used; + int mem_limit; + struct tty_buffer *tail; }; -typedef __u32 Elf32_Word; +struct tty_port_operations; -struct elf32_note { - Elf32_Word n_namesz; - Elf32_Word n_descsz; - Elf32_Word n_type; +struct tty_port_client_operations; + +struct tty_port { + struct tty_bufhead buf; + struct tty_struct *tty; + struct tty_struct *itty; + const struct tty_port_operations *ops; + const struct tty_port_client_operations *client_ops; + spinlock_t lock; + int blocked_open; + int count; + wait_queue_head_t open_wait; + wait_queue_head_t delta_msr_wait; + long unsigned int flags; + long unsigned int iflags; + unsigned char console: 1; + unsigned char low_latency: 1; + struct mutex mutex; + struct mutex buf_mutex; + unsigned char *xmit_buf; + unsigned int close_delay; + unsigned int closing_wait; + int drain_delay; + struct kref kref; + void *client_data; }; -enum pcpu_fc { - PCPU_FC_AUTO = 0, - PCPU_FC_EMBED = 1, - PCPU_FC_PAGE = 2, - PCPU_FC_NR = 3, +struct tty_ldisc_ops { + int magic; + char *name; + int num; + int flags; + int (*open)(struct tty_struct *); + void (*close)(struct tty_struct *); + void (*flush_buffer)(struct tty_struct *); + ssize_t (*read)(struct tty_struct *, struct file *, unsigned char *, size_t); + ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t); + int (*ioctl)(struct tty_struct *, struct file *, unsigned int, long unsigned int); + int (*compat_ioctl)(struct tty_struct *, struct file *, unsigned int, long unsigned int); + void (*set_termios)(struct tty_struct *, struct ktermios *); + __poll_t (*poll)(struct tty_struct *, struct file *, struct poll_table_struct *); + int (*hangup)(struct tty_struct *); + void (*receive_buf)(struct tty_struct *, const unsigned char *, char *, int); + void (*write_wakeup)(struct tty_struct *); + void (*dcd_change)(struct tty_struct *, unsigned int); + int (*receive_buf2)(struct tty_struct *, const unsigned char *, char *, int); + struct module *owner; + int refcount; }; -enum hrtimer_base_type { - HRTIMER_BASE_MONOTONIC = 0, - HRTIMER_BASE_REALTIME = 1, - HRTIMER_BASE_BOOTTIME = 2, - HRTIMER_BASE_TAI = 3, - HRTIMER_BASE_MONOTONIC_SOFT = 4, - HRTIMER_BASE_REALTIME_SOFT = 5, - HRTIMER_BASE_BOOTTIME_SOFT = 6, - HRTIMER_BASE_TAI_SOFT = 7, - HRTIMER_MAX_CLOCK_BASES = 8, +struct tty_ldisc { + struct tty_ldisc_ops *ops; + struct tty_struct *tty; }; -enum rseq_cs_flags_bit { - RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT_BIT = 0, - RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL_BIT = 1, - RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT = 2, +struct tty_port_operations { + int (*carrier_raised)(struct tty_port *); + void (*dtr_rts)(struct tty_port *, int); + void (*shutdown)(struct tty_port *); + int (*activate)(struct tty_port *, struct tty_struct *); + void (*destruct)(struct tty_port *); }; -enum perf_event_task_context { - perf_invalid_context = 4294967295, - perf_hw_context = 0, - perf_sw_context = 1, - perf_nr_task_contexts = 2, +struct tty_port_client_operations { + int (*receive_buf)(struct tty_port *, const unsigned char *, const unsigned char *, size_t); + void (*write_wakeup)(struct tty_port *); }; -enum rseq_event_mask_bits { - RSEQ_EVENT_PREEMPT_BIT = 0, - RSEQ_EVENT_SIGNAL_BIT = 1, - RSEQ_EVENT_MIGRATE_BIT = 2, -}; +struct prot_inuse; -enum { - PROC_ROOT_INO = 1, - PROC_IPC_INIT_INO = 4026531839, - PROC_UTS_INIT_INO = 4026531838, - PROC_USER_INIT_INO = 4026531837, - PROC_PID_INIT_INO = 4026531836, - PROC_CGROUP_INIT_INO = 4026531835, +struct netns_core { + struct ctl_table_header *sysctl_hdr; + int sysctl_somaxconn; + int *sock_inuse; + struct prot_inuse *prot_inuse; }; -typedef __u16 __le16; +struct tcp_mib; -typedef __u16 __be16; +struct ipstats_mib; -typedef __u32 __be32; +struct linux_mib; -typedef __u64 __be64; +struct udp_mib; -typedef __u32 __wsum; +struct icmp_mib; -typedef unsigned int slab_flags_t; +struct icmpmsg_mib; -struct notifier_block; +struct icmpv6_mib; -typedef int (*notifier_fn_t)(struct notifier_block *, long unsigned int, void *); +struct icmpv6msg_mib; -struct notifier_block { - notifier_fn_t notifier_call; - struct notifier_block *next; - int priority; +struct netns_mib { + struct tcp_mib *tcp_statistics; + struct ipstats_mib *ip_statistics; + struct linux_mib *net_statistics; + struct udp_mib *udp_statistics; + struct udp_mib *udplite_statistics; + struct icmp_mib *icmp_statistics; + struct icmpmsg_mib *icmpmsg_statistics; + struct proc_dir_entry *proc_net_devsnmp6; + struct udp_mib *udp_stats_in6; + struct udp_mib *udplite_stats_in6; + struct ipstats_mib *ipv6_statistics; + struct icmpv6_mib *icmpv6_statistics; + struct icmpv6msg_mib *icmpv6msg_statistics; }; -struct raw_notifier_head { - struct notifier_block *head; +struct netns_packet { + struct mutex sklist_lock; + struct hlist_head sklist; }; -struct llist_head { - struct llist_node *first; +struct netns_unix { + int sysctl_max_dgram_qlen; + struct ctl_table_header *ctl; }; -typedef struct __call_single_data call_single_data_t; - -typedef __u64 __addrpair; - -typedef __u32 __portpair; - -typedef struct { - struct net *net; -} possible_net_t; - -struct in6_addr { - union { - __u8 u6_addr8[16]; - __be16 u6_addr16[8]; - __be32 u6_addr32[4]; - } in6_u; +struct netns_nexthop { + struct rb_root rb_root; + struct hlist_head *devhash; + unsigned int seq; + u32 last_id_allocated; }; -struct hlist_nulls_node { - struct hlist_nulls_node *next; - struct hlist_nulls_node **pprev; +struct local_ports { + seqlock_t lock; + int range[2]; + bool warned; }; -struct proto; +struct inet_hashinfo; -struct inet_timewait_death_row; +struct inet_timewait_death_row { + atomic_t tw_count; + long: 32; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct inet_hashinfo *hashinfo; + int sysctl_max_tw_buckets; + long: 32; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; -struct sock_common { - union { - __addrpair skc_addrpair; - struct { - __be32 skc_daddr; - __be32 skc_rcv_saddr; - }; - }; - union { - unsigned int skc_hash; - __u16 skc_u16hashes[2]; - }; - union { - __portpair skc_portpair; - struct { - __be16 skc_dport; - __u16 skc_num; - }; - }; - short unsigned int skc_family; - volatile unsigned char skc_state; - unsigned char skc_reuse: 4; - unsigned char skc_reuseport: 1; - unsigned char skc_ipv6only: 1; - unsigned char skc_net_refcnt: 1; - int skc_bound_dev_if; - union { - struct hlist_node skc_bind_node; - struct hlist_node skc_portaddr_node; - }; - struct proto *skc_prot; - possible_net_t skc_net; - struct in6_addr skc_v6_daddr; - struct in6_addr skc_v6_rcv_saddr; - atomic64_t skc_cookie; - union { - long unsigned int skc_flags; - struct sock *skc_listener; - struct inet_timewait_death_row *skc_tw_dr; - }; - int skc_dontcopy_begin[0]; - union { - struct hlist_node skc_node; - struct hlist_nulls_node skc_nulls_node; - }; - short unsigned int skc_tx_queue_mapping; - short unsigned int skc_rx_queue_mapping; - union { - int skc_incoming_cpu; - u32 skc_rcv_wnd; - u32 skc_tw_rcv_nxt; - }; - refcount_t skc_refcnt; - int skc_dontcopy_end[0]; - union { - u32 skc_rxhash; - u32 skc_window_clamp; - u32 skc_tw_snd_nxt; - }; +struct ping_group_range { + seqlock_t lock; + kgid_t range[2]; }; typedef struct { - spinlock_t slock; - int owned; - wait_queue_head_t wq; -} socket_lock_t; + u64 key[2]; +} siphash_key_t; -struct sk_buff; +struct ipv4_devconf; -struct sk_buff_head { - struct sk_buff *next; - struct sk_buff *prev; - __u32 qlen; - spinlock_t lock; -}; +struct ip_ra_chain; -typedef u64 netdev_features_t; +struct fib_rules_ops; -struct sock_cgroup_data {}; +struct fib_table; -struct sk_filter; +struct inet_peer_base; -struct socket_wq; +struct fqdir; -struct xfrm_policy; +struct xt_table; -struct dst_entry; +struct tcp_congestion_ops; -struct socket; +struct tcp_fastopen_context; -struct sock_reuseport; +struct mr_table; -struct sock { - struct sock_common __sk_common; - socket_lock_t sk_lock; - atomic_t sk_drops; - int sk_rcvlowat; - struct sk_buff_head sk_error_queue; - struct sk_buff *sk_rx_skb_cache; - struct sk_buff_head sk_receive_queue; - struct { - atomic_t rmem_alloc; - int len; - struct sk_buff *head; - struct sk_buff *tail; - } sk_backlog; - int sk_forward_alloc; - unsigned int sk_ll_usec; - unsigned int sk_napi_id; - int sk_rcvbuf; - struct sk_filter *sk_filter; - union { - struct socket_wq *sk_wq; - struct socket_wq *sk_wq_raw; - }; - struct xfrm_policy *sk_policy[2]; - struct dst_entry *sk_rx_dst; - struct dst_entry *sk_dst_cache; - atomic_t sk_omem_alloc; - int sk_sndbuf; - int sk_wmem_queued; - refcount_t sk_wmem_alloc; - long unsigned int sk_tsq_flags; - union { - struct sk_buff *sk_send_head; - struct rb_root tcp_rtx_queue; - }; - struct sk_buff *sk_tx_skb_cache; - struct sk_buff_head sk_write_queue; - __s32 sk_peek_off; - int sk_write_pending; - __u32 sk_dst_pending_confirm; - u32 sk_pacing_status; - long int sk_sndtimeo; - struct timer_list sk_timer; - __u32 sk_priority; - __u32 sk_mark; - long unsigned int sk_pacing_rate; - long unsigned int sk_max_pacing_rate; - struct page_frag sk_frag; - netdev_features_t sk_route_caps; - netdev_features_t sk_route_nocaps; - netdev_features_t sk_route_forced_caps; - int sk_gso_type; - unsigned int sk_gso_max_size; - gfp_t sk_allocation; - __u32 sk_txhash; - unsigned int __sk_flags_offset[0]; - unsigned int sk_padding: 1; - unsigned int sk_kern_sock: 1; - unsigned int sk_no_check_tx: 1; - unsigned int sk_no_check_rx: 1; - unsigned int sk_userlocks: 4; - unsigned int sk_protocol: 8; - unsigned int sk_type: 16; - u16 sk_gso_max_segs; - u8 sk_pacing_shift; - long unsigned int sk_lingertime; - struct proto *sk_prot_creator; - rwlock_t sk_callback_lock; - int sk_err; - int sk_err_soft; - u32 sk_ack_backlog; - u32 sk_max_ack_backlog; - kuid_t sk_uid; - struct pid *sk_peer_pid; - const struct cred *sk_peer_cred; - long int sk_rcvtimeo; - ktime_t sk_stamp; - u16 sk_tsflags; - u8 sk_shutdown; - u32 sk_tskey; - atomic_t sk_zckey; - u8 sk_clockid; - u8 sk_txtime_deadline_mode: 1; - u8 sk_txtime_report_errors: 1; - u8 sk_txtime_unused: 6; - struct socket *sk_socket; - void *sk_user_data; - void *sk_security; - struct sock_cgroup_data sk_cgrp_data; - struct mem_cgroup *sk_memcg; - void (*sk_state_change)(struct sock *); - void (*sk_data_ready)(struct sock *); - void (*sk_write_space)(struct sock *); - void (*sk_error_report)(struct sock *); - int (*sk_backlog_rcv)(struct sock *, struct sk_buff *); - void (*sk_destruct)(struct sock *); - struct sock_reuseport *sk_reuseport_cb; - struct callback_head sk_rcu; +struct fib_notifier_ops; + +struct netns_ipv4 { + struct ctl_table_header *forw_hdr; + struct ctl_table_header *frags_hdr; + struct ctl_table_header *ipv4_hdr; + struct ctl_table_header *route_hdr; + struct ctl_table_header *xfrm4_hdr; + struct ipv4_devconf *devconf_all; + struct ipv4_devconf *devconf_dflt; + struct ip_ra_chain *ra_chain; + struct mutex ra_mutex; + struct fib_rules_ops *rules_ops; + bool fib_has_custom_rules; + unsigned int fib_rules_require_fldissect; + struct fib_table *fib_main; + struct fib_table *fib_default; + bool fib_has_custom_local_routes; + struct hlist_head *fib_table_hash; + bool fib_offload_disabled; + struct sock *fibnl; + struct sock **icmp_sk; + struct sock *mc_autojoin_sk; + struct inet_peer_base *peers; + struct sock **tcp_sk; + struct fqdir *fqdir; + struct xt_table *iptable_filter; + struct xt_table *iptable_mangle; + struct xt_table *iptable_raw; + struct xt_table *arptable_filter; + struct xt_table *iptable_security; + struct xt_table *nat_table; + int sysctl_icmp_echo_ignore_all; + int sysctl_icmp_echo_ignore_broadcasts; + int sysctl_icmp_ignore_bogus_error_responses; + int sysctl_icmp_ratelimit; + int sysctl_icmp_ratemask; + int sysctl_icmp_errors_use_inbound_ifaddr; + struct local_ports ip_local_ports; + int sysctl_tcp_ecn; + int sysctl_tcp_ecn_fallback; + int sysctl_ip_default_ttl; + int sysctl_ip_no_pmtu_disc; + int sysctl_ip_fwd_use_pmtu; + int sysctl_ip_fwd_update_priority; + int sysctl_ip_nonlocal_bind; + int sysctl_ip_dynaddr; + int sysctl_ip_early_demux; + int sysctl_tcp_early_demux; + int sysctl_udp_early_demux; + int sysctl_fwmark_reflect; + int sysctl_tcp_fwmark_accept; + int sysctl_tcp_mtu_probing; + int sysctl_tcp_mtu_probe_floor; + int sysctl_tcp_base_mss; + int sysctl_tcp_min_snd_mss; + int sysctl_tcp_probe_threshold; + u32 sysctl_tcp_probe_interval; + int sysctl_tcp_keepalive_time; + int sysctl_tcp_keepalive_probes; + int sysctl_tcp_keepalive_intvl; + int sysctl_tcp_syn_retries; + int sysctl_tcp_synack_retries; + int sysctl_tcp_syncookies; + int sysctl_tcp_reordering; + int sysctl_tcp_retries1; + int sysctl_tcp_retries2; + int sysctl_tcp_orphan_retries; + int sysctl_tcp_fin_timeout; + unsigned int sysctl_tcp_notsent_lowat; + int sysctl_tcp_tw_reuse; + int sysctl_tcp_sack; + int sysctl_tcp_window_scaling; + int sysctl_tcp_timestamps; + int sysctl_tcp_early_retrans; + int sysctl_tcp_recovery; + int sysctl_tcp_thin_linear_timeouts; + int sysctl_tcp_slow_start_after_idle; + int sysctl_tcp_retrans_collapse; + int sysctl_tcp_stdurg; + int sysctl_tcp_rfc1337; + int sysctl_tcp_abort_on_overflow; + int sysctl_tcp_fack; + int sysctl_tcp_max_reordering; + int sysctl_tcp_dsack; + int sysctl_tcp_app_win; + int sysctl_tcp_adv_win_scale; + int sysctl_tcp_frto; + int sysctl_tcp_nometrics_save; + int sysctl_tcp_moderate_rcvbuf; + int sysctl_tcp_tso_win_divisor; + int sysctl_tcp_workaround_signed_windows; + int sysctl_tcp_limit_output_bytes; + int sysctl_tcp_challenge_ack_limit; + int sysctl_tcp_min_tso_segs; + int sysctl_tcp_min_rtt_wlen; + int sysctl_tcp_autocorking; + int sysctl_tcp_invalid_ratelimit; + int sysctl_tcp_pacing_ss_ratio; + int sysctl_tcp_pacing_ca_ratio; + int sysctl_tcp_wmem[3]; + int sysctl_tcp_rmem[3]; + int sysctl_tcp_comp_sack_nr; + long unsigned int sysctl_tcp_comp_sack_delay_ns; + struct inet_timewait_death_row tcp_death_row; + int sysctl_max_syn_backlog; + int sysctl_tcp_fastopen; + const struct tcp_congestion_ops *tcp_congestion_control; + struct tcp_fastopen_context *tcp_fastopen_ctx; + spinlock_t tcp_fastopen_ctx_lock; + unsigned int sysctl_tcp_fastopen_blackhole_timeout; + atomic_t tfo_active_disable_times; + long unsigned int tfo_active_disable_stamp; + int sysctl_udp_wmem_min; + int sysctl_udp_rmem_min; + int sysctl_igmp_max_memberships; + int sysctl_igmp_max_msf; + int sysctl_igmp_llm_reports; + int sysctl_igmp_qrv; + struct ping_group_range ping_group_range; + atomic_t dev_addr_genid; + long unsigned int *sysctl_local_reserved_ports; + int sysctl_ip_prot_sock; + struct mr_table *mrt; + int sysctl_fib_multipath_use_neigh; + int sysctl_fib_multipath_hash_policy; + struct fib_notifier_ops *notifier_ops; + unsigned int fib_seq; + struct fib_notifier_ops *ipmr_notifier_ops; + unsigned int ipmr_seq; + atomic_t rt_genid; + siphash_key_t ip_id_key; + long: 64; + long: 64; }; -struct rhash_head { - struct rhash_head *next; +struct netns_sysctl_ipv6 { + struct ctl_table_header *hdr; + struct ctl_table_header *route_hdr; + struct ctl_table_header *icmp_hdr; + struct ctl_table_header *frags_hdr; + struct ctl_table_header *xfrm6_hdr; + int bindv6only; + int flush_delay; + int ip6_rt_max_size; + int ip6_rt_gc_min_interval; + int ip6_rt_gc_timeout; + int ip6_rt_gc_interval; + int ip6_rt_gc_elasticity; + int ip6_rt_mtu_expires; + int ip6_rt_min_advmss; + int multipath_hash_policy; + int flowlabel_consistency; + int auto_flowlabels; + int icmpv6_time; + int icmpv6_echo_ignore_all; + int icmpv6_echo_ignore_multicast; + int icmpv6_echo_ignore_anycast; + long unsigned int icmpv6_ratemask[4]; + long unsigned int *icmpv6_ratemask_ptr; + int anycast_src_echo_reply; + int ip_nonlocal_bind; + int fwmark_reflect; + int idgen_retries; + int idgen_delay; + int flowlabel_state_ranges; + int flowlabel_reflect; + int max_dst_opts_cnt; + int max_hbh_opts_cnt; + int max_dst_opts_len; + int max_hbh_opts_len; + int seg6_flowlabel; + bool skip_notify_on_dev_down; }; -struct rhashtable; +struct neighbour; -struct rhashtable_compare_arg { - struct rhashtable *ht; - const void *key; +struct dst_ops { + short unsigned int family; + unsigned int gc_thresh; + int (*gc)(struct dst_ops *); + struct dst_entry * (*check)(struct dst_entry *, __u32); + unsigned int (*default_advmss)(const struct dst_entry *); + unsigned int (*mtu)(const struct dst_entry *); + u32 * (*cow_metrics)(struct dst_entry *, long unsigned int); + void (*destroy)(struct dst_entry *); + void (*ifdown)(struct dst_entry *, struct net_device *, int); + struct dst_entry * (*negative_advice)(struct dst_entry *); + void (*link_failure)(struct sk_buff *); + void (*update_pmtu)(struct dst_entry *, struct sock *, struct sk_buff *, u32, bool); + void (*redirect)(struct dst_entry *, struct sock *, struct sk_buff *); + int (*local_out)(struct net *, struct sock *, struct sk_buff *); + struct neighbour * (*neigh_lookup)(const struct dst_entry *, struct sk_buff *, const void *); + void (*confirm_neigh)(const struct dst_entry *, const void *); + struct kmem_cache *kmem_cachep; + struct percpu_counter pcpuc_entries; + long: 64; + long: 64; + long: 64; }; -typedef u32 (*rht_hashfn_t)(const void *, u32, u32); - -typedef u32 (*rht_obj_hashfn_t)(const void *, u32, u32); +struct ipv6_devconf; -typedef int (*rht_obj_cmpfn_t)(struct rhashtable_compare_arg *, const void *); +struct fib6_info; -struct rhashtable_params { - u16 nelem_hint; - u16 key_len; - u16 key_offset; - u16 head_offset; - unsigned int max_size; - u16 min_size; - bool automatic_shrinking; - rht_hashfn_t hashfn; - rht_obj_hashfn_t obj_hashfn; - rht_obj_cmpfn_t obj_cmpfn; -}; +struct rt6_info; -struct bucket_table; +struct rt6_statistics; -struct rhashtable { - struct bucket_table *tbl; - unsigned int key_len; - unsigned int max_elems; - struct rhashtable_params p; - bool rhlist; - struct work_struct run_work; - struct mutex mutex; - spinlock_t lock; - atomic_t nelems; -}; +struct fib6_table; -struct rhash_lock_head; +struct seg6_pernet_data; -struct bucket_table { - unsigned int size; - unsigned int nest; - u32 hash_rnd; - struct list_head walkers; - struct callback_head rcu; - struct bucket_table *future_tbl; - struct lockdep_map dep_map; +struct netns_ipv6 { + struct netns_sysctl_ipv6 sysctl; + struct ipv6_devconf *devconf_all; + struct ipv6_devconf *devconf_dflt; + struct inet_peer_base *peers; + struct fqdir *fqdir; + struct xt_table *ip6table_filter; + struct xt_table *ip6table_mangle; + struct xt_table *ip6table_raw; + struct xt_table *ip6table_security; + struct xt_table *ip6table_nat; + struct fib6_info *fib6_null_entry; + struct rt6_info *ip6_null_entry; + struct rt6_statistics *rt6_stats; + struct timer_list ip6_fib_timer; + struct hlist_head *fib_table_hash; + struct fib6_table *fib6_main_tbl; + struct list_head fib6_walkers; + long: 64; + long: 64; + struct dst_ops ip6_dst_ops; + rwlock_t fib6_walker_lock; + spinlock_t fib6_gc_lock; + unsigned int ip6_rt_gc_expire; + long unsigned int ip6_rt_last_gc; + unsigned int fib6_rules_require_fldissect; + bool fib6_has_custom_rules; + struct rt6_info *ip6_prohibit_entry; + struct rt6_info *ip6_blk_hole_entry; + struct fib6_table *fib6_local_tbl; + struct fib_rules_ops *fib6_rules_ops; + struct sock **icmp_sk; + struct sock *ndisc_sk; + struct sock *tcp_sk; + struct sock *igmp_sk; + struct sock *mc_autojoin_sk; + atomic_t dev_addr_genid; + atomic_t fib6_sernum; + struct seg6_pernet_data *seg6_data; + struct fib_notifier_ops *notifier_ops; + struct fib_notifier_ops *ip6mr_notifier_ops; + unsigned int ipmr_seq; + struct { + struct hlist_head head; + spinlock_t lock; + u32 seq; + } ip6addrlbl_table; + long: 64; + long: 64; + long: 64; long: 64; - struct rhash_lock_head *buckets[0]; }; -struct fs_struct { - int users; - spinlock_t lock; - seqcount_t seq; - int umask; - int in_exec; - struct path root; - struct path pwd; -}; +struct nf_queue_handler; -typedef u32 compat_uptr_t; +struct nf_logger; -struct compat_robust_list { - compat_uptr_t next; +struct nf_hook_entries; + +struct netns_nf { + struct proc_dir_entry *proc_netfilter; + const struct nf_queue_handler *queue_handler; + const struct nf_logger *nf_loggers[13]; + struct ctl_table_header *nf_log_dir_header; + struct nf_hook_entries *hooks_ipv4[5]; + struct nf_hook_entries *hooks_ipv6[5]; + bool defrag_ipv4; + bool defrag_ipv6; }; -typedef s32 compat_long_t; +struct netns_xt { + struct list_head tables[13]; + bool notrack_deprecated_warning; + bool clusterip_deprecated_warning; +}; -struct compat_robust_list_head { - struct compat_robust_list list; - compat_long_t futex_offset; - compat_uptr_t list_op_pending; +struct nf_ct_event_notifier; + +struct nf_exp_event_notifier; + +struct nf_generic_net { + unsigned int timeout; }; -struct pipe_buffer; +struct nf_tcp_net { + unsigned int timeouts[14]; + int tcp_loose; + int tcp_be_liberal; + int tcp_max_retrans; +}; -struct pipe_inode_info { - struct mutex mutex; - wait_queue_head_t wait; - unsigned int head; - unsigned int tail; - unsigned int max_usage; - unsigned int ring_size; - unsigned int readers; - unsigned int writers; - unsigned int files; - unsigned int r_counter; - unsigned int w_counter; - struct page *tmp_page; - struct fasync_struct *fasync_readers; - struct fasync_struct *fasync_writers; - struct pipe_buffer *bufs; - struct user_struct *user; +struct nf_udp_net { + unsigned int timeouts[2]; }; -struct scatterlist { - long unsigned int page_link; - unsigned int offset; - unsigned int length; - dma_addr_t dma_address; - unsigned int dma_length; +struct nf_icmp_net { + unsigned int timeout; }; -struct iovec { - void *iov_base; - __kernel_size_t iov_len; +struct nf_dccp_net { + int dccp_loose; + unsigned int dccp_timeout[10]; }; -struct kvec { - void *iov_base; - size_t iov_len; +struct nf_sctp_net { + unsigned int timeouts[10]; }; -struct iov_iter { - unsigned int type; - size_t iov_offset; - size_t count; - union { - const struct iovec *iov; - const struct kvec *kvec; - const struct bio_vec *bvec; - struct pipe_inode_info *pipe; - }; - union { - long unsigned int nr_segs; - struct { - unsigned int head; - unsigned int start_head; - }; - }; +struct nf_ip_net { + struct nf_generic_net generic; + struct nf_tcp_net tcp; + struct nf_udp_net udp; + struct nf_icmp_net icmp; + struct nf_icmp_net icmpv6; + struct nf_dccp_net dccp; + struct nf_sctp_net sctp; }; -typedef short unsigned int __kernel_sa_family_t; +struct ct_pcpu; -typedef __kernel_sa_family_t sa_family_t; +struct ip_conntrack_stat; -struct sockaddr { - sa_family_t sa_family; - char sa_data[14]; +struct netns_ct { + atomic_t count; + unsigned int expect_count; + bool auto_assign_helper_warned; + struct ctl_table_header *sysctl_header; + unsigned int sysctl_log_invalid; + int sysctl_events; + int sysctl_acct; + int sysctl_auto_assign_helper; + int sysctl_tstamp; + int sysctl_checksum; + struct ct_pcpu *pcpu_lists; + struct ip_conntrack_stat *stat; + struct nf_ct_event_notifier *nf_conntrack_event_cb; + struct nf_exp_event_notifier *nf_expect_event_cb; + struct nf_ip_net nf_ct_proto; }; -struct msghdr { - void *msg_name; - int msg_namelen; - struct iov_iter msg_iter; - void *msg_control; - __kernel_size_t msg_controllen; - unsigned int msg_flags; - struct kiocb *msg_iocb; +struct netns_nf_frag { + struct fqdir *fqdir; }; -typedef struct { - unsigned int clock_rate; - unsigned int clock_type; - short unsigned int loopback; -} sync_serial_settings; +struct xfrm_policy_hash { + struct hlist_head *table; + unsigned int hmask; + u8 dbits4; + u8 sbits4; + u8 dbits6; + u8 sbits6; +}; -typedef struct { - unsigned int clock_rate; - unsigned int clock_type; - short unsigned int loopback; - unsigned int slot_map; -} te1_settings; +struct xfrm_policy_hthresh { + struct work_struct work; + seqlock_t lock; + u8 lbits4; + u8 rbits4; + u8 lbits6; + u8 rbits6; +}; -typedef struct { - short unsigned int encoding; - short unsigned int parity; -} raw_hdlc_proto; +struct netns_xfrm { + struct list_head state_all; + struct hlist_head *state_bydst; + struct hlist_head *state_bysrc; + struct hlist_head *state_byspi; + unsigned int state_hmask; + unsigned int state_num; + struct work_struct state_hash_work; + struct list_head policy_all; + struct hlist_head *policy_byidx; + unsigned int policy_idx_hmask; + struct hlist_head policy_inexact[3]; + struct xfrm_policy_hash policy_bydst[3]; + unsigned int policy_count[6]; + struct work_struct policy_hash_work; + struct xfrm_policy_hthresh policy_hthresh; + struct list_head inexact_bins; + struct sock *nlsk; + struct sock *nlsk_stash; + u32 sysctl_aevent_etime; + u32 sysctl_aevent_rseqth; + int sysctl_larval_drop; + u32 sysctl_acq_expires; + struct ctl_table_header *sysctl_hdr; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct dst_ops xfrm4_dst_ops; + struct dst_ops xfrm6_dst_ops; + spinlock_t xfrm_state_lock; + spinlock_t xfrm_policy_lock; + struct mutex xfrm_cfg_mutex; + long: 64; + long: 64; + long: 64; +}; -typedef struct { - unsigned int t391; - unsigned int t392; - unsigned int n391; - unsigned int n392; - unsigned int n393; - short unsigned int lmi; - short unsigned int dce; -} fr_proto; +struct netns_xdp { + struct mutex lock; + struct hlist_head list; +}; -typedef struct { - unsigned int dlci; -} fr_proto_pvc; +struct uevent_sock; -typedef struct { - unsigned int dlci; - char master[16]; -} fr_proto_pvc_info; +struct net_generic; + +struct net { + refcount_t passive; + refcount_t count; + spinlock_t rules_mod_lock; + unsigned int dev_unreg_count; + unsigned int dev_base_seq; + int ifindex; + spinlock_t nsid_lock; + atomic_t fnhe_genid; + struct list_head list; + struct list_head exit_list; + struct llist_node cleanup_list; + struct key_tag *key_domain; + struct user_namespace *user_ns; + struct ucounts *ucounts; + struct idr netns_ids; + struct ns_common ns; + struct list_head dev_base_head; + struct proc_dir_entry *proc_net; + struct proc_dir_entry *proc_net_stat; + struct ctl_table_set sysctls; + struct sock *rtnl; + struct sock *genl_sock; + struct uevent_sock *uevent_sock; + struct hlist_head *dev_name_head; + struct hlist_head *dev_index_head; + struct raw_notifier_head netdev_chain; + u32 hash_mix; + struct net_device *loopback_dev; + struct list_head rules_ops; + struct netns_core core; + struct netns_mib mib; + struct netns_packet packet; + struct netns_unix unx; + struct netns_nexthop nexthop; + long: 64; + struct netns_ipv4 ipv4; + struct netns_ipv6 ipv6; + struct netns_nf nf; + struct netns_xt xt; + struct netns_ct ct; + struct netns_nf_frag nf_frag; + struct ctl_table_header *nf_frag_frags_hdr; + struct sock *nfnl; + struct sock *nfnl_stash; + struct net_generic *gen; + struct bpf_prog *flow_dissector_prog; + long: 64; + long: 64; + long: 64; + long: 64; + struct netns_xfrm xfrm; + struct netns_xdp xdp; + struct sock *diag_nlsk; + long: 64; + long: 64; +}; typedef struct { - unsigned int interval; - unsigned int timeout; -} cisco_proto; + local64_t v; +} u64_stats_t; -struct ifmap { - long unsigned int mem_start; - long unsigned int mem_end; - short unsigned int base_addr; - unsigned char irq; - unsigned char dma; - unsigned char port; -}; +struct bpf_offloaded_map; -struct if_settings { - unsigned int type; - unsigned int size; - union { - raw_hdlc_proto *raw_hdlc; - cisco_proto *cisco; - fr_proto *fr; - fr_proto_pvc *fr_pvc; - fr_proto_pvc_info *fr_pvc_info; - sync_serial_settings *sync; - te1_settings *te1; - } ifs_ifsu; +struct bpf_map_dev_ops { + int (*map_get_next_key)(struct bpf_offloaded_map *, void *, void *); + int (*map_lookup_elem)(struct bpf_offloaded_map *, void *, void *); + int (*map_update_elem)(struct bpf_offloaded_map *, void *, void *, u64); + int (*map_delete_elem)(struct bpf_offloaded_map *, void *); }; -struct ifreq { - union { - char ifrn_name[16]; - } ifr_ifrn; - union { - struct sockaddr ifru_addr; - struct sockaddr ifru_dstaddr; - struct sockaddr ifru_broadaddr; - struct sockaddr ifru_netmask; - struct sockaddr ifru_hwaddr; - short int ifru_flags; - int ifru_ivalue; - int ifru_mtu; - struct ifmap ifru_map; - char ifru_slave[16]; - char ifru_newname[16]; - void *ifru_data; - struct if_settings ifru_settings; - } ifr_ifru; +struct bpf_offloaded_map { + struct bpf_map map; + struct net_device *netdev; + const struct bpf_map_dev_ops *dev_ops; + void *dev_priv; + struct list_head offloads; + long: 64; + long: 64; + long: 64; }; -struct vfsmount { - struct dentry *mnt_root; - struct super_block *mnt_sb; - int mnt_flags; +struct net_device_stats { + long unsigned int rx_packets; + long unsigned int tx_packets; + long unsigned int rx_bytes; + long unsigned int tx_bytes; + long unsigned int rx_errors; + long unsigned int tx_errors; + long unsigned int rx_dropped; + long unsigned int tx_dropped; + long unsigned int multicast; + long unsigned int collisions; + long unsigned int rx_length_errors; + long unsigned int rx_over_errors; + long unsigned int rx_crc_errors; + long unsigned int rx_frame_errors; + long unsigned int rx_fifo_errors; + long unsigned int rx_missed_errors; + long unsigned int tx_aborted_errors; + long unsigned int tx_carrier_errors; + long unsigned int tx_fifo_errors; + long unsigned int tx_heartbeat_errors; + long unsigned int tx_window_errors; + long unsigned int rx_compressed; + long unsigned int tx_compressed; }; -typedef struct { - size_t written; - size_t count; - union { - char *buf; - void *data; - } arg; - int error; -} read_descriptor_t; - -struct posix_acl_entry { - short int e_tag; - short unsigned int e_perm; - union { - kuid_t e_uid; - kgid_t e_gid; - }; +struct netdev_hw_addr_list { + struct list_head list; + int count; }; -struct posix_acl { - refcount_t a_refcount; - struct callback_head a_rcu; - unsigned int a_count; - struct posix_acl_entry a_entries[0]; +enum rx_handler_result { + RX_HANDLER_CONSUMED = 0, + RX_HANDLER_ANOTHER = 1, + RX_HANDLER_EXACT = 2, + RX_HANDLER_PASS = 3, }; -typedef unsigned char cc_t; - -typedef unsigned int speed_t; +typedef enum rx_handler_result rx_handler_result_t; -typedef unsigned int tcflag_t; +typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **); -struct ktermios { - tcflag_t c_iflag; - tcflag_t c_oflag; - tcflag_t c_cflag; - tcflag_t c_lflag; - cc_t c_line; - cc_t c_cc[19]; - speed_t c_ispeed; - speed_t c_ospeed; -}; +struct pcpu_dstats; -struct winsize { - short unsigned int ws_row; - short unsigned int ws_col; - short unsigned int ws_xpixel; - short unsigned int ws_ypixel; +struct netdev_tc_txq { + u16 count; + u16 offset; }; -struct termiox { - __u16 x_hflag; - __u16 x_cflag; - __u16 x_rflag[5]; - __u16 x_sflag; -}; +struct sfp_bus; -struct tty_driver; +struct netdev_name_node; -struct serial_icounter_struct; +struct dev_ifalias; -struct serial_struct; +struct net_device_ops; -struct tty_operations { - struct tty_struct * (*lookup)(struct tty_driver *, struct file *, int); - int (*install)(struct tty_driver *, struct tty_struct *); - void (*remove)(struct tty_driver *, struct tty_struct *); - int (*open)(struct tty_struct *, struct file *); - void (*close)(struct tty_struct *, struct file *); - void (*shutdown)(struct tty_struct *); - void (*cleanup)(struct tty_struct *); - int (*write)(struct tty_struct *, const unsigned char *, int); - int (*put_char)(struct tty_struct *, unsigned char); - void (*flush_chars)(struct tty_struct *); - int (*write_room)(struct tty_struct *); - int (*chars_in_buffer)(struct tty_struct *); - int (*ioctl)(struct tty_struct *, unsigned int, long unsigned int); - long int (*compat_ioctl)(struct tty_struct *, unsigned int, long unsigned int); - void (*set_termios)(struct tty_struct *, struct ktermios *); - void (*throttle)(struct tty_struct *); - void (*unthrottle)(struct tty_struct *); - void (*stop)(struct tty_struct *); - void (*start)(struct tty_struct *); - void (*hangup)(struct tty_struct *); - int (*break_ctl)(struct tty_struct *, int); - void (*flush_buffer)(struct tty_struct *); - void (*set_ldisc)(struct tty_struct *); - void (*wait_until_sent)(struct tty_struct *, int); - void (*send_xchar)(struct tty_struct *, char); - int (*tiocmget)(struct tty_struct *); - int (*tiocmset)(struct tty_struct *, unsigned int, unsigned int); - int (*resize)(struct tty_struct *, struct winsize *); - int (*set_termiox)(struct tty_struct *, struct termiox *); - int (*get_icount)(struct tty_struct *, struct serial_icounter_struct *); - int (*get_serial)(struct tty_struct *, struct serial_struct *); - int (*set_serial)(struct tty_struct *, struct serial_struct *); - void (*show_fdinfo)(struct tty_struct *, struct seq_file *); - int (*proc_show)(struct seq_file *, void *); -}; +struct ethtool_ops; -struct ld_semaphore { - atomic_long_t count; - raw_spinlock_t wait_lock; - unsigned int wait_readers; - struct list_head read_wait; - struct list_head write_wait; -}; +struct ndisc_ops; -struct tty_ldisc; +struct header_ops; -struct tty_port; +struct in_device; -struct tty_struct { - int magic; - struct kref kref; - struct device *dev; - struct tty_driver *driver; - const struct tty_operations *ops; - int index; - struct ld_semaphore ldisc_sem; - struct tty_ldisc *ldisc; - struct mutex atomic_write_lock; - struct mutex legacy_mutex; - struct mutex throttle_mutex; - struct rw_semaphore termios_rwsem; - struct mutex winsize_mutex; - spinlock_t ctrl_lock; - spinlock_t flow_lock; - struct ktermios termios; - struct ktermios termios_locked; - struct termiox *termiox; - char name[64]; - struct pid *pgrp; - struct pid *session; - long unsigned int flags; - int count; - struct winsize winsize; - long unsigned int stopped: 1; - long unsigned int flow_stopped: 1; - int: 30; - long unsigned int unused: 62; - int hw_stopped; - long unsigned int ctrl_status: 8; - long unsigned int packet: 1; - int: 23; - long unsigned int unused_ctrl: 55; - unsigned int receive_room; - int flow_change; - struct tty_struct *link; - struct fasync_struct *fasync; - wait_queue_head_t write_wait; - wait_queue_head_t read_wait; - struct work_struct hangup_work; - void *disc_data; - void *driver_data; - spinlock_t files_lock; - struct list_head tty_files; - int closing; - unsigned char *write_buf; - int write_cnt; - struct work_struct SAK_work; - struct tty_port *port; -}; +struct inet6_dev; -struct proc_dir_entry; +struct wireless_dev; -struct tty_driver { - int magic; - struct kref kref; - struct cdev **cdevs; - struct module *owner; - const char *driver_name; - const char *name; - int name_base; - int major; - int minor_start; - unsigned int num; - short int type; - short int subtype; - struct ktermios init_termios; - long unsigned int flags; - struct proc_dir_entry *proc_entry; - struct tty_driver *other; - struct tty_struct **ttys; - struct tty_port **ports; - struct ktermios **termios; - void *driver_state; - const struct tty_operations *ops; - struct list_head tty_drivers; -}; +struct wpan_dev; -struct tty_buffer { - union { - struct tty_buffer *next; - struct llist_node free; - }; - int used; - int size; - int commit; - int read; - int flags; - long unsigned int data[0]; -}; +struct netdev_rx_queue; -struct tty_bufhead { - struct tty_buffer *head; - struct work_struct work; - struct mutex lock; - atomic_t priority; - struct tty_buffer sentinel; - struct llist_head free; - atomic_t mem_used; - int mem_limit; - struct tty_buffer *tail; -}; +struct mini_Qdisc; -struct tty_port_operations; +struct netdev_queue; -struct tty_port_client_operations; +struct cpu_rmap; -struct tty_port { - struct tty_bufhead buf; - struct tty_struct *tty; - struct tty_struct *itty; - const struct tty_port_operations *ops; - const struct tty_port_client_operations *client_ops; - spinlock_t lock; - int blocked_open; - int count; - wait_queue_head_t open_wait; - wait_queue_head_t delta_msr_wait; - long unsigned int flags; - long unsigned int iflags; - unsigned char console: 1; - unsigned char low_latency: 1; - struct mutex mutex; - struct mutex buf_mutex; - unsigned char *xmit_buf; - unsigned int close_delay; - unsigned int closing_wait; - int drain_delay; - struct kref kref; - void *client_data; -}; +struct Qdisc; -struct tty_ldisc_ops { - int magic; - char *name; - int num; - int flags; - int (*open)(struct tty_struct *); - void (*close)(struct tty_struct *); - void (*flush_buffer)(struct tty_struct *); - ssize_t (*read)(struct tty_struct *, struct file *, unsigned char *, size_t); - ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t); - int (*ioctl)(struct tty_struct *, struct file *, unsigned int, long unsigned int); - int (*compat_ioctl)(struct tty_struct *, struct file *, unsigned int, long unsigned int); - void (*set_termios)(struct tty_struct *, struct ktermios *); - __poll_t (*poll)(struct tty_struct *, struct file *, struct poll_table_struct *); - int (*hangup)(struct tty_struct *); - void (*receive_buf)(struct tty_struct *, const unsigned char *, char *, int); - void (*write_wakeup)(struct tty_struct *); - void (*dcd_change)(struct tty_struct *, unsigned int); - int (*receive_buf2)(struct tty_struct *, const unsigned char *, char *, int); - struct module *owner; - int refcount; -}; +struct xps_dev_maps; -struct tty_ldisc { - struct tty_ldisc_ops *ops; - struct tty_struct *tty; -}; +struct netpoll_info; -struct tty_port_operations { - int (*carrier_raised)(struct tty_port *); - void (*dtr_rts)(struct tty_port *, int); - void (*shutdown)(struct tty_port *); - int (*activate)(struct tty_port *, struct tty_struct *); - void (*destruct)(struct tty_port *); -}; +struct pcpu_lstats; -struct tty_port_client_operations { - int (*receive_buf)(struct tty_port *, const unsigned char *, const unsigned char *, size_t); - void (*write_wakeup)(struct tty_port *); +struct pcpu_sw_netstats; + +struct rtnl_link_ops; + +struct phy_device; + +struct net_device { + char name[16]; + struct netdev_name_node *name_node; + struct dev_ifalias *ifalias; + long unsigned int mem_end; + long unsigned int mem_start; + long unsigned int base_addr; + int irq; + long unsigned int state; + struct list_head dev_list; + struct list_head napi_list; + struct list_head unreg_list; + struct list_head close_list; + struct list_head ptype_all; + struct list_head ptype_specific; + struct { + struct list_head upper; + struct list_head lower; + } adj_list; + netdev_features_t features; + netdev_features_t hw_features; + netdev_features_t wanted_features; + netdev_features_t vlan_features; + netdev_features_t hw_enc_features; + netdev_features_t mpls_features; + netdev_features_t gso_partial_features; + int ifindex; + int group; + struct net_device_stats stats; + atomic_long_t rx_dropped; + atomic_long_t tx_dropped; + atomic_long_t rx_nohandler; + atomic_t carrier_up_count; + atomic_t carrier_down_count; + const struct net_device_ops *netdev_ops; + const struct ethtool_ops *ethtool_ops; + const struct ndisc_ops *ndisc_ops; + const struct header_ops *header_ops; + unsigned int flags; + unsigned int priv_flags; + short unsigned int gflags; + short unsigned int padded; + unsigned char operstate; + unsigned char link_mode; + unsigned char if_port; + unsigned char dma; + unsigned int mtu; + unsigned int min_mtu; + unsigned int max_mtu; + short unsigned int type; + short unsigned int hard_header_len; + unsigned char min_header_len; + short unsigned int needed_headroom; + short unsigned int needed_tailroom; + unsigned char perm_addr[32]; + unsigned char addr_assign_type; + unsigned char addr_len; + unsigned char upper_level; + unsigned char lower_level; + short unsigned int neigh_priv_len; + short unsigned int dev_id; + short unsigned int dev_port; + spinlock_t addr_list_lock; + unsigned char name_assign_type; + bool uc_promisc; + struct netdev_hw_addr_list uc; + struct netdev_hw_addr_list mc; + struct netdev_hw_addr_list dev_addrs; + struct kset *queues_kset; + unsigned int promiscuity; + unsigned int allmulti; + struct in_device *ip_ptr; + struct inet6_dev *ip6_ptr; + struct wireless_dev *ieee80211_ptr; + struct wpan_dev *ieee802154_ptr; + unsigned char *dev_addr; + struct netdev_rx_queue *_rx; + unsigned int num_rx_queues; + unsigned int real_num_rx_queues; + struct bpf_prog *xdp_prog; + long unsigned int gro_flush_timeout; + rx_handler_func_t *rx_handler; + void *rx_handler_data; + struct mini_Qdisc *miniq_ingress; + struct netdev_queue *ingress_queue; + struct nf_hook_entries *nf_hooks_ingress; + unsigned char broadcast[32]; + struct cpu_rmap *rx_cpu_rmap; + struct hlist_node index_hlist; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct netdev_queue *_tx; + unsigned int num_tx_queues; + unsigned int real_num_tx_queues; + struct Qdisc *qdisc; + struct hlist_head qdisc_hash[16]; + unsigned int tx_queue_len; + spinlock_t tx_global_lock; + int watchdog_timeo; + struct xps_dev_maps *xps_cpus_map; + struct xps_dev_maps *xps_rxqs_map; + struct mini_Qdisc *miniq_egress; + struct timer_list watchdog_timer; + int *pcpu_refcnt; + struct list_head todo_list; + struct list_head link_watch_list; + enum { + NETREG_UNINITIALIZED = 0, + NETREG_REGISTERED = 1, + NETREG_UNREGISTERING = 2, + NETREG_UNREGISTERED = 3, + NETREG_RELEASED = 4, + NETREG_DUMMY = 5, + } reg_state: 8; + bool dismantle; + enum { + RTNL_LINK_INITIALIZED = 0, + RTNL_LINK_INITIALIZING = 1, + } rtnl_link_state: 16; + bool needs_free_netdev; + void (*priv_destructor)(struct net_device *); + struct netpoll_info *npinfo; + possible_net_t nd_net; + union { + void *ml_priv; + struct pcpu_lstats *lstats; + struct pcpu_sw_netstats *tstats; + struct pcpu_dstats *dstats; + }; + struct device dev; + const struct attribute_group *sysfs_groups[4]; + const struct attribute_group *sysfs_rx_queue_group; + const struct rtnl_link_ops *rtnl_link_ops; + unsigned int gso_max_size; + u16 gso_max_segs; + s16 num_tc; + struct netdev_tc_txq tc_to_txq[16]; + u8 prio_tc_map[16]; + struct phy_device *phydev; + struct sfp_bus *sfp_bus; + struct lock_class_key qdisc_tx_busylock_key; + struct lock_class_key qdisc_running_key; + struct lock_class_key qdisc_xmit_lock_key; + struct lock_class_key addr_list_lock_key; + bool proto_down; + unsigned int wol_enabled: 1; }; -struct prot_inuse; +typedef unsigned int sk_buff_data_t; -struct netns_core { - struct ctl_table_header *sysctl_hdr; - int sysctl_somaxconn; - int *sock_inuse; - struct prot_inuse *prot_inuse; +struct skb_ext; + +struct sk_buff { + union { + struct { + struct sk_buff *next; + struct sk_buff *prev; + union { + struct net_device *dev; + long unsigned int dev_scratch; + }; + }; + struct rb_node rbnode; + struct list_head list; + }; + union { + struct sock *sk; + int ip_defrag_offset; + }; + union { + ktime_t tstamp; + u64 skb_mstamp_ns; + }; + char cb[48]; + union { + struct { + long unsigned int _skb_refdst; + void (*destructor)(struct sk_buff *); + }; + struct list_head tcp_tsorted_anchor; + }; + long unsigned int _nfct; + unsigned int len; + unsigned int data_len; + __u16 mac_len; + __u16 hdr_len; + __u16 queue_mapping; + __u8 __cloned_offset[0]; + __u8 cloned: 1; + __u8 nohdr: 1; + __u8 fclone: 2; + __u8 peeked: 1; + __u8 head_frag: 1; + __u8 pfmemalloc: 1; + __u8 active_extensions; + __u32 headers_start[0]; + __u8 __pkt_type_offset[0]; + __u8 pkt_type: 3; + __u8 ignore_df: 1; + __u8 nf_trace: 1; + __u8 ip_summed: 2; + __u8 ooo_okay: 1; + __u8 l4_hash: 1; + __u8 sw_hash: 1; + __u8 wifi_acked_valid: 1; + __u8 wifi_acked: 1; + __u8 no_fcs: 1; + __u8 encapsulation: 1; + __u8 encap_hdr_csum: 1; + __u8 csum_valid: 1; + __u8 __pkt_vlan_present_offset[0]; + __u8 vlan_present: 1; + __u8 csum_complete_sw: 1; + __u8 csum_level: 2; + __u8 csum_not_inet: 1; + __u8 dst_pending_confirm: 1; + __u8 ndisc_nodetype: 2; + __u8 ipvs_property: 1; + __u8 inner_protocol_type: 1; + __u8 remcsum_offload: 1; + __u8 tc_skip_classify: 1; + __u8 tc_at_ingress: 1; + __u8 tc_redirected: 1; + __u8 tc_from_ingress: 1; + __u16 tc_index; + union { + __wsum csum; + struct { + __u16 csum_start; + __u16 csum_offset; + }; + }; + __u32 priority; + int skb_iif; + __u32 hash; + __be16 vlan_proto; + __u16 vlan_tci; + union { + unsigned int napi_id; + unsigned int sender_cpu; + }; + __u32 secmark; + union { + __u32 mark; + __u32 reserved_tailroom; + }; + union { + __be16 inner_protocol; + __u8 inner_ipproto; + }; + __u16 inner_transport_header; + __u16 inner_network_header; + __u16 inner_mac_header; + __be16 protocol; + __u16 transport_header; + __u16 network_header; + __u16 mac_header; + __u32 headers_end[0]; + sk_buff_data_t tail; + sk_buff_data_t end; + unsigned char *head; + unsigned char *data; + unsigned int truesize; + refcount_t users; + struct skb_ext *extensions; }; -struct tcp_mib; - -struct ipstats_mib; - -struct linux_mib; - -struct udp_mib; - -struct icmp_mib; - -struct icmpmsg_mib; - -struct icmpv6_mib; - -struct icmpv6msg_mib; - -struct netns_mib { - struct tcp_mib *tcp_statistics; - struct ipstats_mib *ip_statistics; - struct linux_mib *net_statistics; - struct udp_mib *udp_statistics; - struct udp_mib *udplite_statistics; - struct icmp_mib *icmp_statistics; - struct icmpmsg_mib *icmpmsg_statistics; - struct proc_dir_entry *proc_net_devsnmp6; - struct udp_mib *udp_stats_in6; - struct udp_mib *udplite_stats_in6; - struct ipstats_mib *ipv6_statistics; - struct icmpv6_mib *icmpv6_statistics; - struct icmpv6msg_mib *icmpv6msg_statistics; +struct sg_table { + struct scatterlist *sgl; + unsigned int nents; + unsigned int orig_nents; }; -struct netns_packet { - struct mutex sklist_lock; - struct hlist_head sklist; -}; +typedef int suspend_state_t; -struct netns_unix { - int sysctl_max_dgram_qlen; - struct ctl_table_header *ctl; +enum suspend_stat_step { + SUSPEND_FREEZE = 1, + SUSPEND_PREPARE = 2, + SUSPEND_SUSPEND = 3, + SUSPEND_SUSPEND_LATE = 4, + SUSPEND_SUSPEND_NOIRQ = 5, + SUSPEND_RESUME_NOIRQ = 6, + SUSPEND_RESUME_EARLY = 7, + SUSPEND_RESUME = 8, }; -struct netns_nexthop { - struct rb_root rb_root; - struct hlist_head *devhash; - unsigned int seq; - u32 last_id_allocated; +struct suspend_stats { + int success; + int fail; + int failed_freeze; + int failed_prepare; + int failed_suspend; + int failed_suspend_late; + int failed_suspend_noirq; + int failed_resume; + int failed_resume_early; + int failed_resume_noirq; + int last_failed_dev; + char failed_devs[80]; + int last_failed_errno; + int errno[2]; + int last_failed_step; + enum suspend_stat_step failed_steps[2]; }; -struct local_ports { - seqlock_t lock; - int range[2]; - bool warned; +enum s2idle_states { + S2IDLE_STATE_NONE = 0, + S2IDLE_STATE_ENTER = 1, + S2IDLE_STATE_WAKE = 2, }; -struct inet_hashinfo; - -struct inet_timewait_death_row { - atomic_t tw_count; - long: 32; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - struct inet_hashinfo *hashinfo; - int sysctl_max_tw_buckets; - long: 32; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +struct pbe { + void *address; + void *orig_address; + struct pbe *next; }; -struct ping_group_range { - seqlock_t lock; - kgid_t range[2]; +enum { + Root_NFS = 255, + Root_CIFS = 254, + Root_RAM0 = 1048576, + Root_RAM1 = 1048577, + Root_FD0 = 2097152, + Root_HDA1 = 3145729, + Root_HDA2 = 3145730, + Root_SDA1 = 8388609, + Root_SDA2 = 8388610, + Root_HDC1 = 23068673, + Root_SR0 = 11534336, }; -typedef struct { - u64 key[2]; -} siphash_key_t; - -struct ipv4_devconf; - -struct ip_ra_chain; - -struct fib_rules_ops; - -struct fib_table; - -struct inet_peer_base; - -struct fqdir; - -struct xt_table; - -struct tcp_congestion_ops; - -struct tcp_fastopen_context; - -struct mr_table; +struct xdr_buf { + struct kvec head[1]; + struct kvec tail[1]; + struct bio_vec *bvec; + struct page **pages; + unsigned int page_base; + unsigned int page_len; + unsigned int flags; + unsigned int buflen; + unsigned int len; +}; -struct fib_notifier_ops; +struct rpc_rqst; -struct netns_ipv4 { - struct ctl_table_header *forw_hdr; - struct ctl_table_header *frags_hdr; - struct ctl_table_header *ipv4_hdr; - struct ctl_table_header *route_hdr; - struct ctl_table_header *xfrm4_hdr; - struct ipv4_devconf *devconf_all; - struct ipv4_devconf *devconf_dflt; - struct ip_ra_chain *ra_chain; - struct mutex ra_mutex; - struct fib_rules_ops *rules_ops; - bool fib_has_custom_rules; - unsigned int fib_rules_require_fldissect; - struct fib_table *fib_main; - struct fib_table *fib_default; - bool fib_has_custom_local_routes; - struct hlist_head *fib_table_hash; - bool fib_offload_disabled; - struct sock *fibnl; - struct sock **icmp_sk; - struct sock *mc_autojoin_sk; - struct inet_peer_base *peers; - struct sock **tcp_sk; - struct fqdir *fqdir; - struct xt_table *iptable_filter; - struct xt_table *iptable_mangle; - struct xt_table *iptable_raw; - struct xt_table *arptable_filter; - struct xt_table *iptable_security; - struct xt_table *nat_table; - int sysctl_icmp_echo_ignore_all; - int sysctl_icmp_echo_ignore_broadcasts; - int sysctl_icmp_ignore_bogus_error_responses; - int sysctl_icmp_ratelimit; - int sysctl_icmp_ratemask; - int sysctl_icmp_errors_use_inbound_ifaddr; - struct local_ports ip_local_ports; - int sysctl_tcp_ecn; - int sysctl_tcp_ecn_fallback; - int sysctl_ip_default_ttl; - int sysctl_ip_no_pmtu_disc; - int sysctl_ip_fwd_use_pmtu; - int sysctl_ip_fwd_update_priority; - int sysctl_ip_nonlocal_bind; - int sysctl_ip_dynaddr; - int sysctl_ip_early_demux; - int sysctl_tcp_early_demux; - int sysctl_udp_early_demux; - int sysctl_fwmark_reflect; - int sysctl_tcp_fwmark_accept; - int sysctl_tcp_mtu_probing; - int sysctl_tcp_mtu_probe_floor; - int sysctl_tcp_base_mss; - int sysctl_tcp_min_snd_mss; - int sysctl_tcp_probe_threshold; - u32 sysctl_tcp_probe_interval; - int sysctl_tcp_keepalive_time; - int sysctl_tcp_keepalive_probes; - int sysctl_tcp_keepalive_intvl; - int sysctl_tcp_syn_retries; - int sysctl_tcp_synack_retries; - int sysctl_tcp_syncookies; - int sysctl_tcp_reordering; - int sysctl_tcp_retries1; - int sysctl_tcp_retries2; - int sysctl_tcp_orphan_retries; - int sysctl_tcp_fin_timeout; - unsigned int sysctl_tcp_notsent_lowat; - int sysctl_tcp_tw_reuse; - int sysctl_tcp_sack; - int sysctl_tcp_window_scaling; - int sysctl_tcp_timestamps; - int sysctl_tcp_early_retrans; - int sysctl_tcp_recovery; - int sysctl_tcp_thin_linear_timeouts; - int sysctl_tcp_slow_start_after_idle; - int sysctl_tcp_retrans_collapse; - int sysctl_tcp_stdurg; - int sysctl_tcp_rfc1337; - int sysctl_tcp_abort_on_overflow; - int sysctl_tcp_fack; - int sysctl_tcp_max_reordering; - int sysctl_tcp_dsack; - int sysctl_tcp_app_win; - int sysctl_tcp_adv_win_scale; - int sysctl_tcp_frto; - int sysctl_tcp_nometrics_save; - int sysctl_tcp_moderate_rcvbuf; - int sysctl_tcp_tso_win_divisor; - int sysctl_tcp_workaround_signed_windows; - int sysctl_tcp_limit_output_bytes; - int sysctl_tcp_challenge_ack_limit; - int sysctl_tcp_min_tso_segs; - int sysctl_tcp_min_rtt_wlen; - int sysctl_tcp_autocorking; - int sysctl_tcp_invalid_ratelimit; - int sysctl_tcp_pacing_ss_ratio; - int sysctl_tcp_pacing_ca_ratio; - int sysctl_tcp_wmem[3]; - int sysctl_tcp_rmem[3]; - int sysctl_tcp_comp_sack_nr; - long unsigned int sysctl_tcp_comp_sack_delay_ns; - struct inet_timewait_death_row tcp_death_row; - int sysctl_max_syn_backlog; - int sysctl_tcp_fastopen; - const struct tcp_congestion_ops *tcp_congestion_control; - struct tcp_fastopen_context *tcp_fastopen_ctx; - spinlock_t tcp_fastopen_ctx_lock; - unsigned int sysctl_tcp_fastopen_blackhole_timeout; - atomic_t tfo_active_disable_times; - long unsigned int tfo_active_disable_stamp; - int sysctl_udp_wmem_min; - int sysctl_udp_rmem_min; - int sysctl_igmp_max_memberships; - int sysctl_igmp_max_msf; - int sysctl_igmp_llm_reports; - int sysctl_igmp_qrv; - struct ping_group_range ping_group_range; - atomic_t dev_addr_genid; - long unsigned int *sysctl_local_reserved_ports; - int sysctl_ip_prot_sock; - struct mr_table *mrt; - int sysctl_fib_multipath_use_neigh; - int sysctl_fib_multipath_hash_policy; - struct fib_notifier_ops *notifier_ops; - unsigned int fib_seq; - struct fib_notifier_ops *ipmr_notifier_ops; - unsigned int ipmr_seq; - atomic_t rt_genid; - siphash_key_t ip_id_key; - long: 64; - long: 64; +struct xdr_stream { + __be32 *p; + struct xdr_buf *buf; + __be32 *end; + struct kvec *iov; + struct kvec scratch; + struct page **page_ptr; + unsigned int nwords; + struct rpc_rqst *rqst; }; -struct netns_sysctl_ipv6 { - struct ctl_table_header *hdr; - struct ctl_table_header *route_hdr; - struct ctl_table_header *icmp_hdr; - struct ctl_table_header *frags_hdr; - struct ctl_table_header *xfrm6_hdr; - int bindv6only; - int flush_delay; - int ip6_rt_max_size; - int ip6_rt_gc_min_interval; - int ip6_rt_gc_timeout; - int ip6_rt_gc_interval; - int ip6_rt_gc_elasticity; - int ip6_rt_mtu_expires; - int ip6_rt_min_advmss; - int multipath_hash_policy; - int flowlabel_consistency; - int auto_flowlabels; - int icmpv6_time; - int icmpv6_echo_ignore_all; - int icmpv6_echo_ignore_multicast; - int icmpv6_echo_ignore_anycast; - long unsigned int icmpv6_ratemask[4]; - long unsigned int *icmpv6_ratemask_ptr; - int anycast_src_echo_reply; - int ip_nonlocal_bind; - int fwmark_reflect; - int idgen_retries; - int idgen_delay; - int flowlabel_state_ranges; - int flowlabel_reflect; - int max_dst_opts_cnt; - int max_hbh_opts_cnt; - int max_dst_opts_len; - int max_hbh_opts_len; - int seg6_flowlabel; - bool skip_notify_on_dev_down; -}; +struct rpc_xprt; -struct net_device; +struct rpc_task; -struct neighbour; +struct rpc_cred; -struct dst_ops { - short unsigned int family; - unsigned int gc_thresh; - int (*gc)(struct dst_ops *); - struct dst_entry * (*check)(struct dst_entry *, __u32); - unsigned int (*default_advmss)(const struct dst_entry *); - unsigned int (*mtu)(const struct dst_entry *); - u32 * (*cow_metrics)(struct dst_entry *, long unsigned int); - void (*destroy)(struct dst_entry *); - void (*ifdown)(struct dst_entry *, struct net_device *, int); - struct dst_entry * (*negative_advice)(struct dst_entry *); - void (*link_failure)(struct sk_buff *); - void (*update_pmtu)(struct dst_entry *, struct sock *, struct sk_buff *, u32, bool); - void (*redirect)(struct dst_entry *, struct sock *, struct sk_buff *); - int (*local_out)(struct net *, struct sock *, struct sk_buff *); - struct neighbour * (*neigh_lookup)(const struct dst_entry *, struct sk_buff *, const void *); - void (*confirm_neigh)(const struct dst_entry *, const void *); - struct kmem_cache *kmem_cachep; - struct percpu_counter pcpuc_entries; - long: 64; - long: 64; - long: 64; +struct rpc_rqst { + struct rpc_xprt *rq_xprt; + struct xdr_buf rq_snd_buf; + struct xdr_buf rq_rcv_buf; + struct rpc_task *rq_task; + struct rpc_cred *rq_cred; + __be32 rq_xid; + int rq_cong; + u32 rq_seqno; + int rq_enc_pages_num; + struct page **rq_enc_pages; + void (*rq_release_snd_buf)(struct rpc_rqst *); + union { + struct list_head rq_list; + struct rb_node rq_recv; + }; + struct list_head rq_xmit; + struct list_head rq_xmit2; + void *rq_buffer; + size_t rq_callsize; + void *rq_rbuffer; + size_t rq_rcvsize; + size_t rq_xmit_bytes_sent; + size_t rq_reply_bytes_recvd; + struct xdr_buf rq_private_buf; + long unsigned int rq_majortimeo; + long unsigned int rq_timeout; + ktime_t rq_rtt; + unsigned int rq_retries; + unsigned int rq_connect_cookie; + atomic_t rq_pin; + u32 rq_bytes_sent; + ktime_t rq_xtime; + int rq_ntrans; }; -struct ipv6_devconf; - -struct fib6_info; - -struct rt6_info; - -struct rt6_statistics; +typedef void (*kxdreproc_t)(struct rpc_rqst *, struct xdr_stream *, const void *); -struct fib6_table; +typedef int (*kxdrdproc_t)(struct rpc_rqst *, struct xdr_stream *, void *); -struct seg6_pernet_data; +struct rpc_procinfo; -struct netns_ipv6 { - struct netns_sysctl_ipv6 sysctl; - struct ipv6_devconf *devconf_all; - struct ipv6_devconf *devconf_dflt; - struct inet_peer_base *peers; - struct fqdir *fqdir; - struct xt_table *ip6table_filter; - struct xt_table *ip6table_mangle; - struct xt_table *ip6table_raw; - struct xt_table *ip6table_security; - struct xt_table *ip6table_nat; - struct fib6_info *fib6_null_entry; - struct rt6_info *ip6_null_entry; - struct rt6_statistics *rt6_stats; - struct timer_list ip6_fib_timer; - struct hlist_head *fib_table_hash; - struct fib6_table *fib6_main_tbl; - struct list_head fib6_walkers; - long: 64; - long: 64; - struct dst_ops ip6_dst_ops; - rwlock_t fib6_walker_lock; - spinlock_t fib6_gc_lock; - unsigned int ip6_rt_gc_expire; - long unsigned int ip6_rt_last_gc; - struct sock **icmp_sk; - struct sock *ndisc_sk; - struct sock *tcp_sk; - struct sock *igmp_sk; - struct sock *mc_autojoin_sk; - atomic_t dev_addr_genid; - atomic_t fib6_sernum; - struct seg6_pernet_data *seg6_data; - struct fib_notifier_ops *notifier_ops; - struct fib_notifier_ops *ip6mr_notifier_ops; - unsigned int ipmr_seq; - struct { - struct hlist_head head; - spinlock_t lock; - u32 seq; - } ip6addrlbl_table; - long: 64; +struct rpc_message { + const struct rpc_procinfo *rpc_proc; + void *rpc_argp; + void *rpc_resp; + const struct cred *rpc_cred; }; -struct nf_queue_handler; - -struct nf_logger; - -struct nf_hook_entries; - -struct netns_nf { - struct proc_dir_entry *proc_netfilter; - const struct nf_queue_handler *queue_handler; - const struct nf_logger *nf_loggers[13]; - struct ctl_table_header *nf_log_dir_header; - struct nf_hook_entries *hooks_ipv4[5]; - struct nf_hook_entries *hooks_ipv6[5]; - bool defrag_ipv4; - bool defrag_ipv6; +struct rpc_procinfo { + u32 p_proc; + kxdreproc_t p_encode; + kxdrdproc_t p_decode; + unsigned int p_arglen; + unsigned int p_replen; + unsigned int p_timer; + u32 p_statidx; + const char *p_name; }; -struct netns_xt { - struct list_head tables[13]; - bool notrack_deprecated_warning; - bool clusterip_deprecated_warning; +struct rpc_wait { + struct list_head list; + struct list_head links; + struct list_head timer_list; }; -struct nf_ct_event_notifier; +struct rpc_wait_queue; -struct nf_exp_event_notifier; +struct rpc_call_ops; -struct nf_generic_net { - unsigned int timeout; +struct rpc_clnt; + +struct rpc_task { + atomic_t tk_count; + int tk_status; + struct list_head tk_task; + void (*tk_callback)(struct rpc_task *); + void (*tk_action)(struct rpc_task *); + long unsigned int tk_timeout; + long unsigned int tk_runstate; + struct rpc_wait_queue *tk_waitqueue; + union { + struct work_struct tk_work; + struct rpc_wait tk_wait; + } u; + int tk_rpc_status; + struct rpc_message tk_msg; + void *tk_calldata; + const struct rpc_call_ops *tk_ops; + struct rpc_clnt *tk_client; + struct rpc_xprt *tk_xprt; + struct rpc_cred *tk_op_cred; + struct rpc_rqst *tk_rqstp; + struct workqueue_struct *tk_workqueue; + ktime_t tk_start; + pid_t tk_owner; + short unsigned int tk_flags; + short unsigned int tk_timeouts; + short unsigned int tk_pid; + unsigned char tk_priority: 2; + unsigned char tk_garb_retry: 2; + unsigned char tk_cred_retry: 2; + unsigned char tk_rebind_retry: 2; }; -struct nf_tcp_net { - unsigned int timeouts[14]; - int tcp_loose; - int tcp_be_liberal; - int tcp_max_retrans; +struct rpc_timer { + struct list_head list; + long unsigned int expires; + struct delayed_work dwork; }; -struct nf_udp_net { - unsigned int timeouts[2]; +struct rpc_wait_queue { + spinlock_t lock; + struct list_head tasks[4]; + unsigned char maxpriority; + unsigned char priority; + unsigned char nr; + short unsigned int qlen; + struct rpc_timer timer_list; + const char *name; }; -struct nf_icmp_net { - unsigned int timeout; +struct rpc_call_ops { + void (*rpc_call_prepare)(struct rpc_task *, void *); + void (*rpc_call_done)(struct rpc_task *, void *); + void (*rpc_count_stats)(struct rpc_task *, void *); + void (*rpc_release)(void *); }; -struct nf_ip_net { - struct nf_generic_net generic; - struct nf_tcp_net tcp; - struct nf_udp_net udp; - struct nf_icmp_net icmp; - struct nf_icmp_net icmpv6; +struct rpc_pipe_dir_head { + struct list_head pdh_entries; + struct dentry *pdh_dentry; }; -struct ct_pcpu; - -struct ip_conntrack_stat; - -struct netns_ct { - atomic_t count; - unsigned int expect_count; - bool auto_assign_helper_warned; - struct ctl_table_header *sysctl_header; - unsigned int sysctl_log_invalid; - int sysctl_events; - int sysctl_acct; - int sysctl_auto_assign_helper; - int sysctl_tstamp; - int sysctl_checksum; - struct ct_pcpu *pcpu_lists; - struct ip_conntrack_stat *stat; - struct nf_ct_event_notifier *nf_conntrack_event_cb; - struct nf_exp_event_notifier *nf_expect_event_cb; - struct nf_ip_net nf_ct_proto; +struct rpc_rtt { + long unsigned int timeo; + long unsigned int srtt[5]; + long unsigned int sdrtt[5]; + int ntimeouts[5]; }; -struct netns_nf_frag { - struct fqdir *fqdir; +struct rpc_timeout { + long unsigned int to_initval; + long unsigned int to_maxval; + long unsigned int to_increment; + unsigned int to_retries; + unsigned char to_exponential; }; -struct xfrm_policy_hash { - struct hlist_head *table; - unsigned int hmask; - u8 dbits4; - u8 sbits4; - u8 dbits6; - u8 sbits6; -}; +struct rpc_xprt_switch; -struct xfrm_policy_hthresh { - struct work_struct work; - seqlock_t lock; - u8 lbits4; - u8 rbits4; - u8 lbits6; - u8 rbits6; -}; +struct rpc_xprt_iter_ops; -struct netns_xfrm { - struct list_head state_all; - struct hlist_head *state_bydst; - struct hlist_head *state_bysrc; - struct hlist_head *state_byspi; - unsigned int state_hmask; - unsigned int state_num; - struct work_struct state_hash_work; - struct list_head policy_all; - struct hlist_head *policy_byidx; - unsigned int policy_idx_hmask; - struct hlist_head policy_inexact[3]; - struct xfrm_policy_hash policy_bydst[3]; - unsigned int policy_count[6]; - struct work_struct policy_hash_work; - struct xfrm_policy_hthresh policy_hthresh; - struct list_head inexact_bins; - struct sock *nlsk; - struct sock *nlsk_stash; - u32 sysctl_aevent_etime; - u32 sysctl_aevent_rseqth; - int sysctl_larval_drop; - u32 sysctl_acq_expires; - struct ctl_table_header *sysctl_hdr; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - struct dst_ops xfrm4_dst_ops; - struct dst_ops xfrm6_dst_ops; - spinlock_t xfrm_state_lock; - spinlock_t xfrm_policy_lock; - struct mutex xfrm_cfg_mutex; - long: 64; - long: 64; - long: 64; +struct rpc_xprt_iter { + struct rpc_xprt_switch *xpi_xpswitch; + struct rpc_xprt *xpi_cursor; + const struct rpc_xprt_iter_ops *xpi_ops; }; -struct uevent_sock; - -struct net_generic; +struct rpc_auth; -struct net { - refcount_t passive; - refcount_t count; - spinlock_t rules_mod_lock; - unsigned int dev_unreg_count; - unsigned int dev_base_seq; - int ifindex; - spinlock_t nsid_lock; - atomic_t fnhe_genid; - struct list_head list; - struct list_head exit_list; - struct llist_node cleanup_list; - struct key_tag *key_domain; - struct user_namespace *user_ns; - struct ucounts *ucounts; - struct idr netns_ids; - struct ns_common ns; - struct list_head dev_base_head; - struct proc_dir_entry *proc_net; - struct proc_dir_entry *proc_net_stat; - struct ctl_table_set sysctls; - struct sock *rtnl; - struct sock *genl_sock; - struct uevent_sock *uevent_sock; - struct hlist_head *dev_name_head; - struct hlist_head *dev_index_head; - struct raw_notifier_head netdev_chain; - u32 hash_mix; - struct net_device *loopback_dev; - struct list_head rules_ops; - struct netns_core core; - struct netns_mib mib; - struct netns_packet packet; - struct netns_unix unx; - struct netns_nexthop nexthop; - long: 64; - struct netns_ipv4 ipv4; - struct netns_ipv6 ipv6; - struct netns_nf nf; - struct netns_xt xt; - struct netns_ct ct; - struct netns_nf_frag nf_frag; - struct ctl_table_header *nf_frag_frags_hdr; - struct sock *nfnl; - struct sock *nfnl_stash; - struct net_generic *gen; - struct bpf_prog *flow_dissector_prog; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - struct netns_xfrm xfrm; - struct sock *diag_nlsk; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; -}; +struct rpc_stat; -typedef struct { - local64_t v; -} u64_stats_t; +struct rpc_iostats; -struct bpf_insn { - __u8 code; - __u8 dst_reg: 4; - __u8 src_reg: 4; - __s16 off; - __s32 imm; -}; +struct rpc_program; -enum bpf_map_type { - BPF_MAP_TYPE_UNSPEC = 0, - BPF_MAP_TYPE_HASH = 1, - BPF_MAP_TYPE_ARRAY = 2, - BPF_MAP_TYPE_PROG_ARRAY = 3, - BPF_MAP_TYPE_PERF_EVENT_ARRAY = 4, - BPF_MAP_TYPE_PERCPU_HASH = 5, - BPF_MAP_TYPE_PERCPU_ARRAY = 6, - BPF_MAP_TYPE_STACK_TRACE = 7, - BPF_MAP_TYPE_CGROUP_ARRAY = 8, - BPF_MAP_TYPE_LRU_HASH = 9, - BPF_MAP_TYPE_LRU_PERCPU_HASH = 10, - BPF_MAP_TYPE_LPM_TRIE = 11, - BPF_MAP_TYPE_ARRAY_OF_MAPS = 12, - BPF_MAP_TYPE_HASH_OF_MAPS = 13, - BPF_MAP_TYPE_DEVMAP = 14, - BPF_MAP_TYPE_SOCKMAP = 15, - BPF_MAP_TYPE_CPUMAP = 16, - BPF_MAP_TYPE_XSKMAP = 17, - BPF_MAP_TYPE_SOCKHASH = 18, - BPF_MAP_TYPE_CGROUP_STORAGE = 19, - BPF_MAP_TYPE_REUSEPORT_SOCKARRAY = 20, - BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE = 21, - BPF_MAP_TYPE_QUEUE = 22, - BPF_MAP_TYPE_STACK = 23, - BPF_MAP_TYPE_SK_STORAGE = 24, - BPF_MAP_TYPE_DEVMAP_HASH = 25, +struct rpc_clnt { + atomic_t cl_count; + unsigned int cl_clid; + struct list_head cl_clients; + struct list_head cl_tasks; + spinlock_t cl_lock; + struct rpc_xprt *cl_xprt; + const struct rpc_procinfo *cl_procinfo; + u32 cl_prog; + u32 cl_vers; + u32 cl_maxproc; + struct rpc_auth *cl_auth; + struct rpc_stat *cl_stats; + struct rpc_iostats *cl_metrics; + unsigned int cl_softrtry: 1; + unsigned int cl_softerr: 1; + unsigned int cl_discrtry: 1; + unsigned int cl_noretranstimeo: 1; + unsigned int cl_autobind: 1; + unsigned int cl_chatty: 1; + struct rpc_rtt *cl_rtt; + const struct rpc_timeout *cl_timeout; + atomic_t cl_swapper; + int cl_nodelen; + char cl_nodename[65]; + struct rpc_pipe_dir_head cl_pipedir_objects; + struct rpc_clnt *cl_parent; + struct rpc_rtt cl_rtt_default; + struct rpc_timeout cl_timeout_default; + const struct rpc_program *cl_program; + const char *cl_principal; + struct rpc_xprt_iter cl_xpi; + const struct cred *cl_cred; }; -enum bpf_prog_type { - BPF_PROG_TYPE_UNSPEC = 0, - BPF_PROG_TYPE_SOCKET_FILTER = 1, - BPF_PROG_TYPE_KPROBE = 2, - BPF_PROG_TYPE_SCHED_CLS = 3, - BPF_PROG_TYPE_SCHED_ACT = 4, - BPF_PROG_TYPE_TRACEPOINT = 5, - BPF_PROG_TYPE_XDP = 6, - BPF_PROG_TYPE_PERF_EVENT = 7, - BPF_PROG_TYPE_CGROUP_SKB = 8, - BPF_PROG_TYPE_CGROUP_SOCK = 9, - BPF_PROG_TYPE_LWT_IN = 10, - BPF_PROG_TYPE_LWT_OUT = 11, - BPF_PROG_TYPE_LWT_XMIT = 12, - BPF_PROG_TYPE_SOCK_OPS = 13, - BPF_PROG_TYPE_SK_SKB = 14, - BPF_PROG_TYPE_CGROUP_DEVICE = 15, - BPF_PROG_TYPE_SK_MSG = 16, - BPF_PROG_TYPE_RAW_TRACEPOINT = 17, - BPF_PROG_TYPE_CGROUP_SOCK_ADDR = 18, - BPF_PROG_TYPE_LWT_SEG6LOCAL = 19, - BPF_PROG_TYPE_LIRC_MODE2 = 20, - BPF_PROG_TYPE_SK_REUSEPORT = 21, - BPF_PROG_TYPE_FLOW_DISSECTOR = 22, - BPF_PROG_TYPE_CGROUP_SYSCTL = 23, - BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE = 24, - BPF_PROG_TYPE_CGROUP_SOCKOPT = 25, - BPF_PROG_TYPE_TRACING = 26, -}; +struct rpc_xprt_ops; -enum bpf_attach_type { - BPF_CGROUP_INET_INGRESS = 0, - BPF_CGROUP_INET_EGRESS = 1, - BPF_CGROUP_INET_SOCK_CREATE = 2, - BPF_CGROUP_SOCK_OPS = 3, - BPF_SK_SKB_STREAM_PARSER = 4, - BPF_SK_SKB_STREAM_VERDICT = 5, - BPF_CGROUP_DEVICE = 6, - BPF_SK_MSG_VERDICT = 7, - BPF_CGROUP_INET4_BIND = 8, - BPF_CGROUP_INET6_BIND = 9, - BPF_CGROUP_INET4_CONNECT = 10, - BPF_CGROUP_INET6_CONNECT = 11, - BPF_CGROUP_INET4_POST_BIND = 12, - BPF_CGROUP_INET6_POST_BIND = 13, - BPF_CGROUP_UDP4_SENDMSG = 14, - BPF_CGROUP_UDP6_SENDMSG = 15, - BPF_LIRC_MODE2 = 16, - BPF_FLOW_DISSECTOR = 17, - BPF_CGROUP_SYSCTL = 18, - BPF_CGROUP_UDP4_RECVMSG = 19, - BPF_CGROUP_UDP6_RECVMSG = 20, - BPF_CGROUP_GETSOCKOPT = 21, - BPF_CGROUP_SETSOCKOPT = 22, - BPF_TRACE_RAW_TP = 23, - BPF_TRACE_FENTRY = 24, - BPF_TRACE_FEXIT = 25, - __MAX_BPF_ATTACH_TYPE = 26, -}; +struct svc_xprt; -union bpf_attr { - struct { - __u32 map_type; - __u32 key_size; - __u32 value_size; - __u32 max_entries; - __u32 map_flags; - __u32 inner_map_fd; - __u32 numa_node; - char map_name[16]; - __u32 map_ifindex; - __u32 btf_fd; - __u32 btf_key_type_id; - __u32 btf_value_type_id; - }; - struct { - __u32 map_fd; - __u64 key; - union { - __u64 value; - __u64 next_key; - }; - __u64 flags; - }; - struct { - __u32 prog_type; - __u32 insn_cnt; - __u64 insns; - __u64 license; - __u32 log_level; - __u32 log_size; - __u64 log_buf; - __u32 kern_version; - __u32 prog_flags; - char prog_name[16]; - __u32 prog_ifindex; - __u32 expected_attach_type; - __u32 prog_btf_fd; - __u32 func_info_rec_size; - __u64 func_info; - __u32 func_info_cnt; - __u32 line_info_rec_size; - __u64 line_info; - __u32 line_info_cnt; - __u32 attach_btf_id; - __u32 attach_prog_fd; - }; - struct { - __u64 pathname; - __u32 bpf_fd; - __u32 file_flags; - }; - struct { - __u32 target_fd; - __u32 attach_bpf_fd; - __u32 attach_type; - __u32 attach_flags; - }; - struct { - __u32 prog_fd; - __u32 retval; - __u32 data_size_in; - __u32 data_size_out; - __u64 data_in; - __u64 data_out; - __u32 repeat; - __u32 duration; - __u32 ctx_size_in; - __u32 ctx_size_out; - __u64 ctx_in; - __u64 ctx_out; - } test; - struct { - union { - __u32 start_id; - __u32 prog_id; - __u32 map_id; - __u32 btf_id; - }; - __u32 next_id; - __u32 open_flags; - }; - struct { - __u32 bpf_fd; - __u32 info_len; - __u64 info; - } info; - struct { - __u32 target_fd; - __u32 attach_type; - __u32 query_flags; - __u32 attach_flags; - __u64 prog_ids; - __u32 prog_cnt; - } query; - struct { - __u64 name; - __u32 prog_fd; - } raw_tracepoint; - struct { - __u64 btf; - __u64 btf_log_buf; - __u32 btf_size; - __u32 btf_log_size; - __u32 btf_log_level; - }; +struct rpc_xprt { + struct kref kref; + const struct rpc_xprt_ops *ops; + const struct rpc_timeout *timeout; + struct __kernel_sockaddr_storage addr; + size_t addrlen; + int prot; + long unsigned int cong; + long unsigned int cwnd; + size_t max_payload; + struct rpc_wait_queue binding; + struct rpc_wait_queue sending; + struct rpc_wait_queue pending; + struct rpc_wait_queue backlog; + struct list_head free; + unsigned int max_reqs; + unsigned int min_reqs; + unsigned int num_reqs; + long unsigned int state; + unsigned char resvport: 1; + unsigned char reuseport: 1; + atomic_t swapper; + unsigned int bind_index; + struct list_head xprt_switch; + long unsigned int bind_timeout; + long unsigned int reestablish_timeout; + unsigned int connect_cookie; + struct work_struct task_cleanup; + struct timer_list timer; + long unsigned int last_used; + long unsigned int idle_timeout; + long unsigned int connect_timeout; + long unsigned int max_reconnect_timeout; + atomic_long_t queuelen; + spinlock_t transport_lock; + spinlock_t reserve_lock; + spinlock_t queue_lock; + u32 xid; + struct rpc_task *snd_task; + struct list_head xmit_queue; + struct svc_xprt *bc_xprt; + struct rb_root recv_queue; struct { - __u32 pid; - __u32 fd; - __u32 flags; - __u32 buf_len; - __u64 buf; - __u32 prog_id; - __u32 fd_type; - __u64 probe_offset; - __u64 probe_addr; - } task_fd_query; + long unsigned int bind_count; + long unsigned int connect_count; + long unsigned int connect_start; + long unsigned int connect_time; + long unsigned int sends; + long unsigned int recvs; + long unsigned int bad_xids; + long unsigned int max_slots; + long long unsigned int req_u; + long long unsigned int bklog_u; + long long unsigned int sending_u; + long long unsigned int pending_u; + } stat; + struct net *xprt_net; + const char *servername; + const char *address_strings[6]; + struct callback_head rcu; }; -struct bpf_func_info { - __u32 insn_off; - __u32 type_id; -}; +struct rpc_credops; -struct bpf_line_info { - __u32 insn_off; - __u32 file_name_off; - __u32 line_off; - __u32 line_col; +struct rpc_cred { + struct hlist_node cr_hash; + struct list_head cr_lru; + struct callback_head cr_rcu; + struct rpc_auth *cr_auth; + const struct rpc_credops *cr_ops; + long unsigned int cr_expire; + long unsigned int cr_flags; + refcount_t cr_count; + const struct cred *cr_cred; }; -struct btf; - -struct bpf_map; +typedef u32 rpc_authflavor_t; -struct btf_type; +struct ethhdr { + unsigned char h_dest[6]; + unsigned char h_source[6]; + __be16 h_proto; +}; -struct bpf_prog_aux; +struct flow_dissector { + unsigned int used_keys; + short unsigned int offset[27]; +}; -struct bpf_map_ops { - int (*map_alloc_check)(union bpf_attr *); - struct bpf_map * (*map_alloc)(union bpf_attr *); - void (*map_release)(struct bpf_map *, struct file *); - void (*map_free)(struct bpf_map *); - int (*map_get_next_key)(struct bpf_map *, void *, void *); - void (*map_release_uref)(struct bpf_map *); - void * (*map_lookup_elem_sys_only)(struct bpf_map *, void *); - void * (*map_lookup_elem)(struct bpf_map *, void *); - int (*map_update_elem)(struct bpf_map *, void *, void *, u64); - int (*map_delete_elem)(struct bpf_map *, void *); - int (*map_push_elem)(struct bpf_map *, void *, u64); - int (*map_pop_elem)(struct bpf_map *, void *); - int (*map_peek_elem)(struct bpf_map *, void *); - void * (*map_fd_get_ptr)(struct bpf_map *, struct file *, int); - void (*map_fd_put_ptr)(void *); - u32 (*map_gen_lookup)(struct bpf_map *, struct bpf_insn *); - u32 (*map_fd_sys_lookup_elem)(void *); - void (*map_seq_show_elem)(struct bpf_map *, void *, struct seq_file *); - int (*map_check_btf)(const struct bpf_map *, const struct btf *, const struct btf_type *, const struct btf_type *); - int (*map_poke_track)(struct bpf_map *, struct bpf_prog_aux *); - void (*map_poke_untrack)(struct bpf_map *, struct bpf_prog_aux *); - void (*map_poke_run)(struct bpf_map *, u32, struct bpf_prog *, struct bpf_prog *); - int (*map_direct_value_addr)(const struct bpf_map *, u64 *, u32); - int (*map_direct_value_meta)(const struct bpf_map *, u64, u32 *); - int (*map_mmap)(struct bpf_map *, struct vm_area_struct *); +struct flowi_tunnel { + __be64 tun_id; }; -struct bpf_map_memory { - u32 pages; - struct user_struct *user; +struct flowi_common { + int flowic_oif; + int flowic_iif; + __u32 flowic_mark; + __u8 flowic_tos; + __u8 flowic_scope; + __u8 flowic_proto; + __u8 flowic_flags; + __u32 flowic_secid; + kuid_t flowic_uid; + struct flowi_tunnel flowic_tun_key; + __u32 flowic_multipath_hash; }; -struct bpf_map { - const struct bpf_map_ops *ops; - struct bpf_map *inner_map_meta; - void *security; - enum bpf_map_type map_type; - u32 key_size; - u32 value_size; - u32 max_entries; - u32 map_flags; - int spin_lock_off; - u32 id; - int numa_node; - u32 btf_key_type_id; - u32 btf_value_type_id; - struct btf *btf; - struct bpf_map_memory memory; - char name[16]; - bool unpriv_array; - bool frozen; - long: 48; - long: 64; - long: 64; - atomic64_t refcnt; - atomic64_t usercnt; - struct work_struct work; - struct mutex freeze_mutex; - u64 writecnt; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +union flowi_uli { + struct { + __be16 dport; + __be16 sport; + } ports; + struct { + __u8 type; + __u8 code; + } icmpt; + struct { + __le16 dport; + __le16 sport; + } dnports; + __be32 spi; + __be32 gre_key; + struct { + __u8 type; + } mht; }; -struct btf_type { - __u32 name_off; - __u32 info; - union { - __u32 size; - __u32 type; - }; +struct flowi4 { + struct flowi_common __fl_common; + __be32 saddr; + __be32 daddr; + union flowi_uli uli; }; -enum bpf_tramp_prog_type { - BPF_TRAMP_FENTRY = 0, - BPF_TRAMP_FEXIT = 1, - BPF_TRAMP_MAX = 2, +struct flowi6 { + struct flowi_common __fl_common; + struct in6_addr daddr; + struct in6_addr saddr; + __be32 flowlabel; + union flowi_uli uli; + __u32 mp_hash; }; -struct bpf_trampoline; +struct flowidn { + struct flowi_common __fl_common; + __le16 daddr; + __le16 saddr; + union flowi_uli uli; +}; -struct bpf_jit_poke_descriptor; +struct flowi { + union { + struct flowi_common __fl_common; + struct flowi4 ip4; + struct flowi6 ip6; + struct flowidn dn; + } u; +}; -struct bpf_prog_ops; +struct ipstats_mib { + u64 mibs[37]; + struct u64_stats_sync syncp; +}; -struct bpf_prog_offload; +struct icmp_mib { + long unsigned int mibs[28]; +}; -struct bpf_func_info_aux; +struct icmpmsg_mib { + atomic_long_t mibs[512]; +}; -struct bpf_prog_stats; +struct icmpv6_mib { + long unsigned int mibs[6]; +}; -struct bpf_prog_aux { - atomic64_t refcnt; - u32 used_map_cnt; - u32 max_ctx_offset; - u32 max_pkt_offset; - u32 max_tp_access; - u32 stack_depth; - u32 id; - u32 func_cnt; - u32 func_idx; - u32 attach_btf_id; - struct bpf_prog *linked_prog; - bool verifier_zext; - bool offload_requested; - bool attach_btf_trace; - bool func_proto_unreliable; - enum bpf_tramp_prog_type trampoline_prog_type; - struct bpf_trampoline *trampoline; - struct hlist_node tramp_hlist; - const struct btf_type *attach_func_proto; - const char *attach_func_name; - struct bpf_prog **func; - void *jit_data; - struct bpf_jit_poke_descriptor *poke_tab; - u32 size_poke_tab; - struct latch_tree_node ksym_tnode; - struct list_head ksym_lnode; - const struct bpf_prog_ops *ops; - struct bpf_map **used_maps; - struct bpf_prog *prog; - struct user_struct *user; - u64 load_time; - struct bpf_map *cgroup_storage[2]; - char name[16]; - void *security; - struct bpf_prog_offload *offload; - struct btf *btf; - struct bpf_func_info *func_info; - struct bpf_func_info_aux *func_info_aux; - struct bpf_line_info *linfo; - void **jited_linfo; - u32 func_info_cnt; - u32 nr_linfo; - u32 linfo_idx; - u32 num_exentries; - struct exception_table_entry *extable; - struct bpf_prog_stats *stats; - union { - struct work_struct work; - struct callback_head rcu; - }; +struct icmpv6_mib_device { + atomic_long_t mibs[6]; }; -struct sock_filter { - __u16 code; - __u8 jt; - __u8 jf; - __u32 k; +struct icmpv6msg_mib { + atomic_long_t mibs[512]; }; -struct sock_fprog_kern; +struct icmpv6msg_mib_device { + atomic_long_t mibs[512]; +}; -struct bpf_prog { - u16 pages; - u16 jited: 1; - u16 jit_requested: 1; - u16 gpl_compatible: 1; - u16 cb_access: 1; - u16 dst_needed: 1; - u16 blinded: 1; - u16 is_func: 1; - u16 kprobe_override: 1; - u16 has_callchain_buf: 1; - u16 enforce_expected_attach_type: 1; - enum bpf_prog_type type; - enum bpf_attach_type expected_attach_type; - u32 len; - u32 jited_len; - u8 tag[8]; - struct bpf_prog_aux *aux; - struct sock_fprog_kern *orig_prog; - unsigned int (*bpf_func)(const void *, const struct bpf_insn *); - union { - struct sock_filter insns[0]; - struct bpf_insn insnsi[0]; - }; +struct tcp_mib { + long unsigned int mibs[16]; }; -struct bpf_offloaded_map; +struct udp_mib { + long unsigned int mibs[9]; +}; -struct bpf_map_dev_ops { - int (*map_get_next_key)(struct bpf_offloaded_map *, void *, void *); - int (*map_lookup_elem)(struct bpf_offloaded_map *, void *, void *); - int (*map_update_elem)(struct bpf_offloaded_map *, void *, void *, u64); - int (*map_delete_elem)(struct bpf_offloaded_map *, void *); +struct linux_mib { + long unsigned int mibs[120]; }; -struct bpf_offloaded_map { - struct bpf_map map; - struct net_device *netdev; - const struct bpf_map_dev_ops *dev_ops; - void *dev_priv; - struct list_head offloads; +struct inet_frags; + +struct fqdir { + long int high_thresh; + long int low_thresh; + int timeout; + int max_dist; + struct inet_frags *f; + struct net *net; + bool dead; + long: 56; + long: 64; + long: 64; + struct rhashtable rhashtable; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + atomic_long_t mem; + struct work_struct destroy_work; long: 64; long: 64; long: 64; }; -struct net_device_stats { - long unsigned int rx_packets; - long unsigned int tx_packets; - long unsigned int rx_bytes; - long unsigned int tx_bytes; - long unsigned int rx_errors; - long unsigned int tx_errors; - long unsigned int rx_dropped; - long unsigned int tx_dropped; - long unsigned int multicast; - long unsigned int collisions; - long unsigned int rx_length_errors; - long unsigned int rx_over_errors; - long unsigned int rx_crc_errors; - long unsigned int rx_frame_errors; - long unsigned int rx_fifo_errors; - long unsigned int rx_missed_errors; - long unsigned int tx_aborted_errors; - long unsigned int tx_carrier_errors; - long unsigned int tx_fifo_errors; - long unsigned int tx_heartbeat_errors; - long unsigned int tx_window_errors; - long unsigned int rx_compressed; - long unsigned int tx_compressed; -}; +struct inet_frag_queue; -struct netdev_hw_addr_list { - struct list_head list; - int count; +struct inet_frags { + unsigned int qsize; + void (*constructor)(struct inet_frag_queue *, const void *); + void (*destructor)(struct inet_frag_queue *); + void (*frag_expire)(struct timer_list *); + struct kmem_cache *frags_cachep; + const char *frags_cache_name; + struct rhashtable_params rhash_params; + refcount_t refcnt; + struct completion completion; }; -enum rx_handler_result { - RX_HANDLER_CONSUMED = 0, - RX_HANDLER_ANOTHER = 1, - RX_HANDLER_EXACT = 2, - RX_HANDLER_PASS = 3, +struct frag_v4_compare_key { + __be32 saddr; + __be32 daddr; + u32 user; + u32 vif; + __be16 id; + u16 protocol; }; -typedef enum rx_handler_result rx_handler_result_t; - -typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **); - -struct pcpu_dstats; - -struct netdev_tc_txq { - u16 count; - u16 offset; +struct frag_v6_compare_key { + struct in6_addr saddr; + struct in6_addr daddr; + u32 user; + __be32 id; + u32 iif; }; -struct sfp_bus; +struct inet_frag_queue { + struct rhash_head node; + union { + struct frag_v4_compare_key v4; + struct frag_v6_compare_key v6; + } key; + struct timer_list timer; + spinlock_t lock; + refcount_t refcnt; + struct rb_root rb_fragments; + struct sk_buff *fragments_tail; + struct sk_buff *last_run_head; + ktime_t stamp; + int len; + int meat; + __u8 flags; + u16 max_size; + struct fqdir *fqdir; + struct callback_head rcu; +}; -struct netdev_name_node; +struct fib_rule; -struct dev_ifalias; +struct fib_lookup_arg; -struct net_device_ops; +struct fib_rule_hdr; -struct ethtool_ops; +struct nlattr; -struct ndisc_ops; +struct netlink_ext_ack; -struct header_ops; +struct nla_policy; -struct in_device; +struct fib_rules_ops { + int family; + struct list_head list; + int rule_size; + int addr_size; + int unresolved_rules; + int nr_goto_rules; + unsigned int fib_rules_seq; + int (*action)(struct fib_rule *, struct flowi *, int, struct fib_lookup_arg *); + bool (*suppress)(struct fib_rule *, struct fib_lookup_arg *); + int (*match)(struct fib_rule *, struct flowi *, int); + int (*configure)(struct fib_rule *, struct sk_buff *, struct fib_rule_hdr *, struct nlattr **, struct netlink_ext_ack *); + int (*delete)(struct fib_rule *); + int (*compare)(struct fib_rule *, struct fib_rule_hdr *, struct nlattr **); + int (*fill)(struct fib_rule *, struct sk_buff *, struct fib_rule_hdr *); + size_t (*nlmsg_payload)(struct fib_rule *); + void (*flush_cache)(struct fib_rules_ops *); + int nlgroup; + const struct nla_policy *policy; + struct list_head rules_list; + struct module *owner; + struct net *fro_net; + struct callback_head rcu; +}; -struct inet6_dev; +enum tcp_ca_event { + CA_EVENT_TX_START = 0, + CA_EVENT_CWND_RESTART = 1, + CA_EVENT_COMPLETE_CWR = 2, + CA_EVENT_LOSS = 3, + CA_EVENT_ECN_NO_CE = 4, + CA_EVENT_ECN_IS_CE = 5, +}; -struct wireless_dev; +struct ack_sample; -struct wpan_dev; +struct rate_sample; -struct netdev_rx_queue; +union tcp_cc_info; -struct mini_Qdisc; +struct tcp_congestion_ops { + struct list_head list; + u32 key; + u32 flags; + void (*init)(struct sock *); + void (*release)(struct sock *); + u32 (*ssthresh)(struct sock *); + void (*cong_avoid)(struct sock *, u32, u32); + void (*set_state)(struct sock *, u8); + void (*cwnd_event)(struct sock *, enum tcp_ca_event); + void (*in_ack_event)(struct sock *, u32); + u32 (*undo_cwnd)(struct sock *); + void (*pkts_acked)(struct sock *, const struct ack_sample *); + u32 (*min_tso_segs)(struct sock *); + u32 (*sndbuf_expand)(struct sock *); + void (*cong_control)(struct sock *, const struct rate_sample *); + size_t (*get_info)(struct sock *, u32, int *, union tcp_cc_info *); + char name[16]; + struct module *owner; +}; -struct netdev_queue; +struct fib_notifier_ops { + int family; + struct list_head list; + unsigned int (*fib_seq_read)(struct net *); + int (*fib_dump)(struct net *, struct notifier_block *, struct netlink_ext_ack *); + struct module *owner; + struct callback_head rcu; +}; -struct cpu_rmap; +struct xfrm_state; -struct Qdisc; +struct lwtunnel_state; -struct xps_dev_maps; +struct dst_entry { + struct net_device *dev; + struct dst_ops *ops; + long unsigned int _metrics; + long unsigned int expires; + struct xfrm_state *xfrm; + int (*input)(struct sk_buff *); + int (*output)(struct net *, struct sock *, struct sk_buff *); + short unsigned int flags; + short int obsolete; + short unsigned int header_len; + short unsigned int trailer_len; + atomic_t __refcnt; + int __use; + long unsigned int lastuse; + struct lwtunnel_state *lwtstate; + struct callback_head callback_head; + short int error; + short int __pad; + __u32 tclassid; +}; -struct netpoll_info; +struct hh_cache { + unsigned int hh_len; + seqlock_t hh_lock; + long unsigned int hh_data[12]; +}; -struct pcpu_lstats; +struct neigh_table; -struct pcpu_sw_netstats; +struct neigh_parms; -struct rtnl_link_ops; +struct neigh_ops; -struct phy_device; +struct neighbour { + struct neighbour *next; + struct neigh_table *tbl; + struct neigh_parms *parms; + long unsigned int confirmed; + long unsigned int updated; + rwlock_t lock; + refcount_t refcnt; + unsigned int arp_queue_len_bytes; + struct sk_buff_head arp_queue; + struct timer_list timer; + long unsigned int used; + atomic_t probes; + __u8 flags; + __u8 nud_state; + __u8 type; + __u8 dead; + u8 protocol; + seqlock_t ha_lock; + int: 32; + unsigned char ha[32]; + struct hh_cache hh; + int (*output)(struct neighbour *, struct sk_buff *); + const struct neigh_ops *ops; + struct list_head gc_list; + struct callback_head rcu; + struct net_device *dev; + u8 primary_key[0]; +}; -struct net_device { - char name[16]; - struct netdev_name_node *name_node; - struct dev_ifalias *ifalias; - long unsigned int mem_end; - long unsigned int mem_start; - long unsigned int base_addr; - int irq; - long unsigned int state; - struct list_head dev_list; - struct list_head napi_list; - struct list_head unreg_list; - struct list_head close_list; - struct list_head ptype_all; - struct list_head ptype_specific; - struct { - struct list_head upper; - struct list_head lower; - } adj_list; - netdev_features_t features; - netdev_features_t hw_features; - netdev_features_t wanted_features; - netdev_features_t vlan_features; - netdev_features_t hw_enc_features; - netdev_features_t mpls_features; - netdev_features_t gso_partial_features; - int ifindex; - int group; - struct net_device_stats stats; - atomic_long_t rx_dropped; - atomic_long_t tx_dropped; - atomic_long_t rx_nohandler; - atomic_t carrier_up_count; - atomic_t carrier_down_count; - const struct net_device_ops *netdev_ops; - const struct ethtool_ops *ethtool_ops; - const struct ndisc_ops *ndisc_ops; - const struct header_ops *header_ops; - unsigned int flags; - unsigned int priv_flags; - short unsigned int gflags; - short unsigned int padded; - unsigned char operstate; - unsigned char link_mode; - unsigned char if_port; - unsigned char dma; - unsigned int mtu; - unsigned int min_mtu; - unsigned int max_mtu; - short unsigned int type; - short unsigned int hard_header_len; - unsigned char min_header_len; - short unsigned int needed_headroom; - short unsigned int needed_tailroom; - unsigned char perm_addr[32]; - unsigned char addr_assign_type; - unsigned char addr_len; - unsigned char upper_level; - unsigned char lower_level; - short unsigned int neigh_priv_len; - short unsigned int dev_id; - short unsigned int dev_port; - spinlock_t addr_list_lock; - unsigned char name_assign_type; - bool uc_promisc; - struct netdev_hw_addr_list uc; - struct netdev_hw_addr_list mc; - struct netdev_hw_addr_list dev_addrs; - struct kset *queues_kset; - unsigned int promiscuity; - unsigned int allmulti; - struct in_device *ip_ptr; - struct inet6_dev *ip6_ptr; - struct wireless_dev *ieee80211_ptr; - struct wpan_dev *ieee802154_ptr; - unsigned char *dev_addr; - struct netdev_rx_queue *_rx; - unsigned int num_rx_queues; - unsigned int real_num_rx_queues; - struct bpf_prog *xdp_prog; - long unsigned int gro_flush_timeout; - rx_handler_func_t *rx_handler; - void *rx_handler_data; - struct mini_Qdisc *miniq_ingress; - struct netdev_queue *ingress_queue; - struct nf_hook_entries *nf_hooks_ingress; - unsigned char broadcast[32]; - struct cpu_rmap *rx_cpu_rmap; - struct hlist_node index_hlist; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - struct netdev_queue *_tx; - unsigned int num_tx_queues; - unsigned int real_num_tx_queues; - struct Qdisc *qdisc; - struct hlist_head qdisc_hash[16]; - unsigned int tx_queue_len; - spinlock_t tx_global_lock; - int watchdog_timeo; - struct xps_dev_maps *xps_cpus_map; - struct xps_dev_maps *xps_rxqs_map; - struct mini_Qdisc *miniq_egress; - struct timer_list watchdog_timer; - int *pcpu_refcnt; - struct list_head todo_list; - struct list_head link_watch_list; - enum { - NETREG_UNINITIALIZED = 0, - NETREG_REGISTERED = 1, - NETREG_UNREGISTERING = 2, - NETREG_UNREGISTERED = 3, - NETREG_RELEASED = 4, - NETREG_DUMMY = 5, - } reg_state: 8; - bool dismantle; - enum { - RTNL_LINK_INITIALIZED = 0, - RTNL_LINK_INITIALIZING = 1, - } rtnl_link_state: 16; - bool needs_free_netdev; - void (*priv_destructor)(struct net_device *); - struct netpoll_info *npinfo; - possible_net_t nd_net; - union { - void *ml_priv; - struct pcpu_lstats *lstats; - struct pcpu_sw_netstats *tstats; - struct pcpu_dstats *dstats; - }; - struct device dev; - const struct attribute_group *sysfs_groups[4]; - const struct attribute_group *sysfs_rx_queue_group; - const struct rtnl_link_ops *rtnl_link_ops; - unsigned int gso_max_size; - u16 gso_max_segs; - s16 num_tc; - struct netdev_tc_txq tc_to_txq[16]; - u8 prio_tc_map[16]; - struct phy_device *phydev; - struct sfp_bus *sfp_bus; - struct lock_class_key qdisc_tx_busylock_key; - struct lock_class_key qdisc_running_key; - struct lock_class_key qdisc_xmit_lock_key; - struct lock_class_key addr_list_lock_key; - bool proto_down; - unsigned int wol_enabled: 1; +struct ipv6_stable_secret { + bool initialized; + struct in6_addr secret; }; -struct bpf_prog_ops { - int (*test_run)(struct bpf_prog *, const union bpf_attr *, union bpf_attr *); +struct ipv6_devconf { + __s32 forwarding; + __s32 hop_limit; + __s32 mtu6; + __s32 accept_ra; + __s32 accept_redirects; + __s32 autoconf; + __s32 dad_transmits; + __s32 rtr_solicits; + __s32 rtr_solicit_interval; + __s32 rtr_solicit_max_interval; + __s32 rtr_solicit_delay; + __s32 force_mld_version; + __s32 mldv1_unsolicited_report_interval; + __s32 mldv2_unsolicited_report_interval; + __s32 use_tempaddr; + __s32 temp_valid_lft; + __s32 temp_prefered_lft; + __s32 regen_max_retry; + __s32 max_desync_factor; + __s32 max_addresses; + __s32 accept_ra_defrtr; + __s32 accept_ra_min_hop_limit; + __s32 accept_ra_pinfo; + __s32 ignore_routes_with_linkdown; + __s32 proxy_ndp; + __s32 accept_source_route; + __s32 accept_ra_from_local; + __s32 disable_ipv6; + __s32 drop_unicast_in_l2_multicast; + __s32 accept_dad; + __s32 force_tllao; + __s32 ndisc_notify; + __s32 suppress_frag_ndisc; + __s32 accept_ra_mtu; + __s32 drop_unsolicited_na; + struct ipv6_stable_secret stable_secret; + __s32 use_oif_addrs_only; + __s32 keep_addr_on_down; + __s32 seg6_enabled; + __u32 enhanced_dad; + __u32 addr_gen_mode; + __s32 disable_policy; + __s32 ndisc_tclass; + struct ctl_table_header *sysctl_header; }; -struct bpf_offload_dev; +struct nf_queue_entry; -struct bpf_prog_offload { - struct bpf_prog *prog; - struct net_device *netdev; - struct bpf_offload_dev *offdev; - void *dev_priv; - struct list_head offloads; - bool dev_state; - bool opt_failed; - void *jited_image; - u32 jited_len; +struct nf_queue_handler { + int (*outfn)(struct nf_queue_entry *, unsigned int); + void (*nf_hook_drop)(struct net *); }; -struct bpf_prog_stats { - u64 cnt; - u64 nsecs; - struct u64_stats_sync syncp; +enum nf_log_type { + NF_LOG_TYPE_LOG = 0, + NF_LOG_TYPE_ULOG = 1, + NF_LOG_TYPE_MAX = 2, }; -struct btf_func_model { - u8 ret_size; - u8 nr_args; - u8 arg_size[12]; -}; +typedef u8 u_int8_t; -struct bpf_trampoline { - struct hlist_node hlist; - struct mutex mutex; - refcount_t refcnt; - u64 key; - struct { - struct btf_func_model model; - void *addr; - bool ftrace_managed; - } func; - struct hlist_head progs_hlist[2]; - int progs_cnt[2]; - void *image; - u64 selector; +struct nf_loginfo; + +typedef void nf_logfn(struct net *, u_int8_t, unsigned int, const struct sk_buff *, const struct net_device *, const struct net_device *, const struct nf_loginfo *, const char *); + +struct nf_logger { + char *name; + enum nf_log_type type; + nf_logfn *logfn; + struct module *me; }; -struct bpf_func_info_aux { - bool unreliable; +struct hlist_nulls_head { + struct hlist_nulls_node *first; }; -struct bpf_jit_poke_descriptor { - void *ip; - union { - struct { - struct bpf_map *map; - u32 key; - } tail_call; - }; - bool ip_stable; - u8 adj_off; - u16 reason; +struct ip_conntrack_stat { + unsigned int found; + unsigned int invalid; + unsigned int ignore; + unsigned int insert; + unsigned int insert_failed; + unsigned int drop; + unsigned int early_drop; + unsigned int error; + unsigned int expect_new; + unsigned int expect_create; + unsigned int expect_delete; + unsigned int search_restart; }; -typedef unsigned int sk_buff_data_t; +struct ct_pcpu { + spinlock_t lock; + struct hlist_nulls_head unconfirmed; + struct hlist_nulls_head dying; +}; -struct skb_ext; +typedef enum { + SS_FREE = 0, + SS_UNCONNECTED = 1, + SS_CONNECTING = 2, + SS_CONNECTED = 3, + SS_DISCONNECTING = 4, +} socket_state; -struct sk_buff { - union { - struct { - struct sk_buff *next; - struct sk_buff *prev; - union { - struct net_device *dev; - long unsigned int dev_scratch; - }; - }; - struct rb_node rbnode; - struct list_head list; - }; - union { - struct sock *sk; - int ip_defrag_offset; - }; - union { - ktime_t tstamp; - u64 skb_mstamp_ns; - }; - char cb[48]; - union { - struct { - long unsigned int _skb_refdst; - void (*destructor)(struct sk_buff *); - }; - struct list_head tcp_tsorted_anchor; - }; - long unsigned int _nfct; - unsigned int len; - unsigned int data_len; - __u16 mac_len; - __u16 hdr_len; - __u16 queue_mapping; - __u8 __cloned_offset[0]; - __u8 cloned: 1; - __u8 nohdr: 1; - __u8 fclone: 2; - __u8 peeked: 1; - __u8 head_frag: 1; - __u8 pfmemalloc: 1; - __u8 active_extensions; - __u32 headers_start[0]; - __u8 __pkt_type_offset[0]; - __u8 pkt_type: 3; - __u8 ignore_df: 1; - __u8 nf_trace: 1; - __u8 ip_summed: 2; - __u8 ooo_okay: 1; - __u8 l4_hash: 1; - __u8 sw_hash: 1; - __u8 wifi_acked_valid: 1; - __u8 wifi_acked: 1; - __u8 no_fcs: 1; - __u8 encapsulation: 1; - __u8 encap_hdr_csum: 1; - __u8 csum_valid: 1; - __u8 __pkt_vlan_present_offset[0]; - __u8 vlan_present: 1; - __u8 csum_complete_sw: 1; - __u8 csum_level: 2; - __u8 csum_not_inet: 1; - __u8 dst_pending_confirm: 1; - __u8 ndisc_nodetype: 2; - __u8 ipvs_property: 1; - __u8 inner_protocol_type: 1; - __u8 remcsum_offload: 1; - __u8 tc_skip_classify: 1; - __u8 tc_at_ingress: 1; - __u8 tc_redirected: 1; - __u8 tc_from_ingress: 1; - __u16 tc_index; - union { - __wsum csum; - struct { - __u16 csum_start; - __u16 csum_offset; - }; - }; - __u32 priority; - int skb_iif; - __u32 hash; - __be16 vlan_proto; - __u16 vlan_tci; - union { - unsigned int napi_id; - unsigned int sender_cpu; - }; - __u32 secmark; - union { - __u32 mark; - __u32 reserved_tailroom; - }; - union { - __be16 inner_protocol; - __u8 inner_ipproto; - }; - __u16 inner_transport_header; - __u16 inner_network_header; - __u16 inner_mac_header; - __be16 protocol; - __u16 transport_header; - __u16 network_header; - __u16 mac_header; - __u32 headers_end[0]; - sk_buff_data_t tail; - sk_buff_data_t end; - unsigned char *head; - unsigned char *data; - unsigned int truesize; - refcount_t users; - struct skb_ext *extensions; +struct socket_wq { + wait_queue_head_t wait; + struct fasync_struct *fasync_list; + long unsigned int flags; + struct callback_head rcu; + long: 64; }; -struct sg_table { - struct scatterlist *sgl; - unsigned int nents; - unsigned int orig_nents; -}; +struct proto_ops; -enum suspend_stat_step { - SUSPEND_FREEZE = 1, - SUSPEND_PREPARE = 2, - SUSPEND_SUSPEND = 3, - SUSPEND_SUSPEND_LATE = 4, - SUSPEND_SUSPEND_NOIRQ = 5, - SUSPEND_RESUME_NOIRQ = 6, - SUSPEND_RESUME_EARLY = 7, - SUSPEND_RESUME = 8, +struct socket { + socket_state state; + short int type; + long unsigned int flags; + struct file *file; + struct sock *sk; + const struct proto_ops *ops; + long: 64; + long: 64; + long: 64; + struct socket_wq wq; }; -struct suspend_stats { - int success; - int fail; - int failed_freeze; - int failed_prepare; - int failed_suspend; - int failed_suspend_late; - int failed_suspend_noirq; - int failed_resume; - int failed_resume_early; - int failed_resume_noirq; - int last_failed_dev; - char failed_devs[80]; - int last_failed_errno; - int errno[2]; - int last_failed_step; - enum suspend_stat_step failed_steps[2]; +typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *, unsigned int, size_t); + +struct proto_ops { + int family; + struct module *owner; + int (*release)(struct socket *); + int (*bind)(struct socket *, struct sockaddr *, int); + int (*connect)(struct socket *, struct sockaddr *, int, int); + int (*socketpair)(struct socket *, struct socket *); + int (*accept)(struct socket *, struct socket *, int, bool); + int (*getname)(struct socket *, struct sockaddr *, int); + __poll_t (*poll)(struct file *, struct socket *, struct poll_table_struct *); + int (*ioctl)(struct socket *, unsigned int, long unsigned int); + int (*compat_ioctl)(struct socket *, unsigned int, long unsigned int); + int (*gettstamp)(struct socket *, void *, bool, bool); + int (*listen)(struct socket *, int); + int (*shutdown)(struct socket *, int); + int (*setsockopt)(struct socket *, int, int, char *, unsigned int); + int (*getsockopt)(struct socket *, int, int, char *, int *); + int (*compat_setsockopt)(struct socket *, int, int, char *, unsigned int); + int (*compat_getsockopt)(struct socket *, int, int, char *, int *); + int (*sendmsg)(struct socket *, struct msghdr *, size_t); + int (*recvmsg)(struct socket *, struct msghdr *, size_t, int); + int (*mmap)(struct file *, struct socket *, struct vm_area_struct *); + ssize_t (*sendpage)(struct socket *, struct page *, int, size_t, int); + ssize_t (*splice_read)(struct socket *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); + int (*set_peek_off)(struct sock *, int); + int (*peek_len)(struct socket *); + int (*read_sock)(struct sock *, read_descriptor_t *, sk_read_actor_t); + int (*sendpage_locked)(struct sock *, struct page *, int, size_t, int); + int (*sendmsg_locked)(struct sock *, struct msghdr *, size_t); + int (*set_rcvlowat)(struct sock *, int); }; -enum s2idle_states { - S2IDLE_STATE_NONE = 0, - S2IDLE_STATE_ENTER = 1, - S2IDLE_STATE_WAKE = 2, +enum swiotlb_force { + SWIOTLB_NORMAL = 0, + SWIOTLB_FORCE = 1, + SWIOTLB_NO_FORCE = 2, }; -enum { - Root_NFS = 255, - Root_CIFS = 254, - Root_RAM0 = 1048576, - Root_RAM1 = 1048577, - Root_FD0 = 2097152, - Root_HDA1 = 3145729, - Root_HDA2 = 3145730, - Root_SDA1 = 8388609, - Root_SDA2 = 8388610, - Root_HDC1 = 23068673, - Root_SR0 = 11534336, -}; +struct pipe_buf_operations; -struct ethhdr { - unsigned char h_dest[6]; - unsigned char h_source[6]; - __be16 h_proto; +struct pipe_buffer { + struct page *page; + unsigned int offset; + unsigned int len; + const struct pipe_buf_operations *ops; + unsigned int flags; + long unsigned int private; }; -struct flow_dissector { - unsigned int used_keys; - short unsigned int offset[27]; +struct pipe_buf_operations { + int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *); + void (*release)(struct pipe_inode_info *, struct pipe_buffer *); + int (*steal)(struct pipe_inode_info *, struct pipe_buffer *); + bool (*get)(struct pipe_inode_info *, struct pipe_buffer *); }; -struct flowi_tunnel { - __be64 tun_id; +struct skb_ext { + refcount_t refcnt; + u8 offset[1]; + u8 chunks; + short: 16; + char data[0]; }; -struct flowi_common { - int flowic_oif; - int flowic_iif; - __u32 flowic_mark; - __u8 flowic_tos; - __u8 flowic_scope; - __u8 flowic_proto; - __u8 flowic_flags; - __u32 flowic_secid; - kuid_t flowic_uid; - struct flowi_tunnel flowic_tun_key; - __u32 flowic_multipath_hash; +struct skb_checksum_ops { + __wsum (*update)(const void *, int, __wsum); + __wsum (*combine)(__wsum, __wsum, int, int); }; -union flowi_uli { - struct { - __be16 dport; - __be16 sport; - } ports; - struct { - __u8 type; - __u8 code; - } icmpt; - struct { - __le16 dport; - __le16 sport; - } dnports; - __be32 spi; - __be32 gre_key; - struct { - __u8 type; - } mht; +struct pernet_operations { + struct list_head list; + int (*init)(struct net *); + void (*pre_exit)(struct net *); + void (*exit)(struct net *); + void (*exit_batch)(struct list_head *); + unsigned int *id; + size_t size; }; -struct flowi4 { - struct flowi_common __fl_common; - __be32 saddr; - __be32 daddr; - union flowi_uli uli; +struct auth_cred { + const struct cred *cred; + const char *principal; }; -struct flowi6 { - struct flowi_common __fl_common; - struct in6_addr daddr; - struct in6_addr saddr; - __be32 flowlabel; - union flowi_uli uli; - __u32 mp_hash; -}; +struct rpc_authops; -struct flowidn { - struct flowi_common __fl_common; - __le16 daddr; - __le16 saddr; - union flowi_uli uli; -}; +struct rpc_cred_cache; -struct flowi { - union { - struct flowi_common __fl_common; - struct flowi4 ip4; - struct flowi6 ip6; - struct flowidn dn; - } u; +struct rpc_auth { + unsigned int au_cslack; + unsigned int au_rslack; + unsigned int au_verfsize; + unsigned int au_ralign; + unsigned int au_flags; + const struct rpc_authops *au_ops; + rpc_authflavor_t au_flavor; + refcount_t au_count; + struct rpc_cred_cache *au_credcache; }; -struct ipstats_mib { - u64 mibs[37]; - struct u64_stats_sync syncp; +struct rpc_credops { + const char *cr_name; + int (*cr_init)(struct rpc_auth *, struct rpc_cred *); + void (*crdestroy)(struct rpc_cred *); + int (*crmatch)(struct auth_cred *, struct rpc_cred *, int); + int (*crmarshal)(struct rpc_task *, struct xdr_stream *); + int (*crrefresh)(struct rpc_task *); + int (*crvalidate)(struct rpc_task *, struct xdr_stream *); + int (*crwrap_req)(struct rpc_task *, struct xdr_stream *); + int (*crunwrap_resp)(struct rpc_task *, struct xdr_stream *); + int (*crkey_timeout)(struct rpc_cred *); + char * (*crstringify_acceptor)(struct rpc_cred *); + bool (*crneed_reencode)(struct rpc_task *); }; -struct icmp_mib { - long unsigned int mibs[28]; -}; +struct rpc_auth_create_args; -struct icmpmsg_mib { - atomic_long_t mibs[512]; +struct rpcsec_gss_info; + +struct rpc_authops { + struct module *owner; + rpc_authflavor_t au_flavor; + char *au_name; + struct rpc_auth * (*create)(const struct rpc_auth_create_args *, struct rpc_clnt *); + void (*destroy)(struct rpc_auth *); + int (*hash_cred)(struct auth_cred *, unsigned int); + struct rpc_cred * (*lookup_cred)(struct rpc_auth *, struct auth_cred *, int); + struct rpc_cred * (*crcreate)(struct rpc_auth *, struct auth_cred *, int, gfp_t); + int (*list_pseudoflavors)(rpc_authflavor_t *, int); + rpc_authflavor_t (*info2flavor)(struct rpcsec_gss_info *); + int (*flavor2info)(rpc_authflavor_t, struct rpcsec_gss_info *); + int (*key_timeout)(struct rpc_auth *, struct rpc_cred *); }; -struct icmpv6_mib { - long unsigned int mibs[6]; +struct rpc_auth_create_args { + rpc_authflavor_t pseudoflavor; + const char *target_name; }; -struct icmpv6_mib_device { - atomic_long_t mibs[6]; +struct rpcsec_gss_oid { + unsigned int len; + u8 data[32]; }; -struct icmpv6msg_mib { - atomic_long_t mibs[512]; +struct rpcsec_gss_info { + struct rpcsec_gss_oid oid; + u32 qop; + u32 service; }; -struct icmpv6msg_mib_device { - atomic_long_t mibs[512]; +struct rpc_xprt_ops { + void (*set_buffer_size)(struct rpc_xprt *, size_t, size_t); + int (*reserve_xprt)(struct rpc_xprt *, struct rpc_task *); + void (*release_xprt)(struct rpc_xprt *, struct rpc_task *); + void (*alloc_slot)(struct rpc_xprt *, struct rpc_task *); + void (*free_slot)(struct rpc_xprt *, struct rpc_rqst *); + void (*rpcbind)(struct rpc_task *); + void (*set_port)(struct rpc_xprt *, short unsigned int); + void (*connect)(struct rpc_xprt *, struct rpc_task *); + int (*buf_alloc)(struct rpc_task *); + void (*buf_free)(struct rpc_task *); + void (*prepare_request)(struct rpc_rqst *); + int (*send_request)(struct rpc_rqst *); + void (*wait_for_reply_request)(struct rpc_task *); + void (*timer)(struct rpc_xprt *, struct rpc_task *); + void (*release_request)(struct rpc_task *); + void (*close)(struct rpc_xprt *); + void (*destroy)(struct rpc_xprt *); + void (*set_connect_timeout)(struct rpc_xprt *, long unsigned int, long unsigned int); + void (*print_stats)(struct rpc_xprt *, struct seq_file *); + int (*enable_swap)(struct rpc_xprt *); + void (*disable_swap)(struct rpc_xprt *); + void (*inject_disconnect)(struct rpc_xprt *); + int (*bc_setup)(struct rpc_xprt *, unsigned int); + size_t (*bc_maxpayload)(struct rpc_xprt *); + unsigned int (*bc_num_slots)(struct rpc_xprt *); + void (*bc_free_rqst)(struct rpc_rqst *); + void (*bc_destroy)(struct rpc_xprt *, unsigned int); }; -struct tcp_mib { - long unsigned int mibs[16]; +struct rpc_xprt_switch { + spinlock_t xps_lock; + struct kref xps_kref; + unsigned int xps_nxprts; + unsigned int xps_nactive; + atomic_long_t xps_queuelen; + struct list_head xps_xprt_list; + struct net *xps_net; + const struct rpc_xprt_iter_ops *xps_iter_ops; + struct callback_head xps_rcu; }; -struct udp_mib { - long unsigned int mibs[9]; +struct rpc_stat { + const struct rpc_program *program; + unsigned int netcnt; + unsigned int netudpcnt; + unsigned int nettcpcnt; + unsigned int nettcpconn; + unsigned int netreconn; + unsigned int rpccnt; + unsigned int rpcretrans; + unsigned int rpcauthrefresh; + unsigned int rpcgarbage; }; -struct linux_mib { - long unsigned int mibs[120]; +struct rpc_version; + +struct rpc_program { + const char *name; + u32 number; + unsigned int nrvers; + const struct rpc_version **version; + struct rpc_stat *stats; + const char *pipe_dir_name; }; -struct inet_frags; +struct ipv6_params { + __s32 disable_ipv6; + __s32 autoconf; +}; -struct fqdir { - long int high_thresh; - long int low_thresh; - int timeout; - int max_dist; - struct inet_frags *f; - struct net *net; - bool dead; - long: 56; - long: 64; - long: 64; - struct rhashtable rhashtable; - long: 64; - long: 64; +struct dql { + unsigned int num_queued; + unsigned int adj_limit; + unsigned int last_obj_cnt; + long: 32; long: 64; long: 64; long: 64; long: 64; long: 64; - atomic_long_t mem; - struct work_struct destroy_work; long: 64; + unsigned int limit; + unsigned int num_completed; + unsigned int prev_ovlimit; + unsigned int prev_num_queued; + unsigned int prev_last_obj_cnt; + unsigned int lowest_slack; + long unsigned int slack_start_time; + unsigned int max_limit; + unsigned int min_limit; + unsigned int slack_hold_time; + long: 32; long: 64; long: 64; }; -struct inet_frag_queue; - -struct inet_frags { - unsigned int qsize; - void (*constructor)(struct inet_frag_queue *, const void *); - void (*destructor)(struct inet_frag_queue *); - void (*frag_expire)(struct timer_list *); - struct kmem_cache *frags_cachep; - const char *frags_cache_name; - struct rhashtable_params rhash_params; - refcount_t refcnt; - struct completion completion; +struct ethtool_drvinfo { + __u32 cmd; + char driver[32]; + char version[32]; + char fw_version[32]; + char bus_info[32]; + char erom_version[32]; + char reserved2[12]; + __u32 n_priv_flags; + __u32 n_stats; + __u32 testinfo_len; + __u32 eedump_len; + __u32 regdump_len; }; -struct frag_v4_compare_key { - __be32 saddr; - __be32 daddr; - u32 user; - u32 vif; - __be16 id; - u16 protocol; +struct ethtool_wolinfo { + __u32 cmd; + __u32 supported; + __u32 wolopts; + __u8 sopass[6]; }; -struct frag_v6_compare_key { - struct in6_addr saddr; - struct in6_addr daddr; - u32 user; - __be32 id; - u32 iif; +struct ethtool_tunable { + __u32 cmd; + __u32 id; + __u32 type_id; + __u32 len; + void *data[0]; }; -struct inet_frag_queue { - struct rhash_head node; - union { - struct frag_v4_compare_key v4; - struct frag_v6_compare_key v6; - } key; - struct timer_list timer; - spinlock_t lock; - refcount_t refcnt; - struct rb_root rb_fragments; - struct sk_buff *fragments_tail; - struct sk_buff *last_run_head; - ktime_t stamp; - int len; - int meat; - __u8 flags; - u16 max_size; - struct fqdir *fqdir; - struct callback_head rcu; +struct ethtool_regs { + __u32 cmd; + __u32 version; + __u32 len; + __u8 data[0]; }; -struct fib_rule; +struct ethtool_eeprom { + __u32 cmd; + __u32 magic; + __u32 offset; + __u32 len; + __u8 data[0]; +}; -struct fib_lookup_arg; +struct ethtool_eee { + __u32 cmd; + __u32 supported; + __u32 advertised; + __u32 lp_advertised; + __u32 eee_active; + __u32 eee_enabled; + __u32 tx_lpi_enabled; + __u32 tx_lpi_timer; + __u32 reserved[2]; +}; -struct fib_rule_hdr; +struct ethtool_modinfo { + __u32 cmd; + __u32 type; + __u32 eeprom_len; + __u32 reserved[8]; +}; -struct nlattr; +struct ethtool_coalesce { + __u32 cmd; + __u32 rx_coalesce_usecs; + __u32 rx_max_coalesced_frames; + __u32 rx_coalesce_usecs_irq; + __u32 rx_max_coalesced_frames_irq; + __u32 tx_coalesce_usecs; + __u32 tx_max_coalesced_frames; + __u32 tx_coalesce_usecs_irq; + __u32 tx_max_coalesced_frames_irq; + __u32 stats_block_coalesce_usecs; + __u32 use_adaptive_rx_coalesce; + __u32 use_adaptive_tx_coalesce; + __u32 pkt_rate_low; + __u32 rx_coalesce_usecs_low; + __u32 rx_max_coalesced_frames_low; + __u32 tx_coalesce_usecs_low; + __u32 tx_max_coalesced_frames_low; + __u32 pkt_rate_high; + __u32 rx_coalesce_usecs_high; + __u32 rx_max_coalesced_frames_high; + __u32 tx_coalesce_usecs_high; + __u32 tx_max_coalesced_frames_high; + __u32 rate_sample_interval; +}; -struct netlink_ext_ack; +struct ethtool_ringparam { + __u32 cmd; + __u32 rx_max_pending; + __u32 rx_mini_max_pending; + __u32 rx_jumbo_max_pending; + __u32 tx_max_pending; + __u32 rx_pending; + __u32 rx_mini_pending; + __u32 rx_jumbo_pending; + __u32 tx_pending; +}; -struct nla_policy; +struct ethtool_channels { + __u32 cmd; + __u32 max_rx; + __u32 max_tx; + __u32 max_other; + __u32 max_combined; + __u32 rx_count; + __u32 tx_count; + __u32 other_count; + __u32 combined_count; +}; -struct fib_rules_ops { - int family; - struct list_head list; - int rule_size; - int addr_size; - int unresolved_rules; - int nr_goto_rules; - unsigned int fib_rules_seq; - int (*action)(struct fib_rule *, struct flowi *, int, struct fib_lookup_arg *); - bool (*suppress)(struct fib_rule *, struct fib_lookup_arg *); - int (*match)(struct fib_rule *, struct flowi *, int); - int (*configure)(struct fib_rule *, struct sk_buff *, struct fib_rule_hdr *, struct nlattr **, struct netlink_ext_ack *); - int (*delete)(struct fib_rule *); - int (*compare)(struct fib_rule *, struct fib_rule_hdr *, struct nlattr **); - int (*fill)(struct fib_rule *, struct sk_buff *, struct fib_rule_hdr *); - size_t (*nlmsg_payload)(struct fib_rule *); - void (*flush_cache)(struct fib_rules_ops *); - int nlgroup; - const struct nla_policy *policy; - struct list_head rules_list; - struct module *owner; - struct net *fro_net; - struct callback_head rcu; +struct ethtool_pauseparam { + __u32 cmd; + __u32 autoneg; + __u32 rx_pause; + __u32 tx_pause; }; -enum tcp_ca_event { - CA_EVENT_TX_START = 0, - CA_EVENT_CWND_RESTART = 1, - CA_EVENT_COMPLETE_CWR = 2, - CA_EVENT_LOSS = 3, - CA_EVENT_ECN_NO_CE = 4, - CA_EVENT_ECN_IS_CE = 5, +struct ethtool_test { + __u32 cmd; + __u32 flags; + __u32 reserved; + __u32 len; + __u64 data[0]; }; -struct ack_sample; +struct ethtool_stats { + __u32 cmd; + __u32 n_stats; + __u64 data[0]; +}; -struct rate_sample; +struct ethtool_tcpip4_spec { + __be32 ip4src; + __be32 ip4dst; + __be16 psrc; + __be16 pdst; + __u8 tos; +}; -union tcp_cc_info; +struct ethtool_ah_espip4_spec { + __be32 ip4src; + __be32 ip4dst; + __be32 spi; + __u8 tos; +}; -struct tcp_congestion_ops { - struct list_head list; - u32 key; - u32 flags; - void (*init)(struct sock *); - void (*release)(struct sock *); - u32 (*ssthresh)(struct sock *); - void (*cong_avoid)(struct sock *, u32, u32); - void (*set_state)(struct sock *, u8); - void (*cwnd_event)(struct sock *, enum tcp_ca_event); - void (*in_ack_event)(struct sock *, u32); - u32 (*undo_cwnd)(struct sock *); - void (*pkts_acked)(struct sock *, const struct ack_sample *); - u32 (*min_tso_segs)(struct sock *); - u32 (*sndbuf_expand)(struct sock *); - void (*cong_control)(struct sock *, const struct rate_sample *); - size_t (*get_info)(struct sock *, u32, int *, union tcp_cc_info *); - char name[16]; - struct module *owner; +struct ethtool_usrip4_spec { + __be32 ip4src; + __be32 ip4dst; + __be32 l4_4_bytes; + __u8 tos; + __u8 ip_ver; + __u8 proto; }; -struct fib_notifier_ops { - int family; - struct list_head list; - unsigned int (*fib_seq_read)(struct net *); - int (*fib_dump)(struct net *, struct notifier_block *, struct netlink_ext_ack *); - struct module *owner; - struct callback_head rcu; +struct ethtool_tcpip6_spec { + __be32 ip6src[4]; + __be32 ip6dst[4]; + __be16 psrc; + __be16 pdst; + __u8 tclass; }; -struct xfrm_state; +struct ethtool_ah_espip6_spec { + __be32 ip6src[4]; + __be32 ip6dst[4]; + __be32 spi; + __u8 tclass; +}; -struct lwtunnel_state; +struct ethtool_usrip6_spec { + __be32 ip6src[4]; + __be32 ip6dst[4]; + __be32 l4_4_bytes; + __u8 tclass; + __u8 l4_proto; +}; -struct dst_entry { - struct net_device *dev; - struct dst_ops *ops; - long unsigned int _metrics; - long unsigned int expires; - struct xfrm_state *xfrm; - int (*input)(struct sk_buff *); - int (*output)(struct net *, struct sock *, struct sk_buff *); - short unsigned int flags; - short int obsolete; - short unsigned int header_len; - short unsigned int trailer_len; - atomic_t __refcnt; - int __use; - long unsigned int lastuse; - struct lwtunnel_state *lwtstate; - struct callback_head callback_head; - short int error; - short int __pad; - __u32 tclassid; +union ethtool_flow_union { + struct ethtool_tcpip4_spec tcp_ip4_spec; + struct ethtool_tcpip4_spec udp_ip4_spec; + struct ethtool_tcpip4_spec sctp_ip4_spec; + struct ethtool_ah_espip4_spec ah_ip4_spec; + struct ethtool_ah_espip4_spec esp_ip4_spec; + struct ethtool_usrip4_spec usr_ip4_spec; + struct ethtool_tcpip6_spec tcp_ip6_spec; + struct ethtool_tcpip6_spec udp_ip6_spec; + struct ethtool_tcpip6_spec sctp_ip6_spec; + struct ethtool_ah_espip6_spec ah_ip6_spec; + struct ethtool_ah_espip6_spec esp_ip6_spec; + struct ethtool_usrip6_spec usr_ip6_spec; + struct ethhdr ether_spec; + __u8 hdata[52]; }; -struct hh_cache { - unsigned int hh_len; - seqlock_t hh_lock; - long unsigned int hh_data[12]; +struct ethtool_flow_ext { + __u8 padding[2]; + unsigned char h_dest[6]; + __be16 vlan_etype; + __be16 vlan_tci; + __be32 data[2]; }; -struct neigh_table; +struct ethtool_rx_flow_spec { + __u32 flow_type; + union ethtool_flow_union h_u; + struct ethtool_flow_ext h_ext; + union ethtool_flow_union m_u; + struct ethtool_flow_ext m_ext; + __u64 ring_cookie; + __u32 location; +}; -struct neigh_parms; +struct ethtool_rxnfc { + __u32 cmd; + __u32 flow_type; + __u64 data; + struct ethtool_rx_flow_spec fs; + union { + __u32 rule_cnt; + __u32 rss_context; + }; + __u32 rule_locs[0]; +}; -struct neigh_ops; +struct ethtool_flash { + __u32 cmd; + __u32 region; + char data[128]; +}; -struct neighbour { - struct neighbour *next; - struct neigh_table *tbl; - struct neigh_parms *parms; - long unsigned int confirmed; - long unsigned int updated; - rwlock_t lock; - refcount_t refcnt; - unsigned int arp_queue_len_bytes; - struct sk_buff_head arp_queue; - struct timer_list timer; - long unsigned int used; - atomic_t probes; - __u8 flags; - __u8 nud_state; - __u8 type; - __u8 dead; - u8 protocol; - seqlock_t ha_lock; - int: 32; - unsigned char ha[32]; - struct hh_cache hh; - int (*output)(struct neighbour *, struct sk_buff *); - const struct neigh_ops *ops; - struct list_head gc_list; - struct callback_head rcu; - struct net_device *dev; - u8 primary_key[0]; +struct ethtool_dump { + __u32 cmd; + __u32 version; + __u32 flag; + __u32 len; + __u8 data[0]; }; -struct ipv6_stable_secret { - bool initialized; - struct in6_addr secret; +struct ethtool_ts_info { + __u32 cmd; + __u32 so_timestamping; + __s32 phc_index; + __u32 tx_types; + __u32 tx_reserved[3]; + __u32 rx_filters; + __u32 rx_reserved[3]; }; -struct ipv6_devconf { - __s32 forwarding; - __s32 hop_limit; - __s32 mtu6; - __s32 accept_ra; - __s32 accept_redirects; - __s32 autoconf; - __s32 dad_transmits; - __s32 rtr_solicits; - __s32 rtr_solicit_interval; - __s32 rtr_solicit_max_interval; - __s32 rtr_solicit_delay; - __s32 force_mld_version; - __s32 mldv1_unsolicited_report_interval; - __s32 mldv2_unsolicited_report_interval; - __s32 use_tempaddr; - __s32 temp_valid_lft; - __s32 temp_prefered_lft; - __s32 regen_max_retry; - __s32 max_desync_factor; - __s32 max_addresses; - __s32 accept_ra_defrtr; - __s32 accept_ra_min_hop_limit; - __s32 accept_ra_pinfo; - __s32 ignore_routes_with_linkdown; - __s32 proxy_ndp; - __s32 accept_source_route; - __s32 accept_ra_from_local; - __s32 disable_ipv6; - __s32 drop_unicast_in_l2_multicast; - __s32 accept_dad; - __s32 force_tllao; - __s32 ndisc_notify; - __s32 suppress_frag_ndisc; - __s32 accept_ra_mtu; - __s32 drop_unsolicited_na; - struct ipv6_stable_secret stable_secret; - __s32 use_oif_addrs_only; - __s32 keep_addr_on_down; - __s32 seg6_enabled; - __u32 enhanced_dad; - __u32 addr_gen_mode; - __s32 disable_policy; - __s32 ndisc_tclass; - struct ctl_table_header *sysctl_header; +struct ethtool_fecparam { + __u32 cmd; + __u32 active_fec; + __u32 fec; + __u32 reserved; }; -struct nf_queue_entry; +struct ethtool_link_settings { + __u32 cmd; + __u32 speed; + __u8 duplex; + __u8 port; + __u8 phy_address; + __u8 autoneg; + __u8 mdio_support; + __u8 eth_tp_mdix; + __u8 eth_tp_mdix_ctrl; + __s8 link_mode_masks_nwords; + __u8 transceiver; + __u8 reserved1[3]; + __u32 reserved[7]; + __u32 link_mode_masks[0]; +}; -struct nf_queue_handler { - int (*outfn)(struct nf_queue_entry *, unsigned int); - void (*nf_hook_drop)(struct net *); +enum ethtool_phys_id_state { + ETHTOOL_ID_INACTIVE = 0, + ETHTOOL_ID_ACTIVE = 1, + ETHTOOL_ID_ON = 2, + ETHTOOL_ID_OFF = 3, }; -enum nf_log_type { - NF_LOG_TYPE_LOG = 0, - NF_LOG_TYPE_ULOG = 1, - NF_LOG_TYPE_MAX = 2, +struct ethtool_link_ksettings { + struct ethtool_link_settings base; + struct { + long unsigned int supported[2]; + long unsigned int advertising[2]; + long unsigned int lp_advertising[2]; + } link_modes; }; -typedef u8 u_int8_t; +struct ethtool_ops { + void (*get_drvinfo)(struct net_device *, struct ethtool_drvinfo *); + int (*get_regs_len)(struct net_device *); + void (*get_regs)(struct net_device *, struct ethtool_regs *, void *); + void (*get_wol)(struct net_device *, struct ethtool_wolinfo *); + int (*set_wol)(struct net_device *, struct ethtool_wolinfo *); + u32 (*get_msglevel)(struct net_device *); + void (*set_msglevel)(struct net_device *, u32); + int (*nway_reset)(struct net_device *); + u32 (*get_link)(struct net_device *); + int (*get_eeprom_len)(struct net_device *); + int (*get_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *); + int (*set_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *); + int (*get_coalesce)(struct net_device *, struct ethtool_coalesce *); + int (*set_coalesce)(struct net_device *, struct ethtool_coalesce *); + void (*get_ringparam)(struct net_device *, struct ethtool_ringparam *); + int (*set_ringparam)(struct net_device *, struct ethtool_ringparam *); + void (*get_pauseparam)(struct net_device *, struct ethtool_pauseparam *); + int (*set_pauseparam)(struct net_device *, struct ethtool_pauseparam *); + void (*self_test)(struct net_device *, struct ethtool_test *, u64 *); + void (*get_strings)(struct net_device *, u32, u8 *); + int (*set_phys_id)(struct net_device *, enum ethtool_phys_id_state); + void (*get_ethtool_stats)(struct net_device *, struct ethtool_stats *, u64 *); + int (*begin)(struct net_device *); + void (*complete)(struct net_device *); + u32 (*get_priv_flags)(struct net_device *); + int (*set_priv_flags)(struct net_device *, u32); + int (*get_sset_count)(struct net_device *, int); + int (*get_rxnfc)(struct net_device *, struct ethtool_rxnfc *, u32 *); + int (*set_rxnfc)(struct net_device *, struct ethtool_rxnfc *); + int (*flash_device)(struct net_device *, struct ethtool_flash *); + int (*reset)(struct net_device *, u32 *); + u32 (*get_rxfh_key_size)(struct net_device *); + u32 (*get_rxfh_indir_size)(struct net_device *); + int (*get_rxfh)(struct net_device *, u32 *, u8 *, u8 *); + int (*set_rxfh)(struct net_device *, const u32 *, const u8 *, const u8); + int (*get_rxfh_context)(struct net_device *, u32 *, u8 *, u8 *, u32); + int (*set_rxfh_context)(struct net_device *, const u32 *, const u8 *, const u8, u32 *, bool); + void (*get_channels)(struct net_device *, struct ethtool_channels *); + int (*set_channels)(struct net_device *, struct ethtool_channels *); + int (*get_dump_flag)(struct net_device *, struct ethtool_dump *); + int (*get_dump_data)(struct net_device *, struct ethtool_dump *, void *); + int (*set_dump)(struct net_device *, struct ethtool_dump *); + int (*get_ts_info)(struct net_device *, struct ethtool_ts_info *); + int (*get_module_info)(struct net_device *, struct ethtool_modinfo *); + int (*get_module_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *); + int (*get_eee)(struct net_device *, struct ethtool_eee *); + int (*set_eee)(struct net_device *, struct ethtool_eee *); + int (*get_tunable)(struct net_device *, const struct ethtool_tunable *, void *); + int (*set_tunable)(struct net_device *, const struct ethtool_tunable *, const void *); + int (*get_per_queue_coalesce)(struct net_device *, u32, struct ethtool_coalesce *); + int (*set_per_queue_coalesce)(struct net_device *, u32, struct ethtool_coalesce *); + int (*get_link_ksettings)(struct net_device *, struct ethtool_link_ksettings *); + int (*set_link_ksettings)(struct net_device *, const struct ethtool_link_ksettings *); + int (*get_fecparam)(struct net_device *, struct ethtool_fecparam *); + int (*set_fecparam)(struct net_device *, struct ethtool_fecparam *); + void (*get_ethtool_phy_stats)(struct net_device *, struct ethtool_stats *, u64 *); +}; -struct nf_loginfo; +struct xdp_mem_info { + u32 type; + u32 id; +}; -typedef void nf_logfn(struct net *, u_int8_t, unsigned int, const struct sk_buff *, const struct net_device *, const struct net_device *, const struct nf_loginfo *, const char *); +struct xdp_rxq_info { + struct net_device *dev; + u32 queue_index; + u32 reg_state; + struct xdp_mem_info mem; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; -struct nf_logger { - char *name; - enum nf_log_type type; - nf_logfn *logfn; - struct module *me; +struct xdp_frame { + void *data; + u16 len; + u16 headroom; + u16 metasize; + struct xdp_mem_info mem; + struct net_device *dev_rx; }; -struct hlist_nulls_head { - struct hlist_nulls_node *first; +struct nlmsghdr { + __u32 nlmsg_len; + __u16 nlmsg_type; + __u16 nlmsg_flags; + __u32 nlmsg_seq; + __u32 nlmsg_pid; }; -struct ct_pcpu { - spinlock_t lock; - struct hlist_nulls_head unconfirmed; - struct hlist_nulls_head dying; +struct nlattr { + __u16 nla_len; + __u16 nla_type; }; -struct ip_conntrack_stat { - unsigned int found; - unsigned int invalid; - unsigned int ignore; - unsigned int insert; - unsigned int insert_failed; - unsigned int drop; - unsigned int early_drop; - unsigned int error; - unsigned int expect_new; - unsigned int expect_create; - unsigned int expect_delete; - unsigned int search_restart; +struct netlink_ext_ack { + const char *_msg; + const struct nlattr *bad_attr; + u8 cookie[20]; + u8 cookie_len; }; -typedef enum { - SS_FREE = 0, - SS_UNCONNECTED = 1, - SS_CONNECTING = 2, - SS_CONNECTED = 3, - SS_DISCONNECTING = 4, -} socket_state; +struct netlink_callback { + struct sk_buff *skb; + const struct nlmsghdr *nlh; + int (*dump)(struct sk_buff *, struct netlink_callback *); + int (*done)(struct netlink_callback *); + void *data; + struct module *module; + struct netlink_ext_ack *extack; + u16 family; + u16 min_dump_alloc; + bool strict_check; + u16 answer_flags; + unsigned int prev_seq; + unsigned int seq; + union { + u8 ctx[48]; + long int args[6]; + }; +}; -struct socket_wq { - wait_queue_head_t wait; - struct fasync_struct *fasync_list; - long unsigned int flags; - struct callback_head rcu; - long: 64; +struct ndmsg { + __u8 ndm_family; + __u8 ndm_pad1; + __u16 ndm_pad2; + __s32 ndm_ifindex; + __u16 ndm_state; + __u8 ndm_flags; + __u8 ndm_type; }; -struct proto_ops; +struct rtnl_link_stats64 { + __u64 rx_packets; + __u64 tx_packets; + __u64 rx_bytes; + __u64 tx_bytes; + __u64 rx_errors; + __u64 tx_errors; + __u64 rx_dropped; + __u64 tx_dropped; + __u64 multicast; + __u64 collisions; + __u64 rx_length_errors; + __u64 rx_over_errors; + __u64 rx_crc_errors; + __u64 rx_frame_errors; + __u64 rx_fifo_errors; + __u64 rx_missed_errors; + __u64 tx_aborted_errors; + __u64 tx_carrier_errors; + __u64 tx_fifo_errors; + __u64 tx_heartbeat_errors; + __u64 tx_window_errors; + __u64 rx_compressed; + __u64 tx_compressed; + __u64 rx_nohandler; +}; -struct socket { - socket_state state; - short int type; - long unsigned int flags; - struct file *file; - struct sock *sk; - const struct proto_ops *ops; - long: 64; - long: 64; - long: 64; - struct socket_wq wq; +struct ifla_vf_guid { + __u32 vf; + __u64 guid; }; -typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *, unsigned int, size_t); +struct ifla_vf_stats { + __u64 rx_packets; + __u64 tx_packets; + __u64 rx_bytes; + __u64 tx_bytes; + __u64 broadcast; + __u64 multicast; + __u64 rx_dropped; + __u64 tx_dropped; +}; -struct proto_ops { - int family; - struct module *owner; - int (*release)(struct socket *); - int (*bind)(struct socket *, struct sockaddr *, int); - int (*connect)(struct socket *, struct sockaddr *, int, int); - int (*socketpair)(struct socket *, struct socket *); - int (*accept)(struct socket *, struct socket *, int, bool); - int (*getname)(struct socket *, struct sockaddr *, int); - __poll_t (*poll)(struct file *, struct socket *, struct poll_table_struct *); - int (*ioctl)(struct socket *, unsigned int, long unsigned int); - int (*compat_ioctl)(struct socket *, unsigned int, long unsigned int); - int (*gettstamp)(struct socket *, void *, bool, bool); - int (*listen)(struct socket *, int); - int (*shutdown)(struct socket *, int); - int (*setsockopt)(struct socket *, int, int, char *, unsigned int); - int (*getsockopt)(struct socket *, int, int, char *, int *); - int (*compat_setsockopt)(struct socket *, int, int, char *, unsigned int); - int (*compat_getsockopt)(struct socket *, int, int, char *, int *); - int (*sendmsg)(struct socket *, struct msghdr *, size_t); - int (*recvmsg)(struct socket *, struct msghdr *, size_t, int); - int (*mmap)(struct file *, struct socket *, struct vm_area_struct *); - ssize_t (*sendpage)(struct socket *, struct page *, int, size_t, int); - ssize_t (*splice_read)(struct socket *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); - int (*set_peek_off)(struct sock *, int); - int (*peek_len)(struct socket *); - int (*read_sock)(struct sock *, read_descriptor_t *, sk_read_actor_t); - int (*sendpage_locked)(struct sock *, struct page *, int, size_t, int); - int (*sendmsg_locked)(struct sock *, struct msghdr *, size_t); - int (*set_rcvlowat)(struct sock *, int); +struct ifla_vf_info { + __u32 vf; + __u8 mac[32]; + __u32 vlan; + __u32 qos; + __u32 spoofchk; + __u32 linkstate; + __u32 min_tx_rate; + __u32 max_tx_rate; + __u32 rss_query_en; + __u32 trusted; + __be16 vlan_proto; }; -struct pipe_buf_operations; +struct tc_stats { + __u64 bytes; + __u32 packets; + __u32 drops; + __u32 overlimits; + __u32 bps; + __u32 pps; + __u32 qlen; + __u32 backlog; +}; -struct pipe_buffer { - struct page *page; - unsigned int offset; - unsigned int len; - const struct pipe_buf_operations *ops; - unsigned int flags; - long unsigned int private; +struct tc_sizespec { + unsigned char cell_log; + unsigned char size_log; + short int cell_align; + int overhead; + unsigned int linklayer; + unsigned int mpu; + unsigned int mtu; + unsigned int tsize; }; -struct pipe_buf_operations { - int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *); - void (*release)(struct pipe_inode_info *, struct pipe_buffer *); - int (*steal)(struct pipe_inode_info *, struct pipe_buffer *); - bool (*get)(struct pipe_inode_info *, struct pipe_buffer *); +enum netdev_tx { + __NETDEV_TX_MIN = 2147483648, + NETDEV_TX_OK = 0, + NETDEV_TX_BUSY = 16, }; -struct skb_ext { - refcount_t refcnt; - u8 offset[1]; - u8 chunks; - short: 16; - char data[0]; +typedef enum netdev_tx netdev_tx_t; + +struct header_ops { + int (*create)(struct sk_buff *, struct net_device *, short unsigned int, const void *, const void *, unsigned int); + int (*parse)(const struct sk_buff *, unsigned char *); + int (*cache)(const struct neighbour *, struct hh_cache *, __be16); + void (*cache_update)(struct hh_cache *, const struct net_device *, const unsigned char *); + bool (*validate)(const char *, unsigned int); + __be16 (*parse_protocol)(const struct sk_buff *); }; -struct dql { - unsigned int num_queued; - unsigned int adj_limit; - unsigned int last_obj_cnt; - long: 32; - long: 64; - long: 64; - long: 64; +struct gro_list { + struct list_head list; + int count; +}; + +struct napi_struct { + struct list_head poll_list; + long unsigned int state; + int weight; + long unsigned int gro_bitmask; + int (*poll)(struct napi_struct *, int); + int poll_owner; + struct net_device *dev; + struct gro_list gro_hash[8]; + struct sk_buff *skb; + struct list_head rx_list; + int rx_count; + struct hrtimer timer; + struct list_head dev_list; + struct hlist_node napi_hash_node; + unsigned int napi_id; +}; + +struct xdp_umem; + +struct netdev_queue { + struct net_device *dev; + struct Qdisc *qdisc; + struct Qdisc *qdisc_sleeping; + struct kobject kobj; + int numa_node; + long unsigned int tx_maxrate; + long unsigned int trans_timeout; + struct net_device *sb_dev; + struct xdp_umem *umem; + spinlock_t _xmit_lock; + int xmit_lock_owner; + long unsigned int trans_start; + long unsigned int state; long: 64; long: 64; long: 64; - unsigned int limit; - unsigned int num_completed; - unsigned int prev_ovlimit; - unsigned int prev_num_queued; - unsigned int prev_last_obj_cnt; - unsigned int lowest_slack; - long unsigned int slack_start_time; - unsigned int max_limit; - unsigned int min_limit; - unsigned int slack_hold_time; - long: 32; long: 64; long: 64; + struct dql dql; }; -struct ethtool_drvinfo { - __u32 cmd; - char driver[32]; - char version[32]; - char fw_version[32]; - char bus_info[32]; - char erom_version[32]; - char reserved2[12]; - __u32 n_priv_flags; - __u32 n_stats; - __u32 testinfo_len; - __u32 eedump_len; - __u32 regdump_len; +struct qdisc_skb_head { + struct sk_buff *head; + struct sk_buff *tail; + __u32 qlen; + spinlock_t lock; }; -struct ethtool_wolinfo { - __u32 cmd; - __u32 supported; - __u32 wolopts; - __u8 sopass[6]; +struct gnet_stats_basic_packed { + __u64 bytes; + __u64 packets; }; -struct ethtool_tunable { - __u32 cmd; - __u32 id; - __u32 type_id; - __u32 len; - void *data[0]; +struct gnet_stats_queue { + __u32 qlen; + __u32 backlog; + __u32 drops; + __u32 requeues; + __u32 overlimits; }; -struct ethtool_regs { - __u32 cmd; - __u32 version; - __u32 len; - __u8 data[0]; -}; +struct Qdisc_ops; -struct ethtool_eeprom { - __u32 cmd; - __u32 magic; - __u32 offset; - __u32 len; - __u8 data[0]; -}; +struct qdisc_size_table; -struct ethtool_eee { - __u32 cmd; - __u32 supported; - __u32 advertised; - __u32 lp_advertised; - __u32 eee_active; - __u32 eee_enabled; - __u32 tx_lpi_enabled; - __u32 tx_lpi_timer; - __u32 reserved[2]; -}; +struct net_rate_estimator; -struct ethtool_modinfo { - __u32 cmd; - __u32 type; - __u32 eeprom_len; - __u32 reserved[8]; +struct gnet_stats_basic_cpu; + +struct Qdisc { + int (*enqueue)(struct sk_buff *, struct Qdisc *, struct sk_buff **); + struct sk_buff * (*dequeue)(struct Qdisc *); + unsigned int flags; + u32 limit; + const struct Qdisc_ops *ops; + struct qdisc_size_table *stab; + struct hlist_node hash; + u32 handle; + u32 parent; + struct netdev_queue *dev_queue; + struct net_rate_estimator *rate_est; + struct gnet_stats_basic_cpu *cpu_bstats; + struct gnet_stats_queue *cpu_qstats; + int padded; + refcount_t refcnt; + long: 64; + long: 64; + long: 64; + struct sk_buff_head gso_skb; + struct qdisc_skb_head q; + struct gnet_stats_basic_packed bstats; + seqcount_t running; + struct gnet_stats_queue qstats; + long unsigned int state; + struct Qdisc *next_sched; + struct sk_buff_head skb_bad_txq; + spinlock_t busylock; + spinlock_t seqlock; + bool empty; + struct callback_head rcu; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct ethtool_coalesce { - __u32 cmd; - __u32 rx_coalesce_usecs; - __u32 rx_max_coalesced_frames; - __u32 rx_coalesce_usecs_irq; - __u32 rx_max_coalesced_frames_irq; - __u32 tx_coalesce_usecs; - __u32 tx_max_coalesced_frames; - __u32 tx_coalesce_usecs_irq; - __u32 tx_max_coalesced_frames_irq; - __u32 stats_block_coalesce_usecs; - __u32 use_adaptive_rx_coalesce; - __u32 use_adaptive_tx_coalesce; - __u32 pkt_rate_low; - __u32 rx_coalesce_usecs_low; - __u32 rx_max_coalesced_frames_low; - __u32 tx_coalesce_usecs_low; - __u32 tx_max_coalesced_frames_low; - __u32 pkt_rate_high; - __u32 rx_coalesce_usecs_high; - __u32 rx_max_coalesced_frames_high; - __u32 tx_coalesce_usecs_high; - __u32 tx_max_coalesced_frames_high; - __u32 rate_sample_interval; +struct rps_map { + unsigned int len; + struct callback_head rcu; + u16 cpus[0]; }; -struct ethtool_ringparam { - __u32 cmd; - __u32 rx_max_pending; - __u32 rx_mini_max_pending; - __u32 rx_jumbo_max_pending; - __u32 tx_max_pending; - __u32 rx_pending; - __u32 rx_mini_pending; - __u32 rx_jumbo_pending; - __u32 tx_pending; +struct rps_dev_flow { + u16 cpu; + u16 filter; + unsigned int last_qtail; }; -struct ethtool_channels { - __u32 cmd; - __u32 max_rx; - __u32 max_tx; - __u32 max_other; - __u32 max_combined; - __u32 rx_count; - __u32 tx_count; - __u32 other_count; - __u32 combined_count; +struct rps_dev_flow_table { + unsigned int mask; + struct callback_head rcu; + struct rps_dev_flow flows[0]; }; -struct ethtool_pauseparam { - __u32 cmd; - __u32 autoneg; - __u32 rx_pause; - __u32 tx_pause; +struct rps_sock_flow_table { + u32 mask; + long: 32; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + u32 ents[0]; }; -struct ethtool_test { - __u32 cmd; - __u32 flags; - __u32 reserved; - __u32 len; - __u64 data[0]; +struct netdev_rx_queue { + struct rps_map *rps_map; + struct rps_dev_flow_table *rps_flow_table; + struct kobject kobj; + struct net_device *dev; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct xdp_rxq_info xdp_rxq; + struct xdp_umem *umem; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct ethtool_stats { - __u32 cmd; - __u32 n_stats; - __u64 data[0]; +struct xps_map { + unsigned int len; + unsigned int alloc_len; + struct callback_head rcu; + u16 queues[0]; }; -struct ethtool_tcpip4_spec { - __be32 ip4src; - __be32 ip4dst; - __be16 psrc; - __be16 pdst; - __u8 tos; +struct xps_dev_maps { + struct callback_head rcu; + struct xps_map *attr_map[0]; }; -struct ethtool_ah_espip4_spec { - __be32 ip4src; - __be32 ip4dst; - __be32 spi; - __u8 tos; +struct netdev_phys_item_id { + unsigned char id[32]; + unsigned char id_len; }; -struct ethtool_usrip4_spec { - __be32 ip4src; - __be32 ip4dst; - __be32 l4_4_bytes; - __u8 tos; - __u8 ip_ver; - __u8 proto; +enum tc_setup_type { + TC_SETUP_QDISC_MQPRIO = 0, + TC_SETUP_CLSU32 = 1, + TC_SETUP_CLSFLOWER = 2, + TC_SETUP_CLSMATCHALL = 3, + TC_SETUP_CLSBPF = 4, + TC_SETUP_BLOCK = 5, + TC_SETUP_QDISC_CBS = 6, + TC_SETUP_QDISC_RED = 7, + TC_SETUP_QDISC_PRIO = 8, + TC_SETUP_QDISC_MQ = 9, + TC_SETUP_QDISC_ETF = 10, + TC_SETUP_ROOT_QDISC = 11, + TC_SETUP_QDISC_GRED = 12, + TC_SETUP_QDISC_TAPRIO = 13, + TC_SETUP_FT = 14, }; -struct ethtool_tcpip6_spec { - __be32 ip6src[4]; - __be32 ip6dst[4]; - __be16 psrc; - __be16 pdst; - __u8 tclass; +enum bpf_netdev_command { + XDP_SETUP_PROG = 0, + XDP_SETUP_PROG_HW = 1, + XDP_QUERY_PROG = 2, + XDP_QUERY_PROG_HW = 3, + BPF_OFFLOAD_MAP_ALLOC = 4, + BPF_OFFLOAD_MAP_FREE = 5, + XDP_SETUP_XSK_UMEM = 6, }; -struct ethtool_ah_espip6_spec { - __be32 ip6src[4]; - __be32 ip6dst[4]; - __be32 spi; - __u8 tclass; +struct netdev_bpf { + enum bpf_netdev_command command; + union { + struct { + u32 flags; + struct bpf_prog *prog; + struct netlink_ext_ack *extack; + }; + struct { + u32 prog_id; + u32 prog_flags; + }; + struct { + struct bpf_offloaded_map *offmap; + }; + struct { + struct xdp_umem *umem; + u16 queue_id; + } xsk; + }; }; -struct ethtool_usrip6_spec { - __be32 ip6src[4]; - __be32 ip6dst[4]; - __be32 l4_4_bytes; - __u8 tclass; - __u8 l4_proto; +struct dev_ifalias { + struct callback_head rcuhead; + char ifalias[0]; }; -union ethtool_flow_union { - struct ethtool_tcpip4_spec tcp_ip4_spec; - struct ethtool_tcpip4_spec udp_ip4_spec; - struct ethtool_tcpip4_spec sctp_ip4_spec; - struct ethtool_ah_espip4_spec ah_ip4_spec; - struct ethtool_ah_espip4_spec esp_ip4_spec; - struct ethtool_usrip4_spec usr_ip4_spec; - struct ethtool_tcpip6_spec tcp_ip6_spec; - struct ethtool_tcpip6_spec udp_ip6_spec; - struct ethtool_tcpip6_spec sctp_ip6_spec; - struct ethtool_ah_espip6_spec ah_ip6_spec; - struct ethtool_ah_espip6_spec esp_ip6_spec; - struct ethtool_usrip6_spec usr_ip6_spec; - struct ethhdr ether_spec; - __u8 hdata[52]; +struct netdev_name_node { + struct hlist_node hlist; + struct list_head list; + struct net_device *dev; + const char *name; }; -struct ethtool_flow_ext { - __u8 padding[2]; - unsigned char h_dest[6]; - __be16 vlan_etype; - __be16 vlan_tci; - __be32 data[2]; +struct udp_tunnel_info; + +struct devlink_port; + +struct net_device_ops { + int (*ndo_init)(struct net_device *); + void (*ndo_uninit)(struct net_device *); + int (*ndo_open)(struct net_device *); + int (*ndo_stop)(struct net_device *); + netdev_tx_t (*ndo_start_xmit)(struct sk_buff *, struct net_device *); + netdev_features_t (*ndo_features_check)(struct sk_buff *, struct net_device *, netdev_features_t); + u16 (*ndo_select_queue)(struct net_device *, struct sk_buff *, struct net_device *); + void (*ndo_change_rx_flags)(struct net_device *, int); + void (*ndo_set_rx_mode)(struct net_device *); + int (*ndo_set_mac_address)(struct net_device *, void *); + int (*ndo_validate_addr)(struct net_device *); + int (*ndo_do_ioctl)(struct net_device *, struct ifreq *, int); + int (*ndo_set_config)(struct net_device *, struct ifmap *); + int (*ndo_change_mtu)(struct net_device *, int); + int (*ndo_neigh_setup)(struct net_device *, struct neigh_parms *); + void (*ndo_tx_timeout)(struct net_device *); + void (*ndo_get_stats64)(struct net_device *, struct rtnl_link_stats64 *); + bool (*ndo_has_offload_stats)(const struct net_device *, int); + int (*ndo_get_offload_stats)(int, const struct net_device *, void *); + struct net_device_stats * (*ndo_get_stats)(struct net_device *); + int (*ndo_vlan_rx_add_vid)(struct net_device *, __be16, u16); + int (*ndo_vlan_rx_kill_vid)(struct net_device *, __be16, u16); + void (*ndo_poll_controller)(struct net_device *); + int (*ndo_netpoll_setup)(struct net_device *, struct netpoll_info *); + void (*ndo_netpoll_cleanup)(struct net_device *); + int (*ndo_set_vf_mac)(struct net_device *, int, u8 *); + int (*ndo_set_vf_vlan)(struct net_device *, int, u16, u8, __be16); + int (*ndo_set_vf_rate)(struct net_device *, int, int, int); + int (*ndo_set_vf_spoofchk)(struct net_device *, int, bool); + int (*ndo_set_vf_trust)(struct net_device *, int, bool); + int (*ndo_get_vf_config)(struct net_device *, int, struct ifla_vf_info *); + int (*ndo_set_vf_link_state)(struct net_device *, int, int); + int (*ndo_get_vf_stats)(struct net_device *, int, struct ifla_vf_stats *); + int (*ndo_set_vf_port)(struct net_device *, int, struct nlattr **); + int (*ndo_get_vf_port)(struct net_device *, int, struct sk_buff *); + int (*ndo_get_vf_guid)(struct net_device *, int, struct ifla_vf_guid *, struct ifla_vf_guid *); + int (*ndo_set_vf_guid)(struct net_device *, int, u64, int); + int (*ndo_set_vf_rss_query_en)(struct net_device *, int, bool); + int (*ndo_setup_tc)(struct net_device *, enum tc_setup_type, void *); + int (*ndo_rx_flow_steer)(struct net_device *, const struct sk_buff *, u16, u32); + int (*ndo_add_slave)(struct net_device *, struct net_device *, struct netlink_ext_ack *); + int (*ndo_del_slave)(struct net_device *, struct net_device *); + netdev_features_t (*ndo_fix_features)(struct net_device *, netdev_features_t); + int (*ndo_set_features)(struct net_device *, netdev_features_t); + int (*ndo_neigh_construct)(struct net_device *, struct neighbour *); + void (*ndo_neigh_destroy)(struct net_device *, struct neighbour *); + int (*ndo_fdb_add)(struct ndmsg *, struct nlattr **, struct net_device *, const unsigned char *, u16, u16, struct netlink_ext_ack *); + int (*ndo_fdb_del)(struct ndmsg *, struct nlattr **, struct net_device *, const unsigned char *, u16); + int (*ndo_fdb_dump)(struct sk_buff *, struct netlink_callback *, struct net_device *, struct net_device *, int *); + int (*ndo_fdb_get)(struct sk_buff *, struct nlattr **, struct net_device *, const unsigned char *, u16, u32, u32, struct netlink_ext_ack *); + int (*ndo_bridge_setlink)(struct net_device *, struct nlmsghdr *, u16, struct netlink_ext_ack *); + int (*ndo_bridge_getlink)(struct sk_buff *, u32, u32, struct net_device *, u32, int); + int (*ndo_bridge_dellink)(struct net_device *, struct nlmsghdr *, u16); + int (*ndo_change_carrier)(struct net_device *, bool); + int (*ndo_get_phys_port_id)(struct net_device *, struct netdev_phys_item_id *); + int (*ndo_get_port_parent_id)(struct net_device *, struct netdev_phys_item_id *); + int (*ndo_get_phys_port_name)(struct net_device *, char *, size_t); + void (*ndo_udp_tunnel_add)(struct net_device *, struct udp_tunnel_info *); + void (*ndo_udp_tunnel_del)(struct net_device *, struct udp_tunnel_info *); + void * (*ndo_dfwd_add_station)(struct net_device *, struct net_device *); + void (*ndo_dfwd_del_station)(struct net_device *, void *); + int (*ndo_set_tx_maxrate)(struct net_device *, int, u32); + int (*ndo_get_iflink)(const struct net_device *); + int (*ndo_change_proto_down)(struct net_device *, bool); + int (*ndo_fill_metadata_dst)(struct net_device *, struct sk_buff *); + void (*ndo_set_rx_headroom)(struct net_device *, int); + int (*ndo_bpf)(struct net_device *, struct netdev_bpf *); + int (*ndo_xdp_xmit)(struct net_device *, int, struct xdp_frame **, u32); + int (*ndo_xsk_wakeup)(struct net_device *, u32, u32); + struct devlink_port * (*ndo_get_devlink_port)(struct net_device *); }; -struct ethtool_rx_flow_spec { - __u32 flow_type; - union ethtool_flow_union h_u; - struct ethtool_flow_ext h_ext; - union ethtool_flow_union m_u; - struct ethtool_flow_ext m_ext; - __u64 ring_cookie; - __u32 location; +struct neigh_parms { + possible_net_t net; + struct net_device *dev; + struct list_head list; + int (*neigh_setup)(struct neighbour *); + struct neigh_table *tbl; + void *sysctl_table; + int dead; + refcount_t refcnt; + struct callback_head callback_head; + int reachable_time; + int data[13]; + long unsigned int data_state[1]; }; -struct ethtool_rxnfc { - __u32 cmd; - __u32 flow_type; - __u64 data; - struct ethtool_rx_flow_spec fs; - union { - __u32 rule_cnt; - __u32 rss_context; - }; - __u32 rule_locs[0]; +struct pcpu_lstats { + u64_stats_t packets; + u64_stats_t bytes; + struct u64_stats_sync syncp; }; -struct ethtool_flash { - __u32 cmd; - __u32 region; - char data[128]; +struct pcpu_sw_netstats { + u64 rx_packets; + u64 rx_bytes; + u64 tx_packets; + u64 tx_bytes; + struct u64_stats_sync syncp; }; -struct ethtool_dump { - __u32 cmd; - __u32 version; - __u32 flag; - __u32 len; - __u8 data[0]; -}; +struct nd_opt_hdr; -struct ethtool_ts_info { - __u32 cmd; - __u32 so_timestamping; - __s32 phc_index; - __u32 tx_types; - __u32 tx_reserved[3]; - __u32 rx_filters; - __u32 rx_reserved[3]; -}; +struct ndisc_options; -struct ethtool_fecparam { - __u32 cmd; - __u32 active_fec; - __u32 fec; - __u32 reserved; +struct prefix_info; + +struct ndisc_ops { + int (*is_useropt)(u8); + int (*parse_options)(const struct net_device *, struct nd_opt_hdr *, struct ndisc_options *); + void (*update)(const struct net_device *, struct neighbour *, u32, u8, const struct ndisc_options *); + int (*opt_addr_space)(const struct net_device *, u8, struct neighbour *, u8 *, u8 **); + void (*fill_addr_option)(const struct net_device *, struct sk_buff *, u8, const u8 *); + void (*prefix_rcv_add_addr)(struct net *, struct net_device *, const struct prefix_info *, struct inet6_dev *, struct in6_addr *, int, u32, bool, bool, __u32, u32, bool); }; -struct ethtool_link_settings { - __u32 cmd; - __u32 speed; - __u8 duplex; - __u8 port; - __u8 phy_address; - __u8 autoneg; - __u8 mdio_support; - __u8 eth_tp_mdix; - __u8 eth_tp_mdix_ctrl; - __s8 link_mode_masks_nwords; - __u8 transceiver; - __u8 reserved1[3]; - __u32 reserved[7]; - __u32 link_mode_masks[0]; +struct ipv6_devstat { + struct proc_dir_entry *proc_dir_entry; + struct ipstats_mib *ipv6; + struct icmpv6_mib_device *icmpv6dev; + struct icmpv6msg_mib_device *icmpv6msgdev; }; -enum ethtool_phys_id_state { - ETHTOOL_ID_INACTIVE = 0, - ETHTOOL_ID_ACTIVE = 1, - ETHTOOL_ID_ON = 2, - ETHTOOL_ID_OFF = 3, +struct ifmcaddr6; + +struct ifacaddr6; + +struct inet6_dev { + struct net_device *dev; + struct list_head addr_list; + struct ifmcaddr6 *mc_list; + struct ifmcaddr6 *mc_tomb; + spinlock_t mc_lock; + unsigned char mc_qrv; + unsigned char mc_gq_running; + unsigned char mc_ifc_count; + unsigned char mc_dad_count; + long unsigned int mc_v1_seen; + long unsigned int mc_qi; + long unsigned int mc_qri; + long unsigned int mc_maxdelay; + struct timer_list mc_gq_timer; + struct timer_list mc_ifc_timer; + struct timer_list mc_dad_timer; + struct ifacaddr6 *ac_list; + rwlock_t lock; + refcount_t refcnt; + __u32 if_flags; + int dead; + u32 desync_factor; + u8 rndid[8]; + struct list_head tempaddr_list; + struct in6_addr token; + struct neigh_parms *nd_parms; + struct ipv6_devconf cnf; + struct ipv6_devstat stats; + struct timer_list rs_timer; + __s32 rs_interval; + __u8 rs_probes; + long unsigned int tstamp; + struct callback_head rcu; }; -struct ethtool_link_ksettings { - struct ethtool_link_settings base; - struct { - long unsigned int supported[2]; - long unsigned int advertising[2]; - long unsigned int lp_advertising[2]; - } link_modes; +struct tcf_proto; + +struct mini_Qdisc { + struct tcf_proto *filter_list; + struct gnet_stats_basic_cpu *cpu_bstats; + struct gnet_stats_queue *cpu_qstats; + struct callback_head rcu; }; -struct ethtool_ops { - void (*get_drvinfo)(struct net_device *, struct ethtool_drvinfo *); - int (*get_regs_len)(struct net_device *); - void (*get_regs)(struct net_device *, struct ethtool_regs *, void *); - void (*get_wol)(struct net_device *, struct ethtool_wolinfo *); - int (*set_wol)(struct net_device *, struct ethtool_wolinfo *); - u32 (*get_msglevel)(struct net_device *); - void (*set_msglevel)(struct net_device *, u32); - int (*nway_reset)(struct net_device *); - u32 (*get_link)(struct net_device *); - int (*get_eeprom_len)(struct net_device *); - int (*get_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *); - int (*set_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *); - int (*get_coalesce)(struct net_device *, struct ethtool_coalesce *); - int (*set_coalesce)(struct net_device *, struct ethtool_coalesce *); - void (*get_ringparam)(struct net_device *, struct ethtool_ringparam *); - int (*set_ringparam)(struct net_device *, struct ethtool_ringparam *); - void (*get_pauseparam)(struct net_device *, struct ethtool_pauseparam *); - int (*set_pauseparam)(struct net_device *, struct ethtool_pauseparam *); - void (*self_test)(struct net_device *, struct ethtool_test *, u64 *); - void (*get_strings)(struct net_device *, u32, u8 *); - int (*set_phys_id)(struct net_device *, enum ethtool_phys_id_state); - void (*get_ethtool_stats)(struct net_device *, struct ethtool_stats *, u64 *); - int (*begin)(struct net_device *); - void (*complete)(struct net_device *); - u32 (*get_priv_flags)(struct net_device *); - int (*set_priv_flags)(struct net_device *, u32); - int (*get_sset_count)(struct net_device *, int); - int (*get_rxnfc)(struct net_device *, struct ethtool_rxnfc *, u32 *); - int (*set_rxnfc)(struct net_device *, struct ethtool_rxnfc *); - int (*flash_device)(struct net_device *, struct ethtool_flash *); - int (*reset)(struct net_device *, u32 *); - u32 (*get_rxfh_key_size)(struct net_device *); - u32 (*get_rxfh_indir_size)(struct net_device *); - int (*get_rxfh)(struct net_device *, u32 *, u8 *, u8 *); - int (*set_rxfh)(struct net_device *, const u32 *, const u8 *, const u8); - int (*get_rxfh_context)(struct net_device *, u32 *, u8 *, u8 *, u32); - int (*set_rxfh_context)(struct net_device *, const u32 *, const u8 *, const u8, u32 *, bool); - void (*get_channels)(struct net_device *, struct ethtool_channels *); - int (*set_channels)(struct net_device *, struct ethtool_channels *); - int (*get_dump_flag)(struct net_device *, struct ethtool_dump *); - int (*get_dump_data)(struct net_device *, struct ethtool_dump *, void *); - int (*set_dump)(struct net_device *, struct ethtool_dump *); - int (*get_ts_info)(struct net_device *, struct ethtool_ts_info *); - int (*get_module_info)(struct net_device *, struct ethtool_modinfo *); - int (*get_module_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *); - int (*get_eee)(struct net_device *, struct ethtool_eee *); - int (*set_eee)(struct net_device *, struct ethtool_eee *); - int (*get_tunable)(struct net_device *, const struct ethtool_tunable *, void *); - int (*set_tunable)(struct net_device *, const struct ethtool_tunable *, const void *); - int (*get_per_queue_coalesce)(struct net_device *, u32, struct ethtool_coalesce *); - int (*set_per_queue_coalesce)(struct net_device *, u32, struct ethtool_coalesce *); - int (*get_link_ksettings)(struct net_device *, struct ethtool_link_ksettings *); - int (*set_link_ksettings)(struct net_device *, const struct ethtool_link_ksettings *); - int (*get_fecparam)(struct net_device *, struct ethtool_fecparam *); - int (*set_fecparam)(struct net_device *, struct ethtool_fecparam *); - void (*get_ethtool_phy_stats)(struct net_device *, struct ethtool_stats *, u64 *); +struct rtnl_link_ops { + struct list_head list; + const char *kind; + size_t priv_size; + void (*setup)(struct net_device *); + unsigned int maxtype; + const struct nla_policy *policy; + int (*validate)(struct nlattr **, struct nlattr **, struct netlink_ext_ack *); + int (*newlink)(struct net *, struct net_device *, struct nlattr **, struct nlattr **, struct netlink_ext_ack *); + int (*changelink)(struct net_device *, struct nlattr **, struct nlattr **, struct netlink_ext_ack *); + void (*dellink)(struct net_device *, struct list_head *); + size_t (*get_size)(const struct net_device *); + int (*fill_info)(struct sk_buff *, const struct net_device *); + size_t (*get_xstats_size)(const struct net_device *); + int (*fill_xstats)(struct sk_buff *, const struct net_device *); + unsigned int (*get_num_tx_queues)(); + unsigned int (*get_num_rx_queues)(); + unsigned int slave_maxtype; + const struct nla_policy *slave_policy; + int (*slave_changelink)(struct net_device *, struct net_device *, struct nlattr **, struct nlattr **, struct netlink_ext_ack *); + size_t (*get_slave_size)(const struct net_device *, const struct net_device *); + int (*fill_slave_info)(struct sk_buff *, const struct net_device *, const struct net_device *); + struct net * (*get_link_net)(const struct net_device *); + size_t (*get_linkxstats_size)(const struct net_device *, int); + int (*fill_linkxstats)(struct sk_buff *, const struct net_device *, int *, int); }; -struct xdp_mem_info { - u32 type; - u32 id; +struct sd_flow_limit { + u64 count; + unsigned int num_buckets; + unsigned int history_head; + u16 history[128]; + u8 buckets[0]; }; -struct xdp_rxq_info { - struct net_device *dev; - u32 queue_index; - u32 reg_state; - struct xdp_mem_info mem; +struct softnet_data { + struct list_head poll_list; + struct sk_buff_head process_queue; + unsigned int processed; + unsigned int time_squeeze; + unsigned int received_rps; + struct softnet_data *rps_ipi_list; + struct sd_flow_limit *flow_limit; + struct Qdisc *output_queue; + struct Qdisc **output_queue_tailp; + struct sk_buff *completion_queue; + struct { + u16 recursion; + u8 more; + } xmit; + long: 32; + long: 64; + long: 64; + long: 64; + unsigned int input_queue_head; + long: 32; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + call_single_data_t csd; + struct softnet_data *rps_ipi_next; + unsigned int cpu; + unsigned int input_queue_tail; + unsigned int dropped; + struct sk_buff_head input_pkt_queue; + struct napi_struct backlog; long: 64; long: 64; long: 64; @@ -12015,1391 +14869,1469 @@ struct xdp_rxq_info { long: 64; }; -struct xdp_frame { - void *data; - u16 len; - u16 headroom; - u16 metasize; - struct xdp_mem_info mem; - struct net_device *dev_rx; +enum { + RTAX_UNSPEC = 0, + RTAX_LOCK = 1, + RTAX_MTU = 2, + RTAX_WINDOW = 3, + RTAX_RTT = 4, + RTAX_RTTVAR = 5, + RTAX_SSTHRESH = 6, + RTAX_CWND = 7, + RTAX_ADVMSS = 8, + RTAX_REORDERING = 9, + RTAX_HOPLIMIT = 10, + RTAX_INITCWND = 11, + RTAX_FEATURES = 12, + RTAX_RTO_MIN = 13, + RTAX_INITRWND = 14, + RTAX_QUICKACK = 15, + RTAX_CC_ALGO = 16, + RTAX_FASTOPEN_NO_COOKIE = 17, + __RTAX_MAX = 18, }; -struct nlmsghdr { - __u32 nlmsg_len; - __u16 nlmsg_type; - __u16 nlmsg_flags; - __u32 nlmsg_seq; - __u32 nlmsg_pid; +struct tcmsg { + unsigned char tcm_family; + unsigned char tcm__pad1; + short unsigned int tcm__pad2; + int tcm_ifindex; + __u32 tcm_handle; + __u32 tcm_parent; + __u32 tcm_info; }; -struct nlattr { - __u16 nla_len; - __u16 nla_type; +struct gnet_stats_basic_cpu { + struct gnet_stats_basic_packed bstats; + struct u64_stats_sync syncp; }; -struct netlink_ext_ack { - const char *_msg; - const struct nlattr *bad_attr; - u8 cookie[20]; - u8 cookie_len; +struct gnet_dump { + spinlock_t *lock; + struct sk_buff *skb; + struct nlattr *tail; + int compat_tc_stats; + int compat_xstats; + int padattr; + void *xstats; + int xstats_len; + struct tc_stats tc_stats; }; -struct netlink_callback { - struct sk_buff *skb; - const struct nlmsghdr *nlh; - int (*dump)(struct sk_buff *, struct netlink_callback *); - int (*done)(struct netlink_callback *); - void *data; - struct module *module; - struct netlink_ext_ack *extack; - u16 family; - u16 min_dump_alloc; - bool strict_check; - u16 answer_flags; - unsigned int prev_seq; - unsigned int seq; +struct nla_policy { + u8 type; + u8 validation_type; + u16 len; union { - u8 ctx[48]; - long int args[6]; + const void *validation_data; + struct { + s16 min; + s16 max; + }; + int (*validate)(const struct nlattr *, struct netlink_ext_ack *); + u16 strict_start_type; }; }; -struct ndmsg { - __u8 ndm_family; - __u8 ndm_pad1; - __u16 ndm_pad2; - __s32 ndm_ifindex; - __u16 ndm_state; - __u8 ndm_flags; - __u8 ndm_type; +struct nl_info { + struct nlmsghdr *nlh; + struct net *nl_net; + u32 portid; + u8 skip_notify: 1; + u8 skip_notify_kernel: 1; }; -struct rtnl_link_stats64 { - __u64 rx_packets; - __u64 tx_packets; - __u64 rx_bytes; - __u64 tx_bytes; - __u64 rx_errors; - __u64 tx_errors; - __u64 rx_dropped; - __u64 tx_dropped; - __u64 multicast; - __u64 collisions; - __u64 rx_length_errors; - __u64 rx_over_errors; - __u64 rx_crc_errors; - __u64 rx_frame_errors; - __u64 rx_fifo_errors; - __u64 rx_missed_errors; - __u64 tx_aborted_errors; - __u64 tx_carrier_errors; - __u64 tx_fifo_errors; - __u64 tx_heartbeat_errors; - __u64 tx_window_errors; - __u64 rx_compressed; - __u64 tx_compressed; - __u64 rx_nohandler; +struct rhash_lock_head {}; + +struct flow_block { + struct list_head cb_list; +}; + +typedef int flow_setup_cb_t(enum tc_setup_type, void *, void *); + +struct qdisc_size_table { + struct callback_head rcu; + struct list_head list; + struct tc_sizespec szopts; + int refcnt; + u16 data[0]; +}; + +struct Qdisc_class_ops; + +struct Qdisc_ops { + struct Qdisc_ops *next; + const struct Qdisc_class_ops *cl_ops; + char id[16]; + int priv_size; + unsigned int static_flags; + int (*enqueue)(struct sk_buff *, struct Qdisc *, struct sk_buff **); + struct sk_buff * (*dequeue)(struct Qdisc *); + struct sk_buff * (*peek)(struct Qdisc *); + int (*init)(struct Qdisc *, struct nlattr *, struct netlink_ext_ack *); + void (*reset)(struct Qdisc *); + void (*destroy)(struct Qdisc *); + int (*change)(struct Qdisc *, struct nlattr *, struct netlink_ext_ack *); + void (*attach)(struct Qdisc *); + int (*change_tx_queue_len)(struct Qdisc *, unsigned int); + int (*dump)(struct Qdisc *, struct sk_buff *); + int (*dump_stats)(struct Qdisc *, struct gnet_dump *); + void (*ingress_block_set)(struct Qdisc *, u32); + void (*egress_block_set)(struct Qdisc *, u32); + u32 (*ingress_block_get)(struct Qdisc *); + u32 (*egress_block_get)(struct Qdisc *); + struct module *owner; +}; + +struct qdisc_walker; + +struct tcf_block; + +struct Qdisc_class_ops { + unsigned int flags; + struct netdev_queue * (*select_queue)(struct Qdisc *, struct tcmsg *); + int (*graft)(struct Qdisc *, long unsigned int, struct Qdisc *, struct Qdisc **, struct netlink_ext_ack *); + struct Qdisc * (*leaf)(struct Qdisc *, long unsigned int); + void (*qlen_notify)(struct Qdisc *, long unsigned int); + long unsigned int (*find)(struct Qdisc *, u32); + int (*change)(struct Qdisc *, u32, u32, struct nlattr **, long unsigned int *, struct netlink_ext_ack *); + int (*delete)(struct Qdisc *, long unsigned int); + void (*walk)(struct Qdisc *, struct qdisc_walker *); + struct tcf_block * (*tcf_block)(struct Qdisc *, long unsigned int, struct netlink_ext_ack *); + long unsigned int (*bind_tcf)(struct Qdisc *, long unsigned int, u32); + void (*unbind_tcf)(struct Qdisc *, long unsigned int); + int (*dump)(struct Qdisc *, long unsigned int, struct sk_buff *, struct tcmsg *); + int (*dump_stats)(struct Qdisc *, long unsigned int, struct gnet_dump *); +}; + +struct tcf_chain; + +struct tcf_block { + struct mutex lock; + struct list_head chain_list; + u32 index; + refcount_t refcnt; + struct net *net; + struct Qdisc *q; + struct rw_semaphore cb_lock; + struct flow_block flow_block; + struct list_head owner_list; + bool keep_dst; + atomic_t offloadcnt; + unsigned int nooffloaddevcnt; + unsigned int lockeddevcnt; + struct { + struct tcf_chain *chain; + struct list_head filter_chain_list; + } chain0; + struct callback_head rcu; + struct hlist_head proto_destroy_ht[128]; + struct mutex proto_destroy_lock; +}; + +struct tcf_result; + +struct tcf_proto_ops; + +struct tcf_proto { + struct tcf_proto *next; + void *root; + int (*classify)(struct sk_buff *, const struct tcf_proto *, struct tcf_result *); + __be16 protocol; + u32 prio; + void *data; + const struct tcf_proto_ops *ops; + struct tcf_chain *chain; + spinlock_t lock; + bool deleting; + refcount_t refcnt; + struct callback_head rcu; + struct hlist_node destroy_ht_node; }; -struct ifla_vf_guid { - __u32 vf; - __u64 guid; +struct tcf_result { + union { + struct { + long unsigned int class; + u32 classid; + }; + const struct tcf_proto *goto_tp; + struct { + bool ingress; + struct gnet_stats_queue *qstats; + }; + }; }; -struct ifla_vf_stats { - __u64 rx_packets; - __u64 tx_packets; - __u64 rx_bytes; - __u64 tx_bytes; - __u64 broadcast; - __u64 multicast; - __u64 rx_dropped; - __u64 tx_dropped; +struct tcf_walker; + +struct tcf_proto_ops { + struct list_head head; + char kind[16]; + int (*classify)(struct sk_buff *, const struct tcf_proto *, struct tcf_result *); + int (*init)(struct tcf_proto *); + void (*destroy)(struct tcf_proto *, bool, struct netlink_ext_ack *); + void * (*get)(struct tcf_proto *, u32); + void (*put)(struct tcf_proto *, void *); + int (*change)(struct net *, struct sk_buff *, struct tcf_proto *, long unsigned int, u32, struct nlattr **, void **, bool, bool, struct netlink_ext_ack *); + int (*delete)(struct tcf_proto *, void *, bool *, bool, struct netlink_ext_ack *); + bool (*delete_empty)(struct tcf_proto *); + void (*walk)(struct tcf_proto *, struct tcf_walker *, bool); + int (*reoffload)(struct tcf_proto *, bool, flow_setup_cb_t *, void *, struct netlink_ext_ack *); + void (*hw_add)(struct tcf_proto *, void *); + void (*hw_del)(struct tcf_proto *, void *); + void (*bind_class)(void *, u32, long unsigned int); + void * (*tmplt_create)(struct net *, struct tcf_chain *, struct nlattr **, struct netlink_ext_ack *); + void (*tmplt_destroy)(void *); + int (*dump)(struct net *, struct tcf_proto *, void *, struct sk_buff *, struct tcmsg *, bool); + int (*tmplt_dump)(struct sk_buff *, struct net *, void *); + struct module *owner; + int flags; }; -struct ifla_vf_info { - __u32 vf; - __u8 mac[32]; - __u32 vlan; - __u32 qos; - __u32 spoofchk; - __u32 linkstate; - __u32 min_tx_rate; - __u32 max_tx_rate; - __u32 rss_query_en; - __u32 trusted; - __be16 vlan_proto; +struct tcf_chain { + struct mutex filter_chain_lock; + struct tcf_proto *filter_chain; + struct list_head list; + struct tcf_block *block; + u32 index; + unsigned int refcnt; + unsigned int action_refcnt; + bool explicitly_created; + bool flushing; + const struct tcf_proto_ops *tmplt_ops; + void *tmplt_priv; + struct callback_head rcu; }; -struct tc_stats { - __u64 bytes; - __u32 packets; - __u32 drops; - __u32 overlimits; - __u32 bps; - __u32 pps; - __u32 qlen; - __u32 backlog; +struct sock_fprog_kern { + u16 len; + struct sock_filter *filter; }; -struct tc_sizespec { - unsigned char cell_log; - unsigned char size_log; - short int cell_align; - int overhead; - unsigned int linklayer; - unsigned int mpu; - unsigned int mtu; - unsigned int tsize; +struct sk_filter { + refcount_t refcnt; + struct callback_head rcu; + struct bpf_prog *prog; }; -enum netdev_tx { - __NETDEV_TX_MIN = 2147483648, - NETDEV_TX_OK = 0, - NETDEV_TX_BUSY = 16, +struct bpf_redirect_info { + u32 flags; + u32 tgt_index; + void *tgt_value; + struct bpf_map *map; + struct bpf_map *map_to_flush; + u32 kern_flags; }; -typedef enum netdev_tx netdev_tx_t; +enum { + NEIGH_VAR_MCAST_PROBES = 0, + NEIGH_VAR_UCAST_PROBES = 1, + NEIGH_VAR_APP_PROBES = 2, + NEIGH_VAR_MCAST_REPROBES = 3, + NEIGH_VAR_RETRANS_TIME = 4, + NEIGH_VAR_BASE_REACHABLE_TIME = 5, + NEIGH_VAR_DELAY_PROBE_TIME = 6, + NEIGH_VAR_GC_STALETIME = 7, + NEIGH_VAR_QUEUE_LEN_BYTES = 8, + NEIGH_VAR_PROXY_QLEN = 9, + NEIGH_VAR_ANYCAST_DELAY = 10, + NEIGH_VAR_PROXY_DELAY = 11, + NEIGH_VAR_LOCKTIME = 12, + NEIGH_VAR_QUEUE_LEN = 13, + NEIGH_VAR_RETRANS_TIME_MS = 14, + NEIGH_VAR_BASE_REACHABLE_TIME_MS = 15, + NEIGH_VAR_GC_INTERVAL = 16, + NEIGH_VAR_GC_THRESH1 = 17, + NEIGH_VAR_GC_THRESH2 = 18, + NEIGH_VAR_GC_THRESH3 = 19, + NEIGH_VAR_MAX = 20, +}; -struct header_ops { - int (*create)(struct sk_buff *, struct net_device *, short unsigned int, const void *, const void *, unsigned int); - int (*parse)(const struct sk_buff *, unsigned char *); - int (*cache)(const struct neighbour *, struct hh_cache *, __be16); - void (*cache_update)(struct hh_cache *, const struct net_device *, const unsigned char *); - bool (*validate)(const char *, unsigned int); - __be16 (*parse_protocol)(const struct sk_buff *); +struct pneigh_entry; + +struct neigh_statistics; + +struct neigh_hash_table; + +struct neigh_table { + int family; + unsigned int entry_size; + unsigned int key_len; + __be16 protocol; + __u32 (*hash)(const void *, const struct net_device *, __u32 *); + bool (*key_eq)(const struct neighbour *, const void *); + int (*constructor)(struct neighbour *); + int (*pconstructor)(struct pneigh_entry *); + void (*pdestructor)(struct pneigh_entry *); + void (*proxy_redo)(struct sk_buff *); + bool (*allow_add)(const struct net_device *, struct netlink_ext_ack *); + char *id; + struct neigh_parms parms; + struct list_head parms_list; + int gc_interval; + int gc_thresh1; + int gc_thresh2; + int gc_thresh3; + long unsigned int last_flush; + struct delayed_work gc_work; + struct timer_list proxy_timer; + struct sk_buff_head proxy_queue; + atomic_t entries; + atomic_t gc_entries; + struct list_head gc_list; + rwlock_t lock; + long unsigned int last_rand; + struct neigh_statistics *stats; + struct neigh_hash_table *nht; + struct pneigh_entry **phash_buckets; }; -struct gro_list { - struct list_head list; - int count; +struct neigh_statistics { + long unsigned int allocs; + long unsigned int destroys; + long unsigned int hash_grows; + long unsigned int res_failed; + long unsigned int lookups; + long unsigned int hits; + long unsigned int rcv_probes_mcast; + long unsigned int rcv_probes_ucast; + long unsigned int periodic_gc_runs; + long unsigned int forced_gc_runs; + long unsigned int unres_discards; + long unsigned int table_fulls; }; -struct napi_struct { - struct list_head poll_list; - long unsigned int state; - int weight; - long unsigned int gro_bitmask; - int (*poll)(struct napi_struct *, int); - int poll_owner; - struct net_device *dev; - struct gro_list gro_hash[8]; - struct sk_buff *skb; - struct list_head rx_list; - int rx_count; - struct hrtimer timer; - struct list_head dev_list; - struct hlist_node napi_hash_node; - unsigned int napi_id; +struct neigh_ops { + int family; + void (*solicit)(struct neighbour *, struct sk_buff *); + void (*error_report)(struct neighbour *, struct sk_buff *); + int (*output)(struct neighbour *, struct sk_buff *); + int (*connected_output)(struct neighbour *, struct sk_buff *); }; -struct netdev_queue { +struct pneigh_entry { + struct pneigh_entry *next; + possible_net_t net; struct net_device *dev; - struct Qdisc *qdisc; - struct Qdisc *qdisc_sleeping; - struct kobject kobj; - int numa_node; - long unsigned int tx_maxrate; - long unsigned int trans_timeout; - struct net_device *sb_dev; - long: 64; - spinlock_t _xmit_lock; - int xmit_lock_owner; - long unsigned int trans_start; - long unsigned int state; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - struct dql dql; + u8 flags; + u8 protocol; + u8 key[0]; }; -struct qdisc_skb_head { - struct sk_buff *head; - struct sk_buff *tail; - __u32 qlen; - spinlock_t lock; +struct neigh_hash_table { + struct neighbour **hash_buckets; + unsigned int hash_shift; + __u32 hash_rnd[4]; + struct callback_head rcu; }; -struct gnet_stats_basic_packed { - __u64 bytes; - __u64 packets; +struct dst_metrics { + u32 metrics[17]; + refcount_t refcnt; }; -struct gnet_stats_queue { - __u32 qlen; - __u32 backlog; - __u32 drops; - __u32 requeues; - __u32 overlimits; +enum { + TCP_ESTABLISHED = 1, + TCP_SYN_SENT = 2, + TCP_SYN_RECV = 3, + TCP_FIN_WAIT1 = 4, + TCP_FIN_WAIT2 = 5, + TCP_TIME_WAIT = 6, + TCP_CLOSE = 7, + TCP_CLOSE_WAIT = 8, + TCP_LAST_ACK = 9, + TCP_LISTEN = 10, + TCP_CLOSING = 11, + TCP_NEW_SYN_RECV = 12, + TCP_MAX_STATES = 13, }; -struct Qdisc_ops; - -struct qdisc_size_table; +struct fib_rule_hdr { + __u8 family; + __u8 dst_len; + __u8 src_len; + __u8 tos; + __u8 table; + __u8 res1; + __u8 res2; + __u8 action; + __u32 flags; +}; -struct net_rate_estimator; +struct fib_rule_port_range { + __u16 start; + __u16 end; +}; -struct gnet_stats_basic_cpu; +struct fib_kuid_range { + kuid_t start; + kuid_t end; +}; -struct Qdisc { - int (*enqueue)(struct sk_buff *, struct Qdisc *, struct sk_buff **); - struct sk_buff * (*dequeue)(struct Qdisc *); - unsigned int flags; - u32 limit; - const struct Qdisc_ops *ops; - struct qdisc_size_table *stab; - struct hlist_node hash; - u32 handle; - u32 parent; - struct netdev_queue *dev_queue; - struct net_rate_estimator *rate_est; - struct gnet_stats_basic_cpu *cpu_bstats; - struct gnet_stats_queue *cpu_qstats; - int padded; +struct fib_rule { + struct list_head list; + int iifindex; + int oifindex; + u32 mark; + u32 mark_mask; + u32 flags; + u32 table; + u8 action; + u8 l3mdev; + u8 proto; + u8 ip_proto; + u32 target; + __be64 tun_id; + struct fib_rule *ctarget; + struct net *fr_net; refcount_t refcnt; - long: 64; - long: 64; - long: 64; - struct sk_buff_head gso_skb; - struct qdisc_skb_head q; - struct gnet_stats_basic_packed bstats; - seqcount_t running; - struct gnet_stats_queue qstats; - long unsigned int state; - struct Qdisc *next_sched; - struct sk_buff_head skb_bad_txq; - spinlock_t busylock; - spinlock_t seqlock; - bool empty; + u32 pref; + int suppress_ifgroup; + int suppress_prefixlen; + char iifname[16]; + char oifname[16]; + struct fib_kuid_range uid_range; + struct fib_rule_port_range sport_range; + struct fib_rule_port_range dport_range; struct callback_head rcu; - long: 64; - long: 64; - long: 64; - long: 64; }; -struct rps_map { - unsigned int len; - struct callback_head rcu; - u16 cpus[0]; +struct fib_lookup_arg { + void *lookup_ptr; + const void *lookup_data; + void *result; + struct fib_rule *rule; + u32 table; + int flags; }; -struct rps_dev_flow { - u16 cpu; - u16 filter; - unsigned int last_qtail; -}; +struct smc_hashinfo; -struct rps_dev_flow_table { - unsigned int mask; - struct callback_head rcu; - struct rps_dev_flow flows[0]; -}; +struct request_sock_ops; -struct rps_sock_flow_table { - u32 mask; - long: 32; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - u32 ents[0]; +struct timewait_sock_ops; + +struct udp_table; + +struct raw_hashinfo; + +struct proto { + void (*close)(struct sock *, long int); + int (*pre_connect)(struct sock *, struct sockaddr *, int); + int (*connect)(struct sock *, struct sockaddr *, int); + int (*disconnect)(struct sock *, int); + struct sock * (*accept)(struct sock *, int, int *, bool); + int (*ioctl)(struct sock *, int, long unsigned int); + int (*init)(struct sock *); + void (*destroy)(struct sock *); + void (*shutdown)(struct sock *, int); + int (*setsockopt)(struct sock *, int, int, char *, unsigned int); + int (*getsockopt)(struct sock *, int, int, char *, int *); + void (*keepalive)(struct sock *, int); + int (*compat_setsockopt)(struct sock *, int, int, char *, unsigned int); + int (*compat_getsockopt)(struct sock *, int, int, char *, int *); + int (*compat_ioctl)(struct sock *, unsigned int, long unsigned int); + int (*sendmsg)(struct sock *, struct msghdr *, size_t); + int (*recvmsg)(struct sock *, struct msghdr *, size_t, int, int, int *); + int (*sendpage)(struct sock *, struct page *, int, size_t, int); + int (*bind)(struct sock *, struct sockaddr *, int); + int (*backlog_rcv)(struct sock *, struct sk_buff *); + void (*release_cb)(struct sock *); + int (*hash)(struct sock *); + void (*unhash)(struct sock *); + void (*rehash)(struct sock *); + int (*get_port)(struct sock *, short unsigned int); + unsigned int inuse_idx; + bool (*stream_memory_free)(const struct sock *, int); + bool (*stream_memory_read)(const struct sock *); + void (*enter_memory_pressure)(struct sock *); + void (*leave_memory_pressure)(struct sock *); + atomic_long_t *memory_allocated; + struct percpu_counter *sockets_allocated; + long unsigned int *memory_pressure; + long int *sysctl_mem; + int *sysctl_wmem; + int *sysctl_rmem; + u32 sysctl_wmem_offset; + u32 sysctl_rmem_offset; + int max_header; + bool no_autobind; + struct kmem_cache *slab; + unsigned int obj_size; + slab_flags_t slab_flags; + unsigned int useroffset; + unsigned int usersize; + struct percpu_counter *orphan_count; + struct request_sock_ops *rsk_prot; + struct timewait_sock_ops *twsk_prot; + union { + struct inet_hashinfo *hashinfo; + struct udp_table *udp_table; + struct raw_hashinfo *raw_hash; + struct smc_hashinfo *smc_hash; + } h; + struct module *owner; + char name[32]; + struct list_head node; + int (*diag_destroy)(struct sock *, int); }; -struct netdev_rx_queue { - struct rps_map *rps_map; - struct rps_dev_flow_table *rps_flow_table; - struct kobject kobj; - struct net_device *dev; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - struct xdp_rxq_info xdp_rxq; +struct request_sock; + +struct request_sock_ops { + int family; + unsigned int obj_size; + struct kmem_cache *slab; + char *slab_name; + int (*rtx_syn_ack)(const struct sock *, struct request_sock *); + void (*send_ack)(const struct sock *, struct sk_buff *, struct request_sock *); + void (*send_reset)(const struct sock *, struct sk_buff *); + void (*destructor)(struct request_sock *); + void (*syn_ack_timeout)(const struct request_sock *); }; -struct xps_map { - unsigned int len; - unsigned int alloc_len; - struct callback_head rcu; - u16 queues[0]; +struct timewait_sock_ops { + struct kmem_cache *twsk_slab; + char *twsk_slab_name; + unsigned int twsk_obj_size; + int (*twsk_unique)(struct sock *, struct sock *, void *); + void (*twsk_destructor)(struct sock *); }; -struct xps_dev_maps { - struct callback_head rcu; - struct xps_map *attr_map[0]; +struct request_sock { + struct sock_common __req_common; + struct request_sock *dl_next; + u16 mss; + u8 num_retrans; + u8 cookie_ts: 1; + u8 num_timeout: 7; + u32 ts_recent; + struct timer_list rsk_timer; + const struct request_sock_ops *rsk_ops; + struct sock *sk; + u32 *saved_syn; + u32 secid; + u32 peer_secid; }; -struct netdev_phys_item_id { - unsigned char id[32]; - unsigned char id_len; +enum tsq_enum { + TSQ_THROTTLED = 0, + TSQ_QUEUED = 1, + TCP_TSQ_DEFERRED = 2, + TCP_WRITE_TIMER_DEFERRED = 3, + TCP_DELACK_TIMER_DEFERRED = 4, + TCP_MTU_REDUCED_DEFERRED = 5, }; -enum tc_setup_type { - TC_SETUP_QDISC_MQPRIO = 0, - TC_SETUP_CLSU32 = 1, - TC_SETUP_CLSFLOWER = 2, - TC_SETUP_CLSMATCHALL = 3, - TC_SETUP_CLSBPF = 4, - TC_SETUP_BLOCK = 5, - TC_SETUP_QDISC_CBS = 6, - TC_SETUP_QDISC_RED = 7, - TC_SETUP_QDISC_PRIO = 8, - TC_SETUP_QDISC_MQ = 9, - TC_SETUP_QDISC_ETF = 10, - TC_SETUP_ROOT_QDISC = 11, - TC_SETUP_QDISC_GRED = 12, - TC_SETUP_QDISC_TAPRIO = 13, - TC_SETUP_FT = 14, +struct static_key_false_deferred { + struct static_key_false key; + long unsigned int timeout; + struct delayed_work work; }; -enum bpf_netdev_command { - XDP_SETUP_PROG = 0, - XDP_SETUP_PROG_HW = 1, - XDP_QUERY_PROG = 2, - XDP_QUERY_PROG_HW = 3, - BPF_OFFLOAD_MAP_ALLOC = 4, - BPF_OFFLOAD_MAP_FREE = 5, - XDP_SETUP_XSK_UMEM = 6, +struct ip6_sf_list { + struct ip6_sf_list *sf_next; + struct in6_addr sf_addr; + long unsigned int sf_count[2]; + unsigned char sf_gsresp; + unsigned char sf_oldin; + unsigned char sf_crcount; }; -struct xdp_umem; - -struct netdev_bpf { - enum bpf_netdev_command command; - union { - struct { - u32 flags; - struct bpf_prog *prog; - struct netlink_ext_ack *extack; - }; - struct { - u32 prog_id; - u32 prog_flags; - }; - struct { - struct bpf_offloaded_map *offmap; - }; - struct { - struct xdp_umem *umem; - u16 queue_id; - } xsk; - }; +struct ifmcaddr6 { + struct in6_addr mca_addr; + struct inet6_dev *idev; + struct ifmcaddr6 *next; + struct ip6_sf_list *mca_sources; + struct ip6_sf_list *mca_tomb; + unsigned int mca_sfmode; + unsigned char mca_crcount; + long unsigned int mca_sfcount[2]; + struct timer_list mca_timer; + unsigned int mca_flags; + int mca_users; + refcount_t mca_refcnt; + spinlock_t mca_lock; + long unsigned int mca_cstamp; + long unsigned int mca_tstamp; }; -struct dev_ifalias { - struct callback_head rcuhead; - char ifalias[0]; +struct ifacaddr6 { + struct in6_addr aca_addr; + struct fib6_info *aca_rt; + struct ifacaddr6 *aca_next; + struct hlist_node aca_addr_lst; + int aca_users; + refcount_t aca_refcnt; + long unsigned int aca_cstamp; + long unsigned int aca_tstamp; + struct callback_head rcu; }; -struct netdev_name_node { - struct hlist_node hlist; - struct list_head list; - struct net_device *dev; - const char *name; -}; +struct fib6_result; -struct udp_tunnel_info; +struct fib6_nh; -struct devlink_port; +struct fib6_config; -struct net_device_ops { - int (*ndo_init)(struct net_device *); - void (*ndo_uninit)(struct net_device *); - int (*ndo_open)(struct net_device *); - int (*ndo_stop)(struct net_device *); - netdev_tx_t (*ndo_start_xmit)(struct sk_buff *, struct net_device *); - netdev_features_t (*ndo_features_check)(struct sk_buff *, struct net_device *, netdev_features_t); - u16 (*ndo_select_queue)(struct net_device *, struct sk_buff *, struct net_device *); - void (*ndo_change_rx_flags)(struct net_device *, int); - void (*ndo_set_rx_mode)(struct net_device *); - int (*ndo_set_mac_address)(struct net_device *, void *); - int (*ndo_validate_addr)(struct net_device *); - int (*ndo_do_ioctl)(struct net_device *, struct ifreq *, int); - int (*ndo_set_config)(struct net_device *, struct ifmap *); - int (*ndo_change_mtu)(struct net_device *, int); - int (*ndo_neigh_setup)(struct net_device *, struct neigh_parms *); - void (*ndo_tx_timeout)(struct net_device *); - void (*ndo_get_stats64)(struct net_device *, struct rtnl_link_stats64 *); - bool (*ndo_has_offload_stats)(const struct net_device *, int); - int (*ndo_get_offload_stats)(int, const struct net_device *, void *); - struct net_device_stats * (*ndo_get_stats)(struct net_device *); - int (*ndo_vlan_rx_add_vid)(struct net_device *, __be16, u16); - int (*ndo_vlan_rx_kill_vid)(struct net_device *, __be16, u16); - void (*ndo_poll_controller)(struct net_device *); - int (*ndo_netpoll_setup)(struct net_device *, struct netpoll_info *); - void (*ndo_netpoll_cleanup)(struct net_device *); - int (*ndo_set_vf_mac)(struct net_device *, int, u8 *); - int (*ndo_set_vf_vlan)(struct net_device *, int, u16, u8, __be16); - int (*ndo_set_vf_rate)(struct net_device *, int, int, int); - int (*ndo_set_vf_spoofchk)(struct net_device *, int, bool); - int (*ndo_set_vf_trust)(struct net_device *, int, bool); - int (*ndo_get_vf_config)(struct net_device *, int, struct ifla_vf_info *); - int (*ndo_set_vf_link_state)(struct net_device *, int, int); - int (*ndo_get_vf_stats)(struct net_device *, int, struct ifla_vf_stats *); - int (*ndo_set_vf_port)(struct net_device *, int, struct nlattr **); - int (*ndo_get_vf_port)(struct net_device *, int, struct sk_buff *); - int (*ndo_get_vf_guid)(struct net_device *, int, struct ifla_vf_guid *, struct ifla_vf_guid *); - int (*ndo_set_vf_guid)(struct net_device *, int, u64, int); - int (*ndo_set_vf_rss_query_en)(struct net_device *, int, bool); - int (*ndo_setup_tc)(struct net_device *, enum tc_setup_type, void *); - int (*ndo_rx_flow_steer)(struct net_device *, const struct sk_buff *, u16, u32); - int (*ndo_add_slave)(struct net_device *, struct net_device *, struct netlink_ext_ack *); - int (*ndo_del_slave)(struct net_device *, struct net_device *); - netdev_features_t (*ndo_fix_features)(struct net_device *, netdev_features_t); - int (*ndo_set_features)(struct net_device *, netdev_features_t); - int (*ndo_neigh_construct)(struct net_device *, struct neighbour *); - void (*ndo_neigh_destroy)(struct net_device *, struct neighbour *); - int (*ndo_fdb_add)(struct ndmsg *, struct nlattr **, struct net_device *, const unsigned char *, u16, u16, struct netlink_ext_ack *); - int (*ndo_fdb_del)(struct ndmsg *, struct nlattr **, struct net_device *, const unsigned char *, u16); - int (*ndo_fdb_dump)(struct sk_buff *, struct netlink_callback *, struct net_device *, struct net_device *, int *); - int (*ndo_fdb_get)(struct sk_buff *, struct nlattr **, struct net_device *, const unsigned char *, u16, u32, u32, struct netlink_ext_ack *); - int (*ndo_bridge_setlink)(struct net_device *, struct nlmsghdr *, u16, struct netlink_ext_ack *); - int (*ndo_bridge_getlink)(struct sk_buff *, u32, u32, struct net_device *, u32, int); - int (*ndo_bridge_dellink)(struct net_device *, struct nlmsghdr *, u16); - int (*ndo_change_carrier)(struct net_device *, bool); - int (*ndo_get_phys_port_id)(struct net_device *, struct netdev_phys_item_id *); - int (*ndo_get_port_parent_id)(struct net_device *, struct netdev_phys_item_id *); - int (*ndo_get_phys_port_name)(struct net_device *, char *, size_t); - void (*ndo_udp_tunnel_add)(struct net_device *, struct udp_tunnel_info *); - void (*ndo_udp_tunnel_del)(struct net_device *, struct udp_tunnel_info *); - void * (*ndo_dfwd_add_station)(struct net_device *, struct net_device *); - void (*ndo_dfwd_del_station)(struct net_device *, void *); - int (*ndo_set_tx_maxrate)(struct net_device *, int, u32); - int (*ndo_get_iflink)(const struct net_device *); - int (*ndo_change_proto_down)(struct net_device *, bool); - int (*ndo_fill_metadata_dst)(struct net_device *, struct sk_buff *); - void (*ndo_set_rx_headroom)(struct net_device *, int); - int (*ndo_bpf)(struct net_device *, struct netdev_bpf *); - int (*ndo_xdp_xmit)(struct net_device *, int, struct xdp_frame **, u32); - int (*ndo_xsk_wakeup)(struct net_device *, u32, u32); - struct devlink_port * (*ndo_get_devlink_port)(struct net_device *); +struct ipv6_stub { + int (*ipv6_sock_mc_join)(struct sock *, int, const struct in6_addr *); + int (*ipv6_sock_mc_drop)(struct sock *, int, const struct in6_addr *); + struct dst_entry * (*ipv6_dst_lookup_flow)(struct net *, const struct sock *, struct flowi6 *, const struct in6_addr *); + int (*ipv6_route_input)(struct sk_buff *); + struct fib6_table * (*fib6_get_table)(struct net *, u32); + int (*fib6_lookup)(struct net *, int, struct flowi6 *, struct fib6_result *, int); + int (*fib6_table_lookup)(struct net *, struct fib6_table *, int, struct flowi6 *, struct fib6_result *, int); + void (*fib6_select_path)(const struct net *, struct fib6_result *, struct flowi6 *, int, bool, const struct sk_buff *, int); + u32 (*ip6_mtu_from_fib6)(const struct fib6_result *, const struct in6_addr *, const struct in6_addr *); + int (*fib6_nh_init)(struct net *, struct fib6_nh *, struct fib6_config *, gfp_t, struct netlink_ext_ack *); + void (*fib6_nh_release)(struct fib6_nh *); + void (*fib6_update_sernum)(struct net *, struct fib6_info *); + int (*ip6_del_rt)(struct net *, struct fib6_info *); + void (*fib6_rt_update)(struct net *, struct fib6_info *, struct nl_info *); + void (*udpv6_encap_enable)(); + void (*ndisc_send_na)(struct net_device *, const struct in6_addr *, const struct in6_addr *, bool, bool, bool, bool); + struct neigh_table *nd_tbl; }; -struct neigh_parms { - possible_net_t net; - struct net_device *dev; - struct list_head list; - int (*neigh_setup)(struct neighbour *); - struct neigh_table *tbl; - void *sysctl_table; - int dead; - refcount_t refcnt; - struct callback_head callback_head; - int reachable_time; - int data[13]; - long unsigned int data_state[1]; +struct fib6_result { + struct fib6_nh *nh; + struct fib6_info *f6i; + u32 fib6_flags; + u8 fib6_type; + struct rt6_info *rt6; }; -struct pcpu_lstats { - u64_stats_t packets; - u64_stats_t bytes; - struct u64_stats_sync syncp; +struct ipv6_bpf_stub { + int (*inet6_bind)(struct sock *, struct sockaddr *, int, bool, bool); + struct sock * (*udp6_lib_lookup)(struct net *, const struct in6_addr *, __be16, const struct in6_addr *, __be16, int, int, struct udp_table *, struct sk_buff *); }; -struct pcpu_sw_netstats { - u64 rx_packets; - u64 rx_bytes; - u64 tx_packets; - u64 tx_bytes; - struct u64_stats_sync syncp; +enum { + __ND_OPT_PREFIX_INFO_END = 0, + ND_OPT_SOURCE_LL_ADDR = 1, + ND_OPT_TARGET_LL_ADDR = 2, + ND_OPT_PREFIX_INFO = 3, + ND_OPT_REDIRECT_HDR = 4, + ND_OPT_MTU = 5, + ND_OPT_NONCE = 14, + __ND_OPT_ARRAY_MAX = 15, + ND_OPT_ROUTE_INFO = 24, + ND_OPT_RDNSS = 25, + ND_OPT_DNSSL = 31, + ND_OPT_6CO = 34, + ND_OPT_CAPTIVE_PORTAL = 37, + __ND_OPT_MAX = 38, }; -struct nd_opt_hdr; - -struct ndisc_options; - -struct prefix_info; - -struct ndisc_ops { - int (*is_useropt)(u8); - int (*parse_options)(const struct net_device *, struct nd_opt_hdr *, struct ndisc_options *); - void (*update)(const struct net_device *, struct neighbour *, u32, u8, const struct ndisc_options *); - int (*opt_addr_space)(const struct net_device *, u8, struct neighbour *, u8 *, u8 **); - void (*fill_addr_option)(const struct net_device *, struct sk_buff *, u8, const u8 *); - void (*prefix_rcv_add_addr)(struct net *, struct net_device *, const struct prefix_info *, struct inet6_dev *, struct in6_addr *, int, u32, bool, bool, __u32, u32, bool); +struct nd_opt_hdr { + __u8 nd_opt_type; + __u8 nd_opt_len; }; -struct ipv6_devstat { - struct proc_dir_entry *proc_dir_entry; - struct ipstats_mib *ipv6; - struct icmpv6_mib_device *icmpv6dev; - struct icmpv6msg_mib_device *icmpv6msgdev; +struct ndisc_options { + struct nd_opt_hdr *nd_opt_array[15]; + struct nd_opt_hdr *nd_useropts; + struct nd_opt_hdr *nd_useropts_end; }; -struct ifmcaddr6; +struct prefix_info { + __u8 type; + __u8 length; + __u8 prefix_len; + __u8 reserved: 6; + __u8 autoconf: 1; + __u8 onlink: 1; + __be32 valid; + __be32 prefered; + __be32 reserved2; + struct in6_addr prefix; +}; -struct ifacaddr6; +struct ip6_ra_chain { + struct ip6_ra_chain *next; + struct sock *sk; + int sel; + void (*destructor)(struct sock *); +}; -struct inet6_dev { - struct net_device *dev; - struct list_head addr_list; - struct ifmcaddr6 *mc_list; - struct ifmcaddr6 *mc_tomb; - spinlock_t mc_lock; - unsigned char mc_qrv; - unsigned char mc_gq_running; - unsigned char mc_ifc_count; - unsigned char mc_dad_count; - long unsigned int mc_v1_seen; - long unsigned int mc_qi; - long unsigned int mc_qri; - long unsigned int mc_maxdelay; - struct timer_list mc_gq_timer; - struct timer_list mc_ifc_timer; - struct timer_list mc_dad_timer; - struct ifacaddr6 *ac_list; - rwlock_t lock; - refcount_t refcnt; - __u32 if_flags; - int dead; - u32 desync_factor; - u8 rndid[8]; - struct list_head tempaddr_list; - struct in6_addr token; - struct neigh_parms *nd_parms; - struct ipv6_devconf cnf; - struct ipv6_devstat stats; - struct timer_list rs_timer; - __s32 rs_interval; - __u8 rs_probes; - long unsigned int tstamp; - struct callback_head rcu; +struct rpc_xprt_iter_ops { + void (*xpi_rewind)(struct rpc_xprt_iter *); + struct rpc_xprt * (*xpi_xprt)(struct rpc_xprt_iter *); + struct rpc_xprt * (*xpi_next)(struct rpc_xprt_iter *); }; -struct tcf_proto; +struct rpc_version { + u32 number; + unsigned int nrprocs; + const struct rpc_procinfo *procs; + unsigned int *counts; +}; -struct mini_Qdisc { - struct tcf_proto *filter_list; - struct gnet_stats_basic_cpu *cpu_bstats; - struct gnet_stats_queue *cpu_qstats; - struct callback_head rcu; +struct nfs_fh { + short unsigned int size; + unsigned char data[128]; }; -struct rtnl_link_ops { - struct list_head list; - const char *kind; - size_t priv_size; - void (*setup)(struct net_device *); - unsigned int maxtype; - const struct nla_policy *policy; - int (*validate)(struct nlattr **, struct nlattr **, struct netlink_ext_ack *); - int (*newlink)(struct net *, struct net_device *, struct nlattr **, struct nlattr **, struct netlink_ext_ack *); - int (*changelink)(struct net_device *, struct nlattr **, struct nlattr **, struct netlink_ext_ack *); - void (*dellink)(struct net_device *, struct list_head *); - size_t (*get_size)(const struct net_device *); - int (*fill_info)(struct sk_buff *, const struct net_device *); - size_t (*get_xstats_size)(const struct net_device *); - int (*fill_xstats)(struct sk_buff *, const struct net_device *); - unsigned int (*get_num_tx_queues)(); - unsigned int (*get_num_rx_queues)(); - unsigned int slave_maxtype; - const struct nla_policy *slave_policy; - int (*slave_changelink)(struct net_device *, struct net_device *, struct nlattr **, struct nlattr **, struct netlink_ext_ack *); - size_t (*get_slave_size)(const struct net_device *, const struct net_device *); - int (*fill_slave_info)(struct sk_buff *, const struct net_device *, const struct net_device *); - struct net * (*get_link_net)(const struct net_device *); - size_t (*get_linkxstats_size)(const struct net_device *, int); - int (*fill_linkxstats)(struct sk_buff *, const struct net_device *, int *, int); +enum nfs3_stable_how { + NFS_UNSTABLE = 0, + NFS_DATA_SYNC = 1, + NFS_FILE_SYNC = 2, + NFS_INVALID_STABLE_HOW = 4294967295, }; -struct sd_flow_limit { - u64 count; - unsigned int num_buckets; - unsigned int history_head; - u16 history[128]; - u8 buckets[0]; +struct nfs4_label { + uint32_t lfs; + uint32_t pi; + u32 len; + char *label; }; -struct softnet_data { - struct list_head poll_list; - struct sk_buff_head process_queue; - unsigned int processed; - unsigned int time_squeeze; - unsigned int received_rps; - struct softnet_data *rps_ipi_list; - struct sd_flow_limit *flow_limit; - struct Qdisc *output_queue; - struct Qdisc **output_queue_tailp; - struct sk_buff *completion_queue; - struct { - u16 recursion; - u8 more; - } xmit; - long: 32; - long: 64; - long: 64; - long: 64; - unsigned int input_queue_head; - long: 32; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - call_single_data_t csd; - struct softnet_data *rps_ipi_next; - unsigned int cpu; - unsigned int input_queue_tail; - unsigned int dropped; - struct sk_buff_head input_pkt_queue; - struct napi_struct backlog; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +typedef struct { + char data[8]; +} nfs4_verifier; + +struct nfs4_stateid_struct { + union { + char data[16]; + struct { + __be32 seqid; + char other[12]; + }; + }; + enum { + NFS4_INVALID_STATEID_TYPE = 0, + NFS4_SPECIAL_STATEID_TYPE = 1, + NFS4_OPEN_STATEID_TYPE = 2, + NFS4_LOCK_STATEID_TYPE = 3, + NFS4_DELEGATION_STATEID_TYPE = 4, + NFS4_LAYOUT_STATEID_TYPE = 5, + NFS4_PNFS_DS_STATEID_TYPE = 6, + NFS4_REVOKED_STATEID_TYPE = 7, + } type; }; -enum { - RTAX_UNSPEC = 0, - RTAX_LOCK = 1, - RTAX_MTU = 2, - RTAX_WINDOW = 3, - RTAX_RTT = 4, - RTAX_RTTVAR = 5, - RTAX_SSTHRESH = 6, - RTAX_CWND = 7, - RTAX_ADVMSS = 8, - RTAX_REORDERING = 9, - RTAX_HOPLIMIT = 10, - RTAX_INITCWND = 11, - RTAX_FEATURES = 12, - RTAX_RTO_MIN = 13, - RTAX_INITRWND = 14, - RTAX_QUICKACK = 15, - RTAX_CC_ALGO = 16, - RTAX_FASTOPEN_NO_COOKIE = 17, - __RTAX_MAX = 18, +typedef struct nfs4_stateid_struct nfs4_stateid; + +enum nfs_opnum4 { + OP_ACCESS = 3, + OP_CLOSE = 4, + OP_COMMIT = 5, + OP_CREATE = 6, + OP_DELEGPURGE = 7, + OP_DELEGRETURN = 8, + OP_GETATTR = 9, + OP_GETFH = 10, + OP_LINK = 11, + OP_LOCK = 12, + OP_LOCKT = 13, + OP_LOCKU = 14, + OP_LOOKUP = 15, + OP_LOOKUPP = 16, + OP_NVERIFY = 17, + OP_OPEN = 18, + OP_OPENATTR = 19, + OP_OPEN_CONFIRM = 20, + OP_OPEN_DOWNGRADE = 21, + OP_PUTFH = 22, + OP_PUTPUBFH = 23, + OP_PUTROOTFH = 24, + OP_READ = 25, + OP_READDIR = 26, + OP_READLINK = 27, + OP_REMOVE = 28, + OP_RENAME = 29, + OP_RENEW = 30, + OP_RESTOREFH = 31, + OP_SAVEFH = 32, + OP_SECINFO = 33, + OP_SETATTR = 34, + OP_SETCLIENTID = 35, + OP_SETCLIENTID_CONFIRM = 36, + OP_VERIFY = 37, + OP_WRITE = 38, + OP_RELEASE_LOCKOWNER = 39, + OP_BACKCHANNEL_CTL = 40, + OP_BIND_CONN_TO_SESSION = 41, + OP_EXCHANGE_ID = 42, + OP_CREATE_SESSION = 43, + OP_DESTROY_SESSION = 44, + OP_FREE_STATEID = 45, + OP_GET_DIR_DELEGATION = 46, + OP_GETDEVICEINFO = 47, + OP_GETDEVICELIST = 48, + OP_LAYOUTCOMMIT = 49, + OP_LAYOUTGET = 50, + OP_LAYOUTRETURN = 51, + OP_SECINFO_NO_NAME = 52, + OP_SEQUENCE = 53, + OP_SET_SSV = 54, + OP_TEST_STATEID = 55, + OP_WANT_DELEGATION = 56, + OP_DESTROY_CLIENTID = 57, + OP_RECLAIM_COMPLETE = 58, + OP_ALLOCATE = 59, + OP_COPY = 60, + OP_COPY_NOTIFY = 61, + OP_DEALLOCATE = 62, + OP_IO_ADVISE = 63, + OP_LAYOUTERROR = 64, + OP_LAYOUTSTATS = 65, + OP_OFFLOAD_CANCEL = 66, + OP_OFFLOAD_STATUS = 67, + OP_READ_PLUS = 68, + OP_SEEK = 69, + OP_WRITE_SAME = 70, + OP_CLONE = 71, + OP_ILLEGAL = 10044, }; -struct tcmsg { - unsigned char tcm_family; - unsigned char tcm__pad1; - short unsigned int tcm__pad2; - int tcm_ifindex; - __u32 tcm_handle; - __u32 tcm_parent; - __u32 tcm_info; +struct nfs4_string { + unsigned int len; + char *data; }; -struct gnet_stats_basic_cpu { - struct gnet_stats_basic_packed bstats; - struct u64_stats_sync syncp; +struct nfs_fsid { + uint64_t major; + uint64_t minor; }; -struct gnet_dump { - spinlock_t *lock; - struct sk_buff *skb; - struct nlattr *tail; - int compat_tc_stats; - int compat_xstats; - int padattr; - void *xstats; - int xstats_len; - struct tc_stats tc_stats; +struct nfs4_threshold { + __u32 bm; + __u32 l_type; + __u64 rd_sz; + __u64 wr_sz; + __u64 rd_io_sz; + __u64 wr_io_sz; }; -struct nla_policy { - u8 type; - u8 validation_type; - u16 len; +struct nfs_fattr { + unsigned int valid; + umode_t mode; + __u32 nlink; + kuid_t uid; + kgid_t gid; + dev_t rdev; + __u64 size; union { - const void *validation_data; struct { - s16 min; - s16 max; - }; - int (*validate)(const struct nlattr *, struct netlink_ext_ack *); - u16 strict_start_type; - }; + __u32 blocksize; + __u32 blocks; + } nfs2; + struct { + __u64 used; + } nfs3; + } du; + struct nfs_fsid fsid; + __u64 fileid; + __u64 mounted_on_fileid; + struct timespec64 atime; + struct timespec64 mtime; + struct timespec64 ctime; + __u64 change_attr; + __u64 pre_change_attr; + __u64 pre_size; + struct timespec64 pre_mtime; + struct timespec64 pre_ctime; + long unsigned int time_start; + long unsigned int gencount; + struct nfs4_string *owner_name; + struct nfs4_string *group_name; + struct nfs4_threshold *mdsthreshold; }; -struct nl_info { - struct nlmsghdr *nlh; - struct net *nl_net; - u32 portid; - u8 skip_notify: 1; - u8 skip_notify_kernel: 1; +struct nfs_fsinfo { + struct nfs_fattr *fattr; + __u32 rtmax; + __u32 rtpref; + __u32 rtmult; + __u32 wtmax; + __u32 wtpref; + __u32 wtmult; + __u32 dtpref; + __u64 maxfilesize; + struct timespec64 time_delta; + __u32 lease_time; + __u32 nlayouttypes; + __u32 layouttype[8]; + __u32 blksize; + __u32 clone_blksize; }; -struct rhash_lock_head {}; - -struct flow_block { - struct list_head cb_list; +struct nfs_fsstat { + struct nfs_fattr *fattr; + __u64 tbytes; + __u64 fbytes; + __u64 abytes; + __u64 tfiles; + __u64 ffiles; + __u64 afiles; }; -typedef int flow_setup_cb_t(enum tc_setup_type, void *, void *); +struct nfs_pathconf { + struct nfs_fattr *fattr; + __u32 max_link; + __u32 max_namelen; +}; -struct qdisc_size_table { - struct callback_head rcu; - struct list_head list; - struct tc_sizespec szopts; - int refcnt; - u16 data[0]; +struct nfs4_change_info { + u32 atomic; + u64 before; + u64 after; }; -struct Qdisc_class_ops; +struct nfs4_slot; -struct Qdisc_ops { - struct Qdisc_ops *next; - const struct Qdisc_class_ops *cl_ops; - char id[16]; - int priv_size; - unsigned int static_flags; - int (*enqueue)(struct sk_buff *, struct Qdisc *, struct sk_buff **); - struct sk_buff * (*dequeue)(struct Qdisc *); - struct sk_buff * (*peek)(struct Qdisc *); - int (*init)(struct Qdisc *, struct nlattr *, struct netlink_ext_ack *); - void (*reset)(struct Qdisc *); - void (*destroy)(struct Qdisc *); - int (*change)(struct Qdisc *, struct nlattr *, struct netlink_ext_ack *); - void (*attach)(struct Qdisc *); - int (*change_tx_queue_len)(struct Qdisc *, unsigned int); - int (*dump)(struct Qdisc *, struct sk_buff *); - int (*dump_stats)(struct Qdisc *, struct gnet_dump *); - void (*ingress_block_set)(struct Qdisc *, u32); - void (*egress_block_set)(struct Qdisc *, u32); - u32 (*ingress_block_get)(struct Qdisc *); - u32 (*egress_block_get)(struct Qdisc *); - struct module *owner; +struct nfs4_sequence_args { + struct nfs4_slot *sa_slot; + u8 sa_cache_this: 1; + u8 sa_privileged: 1; }; -struct qdisc_walker; +struct nfs4_sequence_res { + struct nfs4_slot *sr_slot; + long unsigned int sr_timestamp; + int sr_status; + u32 sr_status_flags; + u32 sr_highest_slotid; + u32 sr_target_highest_slotid; +}; -struct tcf_block; +struct nfs_open_context; -struct Qdisc_class_ops { - unsigned int flags; - struct netdev_queue * (*select_queue)(struct Qdisc *, struct tcmsg *); - int (*graft)(struct Qdisc *, long unsigned int, struct Qdisc *, struct Qdisc **, struct netlink_ext_ack *); - struct Qdisc * (*leaf)(struct Qdisc *, long unsigned int); - void (*qlen_notify)(struct Qdisc *, long unsigned int); - long unsigned int (*find)(struct Qdisc *, u32); - int (*change)(struct Qdisc *, u32, u32, struct nlattr **, long unsigned int *, struct netlink_ext_ack *); - int (*delete)(struct Qdisc *, long unsigned int); - void (*walk)(struct Qdisc *, struct qdisc_walker *); - struct tcf_block * (*tcf_block)(struct Qdisc *, long unsigned int, struct netlink_ext_ack *); - long unsigned int (*bind_tcf)(struct Qdisc *, long unsigned int, u32); - void (*unbind_tcf)(struct Qdisc *, long unsigned int); - int (*dump)(struct Qdisc *, long unsigned int, struct sk_buff *, struct tcmsg *); - int (*dump_stats)(struct Qdisc *, long unsigned int, struct gnet_dump *); +struct nfs_lock_context { + refcount_t count; + struct list_head list; + struct nfs_open_context *open_context; + fl_owner_t lockowner; + atomic_t io_count; + struct callback_head callback_head; }; -struct tcf_chain; +struct nfs4_state; -struct tcf_block { - struct mutex lock; - struct list_head chain_list; - u32 index; - refcount_t refcnt; - struct net *net; - struct Qdisc *q; - struct rw_semaphore cb_lock; - struct flow_block flow_block; - struct list_head owner_list; - bool keep_dst; - atomic_t offloadcnt; - unsigned int nooffloaddevcnt; - unsigned int lockeddevcnt; - struct { - struct tcf_chain *chain; - struct list_head filter_chain_list; - } chain0; - struct callback_head rcu; - struct hlist_head proto_destroy_ht[128]; - struct mutex proto_destroy_lock; +struct nfs_open_context { + struct nfs_lock_context lock_context; + fl_owner_t flock_owner; + struct dentry *dentry; + const struct cred *cred; + struct rpc_cred *ll_cred; + struct nfs4_state *state; + fmode_t mode; + long unsigned int flags; + int error; + struct list_head list; + struct nfs4_threshold *mdsthreshold; + struct callback_head callback_head; }; -struct tcf_result; +struct nfs_auth_info { + unsigned int flavor_len; + rpc_authflavor_t flavors[12]; +}; -struct tcf_proto_ops; +struct pnfs_layoutdriver_type; -struct tcf_proto { - struct tcf_proto *next; - void *root; - int (*classify)(struct sk_buff *, const struct tcf_proto *, struct tcf_result *); - __be16 protocol; - u32 prio; - void *data; - const struct tcf_proto_ops *ops; - struct tcf_chain *chain; - spinlock_t lock; - bool deleting; - refcount_t refcnt; - struct callback_head rcu; - struct hlist_node destroy_ht_node; -}; +struct nfs_client; -struct tcf_result { - union { - struct { - long unsigned int class; - u32 classid; - }; - const struct tcf_proto *goto_tp; - struct { - bool ingress; - struct gnet_stats_queue *qstats; - }; - }; -}; +struct nlm_host; -struct tcf_walker; +struct nfs_iostats; -struct tcf_proto_ops { - struct list_head head; - char kind[16]; - int (*classify)(struct sk_buff *, const struct tcf_proto *, struct tcf_result *); - int (*init)(struct tcf_proto *); - void (*destroy)(struct tcf_proto *, bool, struct netlink_ext_ack *); - void * (*get)(struct tcf_proto *, u32); - void (*put)(struct tcf_proto *, void *); - int (*change)(struct net *, struct sk_buff *, struct tcf_proto *, long unsigned int, u32, struct nlattr **, void **, bool, bool, struct netlink_ext_ack *); - int (*delete)(struct tcf_proto *, void *, bool *, bool, struct netlink_ext_ack *); - bool (*delete_empty)(struct tcf_proto *); - void (*walk)(struct tcf_proto *, struct tcf_walker *, bool); - int (*reoffload)(struct tcf_proto *, bool, flow_setup_cb_t *, void *, struct netlink_ext_ack *); - void (*hw_add)(struct tcf_proto *, void *); - void (*hw_del)(struct tcf_proto *, void *); - void (*bind_class)(void *, u32, long unsigned int); - void * (*tmplt_create)(struct net *, struct tcf_chain *, struct nlattr **, struct netlink_ext_ack *); - void (*tmplt_destroy)(void *); - int (*dump)(struct net *, struct tcf_proto *, void *, struct sk_buff *, struct tcmsg *, bool); - int (*tmplt_dump)(struct sk_buff *, struct net *, void *); - struct module *owner; +struct nfs_server { + struct nfs_client *nfs_client; + struct list_head client_link; + struct list_head master_link; + struct rpc_clnt *client; + struct rpc_clnt *client_acl; + struct nlm_host *nlm_host; + struct nfs_iostats *io_stats; + atomic_long_t writeback; int flags; + unsigned int caps; + unsigned int rsize; + unsigned int rpages; + unsigned int wsize; + unsigned int wpages; + unsigned int wtmult; + unsigned int dtsize; + short unsigned int port; + unsigned int bsize; + unsigned int acregmin; + unsigned int acregmax; + unsigned int acdirmin; + unsigned int acdirmax; + unsigned int namelen; + unsigned int options; + unsigned int clone_blksize; + struct nfs_fsid fsid; + __u64 maxfilesize; + struct timespec64 time_delta; + long unsigned int mount_time; + struct super_block *super; + dev_t s_dev; + struct nfs_auth_info auth_info; + u32 pnfs_blksize; + u32 attr_bitmask[3]; + u32 attr_bitmask_nl[3]; + u32 exclcreat_bitmask[3]; + u32 cache_consistency_bitmask[3]; + u32 acl_bitmask; + u32 fh_expire_type; + struct pnfs_layoutdriver_type *pnfs_curr_ld; + struct rpc_wait_queue roc_rpcwaitq; + void *pnfs_ld_data; + struct rb_root state_owners; + struct ida openowner_id; + struct ida lockowner_id; + struct list_head state_owners_lru; + struct list_head layouts; + struct list_head delegations; + struct list_head ss_copies; + long unsigned int mig_gen; + long unsigned int mig_status; + void (*destroy)(struct nfs_server *); + atomic_t active; + struct __kernel_sockaddr_storage mountd_address; + size_t mountd_addrlen; + u32 mountd_version; + short unsigned int mountd_port; + short unsigned int mountd_protocol; + struct rpc_wait_queue uoc_rpcwaitq; + unsigned int read_hdrsize; + const struct cred *cred; }; -struct tcf_chain { - struct mutex filter_chain_lock; - struct tcf_proto *filter_chain; - struct list_head list; - struct tcf_block *block; - u32 index; - unsigned int refcnt; - unsigned int action_refcnt; - bool explicitly_created; - bool flushing; - const struct tcf_proto_ops *tmplt_ops; - void *tmplt_priv; - struct callback_head rcu; -}; +struct nfs41_server_owner; -struct sock_fprog_kern { - u16 len; - struct sock_filter *filter; -}; +struct nfs41_server_scope; -struct sk_filter { - refcount_t refcnt; - struct callback_head rcu; - struct bpf_prog *prog; -}; +struct nfs41_impl_id; -struct bpf_redirect_info { - u32 flags; - u32 tgt_index; - void *tgt_value; - struct bpf_map *map; - struct bpf_map *map_to_flush; - u32 kern_flags; -}; +struct nfs_rpc_ops; -enum { - NEIGH_VAR_MCAST_PROBES = 0, - NEIGH_VAR_UCAST_PROBES = 1, - NEIGH_VAR_APP_PROBES = 2, - NEIGH_VAR_MCAST_REPROBES = 3, - NEIGH_VAR_RETRANS_TIME = 4, - NEIGH_VAR_BASE_REACHABLE_TIME = 5, - NEIGH_VAR_DELAY_PROBE_TIME = 6, - NEIGH_VAR_GC_STALETIME = 7, - NEIGH_VAR_QUEUE_LEN_BYTES = 8, - NEIGH_VAR_PROXY_QLEN = 9, - NEIGH_VAR_ANYCAST_DELAY = 10, - NEIGH_VAR_PROXY_DELAY = 11, - NEIGH_VAR_LOCKTIME = 12, - NEIGH_VAR_QUEUE_LEN = 13, - NEIGH_VAR_RETRANS_TIME_MS = 14, - NEIGH_VAR_BASE_REACHABLE_TIME_MS = 15, - NEIGH_VAR_GC_INTERVAL = 16, - NEIGH_VAR_GC_THRESH1 = 17, - NEIGH_VAR_GC_THRESH2 = 18, - NEIGH_VAR_GC_THRESH3 = 19, - NEIGH_VAR_MAX = 20, -}; +struct nfs_subversion; -struct pneigh_entry; +struct idmap; -struct neigh_statistics; +struct nfs4_minor_version_ops; -struct neigh_hash_table; +struct nfs4_slot_table; -struct neigh_table { - int family; - unsigned int entry_size; - unsigned int key_len; - __be16 protocol; - __u32 (*hash)(const void *, const struct net_device *, __u32 *); - bool (*key_eq)(const struct neighbour *, const void *); - int (*constructor)(struct neighbour *); - int (*pconstructor)(struct pneigh_entry *); - void (*pdestructor)(struct pneigh_entry *); - void (*proxy_redo)(struct sk_buff *); - bool (*allow_add)(const struct net_device *, struct netlink_ext_ack *); - char *id; - struct neigh_parms parms; - struct list_head parms_list; - int gc_interval; - int gc_thresh1; - int gc_thresh2; - int gc_thresh3; - long unsigned int last_flush; - struct delayed_work gc_work; - struct timer_list proxy_timer; - struct sk_buff_head proxy_queue; - atomic_t entries; - atomic_t gc_entries; - struct list_head gc_list; - rwlock_t lock; - long unsigned int last_rand; - struct neigh_statistics *stats; - struct neigh_hash_table *nht; - struct pneigh_entry **phash_buckets; +struct nfs4_session; + +struct nfs_client { + refcount_t cl_count; + atomic_t cl_mds_count; + int cl_cons_state; + long unsigned int cl_res_state; + long unsigned int cl_flags; + struct __kernel_sockaddr_storage cl_addr; + size_t cl_addrlen; + char *cl_hostname; + char *cl_acceptor; + struct list_head cl_share_link; + struct list_head cl_superblocks; + struct rpc_clnt *cl_rpcclient; + const struct nfs_rpc_ops *rpc_ops; + int cl_proto; + struct nfs_subversion *cl_nfs_mod; + u32 cl_minorversion; + unsigned int cl_nconnect; + const char *cl_principal; + struct list_head cl_ds_clients; + u64 cl_clientid; + nfs4_verifier cl_confirm; + long unsigned int cl_state; + spinlock_t cl_lock; + long unsigned int cl_lease_time; + long unsigned int cl_last_renewal; + struct delayed_work cl_renewd; + struct rpc_wait_queue cl_rpcwaitq; + struct idmap *cl_idmap; + const char *cl_owner_id; + u32 cl_cb_ident; + const struct nfs4_minor_version_ops *cl_mvops; + long unsigned int cl_mig_gen; + struct nfs4_slot_table *cl_slot_tbl; + u32 cl_seqid; + u32 cl_exchange_flags; + struct nfs4_session *cl_session; + bool cl_preserve_clid; + struct nfs41_server_owner *cl_serverowner; + struct nfs41_server_scope *cl_serverscope; + struct nfs41_impl_id *cl_implid; + long unsigned int cl_sp4_flags; + char cl_ipaddr[48]; + struct net *cl_net; + struct list_head pending_cb_stateids; }; -struct neigh_statistics { - long unsigned int allocs; - long unsigned int destroys; - long unsigned int hash_grows; - long unsigned int res_failed; - long unsigned int lookups; - long unsigned int hits; - long unsigned int rcv_probes_mcast; - long unsigned int rcv_probes_ucast; - long unsigned int periodic_gc_runs; - long unsigned int forced_gc_runs; - long unsigned int unres_discards; - long unsigned int table_fulls; +struct nfs_write_verifier { + char data[8]; }; -struct neigh_ops { - int family; - void (*solicit)(struct neighbour *, struct sk_buff *); - void (*error_report)(struct neighbour *, struct sk_buff *); - int (*output)(struct neighbour *, struct sk_buff *); - int (*connected_output)(struct neighbour *, struct sk_buff *); +struct nfs_writeverf { + struct nfs_write_verifier verifier; + enum nfs3_stable_how committed; }; -struct pneigh_entry { - struct pneigh_entry *next; - possible_net_t net; - struct net_device *dev; - u8 flags; - u8 protocol; - u8 key[0]; +struct nfs_pgio_args { + struct nfs4_sequence_args seq_args; + struct nfs_fh *fh; + struct nfs_open_context *context; + struct nfs_lock_context *lock_context; + nfs4_stateid stateid; + __u64 offset; + __u32 count; + unsigned int pgbase; + struct page **pages; + union { + unsigned int replen; + struct { + const u32 *bitmask; + enum nfs3_stable_how stable; + }; + }; }; -struct neigh_hash_table { - struct neighbour **hash_buckets; - unsigned int hash_shift; - __u32 hash_rnd[4]; - struct callback_head rcu; +struct nfs_pgio_res { + struct nfs4_sequence_res seq_res; + struct nfs_fattr *fattr; + __u32 count; + __u32 op_status; + union { + struct { + unsigned int replen; + int eof; + }; + struct { + struct nfs_writeverf *verf; + const struct nfs_server *server; + }; + }; }; -enum { - TCP_ESTABLISHED = 1, - TCP_SYN_SENT = 2, - TCP_SYN_RECV = 3, - TCP_FIN_WAIT1 = 4, - TCP_FIN_WAIT2 = 5, - TCP_TIME_WAIT = 6, - TCP_CLOSE = 7, - TCP_CLOSE_WAIT = 8, - TCP_LAST_ACK = 9, - TCP_LISTEN = 10, - TCP_CLOSING = 11, - TCP_NEW_SYN_RECV = 12, - TCP_MAX_STATES = 13, +struct nfs_commitargs { + struct nfs4_sequence_args seq_args; + struct nfs_fh *fh; + __u64 offset; + __u32 count; + const u32 *bitmask; }; -struct fib_rule_hdr { - __u8 family; - __u8 dst_len; - __u8 src_len; - __u8 tos; - __u8 table; - __u8 res1; - __u8 res2; - __u8 action; - __u32 flags; +struct nfs_commitres { + struct nfs4_sequence_res seq_res; + __u32 op_status; + struct nfs_fattr *fattr; + struct nfs_writeverf *verf; + const struct nfs_server *server; }; -struct fib_rule_port_range { - __u16 start; - __u16 end; +struct nfs_removeargs { + struct nfs4_sequence_args seq_args; + const struct nfs_fh *fh; + struct qstr name; }; -struct fib_kuid_range { - kuid_t start; - kuid_t end; +struct nfs_removeres { + struct nfs4_sequence_res seq_res; + struct nfs_server *server; + struct nfs_fattr *dir_attr; + struct nfs4_change_info cinfo; }; -struct fib_rule { - struct list_head list; - int iifindex; - int oifindex; - u32 mark; - u32 mark_mask; - u32 flags; - u32 table; - u8 action; - u8 l3mdev; - u8 proto; - u8 ip_proto; - u32 target; - __be64 tun_id; - struct fib_rule *ctarget; - struct net *fr_net; - refcount_t refcnt; - u32 pref; - int suppress_ifgroup; - int suppress_prefixlen; - char iifname[16]; - char oifname[16]; - struct fib_kuid_range uid_range; - struct fib_rule_port_range sport_range; - struct fib_rule_port_range dport_range; - struct callback_head rcu; +struct nfs_renameargs { + struct nfs4_sequence_args seq_args; + const struct nfs_fh *old_dir; + const struct nfs_fh *new_dir; + const struct qstr *old_name; + const struct qstr *new_name; }; -struct fib_lookup_arg { - void *lookup_ptr; - const void *lookup_data; - void *result; - struct fib_rule *rule; - u32 table; - int flags; +struct nfs_renameres { + struct nfs4_sequence_res seq_res; + struct nfs_server *server; + struct nfs4_change_info old_cinfo; + struct nfs_fattr *old_fattr; + struct nfs4_change_info new_cinfo; + struct nfs_fattr *new_fattr; }; -struct smc_hashinfo; +struct nfs_entry { + __u64 ino; + __u64 cookie; + __u64 prev_cookie; + const char *name; + unsigned int len; + int eof; + struct nfs_fh *fh; + struct nfs_fattr *fattr; + struct nfs4_label *label; + unsigned char d_type; + struct nfs_server *server; +}; -struct request_sock_ops; +struct pnfs_ds_commit_info {}; -struct timewait_sock_ops; +struct nfs_page_array { + struct page **pagevec; + unsigned int npages; + struct page *page_array[8]; +}; -struct udp_table; +struct nfs_page; -struct raw_hashinfo; +struct pnfs_layout_segment; -struct proto { - void (*close)(struct sock *, long int); - int (*pre_connect)(struct sock *, struct sockaddr *, int); - int (*connect)(struct sock *, struct sockaddr *, int); - int (*disconnect)(struct sock *, int); - struct sock * (*accept)(struct sock *, int, int *, bool); - int (*ioctl)(struct sock *, int, long unsigned int); - int (*init)(struct sock *); - void (*destroy)(struct sock *); - void (*shutdown)(struct sock *, int); - int (*setsockopt)(struct sock *, int, int, char *, unsigned int); - int (*getsockopt)(struct sock *, int, int, char *, int *); - void (*keepalive)(struct sock *, int); - int (*compat_setsockopt)(struct sock *, int, int, char *, unsigned int); - int (*compat_getsockopt)(struct sock *, int, int, char *, int *); - int (*compat_ioctl)(struct sock *, unsigned int, long unsigned int); - int (*sendmsg)(struct sock *, struct msghdr *, size_t); - int (*recvmsg)(struct sock *, struct msghdr *, size_t, int, int, int *); - int (*sendpage)(struct sock *, struct page *, int, size_t, int); - int (*bind)(struct sock *, struct sockaddr *, int); - int (*backlog_rcv)(struct sock *, struct sk_buff *); - void (*release_cb)(struct sock *); - int (*hash)(struct sock *); - void (*unhash)(struct sock *); - void (*rehash)(struct sock *); - int (*get_port)(struct sock *, short unsigned int); - unsigned int inuse_idx; - bool (*stream_memory_free)(const struct sock *, int); - bool (*stream_memory_read)(const struct sock *); - void (*enter_memory_pressure)(struct sock *); - void (*leave_memory_pressure)(struct sock *); - atomic_long_t *memory_allocated; - struct percpu_counter *sockets_allocated; - long unsigned int *memory_pressure; - long int *sysctl_mem; - int *sysctl_wmem; - int *sysctl_rmem; - u32 sysctl_wmem_offset; - u32 sysctl_rmem_offset; - int max_header; - bool no_autobind; - struct kmem_cache *slab; - unsigned int obj_size; - slab_flags_t slab_flags; - unsigned int useroffset; - unsigned int usersize; - struct percpu_counter *orphan_count; - struct request_sock_ops *rsk_prot; - struct timewait_sock_ops *twsk_prot; - union { - struct inet_hashinfo *hashinfo; - struct udp_table *udp_table; - struct raw_hashinfo *raw_hash; - struct smc_hashinfo *smc_hash; - } h; - struct module *owner; - char name[32]; - struct list_head node; - int (*diag_destroy)(struct sock *, int); -}; +struct nfs_pgio_completion_ops; -struct request_sock; +struct nfs_rw_ops; -struct request_sock_ops { - int family; - unsigned int obj_size; - struct kmem_cache *slab; - char *slab_name; - int (*rtx_syn_ack)(const struct sock *, struct request_sock *); - void (*send_ack)(const struct sock *, struct sk_buff *, struct request_sock *); - void (*send_reset)(const struct sock *, struct sk_buff *); - void (*destructor)(struct request_sock *); - void (*syn_ack_timeout)(const struct request_sock *); +struct nfs_io_completion; + +struct nfs_direct_req; + +struct nfs_pgio_header { + struct inode *inode; + const struct cred *cred; + struct list_head pages; + struct nfs_page *req; + struct nfs_writeverf verf; + fmode_t rw_mode; + struct pnfs_layout_segment *lseg; + loff_t io_start; + const struct rpc_call_ops *mds_ops; + void (*release)(struct nfs_pgio_header *); + const struct nfs_pgio_completion_ops *completion_ops; + const struct nfs_rw_ops *rw_ops; + struct nfs_io_completion *io_completion; + struct nfs_direct_req *dreq; + int pnfs_error; + int error; + unsigned int good_bytes; + long unsigned int flags; + struct rpc_task task; + struct nfs_fattr fattr; + struct nfs_pgio_args args; + struct nfs_pgio_res res; + long unsigned int timestamp; + int (*pgio_done_cb)(struct rpc_task *, struct nfs_pgio_header *); + __u64 mds_offset; + struct nfs_page_array page_array; + struct nfs_client *ds_clp; + int ds_commit_idx; + int pgio_mirror_idx; }; -struct timewait_sock_ops { - struct kmem_cache *twsk_slab; - char *twsk_slab_name; - unsigned int twsk_obj_size; - int (*twsk_unique)(struct sock *, struct sock *, void *); - void (*twsk_destructor)(struct sock *); +struct nfs_pgio_completion_ops { + void (*error_cleanup)(struct list_head *, int); + void (*init_hdr)(struct nfs_pgio_header *); + void (*completion)(struct nfs_pgio_header *); + void (*reschedule_io)(struct nfs_pgio_header *); }; -struct request_sock { - struct sock_common __req_common; - struct request_sock *dl_next; - u16 mss; - u8 num_retrans; - u8 cookie_ts: 1; - u8 num_timeout: 7; - u32 ts_recent; - struct timer_list rsk_timer; - const struct request_sock_ops *rsk_ops; - struct sock *sk; - u32 *saved_syn; - u32 secid; - u32 peer_secid; +struct rpc_task_setup; + +struct nfs_rw_ops { + struct nfs_pgio_header * (*rw_alloc_header)(); + void (*rw_free_header)(struct nfs_pgio_header *); + int (*rw_done)(struct rpc_task *, struct nfs_pgio_header *, struct inode *); + void (*rw_result)(struct rpc_task *, struct nfs_pgio_header *); + void (*rw_initiate)(struct nfs_pgio_header *, struct rpc_message *, const struct nfs_rpc_ops *, struct rpc_task_setup *, int); }; -enum tsq_enum { - TSQ_THROTTLED = 0, - TSQ_QUEUED = 1, - TCP_TSQ_DEFERRED = 2, - TCP_WRITE_TIMER_DEFERRED = 3, - TCP_DELACK_TIMER_DEFERRED = 4, - TCP_MTU_REDUCED_DEFERRED = 5, +struct nfs_mds_commit_info { + atomic_t rpcs_out; + atomic_long_t ncommit; + struct list_head list; }; -struct static_key_false_deferred { - struct static_key_false key; - long unsigned int timeout; - struct delayed_work work; +struct nfs_commit_data; + +struct nfs_commit_info; + +struct nfs_commit_completion_ops { + void (*completion)(struct nfs_commit_data *); + void (*resched_write)(struct nfs_commit_info *, struct nfs_page *); }; -struct ip6_sf_list { - struct ip6_sf_list *sf_next; - struct in6_addr sf_addr; - long unsigned int sf_count[2]; - unsigned char sf_gsresp; - unsigned char sf_oldin; - unsigned char sf_crcount; +struct nfs_commit_data { + struct rpc_task task; + struct inode *inode; + const struct cred *cred; + struct nfs_fattr fattr; + struct nfs_writeverf verf; + struct list_head pages; + struct list_head list; + struct nfs_direct_req *dreq; + struct nfs_commitargs args; + struct nfs_commitres res; + struct nfs_open_context *context; + struct pnfs_layout_segment *lseg; + struct nfs_client *ds_clp; + int ds_commit_index; + loff_t lwb; + const struct rpc_call_ops *mds_ops; + const struct nfs_commit_completion_ops *completion_ops; + int (*commit_done_cb)(struct rpc_task *, struct nfs_commit_data *); + long unsigned int flags; }; -struct ifmcaddr6 { - struct in6_addr mca_addr; - struct inet6_dev *idev; - struct ifmcaddr6 *next; - struct ip6_sf_list *mca_sources; - struct ip6_sf_list *mca_tomb; - unsigned int mca_sfmode; - unsigned char mca_crcount; - long unsigned int mca_sfcount[2]; - struct timer_list mca_timer; - unsigned int mca_flags; - int mca_users; - refcount_t mca_refcnt; - spinlock_t mca_lock; - long unsigned int mca_cstamp; - long unsigned int mca_tstamp; +struct nfs_commit_info { + struct inode *inode; + struct nfs_mds_commit_info *mds; + struct pnfs_ds_commit_info *ds; + struct nfs_direct_req *dreq; + const struct nfs_commit_completion_ops *completion_ops; }; -struct ifacaddr6 { - struct in6_addr aca_addr; - struct fib6_info *aca_rt; - struct ifacaddr6 *aca_next; - struct hlist_node aca_addr_lst; - int aca_users; - refcount_t aca_refcnt; - long unsigned int aca_cstamp; - long unsigned int aca_tstamp; - struct callback_head rcu; +struct nfs_unlinkdata { + struct nfs_removeargs args; + struct nfs_removeres res; + struct dentry *dentry; + wait_queue_head_t wq; + const struct cred *cred; + struct nfs_fattr dir_attr; + long int timeout; }; -struct fib6_result; +struct nfs_renamedata { + struct nfs_renameargs args; + struct nfs_renameres res; + const struct cred *cred; + struct inode *old_dir; + struct dentry *old_dentry; + struct nfs_fattr old_fattr; + struct inode *new_dir; + struct dentry *new_dentry; + struct nfs_fattr new_fattr; + void (*complete)(struct rpc_task *, struct nfs_renamedata *); + long int timeout; + bool cancelled; +}; -struct fib6_nh; +struct nlmclnt_operations; -struct fib6_config; +struct nfs_mount_info; -struct ipv6_stub { - int (*ipv6_sock_mc_join)(struct sock *, int, const struct in6_addr *); - int (*ipv6_sock_mc_drop)(struct sock *, int, const struct in6_addr *); - struct dst_entry * (*ipv6_dst_lookup_flow)(struct net *, const struct sock *, struct flowi6 *, const struct in6_addr *); - int (*ipv6_route_input)(struct sk_buff *); - struct fib6_table * (*fib6_get_table)(struct net *, u32); - int (*fib6_lookup)(struct net *, int, struct flowi6 *, struct fib6_result *, int); - int (*fib6_table_lookup)(struct net *, struct fib6_table *, int, struct flowi6 *, struct fib6_result *, int); - void (*fib6_select_path)(const struct net *, struct fib6_result *, struct flowi6 *, int, bool, const struct sk_buff *, int); - u32 (*ip6_mtu_from_fib6)(const struct fib6_result *, const struct in6_addr *, const struct in6_addr *); - int (*fib6_nh_init)(struct net *, struct fib6_nh *, struct fib6_config *, gfp_t, struct netlink_ext_ack *); - void (*fib6_nh_release)(struct fib6_nh *); - void (*fib6_update_sernum)(struct net *, struct fib6_info *); - int (*ip6_del_rt)(struct net *, struct fib6_info *); - void (*fib6_rt_update)(struct net *, struct fib6_info *, struct nl_info *); - void (*udpv6_encap_enable)(); - void (*ndisc_send_na)(struct net_device *, const struct in6_addr *, const struct in6_addr *, bool, bool, bool, bool); - struct neigh_table *nd_tbl; -}; +struct nfs_access_entry; -struct fib6_result { - struct fib6_nh *nh; - struct fib6_info *f6i; - u32 fib6_flags; - u8 fib6_type; - struct rt6_info *rt6; +struct nfs_client_initdata; + +struct nfs_rpc_ops { + u32 version; + const struct dentry_operations *dentry_ops; + const struct inode_operations *dir_inode_ops; + const struct inode_operations *file_inode_ops; + const struct file_operations *file_ops; + const struct nlmclnt_operations *nlmclnt_ops; + int (*getroot)(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); + struct vfsmount * (*submount)(struct nfs_server *, struct dentry *, struct nfs_fh *, struct nfs_fattr *); + struct dentry * (*try_mount)(int, const char *, struct nfs_mount_info *, struct nfs_subversion *); + int (*getattr)(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *, struct inode *); + int (*setattr)(struct dentry *, struct nfs_fattr *, struct iattr *); + int (*lookup)(struct inode *, const struct qstr *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *); + int (*lookupp)(struct inode *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *); + int (*access)(struct inode *, struct nfs_access_entry *); + int (*readlink)(struct inode *, struct page *, unsigned int, unsigned int); + int (*create)(struct inode *, struct dentry *, struct iattr *, int); + int (*remove)(struct inode *, struct dentry *); + void (*unlink_setup)(struct rpc_message *, struct dentry *, struct inode *); + void (*unlink_rpc_prepare)(struct rpc_task *, struct nfs_unlinkdata *); + int (*unlink_done)(struct rpc_task *, struct inode *); + void (*rename_setup)(struct rpc_message *, struct dentry *, struct dentry *); + void (*rename_rpc_prepare)(struct rpc_task *, struct nfs_renamedata *); + int (*rename_done)(struct rpc_task *, struct inode *, struct inode *); + int (*link)(struct inode *, struct inode *, const struct qstr *); + int (*symlink)(struct inode *, struct dentry *, struct page *, unsigned int, struct iattr *); + int (*mkdir)(struct inode *, struct dentry *, struct iattr *); + int (*rmdir)(struct inode *, const struct qstr *); + int (*readdir)(struct dentry *, const struct cred *, u64, struct page **, unsigned int, bool); + int (*mknod)(struct inode *, struct dentry *, struct iattr *, dev_t); + int (*statfs)(struct nfs_server *, struct nfs_fh *, struct nfs_fsstat *); + int (*fsinfo)(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); + int (*pathconf)(struct nfs_server *, struct nfs_fh *, struct nfs_pathconf *); + int (*set_capabilities)(struct nfs_server *, struct nfs_fh *); + int (*decode_dirent)(struct xdr_stream *, struct nfs_entry *, bool); + int (*pgio_rpc_prepare)(struct rpc_task *, struct nfs_pgio_header *); + void (*read_setup)(struct nfs_pgio_header *, struct rpc_message *); + int (*read_done)(struct rpc_task *, struct nfs_pgio_header *); + void (*write_setup)(struct nfs_pgio_header *, struct rpc_message *, struct rpc_clnt **); + int (*write_done)(struct rpc_task *, struct nfs_pgio_header *); + void (*commit_setup)(struct nfs_commit_data *, struct rpc_message *, struct rpc_clnt **); + void (*commit_rpc_prepare)(struct rpc_task *, struct nfs_commit_data *); + int (*commit_done)(struct rpc_task *, struct nfs_commit_data *); + int (*lock)(struct file *, int, struct file_lock *); + int (*lock_check_bounds)(const struct file_lock *); + void (*clear_acl_cache)(struct inode *); + void (*close_context)(struct nfs_open_context *, int); + struct inode * (*open_context)(struct inode *, struct nfs_open_context *, int, struct iattr *, int *); + int (*have_delegation)(struct inode *, fmode_t); + struct nfs_client * (*alloc_client)(const struct nfs_client_initdata *); + struct nfs_client * (*init_client)(struct nfs_client *, const struct nfs_client_initdata *); + void (*free_client)(struct nfs_client *); + struct nfs_server * (*create_server)(struct nfs_mount_info *, struct nfs_subversion *); + struct nfs_server * (*clone_server)(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, rpc_authflavor_t); }; -enum { - __ND_OPT_PREFIX_INFO_END = 0, - ND_OPT_SOURCE_LL_ADDR = 1, - ND_OPT_TARGET_LL_ADDR = 2, - ND_OPT_PREFIX_INFO = 3, - ND_OPT_REDIRECT_HDR = 4, - ND_OPT_MTU = 5, - ND_OPT_NONCE = 14, - __ND_OPT_ARRAY_MAX = 15, - ND_OPT_ROUTE_INFO = 24, - ND_OPT_RDNSS = 25, - ND_OPT_DNSSL = 31, - ND_OPT_6CO = 34, - ND_OPT_CAPTIVE_PORTAL = 37, - __ND_OPT_MAX = 38, +struct nlmclnt_operations { + void (*nlmclnt_alloc_call)(void *); + bool (*nlmclnt_unlock_prepare)(struct rpc_task *, void *); + void (*nlmclnt_release_call)(void *); }; -struct nd_opt_hdr { - __u8 nd_opt_type; - __u8 nd_opt_len; +struct nfs_access_entry { + struct rb_node rb_node; + struct list_head lru; + const struct cred *cred; + __u32 mask; + struct callback_head callback_head; }; -struct ndisc_options { - struct nd_opt_hdr *nd_opt_array[15]; - struct nd_opt_hdr *nd_useropts; - struct nd_opt_hdr *nd_useropts_end; +struct nfs_client_initdata { + long unsigned int init_flags; + const char *hostname; + const struct sockaddr *addr; + const char *nodename; + const char *ip_addr; + size_t addrlen; + struct nfs_subversion *nfs_mod; + int proto; + u32 minorversion; + unsigned int nconnect; + struct net *net; + const struct rpc_timeout *timeparms; + const struct cred *cred; }; -struct prefix_info { - __u8 type; - __u8 length; - __u8 prefix_len; - __u8 reserved: 6; - __u8 autoconf: 1; - __u8 onlink: 1; - __be32 valid; - __be32 prefered; - __be32 reserved2; - struct in6_addr prefix; -}; +struct nfs_seqid; -enum nfs_opnum4 { - OP_ACCESS = 3, - OP_CLOSE = 4, - OP_COMMIT = 5, - OP_CREATE = 6, - OP_DELEGPURGE = 7, - OP_DELEGRETURN = 8, - OP_GETATTR = 9, - OP_GETFH = 10, - OP_LINK = 11, - OP_LOCK = 12, - OP_LOCKT = 13, - OP_LOCKU = 14, - OP_LOOKUP = 15, - OP_LOOKUPP = 16, - OP_NVERIFY = 17, - OP_OPEN = 18, - OP_OPENATTR = 19, - OP_OPEN_CONFIRM = 20, - OP_OPEN_DOWNGRADE = 21, - OP_PUTFH = 22, - OP_PUTPUBFH = 23, - OP_PUTROOTFH = 24, - OP_READ = 25, - OP_READDIR = 26, - OP_READLINK = 27, - OP_REMOVE = 28, - OP_RENAME = 29, - OP_RENEW = 30, - OP_RESTOREFH = 31, - OP_SAVEFH = 32, - OP_SECINFO = 33, - OP_SETATTR = 34, - OP_SETCLIENTID = 35, - OP_SETCLIENTID_CONFIRM = 36, - OP_VERIFY = 37, - OP_WRITE = 38, - OP_RELEASE_LOCKOWNER = 39, - OP_BACKCHANNEL_CTL = 40, - OP_BIND_CONN_TO_SESSION = 41, - OP_EXCHANGE_ID = 42, - OP_CREATE_SESSION = 43, - OP_DESTROY_SESSION = 44, - OP_FREE_STATEID = 45, - OP_GET_DIR_DELEGATION = 46, - OP_GETDEVICEINFO = 47, - OP_GETDEVICELIST = 48, - OP_LAYOUTCOMMIT = 49, - OP_LAYOUTGET = 50, - OP_LAYOUTRETURN = 51, - OP_SECINFO_NO_NAME = 52, - OP_SEQUENCE = 53, - OP_SET_SSV = 54, - OP_TEST_STATEID = 55, - OP_WANT_DELEGATION = 56, - OP_DESTROY_CLIENTID = 57, - OP_RECLAIM_COMPLETE = 58, - OP_ALLOCATE = 59, - OP_COPY = 60, - OP_COPY_NOTIFY = 61, - OP_DEALLOCATE = 62, - OP_IO_ADVISE = 63, - OP_LAYOUTERROR = 64, - OP_LAYOUTSTATS = 65, - OP_OFFLOAD_CANCEL = 66, - OP_OFFLOAD_STATUS = 67, - OP_READ_PLUS = 68, - OP_SEEK = 69, - OP_WRITE_SAME = 70, - OP_CLONE = 71, - OP_ILLEGAL = 10044, +struct nfs_seqid_counter; + +struct nfs4_state_recovery_ops; + +struct nfs4_state_maintenance_ops; + +struct nfs4_mig_recovery_ops; + +struct nfs4_minor_version_ops { + u32 minor_version; + unsigned int init_caps; + int (*init_client)(struct nfs_client *); + void (*shutdown_client)(struct nfs_client *); + bool (*match_stateid)(const nfs4_stateid *, const nfs4_stateid *); + int (*find_root_sec)(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); + void (*free_lock_state)(struct nfs_server *, struct nfs4_lock_state *); + int (*test_and_free_expired)(struct nfs_server *, nfs4_stateid *, const struct cred *); + struct nfs_seqid * (*alloc_seqid)(struct nfs_seqid_counter *, gfp_t); + void (*session_trunk)(struct rpc_clnt *, struct rpc_xprt *, void *); + const struct rpc_call_ops *call_sync_ops; + const struct nfs4_state_recovery_ops *reboot_recovery_ops; + const struct nfs4_state_recovery_ops *nograce_recovery_ops; + const struct nfs4_state_maintenance_ops *state_renewal_ops; + const struct nfs4_mig_recovery_ops *mig_recovery_ops; }; enum perf_branch_sample_type_shift { @@ -13443,6 +16375,21 @@ struct uuidcmp { int len; }; +struct subprocess_info { + struct work_struct work; + struct completion *complete; + const char *path; + char **argv; + char **envp; + struct file *file; + int wait; + int retval; + pid_t pid; + int (*init)(struct subprocess_info *, struct cred *); + void (*cleanup)(struct subprocess_info *); + void *data; +}; + struct mdu_array_info_s { int major_version; int minor_version; @@ -13511,6 +16458,52 @@ enum state { typedef int (*decompress_fn)(unsigned char *, long int, long int (*)(void *, long unsigned int), long int (*)(void *, long unsigned int), unsigned char *, long int *, void (*)(char *)); +typedef u32 note_buf_t[92]; + +struct kimage_arch { + p4d_t *p4d; + pud_t *pud; + pmd_t *pmd; + pte_t *pte; + void *elf_headers; + long unsigned int elf_headers_sz; + long unsigned int elf_load_addr; +}; + +typedef void crash_vmclear_fn(); + +typedef long unsigned int kimage_entry_t; + +struct kexec_segment { + union { + void *buf; + void *kbuf; + }; + size_t bufsz; + long unsigned int mem; + size_t memsz; +}; + +struct kimage { + kimage_entry_t head; + kimage_entry_t *entry; + kimage_entry_t *last_entry; + long unsigned int start; + struct page *control_code_page; + struct page *swap_page; + void *vmcoreinfo_data_copy; + long unsigned int nr_segments; + struct kexec_segment segment[16]; + struct list_head control_pages; + struct list_head dest_pages; + struct list_head unusable_pages; + long unsigned int control_page; + unsigned int type: 1; + unsigned int preserve_context: 1; + unsigned int file_mode: 1; + struct kimage_arch arch; +}; + enum ucount_type { UCOUNT_USER_NAMESPACES = 0, UCOUNT_PID_NAMESPACES = 1, @@ -13882,6 +16875,40 @@ enum tcp_conntrack { TCP_CONNTRACK_TIMEOUT_MAX = 14, }; +enum ct_dccp_states { + CT_DCCP_NONE = 0, + CT_DCCP_REQUEST = 1, + CT_DCCP_RESPOND = 2, + CT_DCCP_PARTOPEN = 3, + CT_DCCP_OPEN = 4, + CT_DCCP_CLOSEREQ = 5, + CT_DCCP_CLOSING = 6, + CT_DCCP_TIMEWAIT = 7, + CT_DCCP_IGNORE = 8, + CT_DCCP_INVALID = 9, + __CT_DCCP_MAX = 10, +}; + +enum ip_conntrack_dir { + IP_CT_DIR_ORIGINAL = 0, + IP_CT_DIR_REPLY = 1, + IP_CT_DIR_MAX = 2, +}; + +enum sctp_conntrack { + SCTP_CONNTRACK_NONE = 0, + SCTP_CONNTRACK_CLOSED = 1, + SCTP_CONNTRACK_COOKIE_WAIT = 2, + SCTP_CONNTRACK_COOKIE_ECHOED = 3, + SCTP_CONNTRACK_ESTABLISHED = 4, + SCTP_CONNTRACK_SHUTDOWN_SENT = 5, + SCTP_CONNTRACK_SHUTDOWN_RECD = 6, + SCTP_CONNTRACK_SHUTDOWN_ACK_SENT = 7, + SCTP_CONNTRACK_HEARTBEAT_SENT = 8, + SCTP_CONNTRACK_HEARTBEAT_ACKED = 9, + SCTP_CONNTRACK_MAX = 10, +}; + enum udp_conntrack { UDP_CT_UNREPLIED = 0, UDP_CT_REPLIED = 1, @@ -13901,6 +16928,13 @@ enum skb_ext_id { SKB_EXT_NUM = 1, }; +enum sched_tunable_scaling { + SCHED_TUNABLESCALING_NONE = 0, + SCHED_TUNABLESCALING_LOG = 1, + SCHED_TUNABLESCALING_LINEAR = 2, + SCHED_TUNABLESCALING_END = 3, +}; + enum audit_ntp_type { AUDIT_NTP_OFFSET = 0, AUDIT_NTP_FREQ = 1, @@ -13911,6 +16945,8 @@ enum audit_ntp_type { AUDIT_NTP_NVALS = 6, }; +typedef long int (*sys_call_ptr_t)(const struct pt_regs *); + enum { EI_ETYPE_NONE = 0, EI_ETYPE_NULL = 1, @@ -13919,8 +16955,6 @@ enum { EI_ETYPE_TRUE = 4, }; -typedef long int (*sys_call_ptr_t)(const struct pt_regs *); - struct io_bitmap { u64 sequence; refcount_t refcnt; @@ -14046,6 +17080,11 @@ struct kprobe_ctlblk { struct prev_kprobe prev_kprobe; }; +struct kretprobe_blackpoint { + const char *name; + void *addr; +}; + struct kprobe_insn_cache { struct mutex mutex; void * (*alloc)(); @@ -14064,801 +17103,303 @@ struct trace_event_raw_sys_enter { struct trace_event_raw_sys_exit { struct trace_entry ent; - long int id; - long int ret; - char __data[0]; -}; - -struct trace_event_data_offsets_sys_enter {}; - -struct trace_event_data_offsets_sys_exit {}; - -struct alt_instr { - s32 instr_offset; - s32 repl_offset; - u16 cpuid; - u8 instrlen; - u8 replacementlen; - u8 padlen; -} __attribute__((packed)); - -enum vm_fault_reason { - VM_FAULT_OOM = 1, - VM_FAULT_SIGBUS = 2, - VM_FAULT_MAJOR = 4, - VM_FAULT_WRITE = 8, - VM_FAULT_HWPOISON = 16, - VM_FAULT_HWPOISON_LARGE = 32, - VM_FAULT_SIGSEGV = 64, - VM_FAULT_NOPAGE = 256, - VM_FAULT_LOCKED = 512, - VM_FAULT_RETRY = 1024, - VM_FAULT_FALLBACK = 2048, - VM_FAULT_DONE_COW = 4096, - VM_FAULT_NEEDDSYNC = 8192, - VM_FAULT_HINDEX_MASK = 983040, -}; - -struct vm_special_mapping { - const char *name; - struct page **pages; - vm_fault_t (*fault)(const struct vm_special_mapping *, struct vm_area_struct *, struct vm_fault *); - int (*mremap)(const struct vm_special_mapping *, struct vm_area_struct *); -}; - -struct pvclock_vcpu_time_info { - u32 version; - u32 pad0; - u64 tsc_timestamp; - u64 system_time; - u32 tsc_to_system_mul; - s8 tsc_shift; - u8 flags; - u8 pad[2]; -}; - -struct pvclock_vsyscall_time_info { - struct pvclock_vcpu_time_info pvti; - long: 64; - long: 64; - long: 64; - long: 64; -}; - -struct ms_hyperv_tsc_page { - volatile u32 tsc_sequence; - u32 reserved1; - volatile u64 tsc_scale; - volatile s64 tsc_offset; - u64 reserved2[509]; -}; - -enum { - X86_TRAP_DE = 0, - X86_TRAP_DB = 1, - X86_TRAP_NMI = 2, - X86_TRAP_BP = 3, - X86_TRAP_OF = 4, - X86_TRAP_BR = 5, - X86_TRAP_UD = 6, - X86_TRAP_NM = 7, - X86_TRAP_DF = 8, - X86_TRAP_OLD_MF = 9, - X86_TRAP_TS = 10, - X86_TRAP_NP = 11, - X86_TRAP_SS = 12, - X86_TRAP_GP = 13, - X86_TRAP_PF = 14, - X86_TRAP_SPURIOUS = 15, - X86_TRAP_MF = 16, - X86_TRAP_AC = 17, - X86_TRAP_MC = 18, - X86_TRAP_XF = 19, - X86_TRAP_IRET = 32, -}; - -enum x86_pf_error_code { - X86_PF_PROT = 1, - X86_PF_WRITE = 2, - X86_PF_USER = 4, - X86_PF_RSVD = 8, - X86_PF_INSTR = 16, - X86_PF_PK = 32, -}; - -struct trace_event_raw_emulate_vsyscall { - struct trace_entry ent; - int nr; - char __data[0]; -}; - -struct trace_event_data_offsets_emulate_vsyscall {}; - -enum { - EMULATE = 0, - XONLY = 1, - NONE = 2, -}; - -enum perf_type_id { - PERF_TYPE_HARDWARE = 0, - PERF_TYPE_SOFTWARE = 1, - PERF_TYPE_TRACEPOINT = 2, - PERF_TYPE_HW_CACHE = 3, - PERF_TYPE_RAW = 4, - PERF_TYPE_BREAKPOINT = 5, - PERF_TYPE_MAX = 6, -}; - -enum perf_hw_id { - PERF_COUNT_HW_CPU_CYCLES = 0, - PERF_COUNT_HW_INSTRUCTIONS = 1, - PERF_COUNT_HW_CACHE_REFERENCES = 2, - PERF_COUNT_HW_CACHE_MISSES = 3, - PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 4, - PERF_COUNT_HW_BRANCH_MISSES = 5, - PERF_COUNT_HW_BUS_CYCLES = 6, - PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 7, - PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 8, - PERF_COUNT_HW_REF_CPU_CYCLES = 9, - PERF_COUNT_HW_MAX = 10, -}; - -enum perf_hw_cache_id { - PERF_COUNT_HW_CACHE_L1D = 0, - PERF_COUNT_HW_CACHE_L1I = 1, - PERF_COUNT_HW_CACHE_LL = 2, - PERF_COUNT_HW_CACHE_DTLB = 3, - PERF_COUNT_HW_CACHE_ITLB = 4, - PERF_COUNT_HW_CACHE_BPU = 5, - PERF_COUNT_HW_CACHE_NODE = 6, - PERF_COUNT_HW_CACHE_MAX = 7, -}; - -enum perf_hw_cache_op_id { - PERF_COUNT_HW_CACHE_OP_READ = 0, - PERF_COUNT_HW_CACHE_OP_WRITE = 1, - PERF_COUNT_HW_CACHE_OP_PREFETCH = 2, - PERF_COUNT_HW_CACHE_OP_MAX = 3, -}; - -enum perf_hw_cache_op_result_id { - PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0, - PERF_COUNT_HW_CACHE_RESULT_MISS = 1, - PERF_COUNT_HW_CACHE_RESULT_MAX = 2, -}; - -enum perf_event_sample_format { - PERF_SAMPLE_IP = 1, - PERF_SAMPLE_TID = 2, - PERF_SAMPLE_TIME = 4, - PERF_SAMPLE_ADDR = 8, - PERF_SAMPLE_READ = 16, - PERF_SAMPLE_CALLCHAIN = 32, - PERF_SAMPLE_ID = 64, - PERF_SAMPLE_CPU = 128, - PERF_SAMPLE_PERIOD = 256, - PERF_SAMPLE_STREAM_ID = 512, - PERF_SAMPLE_RAW = 1024, - PERF_SAMPLE_BRANCH_STACK = 2048, - PERF_SAMPLE_REGS_USER = 4096, - PERF_SAMPLE_STACK_USER = 8192, - PERF_SAMPLE_WEIGHT = 16384, - PERF_SAMPLE_DATA_SRC = 32768, - PERF_SAMPLE_IDENTIFIER = 65536, - PERF_SAMPLE_TRANSACTION = 131072, - PERF_SAMPLE_REGS_INTR = 262144, - PERF_SAMPLE_PHYS_ADDR = 524288, - PERF_SAMPLE_AUX = 1048576, - PERF_SAMPLE_MAX = 2097152, - __PERF_SAMPLE_CALLCHAIN_EARLY = 4294967295, -}; - -enum perf_branch_sample_type { - PERF_SAMPLE_BRANCH_USER = 1, - PERF_SAMPLE_BRANCH_KERNEL = 2, - PERF_SAMPLE_BRANCH_HV = 4, - PERF_SAMPLE_BRANCH_ANY = 8, - PERF_SAMPLE_BRANCH_ANY_CALL = 16, - PERF_SAMPLE_BRANCH_ANY_RETURN = 32, - PERF_SAMPLE_BRANCH_IND_CALL = 64, - PERF_SAMPLE_BRANCH_ABORT_TX = 128, - PERF_SAMPLE_BRANCH_IN_TX = 256, - PERF_SAMPLE_BRANCH_NO_TX = 512, - PERF_SAMPLE_BRANCH_COND = 1024, - PERF_SAMPLE_BRANCH_CALL_STACK = 2048, - PERF_SAMPLE_BRANCH_IND_JUMP = 4096, - PERF_SAMPLE_BRANCH_CALL = 8192, - PERF_SAMPLE_BRANCH_NO_FLAGS = 16384, - PERF_SAMPLE_BRANCH_NO_CYCLES = 32768, - PERF_SAMPLE_BRANCH_TYPE_SAVE = 65536, - PERF_SAMPLE_BRANCH_MAX = 131072, -}; - -struct perf_event_mmap_page { - __u32 version; - __u32 compat_version; - __u32 lock; - __u32 index; - __s64 offset; - __u64 time_enabled; - __u64 time_running; - union { - __u64 capabilities; - struct { - __u64 cap_bit0: 1; - __u64 cap_bit0_is_deprecated: 1; - __u64 cap_user_rdpmc: 1; - __u64 cap_user_time: 1; - __u64 cap_user_time_zero: 1; - __u64 cap_____res: 59; - }; - }; - __u16 pmc_width; - __u16 time_shift; - __u32 time_mult; - __u64 time_offset; - __u64 time_zero; - __u32 size; - __u8 __reserved[948]; - __u64 data_head; - __u64 data_tail; - __u64 data_offset; - __u64 data_size; - __u64 aux_head; - __u64 aux_tail; - __u64 aux_offset; - __u64 aux_size; -}; - -struct ldt_struct { - struct desc_struct *entries; - unsigned int nr_entries; - int slot; -}; - -typedef struct { - u16 __softirq_pending; - unsigned int __nmi_count; - unsigned int apic_timer_irqs; - unsigned int irq_spurious_count; - unsigned int icr_read_retry_count; - unsigned int kvm_posted_intr_ipis; - unsigned int kvm_posted_intr_wakeup_ipis; - unsigned int kvm_posted_intr_nested_ipis; - unsigned int x86_platform_ipis; - unsigned int apic_perf_irqs; - unsigned int apic_irq_work_irqs; - unsigned int irq_resched_count; - unsigned int irq_call_count; - unsigned int irq_tlb_count; - unsigned int irq_thermal_count; - unsigned int irq_threshold_count; - unsigned int irq_deferred_error_count; - long: 32; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; -} irq_cpustat_t; - -struct x86_pmu_capability { - int version; - int num_counters_gp; - int num_counters_fixed; - int bit_width_gp; - int bit_width_fixed; - unsigned int events_mask; - int events_mask_len; + long int id; + long int ret; + char __data[0]; }; -struct debug_store { - u64 bts_buffer_base; - u64 bts_index; - u64 bts_absolute_maximum; - u64 bts_interrupt_threshold; - u64 pebs_buffer_base; - u64 pebs_index; - u64 pebs_absolute_maximum; - u64 pebs_interrupt_threshold; - u64 pebs_event_reset[12]; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +struct trace_event_data_offsets_sys_enter {}; + +struct trace_event_data_offsets_sys_exit {}; + +typedef void (*btf_trace_sys_enter)(void *, struct pt_regs *, long int); + +typedef void (*btf_trace_sys_exit)(void *, struct pt_regs *, long int); + +struct alt_instr { + s32 instr_offset; + s32 repl_offset; + u16 cpuid; + u8 instrlen; + u8 replacementlen; + u8 padlen; +} __attribute__((packed)); + +enum vm_fault_reason { + VM_FAULT_OOM = 1, + VM_FAULT_SIGBUS = 2, + VM_FAULT_MAJOR = 4, + VM_FAULT_WRITE = 8, + VM_FAULT_HWPOISON = 16, + VM_FAULT_HWPOISON_LARGE = 32, + VM_FAULT_SIGSEGV = 64, + VM_FAULT_NOPAGE = 256, + VM_FAULT_LOCKED = 512, + VM_FAULT_RETRY = 1024, + VM_FAULT_FALLBACK = 2048, + VM_FAULT_DONE_COW = 4096, + VM_FAULT_NEEDDSYNC = 8192, + VM_FAULT_HINDEX_MASK = 983040, +}; + +struct vm_special_mapping { + const char *name; + struct page **pages; + vm_fault_t (*fault)(const struct vm_special_mapping *, struct vm_area_struct *, struct vm_fault *); + int (*mremap)(const struct vm_special_mapping *, struct vm_area_struct *); +}; + +struct pvclock_vcpu_time_info { + u32 version; + u32 pad0; + u64 tsc_timestamp; + u64 system_time; + u32 tsc_to_system_mul; + s8 tsc_shift; + u8 flags; + u8 pad[2]; +}; + +struct pvclock_vsyscall_time_info { + struct pvclock_vcpu_time_info pvti; long: 64; long: 64; long: 64; long: 64; }; +struct vdso_timestamp { + u64 sec; + u64 nsec; +}; + +struct vdso_data { + u32 seq; + s32 clock_mode; + u64 cycle_last; + u64 mask; + u32 mult; + u32 shift; + struct vdso_timestamp basetime[12]; + s32 tz_minuteswest; + s32 tz_dsttime; + u32 hrtimer_res; + u32 __unused; +}; + +struct ms_hyperv_tsc_page { + volatile u32 tsc_sequence; + u32 reserved1; + volatile u64 tsc_scale; + volatile s64 tsc_offset; + u64 reserved2[509]; +}; + +struct ms_hyperv_info { + u32 features; + u32 misc_features; + u32 hints; + u32 nested_features; + u32 max_vp_index; + u32 max_lp_index; +}; + +enum { + X86_TRAP_DE = 0, + X86_TRAP_DB = 1, + X86_TRAP_NMI = 2, + X86_TRAP_BP = 3, + X86_TRAP_OF = 4, + X86_TRAP_BR = 5, + X86_TRAP_UD = 6, + X86_TRAP_NM = 7, + X86_TRAP_DF = 8, + X86_TRAP_OLD_MF = 9, + X86_TRAP_TS = 10, + X86_TRAP_NP = 11, + X86_TRAP_SS = 12, + X86_TRAP_GP = 13, + X86_TRAP_PF = 14, + X86_TRAP_SPURIOUS = 15, + X86_TRAP_MF = 16, + X86_TRAP_AC = 17, + X86_TRAP_MC = 18, + X86_TRAP_XF = 19, + X86_TRAP_IRET = 32, +}; + +enum x86_pf_error_code { + X86_PF_PROT = 1, + X86_PF_WRITE = 2, + X86_PF_USER = 4, + X86_PF_RSVD = 8, + X86_PF_INSTR = 16, + X86_PF_PK = 32, +}; + +struct trace_event_raw_emulate_vsyscall { + struct trace_entry ent; + int nr; + char __data[0]; +}; + +struct trace_event_data_offsets_emulate_vsyscall {}; + +typedef void (*btf_trace_emulate_vsyscall)(void *, int); + +enum { + EMULATE = 0, + XONLY = 1, + NONE = 2, +}; + +enum perf_type_id { + PERF_TYPE_HARDWARE = 0, + PERF_TYPE_SOFTWARE = 1, + PERF_TYPE_TRACEPOINT = 2, + PERF_TYPE_HW_CACHE = 3, + PERF_TYPE_RAW = 4, + PERF_TYPE_BREAKPOINT = 5, + PERF_TYPE_MAX = 6, +}; + +enum perf_hw_id { + PERF_COUNT_HW_CPU_CYCLES = 0, + PERF_COUNT_HW_INSTRUCTIONS = 1, + PERF_COUNT_HW_CACHE_REFERENCES = 2, + PERF_COUNT_HW_CACHE_MISSES = 3, + PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 4, + PERF_COUNT_HW_BRANCH_MISSES = 5, + PERF_COUNT_HW_BUS_CYCLES = 6, + PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 7, + PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 8, + PERF_COUNT_HW_REF_CPU_CYCLES = 9, + PERF_COUNT_HW_MAX = 10, +}; + +enum perf_hw_cache_id { + PERF_COUNT_HW_CACHE_L1D = 0, + PERF_COUNT_HW_CACHE_L1I = 1, + PERF_COUNT_HW_CACHE_LL = 2, + PERF_COUNT_HW_CACHE_DTLB = 3, + PERF_COUNT_HW_CACHE_ITLB = 4, + PERF_COUNT_HW_CACHE_BPU = 5, + PERF_COUNT_HW_CACHE_NODE = 6, + PERF_COUNT_HW_CACHE_MAX = 7, +}; + +enum perf_hw_cache_op_id { + PERF_COUNT_HW_CACHE_OP_READ = 0, + PERF_COUNT_HW_CACHE_OP_WRITE = 1, + PERF_COUNT_HW_CACHE_OP_PREFETCH = 2, + PERF_COUNT_HW_CACHE_OP_MAX = 3, +}; + +enum perf_hw_cache_op_result_id { + PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0, + PERF_COUNT_HW_CACHE_RESULT_MISS = 1, + PERF_COUNT_HW_CACHE_RESULT_MAX = 2, +}; + +enum perf_event_sample_format { + PERF_SAMPLE_IP = 1, + PERF_SAMPLE_TID = 2, + PERF_SAMPLE_TIME = 4, + PERF_SAMPLE_ADDR = 8, + PERF_SAMPLE_READ = 16, + PERF_SAMPLE_CALLCHAIN = 32, + PERF_SAMPLE_ID = 64, + PERF_SAMPLE_CPU = 128, + PERF_SAMPLE_PERIOD = 256, + PERF_SAMPLE_STREAM_ID = 512, + PERF_SAMPLE_RAW = 1024, + PERF_SAMPLE_BRANCH_STACK = 2048, + PERF_SAMPLE_REGS_USER = 4096, + PERF_SAMPLE_STACK_USER = 8192, + PERF_SAMPLE_WEIGHT = 16384, + PERF_SAMPLE_DATA_SRC = 32768, + PERF_SAMPLE_IDENTIFIER = 65536, + PERF_SAMPLE_TRANSACTION = 131072, + PERF_SAMPLE_REGS_INTR = 262144, + PERF_SAMPLE_PHYS_ADDR = 524288, + PERF_SAMPLE_AUX = 1048576, + PERF_SAMPLE_MAX = 2097152, + __PERF_SAMPLE_CALLCHAIN_EARLY = 0, +}; + +enum perf_branch_sample_type { + PERF_SAMPLE_BRANCH_USER = 1, + PERF_SAMPLE_BRANCH_KERNEL = 2, + PERF_SAMPLE_BRANCH_HV = 4, + PERF_SAMPLE_BRANCH_ANY = 8, + PERF_SAMPLE_BRANCH_ANY_CALL = 16, + PERF_SAMPLE_BRANCH_ANY_RETURN = 32, + PERF_SAMPLE_BRANCH_IND_CALL = 64, + PERF_SAMPLE_BRANCH_ABORT_TX = 128, + PERF_SAMPLE_BRANCH_IN_TX = 256, + PERF_SAMPLE_BRANCH_NO_TX = 512, + PERF_SAMPLE_BRANCH_COND = 1024, + PERF_SAMPLE_BRANCH_CALL_STACK = 2048, + PERF_SAMPLE_BRANCH_IND_JUMP = 4096, + PERF_SAMPLE_BRANCH_CALL = 8192, + PERF_SAMPLE_BRANCH_NO_FLAGS = 16384, + PERF_SAMPLE_BRANCH_NO_CYCLES = 32768, + PERF_SAMPLE_BRANCH_TYPE_SAVE = 65536, + PERF_SAMPLE_BRANCH_MAX = 131072, +}; + +struct perf_event_mmap_page { + __u32 version; + __u32 compat_version; + __u32 lock; + __u32 index; + __s64 offset; + __u64 time_enabled; + __u64 time_running; + union { + __u64 capabilities; + struct { + __u64 cap_bit0: 1; + __u64 cap_bit0_is_deprecated: 1; + __u64 cap_user_rdpmc: 1; + __u64 cap_user_time: 1; + __u64 cap_user_time_zero: 1; + __u64 cap_____res: 59; + }; + }; + __u16 pmc_width; + __u16 time_shift; + __u32 time_mult; + __u64 time_offset; + __u64 time_zero; + __u32 size; + __u8 __reserved[948]; + __u64 data_head; + __u64 data_tail; + __u64 data_offset; + __u64 data_size; + __u64 aux_head; + __u64 aux_tail; + __u64 aux_offset; + __u64 aux_size; +}; + +struct ldt_struct { + struct desc_struct *entries; + unsigned int nr_entries; + int slot; +}; + +struct x86_pmu_capability { + int version; + int num_counters_gp; + int num_counters_fixed; + int bit_width_gp; + int bit_width_fixed; + unsigned int events_mask; + int events_mask_len; +}; + enum stack_type { STACK_TYPE_UNKNOWN = 0, STACK_TYPE_TASK = 1, @@ -14892,13 +17433,6 @@ struct perf_guest_switch_msr { u64 guest; }; -struct perf_guest_info_callbacks { - int (*is_in_guest)(); - int (*is_user_mode)(); - long unsigned int (*get_guest_ip)(); - void (*handle_intel_pt_intr)(); -}; - struct device_attribute { struct attribute attr; ssize_t (*show)(struct device *, struct device_attribute *, char *); @@ -15289,6 +17823,10 @@ struct perf_sched { typedef int pao_T__; +typedef int pto_T_____2; + +typedef unsigned int pao_T_____2; + enum migratetype { MIGRATE_UNMOVABLE = 0, MIGRATE_MOVABLE = 1, @@ -15327,8 +17865,6 @@ struct perf_msr { bool no_check; }; -typedef long unsigned int pto_T__; - struct amd_uncore { int id; int refcnt; @@ -15596,6 +18132,14 @@ struct pci_error_handlers { void (*resume)(struct pci_dev *); }; +enum pcie_bus_config_types { + PCIE_BUS_TUNE_OFF = 0, + PCIE_BUS_DEFAULT = 1, + PCIE_BUS_SAFE = 2, + PCIE_BUS_PERFORMANCE = 3, + PCIE_BUS_PEER2PEER = 4, +}; + struct syscore_ops { struct list_head node; int (*suspend)(); @@ -15642,12 +18186,6 @@ struct perf_ibs_data { u64 regs[8]; }; -struct kobj_attribute { - struct attribute attr; - ssize_t (*show)(struct kobject *, struct kobj_attribute *, char *); - ssize_t (*store)(struct kobject *, struct kobj_attribute *, const char *, size_t); -}; - struct amd_iommu; struct perf_amd_iommu { @@ -16800,479 +19338,1761 @@ struct bts_ctx { }; enum { - BTS_STATE_STOPPED = 0, - BTS_STATE_INACTIVE = 1, - BTS_STATE_ACTIVE = 2, + BTS_STATE_STOPPED = 0, + BTS_STATE_INACTIVE = 1, + BTS_STATE_ACTIVE = 2, +}; + +struct bts_phys { + struct page *page; + long unsigned int size; + long unsigned int offset; + long unsigned int displacement; +}; + +struct bts_buffer { + size_t real_size; + unsigned int nr_pages; + unsigned int nr_bufs; + unsigned int cur_buf; + bool snapshot; + local_t data_size; + local_t head; + long unsigned int end; + void **data_pages; + struct bts_phys buf[0]; +}; + +struct pebs_basic { + u64 format_size; + u64 ip; + u64 applicable_counters; + u64 tsc; +}; + +struct pebs_meminfo { + u64 address; + u64 aux; + u64 latency; + u64 tsx_tuning; +}; + +struct pebs_gprs { + u64 flags; + u64 ip; + u64 ax; + u64 cx; + u64 dx; + u64 bx; + u64 sp; + u64 bp; + u64 si; + u64 di; + u64 r8; + u64 r9; + u64 r10; + u64 r11; + u64 r12; + u64 r13; + u64 r14; + u64 r15; +}; + +struct pebs_xmm { + u64 xmm[32]; +}; + +struct pebs_lbr_entry { + u64 from; + u64 to; + u64 info; +}; + +struct pebs_lbr { + struct pebs_lbr_entry lbr[0]; +}; + +struct x86_perf_regs { + struct pt_regs regs; + u64 *xmm_regs; +}; + +typedef unsigned int insn_attr_t; + +typedef unsigned char insn_byte_t; + +typedef int insn_value_t; + +struct insn_field { + union { + insn_value_t value; + insn_byte_t bytes[4]; + }; + unsigned char got; + unsigned char nbytes; +}; + +struct insn { + struct insn_field prefixes; + struct insn_field rex_prefix; + struct insn_field vex_prefix; + struct insn_field opcode; + struct insn_field modrm; + struct insn_field sib; + struct insn_field displacement; + union { + struct insn_field immediate; + struct insn_field moffset1; + struct insn_field immediate1; + }; + union { + struct insn_field moffset2; + struct insn_field immediate2; + }; + int emulate_prefix_size; + insn_attr_t attr; + unsigned char opnd_bytes; + unsigned char addr_bytes; + unsigned char length; + unsigned char x86_64; + const insn_byte_t *kaddr; + const insn_byte_t *end_kaddr; + const insn_byte_t *next_byte; +}; + +enum { + PERF_TXN_ELISION = 1, + PERF_TXN_TRANSACTION = 2, + PERF_TXN_SYNC = 4, + PERF_TXN_ASYNC = 8, + PERF_TXN_RETRY = 16, + PERF_TXN_CONFLICT = 32, + PERF_TXN_CAPACITY_WRITE = 64, + PERF_TXN_CAPACITY_READ = 128, + PERF_TXN_MAX = 256, + PERF_TXN_ABORT_MASK = 0, + PERF_TXN_ABORT_SHIFT = 32, +}; + +struct perf_event_header { + __u32 type; + __u16 misc; + __u16 size; +}; + +union intel_x86_pebs_dse { + u64 val; + struct { + unsigned int ld_dse: 4; + unsigned int ld_stlb_miss: 1; + unsigned int ld_locked: 1; + unsigned int ld_reserved: 26; + }; + struct { + unsigned int st_l1d_hit: 1; + unsigned int st_reserved1: 3; + unsigned int st_stlb_miss: 1; + unsigned int st_locked: 1; + unsigned int st_reserved2: 26; + }; +}; + +struct pebs_record_core { + u64 flags; + u64 ip; + u64 ax; + u64 bx; + u64 cx; + u64 dx; + u64 si; + u64 di; + u64 bp; + u64 sp; + u64 r8; + u64 r9; + u64 r10; + u64 r11; + u64 r12; + u64 r13; + u64 r14; + u64 r15; +}; + +struct pebs_record_nhm { + u64 flags; + u64 ip; + u64 ax; + u64 bx; + u64 cx; + u64 dx; + u64 si; + u64 di; + u64 bp; + u64 sp; + u64 r8; + u64 r9; + u64 r10; + u64 r11; + u64 r12; + u64 r13; + u64 r14; + u64 r15; + u64 status; + u64 dla; + u64 dse; + u64 lat; +}; + +union hsw_tsx_tuning { + struct { + u32 cycles_last_block: 32; + u32 hle_abort: 1; + u32 rtm_abort: 1; + u32 instruction_abort: 1; + u32 non_instruction_abort: 1; + u32 retry: 1; + u32 data_conflict: 1; + u32 capacity_writes: 1; + u32 capacity_reads: 1; + }; + u64 value; +}; + +struct pebs_record_skl { + u64 flags; + u64 ip; + u64 ax; + u64 bx; + u64 cx; + u64 dx; + u64 si; + u64 di; + u64 bp; + u64 sp; + u64 r8; + u64 r9; + u64 r10; + u64 r11; + u64 r12; + u64 r13; + u64 r14; + u64 r15; + u64 status; + u64 dla; + u64 dse; + u64 lat; + u64 real_ip; + u64 tsx_tuning; + u64 tsc; +}; + +struct bts_record { + u64 from; + u64 to; + u64 flags; +}; + +enum { + PERF_BR_UNKNOWN = 0, + PERF_BR_COND = 1, + PERF_BR_UNCOND = 2, + PERF_BR_IND = 3, + PERF_BR_CALL = 4, + PERF_BR_IND_CALL = 5, + PERF_BR_RET = 6, + PERF_BR_SYSCALL = 7, + PERF_BR_SYSRET = 8, + PERF_BR_COND_CALL = 9, + PERF_BR_COND_RET = 10, + PERF_BR_MAX = 11, +}; + +enum { + LBR_FORMAT_32 = 0, + LBR_FORMAT_LIP = 1, + LBR_FORMAT_EIP = 2, + LBR_FORMAT_EIP_FLAGS = 3, + LBR_FORMAT_EIP_FLAGS2 = 4, + LBR_FORMAT_INFO = 5, + LBR_FORMAT_TIME = 6, + LBR_FORMAT_MAX_KNOWN = 6, +}; + +enum { + X86_BR_NONE = 0, + X86_BR_USER = 1, + X86_BR_KERNEL = 2, + X86_BR_CALL = 4, + X86_BR_RET = 8, + X86_BR_SYSCALL = 16, + X86_BR_SYSRET = 32, + X86_BR_INT = 64, + X86_BR_IRET = 128, + X86_BR_JCC = 256, + X86_BR_JMP = 512, + X86_BR_IRQ = 1024, + X86_BR_IND_CALL = 2048, + X86_BR_ABORT = 4096, + X86_BR_IN_TX = 8192, + X86_BR_NO_TX = 16384, + X86_BR_ZERO_CALL = 32768, + X86_BR_CALL_STACK = 65536, + X86_BR_IND_JMP = 131072, + X86_BR_TYPE_SAVE = 262144, +}; + +enum { + LBR_NONE = 0, + LBR_VALID = 1, +}; + +enum P4_EVENTS { + P4_EVENT_TC_DELIVER_MODE = 0, + P4_EVENT_BPU_FETCH_REQUEST = 1, + P4_EVENT_ITLB_REFERENCE = 2, + P4_EVENT_MEMORY_CANCEL = 3, + P4_EVENT_MEMORY_COMPLETE = 4, + P4_EVENT_LOAD_PORT_REPLAY = 5, + P4_EVENT_STORE_PORT_REPLAY = 6, + P4_EVENT_MOB_LOAD_REPLAY = 7, + P4_EVENT_PAGE_WALK_TYPE = 8, + P4_EVENT_BSQ_CACHE_REFERENCE = 9, + P4_EVENT_IOQ_ALLOCATION = 10, + P4_EVENT_IOQ_ACTIVE_ENTRIES = 11, + P4_EVENT_FSB_DATA_ACTIVITY = 12, + P4_EVENT_BSQ_ALLOCATION = 13, + P4_EVENT_BSQ_ACTIVE_ENTRIES = 14, + P4_EVENT_SSE_INPUT_ASSIST = 15, + P4_EVENT_PACKED_SP_UOP = 16, + P4_EVENT_PACKED_DP_UOP = 17, + P4_EVENT_SCALAR_SP_UOP = 18, + P4_EVENT_SCALAR_DP_UOP = 19, + P4_EVENT_64BIT_MMX_UOP = 20, + P4_EVENT_128BIT_MMX_UOP = 21, + P4_EVENT_X87_FP_UOP = 22, + P4_EVENT_TC_MISC = 23, + P4_EVENT_GLOBAL_POWER_EVENTS = 24, + P4_EVENT_TC_MS_XFER = 25, + P4_EVENT_UOP_QUEUE_WRITES = 26, + P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE = 27, + P4_EVENT_RETIRED_BRANCH_TYPE = 28, + P4_EVENT_RESOURCE_STALL = 29, + P4_EVENT_WC_BUFFER = 30, + P4_EVENT_B2B_CYCLES = 31, + P4_EVENT_BNR = 32, + P4_EVENT_SNOOP = 33, + P4_EVENT_RESPONSE = 34, + P4_EVENT_FRONT_END_EVENT = 35, + P4_EVENT_EXECUTION_EVENT = 36, + P4_EVENT_REPLAY_EVENT = 37, + P4_EVENT_INSTR_RETIRED = 38, + P4_EVENT_UOPS_RETIRED = 39, + P4_EVENT_UOP_TYPE = 40, + P4_EVENT_BRANCH_RETIRED = 41, + P4_EVENT_MISPRED_BRANCH_RETIRED = 42, + P4_EVENT_X87_ASSIST = 43, + P4_EVENT_MACHINE_CLEAR = 44, + P4_EVENT_INSTR_COMPLETED = 45, +}; + +enum P4_EVENT_OPCODES { + P4_EVENT_TC_DELIVER_MODE_OPCODE = 257, + P4_EVENT_BPU_FETCH_REQUEST_OPCODE = 768, + P4_EVENT_ITLB_REFERENCE_OPCODE = 6147, + P4_EVENT_MEMORY_CANCEL_OPCODE = 517, + P4_EVENT_MEMORY_COMPLETE_OPCODE = 2050, + P4_EVENT_LOAD_PORT_REPLAY_OPCODE = 1026, + P4_EVENT_STORE_PORT_REPLAY_OPCODE = 1282, + P4_EVENT_MOB_LOAD_REPLAY_OPCODE = 770, + P4_EVENT_PAGE_WALK_TYPE_OPCODE = 260, + P4_EVENT_BSQ_CACHE_REFERENCE_OPCODE = 3079, + P4_EVENT_IOQ_ALLOCATION_OPCODE = 774, + P4_EVENT_IOQ_ACTIVE_ENTRIES_OPCODE = 6662, + P4_EVENT_FSB_DATA_ACTIVITY_OPCODE = 5894, + P4_EVENT_BSQ_ALLOCATION_OPCODE = 1287, + P4_EVENT_BSQ_ACTIVE_ENTRIES_OPCODE = 1543, + P4_EVENT_SSE_INPUT_ASSIST_OPCODE = 13313, + P4_EVENT_PACKED_SP_UOP_OPCODE = 2049, + P4_EVENT_PACKED_DP_UOP_OPCODE = 3073, + P4_EVENT_SCALAR_SP_UOP_OPCODE = 2561, + P4_EVENT_SCALAR_DP_UOP_OPCODE = 3585, + P4_EVENT_64BIT_MMX_UOP_OPCODE = 513, + P4_EVENT_128BIT_MMX_UOP_OPCODE = 6657, + P4_EVENT_X87_FP_UOP_OPCODE = 1025, + P4_EVENT_TC_MISC_OPCODE = 1537, + P4_EVENT_GLOBAL_POWER_EVENTS_OPCODE = 4870, + P4_EVENT_TC_MS_XFER_OPCODE = 1280, + P4_EVENT_UOP_QUEUE_WRITES_OPCODE = 2304, + P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE_OPCODE = 1282, + P4_EVENT_RETIRED_BRANCH_TYPE_OPCODE = 1026, + P4_EVENT_RESOURCE_STALL_OPCODE = 257, + P4_EVENT_WC_BUFFER_OPCODE = 1285, + P4_EVENT_B2B_CYCLES_OPCODE = 5635, + P4_EVENT_BNR_OPCODE = 2051, + P4_EVENT_SNOOP_OPCODE = 1539, + P4_EVENT_RESPONSE_OPCODE = 1027, + P4_EVENT_FRONT_END_EVENT_OPCODE = 2053, + P4_EVENT_EXECUTION_EVENT_OPCODE = 3077, + P4_EVENT_REPLAY_EVENT_OPCODE = 2309, + P4_EVENT_INSTR_RETIRED_OPCODE = 516, + P4_EVENT_UOPS_RETIRED_OPCODE = 260, + P4_EVENT_UOP_TYPE_OPCODE = 514, + P4_EVENT_BRANCH_RETIRED_OPCODE = 1541, + P4_EVENT_MISPRED_BRANCH_RETIRED_OPCODE = 772, + P4_EVENT_X87_ASSIST_OPCODE = 773, + P4_EVENT_MACHINE_CLEAR_OPCODE = 517, + P4_EVENT_INSTR_COMPLETED_OPCODE = 1796, +}; + +enum P4_ESCR_EMASKS { + P4_EVENT_TC_DELIVER_MODE__DD = 512, + P4_EVENT_TC_DELIVER_MODE__DB = 1024, + P4_EVENT_TC_DELIVER_MODE__DI = 2048, + P4_EVENT_TC_DELIVER_MODE__BD = 4096, + P4_EVENT_TC_DELIVER_MODE__BB = 8192, + P4_EVENT_TC_DELIVER_MODE__BI = 16384, + P4_EVENT_TC_DELIVER_MODE__ID = 32768, + P4_EVENT_BPU_FETCH_REQUEST__TCMISS = 512, + P4_EVENT_ITLB_REFERENCE__HIT = 512, + P4_EVENT_ITLB_REFERENCE__MISS = 1024, + P4_EVENT_ITLB_REFERENCE__HIT_UK = 2048, + P4_EVENT_MEMORY_CANCEL__ST_RB_FULL = 2048, + P4_EVENT_MEMORY_CANCEL__64K_CONF = 4096, + P4_EVENT_MEMORY_COMPLETE__LSC = 512, + P4_EVENT_MEMORY_COMPLETE__SSC = 1024, + P4_EVENT_LOAD_PORT_REPLAY__SPLIT_LD = 1024, + P4_EVENT_STORE_PORT_REPLAY__SPLIT_ST = 1024, + P4_EVENT_MOB_LOAD_REPLAY__NO_STA = 1024, + P4_EVENT_MOB_LOAD_REPLAY__NO_STD = 4096, + P4_EVENT_MOB_LOAD_REPLAY__PARTIAL_DATA = 8192, + P4_EVENT_MOB_LOAD_REPLAY__UNALGN_ADDR = 16384, + P4_EVENT_PAGE_WALK_TYPE__DTMISS = 512, + P4_EVENT_PAGE_WALK_TYPE__ITMISS = 1024, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_2ndL_HITS = 512, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_2ndL_HITE = 1024, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_2ndL_HITM = 2048, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_3rdL_HITS = 4096, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_3rdL_HITE = 8192, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_3rdL_HITM = 16384, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_2ndL_MISS = 131072, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_3rdL_MISS = 262144, + P4_EVENT_BSQ_CACHE_REFERENCE__WR_2ndL_MISS = 524288, + P4_EVENT_IOQ_ALLOCATION__DEFAULT = 512, + P4_EVENT_IOQ_ALLOCATION__ALL_READ = 16384, + P4_EVENT_IOQ_ALLOCATION__ALL_WRITE = 32768, + P4_EVENT_IOQ_ALLOCATION__MEM_UC = 65536, + P4_EVENT_IOQ_ALLOCATION__MEM_WC = 131072, + P4_EVENT_IOQ_ALLOCATION__MEM_WT = 262144, + P4_EVENT_IOQ_ALLOCATION__MEM_WP = 524288, + P4_EVENT_IOQ_ALLOCATION__MEM_WB = 1048576, + P4_EVENT_IOQ_ALLOCATION__OWN = 4194304, + P4_EVENT_IOQ_ALLOCATION__OTHER = 8388608, + P4_EVENT_IOQ_ALLOCATION__PREFETCH = 16777216, + P4_EVENT_IOQ_ACTIVE_ENTRIES__DEFAULT = 512, + P4_EVENT_IOQ_ACTIVE_ENTRIES__ALL_READ = 16384, + P4_EVENT_IOQ_ACTIVE_ENTRIES__ALL_WRITE = 32768, + P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_UC = 65536, + P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_WC = 131072, + P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_WT = 262144, + P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_WP = 524288, + P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_WB = 1048576, + P4_EVENT_IOQ_ACTIVE_ENTRIES__OWN = 4194304, + P4_EVENT_IOQ_ACTIVE_ENTRIES__OTHER = 8388608, + P4_EVENT_IOQ_ACTIVE_ENTRIES__PREFETCH = 16777216, + P4_EVENT_FSB_DATA_ACTIVITY__DRDY_DRV = 512, + P4_EVENT_FSB_DATA_ACTIVITY__DRDY_OWN = 1024, + P4_EVENT_FSB_DATA_ACTIVITY__DRDY_OTHER = 2048, + P4_EVENT_FSB_DATA_ACTIVITY__DBSY_DRV = 4096, + P4_EVENT_FSB_DATA_ACTIVITY__DBSY_OWN = 8192, + P4_EVENT_FSB_DATA_ACTIVITY__DBSY_OTHER = 16384, + P4_EVENT_BSQ_ALLOCATION__REQ_TYPE0 = 512, + P4_EVENT_BSQ_ALLOCATION__REQ_TYPE1 = 1024, + P4_EVENT_BSQ_ALLOCATION__REQ_LEN0 = 2048, + P4_EVENT_BSQ_ALLOCATION__REQ_LEN1 = 4096, + P4_EVENT_BSQ_ALLOCATION__REQ_IO_TYPE = 16384, + P4_EVENT_BSQ_ALLOCATION__REQ_LOCK_TYPE = 32768, + P4_EVENT_BSQ_ALLOCATION__REQ_CACHE_TYPE = 65536, + P4_EVENT_BSQ_ALLOCATION__REQ_SPLIT_TYPE = 131072, + P4_EVENT_BSQ_ALLOCATION__REQ_DEM_TYPE = 262144, + P4_EVENT_BSQ_ALLOCATION__REQ_ORD_TYPE = 524288, + P4_EVENT_BSQ_ALLOCATION__MEM_TYPE0 = 1048576, + P4_EVENT_BSQ_ALLOCATION__MEM_TYPE1 = 2097152, + P4_EVENT_BSQ_ALLOCATION__MEM_TYPE2 = 4194304, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_TYPE0 = 512, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_TYPE1 = 1024, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_LEN0 = 2048, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_LEN1 = 4096, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_IO_TYPE = 16384, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_LOCK_TYPE = 32768, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_CACHE_TYPE = 65536, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_SPLIT_TYPE = 131072, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_DEM_TYPE = 262144, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_ORD_TYPE = 524288, + P4_EVENT_BSQ_ACTIVE_ENTRIES__MEM_TYPE0 = 1048576, + P4_EVENT_BSQ_ACTIVE_ENTRIES__MEM_TYPE1 = 2097152, + P4_EVENT_BSQ_ACTIVE_ENTRIES__MEM_TYPE2 = 4194304, + P4_EVENT_SSE_INPUT_ASSIST__ALL = 16777216, + P4_EVENT_PACKED_SP_UOP__ALL = 16777216, + P4_EVENT_PACKED_DP_UOP__ALL = 16777216, + P4_EVENT_SCALAR_SP_UOP__ALL = 16777216, + P4_EVENT_SCALAR_DP_UOP__ALL = 16777216, + P4_EVENT_64BIT_MMX_UOP__ALL = 16777216, + P4_EVENT_128BIT_MMX_UOP__ALL = 16777216, + P4_EVENT_X87_FP_UOP__ALL = 16777216, + P4_EVENT_TC_MISC__FLUSH = 8192, + P4_EVENT_GLOBAL_POWER_EVENTS__RUNNING = 512, + P4_EVENT_TC_MS_XFER__CISC = 512, + P4_EVENT_UOP_QUEUE_WRITES__FROM_TC_BUILD = 512, + P4_EVENT_UOP_QUEUE_WRITES__FROM_TC_DELIVER = 1024, + P4_EVENT_UOP_QUEUE_WRITES__FROM_ROM = 2048, + P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE__CONDITIONAL = 1024, + P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE__CALL = 2048, + P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE__RETURN = 4096, + P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE__INDIRECT = 8192, + P4_EVENT_RETIRED_BRANCH_TYPE__CONDITIONAL = 1024, + P4_EVENT_RETIRED_BRANCH_TYPE__CALL = 2048, + P4_EVENT_RETIRED_BRANCH_TYPE__RETURN = 4096, + P4_EVENT_RETIRED_BRANCH_TYPE__INDIRECT = 8192, + P4_EVENT_RESOURCE_STALL__SBFULL = 16384, + P4_EVENT_WC_BUFFER__WCB_EVICTS = 512, + P4_EVENT_WC_BUFFER__WCB_FULL_EVICTS = 1024, + P4_EVENT_FRONT_END_EVENT__NBOGUS = 512, + P4_EVENT_FRONT_END_EVENT__BOGUS = 1024, + P4_EVENT_EXECUTION_EVENT__NBOGUS0 = 512, + P4_EVENT_EXECUTION_EVENT__NBOGUS1 = 1024, + P4_EVENT_EXECUTION_EVENT__NBOGUS2 = 2048, + P4_EVENT_EXECUTION_EVENT__NBOGUS3 = 4096, + P4_EVENT_EXECUTION_EVENT__BOGUS0 = 8192, + P4_EVENT_EXECUTION_EVENT__BOGUS1 = 16384, + P4_EVENT_EXECUTION_EVENT__BOGUS2 = 32768, + P4_EVENT_EXECUTION_EVENT__BOGUS3 = 65536, + P4_EVENT_REPLAY_EVENT__NBOGUS = 512, + P4_EVENT_REPLAY_EVENT__BOGUS = 1024, + P4_EVENT_INSTR_RETIRED__NBOGUSNTAG = 512, + P4_EVENT_INSTR_RETIRED__NBOGUSTAG = 1024, + P4_EVENT_INSTR_RETIRED__BOGUSNTAG = 2048, + P4_EVENT_INSTR_RETIRED__BOGUSTAG = 4096, + P4_EVENT_UOPS_RETIRED__NBOGUS = 512, + P4_EVENT_UOPS_RETIRED__BOGUS = 1024, + P4_EVENT_UOP_TYPE__TAGLOADS = 1024, + P4_EVENT_UOP_TYPE__TAGSTORES = 2048, + P4_EVENT_BRANCH_RETIRED__MMNP = 512, + P4_EVENT_BRANCH_RETIRED__MMNM = 1024, + P4_EVENT_BRANCH_RETIRED__MMTP = 2048, + P4_EVENT_BRANCH_RETIRED__MMTM = 4096, + P4_EVENT_MISPRED_BRANCH_RETIRED__NBOGUS = 512, + P4_EVENT_X87_ASSIST__FPSU = 512, + P4_EVENT_X87_ASSIST__FPSO = 1024, + P4_EVENT_X87_ASSIST__POAO = 2048, + P4_EVENT_X87_ASSIST__POAU = 4096, + P4_EVENT_X87_ASSIST__PREA = 8192, + P4_EVENT_MACHINE_CLEAR__CLEAR = 512, + P4_EVENT_MACHINE_CLEAR__MOCLEAR = 1024, + P4_EVENT_MACHINE_CLEAR__SMCLEAR = 2048, + P4_EVENT_INSTR_COMPLETED__NBOGUS = 512, + P4_EVENT_INSTR_COMPLETED__BOGUS = 1024, +}; + +enum P4_PEBS_METRIC { + P4_PEBS_METRIC__none = 0, + P4_PEBS_METRIC__1stl_cache_load_miss_retired = 1, + P4_PEBS_METRIC__2ndl_cache_load_miss_retired = 2, + P4_PEBS_METRIC__dtlb_load_miss_retired = 3, + P4_PEBS_METRIC__dtlb_store_miss_retired = 4, + P4_PEBS_METRIC__dtlb_all_miss_retired = 5, + P4_PEBS_METRIC__tagged_mispred_branch = 6, + P4_PEBS_METRIC__mob_load_replay_retired = 7, + P4_PEBS_METRIC__split_load_retired = 8, + P4_PEBS_METRIC__split_store_retired = 9, + P4_PEBS_METRIC__max = 10, +}; + +struct p4_event_bind { + unsigned int opcode; + unsigned int escr_msr[2]; + unsigned int escr_emask; + unsigned int shared; + char cntr[6]; +}; + +struct p4_pebs_bind { + unsigned int metric_pebs; + unsigned int metric_vert; +}; + +struct p4_event_alias { + u64 original; + u64 alternative; +}; + +enum cpuid_regs_idx { + CPUID_EAX = 0, + CPUID_EBX = 1, + CPUID_ECX = 2, + CPUID_EDX = 3, +}; + +struct dev_ext_attribute { + struct device_attribute attr; + void *var; +}; + +enum pt_capabilities { + PT_CAP_max_subleaf = 0, + PT_CAP_cr3_filtering = 1, + PT_CAP_psb_cyc = 2, + PT_CAP_ip_filtering = 3, + PT_CAP_mtc = 4, + PT_CAP_ptwrite = 5, + PT_CAP_power_event_trace = 6, + PT_CAP_topa_output = 7, + PT_CAP_topa_multiple_entries = 8, + PT_CAP_single_range_output = 9, + PT_CAP_output_subsys = 10, + PT_CAP_payloads_lip = 11, + PT_CAP_num_address_ranges = 12, + PT_CAP_mtc_periods = 13, + PT_CAP_cycle_thresholds = 14, + PT_CAP_psb_periods = 15, +}; + +enum perf_addr_filter_action_t { + PERF_ADDR_FILTER_ACTION_STOP = 0, + PERF_ADDR_FILTER_ACTION_START = 1, + PERF_ADDR_FILTER_ACTION_FILTER = 2, +}; + +struct perf_addr_filter { + struct list_head entry; + struct path path; + long unsigned int offset; + long unsigned int size; + enum perf_addr_filter_action_t action; +}; + +struct topa_entry { + u64 end: 1; + u64 rsvd0: 1; + u64 intr: 1; + u64 rsvd1: 1; + u64 stop: 1; + u64 rsvd2: 1; + u64 size: 4; + u64 rsvd3: 2; + u64 base: 36; + u64 rsvd4: 16; +}; + +struct pt_pmu { + struct pmu pmu; + u32 caps[8]; + bool vmx; + bool branch_en_always_on; + long unsigned int max_nonturbo_ratio; + unsigned int tsc_art_num; + unsigned int tsc_art_den; +}; + +struct topa; + +struct pt_buffer { + struct list_head tables; + struct topa *first; + struct topa *last; + struct topa *cur; + unsigned int cur_idx; + size_t output_off; + long unsigned int nr_pages; + local_t data_size; + local64_t head; + bool snapshot; + bool single; + long int stop_pos; + long int intr_pos; + struct topa_entry *stop_te; + struct topa_entry *intr_te; + void **data_pages; +}; + +struct topa { + struct list_head list; + u64 offset; + size_t size; + int last; + unsigned int z_count; +}; + +struct pt_filter { + long unsigned int msr_a; + long unsigned int msr_b; + long unsigned int config; +}; + +struct pt_filters { + struct pt_filter filter[4]; + unsigned int nr_filters; +}; + +struct pt { + struct perf_output_handle handle; + struct pt_filters filters; + int handle_nmi; + int vmx_on; + u64 output_base; + u64 output_mask; +}; + +struct pt_cap_desc { + const char *name; + u32 leaf; + u8 reg; + u32 mask; +}; + +struct pt_address_range { + long unsigned int msr_a; + long unsigned int msr_b; + unsigned int reg_off; +}; + +struct topa_page { + struct topa_entry table[507]; + struct topa topa; +}; + +typedef void (*exitcall_t)(); + +enum hrtimer_mode { + HRTIMER_MODE_ABS = 0, + HRTIMER_MODE_REL = 1, + HRTIMER_MODE_PINNED = 2, + HRTIMER_MODE_SOFT = 4, + HRTIMER_MODE_HARD = 8, + HRTIMER_MODE_ABS_PINNED = 2, + HRTIMER_MODE_REL_PINNED = 3, + HRTIMER_MODE_ABS_SOFT = 4, + HRTIMER_MODE_REL_SOFT = 5, + HRTIMER_MODE_ABS_PINNED_SOFT = 6, + HRTIMER_MODE_REL_PINNED_SOFT = 7, + HRTIMER_MODE_ABS_HARD = 8, + HRTIMER_MODE_REL_HARD = 9, + HRTIMER_MODE_ABS_PINNED_HARD = 10, + HRTIMER_MODE_REL_PINNED_HARD = 11, +}; + +struct x86_cpu_id { + __u16 vendor; + __u16 family; + __u16 model; + __u16 feature; + kernel_ulong_t driver_data; +}; + +enum perf_rapl_events { + PERF_RAPL_PP0 = 0, + PERF_RAPL_PKG = 1, + PERF_RAPL_RAM = 2, + PERF_RAPL_PP1 = 3, + PERF_RAPL_PSYS = 4, + PERF_RAPL_MAX = 5, + NR_RAPL_DOMAINS = 5, +}; + +struct rapl_pmu { + raw_spinlock_t lock; + int n_active; + int cpu; + struct list_head active_list; + struct pmu *pmu; + ktime_t timer_interval; + struct hrtimer hrtimer; +}; + +struct rapl_pmus { + struct pmu pmu; + unsigned int maxdie; + struct rapl_pmu *pmus[0]; +}; + +struct rapl_model { + long unsigned int events; + bool apply_quirk; +}; + +struct acpi_device; + +struct pci_sysdata { + int domain; + int node; + struct acpi_device *companion; + void *iommu; + void *fwnode; +}; + +struct pci_extra_dev { + struct pci_dev *dev[4]; +}; + +struct intel_uncore_pmu; + +struct intel_uncore_ops; + +struct uncore_event_desc; + +struct freerunning_counters; + +struct intel_uncore_type { + const char *name; + int num_counters; + int num_boxes; + int perf_ctr_bits; + int fixed_ctr_bits; + int num_freerunning_types; + unsigned int perf_ctr; + unsigned int event_ctl; + unsigned int event_mask; + unsigned int event_mask_ext; + unsigned int fixed_ctr; + unsigned int fixed_ctl; + unsigned int box_ctl; + union { + unsigned int msr_offset; + unsigned int mmio_offset; + }; + unsigned int num_shared_regs: 8; + unsigned int single_fixed: 1; + unsigned int pair_ctr_ctl: 1; + unsigned int *msr_offsets; + struct event_constraint unconstrainted; + struct event_constraint *constraints; + struct intel_uncore_pmu *pmus; + struct intel_uncore_ops *ops; + struct uncore_event_desc *event_descs; + struct freerunning_counters *freerunning; + const struct attribute_group *attr_groups[4]; + struct pmu *pmu; +}; + +struct intel_uncore_box; + +struct intel_uncore_pmu { + struct pmu pmu; + char name[32]; + int pmu_idx; + int func_id; + bool registered; + atomic_t activeboxes; + struct intel_uncore_type *type; + struct intel_uncore_box **boxes; +}; + +struct intel_uncore_ops { + void (*init_box)(struct intel_uncore_box *); + void (*exit_box)(struct intel_uncore_box *); + void (*disable_box)(struct intel_uncore_box *); + void (*enable_box)(struct intel_uncore_box *); + void (*disable_event)(struct intel_uncore_box *, struct perf_event *); + void (*enable_event)(struct intel_uncore_box *, struct perf_event *); + u64 (*read_counter)(struct intel_uncore_box *, struct perf_event *); + int (*hw_config)(struct intel_uncore_box *, struct perf_event *); + struct event_constraint * (*get_constraint)(struct intel_uncore_box *, struct perf_event *); + void (*put_constraint)(struct intel_uncore_box *, struct perf_event *); +}; + +struct uncore_event_desc { + struct kobj_attribute attr; + const char *config; +}; + +struct freerunning_counters { + unsigned int counter_base; + unsigned int counter_offset; + unsigned int box_offset; + unsigned int num_counters; + unsigned int bits; +}; + +struct intel_uncore_extra_reg { + raw_spinlock_t lock; + u64 config; + u64 config1; + u64 config2; + atomic_t ref; +}; + +struct intel_uncore_box { + int pci_phys_id; + int dieid; + int n_active; + int n_events; + int cpu; + long unsigned int flags; + atomic_t refcnt; + struct perf_event *events[10]; + struct perf_event *event_list[10]; + struct event_constraint *event_constraint[10]; + long unsigned int active_mask[1]; + u64 tags[10]; + struct pci_dev *pci_dev; + struct intel_uncore_pmu *pmu; + u64 hrtimer_duration; + struct hrtimer hrtimer; + struct list_head list; + struct list_head active_list; + void *io_addr; + struct intel_uncore_extra_reg shared_regs[0]; +}; + +struct pci2phy_map { + struct list_head list; + int segment; + int pbus_to_physid[256]; +}; + +struct intel_uncore_init_fun { + void (*cpu_init)(); + int (*pci_init)(); + void (*mmio_init)(); +}; + +enum { + EXTRA_REG_NHMEX_M_FILTER = 0, + EXTRA_REG_NHMEX_M_DSP = 1, + EXTRA_REG_NHMEX_M_ISS = 2, + EXTRA_REG_NHMEX_M_MAP = 3, + EXTRA_REG_NHMEX_M_MSC_THR = 4, + EXTRA_REG_NHMEX_M_PGT = 5, + EXTRA_REG_NHMEX_M_PLD = 6, + EXTRA_REG_NHMEX_M_ZDP_CTL_FVC = 7, +}; + +enum { + SNB_PCI_UNCORE_IMC = 0, +}; + +enum perf_snb_uncore_imc_freerunning_types { + SNB_PCI_UNCORE_IMC_DATA = 0, + SNB_PCI_UNCORE_IMC_FREERUNNING_TYPE_MAX = 1, +}; + +struct imc_uncore_pci_dev { + __u32 pci_id; + struct pci_driver *driver; +}; + +enum { + SNBEP_PCI_QPI_PORT0_FILTER = 0, + SNBEP_PCI_QPI_PORT1_FILTER = 1, + BDX_PCI_QPI_PORT2_FILTER = 2, + HSWEP_PCI_PCU_3 = 3, +}; + +enum { + SNBEP_PCI_UNCORE_HA = 0, + SNBEP_PCI_UNCORE_IMC = 1, + SNBEP_PCI_UNCORE_QPI = 2, + SNBEP_PCI_UNCORE_R2PCIE = 3, + SNBEP_PCI_UNCORE_R3QPI = 4, +}; + +enum { + IVBEP_PCI_UNCORE_HA = 0, + IVBEP_PCI_UNCORE_IMC = 1, + IVBEP_PCI_UNCORE_IRP = 2, + IVBEP_PCI_UNCORE_QPI = 3, + IVBEP_PCI_UNCORE_R2PCIE = 4, + IVBEP_PCI_UNCORE_R3QPI = 5, +}; + +enum { + KNL_PCI_UNCORE_MC_UCLK = 0, + KNL_PCI_UNCORE_MC_DCLK = 1, + KNL_PCI_UNCORE_EDC_UCLK = 2, + KNL_PCI_UNCORE_EDC_ECLK = 3, + KNL_PCI_UNCORE_M2PCIE = 4, + KNL_PCI_UNCORE_IRP = 5, +}; + +enum { + HSWEP_PCI_UNCORE_HA = 0, + HSWEP_PCI_UNCORE_IMC = 1, + HSWEP_PCI_UNCORE_IRP = 2, + HSWEP_PCI_UNCORE_QPI = 3, + HSWEP_PCI_UNCORE_R2PCIE = 4, + HSWEP_PCI_UNCORE_R3QPI = 5, +}; + +enum { + BDX_PCI_UNCORE_HA = 0, + BDX_PCI_UNCORE_IMC = 1, + BDX_PCI_UNCORE_IRP = 2, + BDX_PCI_UNCORE_QPI = 3, + BDX_PCI_UNCORE_R2PCIE = 4, + BDX_PCI_UNCORE_R3QPI = 5, +}; + +enum perf_uncore_iio_freerunning_type_id { + SKX_IIO_MSR_IOCLK = 0, + SKX_IIO_MSR_BW = 1, + SKX_IIO_MSR_UTIL = 2, + SKX_IIO_FREERUNNING_TYPE_MAX = 3, +}; + +enum { + SKX_PCI_UNCORE_IMC = 0, + SKX_PCI_UNCORE_M2M = 1, + SKX_PCI_UNCORE_UPI = 2, + SKX_PCI_UNCORE_M2PCIE = 3, + SKX_PCI_UNCORE_M3UPI = 4, +}; + +enum perf_uncore_snr_iio_freerunning_type_id { + SNR_IIO_MSR_IOCLK = 0, + SNR_IIO_MSR_BW_IN = 1, + SNR_IIO_FREERUNNING_TYPE_MAX = 2, +}; + +enum { + SNR_PCI_UNCORE_M2M = 0, +}; + +enum perf_uncore_snr_imc_freerunning_type_id { + SNR_IMC_DCLK = 0, + SNR_IMC_DDR = 1, + SNR_IMC_FREERUNNING_TYPE_MAX = 2, +}; + +struct cstate_model { + long unsigned int core_events; + long unsigned int pkg_events; + long unsigned int quirks; +}; + +enum perf_cstate_core_events { + PERF_CSTATE_CORE_C1_RES = 0, + PERF_CSTATE_CORE_C3_RES = 1, + PERF_CSTATE_CORE_C6_RES = 2, + PERF_CSTATE_CORE_C7_RES = 3, + PERF_CSTATE_CORE_EVENT_MAX = 4, +}; + +enum perf_cstate_pkg_events { + PERF_CSTATE_PKG_C2_RES = 0, + PERF_CSTATE_PKG_C3_RES = 1, + PERF_CSTATE_PKG_C6_RES = 2, + PERF_CSTATE_PKG_C7_RES = 3, + PERF_CSTATE_PKG_C8_RES = 4, + PERF_CSTATE_PKG_C9_RES = 5, + PERF_CSTATE_PKG_C10_RES = 6, + PERF_CSTATE_PKG_EVENT_MAX = 7, +}; + +struct trampoline_header { + u64 start; + u64 efer; + u32 cr4; + u32 flags; +}; + +enum xfeature { + XFEATURE_FP = 0, + XFEATURE_SSE = 1, + XFEATURE_YMM = 2, + XFEATURE_BNDREGS = 3, + XFEATURE_BNDCSR = 4, + XFEATURE_OPMASK = 5, + XFEATURE_ZMM_Hi256 = 6, + XFEATURE_Hi16_ZMM = 7, + XFEATURE_PT_UNIMPLEMENTED_SO_FAR = 8, + XFEATURE_PKRU = 9, + XFEATURE_MAX = 10, +}; + +struct pkru_state { + u32 pkru; + u32 pad; +}; + +enum show_regs_mode { + SHOW_REGS_SHORT = 0, + SHOW_REGS_USER = 1, + SHOW_REGS_ALL = 2, +}; + +struct shared_info; + +struct start_info; + +enum which_selector { + FS = 0, + GS = 1, +}; + +typedef struct task_struct *pto_T_____3; + +typedef u64 pto_T_____4; + +struct sigcontext_64 { + __u64 r8; + __u64 r9; + __u64 r10; + __u64 r11; + __u64 r12; + __u64 r13; + __u64 r14; + __u64 r15; + __u64 di; + __u64 si; + __u64 bp; + __u64 bx; + __u64 dx; + __u64 ax; + __u64 cx; + __u64 sp; + __u64 ip; + __u64 flags; + __u16 cs; + __u16 gs; + __u16 fs; + __u16 ss; + __u64 err; + __u64 trapno; + __u64 oldmask; + __u64 cr2; + __u64 fpstate; + __u64 reserved1[8]; +}; + +struct sigaltstack { + void *ss_sp; + int ss_flags; + size_t ss_size; +}; + +typedef struct sigaltstack stack_t; + +struct siginfo { + union { + struct { + int si_signo; + int si_errno; + int si_code; + union __sifields _sifields; + }; + int _si_pad[32]; + }; +}; + +struct ucontext { + long unsigned int uc_flags; + struct ucontext *uc_link; + stack_t uc_stack; + struct sigcontext_64 uc_mcontext; + sigset_t uc_sigmask; +}; + +typedef u32 compat_sigset_word; + +typedef struct { + compat_sigset_word sig[2]; +} compat_sigset_t; + +struct mce { + __u64 status; + __u64 misc; + __u64 addr; + __u64 mcgstatus; + __u64 ip; + __u64 tsc; + __u64 time; + __u8 cpuvendor; + __u8 inject_flags; + __u8 severity; + __u8 pad; + __u32 cpuid; + __u8 cs; + __u8 bank; + __u8 cpu; + __u8 finished; + __u32 extcpu; + __u32 socketid; + __u32 apicid; + __u64 mcgcap; + __u64 synd; + __u64 ipid; + __u64 ppin; + __u32 microcode; +}; + +typedef long unsigned int mce_banks_t[1]; + +struct smca_hwid { + unsigned int bank_type; + u32 hwid_mcatype; + u32 xec_bitmap; + u8 count; +}; + +struct smca_bank { + struct smca_hwid *hwid; + u32 id; + u8 sysfs_id; +}; + +struct kernel_vm86_regs { + struct pt_regs pt; + short unsigned int es; + short unsigned int __esh; + short unsigned int ds; + short unsigned int __dsh; + short unsigned int fs; + short unsigned int __fsh; + short unsigned int gs; + short unsigned int __gsh; +}; + +struct rt_sigframe { + char *pretcode; + struct ucontext uc; + struct siginfo info; +}; + +typedef struct siginfo siginfo_t; + +typedef s32 compat_clock_t; + +typedef s32 compat_pid_t; + +typedef s32 compat_timer_t; + +typedef s32 compat_int_t; + +typedef u32 __compat_uid32_t; + +union compat_sigval { + compat_int_t sival_int; + compat_uptr_t sival_ptr; +}; + +typedef union compat_sigval compat_sigval_t; + +struct compat_siginfo { + int si_signo; + int si_errno; + int si_code; + union { + int _pad[29]; + struct { + compat_pid_t _pid; + __compat_uid32_t _uid; + } _kill; + struct { + compat_timer_t _tid; + int _overrun; + compat_sigval_t _sigval; + } _timer; + struct { + compat_pid_t _pid; + __compat_uid32_t _uid; + compat_sigval_t _sigval; + } _rt; + struct { + compat_pid_t _pid; + __compat_uid32_t _uid; + int _status; + compat_clock_t _utime; + compat_clock_t _stime; + } _sigchld; + struct { + compat_uptr_t _addr; + union { + short int _addr_lsb; + struct { + char _dummy_bnd[4]; + compat_uptr_t _lower; + compat_uptr_t _upper; + } _addr_bnd; + struct { + char _dummy_pkey[4]; + u32 _pkey; + } _addr_pkey; + }; + } _sigfault; + struct { + compat_long_t _band; + int _fd; + } _sigpoll; + struct { + compat_uptr_t _call_addr; + int _syscall; + unsigned int _arch; + } _sigsys; + } _sifields; }; -struct bts_phys { - struct page *page; - long unsigned int size; - long unsigned int offset; - long unsigned int displacement; -}; +typedef struct compat_siginfo compat_siginfo_t; -struct bts_buffer { - size_t real_size; - unsigned int nr_pages; - unsigned int nr_bufs; - unsigned int cur_buf; - bool snapshot; - local_t data_size; - local_t head; - long unsigned int end; - void **data_pages; - struct bts_phys buf[0]; +enum bug_trap_type { + BUG_TRAP_TYPE_NONE = 0, + BUG_TRAP_TYPE_WARN = 1, + BUG_TRAP_TYPE_BUG = 2, }; -struct entry_stack { - long unsigned int words[64]; +struct mpx_bndcsr { + u64 bndcfgu; + u64 bndstatus; }; -struct entry_stack_page { - struct entry_stack stack; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +enum die_val { + DIE_OOPS = 1, + DIE_INT3 = 2, + DIE_DEBUG = 3, + DIE_PANIC = 4, + DIE_NMI = 5, + DIE_DIE = 6, + DIE_KERNELDEBUG = 7, + DIE_TRAP = 8, + DIE_GPF = 9, + DIE_CALL = 10, + DIE_PAGE_FAULT = 11, + DIE_NMIUNKNOWN = 12, +}; + +struct mpx_fault_info { + void *addr; + void *lower; + void *upper; +}; + +struct bad_iret_stack { + void *error_entry_ret; + struct pt_regs regs; +}; + +enum { + GATE_INTERRUPT = 14, + GATE_TRAP = 15, + GATE_CALL = 12, + GATE_TASK = 5, +}; + +struct irq_desc; + +typedef struct irq_desc *vector_irq_t[256]; + +struct idt_data { + unsigned int vector; + unsigned int segment; + struct idt_bits bits; + const void *addr; +}; + +enum irqreturn { + IRQ_NONE = 0, + IRQ_HANDLED = 1, + IRQ_WAKE_THREAD = 2, +}; + +typedef enum irqreturn irqreturn_t; + +typedef irqreturn_t (*irq_handler_t)(int, void *); + +struct irqaction { + irq_handler_t handler; + void *dev_id; + void *percpu_dev_id; + struct irqaction *next; + irq_handler_t thread_fn; + struct task_struct *thread; + struct irqaction *secondary; + unsigned int irq; + unsigned int flags; + long unsigned int thread_flags; + long unsigned int thread_mask; + const char *name; + struct proc_dir_entry *dir; long: 64; long: 64; long: 64; long: 64; +}; + +struct irq_affinity_notify { + unsigned int irq; + struct kref kref; + struct work_struct work; + void (*notify)(struct irq_affinity_notify *, const cpumask_t *); + void (*release)(struct kref *); +}; + +enum irqchip_irq_state { + IRQCHIP_STATE_PENDING = 0, + IRQCHIP_STATE_ACTIVE = 1, + IRQCHIP_STATE_MASKED = 2, + IRQCHIP_STATE_LINE_LEVEL = 3, +}; + +struct irq_desc___2; + +typedef void (*irq_flow_handler_t)(struct irq_desc___2 *); + +struct msi_desc; + +struct irq_common_data { + unsigned int state_use_accessors; + unsigned int node; + void *handler_data; + struct msi_desc *msi_desc; + cpumask_var_t affinity; + cpumask_var_t effective_affinity; +}; + +struct irq_chip; + +struct irq_data { + u32 mask; + unsigned int irq; + long unsigned int hwirq; + struct irq_common_data *common; + struct irq_chip *chip; + struct irq_domain *domain; + struct irq_data *parent_data; + void *chip_data; +}; + +struct irq_desc___2 { + struct irq_common_data irq_common_data; + struct irq_data irq_data; + unsigned int *kstat_irqs; + irq_flow_handler_t handle_irq; + struct irqaction *action; + unsigned int status_use_accessors; + unsigned int core_internal_state__do_not_mess_with_it; + unsigned int depth; + unsigned int wake_depth; + unsigned int tot_count; + unsigned int irq_count; + long unsigned int last_unhandled; + unsigned int irqs_unhandled; + atomic_t threads_handled; + int threads_handled_last; + raw_spinlock_t lock; + struct cpumask *percpu_enabled; + const struct cpumask *percpu_affinity; + const struct cpumask *affinity_hint; + struct irq_affinity_notify *affinity_notify; + cpumask_var_t pending_mask; + long unsigned int threads_oneshot; + atomic_t threads_active; + wait_queue_head_t wait_for_threads; + unsigned int nr_actions; + unsigned int no_suspend_depth; + unsigned int cond_suspend_depth; + unsigned int force_resume_depth; + struct proc_dir_entry *dir; + struct callback_head rcu; + struct kobject kobj; + struct mutex request_mutex; + int parent_irq; + struct module *owner; + const char *name; long: 64; long: 64; long: 64; long: 64; long: 64; +}; + +struct msi_msg; + +struct irq_chip { + struct device *parent_device; + const char *name; + unsigned int (*irq_startup)(struct irq_data *); + void (*irq_shutdown)(struct irq_data *); + void (*irq_enable)(struct irq_data *); + void (*irq_disable)(struct irq_data *); + void (*irq_ack)(struct irq_data *); + void (*irq_mask)(struct irq_data *); + void (*irq_mask_ack)(struct irq_data *); + void (*irq_unmask)(struct irq_data *); + void (*irq_eoi)(struct irq_data *); + int (*irq_set_affinity)(struct irq_data *, const struct cpumask *, bool); + int (*irq_retrigger)(struct irq_data *); + int (*irq_set_type)(struct irq_data *, unsigned int); + int (*irq_set_wake)(struct irq_data *, unsigned int); + void (*irq_bus_lock)(struct irq_data *); + void (*irq_bus_sync_unlock)(struct irq_data *); + void (*irq_cpu_online)(struct irq_data *); + void (*irq_cpu_offline)(struct irq_data *); + void (*irq_suspend)(struct irq_data *); + void (*irq_resume)(struct irq_data *); + void (*irq_pm_shutdown)(struct irq_data *); + void (*irq_calc_mask)(struct irq_data *); + void (*irq_print_chip)(struct irq_data *, struct seq_file *); + int (*irq_request_resources)(struct irq_data *); + void (*irq_release_resources)(struct irq_data *); + void (*irq_compose_msi_msg)(struct irq_data *, struct msi_msg *); + void (*irq_write_msi_msg)(struct irq_data *, struct msi_msg *); + int (*irq_get_irqchip_state)(struct irq_data *, enum irqchip_irq_state, bool *); + int (*irq_set_irqchip_state)(struct irq_data *, enum irqchip_irq_state, bool); + int (*irq_set_vcpu_affinity)(struct irq_data *, void *); + void (*ipi_send_single)(struct irq_data *, unsigned int); + void (*ipi_send_mask)(struct irq_data *, const struct cpumask *); + int (*irq_nmi_setup)(struct irq_data *); + void (*irq_nmi_teardown)(struct irq_data *); + long unsigned int flags; +}; + +typedef struct irq_desc___2 *vector_irq_t___2[256]; + +struct trace_event_raw_x86_irq_vector { + struct trace_entry ent; + int vector; + char __data[0]; +}; + +struct trace_event_raw_vector_config { + struct trace_entry ent; + unsigned int irq; + unsigned int vector; + unsigned int cpu; + unsigned int apicdest; + char __data[0]; +}; + +struct trace_event_raw_vector_mod { + struct trace_entry ent; + unsigned int irq; + unsigned int vector; + unsigned int cpu; + unsigned int prev_vector; + unsigned int prev_cpu; + char __data[0]; +}; + +struct trace_event_raw_vector_reserve { + struct trace_entry ent; + unsigned int irq; + int ret; + char __data[0]; +}; + +struct trace_event_raw_vector_alloc { + struct trace_entry ent; + unsigned int irq; + unsigned int vector; + bool reserved; + int ret; + char __data[0]; +}; + +struct trace_event_raw_vector_alloc_managed { + struct trace_entry ent; + unsigned int irq; + unsigned int vector; + int ret; + char __data[0]; +}; + +struct trace_event_raw_vector_activate { + struct trace_entry ent; + unsigned int irq; + bool is_managed; + bool can_reserve; + bool reserve; + char __data[0]; +}; + +struct trace_event_raw_vector_teardown { + struct trace_entry ent; + unsigned int irq; + bool is_managed; + bool has_reserved; + char __data[0]; +}; + +struct trace_event_raw_vector_setup { + struct trace_entry ent; + unsigned int irq; + bool is_legacy; + int ret; + char __data[0]; +}; + +struct trace_event_raw_vector_free_moved { + struct trace_entry ent; + unsigned int irq; + unsigned int cpu; + unsigned int vector; + bool is_managed; + char __data[0]; +}; + +struct trace_event_data_offsets_x86_irq_vector {}; + +struct trace_event_data_offsets_vector_config {}; + +struct trace_event_data_offsets_vector_mod {}; + +struct trace_event_data_offsets_vector_reserve {}; + +struct trace_event_data_offsets_vector_alloc {}; + +struct trace_event_data_offsets_vector_alloc_managed {}; + +struct trace_event_data_offsets_vector_activate {}; + +struct trace_event_data_offsets_vector_teardown {}; + +struct trace_event_data_offsets_vector_setup {}; + +struct trace_event_data_offsets_vector_free_moved {}; + +typedef void (*btf_trace_local_timer_entry)(void *, int); + +typedef void (*btf_trace_local_timer_exit)(void *, int); + +typedef void (*btf_trace_spurious_apic_entry)(void *, int); + +typedef void (*btf_trace_spurious_apic_exit)(void *, int); + +typedef void (*btf_trace_error_apic_entry)(void *, int); + +typedef void (*btf_trace_error_apic_exit)(void *, int); + +typedef void (*btf_trace_x86_platform_ipi_entry)(void *, int); + +typedef void (*btf_trace_x86_platform_ipi_exit)(void *, int); + +typedef void (*btf_trace_irq_work_entry)(void *, int); + +typedef void (*btf_trace_irq_work_exit)(void *, int); + +typedef void (*btf_trace_reschedule_entry)(void *, int); + +typedef void (*btf_trace_reschedule_exit)(void *, int); + +typedef void (*btf_trace_call_function_entry)(void *, int); + +typedef void (*btf_trace_call_function_exit)(void *, int); + +typedef void (*btf_trace_call_function_single_entry)(void *, int); + +typedef void (*btf_trace_call_function_single_exit)(void *, int); + +typedef void (*btf_trace_threshold_apic_entry)(void *, int); + +typedef void (*btf_trace_threshold_apic_exit)(void *, int); + +typedef void (*btf_trace_deferred_error_apic_entry)(void *, int); + +typedef void (*btf_trace_deferred_error_apic_exit)(void *, int); + +typedef void (*btf_trace_thermal_apic_entry)(void *, int); + +typedef void (*btf_trace_thermal_apic_exit)(void *, int); + +typedef void (*btf_trace_vector_config)(void *, unsigned int, unsigned int, unsigned int, unsigned int); + +typedef void (*btf_trace_vector_update)(void *, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int); + +typedef void (*btf_trace_vector_clear)(void *, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int); + +typedef void (*btf_trace_vector_reserve_managed)(void *, unsigned int, int); + +typedef void (*btf_trace_vector_reserve)(void *, unsigned int, int); + +typedef void (*btf_trace_vector_alloc)(void *, unsigned int, unsigned int, bool, int); + +typedef void (*btf_trace_vector_alloc_managed)(void *, unsigned int, unsigned int, int); + +typedef void (*btf_trace_vector_activate)(void *, unsigned int, bool, bool, bool); + +typedef void (*btf_trace_vector_deactivate)(void *, unsigned int, bool, bool, bool); + +typedef void (*btf_trace_vector_teardown)(void *, unsigned int, bool, bool); + +typedef void (*btf_trace_vector_setup)(void *, unsigned int, bool, int); + +typedef void (*btf_trace_vector_free_moved)(void *, unsigned int, unsigned int, unsigned int, bool); + +typedef struct irq_desc___2 *pto_T_____5; + +typedef struct pt_regs *pto_T_____6; + +struct estack_pages { + u32 offs; + u16 size; + u16 type; +}; + +struct arch_clocksource_data { + int vclock_mode; +}; + +struct clocksource { + u64 (*read)(struct clocksource *); + u64 mask; + u32 mult; + u32 shift; + u64 max_idle_ns; + u32 maxadj; + struct arch_clocksource_data archdata; + u64 max_cycles; + const char *name; + struct list_head list; + int rating; + int (*enable)(struct clocksource *); + void (*disable)(struct clocksource *); + long unsigned int flags; + void (*suspend)(struct clocksource *); + void (*resume)(struct clocksource *); + void (*mark_unstable)(struct clocksource *); + void (*tick_stable)(struct clocksource *); + struct list_head wd_list; + u64 cs_last; + u64 wd_last; + struct module *owner; +}; + +enum clock_event_state { + CLOCK_EVT_STATE_DETACHED = 0, + CLOCK_EVT_STATE_SHUTDOWN = 1, + CLOCK_EVT_STATE_PERIODIC = 2, + CLOCK_EVT_STATE_ONESHOT = 3, + CLOCK_EVT_STATE_ONESHOT_STOPPED = 4, +}; + +struct clock_event_device { + void (*event_handler)(struct clock_event_device *); + int (*set_next_event)(long unsigned int, struct clock_event_device *); + int (*set_next_ktime)(ktime_t, struct clock_event_device *); + ktime_t next_event; + u64 max_delta_ns; + u64 min_delta_ns; + u32 mult; + u32 shift; + enum clock_event_state state_use_accessors; + unsigned int features; + long unsigned int retries; + int (*set_state_periodic)(struct clock_event_device *); + int (*set_state_oneshot)(struct clock_event_device *); + int (*set_state_oneshot_stopped)(struct clock_event_device *); + int (*set_state_shutdown)(struct clock_event_device *); + int (*tick_resume)(struct clock_event_device *); + void (*broadcast)(const struct cpumask *); + void (*suspend)(struct clock_event_device *); + void (*resume)(struct clock_event_device *); + long unsigned int min_delta_ticks; + long unsigned int max_delta_ticks; + const char *name; + int rating; + int irq; + int bound_on; + const struct cpumask *cpumask; + struct list_head list; + struct module *owner; long: 64; long: 64; long: 64; @@ -17281,7119 +21101,7600 @@ struct entry_stack_page { long: 64; }; -struct debug_store_buffers { - char bts_buffer[65536]; - char pebs_buffer[65536]; +struct irq_affinity_desc { + struct cpumask mask; + unsigned int is_managed: 1; }; -struct cea_exception_stacks { - char DF_stack_guard[4096]; - char DF_stack[4096]; - char NMI_stack_guard[4096]; - char NMI_stack[4096]; - char DB2_stack_guard[4096]; - char DB2_stack[4096]; - char DB1_stack_guard[4096]; - char DB1_stack[4096]; - char DB_stack_guard[4096]; - char DB_stack[4096]; - char MCE_stack_guard[4096]; - char MCE_stack[4096]; - char IST_top_guard[4096]; +struct msi_msg { + u32 address_lo; + u32 address_hi; + u32 data; +}; + +struct platform_msi_priv_data; + +struct platform_msi_desc { + struct platform_msi_priv_data *msi_priv_data; + u16 msi_index; +}; + +struct fsl_mc_msi_desc { + u16 msi_index; +}; + +struct ti_sci_inta_msi_desc { + u16 dev_index; +}; + +struct msi_desc { + struct list_head list; + unsigned int irq; + unsigned int nvec_used; + struct device *dev; + struct msi_msg msg; + struct irq_affinity_desc *affinity; + const void *iommu_cookie; + void (*write_msi_msg)(struct msi_desc *, void *); + void *write_msi_msg_data; + union { + struct { + u32 masked; + struct { + u8 is_msix: 1; + u8 multiple: 3; + u8 multi_cap: 3; + u8 maskbit: 1; + u8 is_64: 1; + u8 is_virtual: 1; + u16 entry_nr; + unsigned int default_irq; + } msi_attrib; + union { + u8 mask_pos; + void *mask_base; + }; + }; + struct platform_msi_desc platform; + struct fsl_mc_msi_desc fsl_mc; + struct ti_sci_inta_msi_desc inta; + }; +}; + +struct irq_chip_regs { + long unsigned int enable; + long unsigned int disable; + long unsigned int mask; + long unsigned int ack; + long unsigned int eoi; + long unsigned int type; + long unsigned int polarity; +}; + +struct irq_chip_type { + struct irq_chip chip; + struct irq_chip_regs regs; + irq_flow_handler_t handler; + u32 type; + u32 mask_cache_priv; + u32 *mask_cache; +}; + +struct irq_chip_generic { + raw_spinlock_t lock; + void *reg_base; + u32 (*reg_readl)(void *); + void (*reg_writel)(u32, void *); + void (*suspend)(struct irq_chip_generic *); + void (*resume)(struct irq_chip_generic *); + unsigned int irq_base; + unsigned int irq_cnt; + u32 mask_cache; + u32 type_cache; + u32 polarity_cache; + u32 wake_enabled; + u32 wake_active; + unsigned int num_ct; + void *private; + long unsigned int installed; + long unsigned int unused; + struct irq_domain *domain; + struct list_head list; + struct irq_chip_type chip_types[0]; +}; + +enum irq_gc_flags { + IRQ_GC_INIT_MASK_CACHE = 1, + IRQ_GC_INIT_NESTED_LOCK = 2, + IRQ_GC_MASK_CACHE_PER_TYPE = 4, + IRQ_GC_NO_MASK = 8, + IRQ_GC_BE_IO = 16, }; -struct cpu_entry_area { - char gdt[4096]; - struct entry_stack_page entry_stack_page; - struct tss_struct tss; - struct cea_exception_stacks estacks; - struct debug_store cpu_debug_store; - struct debug_store_buffers cpu_debug_buffers; +struct irq_domain_chip_generic { + unsigned int irqs_per_chip; + unsigned int num_chips; + unsigned int irq_flags_to_clear; + unsigned int irq_flags_to_set; + enum irq_gc_flags gc_flags; + struct irq_chip_generic *gc[0]; }; -struct pebs_basic { - u64 format_size; - u64 ip; - u64 applicable_counters; - u64 tsc; +struct legacy_pic { + int nr_legacy_irqs; + struct irq_chip *chip; + void (*mask)(unsigned int); + void (*unmask)(unsigned int); + void (*mask_all)(); + void (*restore_mask)(); + void (*init)(int); + int (*probe)(); + int (*irq_pending)(unsigned int); + void (*make_irq)(unsigned int); }; -struct pebs_meminfo { - u64 address; - u64 aux; - u64 latency; - u64 tsx_tuning; +enum refcount_saturation_type { + REFCOUNT_ADD_NOT_ZERO_OVF = 0, + REFCOUNT_ADD_OVF = 1, + REFCOUNT_ADD_UAF = 2, + REFCOUNT_SUB_UAF = 3, + REFCOUNT_DEC_LEAK = 4, }; -struct pebs_gprs { - u64 flags; - u64 ip; - u64 ax; - u64 cx; - u64 dx; - u64 bx; - u64 sp; - u64 bp; - u64 si; - u64 di; - u64 r8; - u64 r9; - u64 r10; - u64 r11; - u64 r12; - u64 r13; - u64 r14; - u64 r15; +enum lockdown_reason { + LOCKDOWN_NONE = 0, + LOCKDOWN_MODULE_SIGNATURE = 1, + LOCKDOWN_DEV_MEM = 2, + LOCKDOWN_EFI_TEST = 3, + LOCKDOWN_KEXEC = 4, + LOCKDOWN_HIBERNATION = 5, + LOCKDOWN_PCI_ACCESS = 6, + LOCKDOWN_IOPORT = 7, + LOCKDOWN_MSR = 8, + LOCKDOWN_ACPI_TABLES = 9, + LOCKDOWN_PCMCIA_CIS = 10, + LOCKDOWN_TIOCSSERIAL = 11, + LOCKDOWN_MODULE_PARAMETERS = 12, + LOCKDOWN_MMIOTRACE = 13, + LOCKDOWN_DEBUGFS = 14, + LOCKDOWN_XMON_WR = 15, + LOCKDOWN_INTEGRITY_MAX = 16, + LOCKDOWN_KCORE = 17, + LOCKDOWN_KPROBES = 18, + LOCKDOWN_BPF_READ = 19, + LOCKDOWN_PERF = 20, + LOCKDOWN_TRACEFS = 21, + LOCKDOWN_XMON_RW = 22, + LOCKDOWN_CONFIDENTIALITY_MAX = 23, }; -struct pebs_xmm { - u64 xmm[32]; +enum lockdep_ok { + LOCKDEP_STILL_OK = 0, + LOCKDEP_NOW_UNRELIABLE = 1, }; -struct pebs_lbr_entry { - u64 from; - u64 to; - u64 info; -}; +typedef long unsigned int uintptr_t; -struct pebs_lbr { - struct pebs_lbr_entry lbr[0]; +struct machine_ops { + void (*restart)(char *); + void (*halt)(); + void (*power_off)(); + void (*shutdown)(); + void (*crash_shutdown)(struct pt_regs *); + void (*emergency_restart)(); }; -struct x86_perf_regs { - struct pt_regs regs; - u64 *xmm_regs; +struct trace_event_raw_nmi_handler { + struct trace_entry ent; + void *handler; + s64 delta_ns; + int handled; + char __data[0]; }; -typedef unsigned int insn_attr_t; +struct trace_event_data_offsets_nmi_handler {}; -typedef unsigned char insn_byte_t; +typedef void (*btf_trace_nmi_handler)(void *, void *, s64, int); -typedef int insn_value_t; +struct nmi_desc { + raw_spinlock_t lock; + struct list_head head; +}; -struct insn_field { - union { - insn_value_t value; - insn_byte_t bytes[4]; - }; - unsigned char got; - unsigned char nbytes; +struct nmi_stats { + unsigned int normal; + unsigned int unknown; + unsigned int external; + unsigned int swallow; }; -struct insn { - struct insn_field prefixes; - struct insn_field rex_prefix; - struct insn_field vex_prefix; - struct insn_field opcode; - struct insn_field modrm; - struct insn_field sib; - struct insn_field displacement; - union { - struct insn_field immediate; - struct insn_field moffset1; - struct insn_field immediate1; - }; - union { - struct insn_field moffset2; - struct insn_field immediate2; - }; - int emulate_prefix_size; - insn_attr_t attr; - unsigned char opnd_bytes; - unsigned char addr_bytes; - unsigned char length; - unsigned char x86_64; - const insn_byte_t *kaddr; - const insn_byte_t *end_kaddr; - const insn_byte_t *next_byte; +enum nmi_states { + NMI_NOT_RUNNING = 0, + NMI_EXECUTING = 1, + NMI_LATCHED = 2, }; +typedef enum nmi_states pto_T_____7; + +typedef bool pto_T_____8; + enum { - PERF_TXN_ELISION = 1, - PERF_TXN_TRANSACTION = 2, - PERF_TXN_SYNC = 4, - PERF_TXN_ASYNC = 8, - PERF_TXN_RETRY = 16, - PERF_TXN_CONFLICT = 32, - PERF_TXN_CAPACITY_WRITE = 64, - PERF_TXN_CAPACITY_READ = 128, - PERF_TXN_MAX = 256, - PERF_TXN_ABORT_MASK = 0, - PERF_TXN_ABORT_SHIFT = 32, + DESC_TSS = 9, + DESC_LDT = 2, + DESCTYPE_S = 16, }; -struct perf_event_header { - __u32 type; - __u16 misc; - __u16 size; +struct ldttss_desc { + u16 limit0; + u16 base0; + u16 base1: 8; + u16 type: 5; + u16 dpl: 2; + u16 p: 1; + u16 limit1: 4; + u16 zero0: 3; + u16 g: 1; + u16 base2: 8; + u32 base3; + u32 zero1; }; -union intel_x86_pebs_dse { - u64 val; - struct { - unsigned int ld_dse: 4; - unsigned int ld_stlb_miss: 1; - unsigned int ld_locked: 1; - unsigned int ld_reserved: 26; - }; - struct { - unsigned int st_l1d_hit: 1; - unsigned int st_reserved1: 3; - unsigned int st_stlb_miss: 1; - unsigned int st_locked: 1; - unsigned int st_reserved2: 26; - }; -}; +typedef struct ldttss_desc ldt_desc; -struct pebs_record_core { - u64 flags; - u64 ip; - u64 ax; - u64 bx; - u64 cx; - u64 dx; - u64 si; - u64 di; - u64 bp; - u64 sp; - u64 r8; - u64 r9; - u64 r10; - u64 r11; - u64 r12; - u64 r13; - u64 r14; - u64 r15; +struct user_desc { + unsigned int entry_number; + unsigned int base_addr; + unsigned int limit; + unsigned int seg_32bit: 1; + unsigned int contents: 2; + unsigned int read_exec_only: 1; + unsigned int limit_in_pages: 1; + unsigned int seg_not_present: 1; + unsigned int useable: 1; + unsigned int lm: 1; }; -struct pebs_record_nhm { - u64 flags; - u64 ip; - u64 ax; - u64 bx; - u64 cx; - u64 dx; - u64 si; - u64 di; - u64 bp; - u64 sp; - u64 r8; - u64 r9; - u64 r10; - u64 r11; - u64 r12; - u64 r13; - u64 r14; - u64 r15; - u64 status; - u64 dla; - u64 dse; - u64 lat; +struct mmu_gather_batch { + struct mmu_gather_batch *next; + unsigned int nr; + unsigned int max; + struct page *pages[0]; }; -union hsw_tsx_tuning { - struct { - u32 cycles_last_block: 32; - u32 hle_abort: 1; - u32 rtm_abort: 1; - u32 instruction_abort: 1; - u32 non_instruction_abort: 1; - u32 retry: 1; - u32 data_conflict: 1; - u32 capacity_writes: 1; - u32 capacity_reads: 1; - }; - u64 value; +struct mmu_gather { + struct mm_struct *mm; + long unsigned int start; + long unsigned int end; + unsigned int fullmm: 1; + unsigned int need_flush_all: 1; + unsigned int freed_tables: 1; + unsigned int cleared_ptes: 1; + unsigned int cleared_pmds: 1; + unsigned int cleared_puds: 1; + unsigned int cleared_p4ds: 1; + unsigned int vma_exec: 1; + unsigned int vma_huge: 1; + unsigned int batch_count; + struct mmu_gather_batch *active; + struct mmu_gather_batch local; + struct page *__pages[8]; }; -struct pebs_record_skl { - u64 flags; - u64 ip; - u64 ax; - u64 bx; - u64 cx; - u64 dx; - u64 si; - u64 di; - u64 bp; - u64 sp; - u64 r8; - u64 r9; - u64 r10; - u64 r11; - u64 r12; - u64 r13; - u64 r14; - u64 r15; - u64 status; - u64 dla; - u64 dse; - u64 lat; - u64 real_ip; - u64 tsx_tuning; - u64 tsc; +struct setup_data { + __u64 next; + __u32 type; + __u32 len; + __u8 data[0]; }; -struct bts_record { - u64 from; - u64 to; - u64 flags; +struct setup_indirect { + __u32 type; + __u32 reserved; + __u64 len; + __u64 addr; }; -enum { - PERF_BR_UNKNOWN = 0, - PERF_BR_COND = 1, - PERF_BR_UNCOND = 2, - PERF_BR_IND = 3, - PERF_BR_CALL = 4, - PERF_BR_IND_CALL = 5, - PERF_BR_RET = 6, - PERF_BR_SYSCALL = 7, - PERF_BR_SYSRET = 8, - PERF_BR_COND_CALL = 9, - PERF_BR_COND_RET = 10, - PERF_BR_MAX = 11, +struct plist_head { + struct list_head node_list; }; -enum { - LBR_FORMAT_32 = 0, - LBR_FORMAT_LIP = 1, - LBR_FORMAT_EIP = 2, - LBR_FORMAT_EIP_FLAGS = 3, - LBR_FORMAT_EIP_FLAGS2 = 4, - LBR_FORMAT_INFO = 5, - LBR_FORMAT_TIME = 6, - LBR_FORMAT_MAX_KNOWN = 6, +enum pm_qos_type { + PM_QOS_UNITIALIZED = 0, + PM_QOS_MAX = 1, + PM_QOS_MIN = 2, + PM_QOS_SUM = 3, }; -enum { - X86_BR_NONE = 0, - X86_BR_USER = 1, - X86_BR_KERNEL = 2, - X86_BR_CALL = 4, - X86_BR_RET = 8, - X86_BR_SYSCALL = 16, - X86_BR_SYSRET = 32, - X86_BR_INT = 64, - X86_BR_IRET = 128, - X86_BR_JCC = 256, - X86_BR_JMP = 512, - X86_BR_IRQ = 1024, - X86_BR_IND_CALL = 2048, - X86_BR_ABORT = 4096, - X86_BR_IN_TX = 8192, - X86_BR_NO_TX = 16384, - X86_BR_ZERO_CALL = 32768, - X86_BR_CALL_STACK = 65536, - X86_BR_IND_JMP = 131072, - X86_BR_TYPE_SAVE = 262144, +struct pm_qos_constraints { + struct plist_head list; + s32 target_value; + s32 default_value; + s32 no_constraint_value; + enum pm_qos_type type; + struct blocking_notifier_head *notifiers; }; -enum { - LBR_NONE = 0, - LBR_VALID = 1, +struct freq_constraints { + struct pm_qos_constraints min_freq; + struct blocking_notifier_head min_freq_notifiers; + struct pm_qos_constraints max_freq; + struct blocking_notifier_head max_freq_notifiers; }; -enum P4_EVENTS { - P4_EVENT_TC_DELIVER_MODE = 0, - P4_EVENT_BPU_FETCH_REQUEST = 1, - P4_EVENT_ITLB_REFERENCE = 2, - P4_EVENT_MEMORY_CANCEL = 3, - P4_EVENT_MEMORY_COMPLETE = 4, - P4_EVENT_LOAD_PORT_REPLAY = 5, - P4_EVENT_STORE_PORT_REPLAY = 6, - P4_EVENT_MOB_LOAD_REPLAY = 7, - P4_EVENT_PAGE_WALK_TYPE = 8, - P4_EVENT_BSQ_CACHE_REFERENCE = 9, - P4_EVENT_IOQ_ALLOCATION = 10, - P4_EVENT_IOQ_ACTIVE_ENTRIES = 11, - P4_EVENT_FSB_DATA_ACTIVITY = 12, - P4_EVENT_BSQ_ALLOCATION = 13, - P4_EVENT_BSQ_ACTIVE_ENTRIES = 14, - P4_EVENT_SSE_INPUT_ASSIST = 15, - P4_EVENT_PACKED_SP_UOP = 16, - P4_EVENT_PACKED_DP_UOP = 17, - P4_EVENT_SCALAR_SP_UOP = 18, - P4_EVENT_SCALAR_DP_UOP = 19, - P4_EVENT_64BIT_MMX_UOP = 20, - P4_EVENT_128BIT_MMX_UOP = 21, - P4_EVENT_X87_FP_UOP = 22, - P4_EVENT_TC_MISC = 23, - P4_EVENT_GLOBAL_POWER_EVENTS = 24, - P4_EVENT_TC_MS_XFER = 25, - P4_EVENT_UOP_QUEUE_WRITES = 26, - P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE = 27, - P4_EVENT_RETIRED_BRANCH_TYPE = 28, - P4_EVENT_RESOURCE_STALL = 29, - P4_EVENT_WC_BUFFER = 30, - P4_EVENT_B2B_CYCLES = 31, - P4_EVENT_BNR = 32, - P4_EVENT_SNOOP = 33, - P4_EVENT_RESPONSE = 34, - P4_EVENT_FRONT_END_EVENT = 35, - P4_EVENT_EXECUTION_EVENT = 36, - P4_EVENT_REPLAY_EVENT = 37, - P4_EVENT_INSTR_RETIRED = 38, - P4_EVENT_UOPS_RETIRED = 39, - P4_EVENT_UOP_TYPE = 40, - P4_EVENT_BRANCH_RETIRED = 41, - P4_EVENT_MISPRED_BRANCH_RETIRED = 42, - P4_EVENT_X87_ASSIST = 43, - P4_EVENT_MACHINE_CLEAR = 44, - P4_EVENT_INSTR_COMPLETED = 45, +struct pm_qos_flags { + struct list_head list; + s32 effective_flags; }; -enum P4_EVENT_OPCODES { - P4_EVENT_TC_DELIVER_MODE_OPCODE = 257, - P4_EVENT_BPU_FETCH_REQUEST_OPCODE = 768, - P4_EVENT_ITLB_REFERENCE_OPCODE = 6147, - P4_EVENT_MEMORY_CANCEL_OPCODE = 517, - P4_EVENT_MEMORY_COMPLETE_OPCODE = 2050, - P4_EVENT_LOAD_PORT_REPLAY_OPCODE = 1026, - P4_EVENT_STORE_PORT_REPLAY_OPCODE = 1282, - P4_EVENT_MOB_LOAD_REPLAY_OPCODE = 770, - P4_EVENT_PAGE_WALK_TYPE_OPCODE = 260, - P4_EVENT_BSQ_CACHE_REFERENCE_OPCODE = 3079, - P4_EVENT_IOQ_ALLOCATION_OPCODE = 774, - P4_EVENT_IOQ_ACTIVE_ENTRIES_OPCODE = 6662, - P4_EVENT_FSB_DATA_ACTIVITY_OPCODE = 5894, - P4_EVENT_BSQ_ALLOCATION_OPCODE = 1287, - P4_EVENT_BSQ_ACTIVE_ENTRIES_OPCODE = 1543, - P4_EVENT_SSE_INPUT_ASSIST_OPCODE = 13313, - P4_EVENT_PACKED_SP_UOP_OPCODE = 2049, - P4_EVENT_PACKED_DP_UOP_OPCODE = 3073, - P4_EVENT_SCALAR_SP_UOP_OPCODE = 2561, - P4_EVENT_SCALAR_DP_UOP_OPCODE = 3585, - P4_EVENT_64BIT_MMX_UOP_OPCODE = 513, - P4_EVENT_128BIT_MMX_UOP_OPCODE = 6657, - P4_EVENT_X87_FP_UOP_OPCODE = 1025, - P4_EVENT_TC_MISC_OPCODE = 1537, - P4_EVENT_GLOBAL_POWER_EVENTS_OPCODE = 4870, - P4_EVENT_TC_MS_XFER_OPCODE = 1280, - P4_EVENT_UOP_QUEUE_WRITES_OPCODE = 2304, - P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE_OPCODE = 1282, - P4_EVENT_RETIRED_BRANCH_TYPE_OPCODE = 1026, - P4_EVENT_RESOURCE_STALL_OPCODE = 257, - P4_EVENT_WC_BUFFER_OPCODE = 1285, - P4_EVENT_B2B_CYCLES_OPCODE = 5635, - P4_EVENT_BNR_OPCODE = 2051, - P4_EVENT_SNOOP_OPCODE = 1539, - P4_EVENT_RESPONSE_OPCODE = 1027, - P4_EVENT_FRONT_END_EVENT_OPCODE = 2053, - P4_EVENT_EXECUTION_EVENT_OPCODE = 3077, - P4_EVENT_REPLAY_EVENT_OPCODE = 2309, - P4_EVENT_INSTR_RETIRED_OPCODE = 516, - P4_EVENT_UOPS_RETIRED_OPCODE = 260, - P4_EVENT_UOP_TYPE_OPCODE = 514, - P4_EVENT_BRANCH_RETIRED_OPCODE = 1541, - P4_EVENT_MISPRED_BRANCH_RETIRED_OPCODE = 772, - P4_EVENT_X87_ASSIST_OPCODE = 773, - P4_EVENT_MACHINE_CLEAR_OPCODE = 517, - P4_EVENT_INSTR_COMPLETED_OPCODE = 1796, +struct dev_pm_qos_request; + +struct dev_pm_qos { + struct pm_qos_constraints resume_latency; + struct pm_qos_constraints latency_tolerance; + struct freq_constraints freq; + struct pm_qos_flags flags; + struct dev_pm_qos_request *resume_latency_req; + struct dev_pm_qos_request *latency_tolerance_req; + struct dev_pm_qos_request *flags_req; }; -enum P4_ESCR_EMASKS { - P4_EVENT_TC_DELIVER_MODE__DD = 512, - P4_EVENT_TC_DELIVER_MODE__DB = 1024, - P4_EVENT_TC_DELIVER_MODE__DI = 2048, - P4_EVENT_TC_DELIVER_MODE__BD = 4096, - P4_EVENT_TC_DELIVER_MODE__BB = 8192, - P4_EVENT_TC_DELIVER_MODE__BI = 16384, - P4_EVENT_TC_DELIVER_MODE__ID = 32768, - P4_EVENT_BPU_FETCH_REQUEST__TCMISS = 512, - P4_EVENT_ITLB_REFERENCE__HIT = 512, - P4_EVENT_ITLB_REFERENCE__MISS = 1024, - P4_EVENT_ITLB_REFERENCE__HIT_UK = 2048, - P4_EVENT_MEMORY_CANCEL__ST_RB_FULL = 2048, - P4_EVENT_MEMORY_CANCEL__64K_CONF = 4096, - P4_EVENT_MEMORY_COMPLETE__LSC = 512, - P4_EVENT_MEMORY_COMPLETE__SSC = 1024, - P4_EVENT_LOAD_PORT_REPLAY__SPLIT_LD = 1024, - P4_EVENT_STORE_PORT_REPLAY__SPLIT_ST = 1024, - P4_EVENT_MOB_LOAD_REPLAY__NO_STA = 1024, - P4_EVENT_MOB_LOAD_REPLAY__NO_STD = 4096, - P4_EVENT_MOB_LOAD_REPLAY__PARTIAL_DATA = 8192, - P4_EVENT_MOB_LOAD_REPLAY__UNALGN_ADDR = 16384, - P4_EVENT_PAGE_WALK_TYPE__DTMISS = 512, - P4_EVENT_PAGE_WALK_TYPE__ITMISS = 1024, - P4_EVENT_BSQ_CACHE_REFERENCE__RD_2ndL_HITS = 512, - P4_EVENT_BSQ_CACHE_REFERENCE__RD_2ndL_HITE = 1024, - P4_EVENT_BSQ_CACHE_REFERENCE__RD_2ndL_HITM = 2048, - P4_EVENT_BSQ_CACHE_REFERENCE__RD_3rdL_HITS = 4096, - P4_EVENT_BSQ_CACHE_REFERENCE__RD_3rdL_HITE = 8192, - P4_EVENT_BSQ_CACHE_REFERENCE__RD_3rdL_HITM = 16384, - P4_EVENT_BSQ_CACHE_REFERENCE__RD_2ndL_MISS = 131072, - P4_EVENT_BSQ_CACHE_REFERENCE__RD_3rdL_MISS = 262144, - P4_EVENT_BSQ_CACHE_REFERENCE__WR_2ndL_MISS = 524288, - P4_EVENT_IOQ_ALLOCATION__DEFAULT = 512, - P4_EVENT_IOQ_ALLOCATION__ALL_READ = 16384, - P4_EVENT_IOQ_ALLOCATION__ALL_WRITE = 32768, - P4_EVENT_IOQ_ALLOCATION__MEM_UC = 65536, - P4_EVENT_IOQ_ALLOCATION__MEM_WC = 131072, - P4_EVENT_IOQ_ALLOCATION__MEM_WT = 262144, - P4_EVENT_IOQ_ALLOCATION__MEM_WP = 524288, - P4_EVENT_IOQ_ALLOCATION__MEM_WB = 1048576, - P4_EVENT_IOQ_ALLOCATION__OWN = 4194304, - P4_EVENT_IOQ_ALLOCATION__OTHER = 8388608, - P4_EVENT_IOQ_ALLOCATION__PREFETCH = 16777216, - P4_EVENT_IOQ_ACTIVE_ENTRIES__DEFAULT = 512, - P4_EVENT_IOQ_ACTIVE_ENTRIES__ALL_READ = 16384, - P4_EVENT_IOQ_ACTIVE_ENTRIES__ALL_WRITE = 32768, - P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_UC = 65536, - P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_WC = 131072, - P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_WT = 262144, - P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_WP = 524288, - P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_WB = 1048576, - P4_EVENT_IOQ_ACTIVE_ENTRIES__OWN = 4194304, - P4_EVENT_IOQ_ACTIVE_ENTRIES__OTHER = 8388608, - P4_EVENT_IOQ_ACTIVE_ENTRIES__PREFETCH = 16777216, - P4_EVENT_FSB_DATA_ACTIVITY__DRDY_DRV = 512, - P4_EVENT_FSB_DATA_ACTIVITY__DRDY_OWN = 1024, - P4_EVENT_FSB_DATA_ACTIVITY__DRDY_OTHER = 2048, - P4_EVENT_FSB_DATA_ACTIVITY__DBSY_DRV = 4096, - P4_EVENT_FSB_DATA_ACTIVITY__DBSY_OWN = 8192, - P4_EVENT_FSB_DATA_ACTIVITY__DBSY_OTHER = 16384, - P4_EVENT_BSQ_ALLOCATION__REQ_TYPE0 = 512, - P4_EVENT_BSQ_ALLOCATION__REQ_TYPE1 = 1024, - P4_EVENT_BSQ_ALLOCATION__REQ_LEN0 = 2048, - P4_EVENT_BSQ_ALLOCATION__REQ_LEN1 = 4096, - P4_EVENT_BSQ_ALLOCATION__REQ_IO_TYPE = 16384, - P4_EVENT_BSQ_ALLOCATION__REQ_LOCK_TYPE = 32768, - P4_EVENT_BSQ_ALLOCATION__REQ_CACHE_TYPE = 65536, - P4_EVENT_BSQ_ALLOCATION__REQ_SPLIT_TYPE = 131072, - P4_EVENT_BSQ_ALLOCATION__REQ_DEM_TYPE = 262144, - P4_EVENT_BSQ_ALLOCATION__REQ_ORD_TYPE = 524288, - P4_EVENT_BSQ_ALLOCATION__MEM_TYPE0 = 1048576, - P4_EVENT_BSQ_ALLOCATION__MEM_TYPE1 = 2097152, - P4_EVENT_BSQ_ALLOCATION__MEM_TYPE2 = 4194304, - P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_TYPE0 = 512, - P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_TYPE1 = 1024, - P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_LEN0 = 2048, - P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_LEN1 = 4096, - P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_IO_TYPE = 16384, - P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_LOCK_TYPE = 32768, - P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_CACHE_TYPE = 65536, - P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_SPLIT_TYPE = 131072, - P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_DEM_TYPE = 262144, - P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_ORD_TYPE = 524288, - P4_EVENT_BSQ_ACTIVE_ENTRIES__MEM_TYPE0 = 1048576, - P4_EVENT_BSQ_ACTIVE_ENTRIES__MEM_TYPE1 = 2097152, - P4_EVENT_BSQ_ACTIVE_ENTRIES__MEM_TYPE2 = 4194304, - P4_EVENT_SSE_INPUT_ASSIST__ALL = 16777216, - P4_EVENT_PACKED_SP_UOP__ALL = 16777216, - P4_EVENT_PACKED_DP_UOP__ALL = 16777216, - P4_EVENT_SCALAR_SP_UOP__ALL = 16777216, - P4_EVENT_SCALAR_DP_UOP__ALL = 16777216, - P4_EVENT_64BIT_MMX_UOP__ALL = 16777216, - P4_EVENT_128BIT_MMX_UOP__ALL = 16777216, - P4_EVENT_X87_FP_UOP__ALL = 16777216, - P4_EVENT_TC_MISC__FLUSH = 8192, - P4_EVENT_GLOBAL_POWER_EVENTS__RUNNING = 512, - P4_EVENT_TC_MS_XFER__CISC = 512, - P4_EVENT_UOP_QUEUE_WRITES__FROM_TC_BUILD = 512, - P4_EVENT_UOP_QUEUE_WRITES__FROM_TC_DELIVER = 1024, - P4_EVENT_UOP_QUEUE_WRITES__FROM_ROM = 2048, - P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE__CONDITIONAL = 1024, - P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE__CALL = 2048, - P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE__RETURN = 4096, - P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE__INDIRECT = 8192, - P4_EVENT_RETIRED_BRANCH_TYPE__CONDITIONAL = 1024, - P4_EVENT_RETIRED_BRANCH_TYPE__CALL = 2048, - P4_EVENT_RETIRED_BRANCH_TYPE__RETURN = 4096, - P4_EVENT_RETIRED_BRANCH_TYPE__INDIRECT = 8192, - P4_EVENT_RESOURCE_STALL__SBFULL = 16384, - P4_EVENT_WC_BUFFER__WCB_EVICTS = 512, - P4_EVENT_WC_BUFFER__WCB_FULL_EVICTS = 1024, - P4_EVENT_FRONT_END_EVENT__NBOGUS = 512, - P4_EVENT_FRONT_END_EVENT__BOGUS = 1024, - P4_EVENT_EXECUTION_EVENT__NBOGUS0 = 512, - P4_EVENT_EXECUTION_EVENT__NBOGUS1 = 1024, - P4_EVENT_EXECUTION_EVENT__NBOGUS2 = 2048, - P4_EVENT_EXECUTION_EVENT__NBOGUS3 = 4096, - P4_EVENT_EXECUTION_EVENT__BOGUS0 = 8192, - P4_EVENT_EXECUTION_EVENT__BOGUS1 = 16384, - P4_EVENT_EXECUTION_EVENT__BOGUS2 = 32768, - P4_EVENT_EXECUTION_EVENT__BOGUS3 = 65536, - P4_EVENT_REPLAY_EVENT__NBOGUS = 512, - P4_EVENT_REPLAY_EVENT__BOGUS = 1024, - P4_EVENT_INSTR_RETIRED__NBOGUSNTAG = 512, - P4_EVENT_INSTR_RETIRED__NBOGUSTAG = 1024, - P4_EVENT_INSTR_RETIRED__BOGUSNTAG = 2048, - P4_EVENT_INSTR_RETIRED__BOGUSTAG = 4096, - P4_EVENT_UOPS_RETIRED__NBOGUS = 512, - P4_EVENT_UOPS_RETIRED__BOGUS = 1024, - P4_EVENT_UOP_TYPE__TAGLOADS = 1024, - P4_EVENT_UOP_TYPE__TAGSTORES = 2048, - P4_EVENT_BRANCH_RETIRED__MMNP = 512, - P4_EVENT_BRANCH_RETIRED__MMNM = 1024, - P4_EVENT_BRANCH_RETIRED__MMTP = 2048, - P4_EVENT_BRANCH_RETIRED__MMTM = 4096, - P4_EVENT_MISPRED_BRANCH_RETIRED__NBOGUS = 512, - P4_EVENT_X87_ASSIST__FPSU = 512, - P4_EVENT_X87_ASSIST__FPSO = 1024, - P4_EVENT_X87_ASSIST__POAO = 2048, - P4_EVENT_X87_ASSIST__POAU = 4096, - P4_EVENT_X87_ASSIST__PREA = 8192, - P4_EVENT_MACHINE_CLEAR__CLEAR = 512, - P4_EVENT_MACHINE_CLEAR__MOCLEAR = 1024, - P4_EVENT_MACHINE_CLEAR__SMCLEAR = 2048, - P4_EVENT_INSTR_COMPLETED__NBOGUS = 512, - P4_EVENT_INSTR_COMPLETED__BOGUS = 1024, +struct acpi_table_ibft { + struct acpi_table_header header; + u8 reserved[12]; }; -enum P4_PEBS_METRIC { - P4_PEBS_METRIC__none = 0, - P4_PEBS_METRIC__1stl_cache_load_miss_retired = 1, - P4_PEBS_METRIC__2ndl_cache_load_miss_retired = 2, - P4_PEBS_METRIC__dtlb_load_miss_retired = 3, - P4_PEBS_METRIC__dtlb_store_miss_retired = 4, - P4_PEBS_METRIC__dtlb_all_miss_retired = 5, - P4_PEBS_METRIC__tagged_mispred_branch = 6, - P4_PEBS_METRIC__mob_load_replay_retired = 7, - P4_PEBS_METRIC__split_load_retired = 8, - P4_PEBS_METRIC__split_store_retired = 9, - P4_PEBS_METRIC__max = 10, +enum efi_secureboot_mode { + efi_secureboot_mode_unset = 0, + efi_secureboot_mode_unknown = 1, + efi_secureboot_mode_disabled = 2, + efi_secureboot_mode_enabled = 3, }; -struct p4_event_bind { - unsigned int opcode; - unsigned int escr_msr[2]; - unsigned int escr_emask; - unsigned int shared; - char cntr[6]; +enum xen_domain_type { + XEN_NATIVE = 0, + XEN_PV_DOMAIN = 1, + XEN_HVM_DOMAIN = 2, }; -struct p4_pebs_bind { - unsigned int metric_pebs; - unsigned int metric_vert; +struct hvm_start_info { + uint32_t magic; + uint32_t version; + uint32_t flags; + uint32_t nr_modules; + uint64_t modlist_paddr; + uint64_t cmdline_paddr; + uint64_t rsdp_paddr; + uint64_t memmap_paddr; + uint32_t memmap_entries; + uint32_t reserved; }; -struct p4_event_alias { - u64 original; - u64 alternative; +struct pm_qos_flags_request { + struct list_head node; + s32 flags; }; -enum cpuid_regs_idx { - CPUID_EAX = 0, - CPUID_EBX = 1, - CPUID_ECX = 2, - CPUID_EDX = 3, +enum freq_qos_req_type { + FREQ_QOS_MIN = 1, + FREQ_QOS_MAX = 2, }; -struct dev_ext_attribute { - struct device_attribute attr; - void *var; +struct freq_qos_request { + enum freq_qos_req_type type; + struct plist_node pnode; + struct freq_constraints *qos; }; -enum pt_capabilities { - PT_CAP_max_subleaf = 0, - PT_CAP_cr3_filtering = 1, - PT_CAP_psb_cyc = 2, - PT_CAP_ip_filtering = 3, - PT_CAP_mtc = 4, - PT_CAP_ptwrite = 5, - PT_CAP_power_event_trace = 6, - PT_CAP_topa_output = 7, - PT_CAP_topa_multiple_entries = 8, - PT_CAP_single_range_output = 9, - PT_CAP_output_subsys = 10, - PT_CAP_payloads_lip = 11, - PT_CAP_num_address_ranges = 12, - PT_CAP_mtc_periods = 13, - PT_CAP_cycle_thresholds = 14, - PT_CAP_psb_periods = 15, +enum dev_pm_qos_req_type { + DEV_PM_QOS_RESUME_LATENCY = 1, + DEV_PM_QOS_LATENCY_TOLERANCE = 2, + DEV_PM_QOS_MIN_FREQUENCY = 3, + DEV_PM_QOS_MAX_FREQUENCY = 4, + DEV_PM_QOS_FLAGS = 5, }; -enum perf_addr_filter_action_t { - PERF_ADDR_FILTER_ACTION_STOP = 0, - PERF_ADDR_FILTER_ACTION_START = 1, - PERF_ADDR_FILTER_ACTION_FILTER = 2, +struct dev_pm_qos_request { + enum dev_pm_qos_req_type type; + union { + struct plist_node pnode; + struct pm_qos_flags_request flr; + struct freq_qos_request freq; + } data; + struct device *dev; }; -struct perf_addr_filter { - struct list_head entry; - struct path path; - long unsigned int offset; - long unsigned int size; - enum perf_addr_filter_action_t action; +enum cpufreq_table_sorting { + CPUFREQ_TABLE_UNSORTED = 0, + CPUFREQ_TABLE_SORTED_ASCENDING = 1, + CPUFREQ_TABLE_SORTED_DESCENDING = 2, }; -struct topa_entry { - u64 end: 1; - u64 rsvd0: 1; - u64 intr: 1; - u64 rsvd1: 1; - u64 stop: 1; - u64 rsvd2: 1; - u64 size: 4; - u64 rsvd3: 2; - u64 base: 36; - u64 rsvd4: 16; +struct cpufreq_cpuinfo { + unsigned int max_freq; + unsigned int min_freq; + unsigned int transition_latency; }; -struct pt_pmu { - struct pmu pmu; - u32 caps[8]; - bool vmx; - bool branch_en_always_on; - long unsigned int max_nonturbo_ratio; - unsigned int tsc_art_num; - unsigned int tsc_art_den; +struct cpufreq_stats; + +struct clk; + +struct cpufreq_governor; + +struct cpufreq_frequency_table; + +struct thermal_cooling_device; + +struct cpufreq_policy { + cpumask_var_t cpus; + cpumask_var_t related_cpus; + cpumask_var_t real_cpus; + unsigned int shared_type; + unsigned int cpu; + struct clk *clk; + struct cpufreq_cpuinfo cpuinfo; + unsigned int min; + unsigned int max; + unsigned int cur; + unsigned int restore_freq; + unsigned int suspend_freq; + unsigned int policy; + unsigned int last_policy; + struct cpufreq_governor *governor; + void *governor_data; + char last_governor[16]; + struct work_struct update; + struct freq_constraints constraints; + struct freq_qos_request *min_freq_req; + struct freq_qos_request *max_freq_req; + struct cpufreq_frequency_table *freq_table; + enum cpufreq_table_sorting freq_table_sorted; + struct list_head policy_list; + struct kobject kobj; + struct completion kobj_unregister; + struct rw_semaphore rwsem; + bool fast_switch_possible; + bool fast_switch_enabled; + unsigned int transition_delay_us; + bool dvfs_possible_from_any_cpu; + unsigned int cached_target_freq; + int cached_resolved_idx; + bool transition_ongoing; + spinlock_t transition_lock; + wait_queue_head_t transition_wait; + struct task_struct *transition_task; + struct cpufreq_stats *stats; + void *driver_data; + struct thermal_cooling_device *cdev; + struct notifier_block nb_min; + struct notifier_block nb_max; }; -struct topa; +struct cpufreq_governor { + char name[16]; + int (*init)(struct cpufreq_policy *); + void (*exit)(struct cpufreq_policy *); + int (*start)(struct cpufreq_policy *); + void (*stop)(struct cpufreq_policy *); + void (*limits)(struct cpufreq_policy *); + ssize_t (*show_setspeed)(struct cpufreq_policy *, char *); + int (*store_setspeed)(struct cpufreq_policy *, unsigned int); + bool dynamic_switching; + struct list_head governor_list; + struct module *owner; +}; -struct pt_buffer { - struct list_head tables; - struct topa *first; - struct topa *last; - struct topa *cur; - unsigned int cur_idx; - size_t output_off; - long unsigned int nr_pages; - local_t data_size; - local64_t head; - bool snapshot; - bool single; - long int stop_pos; - long int intr_pos; - struct topa_entry *stop_te; - struct topa_entry *intr_te; - void **data_pages; +struct cpufreq_frequency_table { + unsigned int flags; + unsigned int driver_data; + unsigned int frequency; }; -struct topa { - struct list_head list; - u64 offset; - size_t size; - int last; - unsigned int z_count; +struct freq_attr { + struct attribute attr; + ssize_t (*show)(struct cpufreq_policy *, char *); + ssize_t (*store)(struct cpufreq_policy *, const char *, size_t); }; -struct pt_filter { - long unsigned int msr_a; - long unsigned int msr_b; - long unsigned int config; +struct efi_scratch { + u64 phys_stack; + struct mm_struct *prev_mm; }; -struct pt_filters { - struct pt_filter filter[4]; - unsigned int nr_filters; +struct amd_nb_bus_dev_range { + u8 bus; + u8 dev_base; + u8 dev_limit; }; -struct pt { - struct perf_output_handle handle; - struct pt_filters filters; - int handle_nmi; - int vmx_on; - u64 output_base; - u64 output_mask; +struct msi_controller { + struct module *owner; + struct device *dev; + struct device_node *of_node; + struct list_head list; + int (*setup_irq)(struct msi_controller *, struct pci_dev *, struct msi_desc *); + int (*setup_irqs)(struct msi_controller *, struct pci_dev *, int, int); + void (*teardown_irq)(struct msi_controller *, unsigned int); }; -struct pt_cap_desc { - const char *name; - u32 leaf; - u8 reg; - u32 mask; +struct pci_raw_ops { + int (*read)(unsigned int, unsigned int, unsigned int, int, int, u32 *); + int (*write)(unsigned int, unsigned int, unsigned int, int, int, u32); }; -struct pt_address_range { - long unsigned int msr_a; - long unsigned int msr_b; - unsigned int reg_off; +struct clock_event_device___2; + +enum jump_label_type { + JUMP_LABEL_NOP = 0, + JUMP_LABEL_JMP = 1, }; -struct topa_page { - struct topa_entry table[507]; - struct topa topa; +struct text_poke_loc { + void *addr; + int len; + s32 rel32; + u8 opcode; + const u8 text[5]; }; -typedef void (*exitcall_t)(); +union jump_code_union { + char code[5]; + struct { + char jump; + int offset; + } __attribute__((packed)); +}; -enum hrtimer_mode { - HRTIMER_MODE_ABS = 0, - HRTIMER_MODE_REL = 1, - HRTIMER_MODE_PINNED = 2, - HRTIMER_MODE_SOFT = 4, - HRTIMER_MODE_HARD = 8, - HRTIMER_MODE_ABS_PINNED = 2, - HRTIMER_MODE_REL_PINNED = 3, - HRTIMER_MODE_ABS_SOFT = 4, - HRTIMER_MODE_REL_SOFT = 5, - HRTIMER_MODE_ABS_PINNED_SOFT = 6, - HRTIMER_MODE_REL_PINNED_SOFT = 7, - HRTIMER_MODE_ABS_HARD = 8, - HRTIMER_MODE_REL_HARD = 9, - HRTIMER_MODE_ABS_PINNED_HARD = 10, - HRTIMER_MODE_REL_PINNED_HARD = 11, +enum { + JL_STATE_START = 0, + JL_STATE_NO_UPDATE = 1, + JL_STATE_UPDATE = 2, }; -struct x86_cpu_id { - __u16 vendor; - __u16 family; - __u16 model; - __u16 feature; - kernel_ulong_t driver_data; +struct vm_unmapped_area_info { + long unsigned int flags; + long unsigned int length; + long unsigned int low_limit; + long unsigned int high_limit; + long unsigned int align_mask; + long unsigned int align_offset; }; -enum perf_rapl_events { - PERF_RAPL_PP0 = 0, - PERF_RAPL_PKG = 1, - PERF_RAPL_RAM = 2, - PERF_RAPL_PP1 = 3, - PERF_RAPL_PSYS = 4, - PERF_RAPL_MAX = 5, - NR_RAPL_DOMAINS = 5, +enum align_flags { + ALIGN_VA_32 = 1, + ALIGN_VA_64 = 2, }; -struct rapl_pmu { - raw_spinlock_t lock; - int n_active; - int cpu; - struct list_head active_list; - struct pmu *pmu; - ktime_t timer_interval; - struct hrtimer hrtimer; +enum { + MEMREMAP_WB = 1, + MEMREMAP_WT = 2, + MEMREMAP_WC = 4, + MEMREMAP_ENC = 8, + MEMREMAP_DEC = 16, }; -struct rapl_pmus { - struct pmu pmu; - unsigned int maxdie; - struct rapl_pmu *pmus[0]; +enum { + IORES_DESC_NONE = 0, + IORES_DESC_CRASH_KERNEL = 1, + IORES_DESC_ACPI_TABLES = 2, + IORES_DESC_ACPI_NV_STORAGE = 3, + IORES_DESC_PERSISTENT_MEMORY = 4, + IORES_DESC_PERSISTENT_MEMORY_LEGACY = 5, + IORES_DESC_DEVICE_PRIVATE_MEMORY = 6, + IORES_DESC_RESERVED = 7, + IORES_DESC_SOFT_RESERVED = 8, +}; + +struct change_member { + struct e820_entry *entry; + long long unsigned int addr; }; -struct rapl_model { - long unsigned int events; - bool apply_quirk; +struct iommu_fwspec { + const struct iommu_ops *ops; + struct fwnode_handle *iommu_fwnode; + void *iommu_priv; + u32 flags; + unsigned int num_ids; + u32 ids[1]; }; -struct acpi_device; +struct iommu_fault_param; -struct pci_sysdata { - int domain; - int node; - struct acpi_device *companion; - void *iommu; - void *fwnode; +struct iommu_param { + struct mutex lock; + struct iommu_fault_param *fault_param; }; -struct pci_extra_dev { - struct pci_dev *dev[4]; +struct of_phandle_args { + struct device_node *np; + int args_count; + uint32_t args[16]; }; -struct intel_uncore_pmu; - -struct intel_uncore_ops; - -struct uncore_event_desc; +struct iommu_fault_unrecoverable { + __u32 reason; + __u32 flags; + __u32 pasid; + __u32 perm; + __u64 addr; + __u64 fetch_addr; +}; -struct freerunning_counters; +struct iommu_fault_page_request { + __u32 flags; + __u32 pasid; + __u32 grpid; + __u32 perm; + __u64 addr; + __u64 private_data[2]; +}; -struct intel_uncore_type { - const char *name; - int num_counters; - int num_boxes; - int perf_ctr_bits; - int fixed_ctr_bits; - int num_freerunning_types; - unsigned int perf_ctr; - unsigned int event_ctl; - unsigned int event_mask; - unsigned int event_mask_ext; - unsigned int fixed_ctr; - unsigned int fixed_ctl; - unsigned int box_ctl; +struct iommu_fault { + __u32 type; + __u32 padding; union { - unsigned int msr_offset; - unsigned int mmio_offset; + struct iommu_fault_unrecoverable event; + struct iommu_fault_page_request prm; + __u8 padding2[56]; }; - unsigned int num_shared_regs: 8; - unsigned int single_fixed: 1; - unsigned int pair_ctr_ctl: 1; - unsigned int *msr_offsets; - struct event_constraint unconstrainted; - struct event_constraint *constraints; - struct intel_uncore_pmu *pmus; - struct intel_uncore_ops *ops; - struct uncore_event_desc *event_descs; - struct freerunning_counters *freerunning; - const struct attribute_group *attr_groups[4]; - struct pmu *pmu; }; -struct intel_uncore_box; - -struct intel_uncore_pmu { - struct pmu pmu; - char name[32]; - int pmu_idx; - int func_id; - bool registered; - atomic_t activeboxes; - struct intel_uncore_type *type; - struct intel_uncore_box **boxes; +struct iommu_page_response { + __u32 version; + __u32 flags; + __u32 pasid; + __u32 grpid; + __u32 code; }; -struct intel_uncore_ops { - void (*init_box)(struct intel_uncore_box *); - void (*exit_box)(struct intel_uncore_box *); - void (*disable_box)(struct intel_uncore_box *); - void (*enable_box)(struct intel_uncore_box *); - void (*disable_event)(struct intel_uncore_box *, struct perf_event *); - void (*enable_event)(struct intel_uncore_box *, struct perf_event *); - u64 (*read_counter)(struct intel_uncore_box *, struct perf_event *); - int (*hw_config)(struct intel_uncore_box *, struct perf_event *); - struct event_constraint * (*get_constraint)(struct intel_uncore_box *, struct perf_event *); - void (*put_constraint)(struct intel_uncore_box *, struct perf_event *); +struct iommu_inv_addr_info { + __u32 flags; + __u32 archid; + __u64 pasid; + __u64 addr; + __u64 granule_size; + __u64 nb_granules; }; -struct uncore_event_desc { - struct kobj_attribute attr; - const char *config; +struct iommu_inv_pasid_info { + __u32 flags; + __u32 archid; + __u64 pasid; }; -struct freerunning_counters { - unsigned int counter_base; - unsigned int counter_offset; - unsigned int box_offset; - unsigned int num_counters; - unsigned int bits; +struct iommu_cache_invalidate_info { + __u32 version; + __u8 cache; + __u8 granularity; + __u8 padding[2]; + union { + struct iommu_inv_pasid_info pasid_info; + struct iommu_inv_addr_info addr_info; + }; }; -struct intel_uncore_extra_reg { - raw_spinlock_t lock; - u64 config; - u64 config1; - u64 config2; - atomic_t ref; +struct iommu_gpasid_bind_data_vtd { + __u64 flags; + __u32 pat; + __u32 emt; }; -struct intel_uncore_box { - int pci_phys_id; - int dieid; - int n_active; - int n_events; - int cpu; - long unsigned int flags; - atomic_t refcnt; - struct perf_event *events[10]; - struct perf_event *event_list[10]; - struct event_constraint *event_constraint[10]; - long unsigned int active_mask[1]; - u64 tags[10]; - struct pci_dev *pci_dev; - struct intel_uncore_pmu *pmu; - u64 hrtimer_duration; - struct hrtimer hrtimer; - struct list_head list; - struct list_head active_list; - void *io_addr; - struct intel_uncore_extra_reg shared_regs[0]; +struct iommu_gpasid_bind_data { + __u32 version; + __u32 format; + __u64 flags; + __u64 gpgd; + __u64 hpasid; + __u64 gpasid; + __u32 addr_width; + __u8 padding[12]; + union { + struct iommu_gpasid_bind_data_vtd vtd; + }; }; -struct pci2phy_map { - struct list_head list; - int segment; - int pbus_to_physid[256]; -}; +typedef int (*iommu_fault_handler_t)(struct iommu_domain *, struct device *, long unsigned int, int, void *); -struct intel_uncore_init_fun { - void (*cpu_init)(); - int (*pci_init)(); - void (*mmio_init)(); +struct iommu_domain_geometry { + dma_addr_t aperture_start; + dma_addr_t aperture_end; + bool force_aperture; }; -enum { - EXTRA_REG_NHMEX_M_FILTER = 0, - EXTRA_REG_NHMEX_M_DSP = 1, - EXTRA_REG_NHMEX_M_ISS = 2, - EXTRA_REG_NHMEX_M_MAP = 3, - EXTRA_REG_NHMEX_M_MSC_THR = 4, - EXTRA_REG_NHMEX_M_PGT = 5, - EXTRA_REG_NHMEX_M_PLD = 6, - EXTRA_REG_NHMEX_M_ZDP_CTL_FVC = 7, +struct iommu_domain { + unsigned int type; + const struct iommu_ops *ops; + long unsigned int pgsize_bitmap; + iommu_fault_handler_t handler; + void *handler_token; + struct iommu_domain_geometry geometry; + void *iova_cookie; }; -enum { - SNB_PCI_UNCORE_IMC = 0, -}; +typedef int (*iommu_mm_exit_handler_t)(struct device *, struct iommu_sva *, void *); -enum perf_snb_uncore_imc_freerunning_types { - SNB_PCI_UNCORE_IMC_DATA = 0, - SNB_PCI_UNCORE_IMC_FREERUNNING_TYPE_MAX = 1, -}; +struct iommu_sva_ops; -struct imc_uncore_pci_dev { - __u32 pci_id; - struct pci_driver *driver; +struct iommu_sva { + struct device *dev; + const struct iommu_sva_ops *ops; }; -enum { - SNBEP_PCI_QPI_PORT0_FILTER = 0, - SNBEP_PCI_QPI_PORT1_FILTER = 1, - BDX_PCI_QPI_PORT2_FILTER = 2, - HSWEP_PCI_PCU_3 = 3, -}; +typedef int (*iommu_dev_fault_handler_t)(struct iommu_fault *, void *); -enum { - SNBEP_PCI_UNCORE_HA = 0, - SNBEP_PCI_UNCORE_IMC = 1, - SNBEP_PCI_UNCORE_QPI = 2, - SNBEP_PCI_UNCORE_R2PCIE = 3, - SNBEP_PCI_UNCORE_R3QPI = 4, +enum iommu_resv_type { + IOMMU_RESV_DIRECT = 0, + IOMMU_RESV_DIRECT_RELAXABLE = 1, + IOMMU_RESV_RESERVED = 2, + IOMMU_RESV_MSI = 3, + IOMMU_RESV_SW_MSI = 4, }; -enum { - IVBEP_PCI_UNCORE_HA = 0, - IVBEP_PCI_UNCORE_IMC = 1, - IVBEP_PCI_UNCORE_IRP = 2, - IVBEP_PCI_UNCORE_QPI = 3, - IVBEP_PCI_UNCORE_R2PCIE = 4, - IVBEP_PCI_UNCORE_R3QPI = 5, +struct iommu_resv_region { + struct list_head list; + phys_addr_t start; + size_t length; + int prot; + enum iommu_resv_type type; }; -enum { - KNL_PCI_UNCORE_MC_UCLK = 0, - KNL_PCI_UNCORE_MC_DCLK = 1, - KNL_PCI_UNCORE_EDC_UCLK = 2, - KNL_PCI_UNCORE_EDC_ECLK = 3, - KNL_PCI_UNCORE_M2PCIE = 4, - KNL_PCI_UNCORE_IRP = 5, +struct iommu_sva_ops { + iommu_mm_exit_handler_t mm_exit; }; -enum { - HSWEP_PCI_UNCORE_HA = 0, - HSWEP_PCI_UNCORE_IMC = 1, - HSWEP_PCI_UNCORE_IRP = 2, - HSWEP_PCI_UNCORE_QPI = 3, - HSWEP_PCI_UNCORE_R2PCIE = 4, - HSWEP_PCI_UNCORE_R3QPI = 5, +struct iommu_iotlb_gather { + long unsigned int start; + long unsigned int end; + size_t pgsize; }; -enum { - BDX_PCI_UNCORE_HA = 0, - BDX_PCI_UNCORE_IMC = 1, - BDX_PCI_UNCORE_IRP = 2, - BDX_PCI_UNCORE_QPI = 3, - BDX_PCI_UNCORE_R2PCIE = 4, - BDX_PCI_UNCORE_R3QPI = 5, +struct iommu_fault_event { + struct iommu_fault fault; + struct list_head list; }; -enum perf_uncore_iio_freerunning_type_id { - SKX_IIO_MSR_IOCLK = 0, - SKX_IIO_MSR_BW = 1, - SKX_IIO_MSR_UTIL = 2, - SKX_IIO_FREERUNNING_TYPE_MAX = 3, +struct iommu_fault_param { + iommu_dev_fault_handler_t handler; + void *data; + struct list_head faults; + struct mutex lock; }; -enum { - SKX_PCI_UNCORE_IMC = 0, - SKX_PCI_UNCORE_M2M = 1, - SKX_PCI_UNCORE_UPI = 2, - SKX_PCI_UNCORE_M2PCIE = 3, - SKX_PCI_UNCORE_M3UPI = 4, +struct iommu_table_entry { + initcall_t detect; + initcall_t depend; + void (*early_init)(); + void (*late_init)(); + int flags; }; -enum perf_uncore_snr_iio_freerunning_type_id { - SNR_IIO_MSR_IOCLK = 0, - SNR_IIO_MSR_BW_IN = 1, - SNR_IIO_FREERUNNING_TYPE_MAX = 2, +enum dmi_field { + DMI_NONE = 0, + DMI_BIOS_VENDOR = 1, + DMI_BIOS_VERSION = 2, + DMI_BIOS_DATE = 3, + DMI_SYS_VENDOR = 4, + DMI_PRODUCT_NAME = 5, + DMI_PRODUCT_VERSION = 6, + DMI_PRODUCT_SERIAL = 7, + DMI_PRODUCT_UUID = 8, + DMI_PRODUCT_SKU = 9, + DMI_PRODUCT_FAMILY = 10, + DMI_BOARD_VENDOR = 11, + DMI_BOARD_NAME = 12, + DMI_BOARD_VERSION = 13, + DMI_BOARD_SERIAL = 14, + DMI_BOARD_ASSET_TAG = 15, + DMI_CHASSIS_VENDOR = 16, + DMI_CHASSIS_TYPE = 17, + DMI_CHASSIS_VERSION = 18, + DMI_CHASSIS_SERIAL = 19, + DMI_CHASSIS_ASSET_TAG = 20, + DMI_STRING_MAX = 21, + DMI_OEM_STRING = 22, }; enum { - SNR_PCI_UNCORE_M2M = 0, + NONE_FORCE_HPET_RESUME = 0, + OLD_ICH_FORCE_HPET_RESUME = 1, + ICH_FORCE_HPET_RESUME = 2, + VT8237_FORCE_HPET_RESUME = 3, + NVIDIA_FORCE_HPET_RESUME = 4, + ATI_FORCE_HPET_RESUME = 5, }; -enum perf_uncore_snr_imc_freerunning_type_id { - SNR_IMC_DCLK = 0, - SNR_IMC_DDR = 1, - SNR_IMC_FREERUNNING_TYPE_MAX = 2, +struct cpu { + int node_id; + int hotpluggable; + struct device dev; }; -struct cstate_model { - long unsigned int core_events; - long unsigned int pkg_events; - long unsigned int quirks; +struct x86_cpu { + struct cpu cpu; }; -enum perf_cstate_core_events { - PERF_CSTATE_CORE_C1_RES = 0, - PERF_CSTATE_CORE_C3_RES = 1, - PERF_CSTATE_CORE_C6_RES = 2, - PERF_CSTATE_CORE_C7_RES = 3, - PERF_CSTATE_CORE_EVENT_MAX = 4, +struct debugfs_blob_wrapper { + void *data; + long unsigned int size; }; -enum perf_cstate_pkg_events { - PERF_CSTATE_PKG_C2_RES = 0, - PERF_CSTATE_PKG_C3_RES = 1, - PERF_CSTATE_PKG_C6_RES = 2, - PERF_CSTATE_PKG_C7_RES = 3, - PERF_CSTATE_PKG_C8_RES = 4, - PERF_CSTATE_PKG_C9_RES = 5, - PERF_CSTATE_PKG_C10_RES = 6, - PERF_CSTATE_PKG_EVENT_MAX = 7, +struct setup_data_node { + u64 paddr; + u32 type; + u32 len; }; -struct trampoline_header { - u64 start; - u64 efer; - u32 cr4; - u32 flags; +struct die_args { + struct pt_regs *regs; + const char *str; + long int err; + int trapnr; + int signr; }; -enum xfeature { - XFEATURE_FP = 0, - XFEATURE_SSE = 1, - XFEATURE_YMM = 2, - XFEATURE_BNDREGS = 3, - XFEATURE_BNDCSR = 4, - XFEATURE_OPMASK = 5, - XFEATURE_ZMM_Hi256 = 6, - XFEATURE_Hi16_ZMM = 7, - XFEATURE_PT_UNIMPLEMENTED_SO_FAR = 8, - XFEATURE_PKRU = 9, - XFEATURE_MAX = 10, +typedef struct { + struct mm_struct *mm; +} temp_mm_state_t; + +struct smp_alt_module { + struct module *mod; + char *name; + const s32 *locks; + const s32 *locks_end; + u8 *text; + u8 *text_end; + struct list_head next; }; -struct pkru_state { - u32 pkru; - u32 pad; +struct bp_patching_desc { + struct text_poke_loc *vec; + int nr_entries; }; -enum show_regs_mode { - SHOW_REGS_SHORT = 0, - SHOW_REGS_USER = 1, - SHOW_REGS_ALL = 2, +struct paravirt_patch_site; + +struct user_i387_struct { + short unsigned int cwd; + short unsigned int swd; + short unsigned int twd; + short unsigned int fop; + __u64 rip; + __u64 rdp; + __u32 mxcsr; + __u32 mxcsr_mask; + __u32 st_space[32]; + __u32 xmm_space[64]; + __u32 padding[24]; }; -enum which_selector { - FS = 0, - GS = 1, +struct user_regs_struct { + long unsigned int r15; + long unsigned int r14; + long unsigned int r13; + long unsigned int r12; + long unsigned int bp; + long unsigned int bx; + long unsigned int r11; + long unsigned int r10; + long unsigned int r9; + long unsigned int r8; + long unsigned int ax; + long unsigned int cx; + long unsigned int dx; + long unsigned int si; + long unsigned int di; + long unsigned int orig_ax; + long unsigned int ip; + long unsigned int cs; + long unsigned int flags; + long unsigned int sp; + long unsigned int ss; + long unsigned int fs_base; + long unsigned int gs_base; + long unsigned int ds; + long unsigned int es; + long unsigned int fs; + long unsigned int gs; }; -struct sigcontext_64 { - __u64 r8; - __u64 r9; - __u64 r10; - __u64 r11; - __u64 r12; - __u64 r13; - __u64 r14; - __u64 r15; - __u64 di; - __u64 si; - __u64 bp; - __u64 bx; - __u64 dx; - __u64 ax; - __u64 cx; - __u64 sp; - __u64 ip; - __u64 flags; - __u16 cs; - __u16 gs; - __u16 fs; - __u16 ss; - __u64 err; - __u64 trapno; - __u64 oldmask; - __u64 cr2; - __u64 fpstate; - __u64 reserved1[8]; +struct user { + struct user_regs_struct regs; + int u_fpvalid; + int pad0; + struct user_i387_struct i387; + long unsigned int u_tsize; + long unsigned int u_dsize; + long unsigned int u_ssize; + long unsigned int start_code; + long unsigned int start_stack; + long int signal; + int reserved; + int pad1; + long unsigned int u_ar0; + struct user_i387_struct *u_fpstate; + long unsigned int magic; + char u_comm[32]; + long unsigned int u_debugreg[8]; + long unsigned int error_code; + long unsigned int fault_address; }; -struct sigaltstack { - void *ss_sp; - int ss_flags; - size_t ss_size; +enum { + HW_BREAKPOINT_LEN_1 = 1, + HW_BREAKPOINT_LEN_2 = 2, + HW_BREAKPOINT_LEN_3 = 3, + HW_BREAKPOINT_LEN_4 = 4, + HW_BREAKPOINT_LEN_5 = 5, + HW_BREAKPOINT_LEN_6 = 6, + HW_BREAKPOINT_LEN_7 = 7, + HW_BREAKPOINT_LEN_8 = 8, }; -typedef struct sigaltstack stack_t; - -struct siginfo { - union { - struct { - int si_signo; - int si_errno; - int si_code; - union __sifields _sifields; - }; - int _si_pad[32]; - }; +enum { + HW_BREAKPOINT_EMPTY = 0, + HW_BREAKPOINT_R = 1, + HW_BREAKPOINT_W = 2, + HW_BREAKPOINT_RW = 3, + HW_BREAKPOINT_X = 4, + HW_BREAKPOINT_INVALID = 7, }; -typedef struct siginfo siginfo_t; +typedef unsigned int u_int; -struct ucontext { - long unsigned int uc_flags; - struct ucontext *uc_link; - stack_t uc_stack; - struct sigcontext_64 uc_mcontext; - sigset_t uc_sigmask; +typedef long long unsigned int cycles_t; + +struct system_counterval_t { + u64 cycles; + struct clocksource *cs; }; -typedef u32 compat_sigset_word; +enum { + WORK_STRUCT_PENDING_BIT = 0, + WORK_STRUCT_DELAYED_BIT = 1, + WORK_STRUCT_PWQ_BIT = 2, + WORK_STRUCT_LINKED_BIT = 3, + WORK_STRUCT_COLOR_SHIFT = 4, + WORK_STRUCT_COLOR_BITS = 4, + WORK_STRUCT_PENDING = 1, + WORK_STRUCT_DELAYED = 2, + WORK_STRUCT_PWQ = 4, + WORK_STRUCT_LINKED = 8, + WORK_STRUCT_STATIC = 0, + WORK_NR_COLORS = 15, + WORK_NO_COLOR = 15, + WORK_CPU_UNBOUND = 64, + WORK_STRUCT_FLAG_BITS = 8, + WORK_OFFQ_FLAG_BASE = 4, + __WORK_OFFQ_CANCELING = 4, + WORK_OFFQ_CANCELING = 16, + WORK_OFFQ_FLAG_BITS = 1, + WORK_OFFQ_POOL_SHIFT = 5, + WORK_OFFQ_LEFT = 59, + WORK_OFFQ_POOL_BITS = 31, + WORK_OFFQ_POOL_NONE = 2147483647, + WORK_STRUCT_FLAG_MASK = 255, + WORK_STRUCT_WQ_DATA_MASK = 4294967040, + WORK_STRUCT_NO_POOL = 4294967264, + WORK_BUSY_PENDING = 1, + WORK_BUSY_RUNNING = 2, + WORKER_DESC_LEN = 24, +}; -typedef struct { - compat_sigset_word sig[2]; -} compat_sigset_t; +struct cpufreq_freqs { + struct cpufreq_policy *policy; + unsigned int old; + unsigned int new; + u8 flags; +}; -struct kernel_vm86_regs { - struct pt_regs pt; - short unsigned int es; - short unsigned int __esh; - short unsigned int ds; - short unsigned int __dsh; - short unsigned int fs; - short unsigned int __fsh; - short unsigned int gs; - short unsigned int __gsh; +struct cyc2ns { + struct cyc2ns_data data[2]; + seqcount_t seq; }; -struct rt_sigframe { - char *pretcode; - struct ucontext uc; - struct siginfo info; +struct freq_desc { + u8 msr_plat; + u32 freqs[9]; }; -typedef s32 compat_clock_t; +struct dmi_strmatch { + unsigned char slot: 7; + unsigned char exact_match: 1; + char substr[79]; +}; -typedef s32 compat_pid_t; +struct dmi_system_id { + int (*callback)(const struct dmi_system_id *); + const char *ident; + struct dmi_strmatch matches[4]; + void *driver_data; +}; -typedef s32 compat_timer_t; +struct pdev_archdata {}; -typedef s32 compat_int_t; +struct mfd_cell; -typedef u32 __compat_uid32_t; +struct platform_device_id; -union compat_sigval { - compat_int_t sival_int; - compat_uptr_t sival_ptr; +struct platform_device { + const char *name; + int id; + bool id_auto; + struct device dev; + u64 dma_mask; + u32 num_resources; + struct resource *resource; + const struct platform_device_id *id_entry; + char *driver_override; + struct mfd_cell *mfd_cell; + struct pdev_archdata archdata; }; -typedef union compat_sigval compat_sigval_t; - -struct compat_siginfo { - int si_signo; - int si_errno; - int si_code; - union { - int _pad[29]; - struct { - compat_pid_t _pid; - __compat_uid32_t _uid; - } _kill; - struct { - compat_timer_t _tid; - int _overrun; - compat_sigval_t _sigval; - } _timer; - struct { - compat_pid_t _pid; - __compat_uid32_t _uid; - compat_sigval_t _sigval; - } _rt; - struct { - compat_pid_t _pid; - __compat_uid32_t _uid; - int _status; - compat_clock_t _utime; - compat_clock_t _stime; - } _sigchld; - struct { - compat_uptr_t _addr; - union { - short int _addr_lsb; - struct { - char _dummy_bnd[4]; - compat_uptr_t _lower; - compat_uptr_t _upper; - } _addr_bnd; - struct { - char _dummy_pkey[4]; - u32 _pkey; - } _addr_pkey; - }; - } _sigfault; - struct { - compat_long_t _band; - int _fd; - } _sigpoll; - struct { - compat_uptr_t _call_addr; - int _syscall; - unsigned int _arch; - } _sigsys; - } _sifields; +struct platform_device_id { + char name[20]; + kernel_ulong_t driver_data; }; -typedef struct compat_siginfo compat_siginfo_t; - -enum bug_trap_type { - BUG_TRAP_TYPE_NONE = 0, - BUG_TRAP_TYPE_WARN = 1, - BUG_TRAP_TYPE_BUG = 2, +struct rtc_time { + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; }; -struct idt_bits { - u16 ist: 3; - u16 zero: 5; - u16 type: 5; - u16 dpl: 2; - u16 p: 1; +struct pnp_device_id { + __u8 id[8]; + kernel_ulong_t driver_data; }; -struct gate_struct { - u16 offset_low; - u16 segment; - struct idt_bits bits; - u16 offset_middle; - u32 offset_high; - u32 reserved; +struct pnp_card_device_id { + __u8 id[8]; + kernel_ulong_t driver_data; + struct { + __u8 id[8]; + } devs[8]; }; -typedef struct gate_struct gate_desc; - -struct mpx_bndcsr { - u64 bndcfgu; - u64 bndstatus; -}; +struct pnp_protocol; -enum die_val { - DIE_OOPS = 1, - DIE_INT3 = 2, - DIE_DEBUG = 3, - DIE_PANIC = 4, - DIE_NMI = 5, - DIE_DIE = 6, - DIE_KERNELDEBUG = 7, - DIE_TRAP = 8, - DIE_GPF = 9, - DIE_CALL = 10, - DIE_PAGE_FAULT = 11, - DIE_NMIUNKNOWN = 12, -}; +struct pnp_id; -struct bad_iret_stack { - void *error_entry_ret; - struct pt_regs regs; +struct pnp_card { + struct device dev; + unsigned char number; + struct list_head global_list; + struct list_head protocol_list; + struct list_head devices; + struct pnp_protocol *protocol; + struct pnp_id *id; + char name[50]; + unsigned char pnpver; + unsigned char productver; + unsigned int serial; + unsigned char checksum; + struct proc_dir_entry *procdir; }; -enum { - GATE_INTERRUPT = 14, - GATE_TRAP = 15, - GATE_CALL = 12, - GATE_TASK = 5, -}; +struct pnp_dev; -struct idt_data { - unsigned int vector; - unsigned int segment; - struct idt_bits bits; - const void *addr; +struct pnp_protocol { + struct list_head protocol_list; + char *name; + int (*get)(struct pnp_dev *); + int (*set)(struct pnp_dev *); + int (*disable)(struct pnp_dev *); + bool (*can_wakeup)(struct pnp_dev *); + int (*suspend)(struct pnp_dev *, pm_message_t); + int (*resume)(struct pnp_dev *); + unsigned char number; + struct device dev; + struct list_head cards; + struct list_head devices; }; -enum irqreturn { - IRQ_NONE = 0, - IRQ_HANDLED = 1, - IRQ_WAKE_THREAD = 2, +struct pnp_id { + char id[8]; + struct pnp_id *next; }; -typedef enum irqreturn irqreturn_t; - -typedef irqreturn_t (*irq_handler_t)(int, void *); +struct pnp_card_driver; -struct irqaction { - irq_handler_t handler; - void *dev_id; - void *percpu_dev_id; - struct irqaction *next; - irq_handler_t thread_fn; - struct task_struct *thread; - struct irqaction *secondary; - unsigned int irq; - unsigned int flags; - long unsigned int thread_flags; - long unsigned int thread_mask; - const char *name; - struct proc_dir_entry *dir; - long: 64; - long: 64; - long: 64; - long: 64; +struct pnp_card_link { + struct pnp_card *card; + struct pnp_card_driver *driver; + void *driver_data; + pm_message_t pm_state; }; -struct irq_affinity_notify { - unsigned int irq; - struct kref kref; - struct work_struct work; - void (*notify)(struct irq_affinity_notify *, const cpumask_t *); - void (*release)(struct kref *); +struct pnp_driver { + char *name; + const struct pnp_device_id *id_table; + unsigned int flags; + int (*probe)(struct pnp_dev *, const struct pnp_device_id *); + void (*remove)(struct pnp_dev *); + void (*shutdown)(struct pnp_dev *); + int (*suspend)(struct pnp_dev *, pm_message_t); + int (*resume)(struct pnp_dev *); + struct device_driver driver; }; -enum irqchip_irq_state { - IRQCHIP_STATE_PENDING = 0, - IRQCHIP_STATE_ACTIVE = 1, - IRQCHIP_STATE_MASKED = 2, - IRQCHIP_STATE_LINE_LEVEL = 3, +struct pnp_card_driver { + struct list_head global_list; + char *name; + const struct pnp_card_device_id *id_table; + unsigned int flags; + int (*probe)(struct pnp_card_link *, const struct pnp_card_device_id *); + void (*remove)(struct pnp_card_link *); + int (*suspend)(struct pnp_card_link *, pm_message_t); + int (*resume)(struct pnp_card_link *); + struct pnp_driver link; }; -struct irq_desc; - -typedef void (*irq_flow_handler_t)(struct irq_desc *); - -struct msi_desc; - -struct irq_common_data { - unsigned int state_use_accessors; - unsigned int node; - void *handler_data; - struct msi_desc *msi_desc; - cpumask_var_t affinity; - cpumask_var_t effective_affinity; +struct pnp_dev { + struct device dev; + u64 dma_mask; + unsigned int number; + int status; + struct list_head global_list; + struct list_head protocol_list; + struct list_head card_list; + struct list_head rdev_list; + struct pnp_protocol *protocol; + struct pnp_card *card; + struct pnp_driver *driver; + struct pnp_card_link *card_link; + struct pnp_id *id; + int active; + int capabilities; + unsigned int num_dependent_sets; + struct list_head resources; + struct list_head options; + char name[50]; + int flags; + struct proc_dir_entry *procent; + void *data; }; -struct irq_chip; +struct sfi_rtc_table_entry { + u64 phys_addr; + u32 irq; +} __attribute__((packed)); -struct irq_data { - u32 mask; - unsigned int irq; - long unsigned int hwirq; - struct irq_common_data *common; - struct irq_chip *chip; - struct irq_domain *domain; - struct irq_data *parent_data; - void *chip_data; +enum intel_mid_cpu_type { + INTEL_MID_CPU_CHIP_PENWELL = 2, + INTEL_MID_CPU_CHIP_CLOVERVIEW = 3, + INTEL_MID_CPU_CHIP_TANGIER = 4, }; -struct irq_desc { - struct irq_common_data irq_common_data; - struct irq_data irq_data; - unsigned int *kstat_irqs; - irq_flow_handler_t handle_irq; - struct irqaction *action; - unsigned int status_use_accessors; - unsigned int core_internal_state__do_not_mess_with_it; - unsigned int depth; - unsigned int wake_depth; - unsigned int tot_count; - unsigned int irq_count; - long unsigned int last_unhandled; - unsigned int irqs_unhandled; - atomic_t threads_handled; - int threads_handled_last; - raw_spinlock_t lock; - struct cpumask *percpu_enabled; - const struct cpumask *percpu_affinity; - const struct cpumask *affinity_hint; - struct irq_affinity_notify *affinity_notify; - cpumask_var_t pending_mask; - long unsigned int threads_oneshot; - atomic_t threads_active; - wait_queue_head_t wait_for_threads; - unsigned int nr_actions; - unsigned int no_suspend_depth; - unsigned int cond_suspend_depth; - unsigned int force_resume_depth; - struct proc_dir_entry *dir; - struct callback_head rcu; - struct kobject kobj; - struct mutex request_mutex; - int parent_irq; - struct module *owner; - const char *name; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +enum intel_mid_timer_options { + INTEL_MID_TIMER_DEFAULT = 0, + INTEL_MID_TIMER_APBT_ONLY = 1, + INTEL_MID_TIMER_LAPIC_APBT = 2, }; -struct msi_msg; +typedef struct ldttss_desc tss_desc; -struct irq_chip { - struct device *parent_device; - const char *name; - unsigned int (*irq_startup)(struct irq_data *); - void (*irq_shutdown)(struct irq_data *); - void (*irq_enable)(struct irq_data *); - void (*irq_disable)(struct irq_data *); - void (*irq_ack)(struct irq_data *); - void (*irq_mask)(struct irq_data *); - void (*irq_mask_ack)(struct irq_data *); - void (*irq_unmask)(struct irq_data *); - void (*irq_eoi)(struct irq_data *); - int (*irq_set_affinity)(struct irq_data *, const struct cpumask *, bool); - int (*irq_retrigger)(struct irq_data *); - int (*irq_set_type)(struct irq_data *, unsigned int); - int (*irq_set_wake)(struct irq_data *, unsigned int); - void (*irq_bus_lock)(struct irq_data *); - void (*irq_bus_sync_unlock)(struct irq_data *); - void (*irq_cpu_online)(struct irq_data *); - void (*irq_cpu_offline)(struct irq_data *); - void (*irq_suspend)(struct irq_data *); - void (*irq_resume)(struct irq_data *); - void (*irq_pm_shutdown)(struct irq_data *); - void (*irq_calc_mask)(struct irq_data *); - void (*irq_print_chip)(struct irq_data *, struct seq_file *); - int (*irq_request_resources)(struct irq_data *); - void (*irq_release_resources)(struct irq_data *); - void (*irq_compose_msi_msg)(struct irq_data *, struct msi_msg *); - void (*irq_write_msi_msg)(struct irq_data *, struct msi_msg *); - int (*irq_get_irqchip_state)(struct irq_data *, enum irqchip_irq_state, bool *); - int (*irq_set_irqchip_state)(struct irq_data *, enum irqchip_irq_state, bool); - int (*irq_set_vcpu_affinity)(struct irq_data *, void *); - void (*ipi_send_single)(struct irq_data *, unsigned int); - void (*ipi_send_mask)(struct irq_data *, const struct cpumask *); - int (*irq_nmi_setup)(struct irq_data *); - void (*irq_nmi_teardown)(struct irq_data *); - long unsigned int flags; +enum idle_boot_override { + IDLE_NO_OVERRIDE = 0, + IDLE_HALT = 1, + IDLE_NOMWAIT = 2, + IDLE_POLL = 3, }; -typedef struct irq_desc *vector_irq_t[256]; +enum tick_broadcast_mode { + TICK_BROADCAST_OFF = 0, + TICK_BROADCAST_ON = 1, + TICK_BROADCAST_FORCE = 2, +}; -struct trace_event_raw_x86_irq_vector { - struct trace_entry ent; - int vector; - char __data[0]; +enum tick_broadcast_state { + TICK_BROADCAST_EXIT = 0, + TICK_BROADCAST_ENTER = 1, }; -struct trace_event_raw_vector_config { - struct trace_entry ent; - unsigned int irq; - unsigned int vector; - unsigned int cpu; - unsigned int apicdest; - char __data[0]; +struct cpuidle_state_usage { + long long unsigned int disable; + long long unsigned int usage; + u64 time_ns; + long long unsigned int above; + long long unsigned int below; + long long unsigned int s2idle_usage; + long long unsigned int s2idle_time; }; -struct trace_event_raw_vector_mod { - struct trace_entry ent; - unsigned int irq; - unsigned int vector; +struct cpuidle_driver_kobj; + +struct cpuidle_state_kobj; + +struct cpuidle_device_kobj; + +struct cpuidle_device { + unsigned int registered: 1; + unsigned int enabled: 1; + unsigned int poll_time_limit: 1; unsigned int cpu; - unsigned int prev_vector; - unsigned int prev_cpu; - char __data[0]; + ktime_t next_hrtimer; + int last_state_idx; + u64 last_residency_ns; + u64 poll_limit_ns; + u64 forced_idle_latency_limit_ns; + struct cpuidle_state_usage states_usage[10]; + struct cpuidle_state_kobj *kobjs[10]; + struct cpuidle_driver_kobj *kobj_driver; + struct cpuidle_device_kobj *kobj_dev; + struct list_head device_list; }; -struct trace_event_raw_vector_reserve { - struct trace_entry ent; - unsigned int irq; - int ret; - char __data[0]; +struct inactive_task_frame { + long unsigned int r15; + long unsigned int r14; + long unsigned int r13; + long unsigned int r12; + long unsigned int bx; + long unsigned int bp; + long unsigned int ret_addr; }; -struct trace_event_raw_vector_alloc { - struct trace_entry ent; - unsigned int irq; - unsigned int vector; - bool reserved; - int ret; - char __data[0]; +struct fork_frame { + struct inactive_task_frame frame; + struct pt_regs regs; }; -struct trace_event_raw_vector_alloc_managed { - struct trace_entry ent; - unsigned int irq; - unsigned int vector; - int ret; - char __data[0]; +struct ssb_state { + struct ssb_state *shared_state; + raw_spinlock_t lock; + unsigned int disable_state; + long unsigned int local_state; }; -struct trace_event_raw_vector_activate { +struct trace_event_raw_x86_fpu { struct trace_entry ent; - unsigned int irq; - bool is_managed; - bool can_reserve; - bool reserve; + struct fpu *fpu; + bool load_fpu; + u64 xfeatures; + u64 xcomp_bv; char __data[0]; }; -struct trace_event_raw_vector_teardown { - struct trace_entry ent; - unsigned int irq; - bool is_managed; - bool has_reserved; - char __data[0]; -}; +struct trace_event_data_offsets_x86_fpu {}; -struct trace_event_raw_vector_setup { - struct trace_entry ent; - unsigned int irq; - bool is_legacy; - int ret; - char __data[0]; -}; +typedef void (*btf_trace_x86_fpu_before_save)(void *, struct fpu *); -struct trace_event_raw_vector_free_moved { - struct trace_entry ent; - unsigned int irq; - unsigned int cpu; - unsigned int vector; - bool is_managed; - char __data[0]; -}; +typedef void (*btf_trace_x86_fpu_after_save)(void *, struct fpu *); -struct trace_event_data_offsets_x86_irq_vector {}; +typedef void (*btf_trace_x86_fpu_before_restore)(void *, struct fpu *); -struct trace_event_data_offsets_vector_config {}; +typedef void (*btf_trace_x86_fpu_after_restore)(void *, struct fpu *); -struct trace_event_data_offsets_vector_mod {}; +typedef void (*btf_trace_x86_fpu_regs_activated)(void *, struct fpu *); -struct trace_event_data_offsets_vector_reserve {}; +typedef void (*btf_trace_x86_fpu_regs_deactivated)(void *, struct fpu *); -struct trace_event_data_offsets_vector_alloc {}; +typedef void (*btf_trace_x86_fpu_init_state)(void *, struct fpu *); -struct trace_event_data_offsets_vector_alloc_managed {}; +typedef void (*btf_trace_x86_fpu_dropped)(void *, struct fpu *); -struct trace_event_data_offsets_vector_activate {}; +typedef void (*btf_trace_x86_fpu_copy_src)(void *, struct fpu *); -struct trace_event_data_offsets_vector_teardown {}; +typedef void (*btf_trace_x86_fpu_copy_dst)(void *, struct fpu *); -struct trace_event_data_offsets_vector_setup {}; +typedef void (*btf_trace_x86_fpu_xstate_check_failed)(void *, struct fpu *); -struct trace_event_data_offsets_vector_free_moved {}; +typedef struct fpu *pto_T_____9; -struct irq_stack { - char stack[16384]; +struct _fpreg { + __u16 significand[4]; + __u16 exponent; }; -struct estack_pages { - u32 offs; - u16 size; - u16 type; +struct _fpxreg { + __u16 significand[4]; + __u16 exponent; + __u16 padding[3]; }; -struct arch_clocksource_data { - int vclock_mode; +struct user_i387_ia32_struct { + u32 cwd; + u32 swd; + u32 twd; + u32 fip; + u32 fcs; + u32 foo; + u32 fos; + u32 st_space[20]; }; -struct clocksource { - u64 (*read)(struct clocksource *); - u64 mask; - u32 mult; - u32 shift; - u64 max_idle_ns; - u32 maxadj; - struct arch_clocksource_data archdata; - u64 max_cycles; - const char *name; - struct list_head list; - int rating; - int (*enable)(struct clocksource *); - void (*disable)(struct clocksource *); - long unsigned int flags; - void (*suspend)(struct clocksource *); - void (*resume)(struct clocksource *); - void (*mark_unstable)(struct clocksource *); - void (*tick_stable)(struct clocksource *); - struct list_head wd_list; - u64 cs_last; - u64 wd_last; - struct module *owner; +struct user_regset; + +typedef int user_regset_active_fn(struct task_struct *, const struct user_regset *); + +typedef int user_regset_get_fn(struct task_struct *, const struct user_regset *, unsigned int, unsigned int, void *, void *); + +typedef int user_regset_set_fn(struct task_struct *, const struct user_regset *, unsigned int, unsigned int, const void *, const void *); + +typedef int user_regset_writeback_fn(struct task_struct *, const struct user_regset *, int); + +typedef unsigned int user_regset_get_size_fn(struct task_struct *, const struct user_regset *); + +struct user_regset { + user_regset_get_fn *get; + user_regset_set_fn *set; + user_regset_active_fn *active; + user_regset_writeback_fn *writeback; + user_regset_get_size_fn *get_size; + unsigned int n; + unsigned int size; + unsigned int align; + unsigned int bias; + unsigned int core_note_type; }; -enum clock_event_state { - CLOCK_EVT_STATE_DETACHED = 0, - CLOCK_EVT_STATE_SHUTDOWN = 1, - CLOCK_EVT_STATE_PERIODIC = 2, - CLOCK_EVT_STATE_ONESHOT = 3, - CLOCK_EVT_STATE_ONESHOT_STOPPED = 4, +struct _fpx_sw_bytes { + __u32 magic1; + __u32 extended_size; + __u64 xfeatures; + __u32 xstate_size; + __u32 padding[7]; }; -struct clock_event_device { - void (*event_handler)(struct clock_event_device *); - int (*set_next_event)(long unsigned int, struct clock_event_device *); - int (*set_next_ktime)(ktime_t, struct clock_event_device *); - ktime_t next_event; - u64 max_delta_ns; - u64 min_delta_ns; - u32 mult; - u32 shift; - enum clock_event_state state_use_accessors; - unsigned int features; - long unsigned int retries; - int (*set_state_periodic)(struct clock_event_device *); - int (*set_state_oneshot)(struct clock_event_device *); - int (*set_state_oneshot_stopped)(struct clock_event_device *); - int (*set_state_shutdown)(struct clock_event_device *); - int (*tick_resume)(struct clock_event_device *); - void (*broadcast)(const struct cpumask *); - void (*suspend)(struct clock_event_device *); - void (*resume)(struct clock_event_device *); - long unsigned int min_delta_ticks; - long unsigned int max_delta_ticks; +struct _xmmreg { + __u32 element[4]; +}; + +struct _fpstate_32 { + __u32 cw; + __u32 sw; + __u32 tag; + __u32 ipoff; + __u32 cssel; + __u32 dataoff; + __u32 datasel; + struct _fpreg _st[8]; + __u16 status; + __u16 magic; + __u32 _fxsr_env[6]; + __u32 mxcsr; + __u32 reserved; + struct _fpxreg _fxsr_st[8]; + struct _xmmreg _xmm[8]; + union { + __u32 padding1[44]; + __u32 padding[44]; + }; + union { + __u32 padding2[12]; + struct _fpx_sw_bytes sw_reserved; + }; +}; + +typedef u32 compat_ulong_t; + +struct user_regset_view { const char *name; - int rating; - int irq; - int bound_on; - const struct cpumask *cpumask; - struct list_head list; - struct module *owner; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; + const struct user_regset *regsets; + unsigned int n; + u32 e_flags; + u16 e_machine; + u8 ei_osabi; }; -struct irq_affinity_desc { - struct cpumask mask; - unsigned int is_managed: 1; +enum x86_regset { + REGSET_GENERAL = 0, + REGSET_FP = 1, + REGSET_XFP = 2, + REGSET_IOPERM64 = 2, + REGSET_XSTATE = 3, + REGSET_TLS = 4, + REGSET_IOPERM32 = 5, }; -struct msi_msg { - u32 address_lo; - u32 address_hi; - u32 data; +struct pt_regs_offset { + const char *name; + int offset; }; -struct platform_msi_priv_data; +typedef bool (*stack_trace_consume_fn)(void *, long unsigned int, bool); -struct platform_msi_desc { - struct platform_msi_priv_data *msi_priv_data; - u16 msi_index; +struct stack_frame_user { + const void *next_fp; + long unsigned int ret_addr; }; -struct fsl_mc_msi_desc { - u16 msi_index; +enum cache_type { + CACHE_TYPE_NOCACHE = 0, + CACHE_TYPE_INST = 1, + CACHE_TYPE_DATA = 2, + CACHE_TYPE_SEPARATE = 3, + CACHE_TYPE_UNIFIED = 4, }; -struct ti_sci_inta_msi_desc { - u16 dev_index; +struct cacheinfo { + unsigned int id; + enum cache_type type; + unsigned int level; + unsigned int coherency_line_size; + unsigned int number_of_sets; + unsigned int ways_of_associativity; + unsigned int physical_line_partition; + unsigned int size; + cpumask_t shared_cpu_map; + unsigned int attributes; + void *fw_token; + bool disable_sysfs; + void *priv; }; -struct msi_desc { - struct list_head list; - unsigned int irq; - unsigned int nvec_used; - struct device *dev; - struct msi_msg msg; - struct irq_affinity_desc *affinity; - const void *iommu_cookie; - void (*write_msi_msg)(struct msi_desc *, void *); - void *write_msi_msg_data; - union { - struct { - u32 masked; - struct { - u8 is_msix: 1; - u8 multiple: 3; - u8 multi_cap: 3; - u8 maskbit: 1; - u8 is_64: 1; - u8 is_virtual: 1; - u16 entry_nr; - unsigned int default_irq; - } msi_attrib; - union { - u8 mask_pos; - void *mask_base; - }; - }; - struct platform_msi_desc platform; - struct fsl_mc_msi_desc fsl_mc; - struct ti_sci_inta_msi_desc inta; - }; +struct cpu_cacheinfo { + struct cacheinfo *info_list; + unsigned int num_levels; + unsigned int num_leaves; + bool cpu_map_populated; }; -struct irq_chip_regs { - long unsigned int enable; - long unsigned int disable; - long unsigned int mask; - long unsigned int ack; - long unsigned int eoi; - long unsigned int type; - long unsigned int polarity; +struct amd_l3_cache { + unsigned int indices; + u8 subcaches[4]; }; -struct irq_chip_type { - struct irq_chip chip; - struct irq_chip_regs regs; - irq_flow_handler_t handler; - u32 type; - u32 mask_cache_priv; - u32 *mask_cache; +struct threshold_block { + unsigned int block; + unsigned int bank; + unsigned int cpu; + u32 address; + u16 interrupt_enable; + bool interrupt_capable; + u16 threshold_limit; + struct kobject kobj; + struct list_head miscj; }; -struct irq_chip_generic { - raw_spinlock_t lock; - void *reg_base; - u32 (*reg_readl)(void *); - void (*reg_writel)(u32, void *); - void (*suspend)(struct irq_chip_generic *); - void (*resume)(struct irq_chip_generic *); - unsigned int irq_base; - unsigned int irq_cnt; - u32 mask_cache; - u32 type_cache; - u32 polarity_cache; - u32 wake_enabled; - u32 wake_active; - unsigned int num_ct; - void *private; - long unsigned int installed; - long unsigned int unused; - struct irq_domain *domain; - struct list_head list; - struct irq_chip_type chip_types[0]; +struct threshold_bank { + struct kobject *kobj; + struct threshold_block *blocks; + refcount_t cpus; }; -enum irq_gc_flags { - IRQ_GC_INIT_MASK_CACHE = 1, - IRQ_GC_INIT_NESTED_LOCK = 2, - IRQ_GC_MASK_CACHE_PER_TYPE = 4, - IRQ_GC_NO_MASK = 8, - IRQ_GC_BE_IO = 16, +struct amd_northbridge { + struct pci_dev *root; + struct pci_dev *misc; + struct pci_dev *link; + struct amd_l3_cache l3_cache; + struct threshold_bank *bank4; }; -struct irq_domain_chip_generic { - unsigned int irqs_per_chip; - unsigned int num_chips; - unsigned int irq_flags_to_clear; - unsigned int irq_flags_to_set; - enum irq_gc_flags gc_flags; - struct irq_chip_generic *gc[0]; +struct cpu_dev { + const char *c_vendor; + const char *c_ident[2]; + void (*c_early_init)(struct cpuinfo_x86 *); + void (*c_bsp_init)(struct cpuinfo_x86 *); + void (*c_init)(struct cpuinfo_x86 *); + void (*c_identify)(struct cpuinfo_x86 *); + void (*c_detect_tlb)(struct cpuinfo_x86 *); + int c_x86_vendor; }; -struct legacy_pic { - int nr_legacy_irqs; - struct irq_chip *chip; - void (*mask)(unsigned int); - void (*unmask)(unsigned int); - void (*mask_all)(); - void (*restore_mask)(); - void (*init)(int); - int (*probe)(); - int (*irq_pending)(unsigned int); - void (*make_irq)(unsigned int); +enum tsx_ctrl_states { + TSX_CTRL_ENABLE = 0, + TSX_CTRL_DISABLE = 1, + TSX_CTRL_NOT_SUPPORTED = 2, }; -enum refcount_saturation_type { - REFCOUNT_ADD_NOT_ZERO_OVF = 0, - REFCOUNT_ADD_OVF = 1, - REFCOUNT_ADD_UAF = 2, - REFCOUNT_SUB_UAF = 3, - REFCOUNT_DEC_LEAK = 4, +struct _cache_table { + unsigned char descriptor; + char cache_type; + short int size; }; -enum lockdown_reason { - LOCKDOWN_NONE = 0, - LOCKDOWN_MODULE_SIGNATURE = 1, - LOCKDOWN_DEV_MEM = 2, - LOCKDOWN_EFI_TEST = 3, - LOCKDOWN_KEXEC = 4, - LOCKDOWN_HIBERNATION = 5, - LOCKDOWN_PCI_ACCESS = 6, - LOCKDOWN_IOPORT = 7, - LOCKDOWN_MSR = 8, - LOCKDOWN_ACPI_TABLES = 9, - LOCKDOWN_PCMCIA_CIS = 10, - LOCKDOWN_TIOCSSERIAL = 11, - LOCKDOWN_MODULE_PARAMETERS = 12, - LOCKDOWN_MMIOTRACE = 13, - LOCKDOWN_DEBUGFS = 14, - LOCKDOWN_XMON_WR = 15, - LOCKDOWN_INTEGRITY_MAX = 16, - LOCKDOWN_KCORE = 17, - LOCKDOWN_KPROBES = 18, - LOCKDOWN_BPF_READ = 19, - LOCKDOWN_PERF = 20, - LOCKDOWN_TRACEFS = 21, - LOCKDOWN_XMON_RW = 22, - LOCKDOWN_CONFIDENTIALITY_MAX = 23, +enum _cache_type { + CTYPE_NULL = 0, + CTYPE_DATA = 1, + CTYPE_INST = 2, + CTYPE_UNIFIED = 3, +}; + +union _cpuid4_leaf_eax { + struct { + enum _cache_type type: 5; + unsigned int level: 3; + unsigned int is_self_initializing: 1; + unsigned int is_fully_associative: 1; + unsigned int reserved: 4; + unsigned int num_threads_sharing: 12; + unsigned int num_cores_on_die: 6; + } split; + u32 full; }; -enum lockdep_ok { - LOCKDEP_STILL_OK = 0, - LOCKDEP_NOW_UNRELIABLE = 1, +union _cpuid4_leaf_ebx { + struct { + unsigned int coherency_line_size: 12; + unsigned int physical_line_partition: 10; + unsigned int ways_of_associativity: 10; + } split; + u32 full; }; -typedef long unsigned int uintptr_t; - -typedef u64 uint64_t; +union _cpuid4_leaf_ecx { + struct { + unsigned int number_of_sets: 32; + } split; + u32 full; +}; -struct trace_event_raw_nmi_handler { - struct trace_entry ent; - void *handler; - s64 delta_ns; - int handled; - char __data[0]; +struct _cpuid4_info_regs { + union _cpuid4_leaf_eax eax; + union _cpuid4_leaf_ebx ebx; + union _cpuid4_leaf_ecx ecx; + unsigned int id; + long unsigned int size; + struct amd_northbridge *nb; }; -struct trace_event_data_offsets_nmi_handler {}; +union l1_cache { + struct { + unsigned int line_size: 8; + unsigned int lines_per_tag: 8; + unsigned int assoc: 8; + unsigned int size_in_kb: 8; + }; + unsigned int val; +}; -struct nmi_desc { - raw_spinlock_t lock; - struct list_head head; +union l2_cache { + struct { + unsigned int line_size: 8; + unsigned int lines_per_tag: 4; + unsigned int assoc: 4; + unsigned int size_in_kb: 16; + }; + unsigned int val; }; -struct nmi_stats { - unsigned int normal; - unsigned int unknown; - unsigned int external; - unsigned int swallow; +union l3_cache { + struct { + unsigned int line_size: 8; + unsigned int lines_per_tag: 4; + unsigned int assoc: 4; + unsigned int res: 2; + unsigned int size_encoded: 14; + }; + unsigned int val; }; -enum nmi_states { - NMI_NOT_RUNNING = 0, - NMI_EXECUTING = 1, - NMI_LATCHED = 2, +struct cpuid_bit { + u16 feature; + u8 reg; + u8 bit; + u32 level; + u32 sub_leaf; }; -typedef unsigned int pao_T_____2; +enum cpuid_leafs { + CPUID_1_EDX = 0, + CPUID_8000_0001_EDX = 1, + CPUID_8086_0001_EDX = 2, + CPUID_LNX_1 = 3, + CPUID_1_ECX = 4, + CPUID_C000_0001_EDX = 5, + CPUID_8000_0001_ECX = 6, + CPUID_LNX_2 = 7, + CPUID_LNX_3 = 8, + CPUID_7_0_EBX = 9, + CPUID_D_1_EAX = 10, + CPUID_LNX_4 = 11, + CPUID_7_1_EAX = 12, + CPUID_8000_0008_EBX = 13, + CPUID_6_EAX = 14, + CPUID_8000_000A_EDX = 15, + CPUID_7_ECX = 16, + CPUID_8000_0007_EBX = 17, + CPUID_7_EDX = 18, +}; -typedef enum nmi_states pto_T_____2; +struct cpuid_dependent_feature { + u32 feature; + u32 level; +}; -typedef int pto_T_____3; +typedef u32 pao_T_____3; -enum { - DESC_TSS = 9, - DESC_LDT = 2, - DESCTYPE_S = 16, +enum spectre_v2_mitigation { + SPECTRE_V2_NONE = 0, + SPECTRE_V2_RETPOLINE_GENERIC = 1, + SPECTRE_V2_RETPOLINE_AMD = 2, + SPECTRE_V2_IBRS_ENHANCED = 3, }; -struct ldttss_desc { - u16 limit0; - u16 base0; - u16 base1: 8; - u16 type: 5; - u16 dpl: 2; - u16 p: 1; - u16 limit1: 4; - u16 zero0: 3; - u16 g: 1; - u16 base2: 8; - u32 base3; - u32 zero1; +enum spectre_v2_user_mitigation { + SPECTRE_V2_USER_NONE = 0, + SPECTRE_V2_USER_STRICT = 1, + SPECTRE_V2_USER_STRICT_PREFERRED = 2, + SPECTRE_V2_USER_PRCTL = 3, + SPECTRE_V2_USER_SECCOMP = 4, }; -typedef struct ldttss_desc ldt_desc; +enum ssb_mitigation { + SPEC_STORE_BYPASS_NONE = 0, + SPEC_STORE_BYPASS_DISABLE = 1, + SPEC_STORE_BYPASS_PRCTL = 2, + SPEC_STORE_BYPASS_SECCOMP = 3, +}; -struct user_desc { - unsigned int entry_number; - unsigned int base_addr; - unsigned int limit; - unsigned int seg_32bit: 1; - unsigned int contents: 2; - unsigned int read_exec_only: 1; - unsigned int limit_in_pages: 1; - unsigned int seg_not_present: 1; - unsigned int useable: 1; - unsigned int lm: 1; +enum mds_mitigations { + MDS_MITIGATION_OFF = 0, + MDS_MITIGATION_FULL = 1, + MDS_MITIGATION_VMWERV = 2, }; -struct mmu_gather_batch { - struct mmu_gather_batch *next; - unsigned int nr; - unsigned int max; - struct page *pages[0]; +enum taa_mitigations { + TAA_MITIGATION_OFF = 0, + TAA_MITIGATION_UCODE_NEEDED = 1, + TAA_MITIGATION_VERW = 2, + TAA_MITIGATION_TSX_DISABLED = 3, }; -struct mmu_gather { - struct mm_struct *mm; - long unsigned int start; - long unsigned int end; - unsigned int fullmm: 1; - unsigned int need_flush_all: 1; - unsigned int freed_tables: 1; - unsigned int cleared_ptes: 1; - unsigned int cleared_pmds: 1; - unsigned int cleared_puds: 1; - unsigned int cleared_p4ds: 1; - unsigned int vma_exec: 1; - unsigned int vma_huge: 1; - unsigned int batch_count; - struct mmu_gather_batch *active; - struct mmu_gather_batch local; - struct page *__pages[8]; +enum vmx_l1d_flush_state { + VMENTER_L1D_FLUSH_AUTO = 0, + VMENTER_L1D_FLUSH_NEVER = 1, + VMENTER_L1D_FLUSH_COND = 2, + VMENTER_L1D_FLUSH_ALWAYS = 3, + VMENTER_L1D_FLUSH_EPT_DISABLED = 4, + VMENTER_L1D_FLUSH_NOT_REQUIRED = 5, }; -struct setup_data { - __u64 next; - __u32 type; - __u32 len; - __u8 data[0]; +enum x86_hypervisor_type { + X86_HYPER_NATIVE = 0, + X86_HYPER_VMWARE = 1, + X86_HYPER_MS_HYPERV = 2, + X86_HYPER_XEN_PV = 3, + X86_HYPER_XEN_HVM = 4, + X86_HYPER_KVM = 5, + X86_HYPER_JAILHOUSE = 6, + X86_HYPER_ACRN = 7, }; -struct setup_indirect { - __u32 type; - __u32 reserved; - __u64 len; - __u64 addr; +enum spectre_v1_mitigation { + SPECTRE_V1_MITIGATION_NONE = 0, + SPECTRE_V1_MITIGATION_AUTO = 1, }; -struct plist_head { - struct list_head node_list; +enum spectre_v2_mitigation_cmd { + SPECTRE_V2_CMD_NONE = 0, + SPECTRE_V2_CMD_AUTO = 1, + SPECTRE_V2_CMD_FORCE = 2, + SPECTRE_V2_CMD_RETPOLINE = 3, + SPECTRE_V2_CMD_RETPOLINE_GENERIC = 4, + SPECTRE_V2_CMD_RETPOLINE_AMD = 5, }; -struct atomic_notifier_head { - spinlock_t lock; - struct notifier_block *head; +enum spectre_v2_user_cmd { + SPECTRE_V2_USER_CMD_NONE = 0, + SPECTRE_V2_USER_CMD_AUTO = 1, + SPECTRE_V2_USER_CMD_FORCE = 2, + SPECTRE_V2_USER_CMD_PRCTL = 3, + SPECTRE_V2_USER_CMD_PRCTL_IBPB = 4, + SPECTRE_V2_USER_CMD_SECCOMP = 5, + SPECTRE_V2_USER_CMD_SECCOMP_IBPB = 6, }; -struct blocking_notifier_head { - struct rw_semaphore rwsem; - struct notifier_block *head; +enum ssb_mitigation_cmd { + SPEC_STORE_BYPASS_CMD_NONE = 0, + SPEC_STORE_BYPASS_CMD_AUTO = 1, + SPEC_STORE_BYPASS_CMD_ON = 2, + SPEC_STORE_BYPASS_CMD_PRCTL = 3, + SPEC_STORE_BYPASS_CMD_SECCOMP = 4, }; -enum pm_qos_type { - PM_QOS_UNITIALIZED = 0, - PM_QOS_MAX = 1, - PM_QOS_MIN = 2, - PM_QOS_SUM = 3, +enum hk_flags { + HK_FLAG_TIMER = 1, + HK_FLAG_RCU = 2, + HK_FLAG_MISC = 4, + HK_FLAG_SCHED = 8, + HK_FLAG_TICK = 16, + HK_FLAG_DOMAIN = 32, + HK_FLAG_WQ = 64, }; -struct pm_qos_constraints { - struct plist_head list; - s32 target_value; - s32 default_value; - s32 no_constraint_value; - enum pm_qos_type type; - struct blocking_notifier_head *notifiers; +struct aperfmperf_sample { + unsigned int khz; + ktime_t time; + u64 aperf; + u64 mperf; }; -struct freq_constraints { - struct pm_qos_constraints min_freq; - struct blocking_notifier_head min_freq_notifiers; - struct pm_qos_constraints max_freq; - struct blocking_notifier_head max_freq_notifiers; +struct cpuid_dep { + unsigned int feature; + unsigned int depends; }; -struct pm_qos_flags { - struct list_head list; - s32 effective_flags; +struct _tlb_table { + unsigned char descriptor; + char tlb_type; + unsigned int entries; + char info[128]; }; -struct dev_pm_qos_request; +struct sku_microcode { + u8 model; + u8 stepping; + u32 microcode; +}; -struct dev_pm_qos { - struct pm_qos_constraints resume_latency; - struct pm_qos_constraints latency_tolerance; - struct freq_constraints freq; - struct pm_qos_flags flags; - struct dev_pm_qos_request *resume_latency_req; - struct dev_pm_qos_request *latency_tolerance_req; - struct dev_pm_qos_request *flags_req; +struct cpuid_regs { + u32 eax; + u32 ebx; + u32 ecx; + u32 edx; }; -enum con_scroll { - SM_UP = 0, - SM_DOWN = 1, +enum pconfig_target { + INVALID_TARGET = 0, + MKTME_TARGET = 1, + PCONFIG_TARGET_NR = 2, }; -struct vc_data; +enum { + PCONFIG_CPUID_SUBLEAF_INVALID = 0, + PCONFIG_CPUID_SUBLEAF_TARGETID = 1, +}; -struct console_font; +typedef u8 pto_T_____10; -struct consw { - struct module *owner; - const char * (*con_startup)(); - void (*con_init)(struct vc_data *, int); - void (*con_deinit)(struct vc_data *); - void (*con_clear)(struct vc_data *, int, int, int, int); - void (*con_putc)(struct vc_data *, int, int, int); - void (*con_putcs)(struct vc_data *, const short unsigned int *, int, int, int); - void (*con_cursor)(struct vc_data *, int); - bool (*con_scroll)(struct vc_data *, unsigned int, unsigned int, enum con_scroll, unsigned int); - int (*con_switch)(struct vc_data *); - int (*con_blank)(struct vc_data *, int, int); - int (*con_font_set)(struct vc_data *, struct console_font *, unsigned int); - int (*con_font_get)(struct vc_data *, struct console_font *); - int (*con_font_default)(struct vc_data *, struct console_font *, char *); - int (*con_font_copy)(struct vc_data *, int); - int (*con_resize)(struct vc_data *, unsigned int, unsigned int, unsigned int); - void (*con_set_palette)(struct vc_data *, const unsigned char *); - void (*con_scrolldelta)(struct vc_data *, int); - int (*con_set_origin)(struct vc_data *); - void (*con_save_screen)(struct vc_data *); - u8 (*con_build_attr)(struct vc_data *, u8, u8, u8, u8, u8, u8); - void (*con_invert_region)(struct vc_data *, u16 *, int); - u16 * (*con_screen_pos)(struct vc_data *, int); - long unsigned int (*con_getxy)(struct vc_data *, long unsigned int, int *, int *); - void (*con_flush_scrollback)(struct vc_data *); - int (*con_debug_enter)(struct vc_data *); - int (*con_debug_leave)(struct vc_data *); +enum mf_flags { + MF_COUNT_INCREASED = 1, + MF_ACTION_REQUIRED = 2, + MF_MUST_KILL = 4, + MF_SOFT_OFFLINE = 8, }; -enum efi_secureboot_mode { - efi_secureboot_mode_unset = 0, - efi_secureboot_mode_unknown = 1, - efi_secureboot_mode_disabled = 2, - efi_secureboot_mode_enabled = 3, +enum mce_notifier_prios { + MCE_PRIO_FIRST = 2147483647, + MCE_PRIO_SRAO = 2147483646, + MCE_PRIO_EXTLOG = 2147483645, + MCE_PRIO_NFIT = 2147483644, + MCE_PRIO_EDAC = 2147483643, + MCE_PRIO_MCELOG = 1, + MCE_PRIO_LOWEST = 0, }; -enum xen_domain_type { - XEN_NATIVE = 0, - XEN_PV_DOMAIN = 1, - XEN_HVM_DOMAIN = 2, +enum mcp_flags { + MCP_TIMESTAMP = 1, + MCP_UC = 2, + MCP_DONTLOG = 4, }; -struct pm_qos_flags_request { - struct list_head node; - s32 flags; +enum severity_level { + MCE_NO_SEVERITY = 0, + MCE_DEFERRED_SEVERITY = 1, + MCE_UCNA_SEVERITY = 1, + MCE_KEEP_SEVERITY = 2, + MCE_SOME_SEVERITY = 3, + MCE_AO_SEVERITY = 4, + MCE_UC_SEVERITY = 5, + MCE_AR_SEVERITY = 6, + MCE_PANIC_SEVERITY = 7, }; -enum freq_qos_req_type { - FREQ_QOS_MIN = 1, - FREQ_QOS_MAX = 2, +struct mce_evt_llist { + struct llist_node llnode; + struct mce mce; }; -struct freq_qos_request { - enum freq_qos_req_type type; - struct plist_node pnode; - struct freq_constraints *qos; +struct mca_config { + bool dont_log_ce; + bool cmci_disabled; + bool ignore_ce; + __u64 lmce_disabled: 1; + __u64 disabled: 1; + __u64 ser: 1; + __u64 recovery: 1; + __u64 bios_cmci_threshold: 1; + long: 35; + __u64 __reserved: 59; + s8 bootlog; + int tolerant; + int monarch_timeout; + int panic_timeout; + u32 rip_msr; }; -enum dev_pm_qos_req_type { - DEV_PM_QOS_RESUME_LATENCY = 1, - DEV_PM_QOS_LATENCY_TOLERANCE = 2, - DEV_PM_QOS_MIN_FREQUENCY = 3, - DEV_PM_QOS_MAX_FREQUENCY = 4, - DEV_PM_QOS_FLAGS = 5, +struct mce_vendor_flags { + __u64 overflow_recov: 1; + __u64 succor: 1; + __u64 smca: 1; + __u64 __reserved_0: 61; }; -struct dev_pm_qos_request { - enum dev_pm_qos_req_type type; - union { - struct plist_node pnode; - struct pm_qos_flags_request flr; - struct freq_qos_request freq; - } data; - struct device *dev; +struct mca_msr_regs { + u32 (*ctl)(int); + u32 (*status)(int); + u32 (*addr)(int); + u32 (*misc)(int); }; -enum e820_type { - E820_TYPE_RAM = 1, - E820_TYPE_RESERVED = 2, - E820_TYPE_ACPI = 3, - E820_TYPE_NVS = 4, - E820_TYPE_UNUSABLE = 5, - E820_TYPE_PMEM = 7, - E820_TYPE_PRAM = 12, - E820_TYPE_SOFT_RESERVED = 4026531839, - E820_TYPE_RESERVED_KERN = 128, +struct trace_event_raw_mce_record { + struct trace_entry ent; + u64 mcgcap; + u64 mcgstatus; + u64 status; + u64 addr; + u64 misc; + u64 synd; + u64 ipid; + u64 ip; + u64 tsc; + u64 walltime; + u32 cpu; + u32 cpuid; + u32 apicid; + u32 socketid; + u8 cs; + u8 bank; + u8 cpuvendor; + char __data[0]; }; -struct e820_entry { - u64 addr; - u64 size; - enum e820_type type; -} __attribute__((packed)); +struct trace_event_data_offsets_mce_record {}; -struct e820_table { - __u32 nr_entries; - struct e820_entry entries[320]; -} __attribute__((packed)); +typedef void (*btf_trace_mce_record)(void *, struct mce *); -struct x86_cpuinit_ops { - void (*setup_percpu_clockev)(); - void (*early_percpu_clock_init)(); - void (*fixup_cpu_id)(struct cpuinfo_x86 *, int); +struct mce_bank { + u64 ctl; + bool init; }; -struct x86_msi_ops { - int (*setup_msi_irqs)(struct pci_dev *, int, int); - void (*teardown_msi_irq)(unsigned int); - void (*teardown_msi_irqs)(struct pci_dev *); - void (*restore_msi_irqs)(struct pci_dev *); +struct mce_bank_dev { + struct device_attribute attr; + char attrname[16]; + u8 bank; }; -struct msi_controller { - struct module *owner; - struct device *dev; - struct device_node *of_node; - struct list_head list; - int (*setup_irq)(struct msi_controller *, struct pci_dev *, struct msi_desc *); - int (*setup_irqs)(struct msi_controller *, struct pci_dev *, int, int); - void (*teardown_irq)(struct msi_controller *, unsigned int); +typedef unsigned int pto_T_____11; + +enum context { + IN_KERNEL = 1, + IN_USER = 2, + IN_KERNEL_RECOV = 3, }; -enum jump_label_type { - JUMP_LABEL_NOP = 0, - JUMP_LABEL_JMP = 1, +enum ser { + SER_REQUIRED = 1, + NO_SER = 2, +}; + +enum exception { + EXCP_CONTEXT = 1, + NO_EXCP = 2, }; -struct text_poke_loc { - void *addr; - int len; - s32 rel32; - u8 opcode; - u8 text[5]; +struct severity { + u64 mask; + u64 result; + unsigned char sev; + unsigned char mcgmask; + unsigned char mcgres; + unsigned char ser; + unsigned char context; + unsigned char excp; + unsigned char covered; + char *msg; }; -union jump_code_union { - char code[5]; - struct { - char jump; - int offset; - } __attribute__((packed)); +struct gen_pool; + +typedef long unsigned int (*genpool_algo_t)(long unsigned int *, long unsigned int, long unsigned int, unsigned int, void *, struct gen_pool *, long unsigned int); + +struct gen_pool { + spinlock_t lock; + struct list_head chunks; + int min_alloc_order; + genpool_algo_t algo; + void *data; + const char *name; }; enum { - JL_STATE_START = 0, - JL_STATE_NO_UPDATE = 1, - JL_STATE_UPDATE = 2, + CMCI_STORM_NONE = 0, + CMCI_STORM_ACTIVE = 1, + CMCI_STORM_SUBSIDED = 2, }; -struct vm_unmapped_area_info { - long unsigned int flags; - long unsigned int length; - long unsigned int low_limit; - long unsigned int high_limit; - long unsigned int align_mask; - long unsigned int align_offset; +enum kobject_action { + KOBJ_ADD = 0, + KOBJ_REMOVE = 1, + KOBJ_CHANGE = 2, + KOBJ_MOVE = 3, + KOBJ_ONLINE = 4, + KOBJ_OFFLINE = 5, + KOBJ_BIND = 6, + KOBJ_UNBIND = 7, + KOBJ_MAX = 8, }; -enum align_flags { - ALIGN_VA_32 = 1, - ALIGN_VA_64 = 2, +enum smca_bank_types { + SMCA_LS = 0, + SMCA_IF = 1, + SMCA_L2_CACHE = 2, + SMCA_DE = 3, + SMCA_RESERVED = 4, + SMCA_EX = 5, + SMCA_FP = 6, + SMCA_L3_CACHE = 7, + SMCA_CS = 8, + SMCA_CS_V2 = 9, + SMCA_PIE = 10, + SMCA_UMC = 11, + SMCA_PB = 12, + SMCA_PSP = 13, + SMCA_PSP_V2 = 14, + SMCA_SMU = 15, + SMCA_SMU_V2 = 16, + SMCA_MP5 = 17, + SMCA_NBIO = 18, + SMCA_PCIE = 19, + N_SMCA_BANK_TYPES = 20, }; -struct va_alignment { - int flags; - long unsigned int mask; - long unsigned int bits; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +struct smca_bank_name { + const char *name; + const char *long_name; }; -enum { - MEMREMAP_WB = 1, - MEMREMAP_WT = 2, - MEMREMAP_WC = 4, - MEMREMAP_ENC = 8, - MEMREMAP_DEC = 16, +struct thresh_restart { + struct threshold_block *b; + int reset; + int set_lvt_off; + int lvt_off; + u16 old_limit; }; -typedef void (*swap_func_t)(void *, void *, int); - -typedef int (*cmp_func_t)(const void *, const void *); +struct threshold_attr { + struct attribute attr; + ssize_t (*show)(struct threshold_block *, char *); + ssize_t (*store)(struct threshold_block *, const char *, size_t); +}; -enum { - IORES_DESC_NONE = 0, - IORES_DESC_CRASH_KERNEL = 1, - IORES_DESC_ACPI_TABLES = 2, - IORES_DESC_ACPI_NV_STORAGE = 3, - IORES_DESC_PERSISTENT_MEMORY = 4, - IORES_DESC_PERSISTENT_MEMORY_LEGACY = 5, - IORES_DESC_DEVICE_PRIVATE_MEMORY = 6, - IORES_DESC_RESERVED = 7, - IORES_DESC_SOFT_RESERVED = 8, +struct _thermal_state { + u64 next_check; + u64 last_interrupt_time; + struct delayed_work therm_work; + long unsigned int count; + long unsigned int last_count; + long unsigned int max_time_ms; + long unsigned int total_time_ms; + bool rate_control_active; + bool new_event; + u8 level; + u8 sample_index; + u8 sample_count; + u8 average; + u8 baseline_temp; + u8 temp_samples[3]; }; -struct change_member { - struct e820_entry *entry; - long long unsigned int addr; +struct thermal_state { + struct _thermal_state core_throttle; + struct _thermal_state core_power_limit; + struct _thermal_state package_throttle; + struct _thermal_state package_power_limit; + struct _thermal_state core_thresh0; + struct _thermal_state core_thresh1; + struct _thermal_state pkg_thresh0; + struct _thermal_state pkg_thresh1; }; -struct iommu_fwspec { - const struct iommu_ops *ops; - struct fwnode_handle *iommu_fwnode; - void *iommu_priv; - u32 flags; - unsigned int num_ids; - u32 ids[1]; +struct mtrr_var_range { + __u32 base_lo; + __u32 base_hi; + __u32 mask_lo; + __u32 mask_hi; }; -struct iommu_fault_param; +typedef __u8 mtrr_type; -struct iommu_param { - struct mutex lock; - struct iommu_fault_param *fault_param; +struct mtrr_state_type { + struct mtrr_var_range var_ranges[256]; + mtrr_type fixed_ranges[88]; + unsigned char enabled; + unsigned char have_fixed; + mtrr_type def_type; }; -struct of_phandle_args { - struct device_node *np; - int args_count; - uint32_t args[16]; +struct mtrr_ops { + u32 vendor; + u32 use_intel_if; + void (*set)(unsigned int, long unsigned int, long unsigned int, mtrr_type); + void (*set_all)(); + void (*get)(unsigned int, long unsigned int *, long unsigned int *, mtrr_type *); + int (*get_free_region)(long unsigned int, long unsigned int, int); + int (*validate_add_page)(long unsigned int, long unsigned int, unsigned int); + int (*have_wrcomb)(); }; -struct iommu_fault_unrecoverable { - __u32 reason; - __u32 flags; - __u32 pasid; - __u32 perm; - __u64 addr; - __u64 fetch_addr; +struct set_mtrr_data { + long unsigned int smp_base; + long unsigned int smp_size; + unsigned int smp_reg; + mtrr_type smp_type; }; -struct iommu_fault_page_request { - __u32 flags; - __u32 pasid; - __u32 grpid; - __u32 perm; - __u64 addr; - __u64 private_data[2]; +struct mtrr_value { + mtrr_type ltype; + long unsigned int lbase; + long unsigned int lsize; }; -struct iommu_fault { +struct mtrr_sentry { + __u64 base; + __u32 size; __u32 type; - __u32 padding; - union { - struct iommu_fault_unrecoverable event; - struct iommu_fault_page_request prm; - __u8 padding2[56]; - }; }; -struct iommu_page_response { - __u32 version; - __u32 flags; - __u32 pasid; - __u32 grpid; - __u32 code; +struct mtrr_gentry { + __u64 base; + __u32 size; + __u32 regnum; + __u32 type; + __u32 _pad; }; -struct iommu_inv_addr_info { - __u32 flags; - __u32 archid; - __u64 pasid; - __u64 addr; - __u64 granule_size; - __u64 nb_granules; +typedef u32 compat_uint_t; + +struct mtrr_sentry32 { + compat_ulong_t base; + compat_uint_t size; + compat_uint_t type; }; -struct iommu_inv_pasid_info { - __u32 flags; - __u32 archid; - __u64 pasid; +struct mtrr_gentry32 { + compat_ulong_t regnum; + compat_uint_t base; + compat_uint_t size; + compat_uint_t type; }; -struct iommu_cache_invalidate_info { - __u32 version; - __u8 cache; - __u8 granularity; - __u8 padding[2]; - union { - struct iommu_inv_pasid_info pasid_info; - struct iommu_inv_addr_info addr_info; - }; +struct fixed_range_block { + int base_msr; + int ranges; }; -struct iommu_gpasid_bind_data_vtd { - __u64 flags; - __u32 pat; - __u32 emt; +struct var_mtrr_range_state { + long unsigned int base_pfn; + long unsigned int size_pfn; + mtrr_type type; }; -struct iommu_gpasid_bind_data { - __u32 version; - __u32 format; - __u64 flags; - __u64 gpgd; - __u64 hpasid; - __u64 gpasid; - __u32 addr_width; - __u8 padding[12]; - union { - struct iommu_gpasid_bind_data_vtd vtd; - }; +struct subsys_interface { + const char *name; + struct bus_type *subsys; + struct list_head node; + int (*add_dev)(struct device *, struct subsys_interface *); + void (*remove_dev)(struct device *, struct subsys_interface *); }; -typedef int (*iommu_fault_handler_t)(struct iommu_domain *, struct device *, long unsigned int, int, void *); +struct property_entry; -struct iommu_domain_geometry { - dma_addr_t aperture_start; - dma_addr_t aperture_end; - bool force_aperture; +struct platform_device_info { + struct device *parent; + struct fwnode_handle *fwnode; + bool of_node_reused; + const char *name; + int id; + const struct resource *res; + unsigned int num_res; + const void *data; + size_t size_data; + u64 dma_mask; + struct property_entry *properties; }; -struct iommu_domain { - unsigned int type; - const struct iommu_ops *ops; - long unsigned int pgsize_bitmap; - iommu_fault_handler_t handler; - void *handler_token; - struct iommu_domain_geometry geometry; - void *iova_cookie; +struct builtin_fw { + char *name; + void *data; + long unsigned int size; }; -typedef int (*iommu_mm_exit_handler_t)(struct device *, struct iommu_sva *, void *); +struct cpio_data { + void *data; + size_t size; + char name[18]; +}; -struct iommu_sva_ops; +enum ucode_state { + UCODE_OK = 0, + UCODE_NEW = 1, + UCODE_UPDATED = 2, + UCODE_NFOUND = 3, + UCODE_ERROR = 4, +}; -struct iommu_sva { - struct device *dev; - const struct iommu_sva_ops *ops; +struct microcode_ops { + enum ucode_state (*request_microcode_user)(int, const void *, size_t); + enum ucode_state (*request_microcode_fw)(int, struct device *, bool); + void (*microcode_fini_cpu)(int); + enum ucode_state (*apply_microcode)(int); + int (*collect_cpu_info)(int, struct cpu_signature *); }; -typedef int (*iommu_dev_fault_handler_t)(struct iommu_fault *, void *); +struct cpu_info_ctx { + struct cpu_signature *cpu_sig; + int err; +}; -enum iommu_resv_type { - IOMMU_RESV_DIRECT = 0, - IOMMU_RESV_DIRECT_RELAXABLE = 1, - IOMMU_RESV_RESERVED = 2, - IOMMU_RESV_MSI = 3, - IOMMU_RESV_SW_MSI = 4, +struct firmware { + size_t size; + const u8 *data; + struct page **pages; + void *priv; }; -struct iommu_resv_region { - struct list_head list; - phys_addr_t start; - size_t length; - int prot; - enum iommu_resv_type type; +struct ucode_patch { + struct list_head plist; + void *data; + u32 patch_id; + u16 equiv_cpu; }; -struct iommu_sva_ops { - iommu_mm_exit_handler_t mm_exit; +struct microcode_header_intel { + unsigned int hdrver; + unsigned int rev; + unsigned int date; + unsigned int sig; + unsigned int cksum; + unsigned int ldrver; + unsigned int pf; + unsigned int datasize; + unsigned int totalsize; + unsigned int reserved[3]; }; -struct iommu_iotlb_gather { - long unsigned int start; - long unsigned int end; - size_t pgsize; +struct microcode_intel { + struct microcode_header_intel hdr; + unsigned int bits[0]; }; -struct iommu_fault_event { - struct iommu_fault fault; - struct list_head list; +struct extended_signature { + unsigned int sig; + unsigned int pf; + unsigned int cksum; }; -struct iommu_fault_param { - iommu_dev_fault_handler_t handler; - void *data; - struct list_head faults; - struct mutex lock; +struct extended_sigtable { + unsigned int count; + unsigned int cksum; + unsigned int reserved[3]; + struct extended_signature sigs[0]; }; -struct iommu_table_entry { - initcall_t detect; - initcall_t depend; - void (*early_init)(); - void (*late_init)(); - int flags; +struct equiv_cpu_entry { + u32 installed_cpu; + u32 fixed_errata_mask; + u32 fixed_errata_compare; + u16 equiv_cpu; + u16 res; }; -enum dmi_field { - DMI_NONE = 0, - DMI_BIOS_VENDOR = 1, - DMI_BIOS_VERSION = 2, - DMI_BIOS_DATE = 3, - DMI_SYS_VENDOR = 4, - DMI_PRODUCT_NAME = 5, - DMI_PRODUCT_VERSION = 6, - DMI_PRODUCT_SERIAL = 7, - DMI_PRODUCT_UUID = 8, - DMI_PRODUCT_SKU = 9, - DMI_PRODUCT_FAMILY = 10, - DMI_BOARD_VENDOR = 11, - DMI_BOARD_NAME = 12, - DMI_BOARD_VERSION = 13, - DMI_BOARD_SERIAL = 14, - DMI_BOARD_ASSET_TAG = 15, - DMI_CHASSIS_VENDOR = 16, - DMI_CHASSIS_TYPE = 17, - DMI_CHASSIS_VERSION = 18, - DMI_CHASSIS_SERIAL = 19, - DMI_CHASSIS_ASSET_TAG = 20, - DMI_STRING_MAX = 21, - DMI_OEM_STRING = 22, +struct microcode_header_amd { + u32 data_code; + u32 patch_id; + u16 mc_patch_data_id; + u8 mc_patch_data_len; + u8 init_flag; + u32 mc_patch_data_checksum; + u32 nb_dev_id; + u32 sb_dev_id; + u16 processor_rev_id; + u8 nb_rev_id; + u8 sb_rev_id; + u8 bios_api_rev; + u8 reserved1[3]; + u32 match_reg[8]; }; -enum { - NONE_FORCE_HPET_RESUME = 0, - OLD_ICH_FORCE_HPET_RESUME = 1, - ICH_FORCE_HPET_RESUME = 2, - VT8237_FORCE_HPET_RESUME = 3, - NVIDIA_FORCE_HPET_RESUME = 4, - ATI_FORCE_HPET_RESUME = 5, +struct microcode_amd { + struct microcode_header_amd hdr; + unsigned int mpb[0]; }; -struct cpu { - int node_id; - int hotpluggable; - struct device dev; +struct equiv_cpu_table { + unsigned int num_entries; + struct equiv_cpu_entry *entry; }; -struct x86_cpu { - struct cpu cpu; +struct cont_desc { + struct microcode_amd *mc; + u32 cpuid_1_eax; + u32 psize; + u8 *data; + size_t size; +}; + +enum mp_irq_source_types { + mp_INT = 0, + mp_NMI = 1, + mp_SMI = 2, + mp_ExtINT = 3, +}; + +struct IO_APIC_route_entry { + __u32 vector: 8; + __u32 delivery_mode: 3; + __u32 dest_mode: 1; + __u32 delivery_status: 1; + __u32 polarity: 1; + __u32 irr: 1; + __u32 trigger: 1; + __u32 mask: 1; + __u32 __reserved_2: 15; + __u32 __reserved_3: 24; + __u32 dest: 8; }; -struct debugfs_blob_wrapper { - void *data; - long unsigned int size; -}; +typedef u64 acpi_physical_address; + +typedef u32 acpi_status; + +typedef void *acpi_handle; + +typedef u8 acpi_adr_space_type; -struct setup_data_node { - u64 paddr; - u32 type; - u32 len; +struct acpi_subtable_header { + u8 type; + u8 length; }; -struct die_args { - struct pt_regs *regs; - const char *str; - long int err; - int trapnr; - int signr; +struct acpi_table_bgrt { + struct acpi_table_header header; + u16 version; + u8 status; + u8 image_type; + u64 image_address; + u32 image_offset_x; + u32 image_offset_y; }; -typedef struct { - struct mm_struct *mm; -} temp_mm_state_t; - -struct smp_alt_module { - struct module *mod; - char *name; - const s32 *locks; - const s32 *locks_end; - u8 *text; - u8 *text_end; - struct list_head next; +struct acpi_table_boot { + struct acpi_table_header header; + u8 cmos_index; + u8 reserved[3]; }; -struct bp_patching_desc { - struct text_poke_loc *vec; - int nr_entries; +struct acpi_hmat_structure { + u16 type; + u16 reserved; + u32 length; }; -struct paravirt_patch_site; +struct acpi_table_hpet { + struct acpi_table_header header; + u32 id; + struct acpi_generic_address address; + u8 sequence; + u16 minimum_tick; + u8 flags; +} __attribute__((packed)); -struct user_i387_struct { - short unsigned int cwd; - short unsigned int swd; - short unsigned int twd; - short unsigned int fop; - __u64 rip; - __u64 rdp; - __u32 mxcsr; - __u32 mxcsr_mask; - __u32 st_space[32]; - __u32 xmm_space[64]; - __u32 padding[24]; +struct acpi_table_madt { + struct acpi_table_header header; + u32 address; + u32 flags; }; -struct user_regs_struct { - long unsigned int r15; - long unsigned int r14; - long unsigned int r13; - long unsigned int r12; - long unsigned int bp; - long unsigned int bx; - long unsigned int r11; - long unsigned int r10; - long unsigned int r9; - long unsigned int r8; - long unsigned int ax; - long unsigned int cx; - long unsigned int dx; - long unsigned int si; - long unsigned int di; - long unsigned int orig_ax; - long unsigned int ip; - long unsigned int cs; - long unsigned int flags; - long unsigned int sp; - long unsigned int ss; - long unsigned int fs_base; - long unsigned int gs_base; - long unsigned int ds; - long unsigned int es; - long unsigned int fs; - long unsigned int gs; +enum acpi_madt_type { + ACPI_MADT_TYPE_LOCAL_APIC = 0, + ACPI_MADT_TYPE_IO_APIC = 1, + ACPI_MADT_TYPE_INTERRUPT_OVERRIDE = 2, + ACPI_MADT_TYPE_NMI_SOURCE = 3, + ACPI_MADT_TYPE_LOCAL_APIC_NMI = 4, + ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE = 5, + ACPI_MADT_TYPE_IO_SAPIC = 6, + ACPI_MADT_TYPE_LOCAL_SAPIC = 7, + ACPI_MADT_TYPE_INTERRUPT_SOURCE = 8, + ACPI_MADT_TYPE_LOCAL_X2APIC = 9, + ACPI_MADT_TYPE_LOCAL_X2APIC_NMI = 10, + ACPI_MADT_TYPE_GENERIC_INTERRUPT = 11, + ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR = 12, + ACPI_MADT_TYPE_GENERIC_MSI_FRAME = 13, + ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR = 14, + ACPI_MADT_TYPE_GENERIC_TRANSLATOR = 15, + ACPI_MADT_TYPE_RESERVED = 16, }; -struct user { - struct user_regs_struct regs; - int u_fpvalid; - int pad0; - struct user_i387_struct i387; - long unsigned int u_tsize; - long unsigned int u_dsize; - long unsigned int u_ssize; - long unsigned int start_code; - long unsigned int start_stack; - long int signal; - int reserved; - int pad1; - long unsigned int u_ar0; - struct user_i387_struct *u_fpstate; - long unsigned int magic; - char u_comm[32]; - long unsigned int u_debugreg[8]; - long unsigned int error_code; - long unsigned int fault_address; +struct acpi_madt_local_apic { + struct acpi_subtable_header header; + u8 processor_id; + u8 id; + u32 lapic_flags; }; -enum { - HW_BREAKPOINT_LEN_1 = 1, - HW_BREAKPOINT_LEN_2 = 2, - HW_BREAKPOINT_LEN_3 = 3, - HW_BREAKPOINT_LEN_4 = 4, - HW_BREAKPOINT_LEN_5 = 5, - HW_BREAKPOINT_LEN_6 = 6, - HW_BREAKPOINT_LEN_7 = 7, - HW_BREAKPOINT_LEN_8 = 8, +struct acpi_madt_io_apic { + struct acpi_subtable_header header; + u8 id; + u8 reserved; + u32 address; + u32 global_irq_base; }; -enum { - HW_BREAKPOINT_EMPTY = 0, - HW_BREAKPOINT_R = 1, - HW_BREAKPOINT_W = 2, - HW_BREAKPOINT_RW = 3, - HW_BREAKPOINT_X = 4, - HW_BREAKPOINT_INVALID = 7, +struct acpi_madt_interrupt_override { + struct acpi_subtable_header header; + u8 bus; + u8 source_irq; + u32 global_irq; + u16 inti_flags; +} __attribute__((packed)); + +struct acpi_madt_nmi_source { + struct acpi_subtable_header header; + u16 inti_flags; + u32 global_irq; }; -typedef unsigned int u_int; +struct acpi_madt_local_apic_nmi { + struct acpi_subtable_header header; + u8 processor_id; + u16 inti_flags; + u8 lint; +} __attribute__((packed)); -typedef long long unsigned int cycles_t; +struct acpi_madt_local_apic_override { + struct acpi_subtable_header header; + u16 reserved; + u64 address; +} __attribute__((packed)); -struct system_counterval_t { - u64 cycles; - struct clocksource *cs; -}; +struct acpi_madt_local_sapic { + struct acpi_subtable_header header; + u8 processor_id; + u8 id; + u8 eid; + u8 reserved[3]; + u32 lapic_flags; + u32 uid; + char uid_string[1]; +} __attribute__((packed)); -enum { - WORK_STRUCT_PENDING_BIT = 0, - WORK_STRUCT_DELAYED_BIT = 1, - WORK_STRUCT_PWQ_BIT = 2, - WORK_STRUCT_LINKED_BIT = 3, - WORK_STRUCT_COLOR_SHIFT = 4, - WORK_STRUCT_COLOR_BITS = 4, - WORK_STRUCT_PENDING = 1, - WORK_STRUCT_DELAYED = 2, - WORK_STRUCT_PWQ = 4, - WORK_STRUCT_LINKED = 8, - WORK_STRUCT_STATIC = 0, - WORK_NR_COLORS = 15, - WORK_NO_COLOR = 15, - WORK_CPU_UNBOUND = 64, - WORK_STRUCT_FLAG_BITS = 8, - WORK_OFFQ_FLAG_BASE = 4, - __WORK_OFFQ_CANCELING = 4, - WORK_OFFQ_CANCELING = 16, - WORK_OFFQ_FLAG_BITS = 1, - WORK_OFFQ_POOL_SHIFT = 5, - WORK_OFFQ_LEFT = 59, - WORK_OFFQ_POOL_BITS = 31, - WORK_OFFQ_POOL_NONE = 2147483647, - WORK_STRUCT_FLAG_MASK = 255, - WORK_STRUCT_WQ_DATA_MASK = 4294967040, - WORK_STRUCT_NO_POOL = 4294967264, - WORK_BUSY_PENDING = 1, - WORK_BUSY_RUNNING = 2, - WORKER_DESC_LEN = 24, +struct acpi_madt_local_x2apic { + struct acpi_subtable_header header; + u16 reserved; + u32 local_apic_id; + u32 lapic_flags; + u32 uid; }; -enum cpufreq_table_sorting { - CPUFREQ_TABLE_UNSORTED = 0, - CPUFREQ_TABLE_SORTED_ASCENDING = 1, - CPUFREQ_TABLE_SORTED_DESCENDING = 2, +struct acpi_madt_local_x2apic_nmi { + struct acpi_subtable_header header; + u16 inti_flags; + u32 uid; + u8 lint; + u8 reserved[3]; }; -struct cpufreq_cpuinfo { - unsigned int max_freq; - unsigned int min_freq; - unsigned int transition_latency; +union acpi_subtable_headers { + struct acpi_subtable_header common; + struct acpi_hmat_structure hmat; }; -struct cpufreq_stats; - -struct clk; +typedef int (*acpi_tbl_entry_handler)(union acpi_subtable_headers *, const long unsigned int); -struct cpufreq_governor; +struct acpi_subtable_proc { + int id; + acpi_tbl_entry_handler handler; + int count; +}; -struct cpufreq_frequency_table; +typedef u32 phys_cpuid_t; -struct thermal_cooling_device; +enum irq_alloc_type { + X86_IRQ_ALLOC_TYPE_IOAPIC = 1, + X86_IRQ_ALLOC_TYPE_HPET = 2, + X86_IRQ_ALLOC_TYPE_MSI = 3, + X86_IRQ_ALLOC_TYPE_MSIX = 4, + X86_IRQ_ALLOC_TYPE_DMAR = 5, + X86_IRQ_ALLOC_TYPE_UV = 6, +}; -struct cpufreq_policy { - cpumask_var_t cpus; - cpumask_var_t related_cpus; - cpumask_var_t real_cpus; - unsigned int shared_type; - unsigned int cpu; - struct clk *clk; - struct cpufreq_cpuinfo cpuinfo; - unsigned int min; - unsigned int max; - unsigned int cur; - unsigned int restore_freq; - unsigned int suspend_freq; - unsigned int policy; - unsigned int last_policy; - struct cpufreq_governor *governor; - void *governor_data; - char last_governor[16]; - struct work_struct update; - struct freq_constraints constraints; - struct freq_qos_request *min_freq_req; - struct freq_qos_request *max_freq_req; - struct cpufreq_frequency_table *freq_table; - enum cpufreq_table_sorting freq_table_sorted; - struct list_head policy_list; - struct kobject kobj; - struct completion kobj_unregister; - struct rw_semaphore rwsem; - bool fast_switch_possible; - bool fast_switch_enabled; - unsigned int transition_delay_us; - bool dvfs_possible_from_any_cpu; - unsigned int cached_target_freq; - int cached_resolved_idx; - bool transition_ongoing; - spinlock_t transition_lock; - wait_queue_head_t transition_wait; - struct task_struct *transition_task; - struct cpufreq_stats *stats; - void *driver_data; - struct thermal_cooling_device *cdev; - struct notifier_block nb_min; - struct notifier_block nb_max; +struct irq_alloc_info { + enum irq_alloc_type type; + u32 flags; + const struct cpumask *mask; + union { + int unused; + struct { + int hpet_id; + int hpet_index; + void *hpet_data; + }; + struct { + struct pci_dev *msi_dev; + irq_hw_number_t msi_hwirq; + }; + struct { + int ioapic_id; + int ioapic_pin; + int ioapic_node; + u32 ioapic_trigger: 1; + u32 ioapic_polarity: 1; + u32 ioapic_valid: 1; + struct IO_APIC_route_entry *ioapic_entry; + }; + struct { + int dmar_id; + void *dmar_data; + }; + }; }; -struct cpufreq_governor { - char name[16]; - int (*init)(struct cpufreq_policy *); - void (*exit)(struct cpufreq_policy *); - int (*start)(struct cpufreq_policy *); - void (*stop)(struct cpufreq_policy *); - void (*limits)(struct cpufreq_policy *); - ssize_t (*show_setspeed)(struct cpufreq_policy *, char *); - int (*store_setspeed)(struct cpufreq_policy *, unsigned int); - bool dynamic_switching; - struct list_head governor_list; - struct module *owner; +struct circ_buf { + char *buf; + int head; + int tail; }; -struct cpufreq_frequency_table { - unsigned int flags; - unsigned int driver_data; - unsigned int frequency; +struct serial_icounter_struct { + int cts; + int dsr; + int rng; + int dcd; + int rx; + int tx; + int frame; + int overrun; + int parity; + int brk; + int buf_overrun; + int reserved[9]; }; -struct cpufreq_freqs { - struct cpufreq_policy *policy; - unsigned int old; - unsigned int new; - u8 flags; +struct serial_struct { + int type; + int line; + unsigned int port; + int irq; + int flags; + int xmit_fifo_size; + int custom_divisor; + int baud_base; + short unsigned int close_delay; + char io_type; + char reserved_char[1]; + int hub6; + short unsigned int closing_wait; + short unsigned int closing_wait2; + unsigned char *iomem_base; + short unsigned int iomem_reg_shift; + unsigned int port_high; + long unsigned int iomap_base; }; -struct cyc2ns { - struct cyc2ns_data data[2]; - seqcount_t seq; +struct serial_rs485 { + __u32 flags; + __u32 delay_rts_before_send; + __u32 delay_rts_after_send; + __u32 padding[5]; }; -struct freq_desc { - u8 msr_plat; - u32 freqs[9]; +struct serial_iso7816 { + __u32 flags; + __u32 tg; + __u32 sc_fi; + __u32 sc_di; + __u32 clk; + __u32 reserved[5]; }; -struct dmi_strmatch { - unsigned char slot: 7; - unsigned char exact_match: 1; - char substr[79]; +struct uart_port; + +struct uart_ops { + unsigned int (*tx_empty)(struct uart_port *); + void (*set_mctrl)(struct uart_port *, unsigned int); + unsigned int (*get_mctrl)(struct uart_port *); + void (*stop_tx)(struct uart_port *); + void (*start_tx)(struct uart_port *); + void (*throttle)(struct uart_port *); + void (*unthrottle)(struct uart_port *); + void (*send_xchar)(struct uart_port *, char); + void (*stop_rx)(struct uart_port *); + void (*enable_ms)(struct uart_port *); + void (*break_ctl)(struct uart_port *, int); + int (*startup)(struct uart_port *); + void (*shutdown)(struct uart_port *); + void (*flush_buffer)(struct uart_port *); + void (*set_termios)(struct uart_port *, struct ktermios *, struct ktermios *); + void (*set_ldisc)(struct uart_port *, struct ktermios *); + void (*pm)(struct uart_port *, unsigned int, unsigned int); + const char * (*type)(struct uart_port *); + void (*release_port)(struct uart_port *); + int (*request_port)(struct uart_port *); + void (*config_port)(struct uart_port *, int); + int (*verify_port)(struct uart_port *, struct serial_struct *); + int (*ioctl)(struct uart_port *, unsigned int, long unsigned int); }; -struct dmi_system_id { - int (*callback)(const struct dmi_system_id *); - const char *ident; - struct dmi_strmatch matches[4]; - void *driver_data; +struct uart_icount { + __u32 cts; + __u32 dsr; + __u32 rng; + __u32 dcd; + __u32 rx; + __u32 tx; + __u32 frame; + __u32 overrun; + __u32 parity; + __u32 brk; + __u32 buf_overrun; }; -struct pdev_archdata {}; +typedef unsigned int upf_t; -struct mfd_cell; +typedef unsigned int upstat_t; -struct platform_device_id; +struct uart_state; -struct platform_device { +struct uart_port { + spinlock_t lock; + long unsigned int iobase; + unsigned char *membase; + unsigned int (*serial_in)(struct uart_port *, int); + void (*serial_out)(struct uart_port *, int, int); + void (*set_termios)(struct uart_port *, struct ktermios *, struct ktermios *); + void (*set_ldisc)(struct uart_port *, struct ktermios *); + unsigned int (*get_mctrl)(struct uart_port *); + void (*set_mctrl)(struct uart_port *, unsigned int); + unsigned int (*get_divisor)(struct uart_port *, unsigned int, unsigned int *); + void (*set_divisor)(struct uart_port *, unsigned int, unsigned int, unsigned int); + int (*startup)(struct uart_port *); + void (*shutdown)(struct uart_port *); + void (*throttle)(struct uart_port *); + void (*unthrottle)(struct uart_port *); + int (*handle_irq)(struct uart_port *); + void (*pm)(struct uart_port *, unsigned int, unsigned int); + void (*handle_break)(struct uart_port *); + int (*rs485_config)(struct uart_port *, struct serial_rs485 *); + int (*iso7816_config)(struct uart_port *, struct serial_iso7816 *); + unsigned int irq; + long unsigned int irqflags; + unsigned int uartclk; + unsigned int fifosize; + unsigned char x_char; + unsigned char regshift; + unsigned char iotype; + unsigned char quirks; + unsigned int read_status_mask; + unsigned int ignore_status_mask; + struct uart_state *state; + struct uart_icount icount; + struct console *cons; + long unsigned int sysrq; + unsigned int sysrq_ch; + upf_t flags; + upstat_t status; + int hw_stopped; + unsigned int mctrl; + unsigned int timeout; + unsigned int type; + const struct uart_ops *ops; + unsigned int custom_divisor; + unsigned int line; + unsigned int minor; + resource_size_t mapbase; + resource_size_t mapsize; + struct device *dev; + unsigned char hub6; + unsigned char suspended; + unsigned char unused[2]; const char *name; - int id; - bool id_auto; - struct device dev; - u64 dma_mask; - u32 num_resources; - struct resource *resource; - const struct platform_device_id *id_entry; - char *driver_override; - struct mfd_cell *mfd_cell; - struct pdev_archdata archdata; -}; - -struct platform_device_id { - char name[20]; - kernel_ulong_t driver_data; + struct attribute_group *attr_group; + const struct attribute_group **tty_groups; + struct serial_rs485 rs485; + struct serial_iso7816 iso7816; + void *private_data; }; -struct rtc_time { - int tm_sec; - int tm_min; - int tm_hour; - int tm_mday; - int tm_mon; - int tm_year; - int tm_wday; - int tm_yday; - int tm_isdst; +enum uart_pm_state { + UART_PM_STATE_ON = 0, + UART_PM_STATE_OFF = 3, + UART_PM_STATE_UNDEFINED = 4, }; -struct pnp_device_id { - __u8 id[8]; - kernel_ulong_t driver_data; +struct uart_state { + struct tty_port port; + enum uart_pm_state pm_state; + struct circ_buf xmit; + atomic_t refcount; + wait_queue_head_t remove_wait; + struct uart_port *uart_port; }; -struct pnp_card_device_id { - __u8 id[8]; - kernel_ulong_t driver_data; - struct { - __u8 id[8]; - } devs[8]; +struct earlycon_device { + struct console *con; + struct uart_port port; + char options[16]; + unsigned int baud; }; -struct pnp_protocol; - -struct pnp_id; - -struct pnp_card { - struct device dev; - unsigned char number; - struct list_head global_list; - struct list_head protocol_list; - struct list_head devices; - struct pnp_protocol *protocol; - struct pnp_id *id; - char name[50]; - unsigned char pnpver; - unsigned char productver; - unsigned int serial; - unsigned char checksum; - struct proc_dir_entry *procdir; +struct earlycon_id { + char name[15]; + char name_term; + char compatible[128]; + int (*setup)(struct earlycon_device *, const char *); }; -struct pnp_dev; - -struct pnp_protocol { - struct list_head protocol_list; - char *name; - int (*get)(struct pnp_dev *); - int (*set)(struct pnp_dev *); - int (*disable)(struct pnp_dev *); - bool (*can_wakeup)(struct pnp_dev *); - int (*suspend)(struct pnp_dev *, pm_message_t); - int (*resume)(struct pnp_dev *); - unsigned char number; - struct device dev; - struct list_head cards; - struct list_head devices; +enum ioapic_domain_type { + IOAPIC_DOMAIN_INVALID = 0, + IOAPIC_DOMAIN_LEGACY = 1, + IOAPIC_DOMAIN_STRICT = 2, + IOAPIC_DOMAIN_DYNAMIC = 3, }; -struct pnp_id { - char id[8]; - struct pnp_id *next; +struct ioapic_domain_cfg { + enum ioapic_domain_type type; + const struct irq_domain_ops *ops; + struct device_node *dev; }; -struct pnp_card_driver; - -struct pnp_card_link { - struct pnp_card *card; - struct pnp_card_driver *driver; - void *driver_data; - pm_message_t pm_state; -}; +struct thermal_cooling_device_ops; -struct pnp_driver { - char *name; - const struct pnp_device_id *id_table; - unsigned int flags; - int (*probe)(struct pnp_dev *, const struct pnp_device_id *); - void (*remove)(struct pnp_dev *); - void (*shutdown)(struct pnp_dev *); - int (*suspend)(struct pnp_dev *, pm_message_t); - int (*resume)(struct pnp_dev *); - struct device_driver driver; +struct thermal_cooling_device { + int id; + char type[20]; + struct device device; + struct device_node *np; + void *devdata; + void *stats; + const struct thermal_cooling_device_ops *ops; + bool updated; + struct mutex lock; + struct list_head thermal_instances; + struct list_head node; }; -struct pnp_card_driver { - struct list_head global_list; - char *name; - const struct pnp_card_device_id *id_table; - unsigned int flags; - int (*probe)(struct pnp_card_link *, const struct pnp_card_device_id *); - void (*remove)(struct pnp_card_link *); - int (*suspend)(struct pnp_card_link *, pm_message_t); - int (*resume)(struct pnp_card_link *); - struct pnp_driver link; +enum thermal_device_mode { + THERMAL_DEVICE_DISABLED = 0, + THERMAL_DEVICE_ENABLED = 1, }; -struct pnp_dev { - struct device dev; - u64 dma_mask; - unsigned int number; - int status; - struct list_head global_list; - struct list_head protocol_list; - struct list_head card_list; - struct list_head rdev_list; - struct pnp_protocol *protocol; - struct pnp_card *card; - struct pnp_driver *driver; - struct pnp_card_link *card_link; - struct pnp_id *id; - int active; - int capabilities; - unsigned int num_dependent_sets; - struct list_head resources; - struct list_head options; - char name[50]; - int flags; - struct proc_dir_entry *procent; - void *data; +enum thermal_trip_type { + THERMAL_TRIP_ACTIVE = 0, + THERMAL_TRIP_PASSIVE = 1, + THERMAL_TRIP_HOT = 2, + THERMAL_TRIP_CRITICAL = 3, }; -typedef struct ldttss_desc tss_desc; - -enum idle_boot_override { - IDLE_NO_OVERRIDE = 0, - IDLE_HALT = 1, - IDLE_NOMWAIT = 2, - IDLE_POLL = 3, +enum thermal_trend { + THERMAL_TREND_STABLE = 0, + THERMAL_TREND_RAISING = 1, + THERMAL_TREND_DROPPING = 2, + THERMAL_TREND_RAISE_FULL = 3, + THERMAL_TREND_DROP_FULL = 4, }; -enum tick_broadcast_mode { - TICK_BROADCAST_OFF = 0, - TICK_BROADCAST_ON = 1, - TICK_BROADCAST_FORCE = 2, +enum thermal_notify_event { + THERMAL_EVENT_UNSPECIFIED = 0, + THERMAL_EVENT_TEMP_SAMPLE = 1, + THERMAL_TRIP_VIOLATED = 2, + THERMAL_TRIP_CHANGED = 3, + THERMAL_DEVICE_DOWN = 4, + THERMAL_DEVICE_UP = 5, + THERMAL_DEVICE_POWER_CAPABILITY_CHANGED = 6, + THERMAL_TABLE_CHANGED = 7, }; -enum tick_broadcast_state { - TICK_BROADCAST_EXIT = 0, - TICK_BROADCAST_ENTER = 1, -}; +struct thermal_zone_device; -struct cpuidle_state_usage { - long long unsigned int disable; - long long unsigned int usage; - u64 time_ns; - long long unsigned int above; - long long unsigned int below; - long long unsigned int s2idle_usage; - long long unsigned int s2idle_time; +struct thermal_zone_device_ops { + int (*bind)(struct thermal_zone_device *, struct thermal_cooling_device *); + int (*unbind)(struct thermal_zone_device *, struct thermal_cooling_device *); + int (*get_temp)(struct thermal_zone_device *, int *); + int (*set_trips)(struct thermal_zone_device *, int, int); + int (*get_mode)(struct thermal_zone_device *, enum thermal_device_mode *); + int (*set_mode)(struct thermal_zone_device *, enum thermal_device_mode); + int (*get_trip_type)(struct thermal_zone_device *, int, enum thermal_trip_type *); + int (*get_trip_temp)(struct thermal_zone_device *, int, int *); + int (*set_trip_temp)(struct thermal_zone_device *, int, int); + int (*get_trip_hyst)(struct thermal_zone_device *, int, int *); + int (*set_trip_hyst)(struct thermal_zone_device *, int, int); + int (*get_crit_temp)(struct thermal_zone_device *, int *); + int (*set_emul_temp)(struct thermal_zone_device *, int); + int (*get_trend)(struct thermal_zone_device *, int, enum thermal_trend *); + int (*notify)(struct thermal_zone_device *, int, enum thermal_trip_type); }; -struct cpuidle_driver_kobj; +struct thermal_attr; -struct cpuidle_state_kobj; +struct thermal_zone_params; -struct cpuidle_device_kobj; +struct thermal_governor; -struct cpuidle_device { - unsigned int registered: 1; - unsigned int enabled: 1; - unsigned int poll_time_limit: 1; - unsigned int cpu; - ktime_t next_hrtimer; - int last_state_idx; - u64 last_residency_ns; - u64 poll_limit_ns; - u64 forced_idle_latency_limit_ns; - struct cpuidle_state_usage states_usage[10]; - struct cpuidle_state_kobj *kobjs[10]; - struct cpuidle_driver_kobj *kobj_driver; - struct cpuidle_device_kobj *kobj_dev; - struct list_head device_list; +struct thermal_zone_device { + int id; + char type[20]; + struct device device; + struct attribute_group trips_attribute_group; + struct thermal_attr *trip_temp_attrs; + struct thermal_attr *trip_type_attrs; + struct thermal_attr *trip_hyst_attrs; + void *devdata; + int trips; + long unsigned int trips_disabled; + int passive_delay; + int polling_delay; + int temperature; + int last_temperature; + int emul_temperature; + int passive; + int prev_low_trip; + int prev_high_trip; + unsigned int forced_passive; + atomic_t need_update; + struct thermal_zone_device_ops *ops; + struct thermal_zone_params *tzp; + struct thermal_governor *governor; + void *governor_data; + struct list_head thermal_instances; + struct ida ida; + struct mutex lock; + struct list_head node; + struct delayed_work poll_queue; + enum thermal_notify_event notify_event; }; -struct inactive_task_frame { - long unsigned int r15; - long unsigned int r14; - long unsigned int r13; - long unsigned int r12; - long unsigned int bx; - long unsigned int bp; - long unsigned int ret_addr; +struct thermal_cooling_device_ops { + int (*get_max_state)(struct thermal_cooling_device *, long unsigned int *); + int (*get_cur_state)(struct thermal_cooling_device *, long unsigned int *); + int (*set_cur_state)(struct thermal_cooling_device *, long unsigned int); + int (*get_requested_power)(struct thermal_cooling_device *, struct thermal_zone_device *, u32 *); + int (*state2power)(struct thermal_cooling_device *, struct thermal_zone_device *, long unsigned int, u32 *); + int (*power2state)(struct thermal_cooling_device *, struct thermal_zone_device *, u32, long unsigned int *); }; -struct fork_frame { - struct inactive_task_frame frame; - struct pt_regs regs; +struct thermal_attr { + struct device_attribute attr; + char name[20]; }; -struct ssb_state { - struct ssb_state *shared_state; - raw_spinlock_t lock; - unsigned int disable_state; - long unsigned int local_state; -}; +struct thermal_bind_params; -struct trace_event_raw_x86_fpu { - struct trace_entry ent; - struct fpu *fpu; - bool load_fpu; - u64 xfeatures; - u64 xcomp_bv; - char __data[0]; +struct thermal_zone_params { + char governor_name[20]; + bool no_hwmon; + int num_tbps; + struct thermal_bind_params *tbp; + u32 sustainable_power; + s32 k_po; + s32 k_pu; + s32 k_i; + s32 k_d; + s32 integral_cutoff; + int slope; + int offset; }; -struct trace_event_data_offsets_x86_fpu {}; - -struct _fpreg { - __u16 significand[4]; - __u16 exponent; +struct thermal_governor { + char name[20]; + int (*bind_to_tz)(struct thermal_zone_device *); + void (*unbind_from_tz)(struct thermal_zone_device *); + int (*throttle)(struct thermal_zone_device *, int); + struct list_head governor_list; }; -struct _fpxreg { - __u16 significand[4]; - __u16 exponent; - __u16 padding[3]; +struct thermal_bind_params { + struct thermal_cooling_device *cdev; + int weight; + int trip_mask; + long unsigned int *binding_limits; + int (*match)(struct thermal_zone_device *, struct thermal_cooling_device *); }; -struct user_i387_ia32_struct { - u32 cwd; - u32 swd; - u32 twd; - u32 fip; - u32 fcs; - u32 foo; - u32 fos; - u32 st_space[20]; +struct acpi_processor_cx { + u8 valid; + u8 type; + u32 address; + u8 entry_method; + u8 index; + u32 latency; + u8 bm_sts_skip; + char desc[32]; }; -struct user_regset; - -typedef int user_regset_active_fn(struct task_struct *, const struct user_regset *); - -typedef int user_regset_get_fn(struct task_struct *, const struct user_regset *, unsigned int, unsigned int, void *, void *); - -typedef int user_regset_set_fn(struct task_struct *, const struct user_regset *, unsigned int, unsigned int, const void *, const void *); - -typedef int user_regset_writeback_fn(struct task_struct *, const struct user_regset *, int); - -typedef unsigned int user_regset_get_size_fn(struct task_struct *, const struct user_regset *); - -struct user_regset { - user_regset_get_fn *get; - user_regset_set_fn *set; - user_regset_active_fn *active; - user_regset_writeback_fn *writeback; - user_regset_get_size_fn *get_size; - unsigned int n; - unsigned int size; - unsigned int align; - unsigned int bias; - unsigned int core_note_type; +struct acpi_lpi_state { + u32 min_residency; + u32 wake_latency; + u32 flags; + u32 arch_flags; + u32 res_cnt_freq; + u32 enable_parent_state; + u64 address; + u8 index; + u8 entry_method; + char desc[32]; }; -struct _fpx_sw_bytes { - __u32 magic1; - __u32 extended_size; - __u64 xfeatures; - __u32 xstate_size; - __u32 padding[7]; +struct acpi_processor_power { + int count; + union { + struct acpi_processor_cx states[8]; + struct acpi_lpi_state lpi_states[8]; + }; + int timer_broadcast_on_state; }; -struct _xmmreg { - __u32 element[4]; +struct acpi_psd_package { + u64 num_entries; + u64 revision; + u64 domain; + u64 coord_type; + u64 num_processors; }; -struct _fpstate_32 { - __u32 cw; - __u32 sw; - __u32 tag; - __u32 ipoff; - __u32 cssel; - __u32 dataoff; - __u32 datasel; - struct _fpreg _st[8]; - __u16 status; - __u16 magic; - __u32 _fxsr_env[6]; - __u32 mxcsr; - __u32 reserved; - struct _fpxreg _fxsr_st[8]; - struct _xmmreg _xmm[8]; - union { - __u32 padding1[44]; - __u32 padding[44]; - }; - union { - __u32 padding2[12]; - struct _fpx_sw_bytes sw_reserved; - }; +struct acpi_pct_register { + u8 descriptor; + u16 length; + u8 space_id; + u8 bit_width; + u8 bit_offset; + u8 reserved; + u64 address; +} __attribute__((packed)); + +struct acpi_processor_px { + u64 core_frequency; + u64 power; + u64 transition_latency; + u64 bus_master_latency; + u64 control; + u64 status; }; -typedef u32 compat_ulong_t; +struct acpi_processor_performance { + unsigned int state; + unsigned int platform_limit; + struct acpi_pct_register control_register; + struct acpi_pct_register status_register; + short: 16; + unsigned int state_count; + int: 32; + struct acpi_processor_px *states; + struct acpi_psd_package domain_info; + cpumask_var_t shared_cpu_map; + unsigned int shared_type; + int: 32; +} __attribute__((packed)); -struct user_regset_view { - const char *name; - const struct user_regset *regsets; - unsigned int n; - u32 e_flags; - u16 e_machine; - u8 ei_osabi; +struct acpi_tsd_package { + u64 num_entries; + u64 revision; + u64 domain; + u64 coord_type; + u64 num_processors; }; -enum x86_regset { - REGSET_GENERAL = 0, - REGSET_FP = 1, - REGSET_XFP = 2, - REGSET_IOPERM64 = 2, - REGSET_XSTATE = 3, - REGSET_TLS = 4, - REGSET_IOPERM32 = 5, +struct acpi_processor_tx_tss { + u64 freqpercentage; + u64 power; + u64 transition_latency; + u64 control; + u64 status; }; -struct pt_regs_offset { - const char *name; - int offset; +struct acpi_processor_tx { + u16 power; + u16 performance; }; -typedef bool (*stack_trace_consume_fn)(void *, long unsigned int, bool); +struct acpi_processor; -struct stack_frame_user { - const void *next_fp; - long unsigned int ret_addr; -}; +struct acpi_processor_throttling { + unsigned int state; + unsigned int platform_limit; + struct acpi_pct_register control_register; + struct acpi_pct_register status_register; + short: 16; + unsigned int state_count; + int: 32; + struct acpi_processor_tx_tss *states_tss; + struct acpi_tsd_package domain_info; + cpumask_var_t shared_cpu_map; + int (*acpi_processor_get_throttling)(struct acpi_processor *); + int (*acpi_processor_set_throttling)(struct acpi_processor *, int, bool); + u32 address; + u8 duty_offset; + u8 duty_width; + u8 tsd_valid_flag; + char: 8; + unsigned int shared_type; + struct acpi_processor_tx states[16]; + int: 32; +} __attribute__((packed)); -enum cache_type { - CACHE_TYPE_NOCACHE = 0, - CACHE_TYPE_INST = 1, - CACHE_TYPE_DATA = 2, - CACHE_TYPE_SEPARATE = 3, - CACHE_TYPE_UNIFIED = 4, +struct acpi_processor_flags { + u8 power: 1; + u8 performance: 1; + u8 throttling: 1; + u8 limit: 1; + u8 bm_control: 1; + u8 bm_check: 1; + u8 has_cst: 1; + u8 has_lpi: 1; + u8 power_setup_done: 1; + u8 bm_rld_set: 1; + u8 need_hotplug_init: 1; }; -struct cacheinfo { - unsigned int id; - enum cache_type type; - unsigned int level; - unsigned int coherency_line_size; - unsigned int number_of_sets; - unsigned int ways_of_associativity; - unsigned int physical_line_partition; - unsigned int size; - cpumask_t shared_cpu_map; - unsigned int attributes; - void *fw_token; - bool disable_sysfs; - void *priv; +struct acpi_processor_lx { + int px; + int tx; }; -struct cpu_cacheinfo { - struct cacheinfo *info_list; - unsigned int num_levels; - unsigned int num_leaves; - bool cpu_map_populated; +struct acpi_processor_limit { + struct acpi_processor_lx state; + struct acpi_processor_lx thermal; + struct acpi_processor_lx user; }; -struct amd_l3_cache { - unsigned int indices; - u8 subcaches[4]; +struct acpi_processor { + acpi_handle handle; + u32 acpi_id; + phys_cpuid_t phys_id; + u32 id; + u32 pblk; + int performance_platform_limit; + int throttling_platform_limit; + struct acpi_processor_flags flags; + struct acpi_processor_power power; + struct acpi_processor_performance *performance; + struct acpi_processor_throttling throttling; + struct acpi_processor_limit limit; + struct thermal_cooling_device *cdev; + struct device *dev; + struct freq_qos_request perflib_req; + struct freq_qos_request thermal_req; }; -struct threshold_block { - unsigned int block; - unsigned int bank; - unsigned int cpu; - u32 address; - u16 interrupt_enable; - bool interrupt_capable; - u16 threshold_limit; - struct kobject kobj; - struct list_head miscj; +struct acpi_processor_errata { + u8 smp; + struct { + u8 throttle: 1; + u8 fdma: 1; + u8 reserved: 6; + u32 bmisx; + } piix4; }; -struct threshold_bank { - struct kobject *kobj; - struct threshold_block *blocks; - refcount_t cpus; -}; +struct cpuidle_driver; -struct amd_northbridge { - struct pci_dev *root; - struct pci_dev *misc; - struct pci_dev *link; - struct amd_l3_cache l3_cache; - struct threshold_bank *bank4; -}; +struct wakeup_header { + u16 video_mode; + u32 pmode_entry; + u16 pmode_cs; + u32 pmode_cr0; + u32 pmode_cr3; + u32 pmode_cr4; + u32 pmode_efer_low; + u32 pmode_efer_high; + u64 pmode_gdt; + u32 pmode_misc_en_low; + u32 pmode_misc_en_high; + u32 pmode_behavior; + u32 realmode_flags; + u32 real_magic; + u32 signature; +} __attribute__((packed)); -struct _cache_table { - unsigned char descriptor; - char cache_type; - short int size; -}; +struct cpc_reg { + u8 descriptor; + u16 length; + u8 space_id; + u8 bit_width; + u8 bit_offset; + u8 access_width; + u64 address; +} __attribute__((packed)); -enum _cache_type { - CTYPE_NULL = 0, - CTYPE_DATA = 1, - CTYPE_INST = 2, - CTYPE_UNIFIED = 3, -}; +struct acpi_power_register { + u8 descriptor; + u16 length; + u8 space_id; + u8 bit_width; + u8 bit_offset; + u8 access_size; + u64 address; +} __attribute__((packed)); -union _cpuid4_leaf_eax { +struct cstate_entry { struct { - enum _cache_type type: 5; - unsigned int level: 3; - unsigned int is_self_initializing: 1; - unsigned int is_fully_associative: 1; - unsigned int reserved: 4; - unsigned int num_threads_sharing: 12; - unsigned int num_cores_on_die: 6; - } split; - u32 full; + unsigned int eax; + unsigned int ecx; + } states[8]; }; -union _cpuid4_leaf_ebx { - struct { - unsigned int coherency_line_size: 12; - unsigned int physical_line_partition: 10; - unsigned int ways_of_associativity: 10; - } split; - u32 full; -}; +typedef void (*nmi_shootdown_cb)(int, struct pt_regs *); -union _cpuid4_leaf_ecx { - struct { - unsigned int number_of_sets: 32; - } split; - u32 full; -}; +struct pci_ops___2; -struct _cpuid4_info_regs { - union _cpuid4_leaf_eax eax; - union _cpuid4_leaf_ebx ebx; - union _cpuid4_leaf_ecx ecx; - unsigned int id; - long unsigned int size; - struct amd_northbridge *nb; +struct cpuid_regs_done { + struct cpuid_regs regs; + struct completion done; }; -union l1_cache { - struct { - unsigned int line_size: 8; - unsigned int lines_per_tag: 8; - unsigned int assoc: 8; - unsigned int size_in_kb: 8; - }; - unsigned int val; +struct intel_early_ops { + resource_size_t (*stolen_size)(int, int, int); + resource_size_t (*stolen_base)(int, int, int, resource_size_t); }; -union l2_cache { - struct { - unsigned int line_size: 8; - unsigned int lines_per_tag: 4; - unsigned int assoc: 4; - unsigned int size_in_kb: 16; - }; - unsigned int val; +struct chipset { + u32 vendor; + u32 device; + u32 class; + u32 class_mask; + u32 flags; + void (*f)(int, int, int); }; -union l3_cache { - struct { - unsigned int line_size: 8; - unsigned int lines_per_tag: 4; - unsigned int assoc: 4; - unsigned int res: 2; - unsigned int size_encoded: 14; - }; - unsigned int val; +struct sched_domain_shared { + atomic_t ref; + atomic_t nr_busy_cpus; + int has_idle_cores; }; -struct cpuid_bit { - u16 feature; - u8 reg; - u8 bit; - u32 level; - u32 sub_leaf; -}; +struct sched_group; -enum cpuid_leafs { - CPUID_1_EDX = 0, - CPUID_8000_0001_EDX = 1, - CPUID_8086_0001_EDX = 2, - CPUID_LNX_1 = 3, - CPUID_1_ECX = 4, - CPUID_C000_0001_EDX = 5, - CPUID_8000_0001_ECX = 6, - CPUID_LNX_2 = 7, - CPUID_LNX_3 = 8, - CPUID_7_0_EBX = 9, - CPUID_D_1_EAX = 10, - CPUID_LNX_4 = 11, - CPUID_7_1_EAX = 12, - CPUID_8000_0008_EBX = 13, - CPUID_6_EAX = 14, - CPUID_8000_000A_EDX = 15, - CPUID_7_ECX = 16, - CPUID_8000_0007_EBX = 17, - CPUID_7_EDX = 18, +struct sched_domain { + struct sched_domain *parent; + struct sched_domain *child; + struct sched_group *groups; + long unsigned int min_interval; + long unsigned int max_interval; + unsigned int busy_factor; + unsigned int imbalance_pct; + unsigned int cache_nice_tries; + int nohz_idle; + int flags; + int level; + long unsigned int last_balance; + unsigned int balance_interval; + unsigned int nr_balance_failed; + u64 max_newidle_lb_cost; + long unsigned int next_decay_max_lb_cost; + u64 avg_scan_cost; + unsigned int lb_count[3]; + unsigned int lb_failed[3]; + unsigned int lb_balanced[3]; + unsigned int lb_imbalance[3]; + unsigned int lb_gained[3]; + unsigned int lb_hot_gained[3]; + unsigned int lb_nobusyg[3]; + unsigned int lb_nobusyq[3]; + unsigned int alb_count; + unsigned int alb_failed; + unsigned int alb_pushed; + unsigned int sbe_count; + unsigned int sbe_balanced; + unsigned int sbe_pushed; + unsigned int sbf_count; + unsigned int sbf_balanced; + unsigned int sbf_pushed; + unsigned int ttwu_wake_remote; + unsigned int ttwu_move_affine; + unsigned int ttwu_move_balance; + union { + void *private; + struct callback_head rcu; + }; + struct sched_domain_shared *shared; + unsigned int span_weight; + long unsigned int span[0]; }; -struct cpu_dev { - const char *c_vendor; - const char *c_ident[2]; - void (*c_early_init)(struct cpuinfo_x86 *); - void (*c_bsp_init)(struct cpuinfo_x86 *); - void (*c_init)(struct cpuinfo_x86 *); - void (*c_identify)(struct cpuinfo_x86 *); - void (*c_detect_tlb)(struct cpuinfo_x86 *); - int c_x86_vendor; -}; +typedef const struct cpumask * (*sched_domain_mask_f)(int); -struct cpuid_dependent_feature { - u32 feature; - u32 level; -}; +typedef int (*sched_domain_flags_f)(); -enum spectre_v2_mitigation { - SPECTRE_V2_NONE = 0, - SPECTRE_V2_RETPOLINE_GENERIC = 1, - SPECTRE_V2_RETPOLINE_AMD = 2, - SPECTRE_V2_IBRS_ENHANCED = 3, -}; +struct sched_group_capacity; -enum spectre_v2_user_mitigation { - SPECTRE_V2_USER_NONE = 0, - SPECTRE_V2_USER_STRICT = 1, - SPECTRE_V2_USER_STRICT_PREFERRED = 2, - SPECTRE_V2_USER_PRCTL = 3, - SPECTRE_V2_USER_SECCOMP = 4, +struct sd_data { + struct sched_domain **sd; + struct sched_domain_shared **sds; + struct sched_group **sg; + struct sched_group_capacity **sgc; }; -enum ssb_mitigation { - SPEC_STORE_BYPASS_NONE = 0, - SPEC_STORE_BYPASS_DISABLE = 1, - SPEC_STORE_BYPASS_PRCTL = 2, - SPEC_STORE_BYPASS_SECCOMP = 3, +struct sched_domain_topology_level { + sched_domain_mask_f mask; + sched_domain_flags_f sd_flags; + int flags; + int numa_level; + struct sd_data data; }; -enum l1tf_mitigations { - L1TF_MITIGATION_OFF = 0, - L1TF_MITIGATION_FLUSH_NOWARN = 1, - L1TF_MITIGATION_FLUSH = 2, - L1TF_MITIGATION_FLUSH_NOSMT = 3, - L1TF_MITIGATION_FULL = 4, - L1TF_MITIGATION_FULL_FORCE = 5, +struct tsc_adjust { + s64 bootval; + s64 adjusted; + long unsigned int nextcheck; + bool warned; }; -enum mds_mitigations { - MDS_MITIGATION_OFF = 0, - MDS_MITIGATION_FULL = 1, - MDS_MITIGATION_VMWERV = 2, +enum { + DUMP_PREFIX_NONE = 0, + DUMP_PREFIX_ADDRESS = 1, + DUMP_PREFIX_OFFSET = 2, }; -enum taa_mitigations { - TAA_MITIGATION_OFF = 0, - TAA_MITIGATION_UCODE_NEEDED = 1, - TAA_MITIGATION_VERW = 2, - TAA_MITIGATION_TSX_DISABLED = 3, +struct mpf_intel { + char signature[4]; + unsigned int physptr; + unsigned char length; + unsigned char specification; + unsigned char checksum; + unsigned char feature1; + unsigned char feature2; + unsigned char feature3; + unsigned char feature4; + unsigned char feature5; }; -enum cpuhp_smt_control { - CPU_SMT_ENABLED = 0, - CPU_SMT_DISABLED = 1, - CPU_SMT_FORCE_DISABLED = 2, - CPU_SMT_NOT_SUPPORTED = 3, - CPU_SMT_NOT_IMPLEMENTED = 4, +struct mpc_ioapic { + unsigned char type; + unsigned char apicid; + unsigned char apicver; + unsigned char flags; + unsigned int apicaddr; }; -enum vmx_l1d_flush_state { - VMENTER_L1D_FLUSH_AUTO = 0, - VMENTER_L1D_FLUSH_NEVER = 1, - VMENTER_L1D_FLUSH_COND = 2, - VMENTER_L1D_FLUSH_ALWAYS = 3, - VMENTER_L1D_FLUSH_EPT_DISABLED = 4, - VMENTER_L1D_FLUSH_NOT_REQUIRED = 5, +struct mpc_lintsrc { + unsigned char type; + unsigned char irqtype; + short unsigned int irqflag; + unsigned char srcbusid; + unsigned char srcbusirq; + unsigned char destapic; + unsigned char destapiclint; }; -enum x86_hypervisor_type { - X86_HYPER_NATIVE = 0, - X86_HYPER_VMWARE = 1, - X86_HYPER_MS_HYPERV = 2, - X86_HYPER_XEN_PV = 3, - X86_HYPER_XEN_HVM = 4, - X86_HYPER_KVM = 5, - X86_HYPER_JAILHOUSE = 6, - X86_HYPER_ACRN = 7, +union apic_ir { + long unsigned int map[4]; + u32 regs[8]; }; -enum spectre_v1_mitigation { - SPECTRE_V1_MITIGATION_NONE = 0, - SPECTRE_V1_MITIGATION_AUTO = 1, +enum ioapic_irq_destination_types { + dest_Fixed = 0, + dest_LowestPrio = 1, + dest_SMI = 2, + dest__reserved_1 = 3, + dest_NMI = 4, + dest_INIT = 5, + dest__reserved_2 = 6, + dest_ExtINT = 7, }; -enum spectre_v2_mitigation_cmd { - SPECTRE_V2_CMD_NONE = 0, - SPECTRE_V2_CMD_AUTO = 1, - SPECTRE_V2_CMD_FORCE = 2, - SPECTRE_V2_CMD_RETPOLINE = 3, - SPECTRE_V2_CMD_RETPOLINE_GENERIC = 4, - SPECTRE_V2_CMD_RETPOLINE_AMD = 5, +enum { + IRQ_SET_MASK_OK = 0, + IRQ_SET_MASK_OK_NOCOPY = 1, + IRQ_SET_MASK_OK_DONE = 2, }; -enum spectre_v2_user_cmd { - SPECTRE_V2_USER_CMD_NONE = 0, - SPECTRE_V2_USER_CMD_AUTO = 1, - SPECTRE_V2_USER_CMD_FORCE = 2, - SPECTRE_V2_USER_CMD_PRCTL = 3, - SPECTRE_V2_USER_CMD_PRCTL_IBPB = 4, - SPECTRE_V2_USER_CMD_SECCOMP = 5, - SPECTRE_V2_USER_CMD_SECCOMP_IBPB = 6, +enum { + IRQD_TRIGGER_MASK = 15, + IRQD_SETAFFINITY_PENDING = 256, + IRQD_ACTIVATED = 512, + IRQD_NO_BALANCING = 1024, + IRQD_PER_CPU = 2048, + IRQD_AFFINITY_SET = 4096, + IRQD_LEVEL = 8192, + IRQD_WAKEUP_STATE = 16384, + IRQD_MOVE_PCNTXT = 32768, + IRQD_IRQ_DISABLED = 65536, + IRQD_IRQ_MASKED = 131072, + IRQD_IRQ_INPROGRESS = 262144, + IRQD_WAKEUP_ARMED = 524288, + IRQD_FORWARDED_TO_VCPU = 1048576, + IRQD_AFFINITY_MANAGED = 2097152, + IRQD_IRQ_STARTED = 4194304, + IRQD_MANAGED_SHUTDOWN = 8388608, + IRQD_SINGLE_TARGET = 16777216, + IRQD_DEFAULT_TRIGGER_SET = 33554432, + IRQD_CAN_RESERVE = 67108864, }; -enum ssb_mitigation_cmd { - SPEC_STORE_BYPASS_CMD_NONE = 0, - SPEC_STORE_BYPASS_CMD_AUTO = 1, - SPEC_STORE_BYPASS_CMD_ON = 2, - SPEC_STORE_BYPASS_CMD_PRCTL = 3, - SPEC_STORE_BYPASS_CMD_SECCOMP = 4, +struct irq_cfg { + unsigned int dest_apicid; + unsigned int vector; }; -enum hk_flags { - HK_FLAG_TIMER = 1, - HK_FLAG_RCU = 2, - HK_FLAG_MISC = 4, - HK_FLAG_SCHED = 8, - HK_FLAG_TICK = 16, - HK_FLAG_DOMAIN = 32, - HK_FLAG_WQ = 64, +enum { + IRQCHIP_FWNODE_REAL = 0, + IRQCHIP_FWNODE_NAMED = 1, + IRQCHIP_FWNODE_NAMED_ID = 2, }; -struct aperfmperf_sample { - unsigned int khz; - ktime_t time; - u64 aperf; - u64 mperf; +enum { + X86_IRQ_ALLOC_CONTIGUOUS_VECTORS = 1, + X86_IRQ_ALLOC_LEGACY = 2, }; -struct cpuid_dep { - unsigned int feature; - unsigned int depends; +struct apic_chip_data { + struct irq_cfg hw_irq_cfg; + unsigned int vector; + unsigned int prev_vector; + unsigned int cpu; + unsigned int prev_cpu; + unsigned int irq; + struct hlist_node clist; + unsigned int move_in_progress: 1; + unsigned int is_managed: 1; + unsigned int can_reserve: 1; + unsigned int has_reserved: 1; }; -struct _tlb_table { - unsigned char descriptor; - char tlb_type; - unsigned int entries; - char info[128]; +struct irq_matrix; + +union IO_APIC_reg_00 { + u32 raw; + struct { + u32 __reserved_2: 14; + u32 LTS: 1; + u32 delivery_type: 1; + u32 __reserved_1: 8; + u32 ID: 8; + } bits; }; -enum tsx_ctrl_states { - TSX_CTRL_ENABLE = 0, - TSX_CTRL_DISABLE = 1, - TSX_CTRL_NOT_SUPPORTED = 2, +union IO_APIC_reg_01 { + u32 raw; + struct { + u32 version: 8; + u32 __reserved_2: 7; + u32 PRQ: 1; + u32 entries: 8; + u32 __reserved_1: 8; + } bits; }; -struct sku_microcode { - u8 model; - u8 stepping; - u32 microcode; +union IO_APIC_reg_02 { + u32 raw; + struct { + u32 __reserved_2: 24; + u32 arbitration: 4; + u32 __reserved_1: 4; + } bits; }; -struct cpuid_regs { - u32 eax; - u32 ebx; - u32 ecx; - u32 edx; +union IO_APIC_reg_03 { + u32 raw; + struct { + u32 boot_DT: 1; + u32 __reserved_1: 31; + } bits; }; -enum pconfig_target { - INVALID_TARGET = 0, - MKTME_TARGET = 1, - PCONFIG_TARGET_NR = 2, +struct IR_IO_APIC_route_entry { + __u64 vector: 8; + __u64 zero: 3; + __u64 index2: 1; + __u64 delivery_status: 1; + __u64 polarity: 1; + __u64 irr: 1; + __u64 trigger: 1; + __u64 mask: 1; + __u64 reserved: 31; + __u64 format: 1; + __u64 index: 15; }; enum { - PCONFIG_CPUID_SUBLEAF_INVALID = 0, - PCONFIG_CPUID_SUBLEAF_TARGETID = 1, + IRQ_TYPE_NONE = 0, + IRQ_TYPE_EDGE_RISING = 1, + IRQ_TYPE_EDGE_FALLING = 2, + IRQ_TYPE_EDGE_BOTH = 3, + IRQ_TYPE_LEVEL_HIGH = 4, + IRQ_TYPE_LEVEL_LOW = 8, + IRQ_TYPE_LEVEL_MASK = 12, + IRQ_TYPE_SENSE_MASK = 15, + IRQ_TYPE_DEFAULT = 15, + IRQ_TYPE_PROBE = 16, + IRQ_LEVEL = 256, + IRQ_PER_CPU = 512, + IRQ_NOPROBE = 1024, + IRQ_NOREQUEST = 2048, + IRQ_NOAUTOEN = 4096, + IRQ_NO_BALANCING = 8192, + IRQ_MOVE_PCNTXT = 16384, + IRQ_NESTED_THREAD = 32768, + IRQ_NOTHREAD = 65536, + IRQ_PER_CPU_DEVID = 131072, + IRQ_IS_POLLED = 262144, + IRQ_DISABLE_UNLAZY = 524288, }; -typedef u8 pto_T_____4; - -enum mf_flags { - MF_COUNT_INCREASED = 1, - MF_ACTION_REQUIRED = 2, - MF_MUST_KILL = 4, - MF_SOFT_OFFLINE = 8, +enum { + IRQCHIP_SET_TYPE_MASKED = 1, + IRQCHIP_EOI_IF_HANDLED = 2, + IRQCHIP_MASK_ON_SUSPEND = 4, + IRQCHIP_ONOFFLINE_ENABLED = 8, + IRQCHIP_SKIP_SET_WAKE = 16, + IRQCHIP_ONESHOT_SAFE = 32, + IRQCHIP_EOI_THREADED = 64, + IRQCHIP_SUPPORTS_LEVEL_MSI = 128, + IRQCHIP_SUPPORTS_NMI = 256, }; -struct mce { - __u64 status; - __u64 misc; - __u64 addr; - __u64 mcgstatus; - __u64 ip; - __u64 tsc; - __u64 time; - __u8 cpuvendor; - __u8 inject_flags; - __u8 severity; - __u8 pad; - __u32 cpuid; - __u8 cs; - __u8 bank; - __u8 cpu; - __u8 finished; - __u32 extcpu; - __u32 socketid; - __u32 apicid; - __u64 mcgcap; - __u64 synd; - __u64 ipid; - __u64 ppin; - __u32 microcode; +struct irq_pin_list { + struct list_head list; + int apic; + int pin; }; -enum mce_notifier_prios { - MCE_PRIO_FIRST = 2147483647, - MCE_PRIO_SRAO = 2147483646, - MCE_PRIO_EXTLOG = 2147483645, - MCE_PRIO_NFIT = 2147483644, - MCE_PRIO_EDAC = 2147483643, - MCE_PRIO_MCELOG = 1, - MCE_PRIO_LOWEST = 0, +struct mp_chip_data { + struct list_head irq_2_pin; + struct IO_APIC_route_entry entry; + int trigger; + int polarity; + u32 count; + bool isa_irq; }; -typedef long unsigned int mce_banks_t[1]; - -enum mcp_flags { - MCP_TIMESTAMP = 1, - MCP_UC = 2, - MCP_DONTLOG = 4, +struct mp_ioapic_gsi { + u32 gsi_base; + u32 gsi_end; }; -enum severity_level { - MCE_NO_SEVERITY = 0, - MCE_DEFERRED_SEVERITY = 1, - MCE_UCNA_SEVERITY = 1, - MCE_KEEP_SEVERITY = 2, - MCE_SOME_SEVERITY = 3, - MCE_AO_SEVERITY = 4, - MCE_UC_SEVERITY = 5, - MCE_AR_SEVERITY = 6, - MCE_PANIC_SEVERITY = 7, +struct ioapic { + int nr_registers; + struct IO_APIC_route_entry *saved_registers; + struct mpc_ioapic mp_config; + struct mp_ioapic_gsi gsi_config; + struct ioapic_domain_cfg irqdomain_cfg; + struct irq_domain *irqdomain; + struct resource *iomem_res; }; -struct mce_evt_llist { - struct llist_node llnode; - struct mce mce; +struct io_apic { + unsigned int index; + unsigned int unused[3]; + unsigned int data; + unsigned int unused2[11]; + unsigned int eoi; }; -struct mca_config { - bool dont_log_ce; - bool cmci_disabled; - bool ignore_ce; - __u64 lmce_disabled: 1; - __u64 disabled: 1; - __u64 ser: 1; - __u64 recovery: 1; - __u64 bios_cmci_threshold: 1; - long: 35; - __u64 __reserved: 59; - s8 bootlog; - int tolerant; - int monarch_timeout; - int panic_timeout; - u32 rip_msr; +union entry_union { + struct { + u32 w1; + u32 w2; + }; + struct IO_APIC_route_entry entry; }; -struct mce_vendor_flags { - __u64 overflow_recov: 1; - __u64 succor: 1; - __u64 smca: 1; - __u64 __reserved_0: 61; -}; +typedef struct irq_alloc_info msi_alloc_info_t; -struct mca_msr_regs { - u32 (*ctl)(int); - u32 (*status)(int); - u32 (*addr)(int); - u32 (*misc)(int); -}; +struct msi_domain_info; -struct trace_event_raw_mce_record { - struct trace_entry ent; - u64 mcgcap; - u64 mcgstatus; - u64 status; - u64 addr; - u64 misc; - u64 synd; - u64 ipid; - u64 ip; - u64 tsc; - u64 walltime; - u32 cpu; - u32 cpuid; - u32 apicid; - u32 socketid; - u8 cs; - u8 bank; - u8 cpuvendor; - char __data[0]; +struct msi_domain_ops { + irq_hw_number_t (*get_hwirq)(struct msi_domain_info *, msi_alloc_info_t *); + int (*msi_init)(struct irq_domain *, struct msi_domain_info *, unsigned int, irq_hw_number_t, msi_alloc_info_t *); + void (*msi_free)(struct irq_domain *, struct msi_domain_info *, unsigned int); + int (*msi_check)(struct irq_domain *, struct msi_domain_info *, struct device *); + int (*msi_prepare)(struct irq_domain *, struct device *, int, msi_alloc_info_t *); + void (*msi_finish)(msi_alloc_info_t *, int); + void (*set_desc)(msi_alloc_info_t *, struct msi_desc *); + int (*handle_error)(struct irq_domain *, struct msi_desc *, int); }; -struct trace_event_data_offsets_mce_record {}; - -struct mce_bank { - u64 ctl; - bool init; +struct msi_domain_info { + u32 flags; + struct msi_domain_ops *ops; + struct irq_chip *chip; + void *chip_data; + irq_flow_handler_t handler; + void *handler_data; + const char *handler_name; + void *data; }; -struct mce_bank_dev { - struct device_attribute attr; - char attrname[16]; - u8 bank; +enum { + MSI_FLAG_USE_DEF_DOM_OPS = 1, + MSI_FLAG_USE_DEF_CHIP_OPS = 2, + MSI_FLAG_MULTI_PCI_MSI = 4, + MSI_FLAG_PCI_MSIX = 8, + MSI_FLAG_ACTIVATE_EARLY = 16, + MSI_FLAG_MUST_REACTIVATE = 32, + MSI_FLAG_LEVEL_CAPABLE = 64, }; -enum context { - IN_KERNEL = 1, - IN_USER = 2, - IN_KERNEL_RECOV = 3, -}; +struct hpet_channel; -enum ser { - SER_REQUIRED = 1, - NO_SER = 2, +struct x86_mapping_info { + void * (*alloc_pgt_page)(void *); + void *context; + long unsigned int page_flag; + long unsigned int offset; + bool direct_gbpages; + long unsigned int kernpg_flag; }; -enum exception { - EXCP_CONTEXT = 1, - NO_EXCP = 2, -}; +struct kexec_file_ops; -struct severity { - u64 mask; - u64 result; - unsigned char sev; - unsigned char mcgmask; - unsigned char mcgres; - unsigned char ser; - unsigned char context; - unsigned char excp; - unsigned char covered; - char *msg; +struct init_pgtable_data { + struct x86_mapping_info *info; + pgd_t *level4p; }; -struct gen_pool; +struct kretprobe_instance; -typedef long unsigned int (*genpool_algo_t)(long unsigned int *, long unsigned int, long unsigned int, unsigned int, void *, struct gen_pool *, long unsigned int); +typedef int (*kretprobe_handler_t)(struct kretprobe_instance *, struct pt_regs *); -struct gen_pool { - spinlock_t lock; - struct list_head chunks; - int min_alloc_order; - genpool_algo_t algo; - void *data; - const char *name; -}; +struct kretprobe; -enum { - CMCI_STORM_NONE = 0, - CMCI_STORM_ACTIVE = 1, - CMCI_STORM_SUBSIDED = 2, +struct kretprobe_instance { + struct hlist_node hlist; + struct kretprobe *rp; + kprobe_opcode_t *ret_addr; + struct task_struct *task; + void *fp; + char data[0]; }; -enum kobject_action { - KOBJ_ADD = 0, - KOBJ_REMOVE = 1, - KOBJ_CHANGE = 2, - KOBJ_MOVE = 3, - KOBJ_ONLINE = 4, - KOBJ_OFFLINE = 5, - KOBJ_BIND = 6, - KOBJ_UNBIND = 7, - KOBJ_MAX = 8, +struct kretprobe { + struct kprobe kp; + kretprobe_handler_t handler; + kretprobe_handler_t entry_handler; + int maxactive; + int nmissed; + size_t data_size; + struct hlist_head free_instances; + raw_spinlock_t lock; }; -enum smca_bank_types { - SMCA_LS = 0, - SMCA_IF = 1, - SMCA_L2_CACHE = 2, - SMCA_DE = 3, - SMCA_RESERVED = 4, - SMCA_EX = 5, - SMCA_FP = 6, - SMCA_L3_CACHE = 7, - SMCA_CS = 8, - SMCA_CS_V2 = 9, - SMCA_PIE = 10, - SMCA_UMC = 11, - SMCA_PB = 12, - SMCA_PSP = 13, - SMCA_PSP_V2 = 14, - SMCA_SMU = 15, - SMCA_SMU_V2 = 16, - SMCA_MP5 = 17, - SMCA_NBIO = 18, - SMCA_PCIE = 19, - N_SMCA_BANK_TYPES = 20, -}; +typedef struct kprobe *pto_T_____12; -struct smca_hwid { - unsigned int bank_type; - u32 hwid_mcatype; - u32 xec_bitmap; - u8 count; -}; +struct __arch_relative_insn { + u8 op; + s32 raddr; +} __attribute__((packed)); -struct smca_bank { - struct smca_hwid *hwid; - u32 id; - u8 sysfs_id; +struct arch_optimized_insn { + kprobe_opcode_t copied_insn[4]; + kprobe_opcode_t *insn; + size_t size; }; -struct smca_bank_name { - const char *name; - const char *long_name; +struct optimized_kprobe { + struct kprobe kp; + struct list_head list; + struct arch_optimized_insn optinsn; }; -struct thresh_restart { - struct threshold_block *b; - int reset; - int set_lvt_off; - int lvt_off; - u16 old_limit; +typedef __u64 Elf64_Off; + +struct elf64_rela { + Elf64_Addr r_offset; + Elf64_Xword r_info; + Elf64_Sxword r_addend; }; -struct threshold_attr { - struct attribute attr; - ssize_t (*show)(struct threshold_block *, char *); - ssize_t (*store)(struct threshold_block *, const char *, size_t); +typedef struct elf64_rela Elf64_Rela; + +struct elf64_hdr { + unsigned char e_ident[16]; + Elf64_Half e_type; + Elf64_Half e_machine; + Elf64_Word e_version; + Elf64_Addr e_entry; + Elf64_Off e_phoff; + Elf64_Off e_shoff; + Elf64_Word e_flags; + Elf64_Half e_ehsize; + Elf64_Half e_phentsize; + Elf64_Half e_phnum; + Elf64_Half e_shentsize; + Elf64_Half e_shnum; + Elf64_Half e_shstrndx; }; -struct _thermal_state { - u64 next_check; - u64 last_interrupt_time; - struct delayed_work therm_work; - long unsigned int count; - long unsigned int last_count; - long unsigned int max_time_ms; - long unsigned int total_time_ms; - bool rate_control_active; - bool new_event; - u8 level; - u8 sample_index; - u8 sample_count; - u8 average; - u8 baseline_temp; - u8 temp_samples[3]; +typedef struct elf64_hdr Elf64_Ehdr; + +struct elf64_shdr { + Elf64_Word sh_name; + Elf64_Word sh_type; + Elf64_Xword sh_flags; + Elf64_Addr sh_addr; + Elf64_Off sh_offset; + Elf64_Xword sh_size; + Elf64_Word sh_link; + Elf64_Word sh_info; + Elf64_Xword sh_addralign; + Elf64_Xword sh_entsize; }; -struct thermal_state { - struct _thermal_state core_throttle; - struct _thermal_state core_power_limit; - struct _thermal_state package_throttle; - struct _thermal_state package_power_limit; - struct _thermal_state core_thresh0; - struct _thermal_state core_thresh1; - struct _thermal_state pkg_thresh0; - struct _thermal_state pkg_thresh1; +typedef struct elf64_shdr Elf64_Shdr; + +struct hpet_data { + long unsigned int hd_phys_address; + void *hd_address; + short unsigned int hd_nirqs; + unsigned int hd_state; + unsigned int hd_irq[32]; }; -typedef int (*cpu_stop_fn_t)(void *); +typedef irqreturn_t (*rtc_irq_handler)(int, void *); -typedef __u8 mtrr_type; +enum hpet_mode { + HPET_MODE_UNUSED = 0, + HPET_MODE_LEGACY = 1, + HPET_MODE_CLOCKEVT = 2, + HPET_MODE_DEVICE = 3, +}; -struct mtrr_ops { - u32 vendor; - u32 use_intel_if; - void (*set)(unsigned int, long unsigned int, long unsigned int, mtrr_type); - void (*set_all)(); - void (*get)(unsigned int, long unsigned int *, long unsigned int *, mtrr_type *); - int (*get_free_region)(long unsigned int, long unsigned int, int); - int (*validate_add_page)(long unsigned int, long unsigned int, unsigned int); - int (*have_wrcomb)(); +struct hpet_channel___2 { + struct clock_event_device evt; + unsigned int num; + unsigned int cpu; + unsigned int irq; + unsigned int in_use; + enum hpet_mode mode; + unsigned int boot_cfg; + char name[10]; + long: 48; + long: 64; + long: 64; + long: 64; }; -struct set_mtrr_data { - long unsigned int smp_base; - long unsigned int smp_size; - unsigned int smp_reg; - mtrr_type smp_type; +struct hpet_base { + unsigned int nr_channels; + unsigned int nr_clockevents; + unsigned int boot_cfg; + struct hpet_channel___2 *channels; }; -struct mtrr_value { - mtrr_type ltype; - long unsigned int lbase; - long unsigned int lsize; +union hpet_lock { + struct { + arch_spinlock_t lock; + u32 value; + }; + u64 lockval; }; -struct mtrr_sentry { - __u64 base; - __u32 size; - __u32 type; +struct amd_northbridge_info { + u16 num; + u64 flags; + struct amd_northbridge *nb; }; -struct mtrr_gentry { - __u64 base; - __u32 size; - __u32 regnum; - __u32 type; - __u32 _pad; +struct scan_area { + u64 addr; + u64 size; }; -typedef u32 compat_uint_t; +struct uprobe_xol_ops; -struct mtrr_sentry32 { - compat_ulong_t base; - compat_uint_t size; - compat_uint_t type; +struct arch_uprobe { + union { + u8 insn[16]; + u8 ixol[16]; + }; + const struct uprobe_xol_ops *ops; + union { + struct { + s32 offs; + u8 ilen; + u8 opc1; + } branch; + struct { + u8 fixups; + u8 ilen; + } defparam; + struct { + u8 reg_offset; + u8 ilen; + } push; + }; }; -struct mtrr_gentry32 { - compat_ulong_t regnum; - compat_uint_t base; - compat_uint_t size; - compat_uint_t type; +struct uprobe_xol_ops { + bool (*emulate)(struct arch_uprobe *, struct pt_regs *); + int (*pre_xol)(struct arch_uprobe *, struct pt_regs *); + int (*post_xol)(struct arch_uprobe *, struct pt_regs *); + void (*abort)(struct arch_uprobe *, struct pt_regs *); }; -struct mtrr_var_range { - __u32 base_lo; - __u32 base_hi; - __u32 mask_lo; - __u32 mask_hi; +enum rp_check { + RP_CHECK_CALL = 0, + RP_CHECK_CHAIN_CALL = 1, + RP_CHECK_RET = 2, }; -struct mtrr_state_type { - struct mtrr_var_range var_ranges[256]; - mtrr_type fixed_ranges[88]; - unsigned char enabled; - unsigned char have_fixed; - mtrr_type def_type; +enum dev_prop_type { + DEV_PROP_U8 = 0, + DEV_PROP_U16 = 1, + DEV_PROP_U32 = 2, + DEV_PROP_U64 = 3, + DEV_PROP_STRING = 4, }; -struct fixed_range_block { - int base_msr; - int ranges; +struct property_entry { + const char *name; + size_t length; + bool is_array; + enum dev_prop_type type; + union { + const void *pointer; + union { + u8 u8_data; + u16 u16_data; + u32 u32_data; + u64 u64_data; + const char *str; + } value; + }; }; -struct range { - u64 start; - u64 end; +struct fb_fix_screeninfo { + char id[16]; + long unsigned int smem_start; + __u32 smem_len; + __u32 type; + __u32 type_aux; + __u32 visual; + __u16 xpanstep; + __u16 ypanstep; + __u16 ywrapstep; + __u32 line_length; + long unsigned int mmio_start; + __u32 mmio_len; + __u32 accel; + __u16 capabilities; + __u16 reserved[2]; }; -struct var_mtrr_range_state { - long unsigned int base_pfn; - long unsigned int size_pfn; - mtrr_type type; +struct fb_bitfield { + __u32 offset; + __u32 length; + __u32 msb_right; }; -struct subsys_interface { - const char *name; - struct bus_type *subsys; - struct list_head node; - int (*add_dev)(struct device *, struct subsys_interface *); - void (*remove_dev)(struct device *, struct subsys_interface *); +struct fb_var_screeninfo { + __u32 xres; + __u32 yres; + __u32 xres_virtual; + __u32 yres_virtual; + __u32 xoffset; + __u32 yoffset; + __u32 bits_per_pixel; + __u32 grayscale; + struct fb_bitfield red; + struct fb_bitfield green; + struct fb_bitfield blue; + struct fb_bitfield transp; + __u32 nonstd; + __u32 activate; + __u32 height; + __u32 width; + __u32 accel_flags; + __u32 pixclock; + __u32 left_margin; + __u32 right_margin; + __u32 upper_margin; + __u32 lower_margin; + __u32 hsync_len; + __u32 vsync_len; + __u32 sync; + __u32 vmode; + __u32 rotate; + __u32 colorspace; + __u32 reserved[4]; }; -struct property_entry; - -struct platform_device_info { - struct device *parent; - struct fwnode_handle *fwnode; - bool of_node_reused; - const char *name; - int id; - const struct resource *res; - unsigned int num_res; - const void *data; - size_t size_data; - u64 dma_mask; - struct property_entry *properties; +struct fb_cmap { + __u32 start; + __u32 len; + __u16 *red; + __u16 *green; + __u16 *blue; + __u16 *transp; }; -struct builtin_fw { - char *name; - void *data; - long unsigned int size; +struct fb_copyarea { + __u32 dx; + __u32 dy; + __u32 width; + __u32 height; + __u32 sx; + __u32 sy; }; -struct cpio_data { - void *data; - size_t size; - char name[18]; +struct fb_fillrect { + __u32 dx; + __u32 dy; + __u32 width; + __u32 height; + __u32 color; + __u32 rop; }; -struct cpu_signature { - unsigned int sig; - unsigned int pf; - unsigned int rev; +struct fb_image { + __u32 dx; + __u32 dy; + __u32 width; + __u32 height; + __u32 fg_color; + __u32 bg_color; + __u8 depth; + const char *data; + struct fb_cmap cmap; }; -enum ucode_state { - UCODE_OK = 0, - UCODE_NEW = 1, - UCODE_UPDATED = 2, - UCODE_NFOUND = 3, - UCODE_ERROR = 4, +struct fbcurpos { + __u16 x; + __u16 y; }; -struct microcode_ops { - enum ucode_state (*request_microcode_user)(int, const void *, size_t); - enum ucode_state (*request_microcode_fw)(int, struct device *, bool); - void (*microcode_fini_cpu)(int); - enum ucode_state (*apply_microcode)(int); - int (*collect_cpu_info)(int, struct cpu_signature *); +struct fb_cursor { + __u16 set; + __u16 enable; + __u16 rop; + const char *mask; + struct fbcurpos hot; + struct fb_image image; }; -struct ucode_cpu_info { - struct cpu_signature cpu_sig; - int valid; - void *mc; +struct fb_chroma { + __u32 redx; + __u32 greenx; + __u32 bluex; + __u32 whitex; + __u32 redy; + __u32 greeny; + __u32 bluey; + __u32 whitey; }; -struct cpu_info_ctx { - struct cpu_signature *cpu_sig; - int err; -}; +struct fb_videomode; -struct firmware { - size_t size; - const u8 *data; - struct page **pages; - void *priv; +struct fb_monspecs { + struct fb_chroma chroma; + struct fb_videomode *modedb; + __u8 manufacturer[4]; + __u8 monitor[14]; + __u8 serial_no[14]; + __u8 ascii[14]; + __u32 modedb_len; + __u32 model; + __u32 serial; + __u32 year; + __u32 week; + __u32 hfmin; + __u32 hfmax; + __u32 dclkmin; + __u32 dclkmax; + __u16 input; + __u16 dpms; + __u16 signal; + __u16 vfmin; + __u16 vfmax; + __u16 gamma; + __u16 gtf: 1; + __u16 misc; + __u8 version; + __u8 revision; + __u8 max_x; + __u8 max_y; }; -struct ucode_patch { - struct list_head plist; - void *data; - u32 patch_id; - u16 equiv_cpu; -}; +struct fb_info; -struct microcode_header_intel { - unsigned int hdrver; - unsigned int rev; - unsigned int date; - unsigned int sig; - unsigned int cksum; - unsigned int ldrver; - unsigned int pf; - unsigned int datasize; - unsigned int totalsize; - unsigned int reserved[3]; +struct fb_pixmap { + u8 *addr; + u32 size; + u32 offset; + u32 buf_align; + u32 scan_align; + u32 access_align; + u32 flags; + u32 blit_x; + u32 blit_y; + void (*writeio)(struct fb_info *, void *, void *, unsigned int); + void (*readio)(struct fb_info *, void *, void *, unsigned int); }; -struct microcode_intel { - struct microcode_header_intel hdr; - unsigned int bits[0]; -}; +struct fb_deferred_io; -struct extended_signature { - unsigned int sig; - unsigned int pf; - unsigned int cksum; +struct fb_ops; + +struct fb_tile_ops; + +struct apertures_struct; + +struct fb_info { + atomic_t count; + int node; + int flags; + int fbcon_rotate_hint; + struct mutex lock; + struct mutex mm_lock; + struct fb_var_screeninfo var; + struct fb_fix_screeninfo fix; + struct fb_monspecs monspecs; + struct work_struct queue; + struct fb_pixmap pixmap; + struct fb_pixmap sprite; + struct fb_cmap cmap; + struct list_head modelist; + struct fb_videomode *mode; + struct delayed_work deferred_work; + struct fb_deferred_io *fbdefio; + struct fb_ops *fbops; + struct device *device; + struct device *dev; + int class_flag; + struct fb_tile_ops *tileops; + union { + char *screen_base; + char *screen_buffer; + }; + long unsigned int screen_size; + void *pseudo_palette; + u32 state; + void *fbcon_par; + void *par; + struct apertures_struct *apertures; + bool skip_vt_switch; }; -struct extended_sigtable { - unsigned int count; - unsigned int cksum; - unsigned int reserved[3]; - struct extended_signature sigs[0]; +struct fb_videomode { + const char *name; + u32 refresh; + u32 xres; + u32 yres; + u32 pixclock; + u32 left_margin; + u32 right_margin; + u32 upper_margin; + u32 lower_margin; + u32 hsync_len; + u32 vsync_len; + u32 sync; + u32 vmode; + u32 flag; }; -struct equiv_cpu_entry { - u32 installed_cpu; - u32 fixed_errata_mask; - u32 fixed_errata_compare; - u16 equiv_cpu; - u16 res; +struct fb_blit_caps { + u32 x; + u32 y; + u32 len; + u32 flags; }; -struct microcode_header_amd { - u32 data_code; - u32 patch_id; - u16 mc_patch_data_id; - u8 mc_patch_data_len; - u8 init_flag; - u32 mc_patch_data_checksum; - u32 nb_dev_id; - u32 sb_dev_id; - u16 processor_rev_id; - u8 nb_rev_id; - u8 sb_rev_id; - u8 bios_api_rev; - u8 reserved1[3]; - u32 match_reg[8]; +struct fb_deferred_io { + long unsigned int delay; + struct mutex lock; + struct list_head pagelist; + void (*first_io)(struct fb_info *); + void (*deferred_io)(struct fb_info *, struct list_head *); }; -struct microcode_amd { - struct microcode_header_amd hdr; - unsigned int mpb[0]; +struct fb_ops { + struct module *owner; + int (*fb_open)(struct fb_info *, int); + int (*fb_release)(struct fb_info *, int); + ssize_t (*fb_read)(struct fb_info *, char *, size_t, loff_t *); + ssize_t (*fb_write)(struct fb_info *, const char *, size_t, loff_t *); + int (*fb_check_var)(struct fb_var_screeninfo *, struct fb_info *); + int (*fb_set_par)(struct fb_info *); + int (*fb_setcolreg)(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, struct fb_info *); + int (*fb_setcmap)(struct fb_cmap *, struct fb_info *); + int (*fb_blank)(int, struct fb_info *); + int (*fb_pan_display)(struct fb_var_screeninfo *, struct fb_info *); + void (*fb_fillrect)(struct fb_info *, const struct fb_fillrect *); + void (*fb_copyarea)(struct fb_info *, const struct fb_copyarea *); + void (*fb_imageblit)(struct fb_info *, const struct fb_image *); + int (*fb_cursor)(struct fb_info *, struct fb_cursor *); + int (*fb_sync)(struct fb_info *); + int (*fb_ioctl)(struct fb_info *, unsigned int, long unsigned int); + int (*fb_compat_ioctl)(struct fb_info *, unsigned int, long unsigned int); + int (*fb_mmap)(struct fb_info *, struct vm_area_struct *); + void (*fb_get_caps)(struct fb_info *, struct fb_blit_caps *, struct fb_var_screeninfo *); + void (*fb_destroy)(struct fb_info *); + int (*fb_debug_enter)(struct fb_info *); + int (*fb_debug_leave)(struct fb_info *); }; -struct equiv_cpu_table { - unsigned int num_entries; - struct equiv_cpu_entry *entry; +struct fb_tilemap { + __u32 width; + __u32 height; + __u32 depth; + __u32 length; + const __u8 *data; }; -struct cont_desc { - struct microcode_amd *mc; - u32 cpuid_1_eax; - u32 psize; - u8 *data; - size_t size; +struct fb_tilerect { + __u32 sx; + __u32 sy; + __u32 width; + __u32 height; + __u32 index; + __u32 fg; + __u32 bg; + __u32 rop; }; -struct mpc_intsrc { - unsigned char type; - unsigned char irqtype; - short unsigned int irqflag; - unsigned char srcbus; - unsigned char srcbusirq; - unsigned char dstapic; - unsigned char dstirq; +struct fb_tilearea { + __u32 sx; + __u32 sy; + __u32 dx; + __u32 dy; + __u32 width; + __u32 height; }; -enum mp_irq_source_types { - mp_INT = 0, - mp_NMI = 1, - mp_SMI = 2, - mp_ExtINT = 3, +struct fb_tileblit { + __u32 sx; + __u32 sy; + __u32 width; + __u32 height; + __u32 fg; + __u32 bg; + __u32 length; + __u32 *indices; }; -struct IO_APIC_route_entry { - __u32 vector: 8; - __u32 delivery_mode: 3; - __u32 dest_mode: 1; - __u32 delivery_status: 1; - __u32 polarity: 1; - __u32 irr: 1; - __u32 trigger: 1; - __u32 mask: 1; - __u32 __reserved_2: 15; - __u32 __reserved_3: 24; - __u32 dest: 8; +struct fb_tilecursor { + __u32 sx; + __u32 sy; + __u32 mode; + __u32 shape; + __u32 fg; + __u32 bg; }; -typedef u64 acpi_io_address; - -typedef u64 acpi_physical_address; - -typedef u32 acpi_status; +struct fb_tile_ops { + void (*fb_settile)(struct fb_info *, struct fb_tilemap *); + void (*fb_tilecopy)(struct fb_info *, struct fb_tilearea *); + void (*fb_tilefill)(struct fb_info *, struct fb_tilerect *); + void (*fb_tileblit)(struct fb_info *, struct fb_tileblit *); + void (*fb_tilecursor)(struct fb_info *, struct fb_tilecursor *); + int (*fb_get_tilemax)(struct fb_info *); +}; -typedef char *acpi_string; +struct aperture { + resource_size_t base; + resource_size_t size; +}; -typedef void *acpi_handle; +struct apertures_struct { + unsigned int count; + struct aperture ranges[0]; +}; -typedef u32 acpi_object_type; +struct dmt_videomode { + u32 dmt_id; + u32 std_2byte_code; + u32 cvt_3byte_code; + const struct fb_videomode *mode; +}; -typedef u8 acpi_adr_space_type; +struct simplefb_platform_data { + u32 width; + u32 height; + u32 stride; + const char *format; +}; -union acpi_object { - acpi_object_type type; - struct { - acpi_object_type type; - u64 value; - } integer; - struct { - acpi_object_type type; - u32 length; - char *pointer; - } string; - struct { - acpi_object_type type; - u32 length; - u8 *pointer; - } buffer; - struct { - acpi_object_type type; - u32 count; - union acpi_object *elements; - } package; - struct { - acpi_object_type type; - acpi_object_type actual_type; - acpi_handle handle; - } reference; - struct { - acpi_object_type type; - u32 proc_id; - acpi_io_address pblk_address; - u32 pblk_length; - } processor; - struct { - acpi_object_type type; - u32 system_level; - u32 resource_order; - } power_resource; +struct efifb_dmi_info { + char *optname; + long unsigned int base; + int stride; + int width; + int height; + int flags; }; -struct acpi_object_list { - u32 count; - union acpi_object *pointer; +enum { + M_I17 = 0, + M_I20 = 1, + M_I20_SR = 2, + M_I24 = 3, + M_I24_8_1 = 4, + M_I24_10_1 = 5, + M_I27_11_1 = 6, + M_MINI = 7, + M_MINI_3_1 = 8, + M_MINI_4_1 = 9, + M_MB = 10, + M_MB_2 = 11, + M_MB_3 = 12, + M_MB_5_1 = 13, + M_MB_6_1 = 14, + M_MB_7_1 = 15, + M_MB_SR = 16, + M_MBA = 17, + M_MBA_3 = 18, + M_MBP = 19, + M_MBP_2 = 20, + M_MBP_2_2 = 21, + M_MBP_SR = 22, + M_MBP_4 = 23, + M_MBP_5_1 = 24, + M_MBP_5_2 = 25, + M_MBP_5_3 = 26, + M_MBP_6_1 = 27, + M_MBP_6_2 = 28, + M_MBP_7_1 = 29, + M_MBP_8_2 = 30, + M_UNKNOWN = 31, }; -struct acpi_subtable_header { - u8 type; - u8 length; +enum { + OVERRIDE_NONE = 0, + OVERRIDE_BASE = 1, + OVERRIDE_STRIDE = 2, + OVERRIDE_HEIGHT = 4, + OVERRIDE_WIDTH = 8, }; -struct acpi_table_boot { - struct acpi_table_header header; - u8 cmos_index; - u8 reserved[3]; +enum perf_sample_regs_abi { + PERF_SAMPLE_REGS_ABI_NONE = 0, + PERF_SAMPLE_REGS_ABI_32 = 1, + PERF_SAMPLE_REGS_ABI_64 = 2, }; -struct acpi_hmat_structure { - u16 type; - u16 reserved; - u32 length; +struct __va_list_tag { + unsigned int gp_offset; + unsigned int fp_offset; + void *overflow_arg_area; + void *reg_save_area; }; -struct acpi_table_hpet { - struct acpi_table_header header; - u32 id; - struct acpi_generic_address address; - u8 sequence; - u16 minimum_tick; - u8 flags; -} __attribute__((packed)); +typedef __builtin_va_list __gnuc_va_list; -struct acpi_table_madt { - struct acpi_table_header header; - u32 address; - u32 flags; +typedef __gnuc_va_list va_list; + +struct va_format { + const char *fmt; + va_list *va; }; -enum acpi_madt_type { - ACPI_MADT_TYPE_LOCAL_APIC = 0, - ACPI_MADT_TYPE_IO_APIC = 1, - ACPI_MADT_TYPE_INTERRUPT_OVERRIDE = 2, - ACPI_MADT_TYPE_NMI_SOURCE = 3, - ACPI_MADT_TYPE_LOCAL_APIC_NMI = 4, - ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE = 5, - ACPI_MADT_TYPE_IO_SAPIC = 6, - ACPI_MADT_TYPE_LOCAL_SAPIC = 7, - ACPI_MADT_TYPE_INTERRUPT_SOURCE = 8, - ACPI_MADT_TYPE_LOCAL_X2APIC = 9, - ACPI_MADT_TYPE_LOCAL_X2APIC_NMI = 10, - ACPI_MADT_TYPE_GENERIC_INTERRUPT = 11, - ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR = 12, - ACPI_MADT_TYPE_GENERIC_MSI_FRAME = 13, - ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR = 14, - ACPI_MADT_TYPE_GENERIC_TRANSLATOR = 15, - ACPI_MADT_TYPE_RESERVED = 16, +struct pci_hostbridge_probe { + u32 bus; + u32 slot; + u32 vendor; + u32 device; }; -struct acpi_madt_local_apic { - struct acpi_subtable_header header; - u8 processor_id; - u8 id; - u32 lapic_flags; +enum pg_level { + PG_LEVEL_NONE = 0, + PG_LEVEL_4K = 1, + PG_LEVEL_2M = 2, + PG_LEVEL_1G = 3, + PG_LEVEL_512G = 4, + PG_LEVEL_NUM = 5, }; -struct acpi_madt_io_apic { - struct acpi_subtable_header header; - u8 id; - u8 reserved; - u32 address; - u32 global_irq_base; +struct trace_print_flags { + long unsigned int mask; + const char *name; }; -struct acpi_madt_interrupt_override { - struct acpi_subtable_header header; - u8 bus; - u8 source_irq; - u32 global_irq; - u16 inti_flags; -} __attribute__((packed)); +enum tlb_flush_reason { + TLB_FLUSH_ON_TASK_SWITCH = 0, + TLB_REMOTE_SHOOTDOWN = 1, + TLB_LOCAL_SHOOTDOWN = 2, + TLB_LOCAL_MM_SHOOTDOWN = 3, + TLB_REMOTE_SEND_IPI = 4, + NR_TLB_FLUSH_REASONS = 5, +}; -struct acpi_madt_nmi_source { - struct acpi_subtable_header header; - u16 inti_flags; - u32 global_irq; +enum { + REGION_INTERSECTS = 0, + REGION_DISJOINT = 1, + REGION_MIXED = 2, }; -struct acpi_madt_local_apic_nmi { - struct acpi_subtable_header header; - u8 processor_id; - u16 inti_flags; - u8 lint; -} __attribute__((packed)); +struct trace_event_raw_tlb_flush { + struct trace_entry ent; + int reason; + long unsigned int pages; + char __data[0]; +}; -struct acpi_madt_local_apic_override { - struct acpi_subtable_header header; - u16 reserved; - u64 address; -} __attribute__((packed)); +struct trace_event_data_offsets_tlb_flush {}; -struct acpi_madt_local_sapic { - struct acpi_subtable_header header; - u8 processor_id; - u8 id; - u8 eid; - u8 reserved[3]; - u32 lapic_flags; - u32 uid; - char uid_string[1]; -} __attribute__((packed)); +typedef void (*btf_trace_tlb_flush)(void *, int, long unsigned int); -struct acpi_madt_local_x2apic { - struct acpi_subtable_header header; - u16 reserved; - u32 local_apic_id; - u32 lapic_flags; - u32 uid; +struct map_range { + long unsigned int start; + long unsigned int end; + unsigned int page_size_mask; }; -struct acpi_madt_local_x2apic_nmi { - struct acpi_subtable_header header; - u16 inti_flags; - u32 uid; - u8 lint; - u8 reserved[3]; +enum kcore_type { + KCORE_TEXT = 0, + KCORE_VMALLOC = 1, + KCORE_RAM = 2, + KCORE_VMEMMAP = 3, + KCORE_USER = 4, + KCORE_OTHER = 5, + KCORE_REMAP = 6, }; -enum acpi_irq_model_id { - ACPI_IRQ_MODEL_PIC = 0, - ACPI_IRQ_MODEL_IOAPIC = 1, - ACPI_IRQ_MODEL_IOSAPIC = 2, - ACPI_IRQ_MODEL_PLATFORM = 3, - ACPI_IRQ_MODEL_GIC = 4, - ACPI_IRQ_MODEL_COUNT = 5, +struct kcore_list { + struct list_head list; + long unsigned int addr; + long unsigned int vaddr; + size_t size; + int type; }; -union acpi_subtable_headers { - struct acpi_subtable_header common; - struct acpi_hmat_structure hmat; +struct hstate { + int next_nid_to_alloc; + int next_nid_to_free; + unsigned int order; + long unsigned int mask; + long unsigned int max_huge_pages; + long unsigned int nr_huge_pages; + long unsigned int free_huge_pages; + long unsigned int resv_huge_pages; + long unsigned int surplus_huge_pages; + long unsigned int nr_overcommit_huge_pages; + struct list_head hugepage_activelist; + struct list_head hugepage_freelists[64]; + unsigned int nr_huge_pages_node[64]; + unsigned int free_huge_pages_node[64]; + unsigned int surplus_huge_pages_node[64]; + char name[32]; }; -typedef int (*acpi_tbl_table_handler)(struct acpi_table_header *); +struct trace_event_raw_x86_exceptions { + struct trace_entry ent; + long unsigned int address; + long unsigned int ip; + long unsigned int error_code; + char __data[0]; +}; -typedef int (*acpi_tbl_entry_handler)(union acpi_subtable_headers *, const long unsigned int); +struct trace_event_data_offsets_x86_exceptions {}; -struct acpi_subtable_proc { - int id; - acpi_tbl_entry_handler handler; - int count; -}; +typedef void (*btf_trace_page_fault_user)(void *, long unsigned int, struct pt_regs *, long unsigned int); -typedef u32 phys_cpuid_t; +typedef void (*btf_trace_page_fault_kernel)(void *, long unsigned int, struct pt_regs *, long unsigned int); -enum irq_alloc_type { - X86_IRQ_ALLOC_TYPE_IOAPIC = 1, - X86_IRQ_ALLOC_TYPE_HPET = 2, - X86_IRQ_ALLOC_TYPE_MSI = 3, - X86_IRQ_ALLOC_TYPE_MSIX = 4, - X86_IRQ_ALLOC_TYPE_DMAR = 5, - X86_IRQ_ALLOC_TYPE_UV = 6, +enum { + IORES_MAP_SYSTEM_RAM = 1, + IORES_MAP_ENCRYPTED = 2, }; -struct irq_alloc_info { - enum irq_alloc_type type; - u32 flags; - const struct cpumask *mask; - union { - int unused; - struct { - int hpet_id; - int hpet_index; - void *hpet_data; - }; - struct { - struct pci_dev *msi_dev; - irq_hw_number_t msi_hwirq; - }; - struct { - int ioapic_id; - int ioapic_pin; - int ioapic_node; - u32 ioapic_trigger: 1; - u32 ioapic_polarity: 1; - u32 ioapic_valid: 1; - struct IO_APIC_route_entry *ioapic_entry; - }; - struct { - int dmar_id; - void *dmar_data; - }; - }; +struct ioremap_desc { + unsigned int flags; }; -enum ioapic_domain_type { - IOAPIC_DOMAIN_INVALID = 0, - IOAPIC_DOMAIN_LEGACY = 1, - IOAPIC_DOMAIN_STRICT = 2, - IOAPIC_DOMAIN_DYNAMIC = 3, +typedef bool (*ex_handler_t)(const struct exception_table_entry *, struct pt_regs *, int, long unsigned int, long unsigned int); + +struct cpa_data { + long unsigned int *vaddr; + pgd_t *pgd; + pgprot_t mask_set; + pgprot_t mask_clr; + long unsigned int numpages; + long unsigned int curpage; + long unsigned int pfn; + unsigned int flags; + unsigned int force_split: 1; + unsigned int force_static_prot: 1; + struct page **pages; }; -struct ioapic_domain_cfg { - enum ioapic_domain_type type; - const struct irq_domain_ops *ops; - struct device_node *dev; +enum cpa_warn { + CPA_CONFLICT = 0, + CPA_PROTECT = 1, + CPA_DETECT = 2, }; -struct wakeup_header { - u16 video_mode; - u32 pmode_entry; - u16 pmode_cs; - u32 pmode_cr0; - u32 pmode_cr3; - u32 pmode_cr4; - u32 pmode_efer_low; - u32 pmode_efer_high; - u64 pmode_gdt; - u32 pmode_misc_en_low; - u32 pmode_misc_en_high; - u32 pmode_behavior; - u32 realmode_flags; - u32 real_magic; - u32 signature; -} __attribute__((packed)); +typedef struct { + u64 val; +} pfn_t; -struct cpc_reg { - u8 descriptor; - u16 length; - u8 space_id; - u8 bit_width; - u8 bit_offset; - u8 access_width; - u64 address; -} __attribute__((packed)); +struct memtype { + u64 start; + u64 end; + u64 subtree_max_end; + enum page_cache_mode type; + struct rb_node rb; +}; + +enum { + PAT_UC = 0, + PAT_WC = 1, + PAT_WT = 4, + PAT_WP = 5, + PAT_WB = 6, + PAT_UC_MINUS = 7, +}; -struct acpi_power_register { - u8 descriptor; - u16 length; - u8 space_id; - u8 bit_width; - u8 bit_offset; - u8 access_size; - u64 address; -} __attribute__((packed)); +struct pagerange_state { + long unsigned int cur_pfn; + int ram; + int not_ram; +}; -struct acpi_processor_cx { - u8 valid; - u8 type; - u32 address; - u8 entry_method; - u8 index; - u32 latency; - u8 bm_sts_skip; - char desc[32]; +struct flush_tlb_info { + struct mm_struct *mm; + long unsigned int start; + long unsigned int end; + u64 new_tlb_gen; + unsigned int stride_shift; + bool freed_tables; }; -struct acpi_processor_flags { - u8 power: 1; - u8 performance: 1; - u8 throttling: 1; - u8 limit: 1; - u8 bm_control: 1; - u8 bm_check: 1; - u8 has_cst: 1; - u8 has_lpi: 1; - u8 power_setup_done: 1; - u8 bm_rld_set: 1; - u8 need_hotplug_init: 1; +typedef u16 pto_T_____13; + +typedef struct mm_struct *pto_T_____14; + +struct exception_stacks { + char DF_stack_guard[0]; + char DF_stack[4096]; + char NMI_stack_guard[0]; + char NMI_stack[4096]; + char DB2_stack_guard[0]; + char DB2_stack[0]; + char DB1_stack_guard[0]; + char DB1_stack[4096]; + char DB_stack_guard[0]; + char DB_stack[4096]; + char MCE_stack_guard[0]; + char MCE_stack[4096]; + char IST_top_guard[0]; }; -struct cstate_entry { - struct { - unsigned int eax; - unsigned int ecx; - } states[8]; +struct rb_augment_callbacks { + void (*propagate)(struct rb_node *, struct rb_node *); + void (*copy)(struct rb_node *, struct rb_node *); + void (*rotate)(struct rb_node *, struct rb_node *); }; -enum reboot_mode { - REBOOT_UNDEFINED = 4294967295, - REBOOT_COLD = 0, - REBOOT_WARM = 1, - REBOOT_HARD = 2, - REBOOT_SOFT = 3, - REBOOT_GPIO = 4, +enum { + MEMTYPE_EXACT_MATCH = 0, + MEMTYPE_END_MATCH = 1, }; -enum reboot_type { - BOOT_TRIPLE = 116, - BOOT_KBD = 107, - BOOT_BIOS = 98, - BOOT_ACPI = 97, - BOOT_EFI = 101, - BOOT_CF9_FORCE = 112, - BOOT_CF9_SAFE = 113, +struct hugepage_subpool { + spinlock_t lock; + long int count; + long int max_hpages; + long int used_hpages; + struct hstate *hstate; + long int min_hpages; + long int rsv_hpages; }; -struct machine_ops { - void (*restart)(char *); - void (*halt)(); - void (*power_off)(); - void (*shutdown)(); - void (*crash_shutdown)(struct pt_regs *); - void (*emergency_restart)(); +struct hugetlbfs_sb_info { + long int max_inodes; + long int free_inodes; + spinlock_t stat_lock; + struct hstate *hstate; + struct hugepage_subpool *spool; + kuid_t uid; + kgid_t gid; + umode_t mode; }; -typedef void (*nmi_shootdown_cb)(int, struct pt_regs *); +struct numa_memblk { + u64 start; + u64 end; + int nid; +}; -struct cpuid_regs_done { - struct cpuid_regs regs; - struct completion done; +struct numa_meminfo { + int nr_blks; + struct numa_memblk blk[128]; }; -struct intel_early_ops { - resource_size_t (*stolen_size)(int, int, int); - resource_size_t (*stolen_base)(int, int, int, resource_size_t); +struct acpi_srat_cpu_affinity { + struct acpi_subtable_header header; + u8 proximity_domain_lo; + u8 apic_id; + u32 flags; + u8 local_sapic_eid; + u8 proximity_domain_hi[3]; + u32 clock_domain; }; -struct chipset { - u32 vendor; - u32 device; - u32 class; - u32 class_mask; +struct acpi_srat_x2apic_cpu_affinity { + struct acpi_subtable_header header; + u16 reserved; + u32 proximity_domain; + u32 apic_id; u32 flags; - void (*f)(int, int, int); + u32 clock_domain; + u32 reserved2; }; -enum apic_intr_mode_id { - APIC_PIC = 0, - APIC_VIRTUAL_WIRE = 1, - APIC_VIRTUAL_WIRE_NO_CONFIG = 2, - APIC_SYMMETRIC_IO = 3, - APIC_SYMMETRIC_IO_NO_ROUTING = 4, +enum uv_system_type { + UV_NONE = 0, + UV_LEGACY_APIC = 1, + UV_X2APIC = 2, + UV_NON_UNIQUE_APIC = 3, }; -struct sched_domain_shared { - atomic_t ref; - atomic_t nr_busy_cpus; - int has_idle_cores; +struct rnd_state { + __u32 s1; + __u32 s2; + __u32 s3; + __u32 s4; }; -struct sched_group; +struct kaslr_memory_region { + long unsigned int *base; + long unsigned int size_tb; +}; -struct sched_domain { - struct sched_domain *parent; - struct sched_domain *child; - struct sched_group *groups; - long unsigned int min_interval; - long unsigned int max_interval; - unsigned int busy_factor; - unsigned int imbalance_pct; - unsigned int cache_nice_tries; - int nohz_idle; - int flags; - int level; - long unsigned int last_balance; - unsigned int balance_interval; - unsigned int nr_balance_failed; - u64 max_newidle_lb_cost; - long unsigned int next_decay_max_lb_cost; - u64 avg_scan_cost; - unsigned int lb_count[3]; - unsigned int lb_failed[3]; - unsigned int lb_balanced[3]; - unsigned int lb_imbalance[3]; - unsigned int lb_gained[3]; - unsigned int lb_hot_gained[3]; - unsigned int lb_nobusyg[3]; - unsigned int lb_nobusyq[3]; - unsigned int alb_count; - unsigned int alb_failed; - unsigned int alb_pushed; - unsigned int sbe_count; - unsigned int sbe_balanced; - unsigned int sbe_pushed; - unsigned int sbf_count; - unsigned int sbf_balanced; - unsigned int sbf_pushed; - unsigned int ttwu_wake_remote; - unsigned int ttwu_move_affine; - unsigned int ttwu_move_balance; - union { - void *private; - struct callback_head rcu; - }; - struct sched_domain_shared *shared; - unsigned int span_weight; - long unsigned int span[0]; +enum pti_mode { + PTI_AUTO = 0, + PTI_FORCE_OFF = 1, + PTI_FORCE_ON = 2, }; -typedef const struct cpumask * (*sched_domain_mask_f)(int); +enum pti_clone_level { + PTI_CLONE_PMD = 0, + PTI_CLONE_PTE = 1, +}; -typedef int (*sched_domain_flags_f)(); +typedef short unsigned int __kernel_old_uid_t; -struct sched_group_capacity; +typedef short unsigned int __kernel_old_gid_t; -struct sd_data { - struct sched_domain **sd; - struct sched_domain_shared **sds; - struct sched_group **sg; - struct sched_group_capacity **sgc; -}; +typedef struct { + int val[2]; +} __kernel_fsid_t; -struct sched_domain_topology_level { - sched_domain_mask_f mask; - sched_domain_flags_f sd_flags; - int flags; - int numa_level; - struct sd_data data; +typedef __kernel_old_uid_t old_uid_t; + +typedef __kernel_old_gid_t old_gid_t; + +struct kstatfs { + long int f_type; + long int f_bsize; + u64 f_blocks; + u64 f_bfree; + u64 f_bavail; + u64 f_files; + u64 f_ffree; + __kernel_fsid_t f_fsid; + long int f_namelen; + long int f_frsize; + long int f_flags; + long int f_spare[4]; }; -struct tsc_adjust { - s64 bootval; - s64 adjusted; - long unsigned int nextcheck; - bool warned; +struct kernel_clone_args { + u64 flags; + int *pidfd; + int *child_tid; + int *parent_tid; + int exit_signal; + long unsigned int stack; + long unsigned int stack_size; + long unsigned int tls; + pid_t *set_tid; + size_t set_tid_size; }; -typedef void * (*pcpu_fc_alloc_fn_t)(unsigned int, size_t, size_t); +struct stat64 { + long long unsigned int st_dev; + unsigned char __pad0[4]; + unsigned int __st_ino; + unsigned int st_mode; + unsigned int st_nlink; + unsigned int st_uid; + unsigned int st_gid; + long long unsigned int st_rdev; + unsigned char __pad3[4]; + long long int st_size; + unsigned int st_blksize; + long long int st_blocks; + unsigned int st_atime; + unsigned int st_atime_nsec; + unsigned int st_mtime; + unsigned int st_mtime_nsec; + unsigned int st_ctime; + unsigned int st_ctime_nsec; + long long unsigned int st_ino; +} __attribute__((packed)); -typedef void (*pcpu_fc_free_fn_t)(void *, size_t); +struct mmap_arg_struct32 { + unsigned int addr; + unsigned int len; + unsigned int prot; + unsigned int flags; + unsigned int fd; + unsigned int offset; +}; -typedef void (*pcpu_fc_populate_pte_fn_t)(long unsigned int); +struct sigcontext_32 { + __u16 gs; + __u16 __gsh; + __u16 fs; + __u16 __fsh; + __u16 es; + __u16 __esh; + __u16 ds; + __u16 __dsh; + __u32 di; + __u32 si; + __u32 bp; + __u32 sp; + __u32 bx; + __u32 dx; + __u32 cx; + __u32 ax; + __u32 trapno; + __u32 err; + __u32 ip; + __u16 cs; + __u16 __csh; + __u32 flags; + __u32 sp_at_signal; + __u16 ss; + __u16 __ssh; + __u32 fpstate; + __u32 oldmask; + __u32 cr2; +}; -typedef int pcpu_fc_cpu_distance_fn_t(unsigned int, unsigned int); +typedef u32 compat_size_t; -enum { - DUMP_PREFIX_NONE = 0, - DUMP_PREFIX_ADDRESS = 1, - DUMP_PREFIX_OFFSET = 2, +struct compat_sigaltstack { + compat_uptr_t ss_sp; + int ss_flags; + compat_size_t ss_size; }; -struct mpf_intel { - char signature[4]; - unsigned int physptr; - unsigned char length; - unsigned char specification; - unsigned char checksum; - unsigned char feature1; - unsigned char feature2; - unsigned char feature3; - unsigned char feature4; - unsigned char feature5; -}; +typedef struct compat_sigaltstack compat_stack_t; -struct mpc_ioapic { - unsigned char type; - unsigned char apicid; - unsigned char apicver; - unsigned char flags; - unsigned int apicaddr; +struct ucontext_ia32 { + unsigned int uc_flags; + unsigned int uc_link; + compat_stack_t uc_stack; + struct sigcontext_32 uc_mcontext; + compat_sigset_t uc_sigmask; }; -struct mpc_lintsrc { - unsigned char type; - unsigned char irqtype; - short unsigned int irqflag; - unsigned char srcbusid; - unsigned char srcbusirq; - unsigned char destapic; - unsigned char destapiclint; +struct sigframe_ia32 { + u32 pretcode; + int sig; + struct sigcontext_32 sc; + struct _fpstate_32 fpstate_unused; + unsigned int extramask[1]; + char retcode[8]; }; -union apic_ir { - long unsigned int map[4]; - u32 regs[8]; +struct rt_sigframe_ia32 { + u32 pretcode; + int sig; + u32 pinfo; + u32 puc; + compat_siginfo_t info; + struct ucontext_ia32 uc; + char retcode[8]; }; -enum ioapic_irq_destination_types { - dest_Fixed = 0, - dest_LowestPrio = 1, - dest_SMI = 2, - dest__reserved_1 = 3, - dest_NMI = 4, - dest_INIT = 5, - dest__reserved_2 = 6, - dest_ExtINT = 7, -}; +typedef struct { + efi_guid_t guid; + u64 table; +} efi_config_table_64_t; -enum { - IRQ_SET_MASK_OK = 0, - IRQ_SET_MASK_OK_NOCOPY = 1, - IRQ_SET_MASK_OK_DONE = 2, +struct efi_mem_range { + struct range range; + u64 attribute; }; -enum { - IRQD_TRIGGER_MASK = 15, - IRQD_SETAFFINITY_PENDING = 256, - IRQD_ACTIVATED = 512, - IRQD_NO_BALANCING = 1024, - IRQD_PER_CPU = 2048, - IRQD_AFFINITY_SET = 4096, - IRQD_LEVEL = 8192, - IRQD_WAKEUP_STATE = 16384, - IRQD_MOVE_PCNTXT = 32768, - IRQD_IRQ_DISABLED = 65536, - IRQD_IRQ_MASKED = 131072, - IRQD_IRQ_INPROGRESS = 262144, - IRQD_WAKEUP_ARMED = 524288, - IRQD_FORWARDED_TO_VCPU = 1048576, - IRQD_AFFINITY_MANAGED = 2097152, - IRQD_IRQ_STARTED = 4194304, - IRQD_MANAGED_SHUTDOWN = 8388608, - IRQD_SINGLE_TARGET = 16777216, - IRQD_DEFAULT_TRIGGER_SET = 33554432, - IRQD_CAN_RESERVE = 67108864, +struct efi_setup_data { + u64 fw_vendor; + u64 runtime; + u64 tables; + u64 smbios; + u64 reserved[8]; }; -struct irq_cfg { - unsigned int dest_apicid; - unsigned int vector; +typedef struct { + efi_table_hdr_t hdr; + u32 get_time; + u32 set_time; + u32 get_wakeup_time; + u32 set_wakeup_time; + u32 set_virtual_address_map; + u32 convert_pointer; + u32 get_variable; + u32 get_next_variable; + u32 set_variable; + u32 get_next_high_mono_count; + u32 reset_system; + u32 update_capsule; + u32 query_capsule_caps; + u32 query_variable_info; +} efi_runtime_services_32_t; + +typedef struct { + efi_table_hdr_t hdr; + u64 get_time; + u64 set_time; + u64 get_wakeup_time; + u64 set_wakeup_time; + u64 set_virtual_address_map; + u64 convert_pointer; + u64 get_variable; + u64 get_next_variable; + u64 set_variable; + u64 get_next_high_mono_count; + u64 reset_system; + u64 update_capsule; + u64 query_capsule_caps; + u64 query_variable_info; +} efi_runtime_services_64_t; + +typedef struct { + efi_guid_t guid; + const char *name; + long unsigned int *ptr; +} efi_config_table_type_t; + +typedef struct { + efi_table_hdr_t hdr; + u64 fw_vendor; + u32 fw_revision; + u32 __pad1; + u64 con_in_handle; + u64 con_in; + u64 con_out_handle; + u64 con_out; + u64 stderr_handle; + u64 stderr; + u64 runtime; + u64 boottime; + u32 nr_tables; + u32 __pad2; + u64 tables; +} efi_system_table_64_t; + +typedef struct { + efi_table_hdr_t hdr; + u32 fw_vendor; + u32 fw_revision; + u32 con_in_handle; + u32 con_in; + u32 con_out_handle; + u32 con_out; + u32 stderr_handle; + u32 stderr; + u32 runtime; + u32 boottime; + u32 nr_tables; + u32 tables; +} efi_system_table_32_t; + +struct efi_memory_map_data { + phys_addr_t phys_map; + long unsigned int size; + long unsigned int desc_version; + long unsigned int desc_size; }; -enum { - IRQCHIP_FWNODE_REAL = 0, - IRQCHIP_FWNODE_NAMED = 1, - IRQCHIP_FWNODE_NAMED_ID = 2, +struct wait_queue_entry; + +typedef int (*wait_queue_func_t)(struct wait_queue_entry *, unsigned int, int, void *); + +struct wait_queue_entry { + unsigned int flags; + void *private; + wait_queue_func_t func; + struct list_head entry; }; enum { - X86_IRQ_ALLOC_CONTIGUOUS_VECTORS = 1, - X86_IRQ_ALLOC_LEGACY = 2, + PM_QOS_RESERVED = 0, + PM_QOS_CPU_DMA_LATENCY = 1, + PM_QOS_NUM_CLASSES = 2, }; -struct apic_chip_data { - struct irq_cfg hw_irq_cfg; - unsigned int vector; - unsigned int prev_vector; - unsigned int cpu; - unsigned int prev_cpu; - unsigned int irq; - struct hlist_node clist; - unsigned int move_in_progress: 1; - unsigned int is_managed: 1; - unsigned int can_reserve: 1; - unsigned int has_reserved: 1; +struct pm_qos_request { + struct plist_node node; + int pm_qos_class; + struct delayed_work work; }; -struct irq_matrix; - -union IO_APIC_reg_00 { - u32 raw; - struct { - u32 __reserved_2: 14; - u32 LTS: 1; - u32 delivery_type: 1; - u32 __reserved_1: 8; - u32 ID: 8; - } bits; +enum { + BPF_REG_0 = 0, + BPF_REG_1 = 1, + BPF_REG_2 = 2, + BPF_REG_3 = 3, + BPF_REG_4 = 4, + BPF_REG_5 = 5, + BPF_REG_6 = 6, + BPF_REG_7 = 7, + BPF_REG_8 = 8, + BPF_REG_9 = 9, + BPF_REG_10 = 10, + __MAX_BPF_REG = 11, }; -union IO_APIC_reg_01 { - u32 raw; - struct { - u32 version: 8; - u32 __reserved_2: 7; - u32 PRQ: 1; - u32 entries: 8; - u32 __reserved_1: 8; - } bits; +enum bpf_jit_poke_reason { + BPF_POKE_REASON_TAIL_CALL = 0, }; -union IO_APIC_reg_02 { - u32 raw; - struct { - u32 __reserved_2: 24; - u32 arbitration: 4; - u32 __reserved_1: 4; - } bits; +struct bpf_array_aux { + enum bpf_prog_type type; + bool jited; + struct list_head poke_progs; + struct bpf_map *map; + struct mutex poke_mutex; + struct work_struct work; }; -union IO_APIC_reg_03 { - u32 raw; - struct { - u32 boot_DT: 1; - u32 __reserved_1: 31; - } bits; +struct bpf_array { + struct bpf_map map; + u32 elem_size; + u32 index_mask; + struct bpf_array_aux *aux; + union { + char value[0]; + void *ptrs[0]; + void *pptrs[0]; + }; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct IR_IO_APIC_route_entry { - __u64 vector: 8; - __u64 zero: 3; - __u64 index2: 1; - __u64 delivery_status: 1; - __u64 polarity: 1; - __u64 irr: 1; - __u64 trigger: 1; - __u64 mask: 1; - __u64 reserved: 31; - __u64 format: 1; - __u64 index: 15; +enum bpf_text_poke_type { + BPF_MOD_CALL = 0, + BPF_MOD_JUMP = 1, }; -enum { - IRQ_TYPE_NONE = 0, - IRQ_TYPE_EDGE_RISING = 1, - IRQ_TYPE_EDGE_FALLING = 2, - IRQ_TYPE_EDGE_BOTH = 3, - IRQ_TYPE_LEVEL_HIGH = 4, - IRQ_TYPE_LEVEL_LOW = 8, - IRQ_TYPE_LEVEL_MASK = 12, - IRQ_TYPE_SENSE_MASK = 15, - IRQ_TYPE_DEFAULT = 15, - IRQ_TYPE_PROBE = 16, - IRQ_LEVEL = 256, - IRQ_PER_CPU = 512, - IRQ_NOPROBE = 1024, - IRQ_NOREQUEST = 2048, - IRQ_NOAUTOEN = 4096, - IRQ_NO_BALANCING = 8192, - IRQ_MOVE_PCNTXT = 16384, - IRQ_NESTED_THREAD = 32768, - IRQ_NOTHREAD = 65536, - IRQ_PER_CPU_DEVID = 131072, - IRQ_IS_POLLED = 262144, - IRQ_DISABLE_UNLAZY = 524288, +struct bpf_binary_header { + u32 pages; + int: 32; + u8 image[0]; }; -enum { - IRQCHIP_SET_TYPE_MASKED = 1, - IRQCHIP_EOI_IF_HANDLED = 2, - IRQCHIP_MASK_ON_SUSPEND = 4, - IRQCHIP_ONOFFLINE_ENABLED = 8, - IRQCHIP_SKIP_SET_WAKE = 16, - IRQCHIP_ONESHOT_SAFE = 32, - IRQCHIP_EOI_THREADED = 64, - IRQCHIP_SUPPORTS_LEVEL_MSI = 128, - IRQCHIP_SUPPORTS_NMI = 256, +struct jit_context { + int cleanup_addr; }; -struct irq_pin_list { - struct list_head list; - int apic; - int pin; +struct x64_jit_data { + struct bpf_binary_header *header; + int *addrs; + u8 *image; + int proglen; + struct jit_context ctx; }; -struct mp_chip_data { - struct list_head irq_2_pin; - struct IO_APIC_route_entry entry; - int trigger; - int polarity; - u32 count; - bool isa_irq; +enum tk_offsets { + TK_OFFS_REAL = 0, + TK_OFFS_BOOT = 1, + TK_OFFS_TAI = 2, + TK_OFFS_MAX = 3, }; -struct mp_ioapic_gsi { - u32 gsi_base; - u32 gsi_end; +struct clone_args { + __u64 flags; + __u64 pidfd; + __u64 child_tid; + __u64 parent_tid; + __u64 exit_signal; + __u64 stack; + __u64 stack_size; + __u64 tls; + __u64 set_tid; + __u64 set_tid_size; }; -struct ioapic { - int nr_registers; - struct IO_APIC_route_entry *saved_registers; - struct mpc_ioapic mp_config; - struct mp_ioapic_gsi gsi_config; - struct ioapic_domain_cfg irqdomain_cfg; - struct irq_domain *irqdomain; - struct resource *iomem_res; +struct fdtable { + unsigned int max_fds; + struct file **fd; + long unsigned int *close_on_exec; + long unsigned int *open_fds; + long unsigned int *full_fds_bits; + struct callback_head rcu; }; -struct io_apic { - unsigned int index; - unsigned int unused[3]; - unsigned int data; - unsigned int unused2[11]; - unsigned int eoi; +struct files_struct { + atomic_t count; + bool resize_in_progress; + wait_queue_head_t resize_wait; + struct fdtable *fdt; + struct fdtable fdtab; + long: 64; + long: 64; + long: 64; + long: 64; + spinlock_t file_lock; + unsigned int next_fd; + long unsigned int close_on_exec_init[1]; + long unsigned int open_fds_init[1]; + long unsigned int full_fds_bits_init[1]; + struct file *fd_array[64]; + long: 64; + long: 64; + long: 64; + long: 64; }; -union entry_union { - struct { - u32 w1; - u32 w2; - }; - struct IO_APIC_route_entry entry; +struct robust_list { + struct robust_list *next; }; -struct clock_event_device___2; - -typedef struct irq_alloc_info msi_alloc_info_t; - -struct msi_domain_info; - -struct msi_domain_ops { - irq_hw_number_t (*get_hwirq)(struct msi_domain_info *, msi_alloc_info_t *); - int (*msi_init)(struct irq_domain *, struct msi_domain_info *, unsigned int, irq_hw_number_t, msi_alloc_info_t *); - void (*msi_free)(struct irq_domain *, struct msi_domain_info *, unsigned int); - int (*msi_check)(struct irq_domain *, struct msi_domain_info *, struct device *); - int (*msi_prepare)(struct irq_domain *, struct device *, int, msi_alloc_info_t *); - void (*msi_finish)(msi_alloc_info_t *, int); - void (*set_desc)(msi_alloc_info_t *, struct msi_desc *); - int (*handle_error)(struct irq_domain *, struct msi_desc *, int); +struct robust_list_head { + struct robust_list list; + long int futex_offset; + struct robust_list *list_op_pending; }; -struct msi_domain_info { - u32 flags; - struct msi_domain_ops *ops; - struct irq_chip *chip; - void *chip_data; - irq_flow_handler_t handler; - void *handler_data; - const char *handler_name; - void *data; +struct multiprocess_signals { + sigset_t signal; + struct hlist_node node; }; +typedef int (*proc_visitor)(struct task_struct *, void *); + enum { - MSI_FLAG_USE_DEF_DOM_OPS = 1, - MSI_FLAG_USE_DEF_CHIP_OPS = 2, - MSI_FLAG_MULTI_PCI_MSI = 4, - MSI_FLAG_PCI_MSIX = 8, - MSI_FLAG_ACTIVATE_EARLY = 16, - MSI_FLAG_MUST_REACTIVATE = 32, - MSI_FLAG_LEVEL_CAPABLE = 64, + IOPRIO_CLASS_NONE = 0, + IOPRIO_CLASS_RT = 1, + IOPRIO_CLASS_BE = 2, + IOPRIO_CLASS_IDLE = 3, }; -struct hpet_channel; - -struct kimage_arch { - p4d_t *p4d; - pud_t *pud; - pmd_t *pmd; - pte_t *pte; - void *elf_headers; - long unsigned int elf_headers_sz; - long unsigned int elf_load_addr; +enum memcg_stat_item { + MEMCG_CACHE = 32, + MEMCG_RSS = 33, + MEMCG_RSS_HUGE = 34, + MEMCG_SWAP = 35, + MEMCG_SOCK = 36, + MEMCG_KERNEL_STACK_KB = 37, + MEMCG_NR_STAT = 38, }; -typedef long unsigned int kimage_entry_t; +typedef struct poll_table_struct poll_table; -struct kexec_segment { - union { - void *buf; - void *kbuf; - }; - size_t bufsz; - long unsigned int mem; - size_t memsz; +enum { + FUTEX_STATE_OK = 0, + FUTEX_STATE_EXITING = 1, + FUTEX_STATE_DEAD = 2, }; -struct kimage { - kimage_entry_t head; - kimage_entry_t *entry; - kimage_entry_t *last_entry; - long unsigned int start; - struct page *control_code_page; - struct page *swap_page; - void *vmcoreinfo_data_copy; - long unsigned int nr_segments; - struct kexec_segment segment[16]; - struct list_head control_pages; - struct list_head dest_pages; - struct list_head unusable_pages; - long unsigned int control_page; - unsigned int type: 1; - unsigned int preserve_context: 1; - unsigned int file_mode: 1; - struct kimage_arch arch; +struct trace_event_raw_task_newtask { + struct trace_entry ent; + pid_t pid; + char comm[16]; + long unsigned int clone_flags; + short int oom_score_adj; + char __data[0]; }; -struct x86_mapping_info { - void * (*alloc_pgt_page)(void *); - void *context; - long unsigned int page_flag; - long unsigned int offset; - bool direct_gbpages; - long unsigned int kernpg_flag; +struct trace_event_raw_task_rename { + struct trace_entry ent; + pid_t pid; + char oldcomm[16]; + char newcomm[16]; + short int oom_score_adj; + char __data[0]; }; -struct init_pgtable_data { - struct x86_mapping_info *info; - pgd_t *level4p; -}; +struct trace_event_data_offsets_task_newtask {}; -typedef void crash_vmclear_fn(); +struct trace_event_data_offsets_task_rename {}; -struct kretprobe_instance; +typedef void (*btf_trace_task_newtask)(void *, struct task_struct *, long unsigned int); -typedef int (*kretprobe_handler_t)(struct kretprobe_instance *, struct pt_regs *); +typedef void (*btf_trace_task_rename)(void *, struct task_struct *, const char *); -struct kretprobe; +typedef long unsigned int pao_T_____4; -struct kretprobe_instance { - struct hlist_node hlist; - struct kretprobe *rp; - kprobe_opcode_t *ret_addr; - struct task_struct *task; - void *fp; - char data[0]; +enum kmsg_dump_reason { + KMSG_DUMP_UNDEF = 0, + KMSG_DUMP_PANIC = 1, + KMSG_DUMP_OOPS = 2, + KMSG_DUMP_EMERG = 3, + KMSG_DUMP_RESTART = 4, + KMSG_DUMP_HALT = 5, + KMSG_DUMP_POWEROFF = 6, }; -struct kretprobe { - struct kprobe kp; - kretprobe_handler_t handler; - kretprobe_handler_t entry_handler; - int maxactive; - int nmissed; - size_t data_size; - struct hlist_head free_instances; - raw_spinlock_t lock; +struct vt_mode { + char mode; + char waitv; + short int relsig; + short int acqsig; + short int frsig; }; -struct kretprobe_blackpoint { - const char *name; - void *addr; +struct console_font { + unsigned int width; + unsigned int height; + unsigned int charcount; + unsigned char *data; }; -struct __arch_relative_insn { - u8 op; - s32 raddr; -} __attribute__((packed)); +struct uni_pagedir; -struct arch_optimized_insn { - kprobe_opcode_t copied_insn[4]; - kprobe_opcode_t *insn; - size_t size; +struct uni_screen; + +struct vc_data { + struct tty_port port; + short unsigned int vc_num; + unsigned int vc_cols; + unsigned int vc_rows; + unsigned int vc_size_row; + unsigned int vc_scan_lines; + long unsigned int vc_origin; + long unsigned int vc_scr_end; + long unsigned int vc_visible_origin; + unsigned int vc_top; + unsigned int vc_bottom; + const struct consw *vc_sw; + short unsigned int *vc_screenbuf; + unsigned int vc_screenbuf_size; + unsigned char vc_mode; + unsigned char vc_attr; + unsigned char vc_def_color; + unsigned char vc_color; + unsigned char vc_s_color; + unsigned char vc_ulcolor; + unsigned char vc_itcolor; + unsigned char vc_halfcolor; + unsigned int vc_cursor_type; + short unsigned int vc_complement_mask; + short unsigned int vc_s_complement_mask; + unsigned int vc_x; + unsigned int vc_y; + unsigned int vc_saved_x; + unsigned int vc_saved_y; + long unsigned int vc_pos; + short unsigned int vc_hi_font_mask; + struct console_font vc_font; + short unsigned int vc_video_erase_char; + unsigned int vc_state; + unsigned int vc_npar; + unsigned int vc_par[16]; + struct vt_mode vt_mode; + struct pid *vt_pid; + int vt_newvt; + wait_queue_head_t paste_wait; + unsigned int vc_charset: 1; + unsigned int vc_s_charset: 1; + unsigned int vc_disp_ctrl: 1; + unsigned int vc_toggle_meta: 1; + unsigned int vc_decscnm: 1; + unsigned int vc_decom: 1; + unsigned int vc_decawm: 1; + unsigned int vc_deccm: 1; + unsigned int vc_decim: 1; + unsigned int vc_intensity: 2; + unsigned int vc_italic: 1; + unsigned int vc_underline: 1; + unsigned int vc_blink: 1; + unsigned int vc_reverse: 1; + unsigned int vc_s_intensity: 2; + unsigned int vc_s_italic: 1; + unsigned int vc_s_underline: 1; + unsigned int vc_s_blink: 1; + unsigned int vc_s_reverse: 1; + unsigned int vc_priv: 3; + unsigned int vc_need_wrap: 1; + unsigned int vc_can_do_color: 1; + unsigned int vc_report_mouse: 2; + unsigned char vc_utf: 1; + unsigned char vc_utf_count; + int vc_utf_char; + unsigned int vc_tab_stop[8]; + unsigned char vc_palette[48]; + short unsigned int *vc_translate; + unsigned char vc_G0_charset; + unsigned char vc_G1_charset; + unsigned char vc_saved_G0; + unsigned char vc_saved_G1; + unsigned int vc_resize_user; + unsigned int vc_bell_pitch; + unsigned int vc_bell_duration; + short unsigned int vc_cur_blink_ms; + struct vc_data **vc_display_fg; + struct uni_pagedir *vc_uni_pagedir; + struct uni_pagedir **vc_uni_pagedir_loc; + struct uni_screen *vc_uni_screen; +}; + +struct vc { + struct vc_data *d; + struct work_struct SAK_work; }; -struct optimized_kprobe { - struct kprobe kp; - struct list_head list; - struct arch_optimized_insn optinsn; +struct vt_spawn_console { + spinlock_t lock; + struct pid *pid; + int sig; }; -typedef struct kprobe *pto_T_____5; +enum con_flush_mode { + CONSOLE_FLUSH_PENDING = 0, + CONSOLE_REPLAY_ALL = 1, +}; -typedef __u64 Elf64_Off; +struct warn_args { + const char *fmt; + va_list args; +}; -typedef __s64 Elf64_Sxword; +struct smp_hotplug_thread { + struct task_struct **store; + struct list_head list; + int (*thread_should_run)(unsigned int); + void (*thread_fn)(unsigned int); + void (*create)(unsigned int); + void (*setup)(unsigned int); + void (*cleanup)(unsigned int, bool); + void (*park)(unsigned int); + void (*unpark)(unsigned int); + bool selfparking; + const char *thread_comm; +}; -struct elf64_rela { - Elf64_Addr r_offset; - Elf64_Xword r_info; - Elf64_Sxword r_addend; +struct trace_event_raw_cpuhp_enter { + struct trace_entry ent; + unsigned int cpu; + int target; + int idx; + void *fun; + char __data[0]; }; -typedef struct elf64_rela Elf64_Rela; +struct trace_event_raw_cpuhp_multi_enter { + struct trace_entry ent; + unsigned int cpu; + int target; + int idx; + void *fun; + char __data[0]; +}; -struct elf64_hdr { - unsigned char e_ident[16]; - Elf64_Half e_type; - Elf64_Half e_machine; - Elf64_Word e_version; - Elf64_Addr e_entry; - Elf64_Off e_phoff; - Elf64_Off e_shoff; - Elf64_Word e_flags; - Elf64_Half e_ehsize; - Elf64_Half e_phentsize; - Elf64_Half e_phnum; - Elf64_Half e_shentsize; - Elf64_Half e_shnum; - Elf64_Half e_shstrndx; +struct trace_event_raw_cpuhp_exit { + struct trace_entry ent; + unsigned int cpu; + int state; + int idx; + int ret; + char __data[0]; }; -typedef struct elf64_hdr Elf64_Ehdr; +struct trace_event_data_offsets_cpuhp_enter {}; -struct elf64_shdr { - Elf64_Word sh_name; - Elf64_Word sh_type; - Elf64_Xword sh_flags; - Elf64_Addr sh_addr; - Elf64_Off sh_offset; - Elf64_Xword sh_size; - Elf64_Word sh_link; - Elf64_Word sh_info; - Elf64_Xword sh_addralign; - Elf64_Xword sh_entsize; -}; +struct trace_event_data_offsets_cpuhp_multi_enter {}; -typedef struct elf64_shdr Elf64_Shdr; +struct trace_event_data_offsets_cpuhp_exit {}; -struct console { - char name[16]; - void (*write)(struct console *, const char *, unsigned int); - int (*read)(struct console *, char *, unsigned int); - struct tty_driver * (*device)(struct console *, int *); - void (*unblank)(); - int (*setup)(struct console *, char *); - int (*match)(struct console *, char *, int, char *); - short int flags; - short int index; - int cflag; - void *data; - struct console *next; -}; +typedef void (*btf_trace_cpuhp_enter)(void *, unsigned int, int, int, int (*)(unsigned int)); -struct hpet_data { - long unsigned int hd_phys_address; - void *hd_address; - short unsigned int hd_nirqs; - unsigned int hd_state; - unsigned int hd_irq[32]; -}; +typedef void (*btf_trace_cpuhp_multi_enter)(void *, unsigned int, int, int, int (*)(unsigned int, struct hlist_node *), struct hlist_node *); -typedef irqreturn_t (*rtc_irq_handler)(int, void *); +typedef void (*btf_trace_cpuhp_exit)(void *, unsigned int, int, int, int); -enum hpet_mode { - HPET_MODE_UNUSED = 0, - HPET_MODE_LEGACY = 1, - HPET_MODE_CLOCKEVT = 2, - HPET_MODE_DEVICE = 3, +struct cpuhp_cpu_state { + enum cpuhp_state state; + enum cpuhp_state target; + enum cpuhp_state fail; + struct task_struct *thread; + bool should_run; + bool rollback; + bool single; + bool bringup; + struct hlist_node *node; + struct hlist_node *last; + enum cpuhp_state cb_state; + int result; + struct completion done_up; + struct completion done_down; }; -struct hpet_channel___2 { - struct clock_event_device evt; - unsigned int num; - unsigned int cpu; - unsigned int irq; - unsigned int in_use; - enum hpet_mode mode; - unsigned int boot_cfg; - char name[10]; - long: 48; - long: 64; - long: 64; - long: 64; +struct cpuhp_step { + const char *name; + union { + int (*single)(unsigned int); + int (*multi)(unsigned int, struct hlist_node *); + } startup; + union { + int (*single)(unsigned int); + int (*multi)(unsigned int, struct hlist_node *); + } teardown; + struct hlist_head list; + bool cant_stop; + bool multi_instance; }; -struct hpet_base { - unsigned int nr_channels; - unsigned int nr_clockevents; - unsigned int boot_cfg; - struct hpet_channel___2 *channels; +enum cpu_mitigations { + CPU_MITIGATIONS_OFF = 0, + CPU_MITIGATIONS_AUTO = 1, + CPU_MITIGATIONS_AUTO_NOSMT = 2, }; -union hpet_lock { - struct { - arch_spinlock_t lock; - u32 value; - }; - u64 lockval; -}; +typedef enum cpuhp_state pto_T_____15; -struct amd_nb_bus_dev_range { - u8 bus; - u8 dev_base; - u8 dev_limit; +struct __kernel_old_timeval { + __kernel_long_t tv_sec; + __kernel_long_t tv_usec; }; -struct amd_northbridge_info { - u16 num; - u64 flags; - struct amd_northbridge *nb; -}; +typedef struct wait_queue_entry wait_queue_entry_t; -struct scan_area { - u64 addr; - u64 size; +struct old_timeval32 { + old_time32_t tv_sec; + s32 tv_usec; }; -enum swiotlb_force { - SWIOTLB_NORMAL = 0, - SWIOTLB_FORCE = 1, - SWIOTLB_NO_FORCE = 2, +struct rusage { + struct __kernel_old_timeval ru_utime; + struct __kernel_old_timeval ru_stime; + __kernel_long_t ru_maxrss; + __kernel_long_t ru_ixrss; + __kernel_long_t ru_idrss; + __kernel_long_t ru_isrss; + __kernel_long_t ru_minflt; + __kernel_long_t ru_majflt; + __kernel_long_t ru_nswap; + __kernel_long_t ru_inblock; + __kernel_long_t ru_oublock; + __kernel_long_t ru_msgsnd; + __kernel_long_t ru_msgrcv; + __kernel_long_t ru_nsignals; + __kernel_long_t ru_nvcsw; + __kernel_long_t ru_nivcsw; }; -struct uprobe_xol_ops; - -struct arch_uprobe { - union { - u8 insn[16]; - u8 ixol[16]; - }; - const struct uprobe_xol_ops *ops; - union { - struct { - s32 offs; - u8 ilen; - u8 opc1; - } branch; - struct { - u8 fixups; - u8 ilen; - } defparam; - struct { - u8 reg_offset; - u8 ilen; - } push; - }; +struct fd { + struct file *file; + unsigned int flags; }; -struct uprobe_xol_ops { - bool (*emulate)(struct arch_uprobe *, struct pt_regs *); - int (*pre_xol)(struct arch_uprobe *, struct pt_regs *); - int (*post_xol)(struct arch_uprobe *, struct pt_regs *); - void (*abort)(struct arch_uprobe *, struct pt_regs *); +struct compat_rusage { + struct old_timeval32 ru_utime; + struct old_timeval32 ru_stime; + compat_long_t ru_maxrss; + compat_long_t ru_ixrss; + compat_long_t ru_idrss; + compat_long_t ru_isrss; + compat_long_t ru_minflt; + compat_long_t ru_majflt; + compat_long_t ru_nswap; + compat_long_t ru_inblock; + compat_long_t ru_oublock; + compat_long_t ru_msgsnd; + compat_long_t ru_msgrcv; + compat_long_t ru_nsignals; + compat_long_t ru_nvcsw; + compat_long_t ru_nivcsw; }; -enum rp_check { - RP_CHECK_CALL = 0, - RP_CHECK_CHAIN_CALL = 1, - RP_CHECK_RET = 2, +struct waitid_info { + pid_t pid; + uid_t uid; + int status; + int cause; }; -enum dev_prop_type { - DEV_PROP_U8 = 0, - DEV_PROP_U16 = 1, - DEV_PROP_U32 = 2, - DEV_PROP_U64 = 3, - DEV_PROP_STRING = 4, +struct wait_opts { + enum pid_type wo_type; + int wo_flags; + struct pid *wo_pid; + struct waitid_info *wo_info; + int wo_stat; + struct rusage *wo_rusage; + wait_queue_entry_t child_wait; + int notask_error; }; -struct property_entry { - const char *name; - size_t length; - bool is_array; - enum dev_prop_type type; - union { - const void *pointer; - union { - u8 u8_data; - u16 u16_data; - u32 u32_data; - u64 u64_data; - const char *str; - } value; - }; +struct softirq_action { + void (*action)(struct softirq_action *); }; -struct simplefb_platform_data { - u32 width; - u32 height; - u32 stride; - const char *format; +struct tasklet_struct { + struct tasklet_struct *next; + long unsigned int state; + atomic_t count; + void (*func)(long unsigned int); + long unsigned int data; }; enum { - M_I17 = 0, - M_I20 = 1, - M_I20_SR = 2, - M_I24 = 3, - M_I24_8_1 = 4, - M_I24_10_1 = 5, - M_I27_11_1 = 6, - M_MINI = 7, - M_MINI_3_1 = 8, - M_MINI_4_1 = 9, - M_MB = 10, - M_MB_2 = 11, - M_MB_3 = 12, - M_MB_5_1 = 13, - M_MB_6_1 = 14, - M_MB_7_1 = 15, - M_MB_SR = 16, - M_MBA = 17, - M_MBA_3 = 18, - M_MBP = 19, - M_MBP_2 = 20, - M_MBP_2_2 = 21, - M_MBP_SR = 22, - M_MBP_4 = 23, - M_MBP_5_1 = 24, - M_MBP_5_2 = 25, - M_MBP_5_3 = 26, - M_MBP_6_1 = 27, - M_MBP_6_2 = 28, - M_MBP_7_1 = 29, - M_MBP_8_2 = 30, - M_UNKNOWN = 31, + TASKLET_STATE_SCHED = 0, + TASKLET_STATE_RUN = 1, }; -struct efifb_dmi_info { - char *optname; - long unsigned int base; - int stride; - int width; - int height; - int flags; +struct trace_event_raw_irq_handler_entry { + struct trace_entry ent; + int irq; + u32 __data_loc_name; + char __data[0]; }; -enum { - OVERRIDE_NONE = 0, - OVERRIDE_BASE = 1, - OVERRIDE_STRIDE = 2, - OVERRIDE_HEIGHT = 4, - OVERRIDE_WIDTH = 8, +struct trace_event_raw_irq_handler_exit { + struct trace_entry ent; + int irq; + int ret; + char __data[0]; }; -enum perf_sample_regs_abi { - PERF_SAMPLE_REGS_ABI_NONE = 0, - PERF_SAMPLE_REGS_ABI_32 = 1, - PERF_SAMPLE_REGS_ABI_64 = 2, +struct trace_event_raw_softirq { + struct trace_entry ent; + unsigned int vec; + char __data[0]; }; -struct __va_list_tag { - unsigned int gp_offset; - unsigned int fp_offset; - void *overflow_arg_area; - void *reg_save_area; +struct trace_event_data_offsets_irq_handler_entry { + u32 name; }; -typedef struct __va_list_tag __gnuc_va_list[1]; +struct trace_event_data_offsets_irq_handler_exit {}; -typedef __gnuc_va_list va_list; +struct trace_event_data_offsets_softirq {}; -struct va_format { - const char *fmt; - va_list *va; -}; +typedef void (*btf_trace_irq_handler_entry)(void *, int, struct irqaction *); -struct pci_hostbridge_probe { - u32 bus; - u32 slot; - u32 vendor; - u32 device; -}; +typedef void (*btf_trace_irq_handler_exit)(void *, int, struct irqaction *, int); -enum pg_level { - PG_LEVEL_NONE = 0, - PG_LEVEL_4K = 1, - PG_LEVEL_2M = 2, - PG_LEVEL_1G = 3, - PG_LEVEL_512G = 4, - PG_LEVEL_NUM = 5, +typedef void (*btf_trace_softirq_entry)(void *, unsigned int); + +typedef void (*btf_trace_softirq_exit)(void *, unsigned int); + +typedef void (*btf_trace_softirq_raise)(void *, unsigned int); + +struct tasklet_head { + struct tasklet_struct *head; + struct tasklet_struct **tail; }; -struct trace_print_flags { - long unsigned int mask; - const char *name; +typedef struct tasklet_struct **pto_T_____16; + +struct resource_entry { + struct list_head node; + struct resource *res; + resource_size_t offset; + struct resource __res; }; -enum tlb_flush_reason { - TLB_FLUSH_ON_TASK_SWITCH = 0, - TLB_REMOTE_SHOOTDOWN = 1, - TLB_LOCAL_SHOOTDOWN = 2, - TLB_LOCAL_MM_SHOOTDOWN = 3, - TLB_REMOTE_SEND_IPI = 4, - NR_TLB_FLUSH_REASONS = 5, +struct resource_constraint { + resource_size_t min; + resource_size_t max; + resource_size_t align; + resource_size_t (*alignf)(void *, const struct resource *, resource_size_t, resource_size_t); + void *alignf_data; }; enum { - REGION_INTERSECTS = 0, - REGION_DISJOINT = 1, - REGION_MIXED = 2, + MAX_IORES_LEVEL = 5, }; -struct trace_event_raw_tlb_flush { - struct trace_entry ent; - int reason; - long unsigned int pages; - char __data[0]; +struct region_devres { + struct resource *parent; + resource_size_t start; + resource_size_t n; }; -struct trace_event_data_offsets_tlb_flush {}; - -struct map_range { - long unsigned int start; - long unsigned int end; - unsigned int page_size_mask; +enum sysctl_writes_mode { + SYSCTL_WRITES_LEGACY = 4294967295, + SYSCTL_WRITES_WARN = 0, + SYSCTL_WRITES_STRICT = 1, }; -enum kcore_type { - KCORE_TEXT = 0, - KCORE_VMALLOC = 1, - KCORE_RAM = 2, - KCORE_VMEMMAP = 3, - KCORE_USER = 4, - KCORE_OTHER = 5, - KCORE_REMAP = 6, +struct do_proc_dointvec_minmax_conv_param { + int *min; + int *max; }; -struct kcore_list { - struct list_head list; - long unsigned int addr; - long unsigned int vaddr; - size_t size; - int type; +struct do_proc_douintvec_minmax_conv_param { + unsigned int *min; + unsigned int *max; }; -struct hstate { - int next_nid_to_alloc; - int next_nid_to_free; - unsigned int order; - long unsigned int mask; - long unsigned int max_huge_pages; - long unsigned int nr_huge_pages; - long unsigned int free_huge_pages; - long unsigned int resv_huge_pages; - long unsigned int surplus_huge_pages; - long unsigned int nr_overcommit_huge_pages; - struct list_head hugepage_activelist; - struct list_head hugepage_freelists[64]; - unsigned int nr_huge_pages_node[64]; - unsigned int free_huge_pages_node[64]; - unsigned int surplus_huge_pages_node[64]; - char name[32]; +struct __sysctl_args { + int *name; + int nlen; + void *oldval; + size_t *oldlenp; + void *newval; + size_t newlen; + long unsigned int __unused[4]; }; -struct trace_event_raw_x86_exceptions { - struct trace_entry ent; - long unsigned int address; - long unsigned int ip; - long unsigned int error_code; - char __data[0]; +enum { + CTL_KERN = 1, + CTL_VM = 2, + CTL_NET = 3, + CTL_PROC = 4, + CTL_FS = 5, + CTL_DEBUG = 6, + CTL_DEV = 7, + CTL_BUS = 8, + CTL_ABI = 9, + CTL_CPU = 10, + CTL_ARLAN = 254, + CTL_S390DBF = 5677, + CTL_SUNRPC = 7249, + CTL_PM = 9899, + CTL_FRV = 9898, }; -struct trace_event_data_offsets_x86_exceptions {}; - enum { - IORES_MAP_SYSTEM_RAM = 1, - IORES_MAP_ENCRYPTED = 2, + KERN_OSTYPE = 1, + KERN_OSRELEASE = 2, + KERN_OSREV = 3, + KERN_VERSION = 4, + KERN_SECUREMASK = 5, + KERN_PROF = 6, + KERN_NODENAME = 7, + KERN_DOMAINNAME = 8, + KERN_PANIC = 15, + KERN_REALROOTDEV = 16, + KERN_SPARC_REBOOT = 21, + KERN_CTLALTDEL = 22, + KERN_PRINTK = 23, + KERN_NAMETRANS = 24, + KERN_PPC_HTABRECLAIM = 25, + KERN_PPC_ZEROPAGED = 26, + KERN_PPC_POWERSAVE_NAP = 27, + KERN_MODPROBE = 28, + KERN_SG_BIG_BUFF = 29, + KERN_ACCT = 30, + KERN_PPC_L2CR = 31, + KERN_RTSIGNR = 32, + KERN_RTSIGMAX = 33, + KERN_SHMMAX = 34, + KERN_MSGMAX = 35, + KERN_MSGMNB = 36, + KERN_MSGPOOL = 37, + KERN_SYSRQ = 38, + KERN_MAX_THREADS = 39, + KERN_RANDOM = 40, + KERN_SHMALL = 41, + KERN_MSGMNI = 42, + KERN_SEM = 43, + KERN_SPARC_STOP_A = 44, + KERN_SHMMNI = 45, + KERN_OVERFLOWUID = 46, + KERN_OVERFLOWGID = 47, + KERN_SHMPATH = 48, + KERN_HOTPLUG = 49, + KERN_IEEE_EMULATION_WARNINGS = 50, + KERN_S390_USER_DEBUG_LOGGING = 51, + KERN_CORE_USES_PID = 52, + KERN_TAINTED = 53, + KERN_CADPID = 54, + KERN_PIDMAX = 55, + KERN_CORE_PATTERN = 56, + KERN_PANIC_ON_OOPS = 57, + KERN_HPPA_PWRSW = 58, + KERN_HPPA_UNALIGNED = 59, + KERN_PRINTK_RATELIMIT = 60, + KERN_PRINTK_RATELIMIT_BURST = 61, + KERN_PTY = 62, + KERN_NGROUPS_MAX = 63, + KERN_SPARC_SCONS_PWROFF = 64, + KERN_HZ_TIMER = 65, + KERN_UNKNOWN_NMI_PANIC = 66, + KERN_BOOTLOADER_TYPE = 67, + KERN_RANDOMIZE = 68, + KERN_SETUID_DUMPABLE = 69, + KERN_SPIN_RETRY = 70, + KERN_ACPI_VIDEO_FLAGS = 71, + KERN_IA64_UNALIGNED = 72, + KERN_COMPAT_LOG = 73, + KERN_MAX_LOCK_DEPTH = 74, + KERN_NMI_WATCHDOG = 75, + KERN_PANIC_ON_NMI = 76, + KERN_PANIC_ON_WARN = 77, + KERN_PANIC_PRINT = 78, }; -struct ioremap_desc { - unsigned int flags; +struct xfs_sysctl_val { + int min; + int val; + int max; }; -typedef bool (*ex_handler_t)(const struct exception_table_entry *, struct pt_regs *, int, long unsigned int, long unsigned int); +typedef struct xfs_sysctl_val xfs_sysctl_val_t; -struct cpa_data { - long unsigned int *vaddr; - pgd_t *pgd; - pgprot_t mask_set; - pgprot_t mask_clr; - long unsigned int numpages; - long unsigned int curpage; - long unsigned int pfn; - unsigned int flags; - unsigned int force_split: 1; - unsigned int force_static_prot: 1; - struct page **pages; +struct xfs_param { + xfs_sysctl_val_t sgid_inherit; + xfs_sysctl_val_t symlink_mode; + xfs_sysctl_val_t panic_mask; + xfs_sysctl_val_t error_level; + xfs_sysctl_val_t syncd_timer; + xfs_sysctl_val_t stats_clear; + xfs_sysctl_val_t inherit_sync; + xfs_sysctl_val_t inherit_nodump; + xfs_sysctl_val_t inherit_noatim; + xfs_sysctl_val_t xfs_buf_timer; + xfs_sysctl_val_t xfs_buf_age; + xfs_sysctl_val_t inherit_nosym; + xfs_sysctl_val_t rotorstep; + xfs_sysctl_val_t inherit_nodfrg; + xfs_sysctl_val_t fstrm_timer; + xfs_sysctl_val_t eofb_timer; + xfs_sysctl_val_t cowb_timer; }; -enum cpa_warn { - CPA_CONFLICT = 0, - CPA_PROTECT = 1, - CPA_DETECT = 2, -}; +typedef struct xfs_param xfs_param_t; -typedef struct { - u64 val; -} pfn_t; +struct xfs_globals { + int log_recovery_delay; + int mount_delay; + bool bug_on_assert; + bool always_cow; +}; -struct memtype { - u64 start; - u64 end; - u64 subtree_max_end; - enum page_cache_mode type; - struct rb_node rb; +enum ethtool_link_mode_bit_indices { + ETHTOOL_LINK_MODE_10baseT_Half_BIT = 0, + ETHTOOL_LINK_MODE_10baseT_Full_BIT = 1, + ETHTOOL_LINK_MODE_100baseT_Half_BIT = 2, + ETHTOOL_LINK_MODE_100baseT_Full_BIT = 3, + ETHTOOL_LINK_MODE_1000baseT_Half_BIT = 4, + ETHTOOL_LINK_MODE_1000baseT_Full_BIT = 5, + ETHTOOL_LINK_MODE_Autoneg_BIT = 6, + ETHTOOL_LINK_MODE_TP_BIT = 7, + ETHTOOL_LINK_MODE_AUI_BIT = 8, + ETHTOOL_LINK_MODE_MII_BIT = 9, + ETHTOOL_LINK_MODE_FIBRE_BIT = 10, + ETHTOOL_LINK_MODE_BNC_BIT = 11, + ETHTOOL_LINK_MODE_10000baseT_Full_BIT = 12, + ETHTOOL_LINK_MODE_Pause_BIT = 13, + ETHTOOL_LINK_MODE_Asym_Pause_BIT = 14, + ETHTOOL_LINK_MODE_2500baseX_Full_BIT = 15, + ETHTOOL_LINK_MODE_Backplane_BIT = 16, + ETHTOOL_LINK_MODE_1000baseKX_Full_BIT = 17, + ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT = 18, + ETHTOOL_LINK_MODE_10000baseKR_Full_BIT = 19, + ETHTOOL_LINK_MODE_10000baseR_FEC_BIT = 20, + ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT = 21, + ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT = 22, + ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT = 23, + ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT = 24, + ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT = 25, + ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT = 26, + ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT = 27, + ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT = 28, + ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT = 29, + ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT = 30, + ETHTOOL_LINK_MODE_25000baseCR_Full_BIT = 31, + ETHTOOL_LINK_MODE_25000baseKR_Full_BIT = 32, + ETHTOOL_LINK_MODE_25000baseSR_Full_BIT = 33, + ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT = 34, + ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT = 35, + ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT = 36, + ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT = 37, + ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT = 38, + ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT = 39, + ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT = 40, + ETHTOOL_LINK_MODE_1000baseX_Full_BIT = 41, + ETHTOOL_LINK_MODE_10000baseCR_Full_BIT = 42, + ETHTOOL_LINK_MODE_10000baseSR_Full_BIT = 43, + ETHTOOL_LINK_MODE_10000baseLR_Full_BIT = 44, + ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT = 45, + ETHTOOL_LINK_MODE_10000baseER_Full_BIT = 46, + ETHTOOL_LINK_MODE_2500baseT_Full_BIT = 47, + ETHTOOL_LINK_MODE_5000baseT_Full_BIT = 48, + ETHTOOL_LINK_MODE_FEC_NONE_BIT = 49, + ETHTOOL_LINK_MODE_FEC_RS_BIT = 50, + ETHTOOL_LINK_MODE_FEC_BASER_BIT = 51, + ETHTOOL_LINK_MODE_50000baseKR_Full_BIT = 52, + ETHTOOL_LINK_MODE_50000baseSR_Full_BIT = 53, + ETHTOOL_LINK_MODE_50000baseCR_Full_BIT = 54, + ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT = 55, + ETHTOOL_LINK_MODE_50000baseDR_Full_BIT = 56, + ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT = 57, + ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT = 58, + ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT = 59, + ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT = 60, + ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT = 61, + ETHTOOL_LINK_MODE_200000baseKR4_Full_BIT = 62, + ETHTOOL_LINK_MODE_200000baseSR4_Full_BIT = 63, + ETHTOOL_LINK_MODE_200000baseLR4_ER4_FR4_Full_BIT = 64, + ETHTOOL_LINK_MODE_200000baseDR4_Full_BIT = 65, + ETHTOOL_LINK_MODE_200000baseCR4_Full_BIT = 66, + ETHTOOL_LINK_MODE_100baseT1_Full_BIT = 67, + ETHTOOL_LINK_MODE_1000baseT1_Full_BIT = 68, + ETHTOOL_LINK_MODE_400000baseKR8_Full_BIT = 69, + ETHTOOL_LINK_MODE_400000baseSR8_Full_BIT = 70, + ETHTOOL_LINK_MODE_400000baseLR8_ER8_FR8_Full_BIT = 71, + ETHTOOL_LINK_MODE_400000baseDR8_Full_BIT = 72, + ETHTOOL_LINK_MODE_400000baseCR8_Full_BIT = 73, + __ETHTOOL_LINK_MODE_MASK_NBITS = 74, }; enum { - PAT_UC = 0, - PAT_WC = 1, - PAT_WT = 4, - PAT_WP = 5, - PAT_WB = 6, - PAT_UC_MINUS = 7, + NAPI_STATE_SCHED = 0, + NAPI_STATE_MISSED = 1, + NAPI_STATE_DISABLE = 2, + NAPI_STATE_NPSVC = 3, + NAPI_STATE_HASHED = 4, + NAPI_STATE_NO_BUSY_POLL = 5, + NAPI_STATE_IN_BUSY_POLL = 6, }; -struct pagerange_state { - long unsigned int cur_pfn; - int ram; - int not_ram; +struct compat_sysctl_args { + compat_uptr_t name; + int nlen; + compat_uptr_t oldval; + compat_uptr_t oldlenp; + compat_uptr_t newval; + compat_size_t newlen; + compat_ulong_t __unused[4]; }; -struct flush_tlb_info { - struct mm_struct *mm; - long unsigned int start; - long unsigned int end; - u64 new_tlb_gen; - unsigned int stride_shift; - bool freed_tables; +struct __user_cap_header_struct { + __u32 version; + int pid; }; -struct exception_stacks { - char DF_stack_guard[0]; - char DF_stack[4096]; - char NMI_stack_guard[0]; - char NMI_stack[4096]; - char DB2_stack_guard[0]; - char DB2_stack[0]; - char DB1_stack_guard[0]; - char DB1_stack[4096]; - char DB_stack_guard[0]; - char DB_stack[4096]; - char MCE_stack_guard[0]; - char MCE_stack[4096]; - char IST_top_guard[0]; -}; +typedef struct __user_cap_header_struct *cap_user_header_t; -struct rb_augment_callbacks { - void (*propagate)(struct rb_node *, struct rb_node *); - void (*copy)(struct rb_node *, struct rb_node *); - void (*rotate)(struct rb_node *, struct rb_node *); +struct __user_cap_data_struct { + __u32 effective; + __u32 permitted; + __u32 inheritable; }; -enum { - MEMTYPE_EXACT_MATCH = 0, - MEMTYPE_END_MATCH = 1, -}; +typedef struct __user_cap_data_struct *cap_user_data_t; -struct hugepage_subpool { - spinlock_t lock; - long int count; - long int max_hpages; - long int used_hpages; - struct hstate *hstate; - long int min_hpages; - long int rsv_hpages; +struct sigqueue { + struct list_head list; + int flags; + kernel_siginfo_t info; + struct user_struct *user; }; -struct hugetlbfs_sb_info { - long int max_inodes; - long int free_inodes; - spinlock_t stat_lock; - struct hstate *hstate; - struct hugepage_subpool *spool; - kuid_t uid; - kgid_t gid; - umode_t mode; +struct ptrace_peeksiginfo_args { + __u64 off; + __u32 flags; + __s32 nr; }; -struct numa_memblk { - u64 start; - u64 end; - int nid; +struct ptrace_syscall_info { + __u8 op; + __u32 arch; + __u64 instruction_pointer; + __u64 stack_pointer; + union { + struct { + __u64 nr; + __u64 args[6]; + } entry; + struct { + __s64 rval; + __u8 is_error; + } exit; + struct { + __u64 nr; + __u64 args[6]; + __u32 ret_data; + } seccomp; + }; }; -struct numa_meminfo { - int nr_blks; - struct numa_memblk blk[128]; +struct compat_iovec { + compat_uptr_t iov_base; + compat_size_t iov_len; }; -struct acpi_srat_cpu_affinity { - struct acpi_subtable_header header; - u8 proximity_domain_lo; - u8 apic_id; - u32 flags; - u8 local_sapic_eid; - u8 proximity_domain_hi[3]; - u32 clock_domain; -}; +typedef long unsigned int old_sigset_t; -struct acpi_srat_x2apic_cpu_affinity { - struct acpi_subtable_header header; - u16 reserved; - u32 proximity_domain; - u32 apic_id; - u32 flags; - u32 clock_domain; - u32 reserved2; +enum siginfo_layout { + SIL_KILL = 0, + SIL_TIMER = 1, + SIL_POLL = 2, + SIL_FAULT = 3, + SIL_FAULT_MCEERR = 4, + SIL_FAULT_BNDERR = 5, + SIL_FAULT_PKUERR = 6, + SIL_CHLD = 7, + SIL_RT = 8, + SIL_SYS = 9, }; -enum uv_system_type { - UV_NONE = 0, - UV_LEGACY_APIC = 1, - UV_X2APIC = 2, - UV_NON_UNIQUE_APIC = 3, -}; +typedef u32 compat_old_sigset_t; -struct rnd_state { - __u32 s1; - __u32 s2; - __u32 s3; - __u32 s4; +struct compat_sigaction { + compat_uptr_t sa_handler; + compat_ulong_t sa_flags; + compat_uptr_t sa_restorer; + compat_sigset_t sa_mask; }; -struct kaslr_memory_region { - long unsigned int *base; - long unsigned int size_tb; +struct compat_old_sigaction { + compat_uptr_t sa_handler; + compat_old_sigset_t sa_mask; + compat_ulong_t sa_flags; + compat_uptr_t sa_restorer; }; -enum pti_mode { - PTI_AUTO = 0, - PTI_FORCE_OFF = 1, - PTI_FORCE_ON = 2, +enum { + TRACE_SIGNAL_DELIVERED = 0, + TRACE_SIGNAL_IGNORED = 1, + TRACE_SIGNAL_ALREADY_PENDING = 2, + TRACE_SIGNAL_OVERFLOW_FAIL = 3, + TRACE_SIGNAL_LOSE_INFO = 4, }; -enum pti_clone_level { - PTI_CLONE_PMD = 0, - PTI_CLONE_PTE = 1, +struct trace_event_raw_signal_generate { + struct trace_entry ent; + int sig; + int errno; + int code; + char comm[16]; + pid_t pid; + int group; + int result; + char __data[0]; }; -typedef short unsigned int __kernel_old_uid_t; - -typedef short unsigned int __kernel_old_gid_t; - -typedef struct { - int val[2]; -} __kernel_fsid_t; - -typedef __kernel_old_uid_t old_uid_t; +struct trace_event_raw_signal_deliver { + struct trace_entry ent; + int sig; + int errno; + int code; + long unsigned int sa_handler; + long unsigned int sa_flags; + char __data[0]; +}; -typedef __kernel_old_gid_t old_gid_t; +struct trace_event_data_offsets_signal_generate {}; -struct kstatfs { - long int f_type; - long int f_bsize; - u64 f_blocks; - u64 f_bfree; - u64 f_bavail; - u64 f_files; - u64 f_ffree; - __kernel_fsid_t f_fsid; - long int f_namelen; - long int f_frsize; - long int f_flags; - long int f_spare[4]; -}; +struct trace_event_data_offsets_signal_deliver {}; -struct kernel_clone_args { - u64 flags; - int *pidfd; - int *child_tid; - int *parent_tid; - int exit_signal; - long unsigned int stack; - long unsigned int stack_size; - long unsigned int tls; - pid_t *set_tid; - size_t set_tid_size; -}; +typedef void (*btf_trace_signal_generate)(void *, int, struct kernel_siginfo *, struct task_struct *, int, int); -struct stat64 { - long long unsigned int st_dev; - unsigned char __pad0[4]; - unsigned int __st_ino; - unsigned int st_mode; - unsigned int st_nlink; - unsigned int st_uid; - unsigned int st_gid; - long long unsigned int st_rdev; - unsigned char __pad3[4]; - long long int st_size; - unsigned int st_blksize; - long long int st_blocks; - unsigned int st_atime; - unsigned int st_atime_nsec; - unsigned int st_mtime; - unsigned int st_mtime_nsec; - unsigned int st_ctime; - unsigned int st_ctime_nsec; - long long unsigned int st_ino; -} __attribute__((packed)); +typedef void (*btf_trace_signal_deliver)(void *, int, struct kernel_siginfo *, struct k_sigaction *); -struct mmap_arg_struct32 { - unsigned int addr; - unsigned int len; - unsigned int prot; - unsigned int flags; - unsigned int fd; - unsigned int offset; -}; +typedef __kernel_clock_t clock_t; -struct sigcontext_32 { - __u16 gs; - __u16 __gsh; - __u16 fs; - __u16 __fsh; - __u16 es; - __u16 __esh; - __u16 ds; - __u16 __dsh; - __u32 di; - __u32 si; - __u32 bp; - __u32 sp; - __u32 bx; - __u32 dx; - __u32 cx; - __u32 ax; - __u32 trapno; - __u32 err; - __u32 ip; - __u16 cs; - __u16 __csh; - __u32 flags; - __u32 sp_at_signal; - __u16 ss; - __u16 __ssh; - __u32 fpstate; - __u32 oldmask; - __u32 cr2; +struct sysinfo { + __kernel_long_t uptime; + __kernel_ulong_t loads[3]; + __kernel_ulong_t totalram; + __kernel_ulong_t freeram; + __kernel_ulong_t sharedram; + __kernel_ulong_t bufferram; + __kernel_ulong_t totalswap; + __kernel_ulong_t freeswap; + __u16 procs; + __u16 pad; + __kernel_ulong_t totalhigh; + __kernel_ulong_t freehigh; + __u32 mem_unit; + char _f[0]; }; -typedef u32 compat_size_t; +enum { + PER_LINUX = 0, + PER_LINUX_32BIT = 8388608, + PER_LINUX_FDPIC = 524288, + PER_SVR4 = 68157441, + PER_SVR3 = 83886082, + PER_SCOSVR3 = 117440515, + PER_OSR5 = 100663299, + PER_WYSEV386 = 83886084, + PER_ISCR4 = 67108869, + PER_BSD = 6, + PER_SUNOS = 67108870, + PER_XENIX = 83886087, + PER_LINUX32 = 8, + PER_LINUX32_3GB = 134217736, + PER_IRIX32 = 67108873, + PER_IRIXN32 = 67108874, + PER_IRIX64 = 67108875, + PER_RISCOS = 12, + PER_SOLARIS = 67108877, + PER_UW7 = 68157454, + PER_OSF4 = 15, + PER_HPUX = 16, + PER_MASK = 255, +}; -struct compat_sigaltstack { - compat_uptr_t ss_sp; - int ss_flags; - compat_size_t ss_size; +struct rlimit64 { + __u64 rlim_cur; + __u64 rlim_max; }; -typedef struct compat_sigaltstack compat_stack_t; +struct oldold_utsname { + char sysname[9]; + char nodename[9]; + char release[9]; + char version[9]; + char machine[9]; +}; -struct ucontext_ia32 { - unsigned int uc_flags; - unsigned int uc_link; - compat_stack_t uc_stack; - struct sigcontext_32 uc_mcontext; - compat_sigset_t uc_sigmask; +struct old_utsname { + char sysname[65]; + char nodename[65]; + char release[65]; + char version[65]; + char machine[65]; }; -struct sigframe_ia32 { - u32 pretcode; - int sig; - struct sigcontext_32 sc; - struct _fpstate_32 fpstate_unused; - unsigned int extramask[1]; - char retcode[8]; +enum uts_proc { + UTS_PROC_OSTYPE = 0, + UTS_PROC_OSRELEASE = 1, + UTS_PROC_VERSION = 2, + UTS_PROC_HOSTNAME = 3, + UTS_PROC_DOMAINNAME = 4, }; -struct rt_sigframe_ia32 { - u32 pretcode; - int sig; - u32 pinfo; - u32 puc; - compat_siginfo_t info; - struct ucontext_ia32 uc; - char retcode[8]; +struct prctl_mm_map { + __u64 start_code; + __u64 end_code; + __u64 start_data; + __u64 end_data; + __u64 start_brk; + __u64 brk; + __u64 start_stack; + __u64 arg_start; + __u64 arg_end; + __u64 env_start; + __u64 env_end; + __u64 *auxv; + __u32 auxv_size; + __u32 exe_fd; }; -typedef struct { - efi_guid_t guid; - u64 table; -} efi_config_table_64_t; +struct tms { + __kernel_clock_t tms_utime; + __kernel_clock_t tms_stime; + __kernel_clock_t tms_cutime; + __kernel_clock_t tms_cstime; +}; -struct efi_mem_range { - struct range range; - u64 attribute; +struct getcpu_cache { + long unsigned int blob[16]; }; -enum efi_rts_ids { - EFI_NONE = 0, - EFI_GET_TIME = 1, - EFI_SET_TIME = 2, - EFI_GET_WAKEUP_TIME = 3, - EFI_SET_WAKEUP_TIME = 4, - EFI_GET_VARIABLE = 5, - EFI_GET_NEXT_VARIABLE = 6, - EFI_SET_VARIABLE = 7, - EFI_QUERY_VARIABLE_INFO = 8, - EFI_GET_NEXT_HIGH_MONO_COUNT = 9, - EFI_RESET_SYSTEM = 10, - EFI_UPDATE_CAPSULE = 11, - EFI_QUERY_CAPSULE_CAPS = 12, +struct compat_tms { + compat_clock_t tms_utime; + compat_clock_t tms_stime; + compat_clock_t tms_cutime; + compat_clock_t tms_cstime; }; -struct efi_runtime_work { - void *arg1; - void *arg2; - void *arg3; - void *arg4; - void *arg5; - efi_status_t status; - struct work_struct work; - enum efi_rts_ids efi_rts_id; - struct completion efi_rts_comp; +struct compat_rlimit { + compat_ulong_t rlim_cur; + compat_ulong_t rlim_max; }; -struct efi_scratch { - u64 phys_stack; - struct mm_struct *prev_mm; +struct compat_sysinfo { + s32 uptime; + u32 loads[3]; + u32 totalram; + u32 freeram; + u32 sharedram; + u32 bufferram; + u32 totalswap; + u32 freeswap; + u16 procs; + u16 pad; + u32 totalhigh; + u32 freehigh; + u32 mem_unit; + char _f[8]; }; -struct efi_setup_data { - u64 fw_vendor; - u64 runtime; - u64 tables; - u64 smbios; - u64 reserved[8]; +struct umh_info { + const char *cmdline; + struct file *pipe_to_umh; + struct file *pipe_from_umh; + struct list_head list; + void (*cleanup)(struct umh_info *); + pid_t pid; }; -typedef struct { - efi_table_hdr_t hdr; - u32 get_time; - u32 set_time; - u32 get_wakeup_time; - u32 set_wakeup_time; - u32 set_virtual_address_map; - u32 convert_pointer; - u32 get_variable; - u32 get_next_variable; - u32 set_variable; - u32 get_next_high_mono_count; - u32 reset_system; - u32 update_capsule; - u32 query_capsule_caps; - u32 query_variable_info; -} efi_runtime_services_32_t; +struct wq_flusher; -typedef struct { - efi_table_hdr_t hdr; - u64 get_time; - u64 set_time; - u64 get_wakeup_time; - u64 set_wakeup_time; - u64 set_virtual_address_map; - u64 convert_pointer; - u64 get_variable; - u64 get_next_variable; - u64 set_variable; - u64 get_next_high_mono_count; - u64 reset_system; - u64 update_capsule; - u64 query_capsule_caps; - u64 query_variable_info; -} efi_runtime_services_64_t; +struct worker; -typedef struct { - efi_guid_t guid; - const char *name; - long unsigned int *ptr; -} efi_config_table_type_t; +struct workqueue_attrs; -typedef struct { - efi_table_hdr_t hdr; - u64 fw_vendor; - u32 fw_revision; - u32 __pad1; - u64 con_in_handle; - u64 con_in; - u64 con_out_handle; - u64 con_out; - u64 stderr_handle; - u64 stderr; - u64 runtime; - u64 boottime; - u32 nr_tables; - u32 __pad2; - u64 tables; -} efi_system_table_64_t; +struct pool_workqueue; -typedef struct { - efi_table_hdr_t hdr; - u32 fw_vendor; - u32 fw_revision; - u32 con_in_handle; - u32 con_in; - u32 con_out_handle; - u32 con_out; - u32 stderr_handle; - u32 stderr; - u32 runtime; - u32 boottime; - u32 nr_tables; - u32 tables; -} efi_system_table_32_t; +struct wq_device; -struct efi_memory_map_data { - phys_addr_t phys_map; - long unsigned int size; - long unsigned int desc_version; - long unsigned int desc_size; +struct workqueue_struct { + struct list_head pwqs; + struct list_head list; + struct mutex mutex; + int work_color; + int flush_color; + atomic_t nr_pwqs_to_flush; + struct wq_flusher *first_flusher; + struct list_head flusher_queue; + struct list_head flusher_overflow; + struct list_head maydays; + struct worker *rescuer; + int nr_drainers; + int saved_max_active; + struct workqueue_attrs *unbound_attrs; + struct pool_workqueue *dfl_pwq; + struct wq_device *wq_dev; + char name[24]; + struct callback_head rcu; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + unsigned int flags; + struct pool_workqueue *cpu_pwqs; + struct pool_workqueue *numa_pwq_tbl[0]; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -typedef int (*efi_memattr_perm_setter)(struct mm_struct *, efi_memory_desc_t *); - -typedef u16 ucs2_char_t; - -struct wait_queue_entry; - -typedef int (*wait_queue_func_t)(struct wait_queue_entry *, unsigned int, int, void *); +struct workqueue_attrs { + int nice; + cpumask_var_t cpumask; + bool no_numa; +}; -struct wait_queue_entry { - unsigned int flags; - void *private; - wait_queue_func_t func; - struct list_head entry; +struct execute_work { + struct work_struct work; }; enum { - PM_QOS_RESERVED = 0, - PM_QOS_CPU_DMA_LATENCY = 1, - PM_QOS_NUM_CLASSES = 2, + WQ_UNBOUND = 2, + WQ_FREEZABLE = 4, + WQ_MEM_RECLAIM = 8, + WQ_HIGHPRI = 16, + WQ_CPU_INTENSIVE = 32, + WQ_SYSFS = 64, + WQ_POWER_EFFICIENT = 128, + __WQ_DRAINING = 65536, + __WQ_ORDERED = 131072, + __WQ_LEGACY = 262144, + __WQ_ORDERED_EXPLICIT = 524288, + WQ_MAX_ACTIVE = 512, + WQ_MAX_UNBOUND_PER_CPU = 4, + WQ_DFL_ACTIVE = 256, }; -struct pm_qos_request { - struct plist_node node; - int pm_qos_class; - struct delayed_work work; +typedef unsigned int xa_mark_t; + +enum xa_lock_type { + XA_LOCK_IRQ = 1, + XA_LOCK_BH = 2, }; -enum tk_offsets { - TK_OFFS_REAL = 0, - TK_OFFS_BOOT = 1, - TK_OFFS_TAI = 2, - TK_OFFS_MAX = 3, +struct __una_u32 { + u32 x; }; -typedef long unsigned int vm_flags_t; +struct worker_pool; -struct clone_args { - __u64 flags; - __u64 pidfd; - __u64 child_tid; - __u64 parent_tid; - __u64 exit_signal; - __u64 stack; - __u64 stack_size; - __u64 tls; - __u64 set_tid; - __u64 set_tid_size; +struct worker { + union { + struct list_head entry; + struct hlist_node hentry; + }; + struct work_struct *current_work; + work_func_t current_func; + struct pool_workqueue *current_pwq; + struct list_head scheduled; + struct task_struct *task; + struct worker_pool *pool; + struct list_head node; + long unsigned int last_active; + unsigned int flags; + int id; + int sleeping; + char desc[24]; + struct workqueue_struct *rescue_wq; + work_func_t last_func; }; -struct fdtable { - unsigned int max_fds; - struct file **fd; - long unsigned int *close_on_exec; - long unsigned int *open_fds; - long unsigned int *full_fds_bits; +struct pool_workqueue { + struct worker_pool *pool; + struct workqueue_struct *wq; + int work_color; + int flush_color; + int refcnt; + int nr_in_flight[15]; + int nr_active; + int max_active; + struct list_head delayed_works; + struct list_head pwqs_node; + struct list_head mayday_node; + struct work_struct unbound_release_work; struct callback_head rcu; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct files_struct { - atomic_t count; - bool resize_in_progress; - wait_queue_head_t resize_wait; - struct fdtable *fdt; - struct fdtable fdtab; +struct worker_pool { + spinlock_t lock; + int cpu; + int node; + int id; + unsigned int flags; + long unsigned int watchdog_ts; + struct list_head worklist; + int nr_workers; + int nr_idle; + struct list_head idle_list; + struct timer_list idle_timer; + struct timer_list mayday_timer; + struct hlist_head busy_hash[64]; + struct worker *manager; + struct list_head workers; + struct completion *detach_completion; + struct ida worker_ida; + struct workqueue_attrs *attrs; + struct hlist_node hash_node; + int refcnt; + long: 32; long: 64; long: 64; long: 64; + atomic_t nr_running; + struct callback_head rcu; long: 64; - spinlock_t file_lock; - unsigned int next_fd; - long unsigned int close_on_exec_init[1]; - long unsigned int open_fds_init[1]; - long unsigned int full_fds_bits_init[1]; - struct file *fd_array[64]; long: 64; long: 64; long: 64; long: 64; }; -struct robust_list { - struct robust_list *next; +enum { + POOL_MANAGER_ACTIVE = 1, + POOL_DISASSOCIATED = 4, + WORKER_DIE = 2, + WORKER_IDLE = 4, + WORKER_PREP = 8, + WORKER_CPU_INTENSIVE = 64, + WORKER_UNBOUND = 128, + WORKER_REBOUND = 256, + WORKER_NOT_RUNNING = 456, + NR_STD_WORKER_POOLS = 2, + UNBOUND_POOL_HASH_ORDER = 6, + BUSY_WORKER_HASH_ORDER = 6, + MAX_IDLE_WORKERS_RATIO = 4, + IDLE_WORKER_TIMEOUT = 300000, + MAYDAY_INITIAL_TIMEOUT = 10, + MAYDAY_INTERVAL = 100, + CREATE_COOLDOWN = 1000, + RESCUER_NICE_LEVEL = 4294967276, + HIGHPRI_NICE_LEVEL = 4294967276, + WQ_NAME_LEN = 24, +}; + +struct wq_flusher { + struct list_head list; + int flush_color; + struct completion done; +}; + +struct wq_device { + struct workqueue_struct *wq; + struct device dev; +}; + +struct trace_event_raw_workqueue_work { + struct trace_entry ent; + void *work; + char __data[0]; +}; + +struct trace_event_raw_workqueue_queue_work { + struct trace_entry ent; + void *work; + void *function; + void *workqueue; + unsigned int req_cpu; + unsigned int cpu; + char __data[0]; +}; + +struct trace_event_raw_workqueue_execute_start { + struct trace_entry ent; + void *work; + void *function; + char __data[0]; +}; + +struct trace_event_data_offsets_workqueue_work {}; + +struct trace_event_data_offsets_workqueue_queue_work {}; + +struct trace_event_data_offsets_workqueue_execute_start {}; + +typedef void (*btf_trace_workqueue_queue_work)(void *, unsigned int, struct pool_workqueue *, struct work_struct *); + +typedef void (*btf_trace_workqueue_activate_work)(void *, struct work_struct *); + +typedef void (*btf_trace_workqueue_execute_start)(void *, struct work_struct *); + +typedef void (*btf_trace_workqueue_execute_end)(void *, struct work_struct *); + +struct wq_barrier { + struct work_struct work; + struct completion done; + struct task_struct *task; +}; + +struct cwt_wait { + wait_queue_entry_t wait; + struct work_struct *work; +}; + +struct apply_wqattrs_ctx { + struct workqueue_struct *wq; + struct workqueue_attrs *attrs; + struct list_head list; + struct pool_workqueue *dfl_pwq; + struct pool_workqueue *pwq_tbl[0]; +}; + +struct work_for_cpu { + struct work_struct work; + long int (*fn)(void *); + void *arg; + long int ret; }; -struct robust_list_head { - struct robust_list list; - long int futex_offset; - struct robust_list *list_op_pending; -}; +typedef void (*task_work_func_t)(struct callback_head *); -struct multiprocess_signals { - sigset_t signal; - struct hlist_node node; +enum { + KERNEL_PARAM_OPS_FL_NOARG = 1, }; -typedef int (*proc_visitor)(struct task_struct *, void *); - enum { - IOPRIO_CLASS_NONE = 0, - IOPRIO_CLASS_RT = 1, - IOPRIO_CLASS_BE = 2, - IOPRIO_CLASS_IDLE = 3, + KERNEL_PARAM_FL_UNSAFE = 1, + KERNEL_PARAM_FL_HWPARAM = 2, }; -enum memcg_stat_item { - MEMCG_CACHE = 32, - MEMCG_RSS = 33, - MEMCG_RSS_HUGE = 34, - MEMCG_SWAP = 35, - MEMCG_SOCK = 36, - MEMCG_KERNEL_STACK_KB = 37, - MEMCG_NR_STAT = 38, +struct param_attribute { + struct module_attribute mattr; + const struct kernel_param *param; }; -typedef struct poll_table_struct poll_table; +struct module_param_attrs { + unsigned int num; + struct attribute_group grp; + struct param_attribute attrs[0]; +}; -enum { - FUTEX_STATE_OK = 0, - FUTEX_STATE_EXITING = 1, - FUTEX_STATE_DEAD = 2, +struct module_version_attribute { + struct module_attribute mattr; + const char *module_name; + const char *version; }; -struct trace_event_raw_task_newtask { - struct trace_entry ent; - pid_t pid; - char comm[16]; - long unsigned int clone_flags; - short int oom_score_adj; - char __data[0]; +struct kmalloced_param { + struct list_head list; + char val[0]; }; -struct trace_event_raw_task_rename { - struct trace_entry ent; - pid_t pid; - char oldcomm[16]; - char newcomm[16]; - short int oom_score_adj; - char __data[0]; +struct sched_param { + int sched_priority; }; -struct trace_event_data_offsets_task_newtask {}; +struct kthread_work; -struct trace_event_data_offsets_task_rename {}; +typedef void (*kthread_work_func_t)(struct kthread_work *); -struct taint_flag { - char c_true; - char c_false; - bool module; -}; +struct kthread_worker; -enum ftrace_dump_mode { - DUMP_NONE = 0, - DUMP_ALL = 1, - DUMP_ORIG = 2, +struct kthread_work { + struct list_head node; + kthread_work_func_t func; + struct kthread_worker *worker; + int canceling; }; -enum kmsg_dump_reason { - KMSG_DUMP_UNDEF = 0, - KMSG_DUMP_PANIC = 1, - KMSG_DUMP_OOPS = 2, - KMSG_DUMP_EMERG = 3, - KMSG_DUMP_RESTART = 4, - KMSG_DUMP_HALT = 5, - KMSG_DUMP_POWEROFF = 6, +enum { + KTW_FREEZABLE = 1, }; -enum con_flush_mode { - CONSOLE_FLUSH_PENDING = 0, - CONSOLE_REPLAY_ALL = 1, +struct kthread_worker { + unsigned int flags; + raw_spinlock_t lock; + struct list_head work_list; + struct list_head delayed_work_list; + struct task_struct *task; + struct kthread_work *current_work; }; -struct warn_args { - const char *fmt; - va_list args; +struct kthread_delayed_work { + struct kthread_work work; + struct timer_list timer; }; -struct smp_hotplug_thread { - struct task_struct **store; +struct kthread_create_info { + int (*threadfn)(void *); + void *data; + int node; + struct task_struct *result; + struct completion *done; struct list_head list; - int (*thread_should_run)(unsigned int); - void (*thread_fn)(unsigned int); - void (*create)(unsigned int); - void (*setup)(unsigned int); - void (*cleanup)(unsigned int, bool); - void (*park)(unsigned int); - void (*unpark)(unsigned int); - bool selfparking; - const char *thread_comm; }; -struct trace_event_raw_cpuhp_enter { - struct trace_entry ent; +struct kthread { + long unsigned int flags; unsigned int cpu; - int target; - int idx; - void *fun; - char __data[0]; + void *data; + struct completion parked; + struct completion exited; }; -struct trace_event_raw_cpuhp_multi_enter { - struct trace_entry ent; - unsigned int cpu; - int target; - int idx; - void *fun; - char __data[0]; +enum KTHREAD_BITS { + KTHREAD_IS_PER_CPU = 0, + KTHREAD_SHOULD_STOP = 1, + KTHREAD_SHOULD_PARK = 2, }; -struct trace_event_raw_cpuhp_exit { - struct trace_entry ent; - unsigned int cpu; - int state; - int idx; - int ret; - char __data[0]; +struct kthread_flush_work { + struct kthread_work work; + struct completion done; }; -struct trace_event_data_offsets_cpuhp_enter {}; - -struct trace_event_data_offsets_cpuhp_multi_enter {}; +struct pt_regs___2; -struct trace_event_data_offsets_cpuhp_exit {}; +struct ipc_ids { + int in_use; + short unsigned int seq; + struct rw_semaphore rwsem; + struct idr ipcs_idr; + int max_idx; + int last_idx; + struct rhashtable key_ht; +}; -struct cpuhp_cpu_state { - enum cpuhp_state state; - enum cpuhp_state target; - enum cpuhp_state fail; - struct task_struct *thread; - bool should_run; - bool rollback; - bool single; - bool bringup; - struct hlist_node *node; - struct hlist_node *last; - enum cpuhp_state cb_state; - int result; - struct completion done_up; - struct completion done_down; +struct ipc_namespace { + refcount_t count; + struct ipc_ids ids[3]; + int sem_ctls[4]; + int used_sems; + unsigned int msg_ctlmax; + unsigned int msg_ctlmnb; + unsigned int msg_ctlmni; + atomic_t msg_bytes; + atomic_t msg_hdrs; + size_t shm_ctlmax; + size_t shm_ctlall; + long unsigned int shm_tot; + int shm_ctlmni; + int shm_rmid_forced; + struct notifier_block ipcns_nb; + struct vfsmount *mq_mnt; + unsigned int mq_queues_count; + unsigned int mq_queues_max; + unsigned int mq_msg_max; + unsigned int mq_msgsize_max; + unsigned int mq_msg_default; + unsigned int mq_msgsize_default; + struct user_namespace *user_ns; + struct ucounts *ucounts; + struct ns_common ns; }; -struct cpuhp_step { - const char *name; - union { - int (*single)(unsigned int); - int (*multi)(unsigned int, struct hlist_node *); - } startup; - union { - int (*single)(unsigned int); - int (*multi)(unsigned int, struct hlist_node *); - } teardown; - struct hlist_head list; - bool cant_stop; - bool multi_instance; +struct srcu_notifier_head { + struct mutex mutex; + struct srcu_struct srcu; + struct notifier_block *head; }; -enum cpu_mitigations { - CPU_MITIGATIONS_OFF = 0, - CPU_MITIGATIONS_AUTO = 1, - CPU_MITIGATIONS_AUTO_NOSMT = 2, +enum what { + PROC_EVENT_NONE = 0, + PROC_EVENT_FORK = 1, + PROC_EVENT_EXEC = 2, + PROC_EVENT_UID = 4, + PROC_EVENT_GID = 64, + PROC_EVENT_SID = 128, + PROC_EVENT_PTRACE = 256, + PROC_EVENT_COMM = 512, + PROC_EVENT_COREDUMP = 1073741824, + PROC_EVENT_EXIT = 2147483648, }; -typedef void (*rcu_callback_t)(struct callback_head *); +typedef u64 async_cookie_t; -struct __kernel_old_timeval { - __kernel_long_t tv_sec; - __kernel_long_t tv_usec; -}; +typedef void (*async_func_t)(void *, async_cookie_t); -typedef struct wait_queue_entry wait_queue_entry_t; +struct async_domain { + struct list_head pending; + unsigned int registered: 1; +}; -struct old_timeval32 { - old_time32_t tv_sec; - s32 tv_usec; +struct async_entry { + struct list_head domain_list; + struct list_head global_list; + struct work_struct work; + async_cookie_t cookie; + async_func_t func; + void *data; + struct async_domain *domain; }; -struct rusage { - struct __kernel_old_timeval ru_utime; - struct __kernel_old_timeval ru_stime; - __kernel_long_t ru_maxrss; - __kernel_long_t ru_ixrss; - __kernel_long_t ru_idrss; - __kernel_long_t ru_isrss; - __kernel_long_t ru_minflt; - __kernel_long_t ru_majflt; - __kernel_long_t ru_nswap; - __kernel_long_t ru_inblock; - __kernel_long_t ru_oublock; - __kernel_long_t ru_msgsnd; - __kernel_long_t ru_msgrcv; - __kernel_long_t ru_nsignals; - __kernel_long_t ru_nvcsw; - __kernel_long_t ru_nivcsw; +struct smpboot_thread_data { + unsigned int cpu; + unsigned int status; + struct smp_hotplug_thread *ht; }; -struct fd { - struct file *file; - unsigned int flags; +enum { + HP_THREAD_NONE = 0, + HP_THREAD_ACTIVE = 1, + HP_THREAD_PARKED = 2, }; -struct compat_rusage { - struct old_timeval32 ru_utime; - struct old_timeval32 ru_stime; - compat_long_t ru_maxrss; - compat_long_t ru_ixrss; - compat_long_t ru_idrss; - compat_long_t ru_isrss; - compat_long_t ru_minflt; - compat_long_t ru_majflt; - compat_long_t ru_nswap; - compat_long_t ru_inblock; - compat_long_t ru_oublock; - compat_long_t ru_msgsnd; - compat_long_t ru_msgrcv; - compat_long_t ru_nsignals; - compat_long_t ru_nvcsw; - compat_long_t ru_nivcsw; +struct pin_cookie {}; + +struct dl_bw { + raw_spinlock_t lock; + u64 bw; + u64 total_bw; }; -struct waitid_info { - pid_t pid; - uid_t uid; - int status; - int cause; +struct cpudl_item; + +struct cpudl { + raw_spinlock_t lock; + int size; + cpumask_var_t free_cpus; + struct cpudl_item *elements; }; -struct wait_opts { - enum pid_type wo_type; - int wo_flags; - struct pid *wo_pid; - struct waitid_info *wo_info; - int wo_stat; - struct rusage *wo_rusage; - wait_queue_entry_t child_wait; - int notask_error; +struct cpupri_vec { + atomic_t count; + cpumask_var_t mask; }; -struct softirq_action { - void (*action)(struct softirq_action *); +struct cpupri { + struct cpupri_vec pri_to_cpu[102]; + int *cpu_to_pri; }; -struct tasklet_struct { - struct tasklet_struct *next; - long unsigned int state; - atomic_t count; - void (*func)(long unsigned int); - long unsigned int data; +struct perf_domain; + +struct root_domain___2 { + atomic_t refcount; + atomic_t rto_count; + struct callback_head rcu; + cpumask_var_t span; + cpumask_var_t online; + int overload; + int overutilized; + cpumask_var_t dlo_mask; + atomic_t dlo_count; + struct dl_bw dl_bw; + struct cpudl cpudl; + struct irq_work rto_push_work; + raw_spinlock_t rto_lock; + int rto_loop; + int rto_cpu; + atomic_t rto_loop_next; + atomic_t rto_loop_start; + cpumask_var_t rto_mask; + struct cpupri cpupri; + long unsigned int max_cpu_capacity; + struct perf_domain *pd; }; -enum { - TASKLET_STATE_SCHED = 0, - TASKLET_STATE_RUN = 1, +struct cfs_rq { + struct load_weight load; + long unsigned int runnable_weight; + unsigned int nr_running; + unsigned int h_nr_running; + unsigned int idle_h_nr_running; + u64 exec_clock; + u64 min_vruntime; + struct rb_root_cached tasks_timeline; + struct sched_entity *curr; + struct sched_entity *next; + struct sched_entity *last; + struct sched_entity *skip; + long: 64; + long: 64; + long: 64; + struct sched_avg avg; + struct { + raw_spinlock_t lock; + int nr; + long unsigned int load_avg; + long unsigned int util_avg; + long unsigned int runnable_sum; + long: 64; + long: 64; + long: 64; + long: 64; + } removed; + long unsigned int tg_load_avg_contrib; + long int propagate; + long int prop_runnable_sum; + long unsigned int h_load; + u64 last_h_load_update; + struct sched_entity *h_load_next; + struct rq *rq; + int on_list; + struct list_head leaf_cfs_rq_list; + struct task_group *tg; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct trace_event_raw_irq_handler_entry { - struct trace_entry ent; - int irq; - u32 __data_loc_name; - char __data[0]; +struct cfs_bandwidth {}; + +struct task_group { + struct cgroup_subsys_state css; + struct sched_entity **se; + struct cfs_rq **cfs_rq; + long unsigned int shares; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + atomic_long_t load_avg; + struct callback_head rcu; + struct list_head list; + struct task_group *parent; + struct list_head siblings; + struct list_head children; + struct cfs_bandwidth cfs_bandwidth; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct trace_event_raw_irq_handler_exit { - struct trace_entry ent; - int irq; - int ret; - char __data[0]; +struct update_util_data { + void (*func)(struct update_util_data *, u64, unsigned int); }; -struct trace_event_raw_softirq { - struct trace_entry ent; - unsigned int vec; - char __data[0]; +enum { + MEMBARRIER_STATE_PRIVATE_EXPEDITED_READY = 1, + MEMBARRIER_STATE_PRIVATE_EXPEDITED = 2, + MEMBARRIER_STATE_GLOBAL_EXPEDITED_READY = 4, + MEMBARRIER_STATE_GLOBAL_EXPEDITED = 8, + MEMBARRIER_STATE_PRIVATE_EXPEDITED_SYNC_CORE_READY = 16, + MEMBARRIER_STATE_PRIVATE_EXPEDITED_SYNC_CORE = 32, }; -struct trace_event_data_offsets_irq_handler_entry { - u32 name; +struct sched_group { + struct sched_group *next; + atomic_t ref; + unsigned int group_weight; + struct sched_group_capacity *sgc; + int asym_prefer_cpu; + long unsigned int cpumask[0]; }; -struct trace_event_data_offsets_irq_handler_exit {}; +struct sched_group_capacity { + atomic_t ref; + long unsigned int capacity; + long unsigned int min_capacity; + long unsigned int max_capacity; + long unsigned int next_update; + int imbalance; + long unsigned int cpumask[0]; +}; -struct trace_event_data_offsets_softirq {}; +struct wake_q_head { + struct wake_q_node *first; + struct wake_q_node **lastp; +}; -struct tasklet_head { - struct tasklet_struct *head; - struct tasklet_struct **tail; +struct sched_attr { + __u32 size; + __u32 sched_policy; + __u64 sched_flags; + __s32 sched_nice; + __u32 sched_priority; + __u64 sched_runtime; + __u64 sched_deadline; + __u64 sched_period; + __u32 sched_util_min; + __u32 sched_util_max; }; -typedef u16 pto_T_____6; - -typedef void (*dr_release_t)(struct device *, void *); +struct cpuidle_driver___2; -typedef int (*dr_match_t)(struct device *, void *, void *); +struct cpuidle_state { + char name[16]; + char desc[32]; + u64 exit_latency_ns; + u64 target_residency_ns; + unsigned int flags; + unsigned int exit_latency; + int power_usage; + unsigned int target_residency; + int (*enter)(struct cpuidle_device *, struct cpuidle_driver___2 *, int); + int (*enter_dead)(struct cpuidle_device *, int); + void (*enter_s2idle)(struct cpuidle_device *, struct cpuidle_driver___2 *, int); +}; -struct resource_entry { - struct list_head node; - struct resource *res; - resource_size_t offset; - struct resource __res; +struct cpuidle_driver___2 { + const char *name; + struct module *owner; + int refcnt; + unsigned int bctimer: 1; + struct cpuidle_state states[10]; + int state_count; + int safe_state_index; + struct cpumask *cpumask; + const char *governor; }; -struct resource_constraint { - resource_size_t min; - resource_size_t max; - resource_size_t align; - resource_size_t (*alignf)(void *, const struct resource *, resource_size_t, resource_size_t); - void *alignf_data; +struct em_cap_state { + long unsigned int frequency; + long unsigned int power; + long unsigned int cost; }; -enum { - MAX_IORES_LEVEL = 5, +struct em_perf_domain { + struct em_cap_state *table; + int nr_cap_states; + long unsigned int cpus[0]; }; -struct region_devres { - struct resource *parent; - resource_size_t start; - resource_size_t n; +enum { + CFTYPE_ONLY_ON_ROOT = 1, + CFTYPE_NOT_ON_ROOT = 2, + CFTYPE_NS_DELEGATABLE = 4, + CFTYPE_NO_PREFIX = 8, + CFTYPE_WORLD_WRITABLE = 16, + CFTYPE_DEBUG = 32, + __CFTYPE_ONLY_ON_DFL = 65536, + __CFTYPE_NOT_ON_DFL = 131072, }; -typedef __kernel_clock_t clock_t; +typedef int (*cpu_stop_fn_t)(void *); -struct dentry_stat_t { - long int nr_dentry; - long int nr_unused; - long int age_limit; - long int want_pages; - long int nr_negative; - long int dummy; -}; +struct cpu_stop_done; -struct files_stat_struct { - long unsigned int nr_files; - long unsigned int nr_free_files; - long unsigned int max_files; +struct cpu_stop_work { + struct list_head list; + cpu_stop_fn_t fn; + void *arg; + struct cpu_stop_done *done; }; -struct inodes_stat_t { - long int nr_inodes; - long int nr_unused; - long int dummy[5]; +struct cpudl_item { + u64 dl; + int cpu; + int idx; }; -enum sysctl_writes_mode { - SYSCTL_WRITES_LEGACY = 4294967295, - SYSCTL_WRITES_WARN = 0, - SYSCTL_WRITES_STRICT = 1, +struct rt_prio_array { + long unsigned int bitmap[2]; + struct list_head queue[100]; }; -struct do_proc_dointvec_minmax_conv_param { - int *min; - int *max; +struct rt_bandwidth { + raw_spinlock_t rt_runtime_lock; + ktime_t rt_period; + u64 rt_runtime; + struct hrtimer rt_period_timer; + unsigned int rt_period_active; }; -struct do_proc_douintvec_minmax_conv_param { - unsigned int *min; - unsigned int *max; +struct dl_bandwidth { + raw_spinlock_t dl_runtime_lock; + u64 dl_runtime; + u64 dl_period; }; -struct __sysctl_args { - int *name; - int nlen; - void *oldval; - size_t *oldlenp; - void *newval; - size_t newlen; - long unsigned int __unused[4]; -}; +typedef int (*tg_visitor)(struct task_group *, void *); -enum { - CTL_KERN = 1, - CTL_VM = 2, - CTL_NET = 3, - CTL_PROC = 4, - CTL_FS = 5, - CTL_DEBUG = 6, - CTL_DEV = 7, - CTL_BUS = 8, - CTL_ABI = 9, - CTL_CPU = 10, - CTL_ARLAN = 254, - CTL_S390DBF = 5677, - CTL_SUNRPC = 7249, - CTL_PM = 9899, - CTL_FRV = 9898, +struct rt_rq { + struct rt_prio_array active; + unsigned int rt_nr_running; + unsigned int rr_nr_running; + struct { + int curr; + int next; + } highest_prio; + long unsigned int rt_nr_migratory; + long unsigned int rt_nr_total; + int overloaded; + struct plist_head pushable_tasks; + int rt_queued; + int rt_throttled; + u64 rt_time; + u64 rt_runtime; + raw_spinlock_t rt_runtime_lock; }; -enum { - KERN_OSTYPE = 1, - KERN_OSRELEASE = 2, - KERN_OSREV = 3, - KERN_VERSION = 4, - KERN_SECUREMASK = 5, - KERN_PROF = 6, - KERN_NODENAME = 7, - KERN_DOMAINNAME = 8, - KERN_PANIC = 15, - KERN_REALROOTDEV = 16, - KERN_SPARC_REBOOT = 21, - KERN_CTLALTDEL = 22, - KERN_PRINTK = 23, - KERN_NAMETRANS = 24, - KERN_PPC_HTABRECLAIM = 25, - KERN_PPC_ZEROPAGED = 26, - KERN_PPC_POWERSAVE_NAP = 27, - KERN_MODPROBE = 28, - KERN_SG_BIG_BUFF = 29, - KERN_ACCT = 30, - KERN_PPC_L2CR = 31, - KERN_RTSIGNR = 32, - KERN_RTSIGMAX = 33, - KERN_SHMMAX = 34, - KERN_MSGMAX = 35, - KERN_MSGMNB = 36, - KERN_MSGPOOL = 37, - KERN_SYSRQ = 38, - KERN_MAX_THREADS = 39, - KERN_RANDOM = 40, - KERN_SHMALL = 41, - KERN_MSGMNI = 42, - KERN_SEM = 43, - KERN_SPARC_STOP_A = 44, - KERN_SHMMNI = 45, - KERN_OVERFLOWUID = 46, - KERN_OVERFLOWGID = 47, - KERN_SHMPATH = 48, - KERN_HOTPLUG = 49, - KERN_IEEE_EMULATION_WARNINGS = 50, - KERN_S390_USER_DEBUG_LOGGING = 51, - KERN_CORE_USES_PID = 52, - KERN_TAINTED = 53, - KERN_CADPID = 54, - KERN_PIDMAX = 55, - KERN_CORE_PATTERN = 56, - KERN_PANIC_ON_OOPS = 57, - KERN_HPPA_PWRSW = 58, - KERN_HPPA_UNALIGNED = 59, - KERN_PRINTK_RATELIMIT = 60, - KERN_PRINTK_RATELIMIT_BURST = 61, - KERN_PTY = 62, - KERN_NGROUPS_MAX = 63, - KERN_SPARC_SCONS_PWROFF = 64, - KERN_HZ_TIMER = 65, - KERN_UNKNOWN_NMI_PANIC = 66, - KERN_BOOTLOADER_TYPE = 67, - KERN_RANDOMIZE = 68, - KERN_SETUID_DUMPABLE = 69, - KERN_SPIN_RETRY = 70, - KERN_ACPI_VIDEO_FLAGS = 71, - KERN_IA64_UNALIGNED = 72, - KERN_COMPAT_LOG = 73, - KERN_MAX_LOCK_DEPTH = 74, - KERN_NMI_WATCHDOG = 75, - KERN_PANIC_ON_NMI = 76, - KERN_PANIC_ON_WARN = 77, - KERN_PANIC_PRINT = 78, +struct dl_rq { + struct rb_root_cached root; + long unsigned int dl_nr_running; + struct { + u64 curr; + u64 next; + } earliest_dl; + long unsigned int dl_nr_migratory; + int overloaded; + struct rb_root_cached pushable_dl_tasks_root; + u64 running_bw; + u64 this_bw; + u64 extra_bw; + u64 bw_ratio; }; -enum ethtool_link_mode_bit_indices { - ETHTOOL_LINK_MODE_10baseT_Half_BIT = 0, - ETHTOOL_LINK_MODE_10baseT_Full_BIT = 1, - ETHTOOL_LINK_MODE_100baseT_Half_BIT = 2, - ETHTOOL_LINK_MODE_100baseT_Full_BIT = 3, - ETHTOOL_LINK_MODE_1000baseT_Half_BIT = 4, - ETHTOOL_LINK_MODE_1000baseT_Full_BIT = 5, - ETHTOOL_LINK_MODE_Autoneg_BIT = 6, - ETHTOOL_LINK_MODE_TP_BIT = 7, - ETHTOOL_LINK_MODE_AUI_BIT = 8, - ETHTOOL_LINK_MODE_MII_BIT = 9, - ETHTOOL_LINK_MODE_FIBRE_BIT = 10, - ETHTOOL_LINK_MODE_BNC_BIT = 11, - ETHTOOL_LINK_MODE_10000baseT_Full_BIT = 12, - ETHTOOL_LINK_MODE_Pause_BIT = 13, - ETHTOOL_LINK_MODE_Asym_Pause_BIT = 14, - ETHTOOL_LINK_MODE_2500baseX_Full_BIT = 15, - ETHTOOL_LINK_MODE_Backplane_BIT = 16, - ETHTOOL_LINK_MODE_1000baseKX_Full_BIT = 17, - ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT = 18, - ETHTOOL_LINK_MODE_10000baseKR_Full_BIT = 19, - ETHTOOL_LINK_MODE_10000baseR_FEC_BIT = 20, - ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT = 21, - ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT = 22, - ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT = 23, - ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT = 24, - ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT = 25, - ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT = 26, - ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT = 27, - ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT = 28, - ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT = 29, - ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT = 30, - ETHTOOL_LINK_MODE_25000baseCR_Full_BIT = 31, - ETHTOOL_LINK_MODE_25000baseKR_Full_BIT = 32, - ETHTOOL_LINK_MODE_25000baseSR_Full_BIT = 33, - ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT = 34, - ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT = 35, - ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT = 36, - ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT = 37, - ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT = 38, - ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT = 39, - ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT = 40, - ETHTOOL_LINK_MODE_1000baseX_Full_BIT = 41, - ETHTOOL_LINK_MODE_10000baseCR_Full_BIT = 42, - ETHTOOL_LINK_MODE_10000baseSR_Full_BIT = 43, - ETHTOOL_LINK_MODE_10000baseLR_Full_BIT = 44, - ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT = 45, - ETHTOOL_LINK_MODE_10000baseER_Full_BIT = 46, - ETHTOOL_LINK_MODE_2500baseT_Full_BIT = 47, - ETHTOOL_LINK_MODE_5000baseT_Full_BIT = 48, - ETHTOOL_LINK_MODE_FEC_NONE_BIT = 49, - ETHTOOL_LINK_MODE_FEC_RS_BIT = 50, - ETHTOOL_LINK_MODE_FEC_BASER_BIT = 51, - ETHTOOL_LINK_MODE_50000baseKR_Full_BIT = 52, - ETHTOOL_LINK_MODE_50000baseSR_Full_BIT = 53, - ETHTOOL_LINK_MODE_50000baseCR_Full_BIT = 54, - ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT = 55, - ETHTOOL_LINK_MODE_50000baseDR_Full_BIT = 56, - ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT = 57, - ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT = 58, - ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT = 59, - ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT = 60, - ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT = 61, - ETHTOOL_LINK_MODE_200000baseKR4_Full_BIT = 62, - ETHTOOL_LINK_MODE_200000baseSR4_Full_BIT = 63, - ETHTOOL_LINK_MODE_200000baseLR4_ER4_FR4_Full_BIT = 64, - ETHTOOL_LINK_MODE_200000baseDR4_Full_BIT = 65, - ETHTOOL_LINK_MODE_200000baseCR4_Full_BIT = 66, - ETHTOOL_LINK_MODE_100baseT1_Full_BIT = 67, - ETHTOOL_LINK_MODE_1000baseT1_Full_BIT = 68, - ETHTOOL_LINK_MODE_400000baseKR8_Full_BIT = 69, - ETHTOOL_LINK_MODE_400000baseSR8_Full_BIT = 70, - ETHTOOL_LINK_MODE_400000baseLR8_ER8_FR8_Full_BIT = 71, - ETHTOOL_LINK_MODE_400000baseDR8_Full_BIT = 72, - ETHTOOL_LINK_MODE_400000baseCR8_Full_BIT = 73, - __ETHTOOL_LINK_MODE_MASK_NBITS = 74, +struct rq { + raw_spinlock_t lock; + unsigned int nr_running; + long unsigned int last_load_update_tick; + long unsigned int last_blocked_load_update_tick; + unsigned int has_blocked_load; + unsigned int nohz_tick_stopped; + atomic_t nohz_flags; + long unsigned int nr_load_updates; + u64 nr_switches; + long: 64; + struct cfs_rq cfs; + struct rt_rq rt; + struct dl_rq dl; + struct list_head leaf_cfs_rq_list; + struct list_head *tmp_alone_branch; + long unsigned int nr_uninterruptible; + struct task_struct *curr; + struct task_struct *idle; + struct task_struct *stop; + long unsigned int next_balance; + struct mm_struct *prev_mm; + unsigned int clock_update_flags; + u64 clock; + long: 64; + long: 64; + long: 64; + u64 clock_task; + u64 clock_pelt; + long unsigned int lost_idle_time; + atomic_t nr_iowait; + int membarrier_state; + struct root_domain___2 *rd; + struct sched_domain *sd; + long unsigned int cpu_capacity; + long unsigned int cpu_capacity_orig; + struct callback_head *balance_callback; + unsigned char idle_balance; + long unsigned int misfit_task_load; + int active_balance; + int push_cpu; + struct cpu_stop_work active_balance_work; + int cpu; + int online; + struct list_head cfs_tasks; + long: 64; + long: 64; + long: 64; + long: 64; + struct sched_avg avg_rt; + struct sched_avg avg_dl; + u64 idle_stamp; + u64 avg_idle; + u64 max_idle_balance_cost; + long unsigned int calc_load_update; + long int calc_load_active; + int hrtick_csd_pending; + long: 32; + long: 64; + long: 64; + call_single_data_t hrtick_csd; + struct hrtimer hrtick_timer; + struct sched_info rq_sched_info; + long long unsigned int rq_cpu_time; + unsigned int yld_count; + unsigned int sched_count; + unsigned int sched_goidle; + unsigned int ttwu_count; + unsigned int ttwu_local; + struct llist_head wake_list; + struct cpuidle_state *idle_state; + long: 64; + long: 64; }; -enum { - NAPI_STATE_SCHED = 0, - NAPI_STATE_MISSED = 1, - NAPI_STATE_DISABLE = 2, - NAPI_STATE_NPSVC = 3, - NAPI_STATE_HASHED = 4, - NAPI_STATE_NO_BUSY_POLL = 5, - NAPI_STATE_IN_BUSY_POLL = 6, +struct perf_domain { + struct em_perf_domain *em_pd; + struct perf_domain *next; + struct callback_head rcu; }; -struct compat_sysctl_args { - compat_uptr_t name; - int nlen; - compat_uptr_t oldval; - compat_uptr_t oldlenp; - compat_uptr_t newval; - compat_size_t newlen; - compat_ulong_t __unused[4]; +struct rq_flags { + long unsigned int flags; + struct pin_cookie cookie; }; -struct __user_cap_header_struct { - __u32 version; - int pid; +enum numa_topology_type { + NUMA_DIRECT = 0, + NUMA_GLUELESS_MESH = 1, + NUMA_BACKPLANE = 2, }; -typedef struct __user_cap_header_struct *cap_user_header_t; - -struct __user_cap_data_struct { - __u32 effective; - __u32 permitted; - __u32 inheritable; +enum { + __SCHED_FEAT_GENTLE_FAIR_SLEEPERS = 0, + __SCHED_FEAT_START_DEBIT = 1, + __SCHED_FEAT_NEXT_BUDDY = 2, + __SCHED_FEAT_LAST_BUDDY = 3, + __SCHED_FEAT_CACHE_HOT_BUDDY = 4, + __SCHED_FEAT_WAKEUP_PREEMPTION = 5, + __SCHED_FEAT_HRTICK = 6, + __SCHED_FEAT_DOUBLE_TICK = 7, + __SCHED_FEAT_NONTASK_CAPACITY = 8, + __SCHED_FEAT_TTWU_QUEUE = 9, + __SCHED_FEAT_SIS_AVG_CPU = 10, + __SCHED_FEAT_SIS_PROP = 11, + __SCHED_FEAT_WARN_DOUBLE_CLOCK = 12, + __SCHED_FEAT_RT_PUSH_IPI = 13, + __SCHED_FEAT_RT_RUNTIME_SHARE = 14, + __SCHED_FEAT_LB_MIN = 15, + __SCHED_FEAT_ATTACH_AGE_LOAD = 16, + __SCHED_FEAT_WA_IDLE = 17, + __SCHED_FEAT_WA_WEIGHT = 18, + __SCHED_FEAT_WA_BIAS = 19, + __SCHED_FEAT_UTIL_EST = 20, + __SCHED_FEAT_UTIL_EST_FASTUP = 21, + __SCHED_FEAT_NR = 22, }; -typedef struct __user_cap_data_struct *cap_user_data_t; - -struct sigqueue { - struct list_head list; - int flags; - kernel_siginfo_t info; - struct user_struct *user; +struct trace_event_raw_sched_kthread_stop { + struct trace_entry ent; + char comm[16]; + pid_t pid; + char __data[0]; }; -struct wait_bit_key { - void *flags; - int bit_nr; - long unsigned int timeout; +struct trace_event_raw_sched_kthread_stop_ret { + struct trace_entry ent; + int ret; + char __data[0]; }; -typedef int wait_bit_action_f(struct wait_bit_key *, int); - -struct ptrace_peeksiginfo_args { - __u64 off; - __u32 flags; - __s32 nr; +struct trace_event_raw_sched_wakeup_template { + struct trace_entry ent; + char comm[16]; + pid_t pid; + int prio; + int success; + int target_cpu; + char __data[0]; }; -struct ptrace_syscall_info { - __u8 op; - __u32 arch; - __u64 instruction_pointer; - __u64 stack_pointer; - union { - struct { - __u64 nr; - __u64 args[6]; - } entry; - struct { - __s64 rval; - __u8 is_error; - } exit; - struct { - __u64 nr; - __u64 args[6]; - __u32 ret_data; - } seccomp; - }; +struct trace_event_raw_sched_switch { + struct trace_entry ent; + char prev_comm[16]; + pid_t prev_pid; + int prev_prio; + long int prev_state; + char next_comm[16]; + pid_t next_pid; + int next_prio; + char __data[0]; }; -struct compat_iovec { - compat_uptr_t iov_base; - compat_size_t iov_len; +struct trace_event_raw_sched_migrate_task { + struct trace_entry ent; + char comm[16]; + pid_t pid; + int prio; + int orig_cpu; + int dest_cpu; + char __data[0]; }; -typedef long unsigned int old_sigset_t; - -enum siginfo_layout { - SIL_KILL = 0, - SIL_TIMER = 1, - SIL_POLL = 2, - SIL_FAULT = 3, - SIL_FAULT_MCEERR = 4, - SIL_FAULT_BNDERR = 5, - SIL_FAULT_PKUERR = 6, - SIL_CHLD = 7, - SIL_RT = 8, - SIL_SYS = 9, +struct trace_event_raw_sched_process_template { + struct trace_entry ent; + char comm[16]; + pid_t pid; + int prio; + char __data[0]; }; -typedef u32 compat_old_sigset_t; - -struct compat_sigaction { - compat_uptr_t sa_handler; - compat_ulong_t sa_flags; - compat_uptr_t sa_restorer; - compat_sigset_t sa_mask; +struct trace_event_raw_sched_process_wait { + struct trace_entry ent; + char comm[16]; + pid_t pid; + int prio; + char __data[0]; }; -struct compat_old_sigaction { - compat_uptr_t sa_handler; - compat_old_sigset_t sa_mask; - compat_ulong_t sa_flags; - compat_uptr_t sa_restorer; +struct trace_event_raw_sched_process_fork { + struct trace_entry ent; + char parent_comm[16]; + pid_t parent_pid; + char child_comm[16]; + pid_t child_pid; + char __data[0]; }; -enum { - TRACE_SIGNAL_DELIVERED = 0, - TRACE_SIGNAL_IGNORED = 1, - TRACE_SIGNAL_ALREADY_PENDING = 2, - TRACE_SIGNAL_OVERFLOW_FAIL = 3, - TRACE_SIGNAL_LOSE_INFO = 4, +struct trace_event_raw_sched_process_exec { + struct trace_entry ent; + u32 __data_loc_filename; + pid_t pid; + pid_t old_pid; + char __data[0]; }; -struct trace_event_raw_signal_generate { +struct trace_event_raw_sched_stat_template { struct trace_entry ent; - int sig; - int errno; - int code; char comm[16]; pid_t pid; - int group; - int result; + u64 delay; char __data[0]; }; -struct trace_event_raw_signal_deliver { +struct trace_event_raw_sched_stat_runtime { struct trace_entry ent; - int sig; - int errno; - int code; - long unsigned int sa_handler; - long unsigned int sa_flags; + char comm[16]; + pid_t pid; + u64 runtime; + u64 vruntime; char __data[0]; }; -struct trace_event_data_offsets_signal_generate {}; - -struct trace_event_data_offsets_signal_deliver {}; - -struct sysinfo { - __kernel_long_t uptime; - __kernel_ulong_t loads[3]; - __kernel_ulong_t totalram; - __kernel_ulong_t freeram; - __kernel_ulong_t sharedram; - __kernel_ulong_t bufferram; - __kernel_ulong_t totalswap; - __kernel_ulong_t freeswap; - __u16 procs; - __u16 pad; - __kernel_ulong_t totalhigh; - __kernel_ulong_t freehigh; - __u32 mem_unit; - char _f[0]; +struct trace_event_raw_sched_pi_setprio { + struct trace_entry ent; + char comm[16]; + pid_t pid; + int oldprio; + int newprio; + char __data[0]; }; -enum { - PER_LINUX = 0, - PER_LINUX_32BIT = 8388608, - PER_LINUX_FDPIC = 524288, - PER_SVR4 = 68157441, - PER_SVR3 = 83886082, - PER_SCOSVR3 = 117440515, - PER_OSR5 = 100663299, - PER_WYSEV386 = 83886084, - PER_ISCR4 = 67108869, - PER_BSD = 6, - PER_SUNOS = 67108870, - PER_XENIX = 83886087, - PER_LINUX32 = 8, - PER_LINUX32_3GB = 134217736, - PER_IRIX32 = 67108873, - PER_IRIXN32 = 67108874, - PER_IRIX64 = 67108875, - PER_RISCOS = 12, - PER_SOLARIS = 67108877, - PER_UW7 = 68157454, - PER_OSF4 = 15, - PER_HPUX = 16, - PER_MASK = 255, +struct trace_event_raw_sched_move_task_template { + struct trace_entry ent; + pid_t pid; + pid_t tgid; + pid_t ngid; + int src_cpu; + int src_nid; + int dst_cpu; + int dst_nid; + char __data[0]; }; -struct rlimit64 { - __u64 rlim_cur; - __u64 rlim_max; +struct trace_event_raw_sched_swap_numa { + struct trace_entry ent; + pid_t src_pid; + pid_t src_tgid; + pid_t src_ngid; + int src_cpu; + int src_nid; + pid_t dst_pid; + pid_t dst_tgid; + pid_t dst_ngid; + int dst_cpu; + int dst_nid; + char __data[0]; }; -struct oldold_utsname { - char sysname[9]; - char nodename[9]; - char release[9]; - char version[9]; - char machine[9]; +struct trace_event_raw_sched_wake_idle_without_ipi { + struct trace_entry ent; + int cpu; + char __data[0]; }; -struct old_utsname { - char sysname[65]; - char nodename[65]; - char release[65]; - char version[65]; - char machine[65]; -}; +struct trace_event_data_offsets_sched_kthread_stop {}; -enum uts_proc { - UTS_PROC_OSTYPE = 0, - UTS_PROC_OSRELEASE = 1, - UTS_PROC_VERSION = 2, - UTS_PROC_HOSTNAME = 3, - UTS_PROC_DOMAINNAME = 4, -}; +struct trace_event_data_offsets_sched_kthread_stop_ret {}; -struct prctl_mm_map { - __u64 start_code; - __u64 end_code; - __u64 start_data; - __u64 end_data; - __u64 start_brk; - __u64 brk; - __u64 start_stack; - __u64 arg_start; - __u64 arg_end; - __u64 env_start; - __u64 env_end; - __u64 *auxv; - __u32 auxv_size; - __u32 exe_fd; -}; +struct trace_event_data_offsets_sched_wakeup_template {}; -struct tms { - __kernel_clock_t tms_utime; - __kernel_clock_t tms_stime; - __kernel_clock_t tms_cutime; - __kernel_clock_t tms_cstime; -}; +struct trace_event_data_offsets_sched_switch {}; -struct getcpu_cache { - long unsigned int blob[16]; -}; +struct trace_event_data_offsets_sched_migrate_task {}; -struct compat_tms { - compat_clock_t tms_utime; - compat_clock_t tms_stime; - compat_clock_t tms_cutime; - compat_clock_t tms_cstime; -}; +struct trace_event_data_offsets_sched_process_template {}; -struct compat_rlimit { - compat_ulong_t rlim_cur; - compat_ulong_t rlim_max; -}; +struct trace_event_data_offsets_sched_process_wait {}; -struct compat_sysinfo { - s32 uptime; - u32 loads[3]; - u32 totalram; - u32 freeram; - u32 sharedram; - u32 bufferram; - u32 totalswap; - u32 freeswap; - u16 procs; - u16 pad; - u32 totalhigh; - u32 freehigh; - u32 mem_unit; - char _f[8]; -}; +struct trace_event_data_offsets_sched_process_fork {}; -struct subprocess_info { - struct work_struct work; - struct completion *complete; - const char *path; - char **argv; - char **envp; - struct file *file; - int wait; - int retval; - pid_t pid; - int (*init)(struct subprocess_info *, struct cred *); - void (*cleanup)(struct subprocess_info *); - void *data; +struct trace_event_data_offsets_sched_process_exec { + u32 filename; }; -struct umh_info { - const char *cmdline; - struct file *pipe_to_umh; - struct file *pipe_from_umh; - struct list_head list; - void (*cleanup)(struct umh_info *); - pid_t pid; -}; +struct trace_event_data_offsets_sched_stat_template {}; -struct wq_flusher; +struct trace_event_data_offsets_sched_stat_runtime {}; -struct worker; +struct trace_event_data_offsets_sched_pi_setprio {}; -struct workqueue_attrs; +struct trace_event_data_offsets_sched_move_task_template {}; -struct pool_workqueue; +struct trace_event_data_offsets_sched_swap_numa {}; -struct wq_device; +struct trace_event_data_offsets_sched_wake_idle_without_ipi {}; -struct workqueue_struct { - struct list_head pwqs; - struct list_head list; - struct mutex mutex; - int work_color; - int flush_color; - atomic_t nr_pwqs_to_flush; - struct wq_flusher *first_flusher; - struct list_head flusher_queue; - struct list_head flusher_overflow; - struct list_head maydays; - struct worker *rescuer; - int nr_drainers; - int saved_max_active; - struct workqueue_attrs *unbound_attrs; - struct pool_workqueue *dfl_pwq; - struct wq_device *wq_dev; - char name[24]; - struct callback_head rcu; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - unsigned int flags; - struct pool_workqueue *cpu_pwqs; - struct pool_workqueue *numa_pwq_tbl[0]; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; -}; +typedef void (*btf_trace_sched_kthread_stop)(void *, struct task_struct *); -struct workqueue_attrs { - int nice; - cpumask_var_t cpumask; - bool no_numa; -}; +typedef void (*btf_trace_sched_kthread_stop_ret)(void *, int); -struct execute_work { - struct work_struct work; +typedef void (*btf_trace_sched_waking)(void *, struct task_struct *); + +typedef void (*btf_trace_sched_wakeup)(void *, struct task_struct *); + +typedef void (*btf_trace_sched_wakeup_new)(void *, struct task_struct *); + +typedef void (*btf_trace_sched_switch)(void *, bool, struct task_struct *, struct task_struct *); + +typedef void (*btf_trace_sched_migrate_task)(void *, struct task_struct *, int); + +typedef void (*btf_trace_sched_process_free)(void *, struct task_struct *); + +typedef void (*btf_trace_sched_process_exit)(void *, struct task_struct *); + +typedef void (*btf_trace_sched_wait_task)(void *, struct task_struct *); + +typedef void (*btf_trace_sched_process_wait)(void *, struct pid *); + +typedef void (*btf_trace_sched_process_fork)(void *, struct task_struct *, struct task_struct *); + +typedef void (*btf_trace_sched_process_exec)(void *, struct task_struct *, pid_t, struct linux_binprm *); + +typedef void (*btf_trace_sched_stat_wait)(void *, struct task_struct *, u64); + +typedef void (*btf_trace_sched_stat_sleep)(void *, struct task_struct *, u64); + +typedef void (*btf_trace_sched_stat_iowait)(void *, struct task_struct *, u64); + +typedef void (*btf_trace_sched_stat_blocked)(void *, struct task_struct *, u64); + +typedef void (*btf_trace_sched_stat_runtime)(void *, struct task_struct *, u64, u64); + +typedef void (*btf_trace_sched_pi_setprio)(void *, struct task_struct *, struct task_struct *); + +typedef void (*btf_trace_sched_move_numa)(void *, struct task_struct *, int, int); + +typedef void (*btf_trace_sched_stick_numa)(void *, struct task_struct *, int, int); + +typedef void (*btf_trace_sched_swap_numa)(void *, struct task_struct *, int, struct task_struct *, int); + +typedef void (*btf_trace_sched_wake_idle_without_ipi)(void *, int); + +struct migration_arg { + struct task_struct *task; + int dest_cpu; }; enum { - WQ_UNBOUND = 2, - WQ_FREEZABLE = 4, - WQ_MEM_RECLAIM = 8, - WQ_HIGHPRI = 16, - WQ_CPU_INTENSIVE = 32, - WQ_SYSFS = 64, - WQ_POWER_EFFICIENT = 128, - __WQ_DRAINING = 65536, - __WQ_ORDERED = 131072, - __WQ_LEGACY = 262144, - __WQ_ORDERED_EXPLICIT = 524288, - WQ_MAX_ACTIVE = 512, - WQ_MAX_UNBOUND_PER_CPU = 4, - WQ_DFL_ACTIVE = 256, + cpuset = 0, + possible = 1, + fail = 2, }; -typedef unsigned int xa_mark_t; - -enum xa_lock_type { - XA_LOCK_IRQ = 1, - XA_LOCK_BH = 2, +enum tick_dep_bits { + TICK_DEP_BIT_POSIX_TIMER = 0, + TICK_DEP_BIT_PERF_EVENTS = 1, + TICK_DEP_BIT_SCHED = 2, + TICK_DEP_BIT_CLOCK_UNSTABLE = 3, + TICK_DEP_BIT_RCU = 4, }; -struct ida { - struct xarray xa; +struct sched_clock_data { + u64 tick_raw; + u64 tick_gtod; + u64 clock; }; -struct __una_u32 { - u32 x; +typedef u64 pao_T_____5; + +struct idle_timer { + struct hrtimer timer; + int done; }; -struct worker_pool; +enum schedutil_type { + FREQUENCY_UTIL = 0, + ENERGY_UTIL = 1, +}; -struct worker { - union { - struct list_head entry; - struct hlist_node hentry; - }; - struct work_struct *current_work; - work_func_t current_func; - struct pool_workqueue *current_pwq; - struct list_head scheduled; - struct task_struct *task; - struct worker_pool *pool; - struct list_head node; - long unsigned int last_active; - unsigned int flags; - int id; - int sleeping; - char desc[24]; - struct workqueue_struct *rescue_wq; - work_func_t last_func; +enum fbq_type { + regular = 0, + remote = 1, + all = 2, }; -struct pool_workqueue { - struct worker_pool *pool; - struct workqueue_struct *wq; - int work_color; - int flush_color; - int refcnt; - int nr_in_flight[15]; - int nr_active; - int max_active; - struct list_head delayed_works; - struct list_head pwqs_node; - struct list_head mayday_node; - struct work_struct unbound_release_work; - struct callback_head rcu; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +enum group_type { + group_has_spare = 0, + group_fully_busy = 1, + group_misfit_task = 2, + group_asym_packing = 3, + group_imbalanced = 4, + group_overloaded = 5, }; -struct worker_pool { - spinlock_t lock; - int cpu; - int node; - int id; - unsigned int flags; - long unsigned int watchdog_ts; - struct list_head worklist; - int nr_workers; - int nr_idle; - struct list_head idle_list; - struct timer_list idle_timer; - struct timer_list mayday_timer; - struct hlist_head busy_hash[64]; - struct worker *manager; - struct list_head workers; - struct completion *detach_completion; - struct ida worker_ida; - struct workqueue_attrs *attrs; - struct hlist_node hash_node; - int refcnt; - long: 32; - long: 64; - long: 64; - long: 64; - atomic_t nr_running; - struct callback_head rcu; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +enum migration_type { + migrate_load = 0, + migrate_util = 1, + migrate_task = 2, + migrate_misfit = 3, }; -enum { - POOL_MANAGER_ACTIVE = 1, - POOL_DISASSOCIATED = 4, - WORKER_DIE = 2, - WORKER_IDLE = 4, - WORKER_PREP = 8, - WORKER_CPU_INTENSIVE = 64, - WORKER_UNBOUND = 128, - WORKER_REBOUND = 256, - WORKER_NOT_RUNNING = 456, - NR_STD_WORKER_POOLS = 2, - UNBOUND_POOL_HASH_ORDER = 6, - BUSY_WORKER_HASH_ORDER = 6, - MAX_IDLE_WORKERS_RATIO = 4, - IDLE_WORKER_TIMEOUT = 300000, - MAYDAY_INITIAL_TIMEOUT = 10, - MAYDAY_INTERVAL = 100, - CREATE_COOLDOWN = 1000, - RESCUER_NICE_LEVEL = 4294967276, - HIGHPRI_NICE_LEVEL = 4294967276, - WQ_NAME_LEN = 24, +struct lb_env { + struct sched_domain *sd; + struct rq *src_rq; + int src_cpu; + int dst_cpu; + struct rq *dst_rq; + struct cpumask *dst_grpmask; + int new_dst_cpu; + enum cpu_idle_type idle; + long int imbalance; + struct cpumask *cpus; + unsigned int flags; + unsigned int loop; + unsigned int loop_break; + unsigned int loop_max; + enum fbq_type fbq_type; + enum migration_type migration_type; + struct list_head tasks; }; -struct wq_flusher { - struct list_head list; - int flush_color; - struct completion done; +struct sg_lb_stats { + long unsigned int avg_load; + long unsigned int group_load; + long unsigned int group_capacity; + long unsigned int group_util; + unsigned int sum_nr_running; + unsigned int sum_h_nr_running; + unsigned int idle_cpus; + unsigned int group_weight; + enum group_type group_type; + unsigned int group_asym_packing; + long unsigned int group_misfit_task_load; }; -struct wq_device { - struct workqueue_struct *wq; - struct device dev; +struct sd_lb_stats { + struct sched_group *busiest; + struct sched_group *local; + long unsigned int total_load; + long unsigned int total_capacity; + long unsigned int avg_load; + unsigned int prefer_sibling; + struct sg_lb_stats busiest_stat; + struct sg_lb_stats local_stat; }; -struct trace_event_raw_workqueue_work { - struct trace_entry ent; - void *work; - char __data[0]; -}; +typedef struct rt_rq *rt_rq_iter_t; -struct trace_event_raw_workqueue_queue_work { - struct trace_entry ent; - void *work; - void *function; - void *workqueue; - unsigned int req_cpu; - unsigned int cpu; - char __data[0]; +struct wait_bit_key { + void *flags; + int bit_nr; + long unsigned int timeout; }; -struct trace_event_raw_workqueue_execute_start { - struct trace_entry ent; - void *work; - void *function; - char __data[0]; +struct wait_bit_queue_entry { + struct wait_bit_key key; + struct wait_queue_entry wq_entry; }; -struct trace_event_data_offsets_workqueue_work {}; - -struct trace_event_data_offsets_workqueue_queue_work {}; +typedef int wait_bit_action_f(struct wait_bit_key *, int); -struct trace_event_data_offsets_workqueue_execute_start {}; +struct swait_queue_head { + raw_spinlock_t lock; + struct list_head task_list; +}; -struct wq_barrier { - struct work_struct work; - struct completion done; +struct swait_queue { struct task_struct *task; + struct list_head task_list; }; -struct cwt_wait { - wait_queue_entry_t wait; - struct work_struct *work; +struct sched_domain_attr { + int relax_domain_level; }; -struct apply_wqattrs_ctx { - struct workqueue_struct *wq; - struct workqueue_attrs *attrs; - struct list_head list; - struct pool_workqueue *dfl_pwq; - struct pool_workqueue *pwq_tbl[0]; +struct s_data { + struct sched_domain **sd; + struct root_domain___2 *rd; }; -struct work_for_cpu { - struct work_struct work; - long int (*fn)(void *); - void *arg; - long int ret; +enum s_alloc { + sa_rootdomain = 0, + sa_sd = 1, + sa_sd_storage = 2, + sa_none = 3, }; -typedef void (*task_work_func_t)(struct callback_head *); - -enum { - KERNEL_PARAM_OPS_FL_NOARG = 1, +enum cpuacct_stat_index { + CPUACCT_STAT_USER = 0, + CPUACCT_STAT_SYSTEM = 1, + CPUACCT_STAT_NSTATS = 2, }; -enum { - KERNEL_PARAM_FL_UNSAFE = 1, - KERNEL_PARAM_FL_HWPARAM = 2, +struct cpuacct_usage { + u64 usages[2]; }; -struct param_attribute { - struct module_attribute mattr; - const struct kernel_param *param; +struct cpuacct { + struct cgroup_subsys_state css; + struct cpuacct_usage *cpuusage; + struct kernel_cpustat *cpustat; }; -struct module_param_attrs { - unsigned int num; - struct attribute_group grp; - struct param_attribute attrs[0]; +enum { + MEMBARRIER_FLAG_SYNC_CORE = 1, }; -struct module_version_attribute { - struct module_attribute mattr; - const char *module_name; - const char *version; +enum membarrier_cmd { + MEMBARRIER_CMD_QUERY = 0, + MEMBARRIER_CMD_GLOBAL = 1, + MEMBARRIER_CMD_GLOBAL_EXPEDITED = 2, + MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED = 4, + MEMBARRIER_CMD_PRIVATE_EXPEDITED = 8, + MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED = 16, + MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE = 32, + MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE = 64, + MEMBARRIER_CMD_SHARED = 1, }; -struct kmalloced_param { +struct ww_acquire_ctx; + +struct mutex_waiter { struct list_head list; - char val[0]; + struct task_struct *task; + struct ww_acquire_ctx *ww_ctx; }; -struct sched_param { - int sched_priority; +struct ww_acquire_ctx { + struct task_struct *task; + long unsigned int stamp; + unsigned int acquired; + short unsigned int wounded; + short unsigned int is_wait_die; }; -struct kthread_work; - -typedef void (*kthread_work_func_t)(struct kthread_work *); - -struct kthread_worker; - -struct kthread_work { - struct list_head node; - kthread_work_func_t func; - struct kthread_worker *worker; - int canceling; +enum mutex_trylock_recursive_enum { + MUTEX_TRYLOCK_FAILED = 0, + MUTEX_TRYLOCK_SUCCESS = 1, + MUTEX_TRYLOCK_RECURSIVE = 2, }; -enum { - KTW_FREEZABLE = 1, +struct ww_mutex { + struct mutex base; + struct ww_acquire_ctx *ctx; }; -struct kthread_worker { - unsigned int flags; +struct semaphore { raw_spinlock_t lock; - struct list_head work_list; - struct list_head delayed_work_list; + unsigned int count; + struct list_head wait_list; +}; + +struct semaphore_waiter { + struct list_head list; struct task_struct *task; - struct kthread_work *current_work; + bool up; }; -struct kthread_delayed_work { - struct kthread_work work; - struct timer_list timer; +enum rwsem_waiter_type { + RWSEM_WAITING_FOR_WRITE = 0, + RWSEM_WAITING_FOR_READ = 1, }; -struct kthread_create_info { - int (*threadfn)(void *); - void *data; - int node; - struct task_struct *result; - struct completion *done; +struct rwsem_waiter { struct list_head list; + struct task_struct *task; + enum rwsem_waiter_type type; + long unsigned int timeout; + long unsigned int last_rowner; }; -struct kthread { - long unsigned int flags; - unsigned int cpu; - void *data; - struct completion parked; - struct completion exited; +enum rwsem_wake_type { + RWSEM_WAKE_ANY = 0, + RWSEM_WAKE_READERS = 1, + RWSEM_WAKE_READ_OWNED = 2, }; -enum KTHREAD_BITS { - KTHREAD_IS_PER_CPU = 0, - KTHREAD_SHOULD_STOP = 1, - KTHREAD_SHOULD_PARK = 2, +enum writer_wait_state { + WRITER_NOT_FIRST = 0, + WRITER_FIRST = 1, + WRITER_HANDOFF = 2, }; -struct kthread_flush_work { - struct kthread_work work; - struct completion done; +enum owner_state { + OWNER_NULL = 1, + OWNER_WRITER = 2, + OWNER_READER = 4, + OWNER_NONSPINNABLE = 8, }; -struct pt_regs___2; +struct optimistic_spin_node { + struct optimistic_spin_node *next; + struct optimistic_spin_node *prev; + int locked; + int cpu; +}; -struct ipc_ids { - int in_use; - short unsigned int seq; - struct rw_semaphore rwsem; - struct idr ipcs_idr; - int max_idx; - int last_idx; - struct rhashtable key_ht; +struct mcs_spinlock { + struct mcs_spinlock *next; + int locked; + int count; }; -struct ipc_namespace { - refcount_t count; - struct ipc_ids ids[3]; - int sem_ctls[4]; - int used_sems; - unsigned int msg_ctlmax; - unsigned int msg_ctlmnb; - unsigned int msg_ctlmni; - atomic_t msg_bytes; - atomic_t msg_hdrs; - size_t shm_ctlmax; - size_t shm_ctlall; - long unsigned int shm_tot; - int shm_ctlmni; - int shm_rmid_forced; - struct notifier_block ipcns_nb; - struct vfsmount *mq_mnt; - unsigned int mq_queues_count; - unsigned int mq_queues_max; - unsigned int mq_msg_max; - unsigned int mq_msgsize_max; - unsigned int mq_msg_default; - unsigned int mq_msgsize_default; - struct user_namespace *user_ns; - struct ucounts *ucounts; - struct ns_common ns; +struct qnode { + struct mcs_spinlock mcs; }; -struct srcu_notifier_head { - struct mutex mutex; - struct srcu_struct srcu; - struct notifier_block *head; +struct hrtimer_sleeper { + struct hrtimer timer; + struct task_struct *task; }; -enum what { - PROC_EVENT_NONE = 0, - PROC_EVENT_FORK = 1, - PROC_EVENT_EXEC = 2, - PROC_EVENT_UID = 4, - PROC_EVENT_GID = 64, - PROC_EVENT_SID = 128, - PROC_EVENT_PTRACE = 256, - PROC_EVENT_COMM = 512, - PROC_EVENT_COREDUMP = 1073741824, - PROC_EVENT_EXIT = 2147483648, +struct rt_mutex; + +struct rt_mutex_waiter { + struct rb_node tree_entry; + struct rb_node pi_tree_entry; + struct task_struct *task; + struct rt_mutex *lock; + int prio; + u64 deadline; }; -typedef u64 async_cookie_t; +struct rt_mutex { + raw_spinlock_t wait_lock; + struct rb_root_cached waiters; + struct task_struct *owner; +}; -typedef void (*async_func_t)(void *, async_cookie_t); +enum rtmutex_chainwalk { + RT_MUTEX_MIN_CHAINWALK = 0, + RT_MUTEX_FULL_CHAINWALK = 1, +}; -struct async_domain { - struct list_head pending; - unsigned int registered: 1; +enum pm_qos_req_action { + PM_QOS_ADD_REQ = 0, + PM_QOS_UPDATE_REQ = 1, + PM_QOS_REMOVE_REQ = 2, }; -struct async_entry { - struct list_head domain_list; - struct list_head global_list; - struct work_struct work; - async_cookie_t cookie; - async_func_t func; - void *data; - struct async_domain *domain; +struct miscdevice { + int minor; + const char *name; + const struct file_operations *fops; + struct list_head list; + struct device *parent; + struct device *this_device; + const struct attribute_group **groups; + const char *nodename; + umode_t mode; }; -struct smpboot_thread_data { - unsigned int cpu; - unsigned int status; - struct smp_hotplug_thread *ht; +struct pm_qos_object { + struct pm_qos_constraints *constraints; + struct miscdevice pm_qos_power_miscdev; + char *name; }; enum { - HP_THREAD_NONE = 0, - HP_THREAD_ACTIVE = 1, - HP_THREAD_PARKED = 2, + TEST_NONE = 0, + TEST_CORE = 1, + TEST_CPUS = 2, + TEST_PLATFORM = 3, + TEST_DEVICES = 4, + TEST_FREEZER = 5, + __TEST_AFTER_LAST = 6, }; -struct pin_cookie {}; +struct pm_vt_switch { + struct list_head head; + struct device *dev; + bool required; +}; -struct cfs_rq { - struct load_weight load; - long unsigned int runnable_weight; - unsigned int nr_running; - unsigned int h_nr_running; - unsigned int idle_h_nr_running; - u64 exec_clock; - u64 min_vruntime; - struct rb_root_cached tasks_timeline; - struct sched_entity *curr; - struct sched_entity *next; - struct sched_entity *last; - struct sched_entity *skip; +struct platform_suspend_ops { + int (*valid)(suspend_state_t); + int (*begin)(suspend_state_t); + int (*prepare)(); + int (*prepare_late)(); + int (*enter)(suspend_state_t); + void (*wake)(); + void (*finish)(); + bool (*suspend_again)(); + void (*end)(); + void (*recover)(); +}; + +struct platform_s2idle_ops { + int (*begin)(); + int (*prepare)(); + int (*prepare_late)(); + void (*wake)(); + void (*restore_early)(); + void (*restore)(); + void (*end)(); +}; + +struct platform_hibernation_ops { + int (*begin)(pm_message_t); + void (*end)(); + int (*pre_snapshot)(); + void (*finish)(); + int (*prepare)(); + int (*enter)(); + void (*leave)(); + int (*pre_restore)(); + void (*restore_cleanup)(); + void (*recover)(); +}; + +enum { + HIBERNATION_INVALID = 0, + HIBERNATION_PLATFORM = 1, + HIBERNATION_SHUTDOWN = 2, + HIBERNATION_REBOOT = 3, + HIBERNATION_SUSPEND = 4, + HIBERNATION_TEST_RESUME = 5, + __HIBERNATION_AFTER_LAST = 6, +}; + +struct swsusp_info { + struct new_utsname uts; + u32 version_code; + long unsigned int num_physpages; + int cpus; + long unsigned int image_pages; + long unsigned int pages; + long unsigned int size; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; long: 64; long: 64; long: 64; - struct sched_avg avg; - struct { - raw_spinlock_t lock; - int nr; - long unsigned int load_avg; - long unsigned int util_avg; - long unsigned int runnable_sum; - long: 64; - long: 64; - long: 64; - long: 64; - } removed; - long unsigned int tg_load_avg_contrib; - long int propagate; - long int prop_runnable_sum; - long unsigned int h_load; - u64 last_h_load_update; - struct sched_entity *h_load_next; - struct rq *rq; - int on_list; - struct list_head leaf_cfs_rq_list; - struct task_group *tg; long: 64; long: 64; long: 64; long: 64; long: 64; -}; - -struct cfs_bandwidth {}; - -struct task_group { - struct cgroup_subsys_state css; - struct sched_entity **se; - struct cfs_rq **cfs_rq; - long unsigned int shares; long: 64; long: 64; long: 64; @@ -24401,1341 +28702,1153 @@ struct task_group { long: 64; long: 64; long: 64; - atomic_long_t load_avg; - struct callback_head rcu; - struct list_head list; - struct task_group *parent; - struct list_head siblings; - struct list_head children; - struct cfs_bandwidth cfs_bandwidth; long: 64; long: 64; long: 64; long: 64; long: 64; long: 64; -}; - -struct update_util_data { - void (*func)(struct update_util_data *, u64, unsigned int); -}; - -enum { - MEMBARRIER_STATE_PRIVATE_EXPEDITED_READY = 1, - MEMBARRIER_STATE_PRIVATE_EXPEDITED = 2, - MEMBARRIER_STATE_GLOBAL_EXPEDITED_READY = 4, - MEMBARRIER_STATE_GLOBAL_EXPEDITED = 8, - MEMBARRIER_STATE_PRIVATE_EXPEDITED_SYNC_CORE_READY = 16, - MEMBARRIER_STATE_PRIVATE_EXPEDITED_SYNC_CORE = 32, -}; - -struct sched_domain_attr { - int relax_domain_level; -}; - -struct sched_group { - struct sched_group *next; - atomic_t ref; - unsigned int group_weight; - struct sched_group_capacity *sgc; - int asym_prefer_cpu; - long unsigned int cpumask[0]; -}; - -struct sched_group_capacity { - atomic_t ref; - long unsigned int capacity; - long unsigned int min_capacity; - long unsigned int max_capacity; - long unsigned int next_update; - int imbalance; - long unsigned int cpumask[0]; -}; - -struct wake_q_head { - struct wake_q_node *first; - struct wake_q_node **lastp; -}; - -struct sched_attr { - __u32 size; - __u32 sched_policy; - __u64 sched_flags; - __s32 sched_nice; - __u32 sched_priority; - __u64 sched_runtime; - __u64 sched_deadline; - __u64 sched_period; - __u32 sched_util_min; - __u32 sched_util_max; -}; - -struct cpuidle_driver; - -struct cpuidle_state { - char name[16]; - char desc[32]; - u64 exit_latency_ns; - u64 target_residency_ns; - unsigned int flags; - unsigned int exit_latency; - int power_usage; - unsigned int target_residency; - int (*enter)(struct cpuidle_device *, struct cpuidle_driver *, int); - int (*enter_dead)(struct cpuidle_device *, int); - void (*enter_s2idle)(struct cpuidle_device *, struct cpuidle_driver *, int); -}; - -struct cpuidle_driver { - const char *name; - struct module *owner; - int refcnt; - unsigned int bctimer: 1; - struct cpuidle_state states[10]; - int state_count; - int safe_state_index; - struct cpumask *cpumask; - const char *governor; -}; - -struct em_cap_state { - long unsigned int frequency; - long unsigned int power; - long unsigned int cost; -}; - -struct em_perf_domain { - struct em_cap_state *table; - int nr_cap_states; - long unsigned int cpus[0]; -}; - -enum { - CFTYPE_ONLY_ON_ROOT = 1, - CFTYPE_NOT_ON_ROOT = 2, - CFTYPE_NS_DELEGATABLE = 4, - CFTYPE_NO_PREFIX = 8, - CFTYPE_WORLD_WRITABLE = 16, - CFTYPE_DEBUG = 32, - __CFTYPE_ONLY_ON_DFL = 65536, - __CFTYPE_NOT_ON_DFL = 131072, -}; - -struct cpu_stop_done; - -struct cpu_stop_work { - struct list_head list; - cpu_stop_fn_t fn; - void *arg; - struct cpu_stop_done *done; -}; - -struct cpupri_vec { - atomic_t count; - cpumask_var_t mask; -}; - -struct cpupri { - struct cpupri_vec pri_to_cpu[102]; - int *cpu_to_pri; -}; - -struct cpudl_item { - u64 dl; - int cpu; - int idx; -}; - -struct cpudl { - raw_spinlock_t lock; - int size; - cpumask_var_t free_cpus; - struct cpudl_item *elements; -}; - -struct rt_prio_array { - long unsigned int bitmap[2]; - struct list_head queue[100]; -}; - -struct rt_bandwidth { - raw_spinlock_t rt_runtime_lock; - ktime_t rt_period; - u64 rt_runtime; - struct hrtimer rt_period_timer; - unsigned int rt_period_active; -}; - -struct dl_bandwidth { - raw_spinlock_t dl_runtime_lock; - u64 dl_runtime; - u64 dl_period; -}; - -struct dl_bw { - raw_spinlock_t lock; - u64 bw; - u64 total_bw; -}; - -typedef int (*tg_visitor)(struct task_group *, void *); - -struct rt_rq { - struct rt_prio_array active; - unsigned int rt_nr_running; - unsigned int rr_nr_running; - struct { - int curr; - int next; - } highest_prio; - long unsigned int rt_nr_migratory; - long unsigned int rt_nr_total; - int overloaded; - struct plist_head pushable_tasks; - int rt_queued; - int rt_throttled; - u64 rt_time; - u64 rt_runtime; - raw_spinlock_t rt_runtime_lock; -}; - -struct dl_rq { - struct rb_root_cached root; - long unsigned int dl_nr_running; - struct { - u64 curr; - u64 next; - } earliest_dl; - long unsigned int dl_nr_migratory; - int overloaded; - struct rb_root_cached pushable_dl_tasks_root; - u64 running_bw; - u64 this_bw; - u64 extra_bw; - u64 bw_ratio; -}; - -struct root_domain; - -struct rq { - raw_spinlock_t lock; - unsigned int nr_running; - long unsigned int last_load_update_tick; - long unsigned int last_blocked_load_update_tick; - unsigned int has_blocked_load; - unsigned int nohz_tick_stopped; - atomic_t nohz_flags; - long unsigned int nr_load_updates; - u64 nr_switches; long: 64; - struct cfs_rq cfs; - struct rt_rq rt; - struct dl_rq dl; - struct list_head leaf_cfs_rq_list; - struct list_head *tmp_alone_branch; - long unsigned int nr_uninterruptible; - struct task_struct *curr; - struct task_struct *idle; - struct task_struct *stop; - long unsigned int next_balance; - struct mm_struct *prev_mm; - unsigned int clock_update_flags; - u64 clock; long: 64; long: 64; long: 64; - u64 clock_task; - u64 clock_pelt; - long unsigned int lost_idle_time; - atomic_t nr_iowait; - int membarrier_state; - struct root_domain *rd; - struct sched_domain *sd; - long unsigned int cpu_capacity; - long unsigned int cpu_capacity_orig; - struct callback_head *balance_callback; - unsigned char idle_balance; - long unsigned int misfit_task_load; - int active_balance; - int push_cpu; - struct cpu_stop_work active_balance_work; - int cpu; - int online; - struct list_head cfs_tasks; long: 64; long: 64; long: 64; long: 64; - struct sched_avg avg_rt; - struct sched_avg avg_dl; - u64 idle_stamp; - u64 avg_idle; - u64 max_idle_balance_cost; - long unsigned int calc_load_update; - long int calc_load_active; - int hrtick_csd_pending; - long: 32; long: 64; long: 64; - call_single_data_t hrtick_csd; - struct hrtimer hrtick_timer; - struct sched_info rq_sched_info; - long long unsigned int rq_cpu_time; - unsigned int yld_count; - unsigned int sched_count; - unsigned int sched_goidle; - unsigned int ttwu_count; - unsigned int ttwu_local; - struct llist_head wake_list; - struct cpuidle_state *idle_state; long: 64; long: 64; }; -struct perf_domain { - struct em_perf_domain *em_pd; - struct perf_domain *next; - struct callback_head rcu; +struct snapshot_handle { + unsigned int cur; + void *buffer; + int sync_read; }; -struct root_domain { - atomic_t refcount; - atomic_t rto_count; - struct callback_head rcu; - cpumask_var_t span; - cpumask_var_t online; - int overload; - int overutilized; - cpumask_var_t dlo_mask; - atomic_t dlo_count; - struct dl_bw dl_bw; - struct cpudl cpudl; - struct irq_work rto_push_work; - raw_spinlock_t rto_lock; - int rto_loop; - int rto_cpu; - atomic_t rto_loop_next; - atomic_t rto_loop_start; - cpumask_var_t rto_mask; - struct cpupri cpupri; - long unsigned int max_cpu_capacity; - struct perf_domain *pd; +struct linked_page { + struct linked_page *next; + char data[4088]; }; -struct rq_flags { - long unsigned int flags; - struct pin_cookie cookie; +struct chain_allocator { + struct linked_page *chain; + unsigned int used_space; + gfp_t gfp_mask; + int safe_needed; }; -enum { - __SCHED_FEAT_GENTLE_FAIR_SLEEPERS = 0, - __SCHED_FEAT_START_DEBIT = 1, - __SCHED_FEAT_NEXT_BUDDY = 2, - __SCHED_FEAT_LAST_BUDDY = 3, - __SCHED_FEAT_CACHE_HOT_BUDDY = 4, - __SCHED_FEAT_WAKEUP_PREEMPTION = 5, - __SCHED_FEAT_HRTICK = 6, - __SCHED_FEAT_DOUBLE_TICK = 7, - __SCHED_FEAT_NONTASK_CAPACITY = 8, - __SCHED_FEAT_TTWU_QUEUE = 9, - __SCHED_FEAT_SIS_AVG_CPU = 10, - __SCHED_FEAT_SIS_PROP = 11, - __SCHED_FEAT_WARN_DOUBLE_CLOCK = 12, - __SCHED_FEAT_RT_PUSH_IPI = 13, - __SCHED_FEAT_RT_RUNTIME_SHARE = 14, - __SCHED_FEAT_LB_MIN = 15, - __SCHED_FEAT_ATTACH_AGE_LOAD = 16, - __SCHED_FEAT_WA_IDLE = 17, - __SCHED_FEAT_WA_WEIGHT = 18, - __SCHED_FEAT_WA_BIAS = 19, - __SCHED_FEAT_UTIL_EST = 20, - __SCHED_FEAT_UTIL_EST_FASTUP = 21, - __SCHED_FEAT_NR = 22, +struct rtree_node { + struct list_head list; + long unsigned int *data; }; -struct trace_event_raw_sched_kthread_stop { - struct trace_entry ent; - char comm[16]; - pid_t pid; - char __data[0]; +struct mem_zone_bm_rtree { + struct list_head list; + struct list_head nodes; + struct list_head leaves; + long unsigned int start_pfn; + long unsigned int end_pfn; + struct rtree_node *rtree; + int levels; + unsigned int blocks; }; -struct trace_event_raw_sched_kthread_stop_ret { - struct trace_entry ent; - int ret; - char __data[0]; +struct bm_position { + struct mem_zone_bm_rtree *zone; + struct rtree_node *node; + long unsigned int node_pfn; + int node_bit; }; -struct trace_event_raw_sched_wakeup_template { - struct trace_entry ent; - char comm[16]; - pid_t pid; - int prio; - int success; - int target_cpu; - char __data[0]; +struct memory_bitmap { + struct list_head zones; + struct linked_page *p_list; + struct bm_position cur; }; -struct trace_event_raw_sched_switch { - struct trace_entry ent; - char prev_comm[16]; - pid_t prev_pid; - int prev_prio; - long int prev_state; - char next_comm[16]; - pid_t next_pid; - int next_prio; - char __data[0]; +struct mem_extent { + struct list_head hook; + long unsigned int start; + long unsigned int end; }; -struct trace_event_raw_sched_migrate_task { - struct trace_entry ent; - char comm[16]; - pid_t pid; - int prio; - int orig_cpu; - int dest_cpu; - char __data[0]; +struct nosave_region { + struct list_head list; + long unsigned int start_pfn; + long unsigned int end_pfn; }; -struct trace_event_raw_sched_process_template { - struct trace_entry ent; - char comm[16]; - pid_t pid; - int prio; - char __data[0]; -}; +typedef struct { + long unsigned int val; +} swp_entry_t; -struct trace_event_raw_sched_process_wait { - struct trace_entry ent; - char comm[16]; - pid_t pid; - int prio; - char __data[0]; +enum { + BIO_NO_PAGE_REF = 0, + BIO_CLONED = 1, + BIO_BOUNCED = 2, + BIO_USER_MAPPED = 3, + BIO_NULL_MAPPED = 4, + BIO_WORKINGSET = 5, + BIO_QUIET = 6, + BIO_CHAIN = 7, + BIO_REFFED = 8, + BIO_THROTTLED = 9, + BIO_TRACE_COMPLETION = 10, + BIO_QUEUE_ENTERED = 11, + BIO_TRACKED = 12, + BIO_FLAG_LAST = 13, }; -struct trace_event_raw_sched_process_fork { - struct trace_entry ent; - char parent_comm[16]; - pid_t parent_pid; - char child_comm[16]; - pid_t child_pid; - char __data[0]; +enum req_opf { + REQ_OP_READ = 0, + REQ_OP_WRITE = 1, + REQ_OP_FLUSH = 2, + REQ_OP_DISCARD = 3, + REQ_OP_SECURE_ERASE = 5, + REQ_OP_ZONE_RESET = 6, + REQ_OP_WRITE_SAME = 7, + REQ_OP_ZONE_RESET_ALL = 8, + REQ_OP_WRITE_ZEROES = 9, + REQ_OP_ZONE_OPEN = 10, + REQ_OP_ZONE_CLOSE = 11, + REQ_OP_ZONE_FINISH = 12, + REQ_OP_SCSI_IN = 32, + REQ_OP_SCSI_OUT = 33, + REQ_OP_DRV_IN = 34, + REQ_OP_DRV_OUT = 35, + REQ_OP_LAST = 36, }; -struct trace_event_raw_sched_process_exec { - struct trace_entry ent; - u32 __data_loc_filename; - pid_t pid; - pid_t old_pid; - char __data[0]; +enum req_flag_bits { + __REQ_FAILFAST_DEV = 8, + __REQ_FAILFAST_TRANSPORT = 9, + __REQ_FAILFAST_DRIVER = 10, + __REQ_SYNC = 11, + __REQ_META = 12, + __REQ_PRIO = 13, + __REQ_NOMERGE = 14, + __REQ_IDLE = 15, + __REQ_INTEGRITY = 16, + __REQ_FUA = 17, + __REQ_PREFLUSH = 18, + __REQ_RAHEAD = 19, + __REQ_BACKGROUND = 20, + __REQ_NOWAIT = 21, + __REQ_NOWAIT_INLINE = 22, + __REQ_CGROUP_PUNT = 23, + __REQ_NOUNMAP = 24, + __REQ_HIPRI = 25, + __REQ_DRV = 26, + __REQ_SWAP = 27, + __REQ_NR_BITS = 28, }; -struct trace_event_raw_sched_stat_template { - struct trace_entry ent; - char comm[16]; - pid_t pid; - u64 delay; - char __data[0]; +struct swap_map_page { + sector_t entries[511]; + sector_t next_swap; }; -struct trace_event_raw_sched_stat_runtime { - struct trace_entry ent; - char comm[16]; - pid_t pid; - u64 runtime; - u64 vruntime; - char __data[0]; +struct swap_map_page_list { + struct swap_map_page *map; + struct swap_map_page_list *next; }; -struct trace_event_raw_sched_pi_setprio { - struct trace_entry ent; - char comm[16]; - pid_t pid; - int oldprio; - int newprio; - char __data[0]; +struct swap_map_handle { + struct swap_map_page *cur; + struct swap_map_page_list *maps; + sector_t cur_swap; + sector_t first_sector; + unsigned int k; + long unsigned int reqd_free_pages; + u32 crc32; }; -struct trace_event_raw_sched_move_task_template { - struct trace_entry ent; - pid_t pid; - pid_t tgid; - pid_t ngid; - int src_cpu; - int src_nid; - int dst_cpu; - int dst_nid; - char __data[0]; +struct swsusp_header { + char reserved[4060]; + u32 crc32; + sector_t image; + unsigned int flags; + char orig_sig[10]; + char sig[10]; }; -struct trace_event_raw_sched_swap_numa { - struct trace_entry ent; - pid_t src_pid; - pid_t src_tgid; - pid_t src_ngid; - int src_cpu; - int src_nid; - pid_t dst_pid; - pid_t dst_tgid; - pid_t dst_ngid; - int dst_cpu; - int dst_nid; - char __data[0]; +struct swsusp_extent { + struct rb_node node; + long unsigned int start; + long unsigned int end; }; -struct trace_event_raw_sched_wake_idle_without_ipi { - struct trace_entry ent; - int cpu; - char __data[0]; +struct hib_bio_batch { + atomic_t count; + wait_queue_head_t wait; + blk_status_t error; }; -struct trace_event_data_offsets_sched_kthread_stop {}; - -struct trace_event_data_offsets_sched_kthread_stop_ret {}; - -struct trace_event_data_offsets_sched_wakeup_template {}; - -struct trace_event_data_offsets_sched_switch {}; - -struct trace_event_data_offsets_sched_migrate_task {}; - -struct trace_event_data_offsets_sched_process_template {}; - -struct trace_event_data_offsets_sched_process_wait {}; - -struct trace_event_data_offsets_sched_process_fork {}; - -struct trace_event_data_offsets_sched_process_exec { - u32 filename; +struct crc_data { + struct task_struct *thr; + atomic_t ready; + atomic_t stop; + unsigned int run_threads; + wait_queue_head_t go; + wait_queue_head_t done; + u32 *crc32; + size_t *unc_len[3]; + unsigned char *unc[3]; }; -struct trace_event_data_offsets_sched_stat_template {}; - -struct trace_event_data_offsets_sched_stat_runtime {}; - -struct trace_event_data_offsets_sched_pi_setprio {}; +struct cmp_data { + struct task_struct *thr; + atomic_t ready; + atomic_t stop; + int ret; + wait_queue_head_t go; + wait_queue_head_t done; + size_t unc_len; + size_t cmp_len; + unsigned char unc[131072]; + unsigned char cmp[143360]; + unsigned char wrk[16384]; +}; -struct trace_event_data_offsets_sched_move_task_template {}; +struct dec_data { + struct task_struct *thr; + atomic_t ready; + atomic_t stop; + int ret; + wait_queue_head_t go; + wait_queue_head_t done; + size_t unc_len; + size_t cmp_len; + unsigned char unc[131072]; + unsigned char cmp[143360]; +}; -struct trace_event_data_offsets_sched_swap_numa {}; +typedef s64 compat_loff_t; -struct trace_event_data_offsets_sched_wake_idle_without_ipi {}; +struct resume_swap_area { + __kernel_loff_t offset; + __u32 dev; +} __attribute__((packed)); -struct migration_arg { - struct task_struct *task; - int dest_cpu; +struct snapshot_data { + struct snapshot_handle handle; + int swap; + int mode; + bool frozen; + bool ready; + bool platform_support; + bool free_bitmaps; }; -enum { - cpuset = 0, - possible = 1, - fail = 2, -}; +struct compat_resume_swap_area { + compat_loff_t offset; + u32 dev; +} __attribute__((packed)); -enum tick_dep_bits { - TICK_DEP_BIT_POSIX_TIMER = 0, - TICK_DEP_BIT_PERF_EVENTS = 1, - TICK_DEP_BIT_SCHED = 2, - TICK_DEP_BIT_CLOCK_UNSTABLE = 3, - TICK_DEP_BIT_RCU = 4, +struct sysrq_key_op { + void (*handler)(int); + char *help_msg; + char *action_msg; + int enable_mask; }; -struct sched_clock_data { - u64 tick_raw; - u64 tick_gtod; - u64 clock; +struct kmsg_dumper { + struct list_head list; + void (*dump)(struct kmsg_dumper *, enum kmsg_dump_reason); + enum kmsg_dump_reason max_reason; + bool active; + bool registered; + u32 cur_idx; + u32 next_idx; + u64 cur_seq; + u64 next_seq; }; -struct idle_timer { - struct hrtimer timer; - int done; +struct trace_event_raw_console { + struct trace_entry ent; + u32 __data_loc_msg; + char __data[0]; }; -enum sched_tunable_scaling { - SCHED_TUNABLESCALING_NONE = 0, - SCHED_TUNABLESCALING_LOG = 1, - SCHED_TUNABLESCALING_LINEAR = 2, - SCHED_TUNABLESCALING_END = 3, +struct trace_event_data_offsets_console { + u32 msg; }; -enum schedutil_type { - FREQUENCY_UTIL = 0, - ENERGY_UTIL = 1, -}; +typedef void (*btf_trace_console)(void *, const char *, size_t); -enum fbq_type { - regular = 0, - remote = 1, - all = 2, +struct console_cmdline { + char name[16]; + int index; + char *options; }; -enum group_type { - group_has_spare = 0, - group_fully_busy = 1, - group_misfit_task = 2, - group_asym_packing = 3, - group_imbalanced = 4, - group_overloaded = 5, +enum devkmsg_log_bits { + __DEVKMSG_LOG_BIT_ON = 0, + __DEVKMSG_LOG_BIT_OFF = 1, + __DEVKMSG_LOG_BIT_LOCK = 2, }; -enum migration_type { - migrate_load = 0, - migrate_util = 1, - migrate_task = 2, - migrate_misfit = 3, +enum devkmsg_log_masks { + DEVKMSG_LOG_MASK_ON = 1, + DEVKMSG_LOG_MASK_OFF = 2, + DEVKMSG_LOG_MASK_LOCK = 4, }; -struct lb_env { - struct sched_domain *sd; - struct rq *src_rq; - int src_cpu; - int dst_cpu; - struct rq *dst_rq; - struct cpumask *dst_grpmask; - int new_dst_cpu; - enum cpu_idle_type idle; - long int imbalance; - struct cpumask *cpus; - unsigned int flags; - unsigned int loop; - unsigned int loop_break; - unsigned int loop_max; - enum fbq_type fbq_type; - enum migration_type migration_type; - struct list_head tasks; +enum con_msg_format_flags { + MSG_FORMAT_DEFAULT = 0, + MSG_FORMAT_SYSLOG = 1, }; -struct sg_lb_stats { - long unsigned int avg_load; - long unsigned int group_load; - long unsigned int group_capacity; - long unsigned int group_util; - unsigned int sum_nr_running; - unsigned int sum_h_nr_running; - unsigned int idle_cpus; - unsigned int group_weight; - enum group_type group_type; - unsigned int group_asym_packing; - long unsigned int group_misfit_task_load; +enum log_flags { + LOG_NEWLINE = 2, + LOG_CONT = 8, }; -struct sd_lb_stats { - struct sched_group *busiest; - struct sched_group *local; - long unsigned int total_load; - long unsigned int total_capacity; - long unsigned int avg_load; - unsigned int prefer_sibling; - struct sg_lb_stats busiest_stat; - struct sg_lb_stats local_stat; +struct printk_log { + u64 ts_nsec; + u16 len; + u16 text_len; + u16 dict_len; + u8 facility; + u8 flags: 5; + u8 level: 3; }; -typedef struct rt_rq *rt_rq_iter_t; +struct devkmsg_user { + u64 seq; + u32 idx; + struct ratelimit_state rs; + struct mutex lock; + char buf[8192]; +}; -struct wait_bit_queue_entry { - struct wait_bit_key key; - struct wait_queue_entry wq_entry; +struct cont { + char buf[992]; + size_t len; + u32 caller_id; + u64 ts_nsec; + u8 level; + u8 facility; + enum log_flags flags; }; -struct swait_queue_head { - raw_spinlock_t lock; - struct list_head task_list; +struct printk_safe_seq_buf { + atomic_t len; + atomic_t message_lost; + struct irq_work work; + unsigned char buffer[8160]; }; -struct swait_queue { - struct task_struct *task; - struct list_head task_list; +enum { + IRQS_AUTODETECT = 1, + IRQS_SPURIOUS_DISABLED = 2, + IRQS_POLL_INPROGRESS = 8, + IRQS_ONESHOT = 32, + IRQS_REPLAY = 64, + IRQS_WAITING = 128, + IRQS_PENDING = 512, + IRQS_SUSPENDED = 2048, + IRQS_TIMINGS = 4096, + IRQS_NMI = 8192, }; -enum numa_topology_type { - NUMA_DIRECT = 0, - NUMA_GLUELESS_MESH = 1, - NUMA_BACKPLANE = 2, +enum { + _IRQ_DEFAULT_INIT_FLAGS = 0, + _IRQ_PER_CPU = 512, + _IRQ_LEVEL = 256, + _IRQ_NOPROBE = 1024, + _IRQ_NOREQUEST = 2048, + _IRQ_NOTHREAD = 65536, + _IRQ_NOAUTOEN = 4096, + _IRQ_MOVE_PCNTXT = 16384, + _IRQ_NO_BALANCING = 8192, + _IRQ_NESTED_THREAD = 32768, + _IRQ_PER_CPU_DEVID = 131072, + _IRQ_IS_POLLED = 262144, + _IRQ_DISABLE_UNLAZY = 524288, + _IRQF_MODIFY_MASK = 1048335, }; -struct s_data { - struct sched_domain **sd; - struct root_domain *rd; +enum { + IRQTF_RUNTHREAD = 0, + IRQTF_WARNED = 1, + IRQTF_AFFINITY = 2, + IRQTF_FORCED_THREAD = 3, }; -enum s_alloc { - sa_rootdomain = 0, - sa_sd = 1, - sa_sd_storage = 2, - sa_none = 3, +enum { + IRQC_IS_HARDIRQ = 0, + IRQC_IS_NESTED = 1, }; -enum cpuacct_stat_index { - CPUACCT_STAT_USER = 0, - CPUACCT_STAT_SYSTEM = 1, - CPUACCT_STAT_NSTATS = 2, +enum { + IRQ_STARTUP_NORMAL = 0, + IRQ_STARTUP_MANAGED = 1, + IRQ_STARTUP_ABORT = 2, }; -struct cpuacct_usage { - u64 usages[2]; +struct irq_devres { + unsigned int irq; + void *dev_id; }; -struct cpuacct { - struct cgroup_subsys_state css; - struct cpuacct_usage *cpuusage; - struct kernel_cpustat *cpustat; +struct irq_desc_devres { + unsigned int from; + unsigned int cnt; }; enum { - MEMBARRIER_FLAG_SYNC_CORE = 1, + IRQ_DOMAIN_FLAG_HIERARCHY = 1, + IRQ_DOMAIN_NAME_ALLOCATED = 64, + IRQ_DOMAIN_FLAG_IPI_PER_CPU = 4, + IRQ_DOMAIN_FLAG_IPI_SINGLE = 8, + IRQ_DOMAIN_FLAG_MSI = 16, + IRQ_DOMAIN_FLAG_MSI_REMAP = 32, + IRQ_DOMAIN_FLAG_NONCORE = 65536, }; -enum membarrier_cmd { - MEMBARRIER_CMD_QUERY = 0, - MEMBARRIER_CMD_GLOBAL = 1, - MEMBARRIER_CMD_GLOBAL_EXPEDITED = 2, - MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED = 4, - MEMBARRIER_CMD_PRIVATE_EXPEDITED = 8, - MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED = 16, - MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE = 32, - MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE = 64, - MEMBARRIER_CMD_SHARED = 1, -}; +typedef u64 acpi_size; -struct ww_acquire_ctx; +typedef u64 acpi_io_address; -struct mutex_waiter { - struct list_head list; - struct task_struct *task; - struct ww_acquire_ctx *ww_ctx; -}; +typedef u32 acpi_object_type; -struct ww_acquire_ctx { - struct task_struct *task; - long unsigned int stamp; - unsigned int acquired; - short unsigned int wounded; - short unsigned int is_wait_die; +union acpi_object { + acpi_object_type type; + struct { + acpi_object_type type; + u64 value; + } integer; + struct { + acpi_object_type type; + u32 length; + char *pointer; + } string; + struct { + acpi_object_type type; + u32 length; + u8 *pointer; + } buffer; + struct { + acpi_object_type type; + u32 count; + union acpi_object *elements; + } package; + struct { + acpi_object_type type; + acpi_object_type actual_type; + acpi_handle handle; + } reference; + struct { + acpi_object_type type; + u32 proc_id; + acpi_io_address pblk_address; + u32 pblk_length; + } processor; + struct { + acpi_object_type type; + u32 system_level; + u32 resource_order; + } power_resource; }; -enum mutex_trylock_recursive_enum { - MUTEX_TRYLOCK_FAILED = 0, - MUTEX_TRYLOCK_SUCCESS = 1, - MUTEX_TRYLOCK_RECURSIVE = 2, +struct acpi_buffer { + acpi_size length; + void *pointer; }; -struct ww_mutex { - struct mutex base; - struct ww_acquire_ctx *ctx; +struct acpi_hotplug_profile { + struct kobject kobj; + int (*scan_dependent)(struct acpi_device *); + void (*notify_online)(struct acpi_device *); + bool enabled: 1; + bool demand_offline: 1; }; -struct semaphore { - raw_spinlock_t lock; - unsigned int count; - struct list_head wait_list; +struct acpi_device_status { + u32 present: 1; + u32 enabled: 1; + u32 show_in_ui: 1; + u32 functional: 1; + u32 battery_present: 1; + u32 reserved: 27; }; -struct semaphore_waiter { - struct list_head list; - struct task_struct *task; - bool up; +struct acpi_device_flags { + u32 dynamic_status: 1; + u32 removable: 1; + u32 ejectable: 1; + u32 power_manageable: 1; + u32 match_driver: 1; + u32 initialized: 1; + u32 visited: 1; + u32 hotplug_notify: 1; + u32 is_dock_station: 1; + u32 of_compatible_ok: 1; + u32 coherent_dma: 1; + u32 cca_seen: 1; + u32 enumeration_by_parent: 1; + u32 reserved: 19; }; -enum rwsem_waiter_type { - RWSEM_WAITING_FOR_WRITE = 0, - RWSEM_WAITING_FOR_READ = 1, +typedef char acpi_bus_id[8]; + +struct acpi_pnp_type { + u32 hardware_id: 1; + u32 bus_address: 1; + u32 platform_id: 1; + u32 reserved: 29; }; -struct rwsem_waiter { - struct list_head list; - struct task_struct *task; - enum rwsem_waiter_type type; - long unsigned int timeout; - long unsigned int last_rowner; +typedef u64 acpi_bus_address; + +typedef char acpi_device_name[40]; + +typedef char acpi_device_class[20]; + +struct acpi_device_pnp { + acpi_bus_id bus_id; + struct acpi_pnp_type type; + acpi_bus_address bus_address; + char *unique_id; + struct list_head ids; + acpi_device_name device_name; + acpi_device_class device_class; + union acpi_object *str_obj; }; -enum rwsem_wake_type { - RWSEM_WAKE_ANY = 0, - RWSEM_WAKE_READERS = 1, - RWSEM_WAKE_READ_OWNED = 2, +struct acpi_device_power_flags { + u32 explicit_get: 1; + u32 power_resources: 1; + u32 inrush_current: 1; + u32 power_removed: 1; + u32 ignore_parent: 1; + u32 dsw_present: 1; + u32 reserved: 26; }; -enum writer_wait_state { - WRITER_NOT_FIRST = 0, - WRITER_FIRST = 1, - WRITER_HANDOFF = 2, +struct acpi_device_power_state { + struct { + u8 valid: 1; + u8 explicit_set: 1; + u8 reserved: 6; + } flags; + int power; + int latency; + struct list_head resources; }; -enum owner_state { - OWNER_NULL = 1, - OWNER_WRITER = 2, - OWNER_READER = 4, - OWNER_NONSPINNABLE = 8, +struct acpi_device_power { + int state; + struct acpi_device_power_flags flags; + struct acpi_device_power_state states[5]; }; -struct optimistic_spin_node { - struct optimistic_spin_node *next; - struct optimistic_spin_node *prev; - int locked; - int cpu; +struct acpi_device_wakeup_flags { + u8 valid: 1; + u8 notifier_present: 1; }; -struct mcs_spinlock { - struct mcs_spinlock *next; - int locked; - int count; +struct acpi_device_wakeup_context { + void (*func)(struct acpi_device_wakeup_context *); + struct device *dev; }; -struct qnode { - struct mcs_spinlock mcs; +struct acpi_device_wakeup { + acpi_handle gpe_device; + u64 gpe_number; + u64 sleep_state; + struct list_head resources; + struct acpi_device_wakeup_flags flags; + struct acpi_device_wakeup_context context; + struct wakeup_source *ws; + int prepare_count; + int enable_count; }; -struct hrtimer_sleeper { - struct hrtimer timer; - struct task_struct *task; +struct acpi_device_perf_flags { + u8 reserved: 8; }; -struct rt_mutex; +struct acpi_device_perf_state; -struct rt_mutex_waiter { - struct rb_node tree_entry; - struct rb_node pi_tree_entry; - struct task_struct *task; - struct rt_mutex *lock; - int prio; - u64 deadline; +struct acpi_device_perf { + int state; + struct acpi_device_perf_flags flags; + int state_count; + struct acpi_device_perf_state *states; }; -struct rt_mutex { - raw_spinlock_t wait_lock; - struct rb_root_cached waiters; - struct task_struct *owner; +struct acpi_device_dir { + struct proc_dir_entry *entry; }; -enum rtmutex_chainwalk { - RT_MUTEX_MIN_CHAINWALK = 0, - RT_MUTEX_FULL_CHAINWALK = 1, +struct acpi_device_data { + const union acpi_object *pointer; + struct list_head properties; + const union acpi_object *of_compatible; + struct list_head subnodes; }; -enum pm_qos_req_action { - PM_QOS_ADD_REQ = 0, - PM_QOS_UPDATE_REQ = 1, - PM_QOS_REMOVE_REQ = 2, -}; +struct acpi_scan_handler; -struct miscdevice { - int minor; - const char *name; - const struct file_operations *fops; - struct list_head list; - struct device *parent; - struct device *this_device; - const struct attribute_group **groups; - const char *nodename; - umode_t mode; -}; +struct acpi_hotplug_context; -struct pm_qos_object { - struct pm_qos_constraints *constraints; - struct miscdevice pm_qos_power_miscdev; - char *name; -}; +struct acpi_driver; -typedef int suspend_state_t; +struct acpi_gpio_mapping; -enum { - TEST_NONE = 0, - TEST_CORE = 1, - TEST_CPUS = 2, - TEST_PLATFORM = 3, - TEST_DEVICES = 4, - TEST_FREEZER = 5, - __TEST_AFTER_LAST = 6, +struct acpi_device { + int device_type; + acpi_handle handle; + struct fwnode_handle fwnode; + struct acpi_device *parent; + struct list_head children; + struct list_head node; + struct list_head wakeup_list; + struct list_head del_list; + struct acpi_device_status status; + struct acpi_device_flags flags; + struct acpi_device_pnp pnp; + struct acpi_device_power power; + struct acpi_device_wakeup wakeup; + struct acpi_device_perf performance; + struct acpi_device_dir dir; + struct acpi_device_data data; + struct acpi_scan_handler *handler; + struct acpi_hotplug_context *hp; + struct acpi_driver *driver; + const struct acpi_gpio_mapping *driver_gpios; + void *driver_data; + struct device dev; + unsigned int physical_node_count; + unsigned int dep_unmet; + struct list_head physical_node_list; + struct mutex physical_node_lock; + void (*remove)(struct acpi_device *); }; -struct pm_vt_switch { - struct list_head head; - struct device *dev; - bool required; +struct acpi_scan_handler { + const struct acpi_device_id *ids; + struct list_head list_node; + bool (*match)(const char *, const struct acpi_device_id **); + int (*attach)(struct acpi_device *, const struct acpi_device_id *); + void (*detach)(struct acpi_device *); + void (*bind)(struct device *); + void (*unbind)(struct device *); + struct acpi_hotplug_profile hotplug; }; -struct platform_suspend_ops { - int (*valid)(suspend_state_t); - int (*begin)(suspend_state_t); - int (*prepare)(); - int (*prepare_late)(); - int (*enter)(suspend_state_t); - void (*wake)(); - void (*finish)(); - bool (*suspend_again)(); - void (*end)(); - void (*recover)(); +struct acpi_hotplug_context { + struct acpi_device *self; + int (*notify)(struct acpi_device *, u32); + void (*uevent)(struct acpi_device *, u32); + void (*fixup)(struct acpi_device *); }; -struct platform_s2idle_ops { - int (*begin)(); - int (*prepare)(); - int (*prepare_late)(); - void (*wake)(); - void (*restore_early)(); - void (*restore)(); - void (*end)(); -}; +typedef int (*acpi_op_add)(struct acpi_device *); -struct platform_hibernation_ops { - int (*begin)(pm_message_t); - void (*end)(); - int (*pre_snapshot)(); - void (*finish)(); - int (*prepare)(); - int (*enter)(); - void (*leave)(); - int (*pre_restore)(); - void (*restore_cleanup)(); - void (*recover)(); -}; +typedef int (*acpi_op_remove)(struct acpi_device *); -enum { - HIBERNATION_INVALID = 0, - HIBERNATION_PLATFORM = 1, - HIBERNATION_SHUTDOWN = 2, - HIBERNATION_REBOOT = 3, - HIBERNATION_SUSPEND = 4, - HIBERNATION_TEST_RESUME = 5, - __HIBERNATION_AFTER_LAST = 6, +typedef void (*acpi_op_notify)(struct acpi_device *, u32); + +struct acpi_device_ops { + acpi_op_add add; + acpi_op_remove remove; + acpi_op_notify notify; }; -struct pbe { - void *address; - void *orig_address; - struct pbe *next; +struct acpi_driver { + char name[80]; + char class[80]; + const struct acpi_device_id *ids; + unsigned int flags; + struct acpi_device_ops ops; + struct device_driver drv; + struct module *owner; }; -struct swsusp_info { - struct new_utsname uts; - u32 version_code; - long unsigned int num_physpages; - int cpus; - long unsigned int image_pages; - long unsigned int pages; - long unsigned int size; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +struct acpi_device_perf_state { + struct { + u8 valid: 1; + u8 reserved: 7; + } flags; + u8 power; + u8 performance; + int latency; +}; + +struct acpi_gpio_params; + +struct acpi_gpio_mapping { + const char *name; + const struct acpi_gpio_params *data; + unsigned int size; + unsigned int quirks; +}; + +struct irqchip_fwid { + struct fwnode_handle fwnode; + unsigned int type; + char *name; + phys_addr_t *pa; +}; + +enum { + AFFINITY = 0, + AFFINITY_LIST = 1, + EFFECTIVE = 2, + EFFECTIVE_LIST = 3, +}; + +struct irq_affinity { + unsigned int pre_vectors; + unsigned int post_vectors; + unsigned int nr_sets; + unsigned int set_size[4]; + void (*calc_sets)(struct irq_affinity *, unsigned int); + void *priv; +}; + +struct node_vectors { + unsigned int id; + union { + unsigned int nvectors; + unsigned int ncpus; + }; +}; + +struct cpumap { + unsigned int available; + unsigned int allocated; + unsigned int managed; + unsigned int managed_allocated; + bool initialized; + bool online; + long unsigned int alloc_map[4]; + long unsigned int managed_map[4]; +}; + +struct irq_matrix___2 { + unsigned int matrix_bits; + unsigned int alloc_start; + unsigned int alloc_end; + unsigned int alloc_size; + unsigned int global_available; + unsigned int global_reserved; + unsigned int systembits_inalloc; + unsigned int total_allocated; + unsigned int online_maps; + struct cpumap *maps; + long unsigned int scratch_map[4]; + long unsigned int system_map[4]; +}; + +struct trace_event_raw_irq_matrix_global { + struct trace_entry ent; + unsigned int online_maps; + unsigned int global_available; + unsigned int global_reserved; + unsigned int total_allocated; + char __data[0]; +}; + +struct trace_event_raw_irq_matrix_global_update { + struct trace_entry ent; + int bit; + unsigned int online_maps; + unsigned int global_available; + unsigned int global_reserved; + unsigned int total_allocated; + char __data[0]; +}; + +struct trace_event_raw_irq_matrix_cpu { + struct trace_entry ent; + int bit; + unsigned int cpu; + bool online; + unsigned int available; + unsigned int allocated; + unsigned int managed; + unsigned int online_maps; + unsigned int global_available; + unsigned int global_reserved; + unsigned int total_allocated; + char __data[0]; +}; + +struct trace_event_data_offsets_irq_matrix_global {}; + +struct trace_event_data_offsets_irq_matrix_global_update {}; + +struct trace_event_data_offsets_irq_matrix_cpu {}; + +typedef void (*btf_trace_irq_matrix_online)(void *, struct irq_matrix___2 *); + +typedef void (*btf_trace_irq_matrix_offline)(void *, struct irq_matrix___2 *); + +typedef void (*btf_trace_irq_matrix_reserve)(void *, struct irq_matrix___2 *); + +typedef void (*btf_trace_irq_matrix_remove_reserved)(void *, struct irq_matrix___2 *); + +typedef void (*btf_trace_irq_matrix_assign_system)(void *, int, struct irq_matrix___2 *); + +typedef void (*btf_trace_irq_matrix_alloc_reserved)(void *, int, unsigned int, struct irq_matrix___2 *, struct cpumap *); + +typedef void (*btf_trace_irq_matrix_reserve_managed)(void *, int, unsigned int, struct irq_matrix___2 *, struct cpumap *); + +typedef void (*btf_trace_irq_matrix_remove_managed)(void *, int, unsigned int, struct irq_matrix___2 *, struct cpumap *); + +typedef void (*btf_trace_irq_matrix_alloc_managed)(void *, int, unsigned int, struct irq_matrix___2 *, struct cpumap *); + +typedef void (*btf_trace_irq_matrix_assign)(void *, int, unsigned int, struct irq_matrix___2 *, struct cpumap *); + +typedef void (*btf_trace_irq_matrix_alloc)(void *, int, unsigned int, struct irq_matrix___2 *, struct cpumap *); + +typedef void (*btf_trace_irq_matrix_free)(void *, int, unsigned int, struct irq_matrix___2 *, struct cpumap *); + +typedef void (*rcu_callback_t)(struct callback_head *); + +typedef void (*call_rcu_func_t)(struct callback_head *, rcu_callback_t); + +struct rcu_synchronize { + struct callback_head head; + struct completion completion; +}; + +struct trace_event_raw_rcu_utilization { + struct trace_entry ent; + const char *s; + char __data[0]; +}; + +struct trace_event_raw_rcu_grace_period { + struct trace_entry ent; + const char *rcuname; + long unsigned int gp_seq; + const char *gpevent; + char __data[0]; +}; + +struct trace_event_raw_rcu_future_grace_period { + struct trace_entry ent; + const char *rcuname; + long unsigned int gp_seq; + long unsigned int gp_seq_req; + u8 level; + int grplo; + int grphi; + const char *gpevent; + char __data[0]; +}; + +struct trace_event_raw_rcu_grace_period_init { + struct trace_entry ent; + const char *rcuname; + long unsigned int gp_seq; + u8 level; + int grplo; + int grphi; + long unsigned int qsmask; + char __data[0]; +}; + +struct trace_event_raw_rcu_exp_grace_period { + struct trace_entry ent; + const char *rcuname; + long unsigned int gpseq; + const char *gpevent; + char __data[0]; +}; + +struct trace_event_raw_rcu_exp_funnel_lock { + struct trace_entry ent; + const char *rcuname; + u8 level; + int grplo; + int grphi; + const char *gpevent; + char __data[0]; +}; + +struct trace_event_raw_rcu_preempt_task { + struct trace_entry ent; + const char *rcuname; + long unsigned int gp_seq; + int pid; + char __data[0]; +}; + +struct trace_event_raw_rcu_unlock_preempted_task { + struct trace_entry ent; + const char *rcuname; + long unsigned int gp_seq; + int pid; + char __data[0]; +}; + +struct trace_event_raw_rcu_quiescent_state_report { + struct trace_entry ent; + const char *rcuname; + long unsigned int gp_seq; + long unsigned int mask; + long unsigned int qsmask; + u8 level; + int grplo; + int grphi; + u8 gp_tasks; + char __data[0]; +}; + +struct trace_event_raw_rcu_fqs { + struct trace_entry ent; + const char *rcuname; + long unsigned int gp_seq; + int cpu; + const char *qsevent; + char __data[0]; +}; + +struct trace_event_raw_rcu_dyntick { + struct trace_entry ent; + const char *polarity; + long int oldnesting; + long int newnesting; + int dynticks; + char __data[0]; +}; + +struct trace_event_raw_rcu_callback { + struct trace_entry ent; + const char *rcuname; + void *rhp; + void *func; + long int qlen_lazy; + long int qlen; + char __data[0]; +}; + +struct trace_event_raw_rcu_kfree_callback { + struct trace_entry ent; + const char *rcuname; + void *rhp; + long unsigned int offset; + long int qlen_lazy; + long int qlen; + char __data[0]; +}; + +struct trace_event_raw_rcu_batch_start { + struct trace_entry ent; + const char *rcuname; + long int qlen_lazy; + long int qlen; + long int blimit; + char __data[0]; +}; + +struct trace_event_raw_rcu_invoke_callback { + struct trace_entry ent; + const char *rcuname; + void *rhp; + void *func; + char __data[0]; +}; + +struct trace_event_raw_rcu_invoke_kfree_callback { + struct trace_entry ent; + const char *rcuname; + void *rhp; + long unsigned int offset; + char __data[0]; +}; + +struct trace_event_raw_rcu_batch_end { + struct trace_entry ent; + const char *rcuname; + int callbacks_invoked; + char cb; + char nr; + char iit; + char risk; + char __data[0]; +}; + +struct trace_event_raw_rcu_torture_read { + struct trace_entry ent; + char rcutorturename[8]; + struct callback_head *rhp; + long unsigned int secs; + long unsigned int c_old; + long unsigned int c; + char __data[0]; +}; + +struct trace_event_raw_rcu_barrier { + struct trace_entry ent; + const char *rcuname; + const char *s; + int cpu; + int cnt; + long unsigned int done; + char __data[0]; +}; + +struct trace_event_data_offsets_rcu_utilization {}; + +struct trace_event_data_offsets_rcu_grace_period {}; + +struct trace_event_data_offsets_rcu_future_grace_period {}; + +struct trace_event_data_offsets_rcu_grace_period_init {}; + +struct trace_event_data_offsets_rcu_exp_grace_period {}; + +struct trace_event_data_offsets_rcu_exp_funnel_lock {}; + +struct trace_event_data_offsets_rcu_preempt_task {}; + +struct trace_event_data_offsets_rcu_unlock_preempted_task {}; + +struct trace_event_data_offsets_rcu_quiescent_state_report {}; + +struct trace_event_data_offsets_rcu_fqs {}; + +struct trace_event_data_offsets_rcu_dyntick {}; + +struct trace_event_data_offsets_rcu_callback {}; + +struct trace_event_data_offsets_rcu_kfree_callback {}; + +struct trace_event_data_offsets_rcu_batch_start {}; + +struct trace_event_data_offsets_rcu_invoke_callback {}; + +struct trace_event_data_offsets_rcu_invoke_kfree_callback {}; + +struct trace_event_data_offsets_rcu_batch_end {}; + +struct trace_event_data_offsets_rcu_torture_read {}; + +struct trace_event_data_offsets_rcu_barrier {}; + +typedef void (*btf_trace_rcu_utilization)(void *, const char *); + +typedef void (*btf_trace_rcu_grace_period)(void *, const char *, long unsigned int, const char *); + +typedef void (*btf_trace_rcu_future_grace_period)(void *, const char *, long unsigned int, long unsigned int, u8, int, int, const char *); + +typedef void (*btf_trace_rcu_grace_period_init)(void *, const char *, long unsigned int, u8, int, int, long unsigned int); + +typedef void (*btf_trace_rcu_exp_grace_period)(void *, const char *, long unsigned int, const char *); + +typedef void (*btf_trace_rcu_exp_funnel_lock)(void *, const char *, u8, int, int, const char *); + +typedef void (*btf_trace_rcu_preempt_task)(void *, const char *, int, long unsigned int); + +typedef void (*btf_trace_rcu_unlock_preempted_task)(void *, const char *, long unsigned int, int); + +typedef void (*btf_trace_rcu_quiescent_state_report)(void *, const char *, long unsigned int, long unsigned int, long unsigned int, u8, int, int, int); + +typedef void (*btf_trace_rcu_fqs)(void *, const char *, long unsigned int, int, const char *); + +typedef void (*btf_trace_rcu_dyntick)(void *, const char *, long int, long int, atomic_t); + +typedef void (*btf_trace_rcu_callback)(void *, const char *, struct callback_head *, long int, long int); + +typedef void (*btf_trace_rcu_kfree_callback)(void *, const char *, struct callback_head *, long unsigned int, long int, long int); + +typedef void (*btf_trace_rcu_batch_start)(void *, const char *, long int, long int, long int); + +typedef void (*btf_trace_rcu_invoke_callback)(void *, const char *, struct callback_head *); + +typedef void (*btf_trace_rcu_invoke_kfree_callback)(void *, const char *, struct callback_head *, long unsigned int); + +typedef void (*btf_trace_rcu_batch_end)(void *, const char *, int, char, char, char, char); + +typedef void (*btf_trace_rcu_torture_read)(void *, const char *, struct callback_head *, long unsigned int, long unsigned int, long unsigned int); + +typedef void (*btf_trace_rcu_barrier)(void *, const char *, const char *, int, int, long unsigned int); + +enum { + GP_IDLE = 0, + GP_ENTER = 1, + GP_PASSED = 2, + GP_EXIT = 3, + GP_REPLAY = 4, +}; + +typedef long unsigned int ulong; + +struct rcu_cblist { + struct callback_head *head; + struct callback_head **tail; + long int len; + long int len_lazy; +}; + +enum rcutorture_type { + RCU_FLAVOR = 0, + RCU_TASKS_FLAVOR = 1, + RCU_TRIVIAL_FLAVOR = 2, + SRCU_FLAVOR = 3, + INVALID_RCU_FLAVOR = 4, +}; + +enum tick_device_mode { + TICKDEV_MODE_PERIODIC = 0, + TICKDEV_MODE_ONESHOT = 1, +}; + +struct tick_device___2 { + struct clock_event_device *evtdev; + enum tick_device_mode mode; +}; + +struct rcu_exp_work { + long unsigned int rew_s; + struct work_struct rew_work; +}; + +struct rcu_node { + raw_spinlock_t lock; + long unsigned int gp_seq; + long unsigned int gp_seq_needed; + long unsigned int completedqs; + long unsigned int qsmask; + long unsigned int rcu_gp_init_mask; + long unsigned int qsmaskinit; + long unsigned int qsmaskinitnext; + long unsigned int expmask; + long unsigned int expmaskinit; + long unsigned int expmaskinitnext; + long unsigned int ffmask; + long unsigned int grpmask; + int grplo; + int grphi; + u8 grpnum; + u8 level; + bool wait_blkd_tasks; + struct rcu_node *parent; + struct list_head blkd_tasks; + struct list_head *gp_tasks; + struct list_head *exp_tasks; + struct list_head *boost_tasks; + struct rt_mutex boost_mtx; + long unsigned int boost_time; + struct task_struct *boost_kthread_task; + unsigned int boost_kthread_status; + long: 32; long: 64; long: 64; long: 64; long: 64; + raw_spinlock_t fqslock; + long: 32; long: 64; long: 64; long: 64; @@ -25743,16 +29856,112 @@ struct swsusp_info { long: 64; long: 64; long: 64; + spinlock_t exp_lock; + long unsigned int exp_seq_rq; + wait_queue_head_t exp_wq[4]; + struct rcu_exp_work rew; + bool exp_need_flush; + long: 56; long: 64; long: 64; long: 64; long: 64; +}; + +union rcu_noqs { + struct { + u8 norm; + u8 exp; + } b; + u16 s; +}; + +struct rcu_data { + long unsigned int gp_seq; + long unsigned int gp_seq_needed; + union rcu_noqs cpu_no_qs; + bool core_needs_qs; + bool beenonline; + bool gpwrap; + bool exp_deferred_qs; + struct rcu_node *mynode; + long unsigned int grpmask; + long unsigned int ticks_this_gp; + struct irq_work defer_qs_iw; + bool defer_qs_iw_pending; + struct rcu_segcblist cblist; + long int qlen_last_fqs_check; + long unsigned int n_force_qs_snap; + long int blimit; + int dynticks_snap; + long int dynticks_nesting; + long int dynticks_nmi_nesting; + atomic_t dynticks; + bool rcu_need_heavy_qs; + bool rcu_urgent_qs; + bool rcu_forced_tick; + struct callback_head barrier_head; + int exp_dynticks_snap; + struct task_struct *rcu_cpu_kthread_task; + unsigned int rcu_cpu_kthread_status; + char rcu_cpu_has_work; + unsigned int softirq_snap; + struct irq_work rcu_iw; + bool rcu_iw_pending; + long unsigned int rcu_iw_gp_seq; + long unsigned int rcu_ofl_gp_seq; + short int rcu_ofl_gp_flags; + long unsigned int rcu_onl_gp_seq; + short int rcu_onl_gp_flags; + long unsigned int last_fqs_resched; + int cpu; +}; + +struct rcu_state { + struct rcu_node node[5]; + struct rcu_node *level[3]; + int ncpus; + long: 32; long: 64; long: 64; long: 64; long: 64; + u8 boost; + long unsigned int gp_seq; + struct task_struct *gp_kthread; + struct swait_queue_head gp_wq; + short int gp_flags; + short int gp_state; + long unsigned int gp_wake_time; + long unsigned int gp_wake_seq; + struct mutex barrier_mutex; + atomic_t barrier_cpu_count; + struct completion barrier_completion; + long unsigned int barrier_sequence; + struct mutex exp_mutex; + struct mutex exp_wake_mutex; + long unsigned int expedited_sequence; + atomic_t expedited_need_qs; + struct swait_queue_head expedited_wq; + int ncpus_snap; + long unsigned int jiffies_force_qs; + long unsigned int jiffies_kick_kthreads; + long unsigned int n_force_qs; + long unsigned int gp_start; + long unsigned int gp_end; + long unsigned int gp_activity; + long unsigned int gp_req_activity; + long unsigned int jiffies_stall; + long unsigned int jiffies_resched; + long unsigned int n_force_qs_gpstart; + long unsigned int gp_max; + const char *name; + char abbr; + long: 56; long: 64; long: 64; + raw_spinlock_t ofl_lock; + long: 32; long: 64; long: 64; long: 64; @@ -25760,1290 +29969,1954 @@ struct swsusp_info { long: 64; long: 64; long: 64; +}; + +typedef char pto_T_____17; + +struct dma_devres { + size_t size; + void *vaddr; + dma_addr_t dma_handle; + long unsigned int attrs; +}; + +enum dma_sync_target { + SYNC_FOR_CPU = 0, + SYNC_FOR_DEVICE = 1, +}; + +struct trace_event_raw_swiotlb_bounced { + struct trace_entry ent; + u32 __data_loc_dev_name; + u64 dma_mask; + dma_addr_t dev_addr; + size_t size; + enum swiotlb_force swiotlb_force; + char __data[0]; +}; + +struct trace_event_data_offsets_swiotlb_bounced { + u32 dev_name; +}; + +typedef void (*btf_trace_swiotlb_bounced)(void *, struct device *, dma_addr_t, size_t, enum swiotlb_force); + +enum profile_type { + PROFILE_TASK_EXIT = 0, + PROFILE_MUNMAP = 1, +}; + +struct profile_hit { + u32 pc; + u32 hits; +}; + +struct stacktrace_cookie { + long unsigned int *store; + unsigned int size; + unsigned int skip; + unsigned int len; +}; + +typedef __kernel_long_t __kernel_suseconds_t; + +typedef __kernel_long_t __kernel_old_time_t; + +typedef __kernel_suseconds_t suseconds_t; + +typedef __u64 timeu64_t; + +struct __kernel_itimerspec { + struct __kernel_timespec it_interval; + struct __kernel_timespec it_value; +}; + +struct timespec { + __kernel_old_time_t tv_sec; + long int tv_nsec; +}; + +struct timeval { + __kernel_old_time_t tv_sec; + __kernel_suseconds_t tv_usec; +}; + +struct itimerspec64 { + struct timespec64 it_interval; + struct timespec64 it_value; +}; + +struct old_itimerspec32 { + struct old_timespec32 it_interval; + struct old_timespec32 it_value; +}; + +struct old_timex32 { + u32 modes; + s32 offset; + s32 freq; + s32 maxerror; + s32 esterror; + s32 status; + s32 constant; + s32 precision; + s32 tolerance; + struct old_timeval32 time; + s32 tick; + s32 ppsfreq; + s32 jitter; + s32 shift; + s32 stabil; + s32 jitcnt; + s32 calcnt; + s32 errcnt; + s32 stbcnt; + s32 tai; + long: 32; long: 64; long: 64; long: 64; long: 64; long: 64; +}; + +struct __kernel_timex_timeval { + __kernel_time64_t tv_sec; + long long int tv_usec; +}; + +struct __kernel_timex { + unsigned int modes; + long long int offset; + long long int freq; + long long int maxerror; + long long int esterror; + int status; + long long int constant; + long long int precision; + long long int tolerance; + struct __kernel_timex_timeval time; + long long int tick; + long long int ppsfreq; + long long int jitter; + int shift; + long long int stabil; + long long int jitcnt; + long long int calcnt; + long long int errcnt; + long long int stbcnt; + int tai; + long: 32; long: 64; long: 64; long: 64; long: 64; long: 64; +}; + +struct trace_event_raw_timer_class { + struct trace_entry ent; + void *timer; + char __data[0]; +}; + +struct trace_event_raw_timer_start { + struct trace_entry ent; + void *timer; + void *function; + long unsigned int expires; + long unsigned int now; + unsigned int flags; + char __data[0]; +}; + +struct trace_event_raw_timer_expire_entry { + struct trace_entry ent; + void *timer; + long unsigned int now; + void *function; + long unsigned int baseclk; + char __data[0]; +}; + +struct trace_event_raw_hrtimer_init { + struct trace_entry ent; + void *hrtimer; + clockid_t clockid; + enum hrtimer_mode mode; + char __data[0]; +}; + +struct trace_event_raw_hrtimer_start { + struct trace_entry ent; + void *hrtimer; + void *function; + s64 expires; + s64 softexpires; + enum hrtimer_mode mode; + char __data[0]; +}; + +struct trace_event_raw_hrtimer_expire_entry { + struct trace_entry ent; + void *hrtimer; + s64 now; + void *function; + char __data[0]; +}; + +struct trace_event_raw_hrtimer_class { + struct trace_entry ent; + void *hrtimer; + char __data[0]; +}; + +struct trace_event_raw_itimer_state { + struct trace_entry ent; + int which; + long long unsigned int expires; + long int value_sec; + long int value_nsec; + long int interval_sec; + long int interval_nsec; + char __data[0]; +}; + +struct trace_event_raw_itimer_expire { + struct trace_entry ent; + int which; + pid_t pid; + long long unsigned int now; + char __data[0]; +}; + +struct trace_event_raw_tick_stop { + struct trace_entry ent; + int success; + int dependency; + char __data[0]; +}; + +struct trace_event_data_offsets_timer_class {}; + +struct trace_event_data_offsets_timer_start {}; + +struct trace_event_data_offsets_timer_expire_entry {}; + +struct trace_event_data_offsets_hrtimer_init {}; + +struct trace_event_data_offsets_hrtimer_start {}; + +struct trace_event_data_offsets_hrtimer_expire_entry {}; + +struct trace_event_data_offsets_hrtimer_class {}; + +struct trace_event_data_offsets_itimer_state {}; + +struct trace_event_data_offsets_itimer_expire {}; + +struct trace_event_data_offsets_tick_stop {}; + +typedef void (*btf_trace_timer_init)(void *, struct timer_list *); + +typedef void (*btf_trace_timer_start)(void *, struct timer_list *, long unsigned int, unsigned int); + +typedef void (*btf_trace_timer_expire_entry)(void *, struct timer_list *, long unsigned int); + +typedef void (*btf_trace_timer_expire_exit)(void *, struct timer_list *); + +typedef void (*btf_trace_timer_cancel)(void *, struct timer_list *); + +typedef void (*btf_trace_hrtimer_init)(void *, struct hrtimer *, clockid_t, enum hrtimer_mode); + +typedef void (*btf_trace_hrtimer_start)(void *, struct hrtimer *, enum hrtimer_mode); + +typedef void (*btf_trace_hrtimer_expire_entry)(void *, struct hrtimer *, ktime_t *); + +typedef void (*btf_trace_hrtimer_expire_exit)(void *, struct hrtimer *); + +typedef void (*btf_trace_hrtimer_cancel)(void *, struct hrtimer *); + +typedef void (*btf_trace_itimer_state)(void *, int, const struct itimerspec64 * const, long long unsigned int); + +typedef void (*btf_trace_itimer_expire)(void *, int, struct pid *, long long unsigned int); + +typedef void (*btf_trace_tick_stop)(void *, int, int); + +struct timer_base { + raw_spinlock_t lock; + struct timer_list *running_timer; + long unsigned int clk; + long unsigned int next_expiry; + unsigned int cpu; + bool is_idle; + bool must_forward_clk; + long unsigned int pending_map[9]; + struct hlist_head vectors[576]; long: 64; long: 64; }; -struct snapshot_handle { - unsigned int cur; - void *buffer; - int sync_read; +struct process_timer { + struct timer_list timer; + struct task_struct *task; +}; + +struct system_time_snapshot { + u64 cycles; + ktime_t real; + ktime_t raw; + unsigned int clock_was_set_seq; + u8 cs_was_changed_seq; +}; + +struct system_device_crosststamp { + ktime_t device; + ktime_t sys_realtime; + ktime_t sys_monoraw; +}; + +struct tk_read_base { + struct clocksource *clock; + u64 mask; + u64 cycle_last; + u32 mult; + u32 shift; + u64 xtime_nsec; + ktime_t base; + u64 base_real; +}; + +struct timekeeper { + struct tk_read_base tkr_mono; + struct tk_read_base tkr_raw; + u64 xtime_sec; + long unsigned int ktime_sec; + struct timespec64 wall_to_monotonic; + ktime_t offs_real; + ktime_t offs_boot; + ktime_t offs_tai; + s32 tai_offset; + unsigned int clock_was_set_seq; + u8 cs_was_changed_seq; + ktime_t next_leap_ktime; + u64 raw_sec; + struct timespec64 monotonic_to_boot; + u64 cycle_interval; + u64 xtime_interval; + s64 xtime_remainder; + u64 raw_interval; + u64 ntp_tick; + s64 ntp_error; + u32 ntp_error_shift; + u32 ntp_err_mult; + u32 skip_second_overflow; +}; + +struct audit_ntp_val { + long long int oldval; + long long int newval; +}; + +struct audit_ntp_data { + struct audit_ntp_val vals[6]; +}; + +enum timekeeping_adv_mode { + TK_ADV_TICK = 0, + TK_ADV_FREQ = 1, +}; + +struct tk_fast { + seqcount_t seq; + struct tk_read_base base[2]; +}; + +typedef s64 int64_t; + +enum tick_nohz_mode { + NOHZ_MODE_INACTIVE = 0, + NOHZ_MODE_LOWRES = 1, + NOHZ_MODE_HIGHRES = 2, +}; + +struct tick_sched { + struct hrtimer sched_timer; + long unsigned int check_clocks; + enum tick_nohz_mode nohz_mode; + unsigned int inidle: 1; + unsigned int tick_stopped: 1; + unsigned int idle_active: 1; + unsigned int do_timer_last: 1; + unsigned int got_idle_tick: 1; + ktime_t last_tick; + ktime_t next_tick; + long unsigned int idle_jiffies; + long unsigned int idle_calls; + long unsigned int idle_sleeps; + ktime_t idle_entrytime; + ktime_t idle_waketime; + ktime_t idle_exittime; + ktime_t idle_sleeptime; + ktime_t iowait_sleeptime; + long unsigned int last_jiffies; + u64 timer_expires; + u64 timer_expires_base; + u64 next_timer; + ktime_t idle_expires; + atomic_t tick_dep_mask; +}; + +struct timer_list_iter { + int cpu; + bool second_pass; + u64 now; +}; + +struct tm { + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + long int tm_year; + int tm_wday; + int tm_yday; +}; + +struct cyclecounter { + u64 (*read)(const struct cyclecounter *); + u64 mask; + u32 mult; + u32 shift; +}; + +struct timecounter { + const struct cyclecounter *cc; + u64 cycle_last; + u64 nsec; + u64 mask; + u64 frac; +}; + +typedef __kernel_timer_t timer_t; + +struct rtc_wkalrm { + unsigned char enabled; + unsigned char pending; + struct rtc_time time; +}; + +enum alarmtimer_type { + ALARM_REALTIME = 0, + ALARM_BOOTTIME = 1, + ALARM_NUMTYPE = 2, + ALARM_REALTIME_FREEZER = 3, + ALARM_BOOTTIME_FREEZER = 4, +}; + +enum alarmtimer_restart { + ALARMTIMER_NORESTART = 0, + ALARMTIMER_RESTART = 1, +}; + +struct alarm { + struct timerqueue_node node; + struct hrtimer timer; + enum alarmtimer_restart (*function)(struct alarm *, ktime_t); + enum alarmtimer_type type; + int state; + void *data; +}; + +struct cpu_timer { + struct timerqueue_node node; + struct timerqueue_head *head; + struct task_struct *task; + struct list_head elist; + int firing; +}; + +struct k_clock; + +struct k_itimer { + struct list_head list; + struct hlist_node t_hash; + spinlock_t it_lock; + const struct k_clock *kclock; + clockid_t it_clock; + timer_t it_id; + int it_active; + s64 it_overrun; + s64 it_overrun_last; + int it_requeue_pending; + int it_sigev_notify; + ktime_t it_interval; + struct signal_struct *it_signal; + union { + struct pid *it_pid; + struct task_struct *it_process; + }; + struct sigqueue *sigq; + union { + struct { + struct hrtimer timer; + } real; + struct cpu_timer cpu; + struct { + struct alarm alarmtimer; + } alarm; + } it; + struct callback_head rcu; +}; + +struct k_clock { + int (*clock_getres)(const clockid_t, struct timespec64 *); + int (*clock_set)(const clockid_t, const struct timespec64 *); + int (*clock_get)(const clockid_t, struct timespec64 *); + int (*clock_adj)(const clockid_t, struct __kernel_timex *); + int (*timer_create)(struct k_itimer *); + int (*nsleep)(const clockid_t, int, const struct timespec64 *); + int (*timer_set)(struct k_itimer *, int, struct itimerspec64 *, struct itimerspec64 *); + int (*timer_del)(struct k_itimer *); + void (*timer_get)(struct k_itimer *, struct itimerspec64 *); + void (*timer_rearm)(struct k_itimer *); + s64 (*timer_forward)(struct k_itimer *, ktime_t); + ktime_t (*timer_remaining)(struct k_itimer *, ktime_t); + int (*timer_try_to_cancel)(struct k_itimer *); + void (*timer_arm)(struct k_itimer *, ktime_t, bool, bool); + void (*timer_wait_running)(struct k_itimer *); +}; + +struct class_interface { + struct list_head node; + struct class *class; + int (*add_dev)(struct device *, struct class_interface *); + void (*remove_dev)(struct device *, struct class_interface *); +}; + +struct rtc_class_ops { + int (*ioctl)(struct device *, unsigned int, long unsigned int); + int (*read_time)(struct device *, struct rtc_time *); + int (*set_time)(struct device *, struct rtc_time *); + int (*read_alarm)(struct device *, struct rtc_wkalrm *); + int (*set_alarm)(struct device *, struct rtc_wkalrm *); + int (*proc)(struct device *, struct seq_file *); + int (*alarm_irq_enable)(struct device *, unsigned int); + int (*read_offset)(struct device *, long int *); + int (*set_offset)(struct device *, long int); }; -struct linked_page { - struct linked_page *next; - char data[4088]; +struct rtc_device; + +struct rtc_timer { + struct timerqueue_node node; + ktime_t period; + void (*func)(struct rtc_device *); + struct rtc_device *rtc; + int enabled; }; -struct chain_allocator { - struct linked_page *chain; - unsigned int used_space; - gfp_t gfp_mask; - int safe_needed; +struct rtc_device { + struct device dev; + struct module *owner; + int id; + const struct rtc_class_ops *ops; + struct mutex ops_lock; + struct cdev char_dev; + long unsigned int flags; + long unsigned int irq_data; + spinlock_t irq_lock; + wait_queue_head_t irq_queue; + struct fasync_struct *async_queue; + int irq_freq; + int max_user_freq; + struct timerqueue_head timerqueue; + struct rtc_timer aie_timer; + struct rtc_timer uie_rtctimer; + struct hrtimer pie_timer; + int pie_enabled; + struct work_struct irqwork; + int uie_unsupported; + long int set_offset_nsec; + bool registered; + bool nvram_old_abi; + struct bin_attribute *nvram; + time64_t range_min; + timeu64_t range_max; + time64_t start_secs; + time64_t offset_secs; + bool set_start_time; }; -struct rtree_node { - struct list_head list; - long unsigned int *data; +struct platform_driver { + int (*probe)(struct platform_device *); + int (*remove)(struct platform_device *); + void (*shutdown)(struct platform_device *); + int (*suspend)(struct platform_device *, pm_message_t); + int (*resume)(struct platform_device *); + struct device_driver driver; + const struct platform_device_id *id_table; + bool prevent_deferred_probe; }; -struct mem_zone_bm_rtree { - struct list_head list; - struct list_head nodes; - struct list_head leaves; - long unsigned int start_pfn; - long unsigned int end_pfn; - struct rtree_node *rtree; - int levels; - unsigned int blocks; +struct trace_event_raw_alarmtimer_suspend { + struct trace_entry ent; + s64 expires; + unsigned char alarm_type; + char __data[0]; }; -struct bm_position { - struct mem_zone_bm_rtree *zone; - struct rtree_node *node; - long unsigned int node_pfn; - int node_bit; +struct trace_event_raw_alarm_class { + struct trace_entry ent; + void *alarm; + unsigned char alarm_type; + s64 expires; + s64 now; + char __data[0]; }; -struct memory_bitmap { - struct list_head zones; - struct linked_page *p_list; - struct bm_position cur; +struct trace_event_data_offsets_alarmtimer_suspend {}; + +struct trace_event_data_offsets_alarm_class {}; + +typedef void (*btf_trace_alarmtimer_suspend)(void *, ktime_t, int); + +typedef void (*btf_trace_alarmtimer_fired)(void *, struct alarm *, ktime_t); + +typedef void (*btf_trace_alarmtimer_start)(void *, struct alarm *, ktime_t); + +typedef void (*btf_trace_alarmtimer_cancel)(void *, struct alarm *, ktime_t); + +struct alarm_base { + spinlock_t lock; + struct timerqueue_head timerqueue; + ktime_t (*gettime)(); + clockid_t base_clockid; }; -struct mem_extent { - struct list_head hook; - long unsigned int start; - long unsigned int end; +struct sigevent { + sigval_t sigev_value; + int sigev_signo; + int sigev_notify; + union { + int _pad[12]; + int _tid; + struct { + void (*_function)(sigval_t); + void *_attribute; + } _sigev_thread; + } _sigev_un; }; -struct nosave_region { - struct list_head list; - long unsigned int start_pfn; - long unsigned int end_pfn; +typedef struct sigevent sigevent_t; + +struct compat_sigevent { + compat_sigval_t sigev_value; + compat_int_t sigev_signo; + compat_int_t sigev_notify; + union { + compat_int_t _pad[13]; + compat_int_t _tid; + struct { + compat_uptr_t _function; + compat_uptr_t _attribute; + } _sigev_thread; + } _sigev_un; }; -typedef struct { - long unsigned int val; -} swp_entry_t; +typedef unsigned int uint; -enum { - BIO_NO_PAGE_REF = 0, - BIO_CLONED = 1, - BIO_BOUNCED = 2, - BIO_USER_MAPPED = 3, - BIO_NULL_MAPPED = 4, - BIO_WORKINGSET = 5, - BIO_QUIET = 6, - BIO_CHAIN = 7, - BIO_REFFED = 8, - BIO_THROTTLED = 9, - BIO_TRACE_COMPLETION = 10, - BIO_QUEUE_ENTERED = 11, - BIO_TRACKED = 12, - BIO_FLAG_LAST = 13, +struct posix_clock; + +struct posix_clock_operations { + struct module *owner; + int (*clock_adjtime)(struct posix_clock *, struct __kernel_timex *); + int (*clock_gettime)(struct posix_clock *, struct timespec64 *); + int (*clock_getres)(struct posix_clock *, struct timespec64 *); + int (*clock_settime)(struct posix_clock *, const struct timespec64 *); + long int (*ioctl)(struct posix_clock *, unsigned int, long unsigned int); + int (*open)(struct posix_clock *, fmode_t); + __poll_t (*poll)(struct posix_clock *, struct file *, poll_table *); + int (*release)(struct posix_clock *); + ssize_t (*read)(struct posix_clock *, uint, char *, size_t); }; -enum req_opf { - REQ_OP_READ = 0, - REQ_OP_WRITE = 1, - REQ_OP_FLUSH = 2, - REQ_OP_DISCARD = 3, - REQ_OP_SECURE_ERASE = 5, - REQ_OP_ZONE_RESET = 6, - REQ_OP_WRITE_SAME = 7, - REQ_OP_ZONE_RESET_ALL = 8, - REQ_OP_WRITE_ZEROES = 9, - REQ_OP_ZONE_OPEN = 10, - REQ_OP_ZONE_CLOSE = 11, - REQ_OP_ZONE_FINISH = 12, - REQ_OP_SCSI_IN = 32, - REQ_OP_SCSI_OUT = 33, - REQ_OP_DRV_IN = 34, - REQ_OP_DRV_OUT = 35, - REQ_OP_LAST = 36, +struct posix_clock { + struct posix_clock_operations ops; + struct cdev cdev; + struct device *dev; + struct rw_semaphore rwsem; + bool zombie; }; -enum req_flag_bits { - __REQ_FAILFAST_DEV = 8, - __REQ_FAILFAST_TRANSPORT = 9, - __REQ_FAILFAST_DRIVER = 10, - __REQ_SYNC = 11, - __REQ_META = 12, - __REQ_PRIO = 13, - __REQ_NOMERGE = 14, - __REQ_IDLE = 15, - __REQ_INTEGRITY = 16, - __REQ_FUA = 17, - __REQ_PREFLUSH = 18, - __REQ_RAHEAD = 19, - __REQ_BACKGROUND = 20, - __REQ_NOWAIT = 21, - __REQ_NOWAIT_INLINE = 22, - __REQ_CGROUP_PUNT = 23, - __REQ_NOUNMAP = 24, - __REQ_HIPRI = 25, - __REQ_DRV = 26, - __REQ_SWAP = 27, - __REQ_NR_BITS = 28, +struct posix_clock_desc { + struct file *fp; + struct posix_clock *clk; }; -struct swap_map_page { - sector_t entries[511]; - sector_t next_swap; +struct itimerval { + struct timeval it_interval; + struct timeval it_value; }; -struct swap_map_page_list { - struct swap_map_page *map; - struct swap_map_page_list *next; +struct old_itimerval32 { + struct old_timeval32 it_interval; + struct old_timeval32 it_value; }; -struct swap_map_handle { - struct swap_map_page *cur; - struct swap_map_page_list *maps; - sector_t cur_swap; - sector_t first_sector; - unsigned int k; - long unsigned int reqd_free_pages; - u32 crc32; +struct ce_unbind { + struct clock_event_device *ce; + int res; }; -struct swsusp_header { - char reserved[4060]; - u32 crc32; - sector_t image; - unsigned int flags; - char orig_sig[10]; - char sig[10]; +typedef ktime_t pto_T_____18; + +union futex_key { + struct { + long unsigned int pgoff; + struct inode *inode; + int offset; + } shared; + struct { + long unsigned int address; + struct mm_struct *mm; + int offset; + } private; + struct { + long unsigned int word; + void *ptr; + int offset; + } both; }; -struct swsusp_extent { - struct rb_node node; - long unsigned int start; - long unsigned int end; +struct futex_pi_state { + struct list_head list; + struct rt_mutex pi_mutex; + struct task_struct *owner; + refcount_t refcount; + union futex_key key; }; -struct hib_bio_batch { - atomic_t count; - wait_queue_head_t wait; - blk_status_t error; +struct futex_q { + struct plist_node list; + struct task_struct *task; + spinlock_t *lock_ptr; + union futex_key key; + struct futex_pi_state *pi_state; + struct rt_mutex_waiter *rt_waiter; + union futex_key *requeue_pi_key; + u32 bitset; }; -struct crc_data { - struct task_struct *thr; - atomic_t ready; - atomic_t stop; - unsigned int run_threads; - wait_queue_head_t go; - wait_queue_head_t done; - u32 *crc32; - size_t *unc_len[3]; - unsigned char *unc[3]; +struct futex_hash_bucket { + atomic_t waiters; + spinlock_t lock; + struct plist_head chain; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct cmp_data { - struct task_struct *thr; - atomic_t ready; - atomic_t stop; - int ret; - wait_queue_head_t go; - wait_queue_head_t done; - size_t unc_len; - size_t cmp_len; - unsigned char unc[131072]; - unsigned char cmp[143360]; - unsigned char wrk[16384]; +enum futex_access { + FUTEX_READ = 0, + FUTEX_WRITE = 1, }; -struct dec_data { - struct task_struct *thr; - atomic_t ready; - atomic_t stop; - int ret; - wait_queue_head_t go; - wait_queue_head_t done; - size_t unc_len; - size_t cmp_len; - unsigned char unc[131072]; - unsigned char cmp[143360]; +struct dma_chan { + int lock; + const char *device_id; }; -typedef s64 compat_loff_t; +enum { + CSD_FLAG_LOCK = 1, + CSD_FLAG_SYNCHRONOUS = 2, +}; -struct resume_swap_area { - __kernel_loff_t offset; - __u32 dev; -} __attribute__((packed)); +struct call_function_data { + call_single_data_t *csd; + cpumask_var_t cpumask; + cpumask_var_t cpumask_ipi; +}; -struct snapshot_data { - struct snapshot_handle handle; - int swap; - int mode; - bool frozen; - bool ready; - bool platform_support; - bool free_bitmaps; +struct smp_call_on_cpu_struct { + struct work_struct work; + struct completion done; + int (*func)(void *); + void *data; + int ret; + int cpu; }; -struct compat_resume_swap_area { - compat_loff_t offset; - u32 dev; -} __attribute__((packed)); +struct latch_tree_root { + seqcount_t seq; + struct rb_root tree[2]; +}; -struct sysrq_key_op { - void (*handler)(int); - char *help_msg; - char *action_msg; - int enable_mask; +struct latch_tree_ops { + bool (*less)(struct latch_tree_node *, struct latch_tree_node *); + int (*comp)(void *, struct latch_tree_node *); }; -struct kmsg_dumper { - struct list_head list; - void (*dump)(struct kmsg_dumper *, enum kmsg_dump_reason); - enum kmsg_dump_reason max_reason; - bool active; - bool registered; - u32 cur_idx; - u32 next_idx; - u64 cur_seq; - u64 next_seq; +struct module_use { + struct list_head source_list; + struct list_head target_list; + struct module *source; + struct module *target; }; -struct trace_event_raw_console { - struct trace_entry ent; - u32 __data_loc_msg; - char __data[0]; +struct module_sect_attr { + struct module_attribute mattr; + char *name; + long unsigned int address; }; -struct trace_event_data_offsets_console { - u32 msg; +struct module_sect_attrs { + struct attribute_group grp; + unsigned int nsections; + struct module_sect_attr attrs[0]; }; -struct console_cmdline { - char name[16]; - int index; - char *options; +struct module_notes_attrs { + struct kobject *dir; + unsigned int notes; + struct bin_attribute attrs[0]; }; -enum devkmsg_log_bits { - __DEVKMSG_LOG_BIT_ON = 0, - __DEVKMSG_LOG_BIT_OFF = 1, - __DEVKMSG_LOG_BIT_LOCK = 2, +struct symsearch { + const struct kernel_symbol *start; + const struct kernel_symbol *stop; + const s32 *crcs; + enum { + NOT_GPL_ONLY = 0, + GPL_ONLY = 1, + WILL_BE_GPL_ONLY = 2, + } licence; + bool unused; }; -enum devkmsg_log_masks { - DEVKMSG_LOG_MASK_ON = 1, - DEVKMSG_LOG_MASK_OFF = 2, - DEVKMSG_LOG_MASK_LOCK = 4, +enum kernel_read_file_id { + READING_UNKNOWN = 0, + READING_FIRMWARE = 1, + READING_FIRMWARE_PREALLOC_BUFFER = 2, + READING_MODULE = 3, + READING_KEXEC_IMAGE = 4, + READING_KEXEC_INITRAMFS = 5, + READING_POLICY = 6, + READING_X509_CERTIFICATE = 7, + READING_MAX_ID = 8, }; -enum con_msg_format_flags { - MSG_FORMAT_DEFAULT = 0, - MSG_FORMAT_SYSLOG = 1, +enum kernel_load_data_id { + LOADING_UNKNOWN = 0, + LOADING_FIRMWARE = 1, + LOADING_FIRMWARE_PREALLOC_BUFFER = 2, + LOADING_MODULE = 3, + LOADING_KEXEC_IMAGE = 4, + LOADING_KEXEC_INITRAMFS = 5, + LOADING_POLICY = 6, + LOADING_X509_CERTIFICATE = 7, + LOADING_MAX_ID = 8, +}; + +struct _ddebug { + const char *modname; + const char *function; + const char *filename; + const char *format; + unsigned int lineno: 18; + unsigned int flags: 8; + union { + struct static_key_true dd_key_true; + struct static_key_false dd_key_false; + } key; +}; + +struct load_info { + const char *name; + struct module *mod; + Elf64_Ehdr *hdr; + long unsigned int len; + Elf64_Shdr *sechdrs; + char *secstrings; + char *strtab; + long unsigned int symoffs; + long unsigned int stroffs; + long unsigned int init_typeoffs; + long unsigned int core_typeoffs; + struct _ddebug *debug; + unsigned int num_debug; + bool sig_ok; + long unsigned int mod_kallsyms_init_off; + struct { + unsigned int sym; + unsigned int str; + unsigned int mod; + unsigned int vers; + unsigned int info; + unsigned int pcpu; + } index; }; -enum log_flags { - LOG_NEWLINE = 2, - LOG_CONT = 8, +struct trace_event_raw_module_load { + struct trace_entry ent; + unsigned int taints; + u32 __data_loc_name; + char __data[0]; }; -struct printk_log { - u64 ts_nsec; - u16 len; - u16 text_len; - u16 dict_len; - u8 facility; - u8 flags: 5; - u8 level: 3; +struct trace_event_raw_module_free { + struct trace_entry ent; + u32 __data_loc_name; + char __data[0]; }; -struct devkmsg_user { - u64 seq; - u32 idx; - struct ratelimit_state rs; - struct mutex lock; - char buf[8192]; +struct trace_event_raw_module_refcnt { + struct trace_entry ent; + long unsigned int ip; + int refcnt; + u32 __data_loc_name; + char __data[0]; }; -struct cont { - char buf[992]; - size_t len; - u32 caller_id; - u64 ts_nsec; - u8 level; - u8 facility; - enum log_flags flags; +struct trace_event_raw_module_request { + struct trace_entry ent; + long unsigned int ip; + bool wait; + u32 __data_loc_name; + char __data[0]; }; -struct printk_safe_seq_buf { - atomic_t len; - atomic_t message_lost; - struct irq_work work; - unsigned char buffer[8160]; +struct trace_event_data_offsets_module_load { + u32 name; }; -enum { - IRQS_AUTODETECT = 1, - IRQS_SPURIOUS_DISABLED = 2, - IRQS_POLL_INPROGRESS = 8, - IRQS_ONESHOT = 32, - IRQS_REPLAY = 64, - IRQS_WAITING = 128, - IRQS_PENDING = 512, - IRQS_SUSPENDED = 2048, - IRQS_TIMINGS = 4096, - IRQS_NMI = 8192, +struct trace_event_data_offsets_module_free { + u32 name; }; -enum { - _IRQ_DEFAULT_INIT_FLAGS = 0, - _IRQ_PER_CPU = 512, - _IRQ_LEVEL = 256, - _IRQ_NOPROBE = 1024, - _IRQ_NOREQUEST = 2048, - _IRQ_NOTHREAD = 65536, - _IRQ_NOAUTOEN = 4096, - _IRQ_MOVE_PCNTXT = 16384, - _IRQ_NO_BALANCING = 8192, - _IRQ_NESTED_THREAD = 32768, - _IRQ_PER_CPU_DEVID = 131072, - _IRQ_IS_POLLED = 262144, - _IRQ_DISABLE_UNLAZY = 524288, - _IRQF_MODIFY_MASK = 1048335, +struct trace_event_data_offsets_module_refcnt { + u32 name; }; -enum { - IRQTF_RUNTHREAD = 0, - IRQTF_WARNED = 1, - IRQTF_AFFINITY = 2, - IRQTF_FORCED_THREAD = 3, +struct trace_event_data_offsets_module_request { + u32 name; }; -enum { - IRQC_IS_HARDIRQ = 0, - IRQC_IS_NESTED = 1, -}; +typedef void (*btf_trace_module_load)(void *, struct module *); -enum { - IRQ_STARTUP_NORMAL = 0, - IRQ_STARTUP_MANAGED = 1, - IRQ_STARTUP_ABORT = 2, -}; +typedef void (*btf_trace_module_free)(void *, struct module *); -struct irq_devres { - unsigned int irq; - void *dev_id; -}; +typedef void (*btf_trace_module_get)(void *, struct module *, long unsigned int); -struct irq_desc_devres { - unsigned int from; - unsigned int cnt; -}; +typedef void (*btf_trace_module_put)(void *, struct module *, long unsigned int); -enum { - IRQ_DOMAIN_FLAG_HIERARCHY = 1, - IRQ_DOMAIN_NAME_ALLOCATED = 64, - IRQ_DOMAIN_FLAG_IPI_PER_CPU = 4, - IRQ_DOMAIN_FLAG_IPI_SINGLE = 8, - IRQ_DOMAIN_FLAG_MSI = 16, - IRQ_DOMAIN_FLAG_MSI_REMAP = 32, - IRQ_DOMAIN_FLAG_NONCORE = 65536, -}; +typedef void (*btf_trace_module_request)(void *, char *, bool, long unsigned int); -typedef u64 acpi_size; +struct mod_tree_root { + struct latch_tree_root root; + long unsigned int addr_min; + long unsigned int addr_max; +}; -struct acpi_buffer { - acpi_size length; - void *pointer; +struct find_symbol_arg { + const char *name; + bool gplok; + bool warn; + struct module *owner; + const s32 *crc; + const struct kernel_symbol *sym; }; -struct acpi_hotplug_profile { - struct kobject kobj; - int (*scan_dependent)(struct acpi_device *); - void (*notify_online)(struct acpi_device *); - bool enabled: 1; - bool demand_offline: 1; +struct mod_initfree { + struct llist_node node; + void *module_init; }; -struct acpi_device_status { - u32 present: 1; - u32 enabled: 1; - u32 show_in_ui: 1; - u32 functional: 1; - u32 battery_present: 1; - u32 reserved: 27; +struct kallsym_iter { + loff_t pos; + loff_t pos_arch_end; + loff_t pos_mod_end; + loff_t pos_ftrace_mod_end; + long unsigned int value; + unsigned int nameoff; + char type; + char name[128]; + char module_name[56]; + int exported; + int show_value; }; -struct acpi_device_flags { - u32 dynamic_status: 1; - u32 removable: 1; - u32 ejectable: 1; - u32 power_manageable: 1; - u32 match_driver: 1; - u32 initialized: 1; - u32 visited: 1; - u32 hotplug_notify: 1; - u32 is_dock_station: 1; - u32 of_compatible_ok: 1; - u32 coherent_dma: 1; - u32 cca_seen: 1; - u32 enumeration_by_parent: 1; - u32 reserved: 19; +enum { + SB_UNFROZEN = 0, + SB_FREEZE_WRITE = 1, + SB_FREEZE_PAGEFAULT = 2, + SB_FREEZE_FS = 3, + SB_FREEZE_COMPLETE = 4, }; -typedef char acpi_bus_id[8]; +struct audit_names; -struct acpi_pnp_type { - u32 hardware_id: 1; - u32 bus_address: 1; - u32 platform_id: 1; - u32 reserved: 29; +struct filename { + const char *name; + const char *uptr; + int refcnt; + struct audit_names *aname; + const char iname[0]; }; -typedef u64 acpi_bus_address; +typedef __u16 comp_t; -typedef char acpi_device_name[40]; +typedef __u32 comp2_t; -typedef char acpi_device_class[20]; +struct acct { + char ac_flag; + char ac_version; + __u16 ac_uid16; + __u16 ac_gid16; + __u16 ac_tty; + __u32 ac_btime; + comp_t ac_utime; + comp_t ac_stime; + comp_t ac_etime; + comp_t ac_mem; + comp_t ac_io; + comp_t ac_rw; + comp_t ac_minflt; + comp_t ac_majflt; + comp_t ac_swaps; + __u16 ac_ahz; + __u32 ac_exitcode; + char ac_comm[17]; + __u8 ac_etime_hi; + __u16 ac_etime_lo; + __u32 ac_uid; + __u32 ac_gid; +}; -struct acpi_device_pnp { - acpi_bus_id bus_id; - struct acpi_pnp_type type; - acpi_bus_address bus_address; - char *unique_id; - struct list_head ids; - acpi_device_name device_name; - acpi_device_class device_class; - union acpi_object *str_obj; +typedef struct acct acct_t; + +struct fs_pin { + wait_queue_head_t wait; + int done; + struct hlist_node s_list; + struct hlist_node m_list; + void (*kill)(struct fs_pin *); }; -struct acpi_device_power_flags { - u32 explicit_get: 1; - u32 power_resources: 1; - u32 inrush_current: 1; - u32 power_removed: 1; - u32 ignore_parent: 1; - u32 dsw_present: 1; - u32 reserved: 26; +struct bsd_acct_struct { + struct fs_pin pin; + atomic_long_t count; + struct callback_head rcu; + struct mutex lock; + int active; + long unsigned int needcheck; + struct file *file; + struct pid_namespace *ns; + struct work_struct work; + struct completion done; }; -struct acpi_device_power_state { - struct { - u8 valid: 1; - u8 explicit_set: 1; - u8 reserved: 6; - } flags; - int power; - int latency; - struct list_head resources; +enum compound_dtor_id { + NULL_COMPOUND_DTOR = 0, + COMPOUND_PAGE_DTOR = 1, + HUGETLB_PAGE_DTOR = 2, + NR_COMPOUND_DTORS = 3, }; -struct acpi_device_power { - int state; - struct acpi_device_power_flags flags; - struct acpi_device_power_state states[5]; +struct elf64_note { + Elf64_Word n_namesz; + Elf64_Word n_descsz; + Elf64_Word n_type; }; -struct acpi_device_wakeup_flags { - u8 valid: 1; - u8 notifier_present: 1; +typedef long unsigned int elf_greg_t; + +typedef elf_greg_t elf_gregset_t[27]; + +struct elf_siginfo { + int si_signo; + int si_code; + int si_errno; }; -struct acpi_device_wakeup_context { - void (*func)(struct acpi_device_wakeup_context *); - struct device *dev; +struct elf_prstatus { + struct elf_siginfo pr_info; + short int pr_cursig; + long unsigned int pr_sigpend; + long unsigned int pr_sighold; + pid_t pr_pid; + pid_t pr_ppid; + pid_t pr_pgrp; + pid_t pr_sid; + struct __kernel_old_timeval pr_utime; + struct __kernel_old_timeval pr_stime; + struct __kernel_old_timeval pr_cutime; + struct __kernel_old_timeval pr_cstime; + elf_gregset_t pr_reg; + int pr_fpvalid; }; -struct acpi_device_wakeup { - acpi_handle gpe_device; - u64 gpe_number; - u64 sleep_state; - struct list_head resources; - struct acpi_device_wakeup_flags flags; - struct acpi_device_wakeup_context context; - struct wakeup_source *ws; - int prepare_count; - int enable_count; +struct compat_kexec_segment { + compat_uptr_t buf; + compat_size_t bufsz; + compat_ulong_t mem; + compat_size_t memsz; }; -struct acpi_device_perf_flags { - u8 reserved: 8; +enum migrate_reason { + MR_COMPACTION = 0, + MR_MEMORY_FAILURE = 1, + MR_MEMORY_HOTPLUG = 2, + MR_SYSCALL = 3, + MR_MEMPOLICY_MBIND = 4, + MR_NUMA_MISPLACED = 5, + MR_CONTIG_RANGE = 6, + MR_TYPES = 7, }; -struct acpi_device_perf_state; +typedef __kernel_ulong_t __kernel_ino_t; -struct acpi_device_perf { - int state; - struct acpi_device_perf_flags flags; - int state_count; - struct acpi_device_perf_state *states; -}; +typedef __kernel_ino_t ino_t; -struct acpi_device_dir { - struct proc_dir_entry *entry; +enum fs_context_purpose { + FS_CONTEXT_FOR_MOUNT = 0, + FS_CONTEXT_FOR_SUBMOUNT = 1, + FS_CONTEXT_FOR_RECONFIGURE = 2, }; -struct acpi_device_data { - const union acpi_object *pointer; - struct list_head properties; - const union acpi_object *of_compatible; - struct list_head subnodes; +enum fs_context_phase { + FS_CONTEXT_CREATE_PARAMS = 0, + FS_CONTEXT_CREATING = 1, + FS_CONTEXT_AWAITING_MOUNT = 2, + FS_CONTEXT_AWAITING_RECONF = 3, + FS_CONTEXT_RECONF_PARAMS = 4, + FS_CONTEXT_RECONFIGURING = 5, + FS_CONTEXT_FAILED = 6, }; -struct acpi_scan_handler; - -struct acpi_hotplug_context; - -struct acpi_driver; +struct fs_context_operations; -struct acpi_gpio_mapping; +struct fc_log; -struct acpi_device { - int device_type; - acpi_handle handle; - struct fwnode_handle fwnode; - struct acpi_device *parent; - struct list_head children; - struct list_head node; - struct list_head wakeup_list; - struct list_head del_list; - struct acpi_device_status status; - struct acpi_device_flags flags; - struct acpi_device_pnp pnp; - struct acpi_device_power power; - struct acpi_device_wakeup wakeup; - struct acpi_device_perf performance; - struct acpi_device_dir dir; - struct acpi_device_data data; - struct acpi_scan_handler *handler; - struct acpi_hotplug_context *hp; - struct acpi_driver *driver; - const struct acpi_gpio_mapping *driver_gpios; - void *driver_data; - struct device dev; - unsigned int physical_node_count; - unsigned int dep_unmet; - struct list_head physical_node_list; - struct mutex physical_node_lock; - void (*remove)(struct acpi_device *); +struct fs_context { + const struct fs_context_operations *ops; + struct mutex uapi_mutex; + struct file_system_type *fs_type; + void *fs_private; + void *sget_key; + struct dentry *root; + struct user_namespace *user_ns; + struct net *net_ns; + const struct cred *cred; + struct fc_log *log; + const char *source; + void *security; + void *s_fs_info; + unsigned int sb_flags; + unsigned int sb_flags_mask; + unsigned int s_iflags; + unsigned int lsm_flags; + enum fs_context_purpose purpose: 8; + enum fs_context_phase phase: 8; + bool need_free: 1; + bool global: 1; }; -struct acpi_scan_handler { - const struct acpi_device_id *ids; - struct list_head list_node; - bool (*match)(const char *, const struct acpi_device_id **); - int (*attach)(struct acpi_device *, const struct acpi_device_id *); - void (*detach)(struct acpi_device *); - void (*bind)(struct device *); - void (*unbind)(struct device *); - struct acpi_hotplug_profile hotplug; +enum kernfs_node_type { + KERNFS_DIR = 1, + KERNFS_FILE = 2, + KERNFS_LINK = 4, }; -struct acpi_hotplug_context { - struct acpi_device *self; - int (*notify)(struct acpi_device *, u32); - void (*uevent)(struct acpi_device *, u32); - void (*fixup)(struct acpi_device *); +enum kernfs_root_flag { + KERNFS_ROOT_CREATE_DEACTIVATED = 1, + KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK = 2, + KERNFS_ROOT_SUPPORT_EXPORTOP = 4, }; -typedef int (*acpi_op_add)(struct acpi_device *); - -typedef int (*acpi_op_remove)(struct acpi_device *); - -typedef void (*acpi_op_notify)(struct acpi_device *, u32); - -struct acpi_device_ops { - acpi_op_add add; - acpi_op_remove remove; - acpi_op_notify notify; +struct kernfs_fs_context { + struct kernfs_root *root; + void *ns_tag; + long unsigned int magic; + bool new_sb_created; }; -struct acpi_driver { - char name[80]; - char class[80]; - const struct acpi_device_id *ids; - unsigned int flags; - struct acpi_device_ops ops; - struct device_driver drv; - struct module *owner; +enum { + __PERCPU_REF_ATOMIC = 1, + __PERCPU_REF_DEAD = 2, + __PERCPU_REF_ATOMIC_DEAD = 3, + __PERCPU_REF_FLAG_BITS = 2, }; -struct acpi_device_perf_state { - struct { - u8 valid: 1; - u8 reserved: 7; - } flags; - u8 power; - u8 performance; - int latency; +enum { + CSS_NO_REF = 1, + CSS_ONLINE = 2, + CSS_RELEASED = 4, + CSS_VISIBLE = 8, + CSS_DYING = 16, }; -struct acpi_gpio_params; +enum { + CGRP_NOTIFY_ON_RELEASE = 0, + CGRP_CPUSET_CLONE_CHILDREN = 1, + CGRP_FREEZE = 2, + CGRP_FROZEN = 3, +}; -struct acpi_gpio_mapping { - const char *name; - const struct acpi_gpio_params *data; - unsigned int size; - unsigned int quirks; +enum { + CGRP_ROOT_NOPREFIX = 2, + CGRP_ROOT_XATTR = 4, + CGRP_ROOT_NS_DELEGATE = 8, + CGRP_ROOT_CPUSET_V2_MODE = 16, + CGRP_ROOT_MEMORY_LOCAL_EVENTS = 32, }; -struct irqchip_fwid { - struct fwnode_handle fwnode; - unsigned int type; - char *name; - phys_addr_t *pa; +struct cgroup_taskset { + struct list_head src_csets; + struct list_head dst_csets; + int nr_tasks; + int ssid; + struct list_head *csets; + struct css_set *cur_cset; + struct task_struct *cur_task; }; -enum { - AFFINITY = 0, - AFFINITY_LIST = 1, - EFFECTIVE = 2, - EFFECTIVE_LIST = 3, +struct css_task_iter { + struct cgroup_subsys *ss; + unsigned int flags; + struct list_head *cset_pos; + struct list_head *cset_head; + struct list_head *tcset_pos; + struct list_head *tcset_head; + struct list_head *task_pos; + struct list_head *tasks_head; + struct list_head *mg_tasks_head; + struct list_head *dying_tasks_head; + struct css_set *cur_cset; + struct css_set *cur_dcset; + struct task_struct *cur_task; + struct list_head iters_node; }; -struct irq_affinity { - unsigned int pre_vectors; - unsigned int post_vectors; - unsigned int nr_sets; - unsigned int set_size[4]; - void (*calc_sets)(struct irq_affinity *, unsigned int); - void *priv; +enum fs_value_type { + fs_value_is_undefined = 0, + fs_value_is_flag = 1, + fs_value_is_string = 2, + fs_value_is_blob = 3, + fs_value_is_filename = 4, + fs_value_is_filename_empty = 5, + fs_value_is_file = 6, }; -struct node_vectors { - unsigned int id; +struct fs_parameter { + const char *key; + enum fs_value_type type: 8; union { - unsigned int nvectors; - unsigned int ncpus; + char *string; + void *blob; + struct filename *name; + struct file *file; }; + size_t size; + int dirfd; }; -struct cpumap { - unsigned int available; - unsigned int allocated; - unsigned int managed; - unsigned int managed_allocated; - bool initialized; - bool online; - long unsigned int alloc_map[4]; - long unsigned int managed_map[4]; +struct fs_context_operations { + void (*free)(struct fs_context *); + int (*dup)(struct fs_context *, struct fs_context *); + int (*parse_param)(struct fs_context *, struct fs_parameter *); + int (*parse_monolithic)(struct fs_context *, void *); + int (*get_tree)(struct fs_context *); + int (*reconfigure)(struct fs_context *); }; -struct irq_matrix___2 { - unsigned int matrix_bits; - unsigned int alloc_start; - unsigned int alloc_end; - unsigned int alloc_size; - unsigned int global_available; - unsigned int global_reserved; - unsigned int systembits_inalloc; - unsigned int total_allocated; - unsigned int online_maps; - struct cpumap *maps; - long unsigned int scratch_map[4]; - long unsigned int system_map[4]; +struct fc_log { + refcount_t usage; + u8 head; + u8 tail; + u8 need_free; + struct module *owner; + char *buffer[8]; }; -struct trace_event_raw_irq_matrix_global { - struct trace_entry ent; - unsigned int online_maps; - unsigned int global_available; - unsigned int global_reserved; - unsigned int total_allocated; - char __data[0]; +struct cgroup_fs_context { + struct kernfs_fs_context kfc; + struct cgroup_root *root; + struct cgroup_namespace *ns; + unsigned int flags; + bool cpuset_clone_children; + bool none; + bool all_ss; + u16 subsys_mask; + char *name; + char *release_agent; }; -struct trace_event_raw_irq_matrix_global_update { - struct trace_entry ent; - int bit; - unsigned int online_maps; - unsigned int global_available; - unsigned int global_reserved; - unsigned int total_allocated; - char __data[0]; +struct cgrp_cset_link { + struct cgroup *cgrp; + struct css_set *cset; + struct list_head cset_link; + struct list_head cgrp_link; }; -struct trace_event_raw_irq_matrix_cpu { - struct trace_entry ent; - int bit; - unsigned int cpu; - bool online; - unsigned int available; - unsigned int allocated; - unsigned int managed; - unsigned int online_maps; - unsigned int global_available; - unsigned int global_reserved; - unsigned int total_allocated; - char __data[0]; +struct cgroup_mgctx { + struct list_head preloaded_src_csets; + struct list_head preloaded_dst_csets; + struct cgroup_taskset tset; + u16 ss_mask; }; -struct trace_event_data_offsets_irq_matrix_global {}; - -struct trace_event_data_offsets_irq_matrix_global_update {}; - -struct trace_event_data_offsets_irq_matrix_cpu {}; - -typedef void (*call_rcu_func_t)(struct callback_head *, rcu_callback_t); - -struct rcu_synchronize { - struct callback_head head; - struct completion completion; +enum fs_parameter_type { + __fs_param_wasnt_defined = 0, + fs_param_is_flag = 1, + fs_param_is_bool = 2, + fs_param_is_u32 = 3, + fs_param_is_u32_octal = 4, + fs_param_is_u32_hex = 5, + fs_param_is_s32 = 6, + fs_param_is_u64 = 7, + fs_param_is_enum = 8, + fs_param_is_string = 9, + fs_param_is_blob = 10, + fs_param_is_blockdev = 11, + fs_param_is_path = 12, + fs_param_is_fd = 13, + nr__fs_parameter_type = 14, }; -struct trace_event_raw_rcu_utilization { - struct trace_entry ent; - const char *s; - char __data[0]; +struct fs_parameter_spec { + const char *name; + u8 opt; + enum fs_parameter_type type: 8; + short unsigned int flags; }; -struct trace_event_raw_rcu_grace_period { - struct trace_entry ent; - const char *rcuname; - long unsigned int gp_seq; - const char *gpevent; - char __data[0]; +struct fs_parameter_enum { + u8 opt; + char name[14]; + u8 value; }; -struct trace_event_raw_rcu_future_grace_period { - struct trace_entry ent; - const char *rcuname; - long unsigned int gp_seq; - long unsigned int gp_seq_req; - u8 level; - int grplo; - int grphi; - const char *gpevent; - char __data[0]; +struct fs_parse_result { + bool negated; + bool has_value; + union { + bool boolean; + int int_32; + unsigned int uint_32; + u64 uint_64; + }; }; -struct trace_event_raw_rcu_grace_period_init { +struct trace_event_raw_cgroup_root { struct trace_entry ent; - const char *rcuname; - long unsigned int gp_seq; - u8 level; - int grplo; - int grphi; - long unsigned int qsmask; + int root; + u16 ss_mask; + u32 __data_loc_name; char __data[0]; }; -struct trace_event_raw_rcu_exp_grace_period { +struct trace_event_raw_cgroup { struct trace_entry ent; - const char *rcuname; - long unsigned int gpseq; - const char *gpevent; + int root; + int id; + int level; + u32 __data_loc_path; char __data[0]; }; -struct trace_event_raw_rcu_exp_funnel_lock { +struct trace_event_raw_cgroup_migrate { struct trace_entry ent; - const char *rcuname; - u8 level; - int grplo; - int grphi; - const char *gpevent; + int dst_root; + int dst_id; + int dst_level; + int pid; + u32 __data_loc_dst_path; + u32 __data_loc_comm; char __data[0]; }; -struct trace_event_raw_rcu_preempt_task { +struct trace_event_raw_cgroup_event { struct trace_entry ent; - const char *rcuname; - long unsigned int gp_seq; - int pid; + int root; + int id; + int level; + u32 __data_loc_path; + int val; char __data[0]; }; -struct trace_event_raw_rcu_unlock_preempted_task { - struct trace_entry ent; - const char *rcuname; - long unsigned int gp_seq; - int pid; - char __data[0]; +struct trace_event_data_offsets_cgroup_root { + u32 name; }; -struct trace_event_raw_rcu_quiescent_state_report { - struct trace_entry ent; - const char *rcuname; - long unsigned int gp_seq; - long unsigned int mask; - long unsigned int qsmask; - u8 level; - int grplo; - int grphi; - u8 gp_tasks; - char __data[0]; +struct trace_event_data_offsets_cgroup { + u32 path; }; -struct trace_event_raw_rcu_fqs { - struct trace_entry ent; - const char *rcuname; - long unsigned int gp_seq; - int cpu; - const char *qsevent; - char __data[0]; +struct trace_event_data_offsets_cgroup_migrate { + u32 dst_path; + u32 comm; }; -struct trace_event_raw_rcu_dyntick { - struct trace_entry ent; - const char *polarity; - long int oldnesting; - long int newnesting; - int dynticks; - char __data[0]; +struct trace_event_data_offsets_cgroup_event { + u32 path; }; -struct trace_event_raw_rcu_callback { - struct trace_entry ent; - const char *rcuname; - void *rhp; - void *func; - long int qlen_lazy; - long int qlen; - char __data[0]; +typedef void (*btf_trace_cgroup_setup_root)(void *, struct cgroup_root *); + +typedef void (*btf_trace_cgroup_destroy_root)(void *, struct cgroup_root *); + +typedef void (*btf_trace_cgroup_remount)(void *, struct cgroup_root *); + +typedef void (*btf_trace_cgroup_mkdir)(void *, struct cgroup *, const char *); + +typedef void (*btf_trace_cgroup_rmdir)(void *, struct cgroup *, const char *); + +typedef void (*btf_trace_cgroup_release)(void *, struct cgroup *, const char *); + +typedef void (*btf_trace_cgroup_rename)(void *, struct cgroup *, const char *); + +typedef void (*btf_trace_cgroup_freeze)(void *, struct cgroup *, const char *); + +typedef void (*btf_trace_cgroup_unfreeze)(void *, struct cgroup *, const char *); + +typedef void (*btf_trace_cgroup_attach_task)(void *, struct cgroup *, const char *, struct task_struct *, bool); + +typedef void (*btf_trace_cgroup_transfer_tasks)(void *, struct cgroup *, const char *, struct task_struct *, bool); + +typedef void (*btf_trace_cgroup_notify_populated)(void *, struct cgroup *, const char *, int); + +typedef void (*btf_trace_cgroup_notify_frozen)(void *, struct cgroup *, const char *, int); + +enum cgroup2_param { + Opt_nsdelegate = 0, + Opt_memory_localevents = 1, + nr__cgroup2_params = 2, }; -struct trace_event_raw_rcu_kfree_callback { - struct trace_entry ent; - const char *rcuname; - void *rhp; - long unsigned int offset; - long int qlen_lazy; - long int qlen; - char __data[0]; +struct cgroupstats { + __u64 nr_sleeping; + __u64 nr_running; + __u64 nr_stopped; + __u64 nr_uninterruptible; + __u64 nr_io_wait; }; -struct trace_event_raw_rcu_batch_start { - struct trace_entry ent; - const char *rcuname; - long int qlen_lazy; - long int qlen; - long int blimit; - char __data[0]; +enum cgroup_filetype { + CGROUP_FILE_PROCS = 0, + CGROUP_FILE_TASKS = 1, }; -struct trace_event_raw_rcu_invoke_callback { - struct trace_entry ent; - const char *rcuname; - void *rhp; - void *func; - char __data[0]; +struct cgroup_pidlist { + struct { + enum cgroup_filetype type; + struct pid_namespace *ns; + } key; + pid_t *list; + int length; + struct list_head links; + struct cgroup *owner; + struct delayed_work destroy_dwork; }; -struct trace_event_raw_rcu_invoke_kfree_callback { - struct trace_entry ent; - const char *rcuname; - void *rhp; - long unsigned int offset; - char __data[0]; +enum cgroup1_param { + Opt_all = 0, + Opt_clone_children = 1, + Opt_cpuset_v2_mode = 2, + Opt_name = 3, + Opt_none = 4, + Opt_noprefix = 5, + Opt_release_agent = 6, + Opt_xattr = 7, }; -struct trace_event_raw_rcu_batch_end { - struct trace_entry ent; - const char *rcuname; - int callbacks_invoked; - char cb; - char nr; - char iit; - char risk; - char __data[0]; +enum freezer_state_flags { + CGROUP_FREEZER_ONLINE = 1, + CGROUP_FREEZING_SELF = 2, + CGROUP_FREEZING_PARENT = 4, + CGROUP_FROZEN = 8, + CGROUP_FREEZING = 6, }; -struct trace_event_raw_rcu_torture_read { - struct trace_entry ent; - char rcutorturename[8]; - struct callback_head *rhp; - long unsigned int secs; - long unsigned int c_old; - long unsigned int c; - char __data[0]; +struct freezer { + struct cgroup_subsys_state css; + unsigned int state; }; -struct trace_event_raw_rcu_barrier { - struct trace_entry ent; - const char *rcuname; - const char *s; - int cpu; +struct fmeter { int cnt; - long unsigned int done; - char __data[0]; + int val; + time64_t time; + spinlock_t lock; }; -struct trace_event_data_offsets_rcu_utilization {}; - -struct trace_event_data_offsets_rcu_grace_period {}; - -struct trace_event_data_offsets_rcu_future_grace_period {}; - -struct trace_event_data_offsets_rcu_grace_period_init {}; - -struct trace_event_data_offsets_rcu_exp_grace_period {}; - -struct trace_event_data_offsets_rcu_exp_funnel_lock {}; - -struct trace_event_data_offsets_rcu_preempt_task {}; +struct cpuset { + struct cgroup_subsys_state css; + long unsigned int flags; + cpumask_var_t cpus_allowed; + nodemask_t mems_allowed; + cpumask_var_t effective_cpus; + nodemask_t effective_mems; + cpumask_var_t subparts_cpus; + nodemask_t old_mems_allowed; + struct fmeter fmeter; + int attach_in_progress; + int pn; + int relax_domain_level; + int nr_subparts_cpus; + int partition_root_state; + int use_parent_ecpus; + int child_ecpus_count; +}; -struct trace_event_data_offsets_rcu_unlock_preempted_task {}; +struct tmpmasks { + cpumask_var_t addmask; + cpumask_var_t delmask; + cpumask_var_t new_cpus; +}; -struct trace_event_data_offsets_rcu_quiescent_state_report {}; +typedef enum { + CS_ONLINE = 0, + CS_CPU_EXCLUSIVE = 1, + CS_MEM_EXCLUSIVE = 2, + CS_MEM_HARDWALL = 3, + CS_MEMORY_MIGRATE = 4, + CS_SCHED_LOAD_BALANCE = 5, + CS_SPREAD_PAGE = 6, + CS_SPREAD_SLAB = 7, +} cpuset_flagbits_t; -struct trace_event_data_offsets_rcu_fqs {}; +enum subparts_cmd { + partcmd_enable = 0, + partcmd_disable = 1, + partcmd_update = 2, +}; -struct trace_event_data_offsets_rcu_dyntick {}; +struct cpuset_migrate_mm_work { + struct work_struct work; + struct mm_struct *mm; + nodemask_t from; + nodemask_t to; +}; -struct trace_event_data_offsets_rcu_callback {}; +typedef enum { + FILE_MEMORY_MIGRATE = 0, + FILE_CPULIST = 1, + FILE_MEMLIST = 2, + FILE_EFFECTIVE_CPULIST = 3, + FILE_EFFECTIVE_MEMLIST = 4, + FILE_SUBPARTS_CPULIST = 5, + FILE_CPU_EXCLUSIVE = 6, + FILE_MEM_EXCLUSIVE = 7, + FILE_MEM_HARDWALL = 8, + FILE_SCHED_LOAD_BALANCE = 9, + FILE_PARTITION_ROOT = 10, + FILE_SCHED_RELAX_DOMAIN_LEVEL = 11, + FILE_MEMORY_PRESSURE_ENABLED = 12, + FILE_MEMORY_PRESSURE = 13, + FILE_SPREAD_PAGE = 14, + FILE_SPREAD_SLAB = 15, +} cpuset_filetype_t; -struct trace_event_data_offsets_rcu_kfree_callback {}; +struct cpu_stop_done { + atomic_t nr_todo; + int ret; + struct completion completion; +}; -struct trace_event_data_offsets_rcu_batch_start {}; +struct cpu_stopper { + struct task_struct *thread; + raw_spinlock_t lock; + bool enabled; + struct list_head works; + struct cpu_stop_work stop_work; +}; -struct trace_event_data_offsets_rcu_invoke_callback {}; +enum multi_stop_state { + MULTI_STOP_NONE = 0, + MULTI_STOP_PREPARE = 1, + MULTI_STOP_DISABLE_IRQ = 2, + MULTI_STOP_RUN = 3, + MULTI_STOP_EXIT = 4, +}; -struct trace_event_data_offsets_rcu_invoke_kfree_callback {}; +struct multi_stop_data { + cpu_stop_fn_t fn; + void *data; + unsigned int num_threads; + const struct cpumask *active_cpus; + enum multi_stop_state state; + atomic_t thread_ack; +}; -struct trace_event_data_offsets_rcu_batch_end {}; +typedef int __kernel_mqd_t; -struct trace_event_data_offsets_rcu_torture_read {}; +typedef __kernel_mqd_t mqd_t; -struct trace_event_data_offsets_rcu_barrier {}; +enum audit_state { + AUDIT_DISABLED = 0, + AUDIT_BUILD_CONTEXT = 1, + AUDIT_RECORD_CONTEXT = 2, +}; -enum { - GP_IDLE = 0, - GP_ENTER = 1, - GP_PASSED = 2, - GP_EXIT = 3, - GP_REPLAY = 4, +struct audit_cap_data { + kernel_cap_t permitted; + kernel_cap_t inheritable; + union { + unsigned int fE; + kernel_cap_t effective; + }; + kernel_cap_t ambient; + kuid_t rootid; }; -typedef long unsigned int ulong; +struct audit_names { + struct list_head list; + struct filename *name; + int name_len; + bool hidden; + long unsigned int ino; + dev_t dev; + umode_t mode; + kuid_t uid; + kgid_t gid; + dev_t rdev; + u32 osid; + struct audit_cap_data fcap; + unsigned int fcap_ver; + unsigned char type; + bool should_free; +}; -struct rcu_cblist { - struct callback_head *head; - struct callback_head **tail; - long int len; - long int len_lazy; +struct mq_attr { + __kernel_long_t mq_flags; + __kernel_long_t mq_maxmsg; + __kernel_long_t mq_msgsize; + __kernel_long_t mq_curmsgs; + __kernel_long_t __reserved[4]; }; -enum rcutorture_type { - RCU_FLAVOR = 0, - RCU_TASKS_FLAVOR = 1, - RCU_TRIVIAL_FLAVOR = 2, - SRCU_FLAVOR = 3, - INVALID_RCU_FLAVOR = 4, +struct audit_proctitle { + int len; + char *value; }; -typedef long unsigned int pao_T_____3; +struct audit_aux_data; -struct rcu_exp_work { - long unsigned int rew_s; - struct work_struct rew_work; -}; +struct audit_tree_refs; -struct rcu_node { - raw_spinlock_t lock; - long unsigned int gp_seq; - long unsigned int gp_seq_needed; - long unsigned int completedqs; - long unsigned int qsmask; - long unsigned int rcu_gp_init_mask; - long unsigned int qsmaskinit; - long unsigned int qsmaskinitnext; - long unsigned int expmask; - long unsigned int expmaskinit; - long unsigned int expmaskinitnext; - long unsigned int ffmask; - long unsigned int grpmask; - int grplo; - int grphi; - u8 grpnum; - u8 level; - bool wait_blkd_tasks; - struct rcu_node *parent; - struct list_head blkd_tasks; - struct list_head *gp_tasks; - struct list_head *exp_tasks; - struct list_head *boost_tasks; - struct rt_mutex boost_mtx; - long unsigned int boost_time; - struct task_struct *boost_kthread_task; - unsigned int boost_kthread_status; - long: 32; - long: 64; - long: 64; - long: 64; - long: 64; - raw_spinlock_t fqslock; - long: 32; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - spinlock_t exp_lock; - long unsigned int exp_seq_rq; - wait_queue_head_t exp_wq[4]; - struct rcu_exp_work rew; - bool exp_need_flush; - long: 56; - long: 64; - long: 64; - long: 64; - long: 64; +struct audit_context { + int dummy; + int in_syscall; + enum audit_state state; + enum audit_state current_state; + unsigned int serial; + int major; + struct timespec64 ctime; + long unsigned int argv[4]; + long int return_code; + u64 prio; + int return_valid; + struct audit_names preallocated_names[5]; + int name_count; + struct list_head names_list; + char *filterkey; + struct path pwd; + struct audit_aux_data *aux; + struct audit_aux_data *aux_pids; + struct __kernel_sockaddr_storage *sockaddr; + size_t sockaddr_len; + pid_t pid; + pid_t ppid; + kuid_t uid; + kuid_t euid; + kuid_t suid; + kuid_t fsuid; + kgid_t gid; + kgid_t egid; + kgid_t sgid; + kgid_t fsgid; + long unsigned int personality; + int arch; + pid_t target_pid; + kuid_t target_auid; + kuid_t target_uid; + unsigned int target_sessionid; + u32 target_sid; + char target_comm[16]; + struct audit_tree_refs *trees; + struct audit_tree_refs *first_trees; + struct list_head killed_trees; + int tree_count; + int type; + union { + struct { + int nargs; + long int args[6]; + } socketcall; + struct { + kuid_t uid; + kgid_t gid; + umode_t mode; + u32 osid; + int has_perm; + uid_t perm_uid; + gid_t perm_gid; + umode_t perm_mode; + long unsigned int qbytes; + } ipc; + struct { + mqd_t mqdes; + struct mq_attr mqstat; + } mq_getsetattr; + struct { + mqd_t mqdes; + int sigev_signo; + } mq_notify; + struct { + mqd_t mqdes; + size_t msg_len; + unsigned int msg_prio; + struct timespec64 abs_timeout; + } mq_sendrecv; + struct { + int oflag; + umode_t mode; + struct mq_attr attr; + } mq_open; + struct { + pid_t pid; + struct audit_cap_data cap; + } capset; + struct { + int fd; + int flags; + } mmap; + struct { + int argc; + } execve; + struct { + char *name; + } module; + }; + int fds[2]; + struct audit_proctitle proctitle; }; -union rcu_noqs { - struct { - u8 norm; - u8 exp; - } b; - u16 s; +enum audit_nlgrps { + AUDIT_NLGRP_NONE = 0, + AUDIT_NLGRP_READLOG = 1, + __AUDIT_NLGRP_MAX = 2, }; -struct rcu_data { - long unsigned int gp_seq; - long unsigned int gp_seq_needed; - union rcu_noqs cpu_no_qs; - bool core_needs_qs; - bool beenonline; - bool gpwrap; - bool exp_deferred_qs; - struct rcu_node *mynode; - long unsigned int grpmask; - long unsigned int ticks_this_gp; - struct irq_work defer_qs_iw; - bool defer_qs_iw_pending; - struct rcu_segcblist cblist; - long int qlen_last_fqs_check; - long unsigned int n_force_qs_snap; - long int blimit; - int dynticks_snap; - long int dynticks_nesting; - long int dynticks_nmi_nesting; - atomic_t dynticks; - bool rcu_need_heavy_qs; - bool rcu_urgent_qs; - bool rcu_forced_tick; - struct callback_head barrier_head; - int exp_dynticks_snap; - struct task_struct *rcu_cpu_kthread_task; - unsigned int rcu_cpu_kthread_status; - char rcu_cpu_has_work; - unsigned int softirq_snap; - struct irq_work rcu_iw; - bool rcu_iw_pending; - long unsigned int rcu_iw_gp_seq; - long unsigned int rcu_ofl_gp_seq; - short int rcu_ofl_gp_flags; - long unsigned int rcu_onl_gp_seq; - short int rcu_onl_gp_flags; - long unsigned int last_fqs_resched; - int cpu; +struct audit_status { + __u32 mask; + __u32 enabled; + __u32 failure; + __u32 pid; + __u32 rate_limit; + __u32 backlog_limit; + __u32 lost; + __u32 backlog; + union { + __u32 version; + __u32 feature_bitmap; + }; + __u32 backlog_wait_time; }; -struct rcu_state { - struct rcu_node node[5]; - struct rcu_node *level[3]; - int ncpus; - long: 32; - long: 64; - long: 64; - long: 64; - long: 64; - u8 boost; - long unsigned int gp_seq; - struct task_struct *gp_kthread; - struct swait_queue_head gp_wq; - short int gp_flags; - short int gp_state; - long unsigned int gp_wake_time; - long unsigned int gp_wake_seq; - struct mutex barrier_mutex; - atomic_t barrier_cpu_count; - struct completion barrier_completion; - long unsigned int barrier_sequence; - struct mutex exp_mutex; - struct mutex exp_wake_mutex; - long unsigned int expedited_sequence; - atomic_t expedited_need_qs; - struct swait_queue_head expedited_wq; - int ncpus_snap; - long unsigned int jiffies_force_qs; - long unsigned int jiffies_kick_kthreads; - long unsigned int n_force_qs; - long unsigned int gp_start; - long unsigned int gp_end; - long unsigned int gp_activity; - long unsigned int gp_req_activity; - long unsigned int jiffies_stall; - long unsigned int jiffies_resched; - long unsigned int n_force_qs_gpstart; - long unsigned int gp_max; - const char *name; - char abbr; - long: 56; - long: 64; - long: 64; - raw_spinlock_t ofl_lock; - long: 32; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +struct audit_features { + __u32 vers; + __u32 mask; + __u32 features; + __u32 lock; }; -typedef bool pto_T_____7; - -struct dma_devres { - size_t size; - void *vaddr; - dma_addr_t dma_handle; - long unsigned int attrs; +struct audit_tty_status { + __u32 enabled; + __u32 log_passwd; }; -enum dma_sync_target { - SYNC_FOR_CPU = 0, - SYNC_FOR_DEVICE = 1, +struct audit_sig_info { + uid_t uid; + pid_t pid; + char ctx[0]; }; -struct trace_event_raw_swiotlb_bounced { - struct trace_entry ent; - u32 __data_loc_dev_name; - u64 dma_mask; - dma_addr_t dev_addr; - size_t size; - enum swiotlb_force swiotlb_force; - char __data[0]; +struct net_generic { + union { + struct { + unsigned int len; + struct callback_head rcu; + } s; + void *ptr[0]; + }; }; -struct trace_event_data_offsets_swiotlb_bounced { - u32 dev_name; +struct scm_creds { + u32 pid; + kuid_t uid; + kgid_t gid; }; -enum profile_type { - PROFILE_TASK_EXIT = 0, - PROFILE_MUNMAP = 1, +struct netlink_skb_parms { + struct scm_creds creds; + __u32 portid; + __u32 dst_group; + __u32 flags; + struct sock *sk; + bool nsid_is_set; + int nsid; }; -struct profile_hit { - u32 pc; - u32 hits; +struct netlink_kernel_cfg { + unsigned int groups; + unsigned int flags; + void (*input)(struct sk_buff *); + struct mutex *cb_mutex; + int (*bind)(struct net *, int); + void (*unbind)(struct net *, int); + bool (*compare)(struct net *, struct sock *); }; -struct stacktrace_cookie { - long unsigned int *store; - unsigned int size; - unsigned int skip; - unsigned int len; +struct audit_netlink_list { + __u32 portid; + struct net *net; + struct sk_buff_head q; }; -typedef __kernel_long_t __kernel_suseconds_t; +struct audit_net { + struct sock *sk; +}; -typedef __kernel_long_t __kernel_old_time_t; +struct auditd_connection { + struct pid *pid; + u32 portid; + struct net *net; + struct callback_head rcu; +}; -typedef __kernel_suseconds_t suseconds_t; +struct audit_ctl_mutex { + struct mutex lock; + void *owner; +}; -typedef __u64 timeu64_t; +struct audit_buffer { + struct sk_buff *skb; + struct audit_context *ctx; + gfp_t gfp_mask; +}; -struct __kernel_itimerspec { - struct __kernel_timespec it_interval; - struct __kernel_timespec it_value; +struct audit_reply { + __u32 portid; + struct net *net; + struct sk_buff *skb; }; -struct timespec { - __kernel_old_time_t tv_sec; - long int tv_nsec; +enum { + Audit_equal = 0, + Audit_not_equal = 1, + Audit_bitmask = 2, + Audit_bittest = 3, + Audit_lt = 4, + Audit_gt = 5, + Audit_le = 6, + Audit_ge = 7, + Audit_bad = 8, }; -struct timeval { - __kernel_old_time_t tv_sec; - __kernel_suseconds_t tv_usec; +struct audit_rule_data { + __u32 flags; + __u32 action; + __u32 field_count; + __u32 mask[64]; + __u32 fields[64]; + __u32 values[64]; + __u32 fieldflags[64]; + __u32 buflen; + char buf[0]; }; -struct timezone { - int tz_minuteswest; - int tz_dsttime; +struct audit_field; + +struct audit_watch; + +struct audit_tree; + +struct audit_fsnotify_mark; + +struct audit_krule { + u32 pflags; + u32 flags; + u32 listnr; + u32 action; + u32 mask[64]; + u32 buflen; + u32 field_count; + char *filterkey; + struct audit_field *fields; + struct audit_field *arch_f; + struct audit_field *inode_f; + struct audit_watch *watch; + struct audit_tree *tree; + struct audit_fsnotify_mark *exe; + struct list_head rlist; + struct list_head list; + u64 prio; }; -struct itimerspec64 { - struct timespec64 it_interval; - struct timespec64 it_value; +struct audit_field { + u32 type; + union { + u32 val; + kuid_t uid; + kgid_t gid; + struct { + char *lsm_str; + void *lsm_rule; + }; + }; + u32 op; }; -struct old_itimerspec32 { - struct old_timespec32 it_interval; - struct old_timespec32 it_value; +struct audit_entry { + struct list_head list; + struct callback_head rcu; + struct audit_krule rule; }; -struct old_timex32 { - u32 modes; - s32 offset; - s32 freq; - s32 maxerror; - s32 esterror; - s32 status; - s32 constant; - s32 precision; - s32 tolerance; - struct old_timeval32 time; - s32 tick; - s32 ppsfreq; - s32 jitter; - s32 shift; - s32 stabil; - s32 jitcnt; - s32 calcnt; - s32 errcnt; - s32 stbcnt; - s32 tai; - long: 32; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; -}; +struct audit_buffer___2; -struct __kernel_timex_timeval { - __kernel_time64_t tv_sec; - long long int tv_usec; +typedef int __kernel_key_t; + +typedef __kernel_key_t key_t; + +struct cpu_vfs_cap_data { + __u32 magic_etc; + kernel_cap_t permitted; + kernel_cap_t inheritable; + kuid_t rootid; }; -struct __kernel_timex { - unsigned int modes; - long long int offset; - long long int freq; - long long int maxerror; - long long int esterror; - int status; - long long int constant; - long long int precision; - long long int tolerance; - struct __kernel_timex_timeval time; - long long int tick; - long long int ppsfreq; - long long int jitter; - int shift; - long long int stabil; - long long int jitcnt; - long long int calcnt; - long long int errcnt; - long long int stbcnt; - int tai; +struct kern_ipc_perm { + spinlock_t lock; + bool deleted; + int id; + key_t key; + kuid_t uid; + kgid_t gid; + kuid_t cuid; + kgid_t cgid; + umode_t mode; + long unsigned int seq; + void *security; + struct rhash_head khtnode; + struct callback_head rcu; + refcount_t refcount; long: 32; long: 64; long: 64; @@ -27052,3134 +31925,2867 @@ struct __kernel_timex { long: 64; }; -struct trace_event_raw_timer_class { - struct trace_entry ent; - void *timer; - char __data[0]; -}; +typedef struct fsnotify_mark_connector *fsnotify_connp_t; -struct trace_event_raw_timer_start { - struct trace_entry ent; - void *timer; - void *function; - long unsigned int expires; - long unsigned int now; - unsigned int flags; - char __data[0]; +struct fsnotify_mark_connector { + spinlock_t lock; + short unsigned int type; + short unsigned int flags; + __kernel_fsid_t fsid; + union { + fsnotify_connp_t *obj; + struct fsnotify_mark_connector *destroy_next; + }; + struct hlist_head list; }; -struct trace_event_raw_timer_expire_entry { - struct trace_entry ent; - void *timer; - long unsigned int now; - void *function; - long unsigned int baseclk; - char __data[0]; +enum fsnotify_obj_type { + FSNOTIFY_OBJ_TYPE_INODE = 0, + FSNOTIFY_OBJ_TYPE_VFSMOUNT = 1, + FSNOTIFY_OBJ_TYPE_SB = 2, + FSNOTIFY_OBJ_TYPE_COUNT = 3, + FSNOTIFY_OBJ_TYPE_DETACHED = 3, }; -struct trace_event_raw_hrtimer_init { - struct trace_entry ent; - void *hrtimer; - clockid_t clockid; - enum hrtimer_mode mode; - char __data[0]; +struct audit_aux_data { + struct audit_aux_data *next; + int type; }; -struct trace_event_raw_hrtimer_start { - struct trace_entry ent; - void *hrtimer; - void *function; - s64 expires; - s64 softexpires; - enum hrtimer_mode mode; - char __data[0]; -}; +struct audit_chunk; -struct trace_event_raw_hrtimer_expire_entry { - struct trace_entry ent; - void *hrtimer; - s64 now; - void *function; - char __data[0]; +struct audit_tree_refs { + struct audit_tree_refs *next; + struct audit_chunk *c[31]; }; -struct trace_event_raw_hrtimer_class { - struct trace_entry ent; - void *hrtimer; - char __data[0]; +struct audit_aux_data_pids { + struct audit_aux_data d; + pid_t target_pid[16]; + kuid_t target_auid[16]; + kuid_t target_uid[16]; + unsigned int target_sessionid[16]; + u32 target_sid[16]; + char target_comm[256]; + int pid_count; }; -struct trace_event_raw_itimer_state { - struct trace_entry ent; - int which; - long long unsigned int expires; - long int value_sec; - long int value_nsec; - long int interval_sec; - long int interval_nsec; - char __data[0]; +struct audit_aux_data_bprm_fcaps { + struct audit_aux_data d; + struct audit_cap_data fcap; + unsigned int fcap_ver; + struct audit_cap_data old_pcap; + struct audit_cap_data new_pcap; }; -struct trace_event_raw_itimer_expire { - struct trace_entry ent; - int which; - pid_t pid; - long long unsigned int now; - char __data[0]; -}; +struct audit_parent; -struct trace_event_raw_tick_stop { - struct trace_entry ent; - int success; - int dependency; - char __data[0]; +struct audit_watch { + refcount_t count; + dev_t dev; + char *path; + long unsigned int ino; + struct audit_parent *parent; + struct list_head wlist; + struct list_head rules; }; -struct trace_event_data_offsets_timer_class {}; +struct fsnotify_group; -struct trace_event_data_offsets_timer_start {}; +struct fsnotify_iter_info; -struct trace_event_data_offsets_timer_expire_entry {}; +struct fsnotify_mark; -struct trace_event_data_offsets_hrtimer_init {}; +struct fsnotify_event; -struct trace_event_data_offsets_hrtimer_start {}; +struct fsnotify_ops { + int (*handle_event)(struct fsnotify_group *, struct inode *, u32, const void *, int, const struct qstr *, u32, struct fsnotify_iter_info *); + void (*free_group_priv)(struct fsnotify_group *); + void (*freeing_mark)(struct fsnotify_mark *, struct fsnotify_group *); + void (*free_event)(struct fsnotify_event *); + void (*free_mark)(struct fsnotify_mark *); +}; -struct trace_event_data_offsets_hrtimer_expire_entry {}; +struct inotify_group_private_data { + spinlock_t idr_lock; + struct idr idr; + struct ucounts *ucounts; +}; -struct trace_event_data_offsets_hrtimer_class {}; +struct fsnotify_group { + const struct fsnotify_ops *ops; + refcount_t refcnt; + spinlock_t notification_lock; + struct list_head notification_list; + wait_queue_head_t notification_waitq; + unsigned int q_len; + unsigned int max_events; + unsigned int priority; + bool shutdown; + struct mutex mark_mutex; + atomic_t num_marks; + atomic_t user_waits; + struct list_head marks_list; + struct fasync_struct *fsn_fa; + struct fsnotify_event *overflow_event; + struct mem_cgroup *memcg; + union { + void *private; + struct inotify_group_private_data inotify_data; + }; +}; -struct trace_event_data_offsets_itimer_state {}; +struct fsnotify_iter_info { + struct fsnotify_mark *marks[3]; + unsigned int report_mask; + int srcu_idx; +}; -struct trace_event_data_offsets_itimer_expire {}; +struct fsnotify_mark { + __u32 mask; + refcount_t refcnt; + struct fsnotify_group *group; + struct list_head g_list; + spinlock_t lock; + struct hlist_node obj_list; + struct fsnotify_mark_connector *connector; + __u32 ignored_mask; + unsigned int flags; +}; -struct trace_event_data_offsets_tick_stop {}; +struct fsnotify_event { + struct list_head list; + struct inode *inode; +}; -struct timer_base { - raw_spinlock_t lock; - struct timer_list *running_timer; - long unsigned int clk; - long unsigned int next_expiry; - unsigned int cpu; - bool is_idle; - bool must_forward_clk; - long unsigned int pending_map[9]; - struct hlist_head vectors[576]; - long: 64; - long: 64; +struct audit_parent { + struct list_head watches; + struct fsnotify_mark mark; }; -struct process_timer { - struct timer_list timer; - struct task_struct *task; +struct audit_fsnotify_mark { + dev_t dev; + long unsigned int ino; + char *path; + struct fsnotify_mark mark; + struct audit_krule *rule; }; -enum tick_device_mode { - TICKDEV_MODE_PERIODIC = 0, - TICKDEV_MODE_ONESHOT = 1, +struct audit_chunk___2; + +struct audit_tree { + refcount_t count; + int goner; + struct audit_chunk___2 *root; + struct list_head chunks; + struct list_head rules; + struct list_head list; + struct list_head same_root; + struct callback_head head; + char pathname[0]; }; -struct tick_device { - struct clock_event_device *evtdev; - enum tick_device_mode mode; +struct node___2 { + struct list_head list; + struct audit_tree *owner; + unsigned int index; }; -struct system_time_snapshot { - u64 cycles; - ktime_t real; - ktime_t raw; - unsigned int clock_was_set_seq; - u8 cs_was_changed_seq; +struct audit_chunk___2 { + struct list_head hash; + long unsigned int key; + struct fsnotify_mark *mark; + struct list_head trees; + int count; + atomic_long_t refs; + struct callback_head head; + struct node___2 owners[0]; }; -struct system_device_crosststamp { - ktime_t device; - ktime_t sys_realtime; - ktime_t sys_monoraw; +struct audit_tree_mark { + struct fsnotify_mark mark; + struct audit_chunk___2 *chunk; }; -struct tk_read_base { - struct clocksource *clock; - u64 mask; - u64 cycle_last; - u32 mult; - u32 shift; - u64 xtime_nsec; - ktime_t base; - u64 base_real; +enum { + HASH_SIZE = 128, }; -struct timekeeper { - struct tk_read_base tkr_mono; - struct tk_read_base tkr_raw; - u64 xtime_sec; - long unsigned int ktime_sec; - struct timespec64 wall_to_monotonic; - ktime_t offs_real; - ktime_t offs_boot; - ktime_t offs_tai; - s32 tai_offset; - unsigned int clock_was_set_seq; - u8 cs_was_changed_seq; - ktime_t next_leap_ktime; - u64 raw_sec; - struct timespec64 monotonic_to_boot; - u64 cycle_interval; - u64 xtime_interval; - s64 xtime_remainder; - u64 raw_interval; - u64 ntp_tick; - s64 ntp_error; - u32 ntp_error_shift; - u32 ntp_err_mult; - u32 skip_second_overflow; +struct kprobe_blacklist_entry { + struct list_head list; + long unsigned int start_addr; + long unsigned int end_addr; }; -struct audit_ntp_val { - long long int oldval; - long long int newval; +struct kprobe_insn_page { + struct list_head list; + kprobe_opcode_t *insns; + struct kprobe_insn_cache *cache; + int nused; + int ngarbage; + char slot_used[0]; }; -struct audit_ntp_data { - struct audit_ntp_val vals[6]; +enum kprobe_slot_state { + SLOT_CLEAN = 0, + SLOT_DIRTY = 1, + SLOT_USED = 2, }; -enum timekeeping_adv_mode { - TK_ADV_TICK = 0, - TK_ADV_FREQ = 1, +struct seccomp_notif_sizes { + __u16 seccomp_notif; + __u16 seccomp_notif_resp; + __u16 seccomp_data; }; -struct tk_fast { - seqcount_t seq; - struct tk_read_base base[2]; +struct seccomp_notif { + __u64 id; + __u32 pid; + __u32 flags; + struct seccomp_data data; }; -typedef s64 int64_t; +struct seccomp_notif_resp { + __u64 id; + __s64 val; + __s32 error; + __u32 flags; +}; -enum tick_nohz_mode { - NOHZ_MODE_INACTIVE = 0, - NOHZ_MODE_LOWRES = 1, - NOHZ_MODE_HIGHRES = 2, +struct notification; + +struct seccomp_filter { + refcount_t usage; + bool log; + struct seccomp_filter *prev; + struct bpf_prog *prog; + struct notification *notif; + struct mutex notify_lock; }; -struct tick_sched { - struct hrtimer sched_timer; - long unsigned int check_clocks; - enum tick_nohz_mode nohz_mode; - unsigned int inidle: 1; - unsigned int tick_stopped: 1; - unsigned int idle_active: 1; - unsigned int do_timer_last: 1; - unsigned int got_idle_tick: 1; - ktime_t last_tick; - ktime_t next_tick; - long unsigned int idle_jiffies; - long unsigned int idle_calls; - long unsigned int idle_sleeps; - ktime_t idle_entrytime; - ktime_t idle_waketime; - ktime_t idle_exittime; - ktime_t idle_sleeptime; - ktime_t iowait_sleeptime; - long unsigned int last_jiffies; - u64 timer_expires; - u64 timer_expires_base; - u64 next_timer; - ktime_t idle_expires; - atomic_t tick_dep_mask; +struct ctl_path { + const char *procname; }; -struct timer_list_iter { - int cpu; - bool second_pass; - u64 now; +struct sock_fprog { + short unsigned int len; + struct sock_filter *filter; }; -struct tm { - int tm_sec; - int tm_min; - int tm_hour; - int tm_mday; - int tm_mon; - long int tm_year; - int tm_wday; - int tm_yday; +struct compat_sock_fprog { + u16 len; + compat_uptr_t filter; }; -struct cyclecounter { - u64 (*read)(const struct cyclecounter *); - u64 mask; - u32 mult; - u32 shift; +enum notify_state { + SECCOMP_NOTIFY_INIT = 0, + SECCOMP_NOTIFY_SENT = 1, + SECCOMP_NOTIFY_REPLIED = 2, }; -struct timecounter { - const struct cyclecounter *cc; - u64 cycle_last; - u64 nsec; - u64 mask; - u64 frac; +struct seccomp_knotif { + struct task_struct *task; + u64 id; + const struct seccomp_data *data; + enum notify_state state; + int error; + long int val; + u32 flags; + struct completion ready; + struct list_head list; +}; + +struct notification { + struct semaphore request; + u64 next_id; + struct list_head notifications; + wait_queue_head_t wqh; +}; + +struct seccomp_log_name { + u32 log; + const char *name; +}; + +struct rchan; + +struct rchan_buf { + void *start; + void *data; + size_t offset; + size_t subbufs_produced; + size_t subbufs_consumed; + struct rchan *chan; + wait_queue_head_t read_wait; + struct irq_work wakeup_work; + struct dentry *dentry; + struct kref kref; + struct page **page_array; + unsigned int page_count; + unsigned int finalized; + size_t *padding; + size_t prev_padding; + size_t bytes_consumed; + size_t early_bytes; + unsigned int cpu; + long: 32; + long: 64; + long: 64; + long: 64; }; -typedef __kernel_timer_t timer_t; +struct rchan_callbacks; -struct rtc_wkalrm { - unsigned char enabled; - unsigned char pending; - struct rtc_time time; +struct rchan { + u32 version; + size_t subbuf_size; + size_t n_subbufs; + size_t alloc_size; + struct rchan_callbacks *cb; + struct kref kref; + void *private_data; + size_t last_toobig; + struct rchan_buf **buf; + int is_global; + struct list_head list; + struct dentry *parent; + int has_base_filename; + char base_filename[255]; }; -enum alarmtimer_type { - ALARM_REALTIME = 0, - ALARM_BOOTTIME = 1, - ALARM_NUMTYPE = 2, - ALARM_REALTIME_FREEZER = 3, - ALARM_BOOTTIME_FREEZER = 4, +struct rchan_callbacks { + int (*subbuf_start)(struct rchan_buf *, void *, void *, size_t); + void (*buf_mapped)(struct rchan_buf *, struct file *); + void (*buf_unmapped)(struct rchan_buf *, struct file *); + struct dentry * (*create_buf_file)(const char *, struct dentry *, umode_t, struct rchan_buf *, int *); + int (*remove_buf_file)(struct dentry *); }; -enum alarmtimer_restart { - ALARMTIMER_NORESTART = 0, - ALARMTIMER_RESTART = 1, +struct partial_page { + unsigned int offset; + unsigned int len; + long unsigned int private; }; -struct alarm { - struct timerqueue_node node; - struct hrtimer timer; - enum alarmtimer_restart (*function)(struct alarm *, ktime_t); - enum alarmtimer_type type; - int state; - void *data; +struct splice_pipe_desc { + struct page **pages; + struct partial_page *partial; + int nr_pages; + unsigned int nr_pages_max; + const struct pipe_buf_operations *ops; + void (*spd_release)(struct splice_pipe_desc *, unsigned int); }; -struct cpu_timer { - struct timerqueue_node node; - struct timerqueue_head *head; - struct task_struct *task; - struct list_head elist; - int firing; +struct rchan_percpu_buf_dispatcher { + struct rchan_buf *buf; + struct dentry *dentry; }; -struct k_clock; - -struct k_itimer { - struct list_head list; - struct hlist_node t_hash; - spinlock_t it_lock; - const struct k_clock *kclock; - clockid_t it_clock; - timer_t it_id; - int it_active; - s64 it_overrun; - s64 it_overrun_last; - int it_requeue_pending; - int it_sigev_notify; - ktime_t it_interval; - struct signal_struct *it_signal; - union { - struct pid *it_pid; - struct task_struct *it_process; - }; - struct sigqueue *sigq; - union { - struct { - struct hrtimer timer; - } real; - struct cpu_timer cpu; - struct { - struct alarm alarmtimer; - } alarm; - } it; - struct callback_head rcu; +enum { + TASKSTATS_TYPE_UNSPEC = 0, + TASKSTATS_TYPE_PID = 1, + TASKSTATS_TYPE_TGID = 2, + TASKSTATS_TYPE_STATS = 3, + TASKSTATS_TYPE_AGGR_PID = 4, + TASKSTATS_TYPE_AGGR_TGID = 5, + TASKSTATS_TYPE_NULL = 6, + __TASKSTATS_TYPE_MAX = 7, }; -struct k_clock { - int (*clock_getres)(const clockid_t, struct timespec64 *); - int (*clock_set)(const clockid_t, const struct timespec64 *); - int (*clock_get)(const clockid_t, struct timespec64 *); - int (*clock_adj)(const clockid_t, struct __kernel_timex *); - int (*timer_create)(struct k_itimer *); - int (*nsleep)(const clockid_t, int, const struct timespec64 *); - int (*timer_set)(struct k_itimer *, int, struct itimerspec64 *, struct itimerspec64 *); - int (*timer_del)(struct k_itimer *); - void (*timer_get)(struct k_itimer *, struct itimerspec64 *); - void (*timer_rearm)(struct k_itimer *); - s64 (*timer_forward)(struct k_itimer *, ktime_t); - ktime_t (*timer_remaining)(struct k_itimer *, ktime_t); - int (*timer_try_to_cancel)(struct k_itimer *); - void (*timer_arm)(struct k_itimer *, ktime_t, bool, bool); - void (*timer_wait_running)(struct k_itimer *); +enum { + TASKSTATS_CMD_ATTR_UNSPEC = 0, + TASKSTATS_CMD_ATTR_PID = 1, + TASKSTATS_CMD_ATTR_TGID = 2, + TASKSTATS_CMD_ATTR_REGISTER_CPUMASK = 3, + TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK = 4, + __TASKSTATS_CMD_ATTR_MAX = 5, }; -struct class_interface { - struct list_head node; - struct class *class; - int (*add_dev)(struct device *, struct class_interface *); - void (*remove_dev)(struct device *, struct class_interface *); +enum { + CGROUPSTATS_CMD_UNSPEC = 3, + CGROUPSTATS_CMD_GET = 4, + CGROUPSTATS_CMD_NEW = 5, + __CGROUPSTATS_CMD_MAX = 6, }; -struct rtc_class_ops { - int (*ioctl)(struct device *, unsigned int, long unsigned int); - int (*read_time)(struct device *, struct rtc_time *); - int (*set_time)(struct device *, struct rtc_time *); - int (*read_alarm)(struct device *, struct rtc_wkalrm *); - int (*set_alarm)(struct device *, struct rtc_wkalrm *); - int (*proc)(struct device *, struct seq_file *); - int (*alarm_irq_enable)(struct device *, unsigned int); - int (*read_offset)(struct device *, long int *); - int (*set_offset)(struct device *, long int); +enum { + CGROUPSTATS_TYPE_UNSPEC = 0, + CGROUPSTATS_TYPE_CGROUP_STATS = 1, + __CGROUPSTATS_TYPE_MAX = 2, }; -struct rtc_device; - -struct rtc_timer { - struct timerqueue_node node; - ktime_t period; - void (*func)(struct rtc_device *); - struct rtc_device *rtc; - int enabled; +enum { + CGROUPSTATS_CMD_ATTR_UNSPEC = 0, + CGROUPSTATS_CMD_ATTR_FD = 1, + __CGROUPSTATS_CMD_ATTR_MAX = 2, }; -struct rtc_device { - struct device dev; - struct module *owner; - int id; - const struct rtc_class_ops *ops; - struct mutex ops_lock; - struct cdev char_dev; - long unsigned int flags; - long unsigned int irq_data; - spinlock_t irq_lock; - wait_queue_head_t irq_queue; - struct fasync_struct *async_queue; - int irq_freq; - int max_user_freq; - struct timerqueue_head timerqueue; - struct rtc_timer aie_timer; - struct rtc_timer uie_rtctimer; - struct hrtimer pie_timer; - int pie_enabled; - struct work_struct irqwork; - int uie_unsupported; - long int set_offset_nsec; - bool registered; - bool nvram_old_abi; - struct bin_attribute *nvram; - time64_t range_min; - timeu64_t range_max; - time64_t start_secs; - time64_t offset_secs; - bool set_start_time; +struct genlmsghdr { + __u8 cmd; + __u8 version; + __u16 reserved; }; -struct platform_driver { - int (*probe)(struct platform_device *); - int (*remove)(struct platform_device *); - void (*shutdown)(struct platform_device *); - int (*suspend)(struct platform_device *, pm_message_t); - int (*resume)(struct platform_device *); - struct device_driver driver; - const struct platform_device_id *id_table; - bool prevent_deferred_probe; +enum { + NLA_UNSPEC = 0, + NLA_U8 = 1, + NLA_U16 = 2, + NLA_U32 = 3, + NLA_U64 = 4, + NLA_STRING = 5, + NLA_FLAG = 6, + NLA_MSECS = 7, + NLA_NESTED = 8, + NLA_NESTED_ARRAY = 9, + NLA_NUL_STRING = 10, + NLA_BINARY = 11, + NLA_S8 = 12, + NLA_S16 = 13, + NLA_S32 = 14, + NLA_S64 = 15, + NLA_BITFIELD32 = 16, + NLA_REJECT = 17, + NLA_EXACT_LEN = 18, + NLA_EXACT_LEN_WARN = 19, + NLA_MIN_LEN = 20, + __NLA_TYPE_MAX = 21, }; -struct trace_event_raw_alarmtimer_suspend { - struct trace_entry ent; - s64 expires; - unsigned char alarm_type; - char __data[0]; +enum netlink_validation { + NL_VALIDATE_LIBERAL = 0, + NL_VALIDATE_TRAILING = 1, + NL_VALIDATE_MAXTYPE = 2, + NL_VALIDATE_UNSPEC = 4, + NL_VALIDATE_STRICT_ATTRS = 8, + NL_VALIDATE_NESTED = 16, }; -struct trace_event_raw_alarm_class { - struct trace_entry ent; - void *alarm; - unsigned char alarm_type; - s64 expires; - s64 now; - char __data[0]; +struct genl_multicast_group { + char name[16]; }; -struct trace_event_data_offsets_alarmtimer_suspend {}; +struct genl_ops; -struct trace_event_data_offsets_alarm_class {}; +struct genl_info; -struct alarm_base { - spinlock_t lock; - struct timerqueue_head timerqueue; - ktime_t (*gettime)(); - clockid_t base_clockid; +struct genl_family { + int id; + unsigned int hdrsize; + char name[16]; + unsigned int version; + unsigned int maxattr; + bool netnsok; + bool parallel_ops; + const struct nla_policy *policy; + int (*pre_doit)(const struct genl_ops *, struct sk_buff *, struct genl_info *); + void (*post_doit)(const struct genl_ops *, struct sk_buff *, struct genl_info *); + int (*mcast_bind)(struct net *, int); + void (*mcast_unbind)(struct net *, int); + struct nlattr **attrbuf; + const struct genl_ops *ops; + const struct genl_multicast_group *mcgrps; + unsigned int n_ops; + unsigned int n_mcgrps; + unsigned int mcgrp_offset; + struct module *module; }; -struct sigevent { - sigval_t sigev_value; - int sigev_signo; - int sigev_notify; - union { - int _pad[12]; - int _tid; - struct { - void (*_function)(sigval_t); - void *_attribute; - } _sigev_thread; - } _sigev_un; +struct genl_ops { + int (*doit)(struct sk_buff *, struct genl_info *); + int (*start)(struct netlink_callback *); + int (*dumpit)(struct sk_buff *, struct netlink_callback *); + int (*done)(struct netlink_callback *); + u8 cmd; + u8 internal_flags; + u8 flags; + u8 validate; }; -typedef struct sigevent sigevent_t; - -struct compat_sigevent { - compat_sigval_t sigev_value; - compat_int_t sigev_signo; - compat_int_t sigev_notify; - union { - compat_int_t _pad[13]; - compat_int_t _tid; - struct { - compat_uptr_t _function; - compat_uptr_t _attribute; - } _sigev_thread; - } _sigev_un; +struct genl_info { + u32 snd_seq; + u32 snd_portid; + struct nlmsghdr *nlhdr; + struct genlmsghdr *genlhdr; + void *userhdr; + struct nlattr **attrs; + possible_net_t _net; + void *user_ptr[2]; + struct netlink_ext_ack *extack; }; -typedef unsigned int uint; - -struct posix_clock; - -struct posix_clock_operations { - struct module *owner; - int (*clock_adjtime)(struct posix_clock *, struct __kernel_timex *); - int (*clock_gettime)(struct posix_clock *, struct timespec64 *); - int (*clock_getres)(struct posix_clock *, struct timespec64 *); - int (*clock_settime)(struct posix_clock *, const struct timespec64 *); - long int (*ioctl)(struct posix_clock *, unsigned int, long unsigned int); - int (*open)(struct posix_clock *, fmode_t); - __poll_t (*poll)(struct posix_clock *, struct file *, poll_table *); - int (*release)(struct posix_clock *); - ssize_t (*read)(struct posix_clock *, uint, char *, size_t); +enum genl_validate_flags { + GENL_DONT_VALIDATE_STRICT = 1, + GENL_DONT_VALIDATE_DUMP = 2, + GENL_DONT_VALIDATE_DUMP_STRICT = 4, }; -struct posix_clock { - struct posix_clock_operations ops; - struct cdev cdev; - struct device *dev; - struct rw_semaphore rwsem; - bool zombie; +struct listener { + struct list_head list; + pid_t pid; + char valid; }; -struct posix_clock_desc { - struct file *fp; - struct posix_clock *clk; +struct listener_list { + struct rw_semaphore sem; + struct list_head list; }; -struct itimerval { - struct timeval it_interval; - struct timeval it_value; +enum actions { + REGISTER = 0, + DEREGISTER = 1, + CPU_DONT_CARE = 2, }; -struct old_itimerval32 { - struct old_timeval32 it_interval; - struct old_timeval32 it_value; +struct tp_module { + struct list_head list; + struct module *mod; }; -struct ce_unbind { - struct clock_event_device *ce; - int res; +struct tp_probes { + struct callback_head rcu; + struct tracepoint_func probes[0]; }; -struct vdso_timestamp { - u64 sec; - u64 nsec; +enum ring_buffer_type { + RINGBUF_TYPE_DATA_TYPE_LEN_MAX = 28, + RINGBUF_TYPE_PADDING = 29, + RINGBUF_TYPE_TIME_EXTEND = 30, + RINGBUF_TYPE_TIME_STAMP = 31, }; -struct vdso_data { - u32 seq; - s32 clock_mode; - u64 cycle_last; - u64 mask; - u32 mult; - u32 shift; - struct vdso_timestamp basetime[12]; - s32 tz_minuteswest; - s32 tz_dsttime; - u32 hrtimer_res; - u32 __unused; +enum ring_buffer_flags { + RB_FL_OVERWRITE = 1, }; -union futex_key { - struct { - long unsigned int pgoff; - struct inode *inode; - int offset; - } shared; - struct { - long unsigned int address; - struct mm_struct *mm; - int offset; - } private; - struct { - long unsigned int word; - void *ptr; - int offset; - } both; +struct rb_irq_work { + struct irq_work work; + wait_queue_head_t waiters; + wait_queue_head_t full_waiters; + bool waiters_pending; + bool full_waiters_pending; + bool wakeup_full; }; -struct futex_pi_state { - struct list_head list; - struct rt_mutex pi_mutex; - struct task_struct *owner; - refcount_t refcount; - union futex_key key; +struct ring_buffer_per_cpu; + +struct ring_buffer { + unsigned int flags; + int cpus; + atomic_t record_disabled; + atomic_t resize_disabled; + cpumask_var_t cpumask; + struct lock_class_key *reader_lock_key; + struct mutex mutex; + struct ring_buffer_per_cpu **buffers; + struct hlist_node node; + u64 (*clock)(); + struct rb_irq_work irq_work; + bool time_stamp_abs; }; -struct futex_q { - struct plist_node list; - struct task_struct *task; - spinlock_t *lock_ptr; - union futex_key key; - struct futex_pi_state *pi_state; - struct rt_mutex_waiter *rt_waiter; - union futex_key *requeue_pi_key; - u32 bitset; +struct buffer_page; + +struct ring_buffer_iter { + struct ring_buffer_per_cpu *cpu_buffer; + long unsigned int head; + struct buffer_page *head_page; + struct buffer_page *cache_reader_page; + long unsigned int cache_read; + u64 read_stamp; }; -struct futex_hash_bucket { - atomic_t waiters; - spinlock_t lock; - struct plist_head chain; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +enum { + RB_LEN_TIME_EXTEND = 8, + RB_LEN_TIME_STAMP = 8, }; -enum futex_access { - FUTEX_READ = 0, - FUTEX_WRITE = 1, +struct buffer_data_page { + u64 time_stamp; + local_t commit; + unsigned char data[0]; }; -struct dma_chan { - int lock; - const char *device_id; +struct buffer_page { + struct list_head list; + local_t write; + unsigned int read; + local_t entries; + long unsigned int real_end; + struct buffer_data_page *page; }; -enum { - CSD_FLAG_LOCK = 1, - CSD_FLAG_SYNCHRONOUS = 2, +struct rb_event_info { + u64 ts; + u64 delta; + long unsigned int length; + struct buffer_page *tail_page; + int add_timestamp; }; -struct call_function_data { - call_single_data_t *csd; - cpumask_var_t cpumask; - cpumask_var_t cpumask_ipi; +enum { + RB_CTX_NMI = 0, + RB_CTX_IRQ = 1, + RB_CTX_SOFTIRQ = 2, + RB_CTX_NORMAL = 3, + RB_CTX_MAX = 4, }; -struct smp_call_on_cpu_struct { - struct work_struct work; - struct completion done; - int (*func)(void *); - void *data; - int ret; +struct ring_buffer_per_cpu { int cpu; + atomic_t record_disabled; + struct ring_buffer *buffer; + raw_spinlock_t reader_lock; + arch_spinlock_t lock; + struct lock_class_key lock_key; + struct buffer_data_page *free_page; + long unsigned int nr_pages; + unsigned int current_context; + struct list_head *pages; + struct buffer_page *head_page; + struct buffer_page *tail_page; + struct buffer_page *commit_page; + struct buffer_page *reader_page; + long unsigned int lost_events; + long unsigned int last_overrun; + long unsigned int nest; + local_t entries_bytes; + local_t entries; + local_t overrun; + local_t commit_overrun; + local_t dropped_events; + local_t committing; + local_t commits; + local_t pages_touched; + local_t pages_read; + long int last_pages_touch; + size_t shortest_full; + long unsigned int read; + long unsigned int read_bytes; + u64 write_stamp; + u64 read_stamp; + long int nr_pages_to_update; + struct list_head new_pages; + struct work_struct update_pages_work; + struct completion update_done; + struct rb_irq_work irq_work; }; -struct static_key_true { - struct static_key key; +struct trace_export { + struct trace_export *next; + void (*write)(struct trace_export *, const void *, unsigned int); }; -struct latch_tree_root { - seqcount_t seq; - struct rb_root tree[2]; -}; +struct prog_entry; -struct latch_tree_ops { - bool (*less)(struct latch_tree_node *, struct latch_tree_node *); - int (*comp)(void *, struct latch_tree_node *); +struct event_filter { + struct prog_entry *prog; + char *filter_string; }; -struct module_use { - struct list_head source_list; - struct list_head target_list; - struct module *source; - struct module *target; +struct trace_array_cpu; + +struct trace_buffer { + struct trace_array *tr; + struct ring_buffer *buffer; + struct trace_array_cpu *data; + u64 time_start; + int cpu; }; -struct module_sect_attr { - struct module_attribute mattr; +struct trace_pid_list; + +struct trace_options; + +struct trace_array { + struct list_head list; char *name; - long unsigned int address; + struct trace_buffer trace_buffer; + struct trace_pid_list *filtered_pids; + arch_spinlock_t max_lock; + int buffer_disabled; + int stop_count; + int clock_id; + int nr_topts; + bool clear_trace; + int buffer_percent; + unsigned int n_err_log_entries; + struct tracer *current_trace; + unsigned int trace_flags; + unsigned char trace_flags_index[32]; + unsigned int flags; + raw_spinlock_t start_lock; + struct list_head err_log; + struct dentry *dir; + struct dentry *options; + struct dentry *percpu_dir; + struct dentry *event_dir; + struct trace_options *topts; + struct list_head systems; + struct list_head events; + struct trace_event_file *trace_marker_file; + cpumask_var_t tracing_cpumask; + int ref; + int time_stamp_abs_ref; + struct list_head hist_vars; }; -struct module_sect_attrs { - struct attribute_group grp; - unsigned int nsections; - struct module_sect_attr attrs[0]; -}; +struct tracer_flags; -struct module_notes_attrs { - struct kobject *dir; - unsigned int notes; - struct bin_attribute attrs[0]; +struct tracer { + const char *name; + int (*init)(struct trace_array *); + void (*reset)(struct trace_array *); + void (*start)(struct trace_array *); + void (*stop)(struct trace_array *); + int (*update_thresh)(struct trace_array *); + void (*open)(struct trace_iterator *); + void (*pipe_open)(struct trace_iterator *); + void (*close)(struct trace_iterator *); + void (*pipe_close)(struct trace_iterator *); + ssize_t (*read)(struct trace_iterator *, struct file *, char *, size_t, loff_t *); + ssize_t (*splice_read)(struct trace_iterator *, struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); + void (*print_header)(struct seq_file *); + enum print_line_t (*print_line)(struct trace_iterator *); + int (*set_flag)(struct trace_array *, u32, u32, int); + int (*flag_changed)(struct trace_array *, u32, int); + struct tracer *next; + struct tracer_flags *flags; + int enabled; + int ref; + bool print_max; + bool allow_instances; + bool noboot; }; -struct symsearch { - const struct kernel_symbol *start; - const struct kernel_symbol *stop; - const s32 *crcs; - enum { - NOT_GPL_ONLY = 0, - GPL_ONLY = 1, - WILL_BE_GPL_ONLY = 2, - } licence; - bool unused; +enum trace_iter_flags { + TRACE_FILE_LAT_FMT = 1, + TRACE_FILE_ANNOTATE = 2, + TRACE_FILE_TIME_IN_NS = 4, }; -enum kernel_read_file_id { - READING_UNKNOWN = 0, - READING_FIRMWARE = 1, - READING_FIRMWARE_PREALLOC_BUFFER = 2, - READING_MODULE = 3, - READING_KEXEC_IMAGE = 4, - READING_KEXEC_INITRAMFS = 5, - READING_POLICY = 6, - READING_X509_CERTIFICATE = 7, - READING_MAX_ID = 8, -}; +struct event_subsystem; -enum kernel_load_data_id { - LOADING_UNKNOWN = 0, - LOADING_FIRMWARE = 1, - LOADING_FIRMWARE_PREALLOC_BUFFER = 2, - LOADING_MODULE = 3, - LOADING_KEXEC_IMAGE = 4, - LOADING_KEXEC_INITRAMFS = 5, - LOADING_POLICY = 6, - LOADING_X509_CERTIFICATE = 7, - LOADING_MAX_ID = 8, +struct trace_subsystem_dir { + struct list_head list; + struct event_subsystem *subsystem; + struct trace_array *tr; + struct dentry *entry; + int ref_count; + int nr_events; }; -struct _ddebug { - const char *modname; - const char *function; - const char *filename; - const char *format; - unsigned int lineno: 18; - unsigned int flags: 8; - union { - struct static_key_true dd_key_true; - struct static_key_false dd_key_false; - } key; +enum event_trigger_type { + ETT_NONE = 0, + ETT_TRACE_ONOFF = 1, + ETT_SNAPSHOT = 2, + ETT_STACKTRACE = 4, + ETT_EVENT_ENABLE = 8, + ETT_EVENT_HIST = 16, + ETT_HIST_ENABLE = 32, }; -struct load_info { - const char *name; - struct module *mod; - Elf64_Ehdr *hdr; - long unsigned int len; - Elf64_Shdr *sechdrs; - char *secstrings; - char *strtab; - long unsigned int symoffs; - long unsigned int stroffs; - long unsigned int init_typeoffs; - long unsigned int core_typeoffs; - struct _ddebug *debug; - unsigned int num_debug; - bool sig_ok; - long unsigned int mod_kallsyms_init_off; - struct { - unsigned int sym; - unsigned int str; - unsigned int mod; - unsigned int vers; - unsigned int info; - unsigned int pcpu; - } index; +enum trace_type { + __TRACE_FIRST_TYPE = 0, + TRACE_FN = 1, + TRACE_CTX = 2, + TRACE_WAKE = 3, + TRACE_STACK = 4, + TRACE_PRINT = 5, + TRACE_BPRINT = 6, + TRACE_MMIO_RW = 7, + TRACE_MMIO_MAP = 8, + TRACE_BRANCH = 9, + TRACE_GRAPH_RET = 10, + TRACE_GRAPH_ENT = 11, + TRACE_USER_STACK = 12, + TRACE_BLK = 13, + TRACE_BPUTS = 14, + TRACE_HWLAT = 15, + TRACE_RAW_DATA = 16, + __TRACE_LAST_TYPE = 17, }; -struct trace_event_raw_module_load { +struct ftrace_entry { struct trace_entry ent; - unsigned int taints; - u32 __data_loc_name; - char __data[0]; + long unsigned int ip; + long unsigned int parent_ip; }; -struct trace_event_raw_module_free { +struct stack_entry { struct trace_entry ent; - u32 __data_loc_name; - char __data[0]; + int size; + long unsigned int caller[0]; }; -struct trace_event_raw_module_refcnt { +struct userstack_entry { struct trace_entry ent; - long unsigned int ip; - int refcnt; - u32 __data_loc_name; - char __data[0]; + unsigned int tgid; + long unsigned int caller[8]; }; -struct trace_event_raw_module_request { +struct bprint_entry { struct trace_entry ent; long unsigned int ip; - bool wait; - u32 __data_loc_name; - char __data[0]; + const char *fmt; + u32 buf[0]; }; -struct trace_event_data_offsets_module_load { - u32 name; +struct print_entry { + struct trace_entry ent; + long unsigned int ip; + char buf[0]; }; -struct trace_event_data_offsets_module_free { - u32 name; +struct raw_data_entry { + struct trace_entry ent; + unsigned int id; + char buf[0]; }; -struct trace_event_data_offsets_module_refcnt { - u32 name; +struct bputs_entry { + struct trace_entry ent; + long unsigned int ip; + const char *str; }; -struct trace_event_data_offsets_module_request { - u32 name; +enum trace_flag_type { + TRACE_FLAG_IRQS_OFF = 1, + TRACE_FLAG_IRQS_NOSUPPORT = 2, + TRACE_FLAG_NEED_RESCHED = 4, + TRACE_FLAG_HARDIRQ = 8, + TRACE_FLAG_SOFTIRQ = 16, + TRACE_FLAG_PREEMPT_RESCHED = 32, + TRACE_FLAG_NMI = 64, }; -struct mod_tree_root { - struct latch_tree_root root; - long unsigned int addr_min; - long unsigned int addr_max; +struct trace_array_cpu { + atomic_t disabled; + void *buffer_page; + long unsigned int entries; + long unsigned int saved_latency; + long unsigned int critical_start; + long unsigned int critical_end; + long unsigned int critical_sequence; + long unsigned int nice; + long unsigned int policy; + long unsigned int rt_priority; + long unsigned int skipped_entries; + u64 preempt_timestamp; + pid_t pid; + kuid_t uid; + char comm[16]; + bool ignore_pid; }; -struct find_symbol_arg { - const char *name; - bool gplok; - bool warn; - struct module *owner; - const s32 *crc; - const struct kernel_symbol *sym; -}; +struct trace_option_dentry; -struct mod_initfree { - struct llist_node node; - void *module_init; +struct trace_options { + struct tracer *tracer; + struct trace_option_dentry *topts; }; -struct kallsym_iter { - loff_t pos; - loff_t pos_arch_end; - loff_t pos_mod_end; - loff_t pos_ftrace_mod_end; - long unsigned int value; - unsigned int nameoff; - char type; - char name[128]; - char module_name[56]; - int exported; - int show_value; -}; +struct tracer_opt; -enum { - SB_UNFROZEN = 0, - SB_FREEZE_WRITE = 1, - SB_FREEZE_PAGEFAULT = 2, - SB_FREEZE_FS = 3, - SB_FREEZE_COMPLETE = 4, +struct trace_option_dentry { + struct tracer_opt *opt; + struct tracer_flags *flags; + struct trace_array *tr; + struct dentry *entry; }; -typedef __u16 comp_t; - -typedef __u32 comp2_t; - -struct acct { - char ac_flag; - char ac_version; - __u16 ac_uid16; - __u16 ac_gid16; - __u16 ac_tty; - __u32 ac_btime; - comp_t ac_utime; - comp_t ac_stime; - comp_t ac_etime; - comp_t ac_mem; - comp_t ac_io; - comp_t ac_rw; - comp_t ac_minflt; - comp_t ac_majflt; - comp_t ac_swaps; - __u16 ac_ahz; - __u32 ac_exitcode; - char ac_comm[17]; - __u8 ac_etime_hi; - __u16 ac_etime_lo; - __u32 ac_uid; - __u32 ac_gid; +struct trace_pid_list { + int pid_max; + long unsigned int *pids; }; -typedef struct acct acct_t; +typedef bool (*cond_update_fn_t)(struct trace_array *, void *); -struct fs_pin { - wait_queue_head_t wait; - int done; - struct hlist_node s_list; - struct hlist_node m_list; - void (*kill)(struct fs_pin *); +enum { + TRACE_ARRAY_FL_GLOBAL = 1, }; -struct bsd_acct_struct { - struct fs_pin pin; - atomic_long_t count; - struct callback_head rcu; - struct mutex lock; - int active; - long unsigned int needcheck; - struct file *file; - struct pid_namespace *ns; - struct work_struct work; - struct completion done; +struct tracer_opt { + const char *name; + u32 bit; }; -enum compound_dtor_id { - NULL_COMPOUND_DTOR = 0, - COMPOUND_PAGE_DTOR = 1, - HUGETLB_PAGE_DTOR = 2, - NR_COMPOUND_DTORS = 3, +struct tracer_flags { + u32 val; + struct tracer_opt *opts; + struct tracer *trace; }; -struct elf64_note { - Elf64_Word n_namesz; - Elf64_Word n_descsz; - Elf64_Word n_type; +struct trace_parser { + bool cont; + char *buffer; + unsigned int idx; + unsigned int size; }; -typedef long unsigned int elf_greg_t; - -typedef elf_greg_t elf_gregset_t[27]; - -struct elf_siginfo { - int si_signo; - int si_code; - int si_errno; +enum trace_iterator_bits { + TRACE_ITER_PRINT_PARENT_BIT = 0, + TRACE_ITER_SYM_OFFSET_BIT = 1, + TRACE_ITER_SYM_ADDR_BIT = 2, + TRACE_ITER_VERBOSE_BIT = 3, + TRACE_ITER_RAW_BIT = 4, + TRACE_ITER_HEX_BIT = 5, + TRACE_ITER_BIN_BIT = 6, + TRACE_ITER_BLOCK_BIT = 7, + TRACE_ITER_PRINTK_BIT = 8, + TRACE_ITER_ANNOTATE_BIT = 9, + TRACE_ITER_USERSTACKTRACE_BIT = 10, + TRACE_ITER_SYM_USEROBJ_BIT = 11, + TRACE_ITER_PRINTK_MSGONLY_BIT = 12, + TRACE_ITER_CONTEXT_INFO_BIT = 13, + TRACE_ITER_LATENCY_FMT_BIT = 14, + TRACE_ITER_RECORD_CMD_BIT = 15, + TRACE_ITER_RECORD_TGID_BIT = 16, + TRACE_ITER_OVERWRITE_BIT = 17, + TRACE_ITER_STOP_ON_FREE_BIT = 18, + TRACE_ITER_IRQ_INFO_BIT = 19, + TRACE_ITER_MARKERS_BIT = 20, + TRACE_ITER_EVENT_FORK_BIT = 21, + TRACE_ITER_STACKTRACE_BIT = 22, + TRACE_ITER_LAST_BIT = 23, }; -struct elf_prstatus { - struct elf_siginfo pr_info; - short int pr_cursig; - long unsigned int pr_sigpend; - long unsigned int pr_sighold; - pid_t pr_pid; - pid_t pr_ppid; - pid_t pr_pgrp; - pid_t pr_sid; - struct __kernel_old_timeval pr_utime; - struct __kernel_old_timeval pr_stime; - struct __kernel_old_timeval pr_cutime; - struct __kernel_old_timeval pr_cstime; - elf_gregset_t pr_reg; - int pr_fpvalid; +enum trace_iterator_flags { + TRACE_ITER_PRINT_PARENT = 1, + TRACE_ITER_SYM_OFFSET = 2, + TRACE_ITER_SYM_ADDR = 4, + TRACE_ITER_VERBOSE = 8, + TRACE_ITER_RAW = 16, + TRACE_ITER_HEX = 32, + TRACE_ITER_BIN = 64, + TRACE_ITER_BLOCK = 128, + TRACE_ITER_PRINTK = 256, + TRACE_ITER_ANNOTATE = 512, + TRACE_ITER_USERSTACKTRACE = 1024, + TRACE_ITER_SYM_USEROBJ = 2048, + TRACE_ITER_PRINTK_MSGONLY = 4096, + TRACE_ITER_CONTEXT_INFO = 8192, + TRACE_ITER_LATENCY_FMT = 16384, + TRACE_ITER_RECORD_CMD = 32768, + TRACE_ITER_RECORD_TGID = 65536, + TRACE_ITER_OVERWRITE = 131072, + TRACE_ITER_STOP_ON_FREE = 262144, + TRACE_ITER_IRQ_INFO = 524288, + TRACE_ITER_MARKERS = 1048576, + TRACE_ITER_EVENT_FORK = 2097152, + TRACE_ITER_STACKTRACE = 4194304, }; -typedef u32 note_buf_t[92]; - -struct compat_kexec_segment { - compat_uptr_t buf; - compat_size_t bufsz; - compat_ulong_t mem; - compat_size_t memsz; +struct event_subsystem { + struct list_head list; + const char *name; + struct event_filter *filter; + int ref_count; }; -enum migrate_reason { - MR_COMPACTION = 0, - MR_MEMORY_FAILURE = 1, - MR_MEMORY_HOTPLUG = 2, - MR_SYSCALL = 3, - MR_MEMPOLICY_MBIND = 4, - MR_NUMA_MISPLACED = 5, - MR_CONTIG_RANGE = 6, - MR_TYPES = 7, +struct saved_cmdlines_buffer { + unsigned int map_pid_to_cmdline[32769]; + unsigned int *map_cmdline_to_pid; + unsigned int cmdline_num; + int cmdline_idx; + char *saved_cmdlines; }; -typedef __kernel_ulong_t __kernel_ino_t; - -typedef __kernel_ino_t ino_t; - -enum fs_context_purpose { - FS_CONTEXT_FOR_MOUNT = 0, - FS_CONTEXT_FOR_SUBMOUNT = 1, - FS_CONTEXT_FOR_RECONFIGURE = 2, +struct ftrace_stack { + long unsigned int calls[1024]; }; -enum fs_context_phase { - FS_CONTEXT_CREATE_PARAMS = 0, - FS_CONTEXT_CREATING = 1, - FS_CONTEXT_AWAITING_MOUNT = 2, - FS_CONTEXT_AWAITING_RECONF = 3, - FS_CONTEXT_RECONF_PARAMS = 4, - FS_CONTEXT_RECONFIGURING = 5, - FS_CONTEXT_FAILED = 6, +struct ftrace_stacks { + struct ftrace_stack stacks[4]; }; -struct fs_context_operations; +struct trace_buffer_struct { + int nesting; + char buffer[4096]; +}; -struct fc_log; +struct ftrace_buffer_info { + struct trace_iterator iter; + void *spare; + unsigned int spare_cpu; + unsigned int read; +}; -struct fs_context { - const struct fs_context_operations *ops; - struct mutex uapi_mutex; - struct file_system_type *fs_type; - void *fs_private; - void *sget_key; - struct dentry *root; - struct user_namespace *user_ns; - struct net *net_ns; - const struct cred *cred; - struct fc_log *log; - const char *source; - void *security; - void *s_fs_info; - unsigned int sb_flags; - unsigned int sb_flags_mask; - unsigned int s_iflags; - unsigned int lsm_flags; - enum fs_context_purpose purpose: 8; - enum fs_context_phase phase: 8; - bool need_free: 1; - bool global: 1; +struct err_info { + const char **errs; + u8 type; + u8 pos; + u64 ts; }; -enum kernfs_node_type { - KERNFS_DIR = 1, - KERNFS_FILE = 2, - KERNFS_LINK = 4, +struct tracing_log_err { + struct list_head list; + struct err_info info; + char loc[128]; + char cmd[256]; }; -enum kernfs_root_flag { - KERNFS_ROOT_CREATE_DEACTIVATED = 1, - KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK = 2, - KERNFS_ROOT_SUPPORT_EXPORTOP = 4, +struct buffer_ref { + struct ring_buffer *buffer; + void *page; + int cpu; + refcount_t refcount; }; -struct kernfs_fs_context { - struct kernfs_root *root; - void *ns_tag; - long unsigned int magic; - bool new_sb_created; +struct ctx_switch_entry { + struct trace_entry ent; + unsigned int prev_pid; + unsigned int next_pid; + unsigned int next_cpu; + unsigned char prev_prio; + unsigned char prev_state; + unsigned char next_prio; + unsigned char next_state; }; -enum { - __PERCPU_REF_ATOMIC = 1, - __PERCPU_REF_DEAD = 2, - __PERCPU_REF_ATOMIC_DEAD = 3, - __PERCPU_REF_FLAG_BITS = 2, +struct hwlat_entry { + struct trace_entry ent; + u64 duration; + u64 outer_duration; + u64 nmi_total_ts; + struct timespec64 timestamp; + unsigned int nmi_count; + unsigned int seqnum; }; -enum { - CSS_NO_REF = 1, - CSS_ONLINE = 2, - CSS_RELEASED = 4, - CSS_VISIBLE = 8, - CSS_DYING = 16, +struct trace_mark { + long long unsigned int val; + char sym; }; -enum { - CGRP_NOTIFY_ON_RELEASE = 0, - CGRP_CPUSET_CLONE_CHILDREN = 1, - CGRP_FREEZE = 2, - CGRP_FROZEN = 3, +typedef int (*cmp_func_t)(const void *, const void *); + +struct tracer_stat { + const char *name; + void * (*stat_start)(struct tracer_stat *); + void * (*stat_next)(void *, int); + cmp_func_t stat_cmp; + int (*stat_show)(struct seq_file *, void *); + void (*stat_release)(void *); + int (*stat_headers)(struct seq_file *); }; -enum { - CGRP_ROOT_NOPREFIX = 2, - CGRP_ROOT_XATTR = 4, - CGRP_ROOT_NS_DELEGATE = 8, - CGRP_ROOT_CPUSET_V2_MODE = 16, - CGRP_ROOT_MEMORY_LOCAL_EVENTS = 32, +struct stat_node { + struct rb_node node; + void *stat; }; -struct cgroup_taskset { - struct list_head src_csets; - struct list_head dst_csets; - int nr_tasks; - int ssid; - struct list_head *csets; - struct css_set *cur_cset; - struct task_struct *cur_task; +struct stat_session { + struct list_head session_list; + struct tracer_stat *ts; + struct rb_root stat_root; + struct mutex stat_mutex; + struct dentry *file; }; -struct css_task_iter { - struct cgroup_subsys *ss; - unsigned int flags; - struct list_head *cset_pos; - struct list_head *cset_head; - struct list_head *tcset_pos; - struct list_head *tcset_head; - struct list_head *task_pos; - struct list_head *tasks_head; - struct list_head *mg_tasks_head; - struct list_head *dying_tasks_head; - struct css_set *cur_cset; - struct css_set *cur_dcset; - struct task_struct *cur_task; - struct list_head iters_node; +struct trace_bprintk_fmt { + struct list_head list; + const char *fmt; }; -enum fs_value_type { - fs_value_is_undefined = 0, - fs_value_is_flag = 1, - fs_value_is_string = 2, - fs_value_is_blob = 3, - fs_value_is_filename = 4, - fs_value_is_filename_empty = 5, - fs_value_is_file = 6, +enum { + TRACE_NOP_OPT_ACCEPT = 1, + TRACE_NOP_OPT_REFUSE = 2, }; -struct fs_parameter { - const char *key; - enum fs_value_type type: 8; - union { - char *string; - void *blob; - struct filename *name; - struct file *file; +typedef __u32 blk_mq_req_flags_t; + +struct blk_mq_ctxs; + +struct blk_mq_ctx { + struct { + spinlock_t lock; + struct list_head rq_lists[3]; + long: 64; }; - size_t size; - int dirfd; + unsigned int cpu; + short unsigned int index_hw[3]; + struct blk_mq_hw_ctx *hctxs[3]; + long unsigned int rq_dispatched[2]; + long unsigned int rq_merged; + long unsigned int rq_completed[2]; + struct request_queue *queue; + struct blk_mq_ctxs *ctxs; + struct kobject kobj; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct fs_context_operations { - void (*free)(struct fs_context *); - int (*dup)(struct fs_context *, struct fs_context *); - int (*parse_param)(struct fs_context *, struct fs_parameter *); - int (*parse_monolithic)(struct fs_context *, void *); - int (*get_tree)(struct fs_context *); - int (*reconfigure)(struct fs_context *); +struct sbitmap_word; + +struct sbitmap { + unsigned int depth; + unsigned int shift; + unsigned int map_nr; + struct sbitmap_word *map; }; -struct fc_log { - refcount_t usage; - u8 head; - u8 tail; - u8 need_free; - struct module *owner; - char *buffer[8]; +struct blk_mq_tags; + +struct blk_mq_hw_ctx { + struct { + spinlock_t lock; + struct list_head dispatch; + long unsigned int state; + long: 64; + long: 64; + long: 64; + long: 64; + }; + struct delayed_work run_work; + cpumask_var_t cpumask; + int next_cpu; + int next_cpu_batch; + long unsigned int flags; + void *sched_data; + struct request_queue *queue; + struct blk_flush_queue *fq; + void *driver_data; + struct sbitmap ctx_map; + struct blk_mq_ctx *dispatch_from; + unsigned int dispatch_busy; + short unsigned int type; + short unsigned int nr_ctx; + struct blk_mq_ctx **ctxs; + spinlock_t dispatch_wait_lock; + wait_queue_entry_t dispatch_wait; + atomic_t wait_index; + struct blk_mq_tags *tags; + struct blk_mq_tags *sched_tags; + long unsigned int queued; + long unsigned int run; + long unsigned int dispatched[7]; + unsigned int numa_node; + unsigned int queue_num; + atomic_t nr_active; + struct hlist_node cpuhp_dead; + struct kobject kobj; + long unsigned int poll_considered; + long unsigned int poll_invoked; + long unsigned int poll_success; + struct dentry *debugfs_dir; + struct dentry *sched_debugfs_dir; + struct list_head hctx_list; + struct srcu_struct srcu[0]; + long: 64; + long: 64; + long: 64; }; -struct cgroup_fs_context { - struct kernfs_fs_context kfc; - struct cgroup_root *root; - struct cgroup_namespace *ns; - unsigned int flags; - bool cpuset_clone_children; - bool none; - bool all_ss; - u16 subsys_mask; - char *name; - char *release_agent; +struct blk_mq_alloc_data { + struct request_queue *q; + blk_mq_req_flags_t flags; + unsigned int shallow_depth; + unsigned int cmd_flags; + struct blk_mq_ctx *ctx; + struct blk_mq_hw_ctx *hctx; }; -struct cgrp_cset_link { - struct cgroup *cgrp; - struct css_set *cset; - struct list_head cset_link; - struct list_head cgrp_link; +struct blk_stat_callback { + struct list_head list; + struct timer_list timer; + struct blk_rq_stat *cpu_stat; + int (*bucket_fn)(const struct request *); + unsigned int buckets; + struct blk_rq_stat *stat; + void (*timer_fn)(struct blk_stat_callback *); + void *data; + struct callback_head rcu; }; -struct cgroup_mgctx { - struct list_head preloaded_src_csets; - struct list_head preloaded_dst_csets; - struct cgroup_taskset tset; - u16 ss_mask; +struct blk_trace { + int trace_state; + struct rchan *rchan; + long unsigned int *sequence; + unsigned char *msg_data; + u16 act_mask; + u64 start_lba; + u64 end_lba; + u32 pid; + u32 dev; + struct dentry *dir; + struct dentry *dropped_file; + struct dentry *msg_file; + struct list_head running_list; + atomic_t dropped; }; -enum fs_parameter_type { - __fs_param_wasnt_defined = 0, - fs_param_is_flag = 1, - fs_param_is_bool = 2, - fs_param_is_u32 = 3, - fs_param_is_u32_octal = 4, - fs_param_is_u32_hex = 5, - fs_param_is_s32 = 6, - fs_param_is_u64 = 7, - fs_param_is_enum = 8, - fs_param_is_string = 9, - fs_param_is_blob = 10, - fs_param_is_blockdev = 11, - fs_param_is_path = 12, - fs_param_is_fd = 13, - nr__fs_parameter_type = 14, +struct blk_flush_queue { + unsigned int flush_queue_delayed: 1; + unsigned int flush_pending_idx: 1; + unsigned int flush_running_idx: 1; + blk_status_t rq_status; + long unsigned int flush_pending_since; + struct list_head flush_queue[2]; + struct list_head flush_data_in_flight; + struct request *flush_rq; + struct request *orig_rq; + struct lock_class_key key; + spinlock_t mq_flush_lock; }; -struct fs_parameter_spec { - const char *name; - u8 opt; - enum fs_parameter_type type: 8; - short unsigned int flags; +struct blk_mq_queue_map { + unsigned int *mq_map; + unsigned int nr_queues; + unsigned int queue_offset; }; -struct fs_parameter_enum { - u8 opt; - char name[14]; - u8 value; +struct blk_mq_tag_set { + struct blk_mq_queue_map map[3]; + unsigned int nr_maps; + const struct blk_mq_ops *ops; + unsigned int nr_hw_queues; + unsigned int queue_depth; + unsigned int reserved_tags; + unsigned int cmd_size; + int numa_node; + unsigned int timeout; + unsigned int flags; + void *driver_data; + struct blk_mq_tags **tags; + struct mutex tag_list_lock; + struct list_head tag_list; }; -struct fs_parse_result { - bool negated; - bool has_value; - union { - bool boolean; - int int_32; - unsigned int uint_32; - u64 uint_64; - }; +typedef u64 compat_u64; + +enum blktrace_cat { + BLK_TC_READ = 1, + BLK_TC_WRITE = 2, + BLK_TC_FLUSH = 4, + BLK_TC_SYNC = 8, + BLK_TC_SYNCIO = 8, + BLK_TC_QUEUE = 16, + BLK_TC_REQUEUE = 32, + BLK_TC_ISSUE = 64, + BLK_TC_COMPLETE = 128, + BLK_TC_FS = 256, + BLK_TC_PC = 512, + BLK_TC_NOTIFY = 1024, + BLK_TC_AHEAD = 2048, + BLK_TC_META = 4096, + BLK_TC_DISCARD = 8192, + BLK_TC_DRV_DATA = 16384, + BLK_TC_FUA = 32768, + BLK_TC_END = 32768, }; -struct trace_event_raw_cgroup_root { - struct trace_entry ent; - int root; - u16 ss_mask; - u32 __data_loc_name; - char __data[0]; +enum blktrace_act { + __BLK_TA_QUEUE = 1, + __BLK_TA_BACKMERGE = 2, + __BLK_TA_FRONTMERGE = 3, + __BLK_TA_GETRQ = 4, + __BLK_TA_SLEEPRQ = 5, + __BLK_TA_REQUEUE = 6, + __BLK_TA_ISSUE = 7, + __BLK_TA_COMPLETE = 8, + __BLK_TA_PLUG = 9, + __BLK_TA_UNPLUG_IO = 10, + __BLK_TA_UNPLUG_TIMER = 11, + __BLK_TA_INSERT = 12, + __BLK_TA_SPLIT = 13, + __BLK_TA_BOUNCE = 14, + __BLK_TA_REMAP = 15, + __BLK_TA_ABORT = 16, + __BLK_TA_DRV_DATA = 17, + __BLK_TA_CGROUP = 256, }; -struct trace_event_raw_cgroup { - struct trace_entry ent; - int root; - int id; - int level; - u32 __data_loc_path; - char __data[0]; +enum blktrace_notify { + __BLK_TN_PROCESS = 0, + __BLK_TN_TIMESTAMP = 1, + __BLK_TN_MESSAGE = 2, + __BLK_TN_CGROUP = 256, }; -struct trace_event_raw_cgroup_migrate { - struct trace_entry ent; - int dst_root; - int dst_id; - int dst_level; - int pid; - u32 __data_loc_dst_path; - u32 __data_loc_comm; - char __data[0]; +struct blk_io_trace { + __u32 magic; + __u32 sequence; + __u64 time; + __u64 sector; + __u32 bytes; + __u32 action; + __u32 pid; + __u32 device; + __u32 cpu; + __u16 error; + __u16 pdu_len; }; -struct trace_event_raw_cgroup_event { - struct trace_entry ent; - int root; - int id; - int level; - u32 __data_loc_path; - int val; - char __data[0]; +struct blk_io_trace_remap { + __be32 device_from; + __be32 device_to; + __be64 sector_from; }; -struct trace_event_data_offsets_cgroup_root { - u32 name; +enum { + Blktrace_setup = 1, + Blktrace_running = 2, + Blktrace_stopped = 3, }; -struct trace_event_data_offsets_cgroup { - u32 path; +struct blk_user_trace_setup { + char name[32]; + __u16 act_mask; + __u32 buf_size; + __u32 buf_nr; + __u64 start_lba; + __u64 end_lba; + __u32 pid; }; -struct trace_event_data_offsets_cgroup_migrate { - u32 dst_path; - u32 comm; -}; +struct compat_blk_user_trace_setup { + char name[32]; + u16 act_mask; + short: 16; + u32 buf_size; + u32 buf_nr; + compat_u64 start_lba; + compat_u64 end_lba; + u32 pid; +} __attribute__((packed)); -struct trace_event_data_offsets_cgroup_event { - u32 path; -}; +struct blkcg {}; -enum cgroup2_param { - Opt_nsdelegate = 0, - Opt_memory_localevents = 1, - nr__cgroup2_params = 2, +struct sbitmap_word { + long unsigned int depth; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long unsigned int word; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long unsigned int cleared; + spinlock_t swap_lock; + long: 32; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct cgroupstats { - __u64 nr_sleeping; - __u64 nr_running; - __u64 nr_stopped; - __u64 nr_uninterruptible; - __u64 nr_io_wait; +struct sbq_wait_state { + atomic_t wait_cnt; + wait_queue_head_t wait; + long: 64; + long: 64; + long: 64; + long: 64; }; -enum cgroup_filetype { - CGROUP_FILE_PROCS = 0, - CGROUP_FILE_TASKS = 1, +struct sbitmap_queue { + struct sbitmap sb; + unsigned int *alloc_hint; + unsigned int wake_batch; + atomic_t wake_index; + struct sbq_wait_state *ws; + atomic_t ws_active; + bool round_robin; + unsigned int min_shallow_depth; }; -struct cgroup_pidlist { - struct { - enum cgroup_filetype type; - struct pid_namespace *ns; - } key; - pid_t *list; - int length; - struct list_head links; - struct cgroup *owner; - struct delayed_work destroy_dwork; +struct blk_mq_tags { + unsigned int nr_tags; + unsigned int nr_reserved_tags; + atomic_t active_queues; + struct sbitmap_queue bitmap_tags; + struct sbitmap_queue breserved_tags; + struct request **rqs; + struct request **static_rqs; + struct list_head page_list; }; -enum cgroup1_param { - Opt_all = 0, - Opt_clone_children = 1, - Opt_cpuset_v2_mode = 2, - Opt_name = 3, - Opt_none = 4, - Opt_noprefix = 5, - Opt_release_agent = 6, - Opt_xattr = 7, +struct blk_mq_queue_data { + struct request *rq; + bool last; }; -enum freezer_state_flags { - CGROUP_FREEZER_ONLINE = 1, - CGROUP_FREEZING_SELF = 2, - CGROUP_FREEZING_PARENT = 4, - CGROUP_FROZEN = 8, - CGROUP_FREEZING = 6, +struct blk_mq_ctxs { + struct kobject kobj; + struct blk_mq_ctx *queue_ctx; }; -struct freezer { - struct cgroup_subsys_state css; - unsigned int state; -}; +typedef void blk_log_action_t(struct trace_iterator *, const char *, bool); -struct fmeter { - int cnt; - int val; - time64_t time; - spinlock_t lock; +struct ftrace_event_field { + struct list_head link; + const char *name; + const char *type; + int filter_type; + int offset; + int size; + int is_signed; }; -struct cpuset { - struct cgroup_subsys_state css; - long unsigned int flags; - cpumask_var_t cpus_allowed; - nodemask_t mems_allowed; - cpumask_var_t effective_cpus; - nodemask_t effective_mems; - cpumask_var_t subparts_cpus; - nodemask_t old_mems_allowed; - struct fmeter fmeter; - int attach_in_progress; - int pn; - int relax_domain_level; - int nr_subparts_cpus; - int partition_root_state; - int use_parent_ecpus; - int child_ecpus_count; +enum { + FORMAT_HEADER = 1, + FORMAT_FIELD_SEPERATOR = 2, + FORMAT_PRINTFMT = 3, }; -struct tmpmasks { - cpumask_var_t addmask; - cpumask_var_t delmask; - cpumask_var_t new_cpus; -}; +struct ftrace_graph_ent { + long unsigned int func; + int depth; +} __attribute__((packed)); -typedef enum { - CS_ONLINE = 0, - CS_CPU_EXCLUSIVE = 1, - CS_MEM_EXCLUSIVE = 2, - CS_MEM_HARDWALL = 3, - CS_MEMORY_MIGRATE = 4, - CS_SCHED_LOAD_BALANCE = 5, - CS_SPREAD_PAGE = 6, - CS_SPREAD_SLAB = 7, -} cpuset_flagbits_t; +struct ftrace_graph_ret { + long unsigned int func; + long unsigned int overrun; + long long unsigned int calltime; + long long unsigned int rettime; + int depth; +} __attribute__((packed)); -enum subparts_cmd { - partcmd_enable = 0, - partcmd_disable = 1, - partcmd_update = 2, +struct mmiotrace_rw { + resource_size_t phys; + long unsigned int value; + long unsigned int pc; + int map_id; + unsigned char opcode; + unsigned char width; }; -struct cpuset_migrate_mm_work { - struct work_struct work; - struct mm_struct *mm; - nodemask_t from; - nodemask_t to; +struct mmiotrace_map { + resource_size_t phys; + long unsigned int virt; + long unsigned int len; + int map_id; + unsigned char opcode; }; -typedef enum { - FILE_MEMORY_MIGRATE = 0, - FILE_CPULIST = 1, - FILE_MEMLIST = 2, - FILE_EFFECTIVE_CPULIST = 3, - FILE_EFFECTIVE_MEMLIST = 4, - FILE_SUBPARTS_CPULIST = 5, - FILE_CPU_EXCLUSIVE = 6, - FILE_MEM_EXCLUSIVE = 7, - FILE_MEM_HARDWALL = 8, - FILE_SCHED_LOAD_BALANCE = 9, - FILE_PARTITION_ROOT = 10, - FILE_SCHED_RELAX_DOMAIN_LEVEL = 11, - FILE_MEMORY_PRESSURE_ENABLED = 12, - FILE_MEMORY_PRESSURE = 13, - FILE_SPREAD_PAGE = 14, - FILE_SPREAD_SLAB = 15, -} cpuset_filetype_t; - -struct root_domain___2; +struct ftrace_graph_ent_entry { + struct trace_entry ent; + struct ftrace_graph_ent graph_ent; +} __attribute__((packed)); -struct cpu_stop_done { - atomic_t nr_todo; - int ret; - struct completion completion; -}; +struct ftrace_graph_ret_entry { + struct trace_entry ent; + struct ftrace_graph_ret ret; +} __attribute__((packed)); -struct cpu_stopper { - struct task_struct *thread; - raw_spinlock_t lock; - bool enabled; - struct list_head works; - struct cpu_stop_work stop_work; +struct trace_mmiotrace_rw { + struct trace_entry ent; + struct mmiotrace_rw rw; }; -enum multi_stop_state { - MULTI_STOP_NONE = 0, - MULTI_STOP_PREPARE = 1, - MULTI_STOP_DISABLE_IRQ = 2, - MULTI_STOP_RUN = 3, - MULTI_STOP_EXIT = 4, +struct trace_mmiotrace_map { + struct trace_entry ent; + struct mmiotrace_map map; }; -struct multi_stop_data { - cpu_stop_fn_t fn; - void *data; - unsigned int num_threads; - const struct cpumask *active_cpus; - enum multi_stop_state state; - atomic_t thread_ack; +struct trace_branch { + struct trace_entry ent; + unsigned int line; + char func[31]; + char file[21]; + char correct; + char constant; }; -typedef int __kernel_mqd_t; +typedef long unsigned int perf_trace_t[256]; -typedef __kernel_mqd_t mqd_t; +struct filter_pred; -enum audit_state { - AUDIT_DISABLED = 0, - AUDIT_BUILD_CONTEXT = 1, - AUDIT_RECORD_CONTEXT = 2, +struct prog_entry { + int target; + int when_to_branch; + struct filter_pred *pred; }; -struct audit_cap_data { - kernel_cap_t permitted; - kernel_cap_t inheritable; - union { - unsigned int fE; - kernel_cap_t effective; - }; - kernel_cap_t ambient; - kuid_t rootid; -}; +typedef int (*filter_pred_fn_t)(struct filter_pred *, void *); -struct audit_names { - struct list_head list; - struct filename *name; - int name_len; - bool hidden; - long unsigned int ino; - dev_t dev; - umode_t mode; - kuid_t uid; - kgid_t gid; - dev_t rdev; - u32 osid; - struct audit_cap_data fcap; - unsigned int fcap_ver; - unsigned char type; - bool should_free; -}; +struct regex; -struct mq_attr { - __kernel_long_t mq_flags; - __kernel_long_t mq_maxmsg; - __kernel_long_t mq_msgsize; - __kernel_long_t mq_curmsgs; - __kernel_long_t __reserved[4]; -}; +typedef int (*regex_match_func)(char *, struct regex *, int); -struct audit_proctitle { +struct regex { + char pattern[256]; int len; - char *value; + int field_len; + regex_match_func match; }; -struct audit_aux_data; - -struct __kernel_sockaddr_storage; - -struct audit_tree_refs; +struct filter_pred { + filter_pred_fn_t fn; + u64 val; + struct regex regex; + short unsigned int *ops; + struct ftrace_event_field *field; + int offset; + int not; + int op; +}; -struct audit_context { - int dummy; - int in_syscall; - enum audit_state state; - enum audit_state current_state; - unsigned int serial; - int major; - struct timespec64 ctime; - long unsigned int argv[4]; - long int return_code; - u64 prio; - int return_valid; - struct audit_names preallocated_names[5]; - int name_count; - struct list_head names_list; - char *filterkey; - struct path pwd; - struct audit_aux_data *aux; - struct audit_aux_data *aux_pids; - struct __kernel_sockaddr_storage *sockaddr; - size_t sockaddr_len; - pid_t pid; - pid_t ppid; - kuid_t uid; - kuid_t euid; - kuid_t suid; - kuid_t fsuid; - kgid_t gid; - kgid_t egid; - kgid_t sgid; - kgid_t fsgid; - long unsigned int personality; - int arch; - pid_t target_pid; - kuid_t target_auid; - kuid_t target_uid; - unsigned int target_sessionid; - u32 target_sid; - char target_comm[16]; - struct audit_tree_refs *trees; - struct audit_tree_refs *first_trees; - struct list_head killed_trees; - int tree_count; - int type; - union { - struct { - int nargs; - long int args[6]; - } socketcall; - struct { - kuid_t uid; - kgid_t gid; - umode_t mode; - u32 osid; - int has_perm; - uid_t perm_uid; - gid_t perm_gid; - umode_t perm_mode; - long unsigned int qbytes; - } ipc; - struct { - mqd_t mqdes; - struct mq_attr mqstat; - } mq_getsetattr; - struct { - mqd_t mqdes; - int sigev_signo; - } mq_notify; - struct { - mqd_t mqdes; - size_t msg_len; - unsigned int msg_prio; - struct timespec64 abs_timeout; - } mq_sendrecv; - struct { - int oflag; - umode_t mode; - struct mq_attr attr; - } mq_open; - struct { - pid_t pid; - struct audit_cap_data cap; - } capset; - struct { - int fd; - int flags; - } mmap; - struct { - int argc; - } execve; - struct { - char *name; - } module; - }; - int fds[2]; - struct audit_proctitle proctitle; +enum regex_type { + MATCH_FULL = 0, + MATCH_FRONT_ONLY = 1, + MATCH_MIDDLE_ONLY = 2, + MATCH_END_ONLY = 3, + MATCH_GLOB = 4, + MATCH_INDEX = 5, }; -enum audit_nlgrps { - AUDIT_NLGRP_NONE = 0, - AUDIT_NLGRP_READLOG = 1, - __AUDIT_NLGRP_MAX = 2, +enum filter_op_ids { + OP_GLOB = 0, + OP_NE = 1, + OP_EQ = 2, + OP_LE = 3, + OP_LT = 4, + OP_GE = 5, + OP_GT = 6, + OP_BAND = 7, + OP_MAX = 8, }; -struct audit_status { - __u32 mask; - __u32 enabled; - __u32 failure; - __u32 pid; - __u32 rate_limit; - __u32 backlog_limit; - __u32 lost; - __u32 backlog; - union { - __u32 version; - __u32 feature_bitmap; - }; - __u32 backlog_wait_time; +enum { + FILT_ERR_NONE = 0, + FILT_ERR_INVALID_OP = 1, + FILT_ERR_TOO_MANY_OPEN = 2, + FILT_ERR_TOO_MANY_CLOSE = 3, + FILT_ERR_MISSING_QUOTE = 4, + FILT_ERR_OPERAND_TOO_LONG = 5, + FILT_ERR_EXPECT_STRING = 6, + FILT_ERR_EXPECT_DIGIT = 7, + FILT_ERR_ILLEGAL_FIELD_OP = 8, + FILT_ERR_FIELD_NOT_FOUND = 9, + FILT_ERR_ILLEGAL_INTVAL = 10, + FILT_ERR_BAD_SUBSYS_FILTER = 11, + FILT_ERR_TOO_MANY_PREDS = 12, + FILT_ERR_INVALID_FILTER = 13, + FILT_ERR_IP_FIELD_ONLY = 14, + FILT_ERR_INVALID_VALUE = 15, + FILT_ERR_ERRNO = 16, + FILT_ERR_NO_FILTER = 17, }; -struct audit_features { - __u32 vers; - __u32 mask; - __u32 features; - __u32 lock; +struct filter_parse_error { + int lasterr; + int lasterr_pos; }; -struct audit_tty_status { - __u32 enabled; - __u32 log_passwd; +typedef int (*parse_pred_fn)(const char *, void *, int, struct filter_parse_error *, struct filter_pred **); + +enum { + INVERT = 1, + PROCESS_AND = 2, + PROCESS_OR = 4, }; -struct audit_sig_info { - uid_t uid; - pid_t pid; - char ctx[0]; +enum { + TOO_MANY_CLOSE = 4294967295, + TOO_MANY_OPEN = 4294967294, + MISSING_QUOTE = 4294967293, }; -struct __kernel_sockaddr_storage { - union { - struct { - __kernel_sa_family_t ss_family; - char __data[126]; - }; - void *__align; - }; +struct filter_list { + struct list_head list; + struct event_filter *filter; }; -struct net_generic { - union { - struct { - unsigned int len; - struct callback_head rcu; - } s; - void *ptr[0]; - }; +struct event_trigger_ops; + +struct event_command; + +struct event_trigger_data { + long unsigned int count; + int ref; + struct event_trigger_ops *ops; + struct event_command *cmd_ops; + struct event_filter *filter; + char *filter_str; + void *private_data; + bool paused; + bool paused_tmp; + struct list_head list; + char *name; + struct list_head named_list; + struct event_trigger_data *named_data; }; -struct pernet_operations { +struct event_trigger_ops { + void (*func)(struct event_trigger_data *, void *, struct ring_buffer_event *); + int (*init)(struct event_trigger_ops *, struct event_trigger_data *); + void (*free)(struct event_trigger_ops *, struct event_trigger_data *); + int (*print)(struct seq_file *, struct event_trigger_ops *, struct event_trigger_data *); +}; + +struct event_command { struct list_head list; - int (*init)(struct net *); - void (*pre_exit)(struct net *); - void (*exit)(struct net *); - void (*exit_batch)(struct list_head *); - unsigned int *id; - size_t size; + char *name; + enum event_trigger_type trigger_type; + int flags; + int (*func)(struct event_command *, struct trace_event_file *, char *, char *, char *); + int (*reg)(char *, struct event_trigger_ops *, struct event_trigger_data *, struct trace_event_file *); + void (*unreg)(char *, struct event_trigger_ops *, struct event_trigger_data *, struct trace_event_file *); + void (*unreg_all)(struct trace_event_file *); + int (*set_filter)(char *, struct event_trigger_data *, struct trace_event_file *); + struct event_trigger_ops * (*get_trigger_ops)(char *, char *); }; -struct scm_creds { - u32 pid; - kuid_t uid; - kgid_t gid; +struct enable_trigger_data { + struct trace_event_file *file; + bool enable; + bool hist; }; -struct netlink_skb_parms { - struct scm_creds creds; - __u32 portid; - __u32 dst_group; - __u32 flags; - struct sock *sk; - bool nsid_is_set; - int nsid; +enum event_command_flags { + EVENT_CMD_FL_POST_TRIGGER = 1, + EVENT_CMD_FL_NEEDS_REC = 2, }; -struct netlink_kernel_cfg { - unsigned int groups; - unsigned int flags; - void (*input)(struct sk_buff *); - struct mutex *cb_mutex; - int (*bind)(struct net *, int); - void (*unbind)(struct net *, int); - bool (*compare)(struct net *, struct sock *); +enum { + BPF_F_INDEX_MASK = 4294967295, + BPF_F_CURRENT_CPU = 4294967295, + BPF_F_CTXLEN_MASK = 0, }; -struct audit_netlink_list { - __u32 portid; - struct net *net; - struct sk_buff_head q; +struct bpf_perf_event_value { + __u64 counter; + __u64 enabled; + __u64 running; }; -struct audit_net { - struct sock *sk; +struct bpf_raw_tracepoint_args { + __u64 args[0]; }; -struct auditd_connection { - struct pid *pid; - u32 portid; - struct net *net; - struct callback_head rcu; +enum bpf_task_fd_type { + BPF_FD_TYPE_RAW_TRACEPOINT = 0, + BPF_FD_TYPE_TRACEPOINT = 1, + BPF_FD_TYPE_KPROBE = 2, + BPF_FD_TYPE_KRETPROBE = 3, + BPF_FD_TYPE_UPROBE = 4, + BPF_FD_TYPE_URETPROBE = 5, }; -struct audit_ctl_mutex { - struct mutex lock; - void *owner; +struct bpf_event_entry { + struct perf_event *event; + struct file *perf_file; + struct file *map_file; + struct callback_head rcu; }; -struct audit_buffer { - struct sk_buff *skb; - struct audit_context *ctx; - gfp_t gfp_mask; +typedef long unsigned int (*bpf_ctx_copy_t)(void *, const void *, long unsigned int, long unsigned int); + +typedef struct pt_regs bpf_user_pt_regs_t; + +struct bpf_perf_event_data { + bpf_user_pt_regs_t regs; + __u64 sample_period; + __u64 addr; }; -struct audit_reply { - __u32 portid; - struct net *net; - struct sk_buff *skb; +struct perf_event_query_bpf { + __u32 ids_len; + __u32 prog_cnt; + __u32 ids[0]; }; -enum { - Audit_equal = 0, - Audit_not_equal = 1, - Audit_bitmask = 2, - Audit_bittest = 3, - Audit_lt = 4, - Audit_gt = 5, - Audit_le = 6, - Audit_ge = 7, - Audit_bad = 8, +struct bpf_perf_event_data_kern { + bpf_user_pt_regs_t *regs; + struct perf_sample_data *data; + struct perf_event *event; }; -struct audit_rule_data { - __u32 flags; - __u32 action; - __u32 field_count; - __u32 mask[64]; - __u32 fields[64]; - __u32 values[64]; - __u32 fieldflags[64]; - __u32 buflen; - char buf[0]; +struct bpf_trace_module { + struct module *module; + struct list_head list; }; -struct audit_field; +typedef u64 (*btf_bpf_override_return)(struct pt_regs *, long unsigned int); -struct audit_watch; +typedef u64 (*btf_bpf_probe_read_user)(void *, u32, const void *); -struct audit_tree; +typedef u64 (*btf_bpf_probe_read_user_str)(void *, u32, const void *); -struct audit_fsnotify_mark; +typedef u64 (*btf_bpf_probe_read_kernel)(void *, u32, const void *); -struct audit_krule { - u32 pflags; - u32 flags; - u32 listnr; - u32 action; - u32 mask[64]; - u32 buflen; - u32 field_count; - char *filterkey; - struct audit_field *fields; - struct audit_field *arch_f; - struct audit_field *inode_f; - struct audit_watch *watch; - struct audit_tree *tree; - struct audit_fsnotify_mark *exe; - struct list_head rlist; - struct list_head list; - u64 prio; -}; +typedef u64 (*btf_bpf_probe_read_compat)(void *, u32, const void *); -struct audit_field { - u32 type; - union { - u32 val; - kuid_t uid; - kgid_t gid; - struct { - char *lsm_str; - void *lsm_rule; - }; - }; - u32 op; -}; +typedef u64 (*btf_bpf_probe_read_kernel_str)(void *, u32, const void *); -struct audit_entry { - struct list_head list; - struct callback_head rcu; - struct audit_krule rule; -}; +typedef u64 (*btf_bpf_probe_read_compat_str)(void *, u32, const void *); -struct audit_buffer___2; +typedef u64 (*btf_bpf_probe_write_user)(void *, const void *, u32); -typedef int __kernel_key_t; +typedef u64 (*btf_bpf_trace_printk)(char *, u32, u64, u64, u64); -typedef __kernel_key_t key_t; +typedef u64 (*btf_bpf_perf_event_read)(struct bpf_map *, u64); -struct cpu_vfs_cap_data { - __u32 magic_etc; - kernel_cap_t permitted; - kernel_cap_t inheritable; - kuid_t rootid; -}; +typedef u64 (*btf_bpf_perf_event_read_value)(struct bpf_map *, u64, struct bpf_perf_event_value *, u32); -struct kern_ipc_perm { - spinlock_t lock; - bool deleted; - int id; - key_t key; - kuid_t uid; - kgid_t gid; - kuid_t cuid; - kgid_t cgid; - umode_t mode; - long unsigned int seq; - void *security; - struct rhash_head khtnode; - struct callback_head rcu; - refcount_t refcount; - long: 32; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +struct bpf_trace_sample_data { + struct perf_sample_data sds[3]; }; -typedef struct fsnotify_mark_connector *fsnotify_connp_t; +typedef u64 (*btf_bpf_perf_event_output)(struct pt_regs *, struct bpf_map *, u64, void *, u64); -struct fsnotify_mark_connector { - spinlock_t lock; - short unsigned int type; - short unsigned int flags; - __kernel_fsid_t fsid; - union { - fsnotify_connp_t *obj; - struct fsnotify_mark_connector *destroy_next; - }; - struct hlist_head list; +struct bpf_nested_pt_regs { + struct pt_regs regs[3]; }; -enum fsnotify_obj_type { - FSNOTIFY_OBJ_TYPE_INODE = 0, - FSNOTIFY_OBJ_TYPE_VFSMOUNT = 1, - FSNOTIFY_OBJ_TYPE_SB = 2, - FSNOTIFY_OBJ_TYPE_COUNT = 3, - FSNOTIFY_OBJ_TYPE_DETACHED = 3, +typedef u64 (*btf_bpf_get_current_task)(); + +typedef u64 (*btf_bpf_current_task_under_cgroup)(struct bpf_map *, u32); + +struct send_signal_irq_work { + struct irq_work irq_work; + struct task_struct *task; + u32 sig; }; -struct audit_aux_data { - struct audit_aux_data *next; - int type; +typedef u64 (*btf_bpf_send_signal)(u32); + +typedef u64 (*btf_bpf_perf_event_output_tp)(void *, struct bpf_map *, u64, void *, u64); + +typedef u64 (*btf_bpf_get_stackid_tp)(void *, struct bpf_map *, u64); + +typedef u64 (*btf_bpf_get_stack_tp)(void *, void *, u32, u64); + +typedef u64 (*btf_bpf_perf_prog_read_value)(struct bpf_perf_event_data_kern *, struct bpf_perf_event_value *, u32); + +struct bpf_raw_tp_regs { + struct pt_regs regs[3]; }; -struct audit_chunk; +typedef u64 (*btf_bpf_perf_event_output_raw_tp)(struct bpf_raw_tracepoint_args *, struct bpf_map *, u64, void *, u64); -struct audit_tree_refs { - struct audit_tree_refs *next; - struct audit_chunk *c[31]; +typedef u64 (*btf_bpf_get_stackid_raw_tp)(struct bpf_raw_tracepoint_args *, struct bpf_map *, u64); + +typedef u64 (*btf_bpf_get_stack_raw_tp)(struct bpf_raw_tracepoint_args *, void *, u32, u64); + +typedef struct bpf_cgroup_storage *pto_T_____19; + +struct kprobe_trace_entry_head { + struct trace_entry ent; + long unsigned int ip; }; -struct audit_aux_data_pids { - struct audit_aux_data d; - pid_t target_pid[16]; - kuid_t target_auid[16]; - kuid_t target_uid[16]; - unsigned int target_sessionid[16]; - u32 target_sid[16]; - char target_comm[256]; - int pid_count; +struct kretprobe_trace_entry_head { + struct trace_entry ent; + long unsigned int func; + long unsigned int ret_ip; }; -struct audit_aux_data_bprm_fcaps { - struct audit_aux_data d; - struct audit_cap_data fcap; - unsigned int fcap_ver; - struct audit_cap_data old_pcap; - struct audit_cap_data new_pcap; +struct dyn_event; + +struct dyn_event_operations { + struct list_head list; + int (*create)(int, const char **); + int (*show)(struct seq_file *, struct dyn_event *); + bool (*is_busy)(struct dyn_event *); + int (*free)(struct dyn_event *); + bool (*match)(const char *, const char *, int, const char **, struct dyn_event *); }; -struct audit_parent; +struct dyn_event { + struct list_head list; + struct dyn_event_operations *ops; +}; -struct audit_watch { - refcount_t count; - dev_t dev; - char *path; - long unsigned int ino; - struct audit_parent *parent; - struct list_head wlist; - struct list_head rules; +typedef int (*print_type_func_t)(struct trace_seq *, void *, void *); + +enum fetch_op { + FETCH_OP_NOP = 0, + FETCH_OP_REG = 1, + FETCH_OP_STACK = 2, + FETCH_OP_STACKP = 3, + FETCH_OP_RETVAL = 4, + FETCH_OP_IMM = 5, + FETCH_OP_COMM = 6, + FETCH_OP_ARG = 7, + FETCH_OP_FOFFS = 8, + FETCH_OP_DATA = 9, + FETCH_OP_DEREF = 10, + FETCH_OP_UDEREF = 11, + FETCH_OP_ST_RAW = 12, + FETCH_OP_ST_MEM = 13, + FETCH_OP_ST_UMEM = 14, + FETCH_OP_ST_STRING = 15, + FETCH_OP_ST_USTRING = 16, + FETCH_OP_MOD_BF = 17, + FETCH_OP_LP_ARRAY = 18, + FETCH_OP_END = 19, + FETCH_NOP_SYMBOL = 20, }; -struct fsnotify_group; +struct fetch_insn { + enum fetch_op op; + union { + unsigned int param; + struct { + unsigned int size; + int offset; + }; + struct { + unsigned char basesize; + unsigned char lshift; + unsigned char rshift; + }; + long unsigned int immediate; + void *data; + }; +}; -struct fsnotify_iter_info; +struct fetch_type { + const char *name; + size_t size; + int is_signed; + print_type_func_t print; + const char *fmt; + const char *fmttype; +}; -struct fsnotify_mark; +struct probe_arg { + struct fetch_insn *code; + bool dynamic; + unsigned int offset; + unsigned int count; + const char *name; + const char *comm; + char *fmt; + const struct fetch_type *type; +}; -struct fsnotify_event; +struct trace_uprobe_filter { + rwlock_t rwlock; + int nr_systemwide; + struct list_head perf_events; +}; -struct fsnotify_ops { - int (*handle_event)(struct fsnotify_group *, struct inode *, u32, const void *, int, const struct qstr *, u32, struct fsnotify_iter_info *); - void (*free_group_priv)(struct fsnotify_group *); - void (*freeing_mark)(struct fsnotify_mark *, struct fsnotify_group *); - void (*free_event)(struct fsnotify_event *); - void (*free_mark)(struct fsnotify_mark *); +struct trace_probe_event { + unsigned int flags; + struct trace_event_class class; + struct trace_event_call call; + struct list_head files; + struct list_head probes; + struct trace_uprobe_filter filter[0]; }; -struct inotify_group_private_data { - spinlock_t idr_lock; - struct idr idr; - struct ucounts *ucounts; +struct trace_probe { + struct list_head list; + struct trace_probe_event *event; + ssize_t size; + unsigned int nr_args; + struct probe_arg args[0]; }; -struct fsnotify_group { - const struct fsnotify_ops *ops; - refcount_t refcnt; - spinlock_t notification_lock; - struct list_head notification_list; - wait_queue_head_t notification_waitq; - unsigned int q_len; - unsigned int max_events; - unsigned int priority; - bool shutdown; - struct mutex mark_mutex; - atomic_t num_marks; - atomic_t user_waits; - struct list_head marks_list; - struct fasync_struct *fsn_fa; - struct fsnotify_event *overflow_event; - struct mem_cgroup *memcg; - union { - void *private; - struct inotify_group_private_data inotify_data; - }; +struct event_file_link { + struct trace_event_file *file; + struct list_head list; }; -struct fsnotify_iter_info { - struct fsnotify_mark *marks[3]; - unsigned int report_mask; - int srcu_idx; +enum { + TP_ERR_FILE_NOT_FOUND = 0, + TP_ERR_NO_REGULAR_FILE = 1, + TP_ERR_BAD_REFCNT = 2, + TP_ERR_REFCNT_OPEN_BRACE = 3, + TP_ERR_BAD_REFCNT_SUFFIX = 4, + TP_ERR_BAD_UPROBE_OFFS = 5, + TP_ERR_MAXACT_NO_KPROBE = 6, + TP_ERR_BAD_MAXACT = 7, + TP_ERR_MAXACT_TOO_BIG = 8, + TP_ERR_BAD_PROBE_ADDR = 9, + TP_ERR_BAD_RETPROBE = 10, + TP_ERR_NO_GROUP_NAME = 11, + TP_ERR_GROUP_TOO_LONG = 12, + TP_ERR_BAD_GROUP_NAME = 13, + TP_ERR_NO_EVENT_NAME = 14, + TP_ERR_EVENT_TOO_LONG = 15, + TP_ERR_BAD_EVENT_NAME = 16, + TP_ERR_RETVAL_ON_PROBE = 17, + TP_ERR_BAD_STACK_NUM = 18, + TP_ERR_BAD_ARG_NUM = 19, + TP_ERR_BAD_VAR = 20, + TP_ERR_BAD_REG_NAME = 21, + TP_ERR_BAD_MEM_ADDR = 22, + TP_ERR_BAD_IMM = 23, + TP_ERR_IMMSTR_NO_CLOSE = 24, + TP_ERR_FILE_ON_KPROBE = 25, + TP_ERR_BAD_FILE_OFFS = 26, + TP_ERR_SYM_ON_UPROBE = 27, + TP_ERR_TOO_MANY_OPS = 28, + TP_ERR_DEREF_NEED_BRACE = 29, + TP_ERR_BAD_DEREF_OFFS = 30, + TP_ERR_DEREF_OPEN_BRACE = 31, + TP_ERR_COMM_CANT_DEREF = 32, + TP_ERR_BAD_FETCH_ARG = 33, + TP_ERR_ARRAY_NO_CLOSE = 34, + TP_ERR_BAD_ARRAY_SUFFIX = 35, + TP_ERR_BAD_ARRAY_NUM = 36, + TP_ERR_ARRAY_TOO_BIG = 37, + TP_ERR_BAD_TYPE = 38, + TP_ERR_BAD_STRING = 39, + TP_ERR_BAD_BITFIELD = 40, + TP_ERR_ARG_NAME_TOO_LONG = 41, + TP_ERR_NO_ARG_NAME = 42, + TP_ERR_BAD_ARG_NAME = 43, + TP_ERR_USED_ARG_NAME = 44, + TP_ERR_ARG_TOO_LONG = 45, + TP_ERR_NO_ARG_BODY = 46, + TP_ERR_BAD_INSN_BNDRY = 47, + TP_ERR_FAIL_REG_PROBE = 48, + TP_ERR_DIFF_PROBE_TYPE = 49, + TP_ERR_DIFF_ARG_TYPE = 50, + TP_ERR_SAME_PROBE = 51, }; -struct fsnotify_mark { - __u32 mask; - refcount_t refcnt; - struct fsnotify_group *group; - struct list_head g_list; - spinlock_t lock; - struct hlist_node obj_list; - struct fsnotify_mark_connector *connector; - __u32 ignored_mask; - unsigned int flags; +struct trace_kprobe { + struct dyn_event devent; + struct kretprobe rp; + long unsigned int *nhit; + const char *symbol; + struct trace_probe tp; }; -struct fsnotify_event { - struct list_head list; - struct inode *inode; +struct trace_event_raw_cpu { + struct trace_entry ent; + u32 state; + u32 cpu_id; + char __data[0]; }; -struct audit_parent { - struct list_head watches; - struct fsnotify_mark mark; +struct trace_event_raw_powernv_throttle { + struct trace_entry ent; + int chip_id; + u32 __data_loc_reason; + int pmax; + char __data[0]; }; -struct audit_fsnotify_mark { - dev_t dev; - long unsigned int ino; - char *path; - struct fsnotify_mark mark; - struct audit_krule *rule; +struct trace_event_raw_pstate_sample { + struct trace_entry ent; + u32 core_busy; + u32 scaled_busy; + u32 from; + u32 to; + u64 mperf; + u64 aperf; + u64 tsc; + u32 freq; + u32 io_boost; + char __data[0]; }; -struct audit_chunk___2; - -struct audit_tree { - refcount_t count; - int goner; - struct audit_chunk___2 *root; - struct list_head chunks; - struct list_head rules; - struct list_head list; - struct list_head same_root; - struct callback_head head; - char pathname[0]; +struct trace_event_raw_cpu_frequency_limits { + struct trace_entry ent; + u32 min_freq; + u32 max_freq; + u32 cpu_id; + char __data[0]; }; -struct node { - struct list_head list; - struct audit_tree *owner; - unsigned int index; +struct trace_event_raw_device_pm_callback_start { + struct trace_entry ent; + u32 __data_loc_device; + u32 __data_loc_driver; + u32 __data_loc_parent; + u32 __data_loc_pm_ops; + int event; + char __data[0]; }; -struct audit_chunk___2 { - struct list_head hash; - long unsigned int key; - struct fsnotify_mark *mark; - struct list_head trees; - int count; - atomic_long_t refs; - struct callback_head head; - struct node owners[0]; +struct trace_event_raw_device_pm_callback_end { + struct trace_entry ent; + u32 __data_loc_device; + u32 __data_loc_driver; + int error; + char __data[0]; }; -struct audit_tree_mark { - struct fsnotify_mark mark; - struct audit_chunk___2 *chunk; +struct trace_event_raw_suspend_resume { + struct trace_entry ent; + const char *action; + int val; + bool start; + char __data[0]; }; -enum { - HASH_SIZE = 128, +struct trace_event_raw_wakeup_source { + struct trace_entry ent; + u32 __data_loc_name; + u64 state; + char __data[0]; }; -struct kprobe_blacklist_entry { - struct list_head list; - long unsigned int start_addr; - long unsigned int end_addr; +struct trace_event_raw_clock { + struct trace_entry ent; + u32 __data_loc_name; + u64 state; + u64 cpu_id; + char __data[0]; }; -struct kprobe_insn_page { - struct list_head list; - kprobe_opcode_t *insns; - struct kprobe_insn_cache *cache; - int nused; - int ngarbage; - char slot_used[0]; +struct trace_event_raw_power_domain { + struct trace_entry ent; + u32 __data_loc_name; + u64 state; + u64 cpu_id; + char __data[0]; }; -enum kprobe_slot_state { - SLOT_CLEAN = 0, - SLOT_DIRTY = 1, - SLOT_USED = 2, +struct trace_event_raw_pm_qos_request { + struct trace_entry ent; + int pm_qos_class; + s32 value; + char __data[0]; }; -struct seccomp_notif_sizes { - __u16 seccomp_notif; - __u16 seccomp_notif_resp; - __u16 seccomp_data; +struct trace_event_raw_pm_qos_update_request_timeout { + struct trace_entry ent; + int pm_qos_class; + s32 value; + long unsigned int timeout_us; + char __data[0]; }; -struct seccomp_notif { - __u64 id; - __u32 pid; - __u32 flags; - struct seccomp_data data; +struct trace_event_raw_pm_qos_update { + struct trace_entry ent; + enum pm_qos_req_action action; + int prev_value; + int curr_value; + char __data[0]; }; -struct seccomp_notif_resp { - __u64 id; - __s64 val; - __s32 error; - __u32 flags; +struct trace_event_raw_dev_pm_qos_request { + struct trace_entry ent; + u32 __data_loc_name; + enum dev_pm_qos_req_type type; + s32 new_value; + char __data[0]; }; -struct notification; +struct trace_event_data_offsets_cpu {}; -struct seccomp_filter { - refcount_t usage; - bool log; - struct seccomp_filter *prev; - struct bpf_prog *prog; - struct notification *notif; - struct mutex notify_lock; +struct trace_event_data_offsets_powernv_throttle { + u32 reason; }; -struct ctl_path { - const char *procname; -}; +struct trace_event_data_offsets_pstate_sample {}; -struct sock_fprog { - short unsigned int len; - struct sock_filter *filter; -}; +struct trace_event_data_offsets_cpu_frequency_limits {}; -struct compat_sock_fprog { - u16 len; - compat_uptr_t filter; +struct trace_event_data_offsets_device_pm_callback_start { + u32 device; + u32 driver; + u32 parent; + u32 pm_ops; }; -typedef int (*bpf_aux_classic_check_t)(struct sock_filter *, unsigned int); - -enum notify_state { - SECCOMP_NOTIFY_INIT = 0, - SECCOMP_NOTIFY_SENT = 1, - SECCOMP_NOTIFY_REPLIED = 2, +struct trace_event_data_offsets_device_pm_callback_end { + u32 device; + u32 driver; }; -struct seccomp_knotif { - struct task_struct *task; - u64 id; - const struct seccomp_data *data; - enum notify_state state; - int error; - long int val; - u32 flags; - struct completion ready; - struct list_head list; +struct trace_event_data_offsets_suspend_resume {}; + +struct trace_event_data_offsets_wakeup_source { + u32 name; }; -struct notification { - struct semaphore request; - u64 next_id; - struct list_head notifications; - wait_queue_head_t wqh; +struct trace_event_data_offsets_clock { + u32 name; }; -struct seccomp_log_name { - u32 log; - const char *name; +struct trace_event_data_offsets_power_domain { + u32 name; }; -struct rchan; +struct trace_event_data_offsets_pm_qos_request {}; -struct rchan_buf { - void *start; - void *data; - size_t offset; - size_t subbufs_produced; - size_t subbufs_consumed; - struct rchan *chan; - wait_queue_head_t read_wait; - struct irq_work wakeup_work; - struct dentry *dentry; - struct kref kref; - struct page **page_array; - unsigned int page_count; - unsigned int finalized; - size_t *padding; - size_t prev_padding; - size_t bytes_consumed; - size_t early_bytes; - unsigned int cpu; - long: 32; - long: 64; - long: 64; - long: 64; -}; +struct trace_event_data_offsets_pm_qos_update_request_timeout {}; -struct rchan_callbacks; +struct trace_event_data_offsets_pm_qos_update {}; -struct rchan { - u32 version; - size_t subbuf_size; - size_t n_subbufs; - size_t alloc_size; - struct rchan_callbacks *cb; - struct kref kref; - void *private_data; - size_t last_toobig; - struct rchan_buf **buf; - int is_global; - struct list_head list; - struct dentry *parent; - int has_base_filename; - char base_filename[255]; +struct trace_event_data_offsets_dev_pm_qos_request { + u32 name; }; -struct rchan_callbacks { - int (*subbuf_start)(struct rchan_buf *, void *, void *, size_t); - void (*buf_mapped)(struct rchan_buf *, struct file *); - void (*buf_unmapped)(struct rchan_buf *, struct file *); - struct dentry * (*create_buf_file)(const char *, struct dentry *, umode_t, struct rchan_buf *, int *); - int (*remove_buf_file)(struct dentry *); -}; +typedef void (*btf_trace_cpu_idle)(void *, unsigned int, unsigned int); -struct partial_page { - unsigned int offset; - unsigned int len; - long unsigned int private; -}; +typedef void (*btf_trace_powernv_throttle)(void *, int, const char *, int); -struct splice_pipe_desc { - struct page **pages; - struct partial_page *partial; - int nr_pages; - unsigned int nr_pages_max; - const struct pipe_buf_operations *ops; - void (*spd_release)(struct splice_pipe_desc *, unsigned int); -}; +typedef void (*btf_trace_pstate_sample)(void *, u32, u32, u32, u32, u64, u64, u64, u32, u32); -struct rchan_percpu_buf_dispatcher { - struct rchan_buf *buf; - struct dentry *dentry; -}; +typedef void (*btf_trace_cpu_frequency)(void *, unsigned int, unsigned int); -enum { - TASKSTATS_TYPE_UNSPEC = 0, - TASKSTATS_TYPE_PID = 1, - TASKSTATS_TYPE_TGID = 2, - TASKSTATS_TYPE_STATS = 3, - TASKSTATS_TYPE_AGGR_PID = 4, - TASKSTATS_TYPE_AGGR_TGID = 5, - TASKSTATS_TYPE_NULL = 6, - __TASKSTATS_TYPE_MAX = 7, -}; +typedef void (*btf_trace_cpu_frequency_limits)(void *, struct cpufreq_policy *); -enum { - TASKSTATS_CMD_ATTR_UNSPEC = 0, - TASKSTATS_CMD_ATTR_PID = 1, - TASKSTATS_CMD_ATTR_TGID = 2, - TASKSTATS_CMD_ATTR_REGISTER_CPUMASK = 3, - TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK = 4, - __TASKSTATS_CMD_ATTR_MAX = 5, -}; +typedef void (*btf_trace_device_pm_callback_start)(void *, struct device *, const char *, int); -enum { - CGROUPSTATS_CMD_UNSPEC = 3, - CGROUPSTATS_CMD_GET = 4, - CGROUPSTATS_CMD_NEW = 5, - __CGROUPSTATS_CMD_MAX = 6, -}; +typedef void (*btf_trace_device_pm_callback_end)(void *, struct device *, int); -enum { - CGROUPSTATS_TYPE_UNSPEC = 0, - CGROUPSTATS_TYPE_CGROUP_STATS = 1, - __CGROUPSTATS_TYPE_MAX = 2, -}; +typedef void (*btf_trace_suspend_resume)(void *, const char *, int, bool); -enum { - CGROUPSTATS_CMD_ATTR_UNSPEC = 0, - CGROUPSTATS_CMD_ATTR_FD = 1, - __CGROUPSTATS_CMD_ATTR_MAX = 2, -}; +typedef void (*btf_trace_wakeup_source_activate)(void *, const char *, unsigned int); -struct genlmsghdr { - __u8 cmd; - __u8 version; - __u16 reserved; -}; +typedef void (*btf_trace_wakeup_source_deactivate)(void *, const char *, unsigned int); -enum { - NLA_UNSPEC = 0, - NLA_U8 = 1, - NLA_U16 = 2, - NLA_U32 = 3, - NLA_U64 = 4, - NLA_STRING = 5, - NLA_FLAG = 6, - NLA_MSECS = 7, - NLA_NESTED = 8, - NLA_NESTED_ARRAY = 9, - NLA_NUL_STRING = 10, - NLA_BINARY = 11, - NLA_S8 = 12, - NLA_S16 = 13, - NLA_S32 = 14, - NLA_S64 = 15, - NLA_BITFIELD32 = 16, - NLA_REJECT = 17, - NLA_EXACT_LEN = 18, - NLA_EXACT_LEN_WARN = 19, - NLA_MIN_LEN = 20, - __NLA_TYPE_MAX = 21, -}; +typedef void (*btf_trace_clock_enable)(void *, const char *, unsigned int, unsigned int); -enum netlink_validation { - NL_VALIDATE_LIBERAL = 0, - NL_VALIDATE_TRAILING = 1, - NL_VALIDATE_MAXTYPE = 2, - NL_VALIDATE_UNSPEC = 4, - NL_VALIDATE_STRICT_ATTRS = 8, - NL_VALIDATE_NESTED = 16, -}; +typedef void (*btf_trace_clock_disable)(void *, const char *, unsigned int, unsigned int); -struct genl_multicast_group { - char name[16]; -}; +typedef void (*btf_trace_clock_set_rate)(void *, const char *, unsigned int, unsigned int); -struct genl_ops; +typedef void (*btf_trace_power_domain_target)(void *, const char *, unsigned int, unsigned int); -struct genl_info; +typedef void (*btf_trace_pm_qos_add_request)(void *, int, s32); -struct genl_family { - int id; - unsigned int hdrsize; - char name[16]; - unsigned int version; - unsigned int maxattr; - bool netnsok; - bool parallel_ops; - const struct nla_policy *policy; - int (*pre_doit)(const struct genl_ops *, struct sk_buff *, struct genl_info *); - void (*post_doit)(const struct genl_ops *, struct sk_buff *, struct genl_info *); - int (*mcast_bind)(struct net *, int); - void (*mcast_unbind)(struct net *, int); - struct nlattr **attrbuf; - const struct genl_ops *ops; - const struct genl_multicast_group *mcgrps; - unsigned int n_ops; - unsigned int n_mcgrps; - unsigned int mcgrp_offset; - struct module *module; -}; +typedef void (*btf_trace_pm_qos_update_request)(void *, int, s32); -struct genl_ops { - int (*doit)(struct sk_buff *, struct genl_info *); - int (*start)(struct netlink_callback *); - int (*dumpit)(struct sk_buff *, struct netlink_callback *); - int (*done)(struct netlink_callback *); - u8 cmd; - u8 internal_flags; - u8 flags; - u8 validate; -}; +typedef void (*btf_trace_pm_qos_remove_request)(void *, int, s32); -struct genl_info { - u32 snd_seq; - u32 snd_portid; - struct nlmsghdr *nlhdr; - struct genlmsghdr *genlhdr; - void *userhdr; - struct nlattr **attrs; - possible_net_t _net; - void *user_ptr[2]; - struct netlink_ext_ack *extack; -}; +typedef void (*btf_trace_pm_qos_update_request_timeout)(void *, int, s32, long unsigned int); -enum genl_validate_flags { - GENL_DONT_VALIDATE_STRICT = 1, - GENL_DONT_VALIDATE_DUMP = 2, - GENL_DONT_VALIDATE_DUMP_STRICT = 4, -}; +typedef void (*btf_trace_pm_qos_update_target)(void *, enum pm_qos_req_action, int, int); -struct listener { - struct list_head list; - pid_t pid; - char valid; -}; +typedef void (*btf_trace_pm_qos_update_flags)(void *, enum pm_qos_req_action, int, int); -struct listener_list { - struct rw_semaphore sem; - struct list_head list; -}; +typedef void (*btf_trace_dev_pm_qos_add_request)(void *, const char *, enum dev_pm_qos_req_type, s32); -enum actions { - REGISTER = 0, - DEREGISTER = 1, - CPU_DONT_CARE = 2, -}; +typedef void (*btf_trace_dev_pm_qos_update_request)(void *, const char *, enum dev_pm_qos_req_type, s32); -struct tp_module { - struct list_head list; - struct module *mod; -}; +typedef void (*btf_trace_dev_pm_qos_remove_request)(void *, const char *, enum dev_pm_qos_req_type, s32); -struct tp_probes { - struct callback_head rcu; - struct tracepoint_func probes[0]; +struct trace_event_raw_rpm_internal { + struct trace_entry ent; + u32 __data_loc_name; + int flags; + int usage_count; + int disable_depth; + int runtime_auto; + int request_pending; + int irq_safe; + int child_count; + char __data[0]; }; -enum ring_buffer_type { - RINGBUF_TYPE_DATA_TYPE_LEN_MAX = 28, - RINGBUF_TYPE_PADDING = 29, - RINGBUF_TYPE_TIME_EXTEND = 30, - RINGBUF_TYPE_TIME_STAMP = 31, +struct trace_event_raw_rpm_return_int { + struct trace_entry ent; + u32 __data_loc_name; + long unsigned int ip; + int ret; + char __data[0]; }; -enum ring_buffer_flags { - RB_FL_OVERWRITE = 1, +struct trace_event_data_offsets_rpm_internal { + u32 name; }; -struct rb_irq_work { - struct irq_work work; - wait_queue_head_t waiters; - wait_queue_head_t full_waiters; - bool waiters_pending; - bool full_waiters_pending; - bool wakeup_full; +struct trace_event_data_offsets_rpm_return_int { + u32 name; }; -struct ring_buffer_per_cpu; +typedef void (*btf_trace_rpm_suspend)(void *, struct device *, int); -struct ring_buffer { - unsigned int flags; - int cpus; - atomic_t record_disabled; - atomic_t resize_disabled; - cpumask_var_t cpumask; - struct lock_class_key *reader_lock_key; - struct mutex mutex; - struct ring_buffer_per_cpu **buffers; - struct hlist_node node; - u64 (*clock)(); - struct rb_irq_work irq_work; - bool time_stamp_abs; -}; +typedef void (*btf_trace_rpm_resume)(void *, struct device *, int); -struct buffer_page; +typedef void (*btf_trace_rpm_idle)(void *, struct device *, int); -struct ring_buffer_iter { - struct ring_buffer_per_cpu *cpu_buffer; - long unsigned int head; - struct buffer_page *head_page; - struct buffer_page *cache_reader_page; - long unsigned int cache_read; - u64 read_stamp; -}; +typedef void (*btf_trace_rpm_return_int)(void *, struct device *, long unsigned int, int); -enum { - RB_LEN_TIME_EXTEND = 8, - RB_LEN_TIME_STAMP = 8, +struct trace_probe_log { + const char *subsystem; + const char **argv; + int argc; + int index; }; -struct buffer_data_page { - u64 time_stamp; - local_t commit; - unsigned char data[0]; +enum uprobe_filter_ctx { + UPROBE_FILTER_REGISTER = 0, + UPROBE_FILTER_UNREGISTER = 1, + UPROBE_FILTER_MMAP = 2, }; -struct buffer_page { - struct list_head list; - local_t write; - unsigned int read; - local_t entries; - long unsigned int real_end; - struct buffer_data_page *page; +struct uprobe_consumer { + int (*handler)(struct uprobe_consumer *, struct pt_regs *); + int (*ret_handler)(struct uprobe_consumer *, long unsigned int, struct pt_regs *); + bool (*filter)(struct uprobe_consumer *, enum uprobe_filter_ctx, struct mm_struct *); + struct uprobe_consumer *next; }; -struct rb_event_info { - u64 ts; - u64 delta; - long unsigned int length; - struct buffer_page *tail_page; - int add_timestamp; +struct uprobe_trace_entry_head { + struct trace_entry ent; + long unsigned int vaddr[0]; }; -enum { - RB_CTX_NMI = 0, - RB_CTX_IRQ = 1, - RB_CTX_SOFTIRQ = 2, - RB_CTX_NORMAL = 3, - RB_CTX_MAX = 4, +struct trace_uprobe { + struct dyn_event devent; + struct uprobe_consumer consumer; + struct path path; + struct inode *inode; + char *filename; + long unsigned int offset; + long unsigned int ref_ctr_offset; + long unsigned int nhit; + struct trace_probe tp; }; -struct ring_buffer_per_cpu { - int cpu; - atomic_t record_disabled; - struct ring_buffer *buffer; - raw_spinlock_t reader_lock; - arch_spinlock_t lock; - struct lock_class_key lock_key; - struct buffer_data_page *free_page; - long unsigned int nr_pages; - unsigned int current_context; - struct list_head *pages; - struct buffer_page *head_page; - struct buffer_page *tail_page; - struct buffer_page *commit_page; - struct buffer_page *reader_page; - long unsigned int lost_events; - long unsigned int last_overrun; - long unsigned int nest; - local_t entries_bytes; - local_t entries; - local_t overrun; - local_t commit_overrun; - local_t dropped_events; - local_t committing; - local_t commits; - local_t pages_touched; - local_t pages_read; - long int last_pages_touch; - size_t shortest_full; - long unsigned int read; - long unsigned int read_bytes; - u64 write_stamp; - u64 read_stamp; - long int nr_pages_to_update; - struct list_head new_pages; - struct work_struct update_pages_work; - struct completion update_done; - struct rb_irq_work irq_work; +struct uprobe_dispatch_data { + struct trace_uprobe *tu; + long unsigned int bp_addr; }; -typedef struct vfsmount * (*debugfs_automount_t)(struct dentry *, void *); - -struct trace_export { - struct trace_export *next; - void (*write)(struct trace_export *, const void *, unsigned int); +struct uprobe_cpu_buffer { + struct mutex mutex; + void *buf; }; -struct prog_entry; +typedef bool (*filter_func_t)(struct uprobe_consumer *, enum uprobe_filter_ctx, struct mm_struct *); -struct event_filter { - struct prog_entry *prog; - char *filter_string; -}; +typedef __u32 __le32; -struct trace_array_cpu; +typedef __u64 __le64; -struct trace_buffer { - struct trace_array *tr; - struct ring_buffer *buffer; - struct trace_array_cpu *data; - u64 time_start; - int cpu; +enum xdp_action { + XDP_ABORTED = 0, + XDP_DROP = 1, + XDP_PASS = 2, + XDP_TX = 3, + XDP_REDIRECT = 4, }; -struct trace_pid_list; - -struct trace_options; +enum xdp_mem_type { + MEM_TYPE_PAGE_SHARED = 0, + MEM_TYPE_PAGE_ORDER0 = 1, + MEM_TYPE_PAGE_POOL = 2, + MEM_TYPE_ZERO_COPY = 3, + MEM_TYPE_MAX = 4, +}; -struct trace_array { - struct list_head list; - char *name; - struct trace_buffer trace_buffer; - struct trace_pid_list *filtered_pids; - arch_spinlock_t max_lock; - int buffer_disabled; - int stop_count; - int clock_id; - int nr_topts; - bool clear_trace; - int buffer_percent; - unsigned int n_err_log_entries; - struct tracer *current_trace; - unsigned int trace_flags; - unsigned char trace_flags_index[32]; - unsigned int flags; - raw_spinlock_t start_lock; - struct list_head err_log; - struct dentry *dir; - struct dentry *options; - struct dentry *percpu_dir; - struct dentry *event_dir; - struct trace_options *topts; - struct list_head systems; - struct list_head events; - struct trace_event_file *trace_marker_file; - cpumask_var_t tracing_cpumask; - int ref; - int time_stamp_abs_ref; - struct list_head hist_vars; +struct zero_copy_allocator { + void (*free)(struct zero_copy_allocator *, long unsigned int); }; -struct tracer_flags; +typedef void (*bpf_jit_fill_hole_t)(void *, unsigned int); -struct tracer { - const char *name; - int (*init)(struct trace_array *); - void (*reset)(struct trace_array *); - void (*start)(struct trace_array *); - void (*stop)(struct trace_array *); - int (*update_thresh)(struct trace_array *); - void (*open)(struct trace_iterator *); - void (*pipe_open)(struct trace_iterator *); - void (*close)(struct trace_iterator *); - void (*pipe_close)(struct trace_iterator *); - ssize_t (*read)(struct trace_iterator *, struct file *, char *, size_t, loff_t *); - ssize_t (*splice_read)(struct trace_iterator *, struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); - void (*print_header)(struct seq_file *); - enum print_line_t (*print_line)(struct trace_iterator *); - int (*set_flag)(struct trace_array *, u32, u32, int); - int (*flag_changed)(struct trace_array *, u32, int); - struct tracer *next; - struct tracer_flags *flags; - int enabled; - int ref; - bool print_max; - bool allow_instances; - bool noboot; +struct bpf_prog_dummy { + struct bpf_prog prog; }; -enum trace_iter_flags { - TRACE_FILE_LAT_FMT = 1, - TRACE_FILE_ANNOTATE = 2, - TRACE_FILE_TIME_IN_NS = 4, -}; +typedef u64 (*btf_bpf_user_rnd_u32)(); -struct event_subsystem; +struct page_pool; -struct trace_subsystem_dir { - struct list_head list; - struct event_subsystem *subsystem; - struct trace_array *tr; - struct dentry *entry; - int ref_count; - int nr_events; +struct xdp_mem_allocator { + struct xdp_mem_info mem; + union { + void *allocator; + struct page_pool *page_pool; + struct zero_copy_allocator *zc_alloc; + }; + struct rhash_head node; + struct callback_head rcu; }; -enum trace_type { - __TRACE_FIRST_TYPE = 0, - TRACE_FN = 1, - TRACE_CTX = 2, - TRACE_WAKE = 3, - TRACE_STACK = 4, - TRACE_PRINT = 5, - TRACE_BPRINT = 6, - TRACE_MMIO_RW = 7, - TRACE_MMIO_MAP = 8, - TRACE_BRANCH = 9, - TRACE_GRAPH_RET = 10, - TRACE_GRAPH_ENT = 11, - TRACE_USER_STACK = 12, - TRACE_BLK = 13, - TRACE_BPUTS = 14, - TRACE_HWLAT = 15, - TRACE_RAW_DATA = 16, - __TRACE_LAST_TYPE = 17, +struct trace_event_raw_xdp_exception { + struct trace_entry ent; + int prog_id; + u32 act; + int ifindex; + char __data[0]; }; -struct ftrace_entry { +struct trace_event_raw_xdp_bulk_tx { struct trace_entry ent; - long unsigned int ip; - long unsigned int parent_ip; + int ifindex; + u32 act; + int drops; + int sent; + int err; + char __data[0]; }; -struct stack_entry { +struct trace_event_raw_xdp_redirect_template { struct trace_entry ent; - int size; - long unsigned int caller[0]; + int prog_id; + u32 act; + int ifindex; + int err; + int to_ifindex; + u32 map_id; + int map_index; + char __data[0]; }; -struct userstack_entry { +struct trace_event_raw_xdp_cpumap_kthread { struct trace_entry ent; - unsigned int tgid; - long unsigned int caller[8]; + int map_id; + u32 act; + int cpu; + unsigned int drops; + unsigned int processed; + int sched; + char __data[0]; }; -struct bprint_entry { +struct trace_event_raw_xdp_cpumap_enqueue { struct trace_entry ent; - long unsigned int ip; - const char *fmt; - u32 buf[0]; + int map_id; + u32 act; + int cpu; + unsigned int drops; + unsigned int processed; + int to_cpu; + char __data[0]; }; -struct print_entry { +struct trace_event_raw_xdp_devmap_xmit { struct trace_entry ent; - long unsigned int ip; - char buf[0]; + int map_id; + u32 act; + u32 map_index; + int drops; + int sent; + int from_ifindex; + int to_ifindex; + int err; + char __data[0]; }; -struct raw_data_entry { +struct trace_event_raw_mem_disconnect { struct trace_entry ent; - unsigned int id; - char buf[0]; + const struct xdp_mem_allocator *xa; + u32 mem_id; + u32 mem_type; + const void *allocator; + char __data[0]; }; -struct bputs_entry { +struct trace_event_raw_mem_connect { struct trace_entry ent; - long unsigned int ip; - const char *str; + const struct xdp_mem_allocator *xa; + u32 mem_id; + u32 mem_type; + const void *allocator; + const struct xdp_rxq_info *rxq; + int ifindex; + char __data[0]; }; -enum trace_flag_type { - TRACE_FLAG_IRQS_OFF = 1, - TRACE_FLAG_IRQS_NOSUPPORT = 2, - TRACE_FLAG_NEED_RESCHED = 4, - TRACE_FLAG_HARDIRQ = 8, - TRACE_FLAG_SOFTIRQ = 16, - TRACE_FLAG_PREEMPT_RESCHED = 32, - TRACE_FLAG_NMI = 64, +struct trace_event_raw_mem_return_failed { + struct trace_entry ent; + const struct page *page; + u32 mem_id; + u32 mem_type; + char __data[0]; }; -struct trace_array_cpu { - atomic_t disabled; - void *buffer_page; - long unsigned int entries; - long unsigned int saved_latency; - long unsigned int critical_start; - long unsigned int critical_end; - long unsigned int critical_sequence; - long unsigned int nice; - long unsigned int policy; - long unsigned int rt_priority; - long unsigned int skipped_entries; - u64 preempt_timestamp; - pid_t pid; - kuid_t uid; - char comm[16]; - bool ignore_pid; -}; +struct trace_event_data_offsets_xdp_exception {}; -struct trace_option_dentry; +struct trace_event_data_offsets_xdp_bulk_tx {}; -struct trace_options { - struct tracer *tracer; - struct trace_option_dentry *topts; -}; +struct trace_event_data_offsets_xdp_redirect_template {}; -struct tracer_opt; +struct trace_event_data_offsets_xdp_cpumap_kthread {}; -struct trace_option_dentry { - struct tracer_opt *opt; - struct tracer_flags *flags; - struct trace_array *tr; - struct dentry *entry; -}; +struct trace_event_data_offsets_xdp_cpumap_enqueue {}; -struct trace_pid_list { - int pid_max; - long unsigned int *pids; -}; +struct trace_event_data_offsets_xdp_devmap_xmit {}; -typedef bool (*cond_update_fn_t)(struct trace_array *, void *); +struct trace_event_data_offsets_mem_disconnect {}; -enum { - TRACE_ARRAY_FL_GLOBAL = 1, -}; +struct trace_event_data_offsets_mem_connect {}; -struct tracer_opt { - const char *name; - u32 bit; -}; +struct trace_event_data_offsets_mem_return_failed {}; -struct tracer_flags { - u32 val; - struct tracer_opt *opts; - struct tracer *trace; -}; +typedef void (*btf_trace_xdp_exception)(void *, const struct net_device *, const struct bpf_prog *, u32); -struct trace_parser { - bool cont; - char *buffer; - unsigned int idx; - unsigned int size; -}; +typedef void (*btf_trace_xdp_bulk_tx)(void *, const struct net_device *, int, int, int); -enum trace_iterator_bits { - TRACE_ITER_PRINT_PARENT_BIT = 0, - TRACE_ITER_SYM_OFFSET_BIT = 1, - TRACE_ITER_SYM_ADDR_BIT = 2, - TRACE_ITER_VERBOSE_BIT = 3, - TRACE_ITER_RAW_BIT = 4, - TRACE_ITER_HEX_BIT = 5, - TRACE_ITER_BIN_BIT = 6, - TRACE_ITER_BLOCK_BIT = 7, - TRACE_ITER_PRINTK_BIT = 8, - TRACE_ITER_ANNOTATE_BIT = 9, - TRACE_ITER_USERSTACKTRACE_BIT = 10, - TRACE_ITER_SYM_USEROBJ_BIT = 11, - TRACE_ITER_PRINTK_MSGONLY_BIT = 12, - TRACE_ITER_CONTEXT_INFO_BIT = 13, - TRACE_ITER_LATENCY_FMT_BIT = 14, - TRACE_ITER_RECORD_CMD_BIT = 15, - TRACE_ITER_RECORD_TGID_BIT = 16, - TRACE_ITER_OVERWRITE_BIT = 17, - TRACE_ITER_STOP_ON_FREE_BIT = 18, - TRACE_ITER_IRQ_INFO_BIT = 19, - TRACE_ITER_MARKERS_BIT = 20, - TRACE_ITER_EVENT_FORK_BIT = 21, - TRACE_ITER_STACKTRACE_BIT = 22, - TRACE_ITER_LAST_BIT = 23, -}; +typedef void (*btf_trace_xdp_redirect)(void *, const struct net_device *, const struct bpf_prog *, int, int, const struct bpf_map *, u32); -enum trace_iterator_flags { - TRACE_ITER_PRINT_PARENT = 1, - TRACE_ITER_SYM_OFFSET = 2, - TRACE_ITER_SYM_ADDR = 4, - TRACE_ITER_VERBOSE = 8, - TRACE_ITER_RAW = 16, - TRACE_ITER_HEX = 32, - TRACE_ITER_BIN = 64, - TRACE_ITER_BLOCK = 128, - TRACE_ITER_PRINTK = 256, - TRACE_ITER_ANNOTATE = 512, - TRACE_ITER_USERSTACKTRACE = 1024, - TRACE_ITER_SYM_USEROBJ = 2048, - TRACE_ITER_PRINTK_MSGONLY = 4096, - TRACE_ITER_CONTEXT_INFO = 8192, - TRACE_ITER_LATENCY_FMT = 16384, - TRACE_ITER_RECORD_CMD = 32768, - TRACE_ITER_RECORD_TGID = 65536, - TRACE_ITER_OVERWRITE = 131072, - TRACE_ITER_STOP_ON_FREE = 262144, - TRACE_ITER_IRQ_INFO = 524288, - TRACE_ITER_MARKERS = 1048576, - TRACE_ITER_EVENT_FORK = 2097152, - TRACE_ITER_STACKTRACE = 4194304, -}; +typedef void (*btf_trace_xdp_redirect_err)(void *, const struct net_device *, const struct bpf_prog *, int, int, const struct bpf_map *, u32); -struct event_subsystem { - struct list_head list; - const char *name; - struct event_filter *filter; - int ref_count; -}; +typedef void (*btf_trace_xdp_redirect_map)(void *, const struct net_device *, const struct bpf_prog *, int, int, const struct bpf_map *, u32); -struct saved_cmdlines_buffer { - unsigned int map_pid_to_cmdline[32769]; - unsigned int *map_cmdline_to_pid; - unsigned int cmdline_num; - int cmdline_idx; - char *saved_cmdlines; -}; +typedef void (*btf_trace_xdp_redirect_map_err)(void *, const struct net_device *, const struct bpf_prog *, int, int, const struct bpf_map *, u32); -struct ftrace_stack { - long unsigned int calls[1024]; -}; +typedef void (*btf_trace_xdp_cpumap_kthread)(void *, int, unsigned int, unsigned int, int); -struct ftrace_stacks { - struct ftrace_stack stacks[4]; -}; +typedef void (*btf_trace_xdp_cpumap_enqueue)(void *, int, unsigned int, unsigned int, int); -struct trace_buffer_struct { - int nesting; - char buffer[4096]; -}; +typedef void (*btf_trace_xdp_devmap_xmit)(void *, const struct bpf_map *, u32, int, int, const struct net_device *, const struct net_device *, int); -struct ftrace_buffer_info { - struct trace_iterator iter; - void *spare; - unsigned int spare_cpu; - unsigned int read; -}; +typedef void (*btf_trace_mem_disconnect)(void *, const struct xdp_mem_allocator *); -struct err_info { - const char **errs; - u8 type; - u8 pos; - u64 ts; -}; +typedef void (*btf_trace_mem_connect)(void *, const struct xdp_mem_allocator *, const struct xdp_rxq_info *); -struct tracing_log_err { - struct list_head list; - struct err_info info; - char loc[128]; - char cmd[256]; -}; +typedef void (*btf_trace_mem_return_failed)(void *, const struct xdp_mem_info *, const struct page *); -struct buffer_ref { - struct ring_buffer *buffer; - void *page; - int cpu; - refcount_t refcount; +enum bpf_cmd { + BPF_MAP_CREATE = 0, + BPF_MAP_LOOKUP_ELEM = 1, + BPF_MAP_UPDATE_ELEM = 2, + BPF_MAP_DELETE_ELEM = 3, + BPF_MAP_GET_NEXT_KEY = 4, + BPF_PROG_LOAD = 5, + BPF_OBJ_PIN = 6, + BPF_OBJ_GET = 7, + BPF_PROG_ATTACH = 8, + BPF_PROG_DETACH = 9, + BPF_PROG_TEST_RUN = 10, + BPF_PROG_GET_NEXT_ID = 11, + BPF_MAP_GET_NEXT_ID = 12, + BPF_PROG_GET_FD_BY_ID = 13, + BPF_MAP_GET_FD_BY_ID = 14, + BPF_OBJ_GET_INFO_BY_FD = 15, + BPF_PROG_QUERY = 16, + BPF_RAW_TRACEPOINT_OPEN = 17, + BPF_BTF_LOAD = 18, + BPF_BTF_GET_FD_BY_ID = 19, + BPF_TASK_FD_QUERY = 20, + BPF_MAP_LOOKUP_AND_DELETE_ELEM = 21, + BPF_MAP_FREEZE = 22, + BPF_BTF_GET_NEXT_ID = 23, }; -struct ctx_switch_entry { - struct trace_entry ent; - unsigned int prev_pid; - unsigned int next_pid; - unsigned int next_cpu; - unsigned char prev_prio; - unsigned char prev_state; - unsigned char next_prio; - unsigned char next_state; +enum { + BPF_ANY = 0, + BPF_NOEXIST = 1, + BPF_EXIST = 2, + BPF_F_LOCK = 4, }; -struct hwlat_entry { - struct trace_entry ent; - u64 duration; - u64 outer_duration; - u64 nmi_total_ts; - struct timespec64 timestamp; - unsigned int nmi_count; - unsigned int seqnum; +enum { + BPF_F_NO_PREALLOC = 1, + BPF_F_NO_COMMON_LRU = 2, + BPF_F_NUMA_NODE = 4, + BPF_F_RDONLY = 8, + BPF_F_WRONLY = 16, + BPF_F_STACK_BUILD_ID = 32, + BPF_F_ZERO_SEED = 64, + BPF_F_RDONLY_PROG = 128, + BPF_F_WRONLY_PROG = 256, + BPF_F_CLONE = 512, + BPF_F_MMAPABLE = 1024, }; -struct trace_mark { - long long unsigned int val; - char sym; +struct bpf_prog_info { + __u32 type; + __u32 id; + __u8 tag[8]; + __u32 jited_prog_len; + __u32 xlated_prog_len; + __u64 jited_prog_insns; + __u64 xlated_prog_insns; + __u64 load_time; + __u32 created_by_uid; + __u32 nr_map_ids; + __u64 map_ids; + char name[16]; + __u32 ifindex; + __u32 gpl_compatible: 1; + __u64 netns_dev; + __u64 netns_ino; + __u32 nr_jited_ksyms; + __u32 nr_jited_func_lens; + __u64 jited_ksyms; + __u64 jited_func_lens; + __u32 btf_id; + __u32 func_info_rec_size; + __u64 func_info; + __u32 nr_func_info; + __u32 nr_line_info; + __u64 line_info; + __u64 jited_line_info; + __u32 nr_jited_line_info; + __u32 line_info_rec_size; + __u32 jited_line_info_rec_size; + __u32 nr_prog_tags; + __u64 prog_tags; + __u64 run_time_ns; + __u64 run_cnt; +}; + +struct bpf_map_info { + __u32 type; + __u32 id; + __u32 key_size; + __u32 value_size; + __u32 max_entries; + __u32 map_flags; + char name[16]; + __u32 ifindex; + __u64 netns_dev; + __u64 netns_ino; + __u32 btf_id; + __u32 btf_key_type_id; + __u32 btf_value_type_id; +}; + +struct bpf_btf_info { + __u64 btf; + __u32 btf_size; + __u32 id; }; -struct tracer_stat { - const char *name; - void * (*stat_start)(struct tracer_stat *); - void * (*stat_next)(void *, int); - cmp_func_t stat_cmp; - int (*stat_show)(struct seq_file *, void *); - void (*stat_release)(void *); - int (*stat_headers)(struct seq_file *); +struct bpf_spin_lock { + __u32 val; }; -struct stat_node { - struct rb_node node; - void *stat; +enum perf_bpf_event_type { + PERF_BPF_EVENT_UNKNOWN = 0, + PERF_BPF_EVENT_PROG_LOAD = 1, + PERF_BPF_EVENT_PROG_UNLOAD = 2, + PERF_BPF_EVENT_MAX = 3, }; -struct stat_session { - struct list_head session_list; - struct tracer_stat *ts; - struct rb_root stat_root; - struct mutex stat_mutex; - struct dentry *file; +struct bpf_raw_tracepoint { + struct bpf_raw_event_map *btp; + struct bpf_prog *prog; }; -struct trace_bprintk_fmt { - struct list_head list; - const char *fmt; +struct bpf_verifier_log { + u32 level; + char kbuf[1024]; + char *ubuf; + u32 len_used; + u32 len_total; }; -enum { - TRACE_NOP_OPT_ACCEPT = 1, - TRACE_NOP_OPT_REFUSE = 2, +struct bpf_subprog_info { + u32 start; + u32 linfo_idx; + u16 stack_depth; }; -typedef __u32 blk_mq_req_flags_t; +struct bpf_verifier_stack_elem; -struct blk_mq_ctxs; +struct bpf_verifier_state; -struct blk_mq_ctx { +struct bpf_verifier_state_list; + +struct bpf_insn_aux_data; + +struct bpf_verifier_env { + u32 insn_idx; + u32 prev_insn_idx; + struct bpf_prog *prog; + const struct bpf_verifier_ops *ops; + struct bpf_verifier_stack_elem *head; + int stack_size; + bool strict_alignment; + bool test_state_freq; + struct bpf_verifier_state *cur_state; + struct bpf_verifier_state_list **explored_states; + struct bpf_verifier_state_list *free_list; + struct bpf_map *used_maps[64]; + u32 used_map_cnt; + u32 id_gen; + bool allow_ptr_leaks; + bool seen_direct_write; + struct bpf_insn_aux_data *insn_aux_data; + const struct bpf_line_info *prev_linfo; + struct bpf_verifier_log log; + struct bpf_subprog_info subprog_info[257]; struct { - spinlock_t lock; - struct list_head rq_lists[3]; - long: 64; + int *insn_state; + int *insn_stack; + int cur_stack; + } cfg; + u32 subprog_cnt; + u32 prev_insn_processed; + u32 insn_processed; + u32 prev_jmps_processed; + u32 jmps_processed; + u64 verification_time; + u32 max_states_per_insn; + u32 total_states; + u32 peak_states; + u32 longest_mark_read_walk; +}; + +typedef u32 (*bpf_convert_ctx_access_t)(enum bpf_access_type, const struct bpf_insn *, struct bpf_insn *, struct bpf_prog *, u32 *); + +struct tnum { + u64 value; + u64 mask; +}; + +enum bpf_reg_liveness { + REG_LIVE_NONE = 0, + REG_LIVE_READ32 = 1, + REG_LIVE_READ64 = 2, + REG_LIVE_READ = 3, + REG_LIVE_WRITTEN = 4, + REG_LIVE_DONE = 8, +}; + +struct bpf_reg_state { + enum bpf_reg_type type; + union { + u16 range; + struct bpf_map *map_ptr; + u32 btf_id; + long unsigned int raw; }; - unsigned int cpu; - short unsigned int index_hw[3]; - struct blk_mq_hw_ctx *hctxs[3]; - long unsigned int rq_dispatched[2]; - long unsigned int rq_merged; - long unsigned int rq_completed[2]; - struct request_queue *queue; - struct blk_mq_ctxs *ctxs; - struct kobject kobj; - long: 64; - long: 64; - long: 64; - long: 64; + s32 off; + u32 id; + u32 ref_obj_id; + struct tnum var_off; + s64 smin_value; + s64 smax_value; + u64 umin_value; + u64 umax_value; + struct bpf_reg_state *parent; + u32 frameno; + s32 subreg_def; + enum bpf_reg_liveness live; + bool precise; }; -struct sbitmap_word; +enum bpf_stack_slot_type { + STACK_INVALID = 0, + STACK_SPILL = 1, + STACK_MISC = 2, + STACK_ZERO = 3, +}; -struct sbitmap { - unsigned int depth; - unsigned int shift; - unsigned int map_nr; - struct sbitmap_word *map; +struct bpf_stack_state { + struct bpf_reg_state spilled_ptr; + u8 slot_type[8]; }; -struct blk_mq_tags; +struct bpf_reference_state { + int id; + int insn_idx; +}; -struct blk_mq_hw_ctx { - struct { - spinlock_t lock; - struct list_head dispatch; - long unsigned int state; - long: 64; - long: 64; - long: 64; - long: 64; - }; - struct delayed_work run_work; - cpumask_var_t cpumask; - int next_cpu; - int next_cpu_batch; - long unsigned int flags; - void *sched_data; - struct request_queue *queue; - struct blk_flush_queue *fq; - void *driver_data; - struct sbitmap ctx_map; - struct blk_mq_ctx *dispatch_from; - unsigned int dispatch_busy; - short unsigned int type; - short unsigned int nr_ctx; - struct blk_mq_ctx **ctxs; - spinlock_t dispatch_wait_lock; - wait_queue_entry_t dispatch_wait; - atomic_t wait_index; - struct blk_mq_tags *tags; - struct blk_mq_tags *sched_tags; - long unsigned int queued; - long unsigned int run; - long unsigned int dispatched[7]; - unsigned int numa_node; - unsigned int queue_num; - atomic_t nr_active; - struct hlist_node cpuhp_dead; - struct kobject kobj; - long unsigned int poll_considered; - long unsigned int poll_invoked; - long unsigned int poll_success; - struct dentry *debugfs_dir; - struct dentry *sched_debugfs_dir; - struct list_head hctx_list; - struct srcu_struct srcu[0]; - long: 64; - long: 64; - long: 64; +struct bpf_func_state { + struct bpf_reg_state regs[11]; + int callsite; + u32 frameno; + u32 subprogno; + int acquired_refs; + struct bpf_reference_state *refs; + int allocated_stack; + struct bpf_stack_state *stack; }; -struct blk_mq_alloc_data { - struct request_queue *q; - blk_mq_req_flags_t flags; - unsigned int shallow_depth; - unsigned int cmd_flags; - struct blk_mq_ctx *ctx; - struct blk_mq_hw_ctx *hctx; +struct bpf_idx_pair { + u32 prev_idx; + u32 idx; }; -struct blk_stat_callback { - struct list_head list; - struct timer_list timer; - struct blk_rq_stat *cpu_stat; - int (*bucket_fn)(const struct request *); - unsigned int buckets; - struct blk_rq_stat *stat; - void (*timer_fn)(struct blk_stat_callback *); - void *data; - struct callback_head rcu; +struct bpf_verifier_state { + struct bpf_func_state *frame[8]; + struct bpf_verifier_state *parent; + u32 branches; + u32 insn_idx; + u32 curframe; + u32 active_spin_lock; + bool speculative; + u32 first_insn_idx; + u32 last_insn_idx; + struct bpf_idx_pair *jmp_history; + u32 jmp_history_cnt; }; -struct blk_trace { - int trace_state; - struct rchan *rchan; - long unsigned int *sequence; - unsigned char *msg_data; - u16 act_mask; - u64 start_lba; - u64 end_lba; - u32 pid; - u32 dev; - struct dentry *dir; - struct dentry *dropped_file; - struct dentry *msg_file; - struct list_head running_list; - atomic_t dropped; +struct bpf_verifier_state_list { + struct bpf_verifier_state state; + struct bpf_verifier_state_list *next; + int miss_cnt; + int hit_cnt; }; -struct blk_flush_queue { - unsigned int flush_queue_delayed: 1; - unsigned int flush_pending_idx: 1; - unsigned int flush_running_idx: 1; - blk_status_t rq_status; - long unsigned int flush_pending_since; - struct list_head flush_queue[2]; - struct list_head flush_data_in_flight; - struct request *flush_rq; - struct request *orig_rq; - struct lock_class_key key; - spinlock_t mq_flush_lock; +struct bpf_insn_aux_data { + union { + enum bpf_reg_type ptr_type; + long unsigned int map_ptr_state; + s32 call_imm; + u32 alu_limit; + struct { + u32 map_index; + u32 map_off; + }; + }; + u64 map_key_state; + int ctx_field_size; + int sanitize_stack_off; + bool seen; + bool zext_dst; + u8 alu_state; + bool prune_point; + unsigned int orig_idx; }; -struct blk_mq_queue_map { - unsigned int *mq_map; - unsigned int nr_queues; - unsigned int queue_offset; +struct bpf_verifier_stack_elem { + struct bpf_verifier_state st; + int insn_idx; + int prev_insn_idx; + struct bpf_verifier_stack_elem *next; }; -struct blk_mq_tag_set { - struct blk_mq_queue_map map[3]; - unsigned int nr_maps; - const struct blk_mq_ops *ops; - unsigned int nr_hw_queues; - unsigned int queue_depth; - unsigned int reserved_tags; - unsigned int cmd_size; - int numa_node; - unsigned int timeout; - unsigned int flags; - void *driver_data; - struct blk_mq_tags **tags; - struct mutex tag_list_lock; - struct list_head tag_list; +typedef void (*bpf_insn_print_t)(void *, const char *, ...); + +typedef const char * (*bpf_insn_revmap_call_t)(void *, const struct bpf_insn *); + +typedef const char * (*bpf_insn_print_imm_t)(void *, const struct bpf_insn *, __u64); + +struct bpf_insn_cbs { + bpf_insn_print_t cb_print; + bpf_insn_revmap_call_t cb_call; + bpf_insn_print_imm_t cb_imm; + void *private_data; }; -typedef u64 compat_u64; +struct bpf_call_arg_meta { + struct bpf_map *map_ptr; + bool raw_mode; + bool pkt_access; + int regno; + int access_size; + s64 msize_smax_value; + u64 msize_umax_value; + int ref_obj_id; + int func_id; + u32 btf_id; +}; -enum blktrace_cat { - BLK_TC_READ = 1, - BLK_TC_WRITE = 2, - BLK_TC_FLUSH = 4, - BLK_TC_SYNC = 8, - BLK_TC_SYNCIO = 8, - BLK_TC_QUEUE = 16, - BLK_TC_REQUEUE = 32, - BLK_TC_ISSUE = 64, - BLK_TC_COMPLETE = 128, - BLK_TC_FS = 256, - BLK_TC_PC = 512, - BLK_TC_NOTIFY = 1024, - BLK_TC_AHEAD = 2048, - BLK_TC_META = 4096, - BLK_TC_DISCARD = 8192, - BLK_TC_DRV_DATA = 16384, - BLK_TC_FUA = 32768, - BLK_TC_END = 32768, +enum reg_arg_type { + SRC_OP = 0, + DST_OP = 1, + DST_OP_NO_MARK = 2, }; -enum blktrace_act { - __BLK_TA_QUEUE = 1, - __BLK_TA_BACKMERGE = 2, - __BLK_TA_FRONTMERGE = 3, - __BLK_TA_GETRQ = 4, - __BLK_TA_SLEEPRQ = 5, - __BLK_TA_REQUEUE = 6, - __BLK_TA_ISSUE = 7, - __BLK_TA_COMPLETE = 8, - __BLK_TA_PLUG = 9, - __BLK_TA_UNPLUG_IO = 10, - __BLK_TA_UNPLUG_TIMER = 11, - __BLK_TA_INSERT = 12, - __BLK_TA_SPLIT = 13, - __BLK_TA_BOUNCE = 14, - __BLK_TA_REMAP = 15, - __BLK_TA_ABORT = 16, - __BLK_TA_DRV_DATA = 17, - __BLK_TA_CGROUP = 256, +enum { + DISCOVERED = 16, + EXPLORED = 32, + FALLTHROUGH = 1, + BRANCH = 2, }; -enum blktrace_notify { - __BLK_TN_PROCESS = 0, - __BLK_TN_TIMESTAMP = 1, - __BLK_TN_MESSAGE = 2, - __BLK_TN_CGROUP = 256, +struct idpair { + u32 old; + u32 cur; }; -struct blk_io_trace { - __u32 magic; - __u32 sequence; - __u64 time; - __u64 sector; - __u32 bytes; - __u32 action; - __u32 pid; - __u32 device; - __u32 cpu; - __u16 error; - __u16 pdu_len; +struct tree_descr { + const char *name; + const struct file_operations *ops; + int mode; }; -struct blk_io_trace_remap { - __be32 device_from; - __be32 device_to; - __be64 sector_from; +enum bpf_type { + BPF_TYPE_UNSPEC = 0, + BPF_TYPE_PROG = 1, + BPF_TYPE_MAP = 2, +}; + +struct map_iter { + void *key; + bool done; }; enum { - Blktrace_setup = 1, - Blktrace_running = 2, - Blktrace_stopped = 3, + OPT_MODE = 0, }; -struct blk_user_trace_setup { - char name[32]; - __u16 act_mask; - __u32 buf_size; - __u32 buf_nr; - __u64 start_lba; - __u64 end_lba; - __u32 pid; +struct bpf_mount_opts { + umode_t mode; }; -struct compat_blk_user_trace_setup { - char name[32]; - u16 act_mask; - short: 16; - u32 buf_size; - u32 buf_nr; - compat_u64 start_lba; - compat_u64 end_lba; - u32 pid; -} __attribute__((packed)); +typedef u64 (*btf_bpf_map_lookup_elem)(struct bpf_map *, void *); -struct blkcg {}; +typedef u64 (*btf_bpf_map_update_elem)(struct bpf_map *, void *, void *, u64); -struct sbitmap_word { - long unsigned int depth; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +typedef u64 (*btf_bpf_map_delete_elem)(struct bpf_map *, void *); + +typedef u64 (*btf_bpf_map_push_elem)(struct bpf_map *, void *, u64); + +typedef u64 (*btf_bpf_map_pop_elem)(struct bpf_map *, void *); + +typedef u64 (*btf_bpf_map_peek_elem)(struct bpf_map *, void *); + +typedef u64 (*btf_bpf_get_smp_processor_id)(); + +typedef u64 (*btf_bpf_get_numa_node_id)(); + +typedef u64 (*btf_bpf_ktime_get_ns)(); + +typedef u64 (*btf_bpf_get_current_pid_tgid)(); + +typedef u64 (*btf_bpf_get_current_uid_gid)(); + +typedef u64 (*btf_bpf_get_current_comm)(char *, u32); + +typedef u64 (*btf_bpf_spin_lock)(struct bpf_spin_lock *); + +typedef u64 (*btf_bpf_spin_unlock)(struct bpf_spin_lock *); + +typedef u64 (*btf_bpf_get_current_cgroup_id)(); + +typedef u64 (*btf_bpf_get_local_storage)(struct bpf_map *, u64); + +typedef u64 (*btf_bpf_strtol)(const char *, size_t, u64, long int *); + +typedef u64 (*btf_bpf_strtoul)(const char *, size_t, u64, long unsigned int *); + +struct pcpu_freelist_node; + +struct pcpu_freelist_head { + struct pcpu_freelist_node *first; + raw_spinlock_t lock; +}; + +struct pcpu_freelist_node { + struct pcpu_freelist_node *next; +}; + +struct pcpu_freelist { + struct pcpu_freelist_head *freelist; +}; + +struct bpf_lru_node { + struct list_head list; + u16 cpu; + u8 type; + u8 ref; +}; + +struct bpf_lru_list { + struct list_head lists[3]; + unsigned int counts[2]; + struct list_head *next_inactive_rotation; + raw_spinlock_t lock; + long: 32; long: 64; - long unsigned int word; long: 64; long: 64; long: 64; long: 64; long: 64; long: 64; +}; + +struct bpf_lru_locallist { + struct list_head lists[2]; + u16 next_steal; + raw_spinlock_t lock; +}; + +struct bpf_common_lru { + struct bpf_lru_list lru_list; + struct bpf_lru_locallist *local_list; long: 64; - long unsigned int cleared; - spinlock_t swap_lock; - long: 32; long: 64; long: 64; long: 64; @@ -30188,804 +34794,1118 @@ struct sbitmap_word { long: 64; }; -struct sbq_wait_state { - atomic_t wait_cnt; - wait_queue_head_t wait; +typedef bool (*del_from_htab_func)(void *, struct bpf_lru_node *); + +struct bpf_lru { + union { + struct bpf_common_lru common_lru; + struct bpf_lru_list *percpu_lru; + }; + del_from_htab_func del_from_htab; + void *del_arg; + unsigned int hash_offset; + unsigned int nr_scans; + bool percpu; + long: 56; long: 64; long: 64; long: 64; long: 64; }; -struct sbitmap_queue { - struct sbitmap sb; - unsigned int *alloc_hint; - unsigned int wake_batch; - atomic_t wake_index; - struct sbq_wait_state *ws; - atomic_t ws_active; - bool round_robin; - unsigned int min_shallow_depth; -}; - -struct blk_mq_tags { - unsigned int nr_tags; - unsigned int nr_reserved_tags; - atomic_t active_queues; - struct sbitmap_queue bitmap_tags; - struct sbitmap_queue breserved_tags; - struct request **rqs; - struct request **static_rqs; - struct list_head page_list; -}; - -struct blk_mq_queue_data { - struct request *rq; - bool last; -}; - -struct blk_mq_ctxs { - struct kobject kobj; - struct blk_mq_ctx *queue_ctx; -}; - -typedef void blk_log_action_t(struct trace_iterator *, const char *, bool); - -struct ftrace_event_field { - struct list_head link; - const char *name; - const char *type; - int filter_type; - int offset; - int size; - int is_signed; -}; - -enum { - FORMAT_HEADER = 1, - FORMAT_FIELD_SEPERATOR = 2, - FORMAT_PRINTFMT = 3, +struct bucket { + struct hlist_nulls_head head; + raw_spinlock_t lock; }; -struct ftrace_graph_ent { - long unsigned int func; - int depth; -} __attribute__((packed)); - -struct ftrace_graph_ret { - long unsigned int func; - long unsigned int overrun; - long long unsigned int calltime; - long long unsigned int rettime; - int depth; -} __attribute__((packed)); - -struct mmiotrace_rw { - resource_size_t phys; - long unsigned int value; - long unsigned int pc; - int map_id; - unsigned char opcode; - unsigned char width; -}; +struct htab_elem; -struct mmiotrace_map { - resource_size_t phys; - long unsigned int virt; - long unsigned int len; - int map_id; - unsigned char opcode; +struct bpf_htab { + struct bpf_map map; + struct bucket *buckets; + void *elems; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + union { + struct pcpu_freelist freelist; + struct bpf_lru lru; + }; + struct htab_elem **extra_elems; + atomic_t count; + u32 n_buckets; + u32 elem_size; + u32 hashrnd; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct ftrace_graph_ent_entry { - struct trace_entry ent; - struct ftrace_graph_ent graph_ent; -} __attribute__((packed)); - -struct ftrace_graph_ret_entry { - struct trace_entry ent; - struct ftrace_graph_ret ret; -} __attribute__((packed)); - -struct trace_mmiotrace_rw { - struct trace_entry ent; - struct mmiotrace_rw rw; +struct htab_elem { + union { + struct hlist_nulls_node hash_node; + struct { + void *padding; + union { + struct bpf_htab *htab; + struct pcpu_freelist_node fnode; + }; + }; + }; + union { + struct callback_head rcu; + struct bpf_lru_node lru_node; + }; + u32 hash; + int: 32; + char key[0]; }; -struct trace_mmiotrace_map { - struct trace_entry ent; - struct mmiotrace_map map; +struct prog_poke_elem { + struct list_head list; + struct bpf_prog_aux *aux; }; -struct trace_branch { - struct trace_entry ent; - unsigned int line; - char func[31]; - char file[21]; - char correct; - char constant; +enum bpf_lru_list_type { + BPF_LRU_LIST_T_ACTIVE = 0, + BPF_LRU_LIST_T_INACTIVE = 1, + BPF_LRU_LIST_T_FREE = 2, + BPF_LRU_LOCAL_LIST_T_FREE = 3, + BPF_LRU_LOCAL_LIST_T_PENDING = 4, }; -typedef long unsigned int perf_trace_t[256]; - -struct filter_pred; - -struct prog_entry { - int target; - int when_to_branch; - struct filter_pred *pred; +struct bpf_lpm_trie_key { + __u32 prefixlen; + __u8 data[0]; }; -typedef int (*filter_pred_fn_t)(struct filter_pred *, void *); - -struct regex; - -typedef int (*regex_match_func)(char *, struct regex *, int); - -struct regex { - char pattern[256]; - int len; - int field_len; - regex_match_func match; +struct lpm_trie_node { + struct callback_head rcu; + struct lpm_trie_node *child[2]; + u32 prefixlen; + u32 flags; + u8 data[0]; }; -struct filter_pred { - filter_pred_fn_t fn; - u64 val; - struct regex regex; - short unsigned int *ops; - struct ftrace_event_field *field; - int offset; - int not; - int op; +struct lpm_trie { + struct bpf_map map; + struct lpm_trie_node *root; + size_t n_entries; + size_t max_prefixlen; + size_t data_size; + raw_spinlock_t lock; + long: 32; + long: 64; + long: 64; + long: 64; }; -enum regex_type { - MATCH_FULL = 0, - MATCH_FRONT_ONLY = 1, - MATCH_MIDDLE_ONLY = 2, - MATCH_END_ONLY = 3, - MATCH_GLOB = 4, - MATCH_INDEX = 5, +struct idr___2; + +struct bpf_cgroup_storage_map { + struct bpf_map map; + spinlock_t lock; + struct bpf_prog_aux *aux; + struct rb_root root; + struct list_head list; + long: 64; + long: 64; + long: 64; }; -enum filter_op_ids { - OP_GLOB = 0, - OP_NE = 1, - OP_EQ = 2, - OP_LE = 3, - OP_LT = 4, - OP_GE = 5, - OP_GT = 6, - OP_BAND = 7, - OP_MAX = 8, +struct btf_member { + __u32 name_off; + __u32 type; + __u32 offset; }; -enum { - FILT_ERR_NONE = 0, - FILT_ERR_INVALID_OP = 1, - FILT_ERR_TOO_MANY_OPEN = 2, - FILT_ERR_TOO_MANY_CLOSE = 3, - FILT_ERR_MISSING_QUOTE = 4, - FILT_ERR_OPERAND_TOO_LONG = 5, - FILT_ERR_EXPECT_STRING = 6, - FILT_ERR_EXPECT_DIGIT = 7, - FILT_ERR_ILLEGAL_FIELD_OP = 8, - FILT_ERR_FIELD_NOT_FOUND = 9, - FILT_ERR_ILLEGAL_INTVAL = 10, - FILT_ERR_BAD_SUBSYS_FILTER = 11, - FILT_ERR_TOO_MANY_PREDS = 12, - FILT_ERR_INVALID_FILTER = 13, - FILT_ERR_IP_FIELD_ONLY = 14, - FILT_ERR_INVALID_VALUE = 15, - FILT_ERR_ERRNO = 16, - FILT_ERR_NO_FILTER = 17, +struct bpf_queue_stack { + struct bpf_map map; + raw_spinlock_t lock; + u32 head; + u32 tail; + u32 size; + char elements[0]; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct filter_parse_error { - int lasterr; - int lasterr_pos; +struct btf_enum { + __u32 name_off; + __s32 val; }; -typedef int (*parse_pred_fn)(const char *, void *, int, struct filter_parse_error *, struct filter_pred **); +struct btf_array { + __u32 type; + __u32 index_type; + __u32 nelems; +}; -enum { - INVERT = 1, - PROCESS_AND = 2, - PROCESS_OR = 4, +struct btf_param { + __u32 name_off; + __u32 type; }; enum { - TOO_MANY_CLOSE = 4294967295, - TOO_MANY_OPEN = 4294967294, - MISSING_QUOTE = 4294967293, + BTF_VAR_STATIC = 0, + BTF_VAR_GLOBAL_ALLOCATED = 1, }; -struct filter_list { - struct list_head list; - struct event_filter *filter; +struct btf_var { + __u32 linkage; }; -struct event_trigger_ops; - -struct event_command; +struct btf_var_secinfo { + __u32 type; + __u32 offset; + __u32 size; +}; -struct event_trigger_data { - long unsigned int count; - int ref; - struct event_trigger_ops *ops; - struct event_command *cmd_ops; - struct event_filter *filter; - char *filter_str; - void *private_data; - bool paused; - bool paused_tmp; - struct list_head list; - char *name; - struct list_head named_list; - struct event_trigger_data *named_data; +struct bpf_flow_keys { + __u16 nhoff; + __u16 thoff; + __u16 addr_proto; + __u8 is_frag; + __u8 is_first_frag; + __u8 is_encap; + __u8 ip_proto; + __be16 n_proto; + __be16 sport; + __be16 dport; + union { + struct { + __be32 ipv4_src; + __be32 ipv4_dst; + }; + struct { + __u32 ipv6_src[4]; + __u32 ipv6_dst[4]; + }; + }; + __u32 flags; + __be32 flow_label; }; -struct event_trigger_ops { - void (*func)(struct event_trigger_data *, void *, struct ring_buffer_event *); - int (*init)(struct event_trigger_ops *, struct event_trigger_data *); - void (*free)(struct event_trigger_ops *, struct event_trigger_data *); - int (*print)(struct seq_file *, struct event_trigger_ops *, struct event_trigger_data *); +struct bpf_sock { + __u32 bound_dev_if; + __u32 family; + __u32 type; + __u32 protocol; + __u32 mark; + __u32 priority; + __u32 src_ip4; + __u32 src_ip6[4]; + __u32 src_port; + __u32 dst_port; + __u32 dst_ip4; + __u32 dst_ip6[4]; + __u32 state; }; -struct event_command { - struct list_head list; - char *name; - enum event_trigger_type trigger_type; - int flags; - int (*func)(struct event_command *, struct trace_event_file *, char *, char *, char *); - int (*reg)(char *, struct event_trigger_ops *, struct event_trigger_data *, struct trace_event_file *); - void (*unreg)(char *, struct event_trigger_ops *, struct event_trigger_data *, struct trace_event_file *); - void (*unreg_all)(struct trace_event_file *); - int (*set_filter)(char *, struct event_trigger_data *, struct trace_event_file *); - struct event_trigger_ops * (*get_trigger_ops)(char *, char *); +struct __sk_buff { + __u32 len; + __u32 pkt_type; + __u32 mark; + __u32 queue_mapping; + __u32 protocol; + __u32 vlan_present; + __u32 vlan_tci; + __u32 vlan_proto; + __u32 priority; + __u32 ingress_ifindex; + __u32 ifindex; + __u32 tc_index; + __u32 cb[5]; + __u32 hash; + __u32 tc_classid; + __u32 data; + __u32 data_end; + __u32 napi_id; + __u32 family; + __u32 remote_ip4; + __u32 local_ip4; + __u32 remote_ip6[4]; + __u32 local_ip6[4]; + __u32 remote_port; + __u32 local_port; + __u32 data_meta; + union { + struct bpf_flow_keys *flow_keys; + }; + __u64 tstamp; + __u32 wire_len; + __u32 gso_segs; + union { + struct bpf_sock *sk; + }; }; -struct enable_trigger_data { - struct trace_event_file *file; - bool enable; - bool hist; +struct xdp_md { + __u32 data; + __u32 data_end; + __u32 data_meta; + __u32 ingress_ifindex; + __u32 rx_queue_index; }; -enum event_command_flags { - EVENT_CMD_FL_POST_TRIGGER = 1, - EVENT_CMD_FL_NEEDS_REC = 2, +struct sk_msg_md { + union { + void *data; + }; + union { + void *data_end; + }; + __u32 family; + __u32 remote_ip4; + __u32 local_ip4; + __u32 remote_ip6[4]; + __u32 local_ip6[4]; + __u32 remote_port; + __u32 local_port; + __u32 size; }; -enum bpf_task_fd_type { - BPF_FD_TYPE_RAW_TRACEPOINT = 0, - BPF_FD_TYPE_TRACEPOINT = 1, - BPF_FD_TYPE_KPROBE = 2, - BPF_FD_TYPE_KRETPROBE = 3, - BPF_FD_TYPE_UPROBE = 4, - BPF_FD_TYPE_URETPROBE = 5, +struct sk_reuseport_md { + union { + void *data; + }; + union { + void *data_end; + }; + __u32 len; + __u32 eth_protocol; + __u32 ip_protocol; + __u32 bind_inany; + __u32 hash; }; -struct kprobe_trace_entry_head { - struct trace_entry ent; - long unsigned int ip; +struct bpf_sock_addr { + __u32 user_family; + __u32 user_ip4; + __u32 user_ip6[4]; + __u32 user_port; + __u32 family; + __u32 type; + __u32 protocol; + __u32 msg_src_ip4; + __u32 msg_src_ip6[4]; + union { + struct bpf_sock *sk; + }; }; -struct kretprobe_trace_entry_head { - struct trace_entry ent; - long unsigned int func; - long unsigned int ret_ip; +struct bpf_sock_ops { + __u32 op; + union { + __u32 args[4]; + __u32 reply; + __u32 replylong[4]; + }; + __u32 family; + __u32 remote_ip4; + __u32 local_ip4; + __u32 remote_ip6[4]; + __u32 local_ip6[4]; + __u32 remote_port; + __u32 local_port; + __u32 is_fullsock; + __u32 snd_cwnd; + __u32 srtt_us; + __u32 bpf_sock_ops_cb_flags; + __u32 state; + __u32 rtt_min; + __u32 snd_ssthresh; + __u32 rcv_nxt; + __u32 snd_nxt; + __u32 snd_una; + __u32 mss_cache; + __u32 ecn_flags; + __u32 rate_delivered; + __u32 rate_interval_us; + __u32 packets_out; + __u32 retrans_out; + __u32 total_retrans; + __u32 segs_in; + __u32 data_segs_in; + __u32 segs_out; + __u32 data_segs_out; + __u32 lost_out; + __u32 sacked_out; + __u32 sk_txhash; + __u64 bytes_received; + __u64 bytes_acked; + union { + struct bpf_sock *sk; + }; }; -struct dyn_event; +struct bpf_cgroup_dev_ctx { + __u32 access_type; + __u32 major; + __u32 minor; +}; -struct dyn_event_operations { - struct list_head list; - int (*create)(int, const char **); - int (*show)(struct seq_file *, struct dyn_event *); - bool (*is_busy)(struct dyn_event *); - int (*free)(struct dyn_event *); - bool (*match)(const char *, const char *, int, const char **, struct dyn_event *); +struct bpf_sysctl { + __u32 write; + __u32 file_pos; }; -struct dyn_event { - struct list_head list; - struct dyn_event_operations *ops; +struct bpf_sockopt { + union { + struct bpf_sock *sk; + }; + union { + void *optval; + }; + union { + void *optval_end; + }; + __s32 level; + __s32 optname; + __s32 optlen; + __s32 retval; }; -typedef int (*print_type_func_t)(struct trace_seq *, void *, void *); +struct sk_reuseport_kern { + struct sk_buff *skb; + struct sock *sk; + struct sock *selected_sk; + void *data_end; + u32 hash; + u32 reuseport_id; + bool bind_inany; +}; -enum fetch_op { - FETCH_OP_NOP = 0, - FETCH_OP_REG = 1, - FETCH_OP_STACK = 2, - FETCH_OP_STACKP = 3, - FETCH_OP_RETVAL = 4, - FETCH_OP_IMM = 5, - FETCH_OP_COMM = 6, - FETCH_OP_ARG = 7, - FETCH_OP_FOFFS = 8, - FETCH_OP_DATA = 9, - FETCH_OP_DEREF = 10, - FETCH_OP_UDEREF = 11, - FETCH_OP_ST_RAW = 12, - FETCH_OP_ST_MEM = 13, - FETCH_OP_ST_UMEM = 14, - FETCH_OP_ST_STRING = 15, - FETCH_OP_ST_USTRING = 16, - FETCH_OP_MOD_BF = 17, - FETCH_OP_LP_ARRAY = 18, - FETCH_OP_END = 19, - FETCH_NOP_SYMBOL = 20, +struct bpf_flow_dissector { + struct bpf_flow_keys *flow_keys; + const struct sk_buff *skb; + void *data; + void *data_end; }; -struct fetch_insn { - enum fetch_op op; +struct inet_listen_hashbucket { + spinlock_t lock; + unsigned int count; union { - unsigned int param; - struct { - unsigned int size; - int offset; - }; - struct { - unsigned char basesize; - unsigned char lshift; - unsigned char rshift; - }; - long unsigned int immediate; - void *data; + struct hlist_head head; + struct hlist_nulls_head nulls_head; }; }; -struct fetch_type { - const char *name; - size_t size; - int is_signed; - print_type_func_t print; - const char *fmt; - const char *fmttype; -}; +struct inet_ehash_bucket; -struct probe_arg { - struct fetch_insn *code; - bool dynamic; - unsigned int offset; - unsigned int count; - const char *name; - const char *comm; - char *fmt; - const struct fetch_type *type; +struct inet_bind_hashbucket; + +struct inet_hashinfo { + struct inet_ehash_bucket *ehash; + spinlock_t *ehash_locks; + unsigned int ehash_mask; + unsigned int ehash_locks_mask; + struct kmem_cache *bind_bucket_cachep; + struct inet_bind_hashbucket *bhash; + unsigned int bhash_size; + unsigned int lhash2_mask; + struct inet_listen_hashbucket *lhash2; + long: 64; + struct inet_listen_hashbucket listening_hash[32]; }; -struct trace_uprobe_filter { - rwlock_t rwlock; - int nr_systemwide; - struct list_head perf_events; +struct ip_ra_chain { + struct ip_ra_chain *next; + struct sock *sk; + union { + void (*destructor)(struct sock *); + struct sock *saved_sk; + }; + struct callback_head rcu; }; -struct trace_probe_event { - unsigned int flags; - struct trace_event_class class; - struct trace_event_call call; - struct list_head files; - struct list_head probes; - struct trace_uprobe_filter filter[0]; +struct fib_table { + struct hlist_node tb_hlist; + u32 tb_id; + int tb_num_default; + struct callback_head rcu; + long unsigned int *tb_data; + long unsigned int __data[0]; }; -struct trace_probe { - struct list_head list; - struct trace_probe_event *event; - ssize_t size; - unsigned int nr_args; - struct probe_arg args[0]; +struct inet_peer_base { + struct rb_root rb_root; + seqlock_t lock; + int total; }; -struct event_file_link { - struct trace_event_file *file; - struct list_head list; +struct tcp_fastopen_context { + siphash_key_t key[2]; + int num; + struct callback_head rcu; }; -enum { - TP_ERR_FILE_NOT_FOUND = 0, - TP_ERR_NO_REGULAR_FILE = 1, - TP_ERR_BAD_REFCNT = 2, - TP_ERR_REFCNT_OPEN_BRACE = 3, - TP_ERR_BAD_REFCNT_SUFFIX = 4, - TP_ERR_BAD_UPROBE_OFFS = 5, - TP_ERR_MAXACT_NO_KPROBE = 6, - TP_ERR_BAD_MAXACT = 7, - TP_ERR_MAXACT_TOO_BIG = 8, - TP_ERR_BAD_PROBE_ADDR = 9, - TP_ERR_BAD_RETPROBE = 10, - TP_ERR_NO_GROUP_NAME = 11, - TP_ERR_GROUP_TOO_LONG = 12, - TP_ERR_BAD_GROUP_NAME = 13, - TP_ERR_NO_EVENT_NAME = 14, - TP_ERR_EVENT_TOO_LONG = 15, - TP_ERR_BAD_EVENT_NAME = 16, - TP_ERR_RETVAL_ON_PROBE = 17, - TP_ERR_BAD_STACK_NUM = 18, - TP_ERR_BAD_ARG_NUM = 19, - TP_ERR_BAD_VAR = 20, - TP_ERR_BAD_REG_NAME = 21, - TP_ERR_BAD_MEM_ADDR = 22, - TP_ERR_BAD_IMM = 23, - TP_ERR_IMMSTR_NO_CLOSE = 24, - TP_ERR_FILE_ON_KPROBE = 25, - TP_ERR_BAD_FILE_OFFS = 26, - TP_ERR_SYM_ON_UPROBE = 27, - TP_ERR_TOO_MANY_OPS = 28, - TP_ERR_DEREF_NEED_BRACE = 29, - TP_ERR_BAD_DEREF_OFFS = 30, - TP_ERR_DEREF_OPEN_BRACE = 31, - TP_ERR_COMM_CANT_DEREF = 32, - TP_ERR_BAD_FETCH_ARG = 33, - TP_ERR_ARRAY_NO_CLOSE = 34, - TP_ERR_BAD_ARRAY_SUFFIX = 35, - TP_ERR_BAD_ARRAY_NUM = 36, - TP_ERR_ARRAY_TOO_BIG = 37, - TP_ERR_BAD_TYPE = 38, - TP_ERR_BAD_STRING = 39, - TP_ERR_BAD_BITFIELD = 40, - TP_ERR_ARG_NAME_TOO_LONG = 41, - TP_ERR_NO_ARG_NAME = 42, - TP_ERR_BAD_ARG_NAME = 43, - TP_ERR_USED_ARG_NAME = 44, - TP_ERR_ARG_TOO_LONG = 45, - TP_ERR_NO_ARG_BODY = 46, - TP_ERR_BAD_INSN_BNDRY = 47, - TP_ERR_FAIL_REG_PROBE = 48, - TP_ERR_DIFF_PROBE_TYPE = 49, - TP_ERR_DIFF_ARG_TYPE = 50, - TP_ERR_SAME_PROBE = 51, +struct xdp_buff { + void *data; + void *data_end; + void *data_meta; + void *data_hard_start; + long unsigned int handle; + struct xdp_rxq_info *rxq; }; -struct trace_kprobe { - struct dyn_event devent; - struct kretprobe rp; - long unsigned int *nhit; - const char *symbol; - struct trace_probe tp; +struct bpf_sock_addr_kern { + struct sock *sk; + struct sockaddr *uaddr; + u64 tmp_reg; + void *t_ctx; }; -struct trace_event_raw_cpu { - struct trace_entry ent; - u32 state; - u32 cpu_id; - char __data[0]; +struct bpf_sock_ops_kern { + struct sock *sk; + u32 op; + union { + u32 args[4]; + u32 reply; + u32 replylong[4]; + }; + u32 is_fullsock; + u64 temp; }; -struct trace_event_raw_powernv_throttle { - struct trace_entry ent; - int chip_id; - u32 __data_loc_reason; - int pmax; - char __data[0]; +struct bpf_sysctl_kern { + struct ctl_table_header *head; + struct ctl_table *table; + void *cur_val; + size_t cur_len; + void *new_val; + size_t new_len; + int new_updated; + int write; + loff_t *ppos; + u64 tmp_reg; }; -struct trace_event_raw_pstate_sample { - struct trace_entry ent; - u32 core_busy; - u32 scaled_busy; - u32 from; - u32 to; - u64 mperf; - u64 aperf; - u64 tsc; - u32 freq; - u32 io_boost; - char __data[0]; +struct bpf_sockopt_kern { + struct sock *sk; + u8 *optval; + u8 *optval_end; + s32 level; + s32 optname; + s32 optlen; + s32 retval; }; -struct trace_event_raw_cpu_frequency_limits { - struct trace_entry ent; - u32 min_freq; - u32 max_freq; - u32 cpu_id; - char __data[0]; +struct sock_reuseport { + struct callback_head rcu; + u16 max_socks; + u16 num_socks; + unsigned int synq_overflow_ts; + unsigned int reuseport_id; + unsigned int bind_inany: 1; + unsigned int has_conns: 1; + struct bpf_prog *prog; + struct sock *socks[0]; }; -struct trace_event_raw_device_pm_callback_start { - struct trace_entry ent; - u32 __data_loc_device; - u32 __data_loc_driver; - u32 __data_loc_parent; - u32 __data_loc_pm_ops; - int event; - char __data[0]; +struct ip_rt_acct { + __u32 o_bytes; + __u32 o_packets; + __u32 i_bytes; + __u32 i_packets; }; -struct trace_event_raw_device_pm_callback_end { - struct trace_entry ent; - u32 __data_loc_device; - u32 __data_loc_driver; - int error; - char __data[0]; +struct inet_ehash_bucket { + struct hlist_nulls_head chain; }; -struct trace_event_raw_suspend_resume { - struct trace_entry ent; - const char *action; - int val; - bool start; - char __data[0]; +struct inet_bind_hashbucket { + spinlock_t lock; + struct hlist_head chain; }; -struct trace_event_raw_wakeup_source { - struct trace_entry ent; - u32 __data_loc_name; - u64 state; - char __data[0]; +struct ack_sample { + u32 pkts_acked; + s32 rtt_us; + u32 in_flight; }; -struct trace_event_raw_clock { - struct trace_entry ent; - u32 __data_loc_name; - u64 state; - u64 cpu_id; - char __data[0]; +struct rate_sample { + u64 prior_mstamp; + u32 prior_delivered; + s32 delivered; + long int interval_us; + u32 snd_interval_us; + u32 rcv_interval_us; + long int rtt_us; + int losses; + u32 acked_sacked; + u32 prior_in_flight; + bool is_app_limited; + bool is_retrans; + bool is_ack_delayed; }; -struct trace_event_raw_power_domain { - struct trace_entry ent; - u32 __data_loc_name; - u64 state; - u64 cpu_id; - char __data[0]; +struct sk_msg_sg { + u32 start; + u32 curr; + u32 end; + u32 size; + u32 copybreak; + long unsigned int copy; + struct scatterlist data[19]; }; -struct trace_event_raw_pm_qos_request { - struct trace_entry ent; - int pm_qos_class; - s32 value; - char __data[0]; +struct sk_msg { + struct sk_msg_sg sg; + void *data; + void *data_end; + u32 apply_bytes; + u32 cork_bytes; + u32 flags; + struct sk_buff *skb; + struct sock *sk_redir; + struct sock *sk; + struct list_head list; }; -struct trace_event_raw_pm_qos_update_request_timeout { - struct trace_entry ent; - int pm_qos_class; - s32 value; - long unsigned int timeout_us; - char __data[0]; +enum verifier_phase { + CHECK_META = 0, + CHECK_TYPE = 1, }; -struct trace_event_raw_pm_qos_update { - struct trace_entry ent; - enum pm_qos_req_action action; - int prev_value; - int curr_value; - char __data[0]; +struct resolve_vertex { + const struct btf_type *t; + u32 type_id; + u16 next_member; }; -struct trace_event_raw_dev_pm_qos_request { - struct trace_entry ent; - u32 __data_loc_name; - enum dev_pm_qos_req_type type; - s32 new_value; - char __data[0]; +enum visit_state { + NOT_VISITED = 0, + VISITED = 1, + RESOLVED = 2, }; -struct trace_event_data_offsets_cpu {}; +enum resolve_mode { + RESOLVE_TBD = 0, + RESOLVE_PTR = 1, + RESOLVE_STRUCT_OR_ARRAY = 2, +}; -struct trace_event_data_offsets_powernv_throttle { - u32 reason; +struct btf_sec_info { + u32 off; + u32 len; }; -struct trace_event_data_offsets_pstate_sample {}; +struct btf_verifier_env { + struct btf *btf; + u8 *visit_states; + struct resolve_vertex stack[32]; + struct bpf_verifier_log log; + u32 log_type_id; + u32 top_stack; + enum verifier_phase phase; + enum resolve_mode resolve_mode; +}; + +struct btf_kind_operations { + s32 (*check_meta)(struct btf_verifier_env *, const struct btf_type *, u32); + int (*resolve)(struct btf_verifier_env *, const struct resolve_vertex *); + int (*check_member)(struct btf_verifier_env *, const struct btf_type *, const struct btf_member *, const struct btf_type *); + int (*check_kflag_member)(struct btf_verifier_env *, const struct btf_type *, const struct btf_member *, const struct btf_type *); + void (*log_details)(struct btf_verifier_env *, const struct btf_type *); + void (*seq_show)(const struct btf *, const struct btf_type *, u32, void *, u8, struct seq_file *); +}; + +struct bpf_ctx_convert { + struct __sk_buff BPF_PROG_TYPE_SOCKET_FILTER_prog; + struct sk_buff BPF_PROG_TYPE_SOCKET_FILTER_kern; + struct __sk_buff BPF_PROG_TYPE_SCHED_CLS_prog; + struct sk_buff BPF_PROG_TYPE_SCHED_CLS_kern; + struct __sk_buff BPF_PROG_TYPE_SCHED_ACT_prog; + struct sk_buff BPF_PROG_TYPE_SCHED_ACT_kern; + struct xdp_md BPF_PROG_TYPE_XDP_prog; + struct xdp_buff BPF_PROG_TYPE_XDP_kern; + struct __sk_buff BPF_PROG_TYPE_CGROUP_SKB_prog; + struct sk_buff BPF_PROG_TYPE_CGROUP_SKB_kern; + struct bpf_sock BPF_PROG_TYPE_CGROUP_SOCK_prog; + struct sock BPF_PROG_TYPE_CGROUP_SOCK_kern; + struct bpf_sock_addr BPF_PROG_TYPE_CGROUP_SOCK_ADDR_prog; + struct bpf_sock_addr_kern BPF_PROG_TYPE_CGROUP_SOCK_ADDR_kern; + struct __sk_buff BPF_PROG_TYPE_LWT_IN_prog; + struct sk_buff BPF_PROG_TYPE_LWT_IN_kern; + struct __sk_buff BPF_PROG_TYPE_LWT_OUT_prog; + struct sk_buff BPF_PROG_TYPE_LWT_OUT_kern; + struct __sk_buff BPF_PROG_TYPE_LWT_XMIT_prog; + struct sk_buff BPF_PROG_TYPE_LWT_XMIT_kern; + struct __sk_buff BPF_PROG_TYPE_LWT_SEG6LOCAL_prog; + struct sk_buff BPF_PROG_TYPE_LWT_SEG6LOCAL_kern; + struct bpf_sock_ops BPF_PROG_TYPE_SOCK_OPS_prog; + struct bpf_sock_ops_kern BPF_PROG_TYPE_SOCK_OPS_kern; + struct __sk_buff BPF_PROG_TYPE_SK_SKB_prog; + struct sk_buff BPF_PROG_TYPE_SK_SKB_kern; + struct sk_msg_md BPF_PROG_TYPE_SK_MSG_prog; + struct sk_msg BPF_PROG_TYPE_SK_MSG_kern; + struct __sk_buff BPF_PROG_TYPE_FLOW_DISSECTOR_prog; + struct bpf_flow_dissector BPF_PROG_TYPE_FLOW_DISSECTOR_kern; + bpf_user_pt_regs_t BPF_PROG_TYPE_KPROBE_prog; + struct pt_regs BPF_PROG_TYPE_KPROBE_kern; + __u64 BPF_PROG_TYPE_TRACEPOINT_prog; + u64 BPF_PROG_TYPE_TRACEPOINT_kern; + struct bpf_perf_event_data BPF_PROG_TYPE_PERF_EVENT_prog; + struct bpf_perf_event_data_kern BPF_PROG_TYPE_PERF_EVENT_kern; + struct bpf_raw_tracepoint_args BPF_PROG_TYPE_RAW_TRACEPOINT_prog; + u64 BPF_PROG_TYPE_RAW_TRACEPOINT_kern; + struct bpf_raw_tracepoint_args BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE_prog; + u64 BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE_kern; + void *BPF_PROG_TYPE_TRACING_prog; + void *BPF_PROG_TYPE_TRACING_kern; + struct bpf_cgroup_dev_ctx BPF_PROG_TYPE_CGROUP_DEVICE_prog; + struct bpf_cgroup_dev_ctx BPF_PROG_TYPE_CGROUP_DEVICE_kern; + struct bpf_sysctl BPF_PROG_TYPE_CGROUP_SYSCTL_prog; + struct bpf_sysctl_kern BPF_PROG_TYPE_CGROUP_SYSCTL_kern; + struct bpf_sockopt BPF_PROG_TYPE_CGROUP_SOCKOPT_prog; + struct bpf_sockopt_kern BPF_PROG_TYPE_CGROUP_SOCKOPT_kern; + struct sk_reuseport_md BPF_PROG_TYPE_SK_REUSEPORT_prog; + struct sk_reuseport_kern BPF_PROG_TYPE_SK_REUSEPORT_kern; +}; + +enum { + __ctx_convertBPF_PROG_TYPE_SOCKET_FILTER = 0, + __ctx_convertBPF_PROG_TYPE_SCHED_CLS = 1, + __ctx_convertBPF_PROG_TYPE_SCHED_ACT = 2, + __ctx_convertBPF_PROG_TYPE_XDP = 3, + __ctx_convertBPF_PROG_TYPE_CGROUP_SKB = 4, + __ctx_convertBPF_PROG_TYPE_CGROUP_SOCK = 5, + __ctx_convertBPF_PROG_TYPE_CGROUP_SOCK_ADDR = 6, + __ctx_convertBPF_PROG_TYPE_LWT_IN = 7, + __ctx_convertBPF_PROG_TYPE_LWT_OUT = 8, + __ctx_convertBPF_PROG_TYPE_LWT_XMIT = 9, + __ctx_convertBPF_PROG_TYPE_LWT_SEG6LOCAL = 10, + __ctx_convertBPF_PROG_TYPE_SOCK_OPS = 11, + __ctx_convertBPF_PROG_TYPE_SK_SKB = 12, + __ctx_convertBPF_PROG_TYPE_SK_MSG = 13, + __ctx_convertBPF_PROG_TYPE_FLOW_DISSECTOR = 14, + __ctx_convertBPF_PROG_TYPE_KPROBE = 15, + __ctx_convertBPF_PROG_TYPE_TRACEPOINT = 16, + __ctx_convertBPF_PROG_TYPE_PERF_EVENT = 17, + __ctx_convertBPF_PROG_TYPE_RAW_TRACEPOINT = 18, + __ctx_convertBPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE = 19, + __ctx_convertBPF_PROG_TYPE_TRACING = 20, + __ctx_convertBPF_PROG_TYPE_CGROUP_DEVICE = 21, + __ctx_convertBPF_PROG_TYPE_CGROUP_SYSCTL = 22, + __ctx_convertBPF_PROG_TYPE_CGROUP_SOCKOPT = 23, + __ctx_convertBPF_PROG_TYPE_SK_REUSEPORT = 24, + __ctx_convert_unused = 25, +}; -struct trace_event_data_offsets_cpu_frequency_limits {}; +enum net_device_flags { + IFF_UP = 1, + IFF_BROADCAST = 2, + IFF_DEBUG = 4, + IFF_LOOPBACK = 8, + IFF_POINTOPOINT = 16, + IFF_NOTRAILERS = 32, + IFF_RUNNING = 64, + IFF_NOARP = 128, + IFF_PROMISC = 256, + IFF_ALLMULTI = 512, + IFF_MASTER = 1024, + IFF_SLAVE = 2048, + IFF_MULTICAST = 4096, + IFF_PORTSEL = 8192, + IFF_AUTOMEDIA = 16384, + IFF_DYNAMIC = 32768, + IFF_LOWER_UP = 65536, + IFF_DORMANT = 131072, + IFF_ECHO = 262144, +}; -struct trace_event_data_offsets_device_pm_callback_start { - u32 device; - u32 driver; - u32 parent; - u32 pm_ops; +enum netdev_cmd { + NETDEV_UP = 1, + NETDEV_DOWN = 2, + NETDEV_REBOOT = 3, + NETDEV_CHANGE = 4, + NETDEV_REGISTER = 5, + NETDEV_UNREGISTER = 6, + NETDEV_CHANGEMTU = 7, + NETDEV_CHANGEADDR = 8, + NETDEV_PRE_CHANGEADDR = 9, + NETDEV_GOING_DOWN = 10, + NETDEV_CHANGENAME = 11, + NETDEV_FEAT_CHANGE = 12, + NETDEV_BONDING_FAILOVER = 13, + NETDEV_PRE_UP = 14, + NETDEV_PRE_TYPE_CHANGE = 15, + NETDEV_POST_TYPE_CHANGE = 16, + NETDEV_POST_INIT = 17, + NETDEV_RELEASE = 18, + NETDEV_NOTIFY_PEERS = 19, + NETDEV_JOIN = 20, + NETDEV_CHANGEUPPER = 21, + NETDEV_RESEND_IGMP = 22, + NETDEV_PRECHANGEMTU = 23, + NETDEV_CHANGEINFODATA = 24, + NETDEV_BONDING_INFO = 25, + NETDEV_PRECHANGEUPPER = 26, + NETDEV_CHANGELOWERSTATE = 27, + NETDEV_UDP_TUNNEL_PUSH_INFO = 28, + NETDEV_UDP_TUNNEL_DROP_INFO = 29, + NETDEV_CHANGE_TX_QUEUE_LEN = 30, + NETDEV_CVLAN_FILTER_PUSH_INFO = 31, + NETDEV_CVLAN_FILTER_DROP_INFO = 32, + NETDEV_SVLAN_FILTER_PUSH_INFO = 33, + NETDEV_SVLAN_FILTER_DROP_INFO = 34, }; -struct trace_event_data_offsets_device_pm_callback_end { - u32 device; - u32 driver; +struct netdev_notifier_info { + struct net_device *dev; + struct netlink_ext_ack *extack; }; -struct trace_event_data_offsets_suspend_resume {}; +struct bpf_dtab_netdev; -struct trace_event_data_offsets_wakeup_source { - u32 name; +struct xdp_bulk_queue { + struct xdp_frame *q[16]; + struct list_head flush_node; + struct net_device *dev_rx; + struct bpf_dtab_netdev *obj; + unsigned int count; }; -struct trace_event_data_offsets_clock { - u32 name; +struct bpf_dtab; + +struct bpf_dtab_netdev { + struct net_device *dev; + struct hlist_node index_hlist; + struct bpf_dtab *dtab; + struct xdp_bulk_queue *bulkq; + struct callback_head rcu; + unsigned int idx; }; -struct trace_event_data_offsets_power_domain { - u32 name; +struct bpf_dtab { + struct bpf_map map; + struct bpf_dtab_netdev **netdev_map; + struct list_head *flush_list; + struct list_head list; + struct hlist_head *dev_index_head; + spinlock_t index_lock; + unsigned int items; + u32 n_buckets; + long: 32; + long: 64; }; -struct trace_event_data_offsets_pm_qos_request {}; +typedef struct bio_vec skb_frag_t; -struct trace_event_data_offsets_pm_qos_update_request_timeout {}; +struct skb_shared_hwtstamps { + ktime_t hwtstamp; +}; -struct trace_event_data_offsets_pm_qos_update {}; +struct skb_shared_info { + __u8 __unused; + __u8 meta_len; + __u8 nr_frags; + __u8 tx_flags; + short unsigned int gso_size; + short unsigned int gso_segs; + struct sk_buff *frag_list; + struct skb_shared_hwtstamps hwtstamps; + unsigned int gso_type; + u32 tskey; + atomic_t dataref; + void *destructor_arg; + skb_frag_t frags[17]; +}; -struct trace_event_data_offsets_dev_pm_qos_request { - u32 name; +struct ptr_ring { + int producer; + spinlock_t producer_lock; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + int consumer_head; + int consumer_tail; + spinlock_t consumer_lock; + long: 32; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + int size; + int batch; + void **queue; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct trace_event_raw_rpm_internal { - struct trace_entry ent; - u32 __data_loc_name; - int flags; - int usage_count; - int disable_depth; - int runtime_auto; - int request_pending; - int irq_safe; - int child_count; - char __data[0]; +struct bpf_cpu_map_entry; + +struct xdp_bulk_queue___2 { + void *q[8]; + struct list_head flush_node; + struct bpf_cpu_map_entry *obj; + unsigned int count; }; -struct trace_event_raw_rpm_return_int { - struct trace_entry ent; - u32 __data_loc_name; - long unsigned int ip; - int ret; - char __data[0]; +struct bpf_cpu_map; + +struct bpf_cpu_map_entry { + u32 cpu; + int map_id; + u32 qsize; + struct xdp_bulk_queue___2 *bulkq; + struct bpf_cpu_map *cmap; + struct ptr_ring *queue; + struct task_struct *kthread; + struct work_struct kthread_stop_wq; + atomic_t refcnt; + struct callback_head rcu; }; -struct trace_event_data_offsets_rpm_internal { - u32 name; +struct bpf_cpu_map { + struct bpf_map map; + struct bpf_cpu_map_entry **cpu_map; + struct list_head *flush_list; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct trace_event_data_offsets_rpm_return_int { - u32 name; +struct xsk_queue; + +struct xdp_umem_page; + +struct xdp_umem_fq_reuse; + +struct xdp_umem { + struct xsk_queue *fq; + struct xsk_queue *cq; + struct xdp_umem_page *pages; + u64 chunk_mask; + u64 size; + u32 headroom; + u32 chunk_size_nohr; + struct user_struct *user; + long unsigned int address; + refcount_t users; + struct work_struct work; + struct page **pgs; + u32 npgs; + u16 queue_id; + u8 need_wakeup; + u8 flags; + int id; + struct net_device *dev; + struct xdp_umem_fq_reuse *fq_reuse; + bool zc; + spinlock_t xsk_list_lock; + struct list_head xsk_list; }; -struct trace_probe_log { - const char *subsystem; - const char **argv; - int argc; - int index; +struct xdp_umem_page { + void *addr; + dma_addr_t dma; }; -enum uprobe_filter_ctx { - UPROBE_FILTER_REGISTER = 0, - UPROBE_FILTER_UNREGISTER = 1, - UPROBE_FILTER_MMAP = 2, +struct xdp_umem_fq_reuse { + u32 nentries; + u32 length; + u64 handles[0]; }; -struct uprobe_consumer { - int (*handler)(struct uprobe_consumer *, struct pt_regs *); - int (*ret_handler)(struct uprobe_consumer *, long unsigned int, struct pt_regs *); - bool (*filter)(struct uprobe_consumer *, enum uprobe_filter_ctx, struct mm_struct *); - struct uprobe_consumer *next; +struct xdp_sock; + +struct xsk_map { + struct bpf_map map; + struct list_head *flush_list; + spinlock_t lock; + struct xdp_sock *xsk_map[0]; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct uprobe_trace_entry_head { - struct trace_entry ent; - long unsigned int vaddr[0]; +struct xdp_sock { + struct sock sk; + struct xsk_queue *rx; + struct net_device *dev; + struct xdp_umem *umem; + struct list_head flush_node; + u16 queue_id; + bool zc; + enum { + XSK_READY = 0, + XSK_BOUND = 1, + XSK_UNBOUND = 2, + } state; + struct mutex mutex; + struct xsk_queue *tx; + struct list_head list; + spinlock_t tx_completion_lock; + spinlock_t rx_lock; + u64 rx_dropped; + struct list_head map_list; + spinlock_t map_list_lock; }; -struct trace_uprobe { - struct dyn_event devent; - struct uprobe_consumer consumer; - struct path path; - struct inode *inode; - char *filename; - long unsigned int offset; - long unsigned int ref_ctr_offset; - long unsigned int nhit; - struct trace_probe tp; +struct xsk_map_node { + struct list_head node; + struct xsk_map *map; + struct xdp_sock **map_entry; }; -struct uprobe_dispatch_data { - struct trace_uprobe *tu; - long unsigned int bp_addr; +struct bpf_prog_offload_ops { + int (*insn_hook)(struct bpf_verifier_env *, int, int); + int (*finalize)(struct bpf_verifier_env *); + int (*replace_insn)(struct bpf_verifier_env *, u32, struct bpf_insn *); + int (*remove_insns)(struct bpf_verifier_env *, u32, u32); + int (*prepare)(struct bpf_prog *); + int (*translate)(struct bpf_prog *); + void (*destroy)(struct bpf_prog *); }; -struct uprobe_cpu_buffer { - struct mutex mutex; - void *buf; +struct bpf_offload_dev { + const struct bpf_prog_offload_ops *ops; + struct list_head netdevs; + void *priv; }; -typedef bool (*filter_func_t)(struct uprobe_consumer *, enum uprobe_filter_ctx, struct mm_struct *); +struct rhlist_head { + struct rhash_head rhead; + struct rhlist_head *next; +}; -typedef __u32 __le32; +struct bpf_offload_netdev { + struct rhash_head l; + struct net_device *netdev; + struct bpf_offload_dev *offdev; + struct list_head progs; + struct list_head maps; + struct list_head offdev_netdevs; +}; -typedef __u64 __le64; +struct ns_get_path_bpf_prog_args { + struct bpf_prog *prog; + struct bpf_prog_info *info; +}; + +struct ns_get_path_bpf_map_args { + struct bpf_offloaded_map *offmap; + struct bpf_map_info *info; +}; + +enum bpf_stack_build_id_status { + BPF_STACK_BUILD_ID_EMPTY = 0, + BPF_STACK_BUILD_ID_VALID = 1, + BPF_STACK_BUILD_ID_IP = 2, +}; + +struct bpf_stack_build_id { + __s32 status; + unsigned char build_id[20]; + union { + __u64 offset; + __u64 ip; + }; +}; enum { - BPF_REG_0 = 0, - BPF_REG_1 = 1, - BPF_REG_2 = 2, - BPF_REG_3 = 3, - BPF_REG_4 = 4, - BPF_REG_5 = 5, - BPF_REG_6 = 6, - BPF_REG_7 = 7, - BPF_REG_8 = 8, - BPF_REG_9 = 9, - BPF_REG_10 = 10, - __MAX_BPF_REG = 11, + BPF_F_SKIP_FIELD_MASK = 255, + BPF_F_USER_STACK = 256, + BPF_F_FAST_STACK_CMP = 512, + BPF_F_REUSE_STACKID = 1024, + BPF_F_USER_BUILD_ID = 2048, }; -enum xdp_action { - XDP_ABORTED = 0, - XDP_DROP = 1, - XDP_PASS = 2, - XDP_TX = 3, - XDP_REDIRECT = 4, +typedef __u32 Elf32_Addr; + +typedef __u16 Elf32_Half; + +typedef __u32 Elf32_Off; + +struct elf32_hdr { + unsigned char e_ident[16]; + Elf32_Half e_type; + Elf32_Half e_machine; + Elf32_Word e_version; + Elf32_Addr e_entry; + Elf32_Off e_phoff; + Elf32_Off e_shoff; + Elf32_Word e_flags; + Elf32_Half e_ehsize; + Elf32_Half e_phentsize; + Elf32_Half e_phnum; + Elf32_Half e_shentsize; + Elf32_Half e_shnum; + Elf32_Half e_shstrndx; }; -enum bpf_arg_type { - ARG_DONTCARE = 0, - ARG_CONST_MAP_PTR = 1, - ARG_PTR_TO_MAP_KEY = 2, - ARG_PTR_TO_MAP_VALUE = 3, - ARG_PTR_TO_UNINIT_MAP_VALUE = 4, - ARG_PTR_TO_MAP_VALUE_OR_NULL = 5, - ARG_PTR_TO_MEM = 6, - ARG_PTR_TO_MEM_OR_NULL = 7, - ARG_PTR_TO_UNINIT_MEM = 8, - ARG_CONST_SIZE = 9, - ARG_CONST_SIZE_OR_ZERO = 10, - ARG_PTR_TO_CTX = 11, - ARG_ANYTHING = 12, - ARG_PTR_TO_SPIN_LOCK = 13, - ARG_PTR_TO_SOCK_COMMON = 14, - ARG_PTR_TO_INT = 15, - ARG_PTR_TO_LONG = 16, - ARG_PTR_TO_SOCKET = 17, - ARG_PTR_TO_BTF_ID = 18, -}; +typedef struct elf32_hdr Elf32_Ehdr; -enum bpf_return_type { - RET_INTEGER = 0, - RET_VOID = 1, - RET_PTR_TO_MAP_VALUE = 2, - RET_PTR_TO_MAP_VALUE_OR_NULL = 3, - RET_PTR_TO_SOCKET_OR_NULL = 4, - RET_PTR_TO_TCP_SOCK_OR_NULL = 5, - RET_PTR_TO_SOCK_COMMON_OR_NULL = 6, +struct elf32_phdr { + Elf32_Word p_type; + Elf32_Off p_offset; + Elf32_Addr p_vaddr; + Elf32_Addr p_paddr; + Elf32_Word p_filesz; + Elf32_Word p_memsz; + Elf32_Word p_flags; + Elf32_Word p_align; }; -struct bpf_func_proto { - u64 (*func)(u64, u64, u64, u64, u64); - bool gpl_only; - bool pkt_access; - enum bpf_return_type ret_type; - union { - struct { - enum bpf_arg_type arg1_type; - enum bpf_arg_type arg2_type; - enum bpf_arg_type arg3_type; - enum bpf_arg_type arg4_type; - enum bpf_arg_type arg5_type; - }; - enum bpf_arg_type arg_type[5]; - }; - int *btf_id; +typedef struct elf32_phdr Elf32_Phdr; + +struct elf64_phdr { + Elf64_Word p_type; + Elf64_Word p_flags; + Elf64_Off p_offset; + Elf64_Addr p_vaddr; + Elf64_Addr p_paddr; + Elf64_Xword p_filesz; + Elf64_Xword p_memsz; + Elf64_Xword p_align; }; -struct bpf_array_aux { - enum bpf_prog_type type; - bool jited; - struct list_head poke_progs; - struct bpf_map *map; - struct mutex poke_mutex; - struct work_struct work; +typedef struct elf64_phdr Elf64_Phdr; + +typedef struct elf32_note Elf32_Nhdr; + +struct stack_map_bucket { + struct pcpu_freelist_node fnode; + u32 hash; + u32 nr; + u64 data[0]; }; -struct bpf_array { +struct bpf_stack_map { struct bpf_map map; - u32 elem_size; - u32 index_mask; - struct bpf_array_aux *aux; - union { - char value[0]; - void *ptrs[0]; - void *pptrs[0]; - }; - long: 64; + void *elems; + struct pcpu_freelist freelist; + u32 n_buckets; + struct stack_map_bucket *buckets[0]; long: 64; long: 64; long: 64; @@ -30993,163 +35913,451 @@ struct bpf_array { long: 64; }; -typedef long unsigned int (*bpf_ctx_copy_t)(void *, const void *, long unsigned int, long unsigned int); +struct stack_map_irq_work { + struct irq_work irq_work; + struct rw_semaphore *sem; +}; -enum bpf_text_poke_type { - BPF_MOD_CALL = 0, - BPF_MOD_JUMP = 1, +typedef u64 (*btf_bpf_get_stackid)(struct pt_regs *, struct bpf_map *, u64); + +typedef u64 (*btf_bpf_get_stack)(struct pt_regs *, void *, u32, u64); + +enum { + BPF_F_SYSCTL_BASE_NAME = 1, }; -enum xdp_mem_type { - MEM_TYPE_PAGE_SHARED = 0, - MEM_TYPE_PAGE_ORDER0 = 1, - MEM_TYPE_PAGE_POOL = 2, - MEM_TYPE_ZERO_COPY = 3, - MEM_TYPE_MAX = 4, +struct bpf_prog_list { + struct list_head node; + struct bpf_prog *prog; + struct bpf_cgroup_storage *storage[2]; }; -struct zero_copy_allocator { - void (*free)(struct zero_copy_allocator *, long unsigned int); +struct qdisc_skb_cb { + struct { + unsigned int pkt_len; + u16 slave_dev_queue_mapping; + u16 tc_classid; + }; + unsigned char data[20]; }; -struct bpf_prog_dummy { - struct bpf_prog prog; +struct bpf_skb_data_end { + struct qdisc_skb_cb qdisc_cb; + void *data_meta; + void *data_end; }; -typedef u64 (*btf_bpf_user_rnd_u32)(); +enum { + TCPF_ESTABLISHED = 2, + TCPF_SYN_SENT = 4, + TCPF_SYN_RECV = 8, + TCPF_FIN_WAIT1 = 16, + TCPF_FIN_WAIT2 = 32, + TCPF_TIME_WAIT = 64, + TCPF_CLOSE = 128, + TCPF_CLOSE_WAIT = 256, + TCPF_LAST_ACK = 512, + TCPF_LISTEN = 1024, + TCPF_CLOSING = 2048, + TCPF_NEW_SYN_RECV = 4096, +}; -struct page_pool; +typedef u64 (*btf_bpf_sysctl_get_name)(struct bpf_sysctl_kern *, char *, size_t, u64); -struct xdp_mem_allocator { - struct xdp_mem_info mem; - union { - void *allocator; - struct page_pool *page_pool; - struct zero_copy_allocator *zc_alloc; - }; - struct rhash_head node; - struct callback_head rcu; +typedef u64 (*btf_bpf_sysctl_get_current_value)(struct bpf_sysctl_kern *, char *, size_t); + +typedef u64 (*btf_bpf_sysctl_get_new_value)(struct bpf_sysctl_kern *, char *, size_t); + +typedef u64 (*btf_bpf_sysctl_set_new_value)(struct bpf_sysctl_kern *, const char *, size_t); + +enum sock_type { + SOCK_STREAM = 1, + SOCK_DGRAM = 2, + SOCK_RAW = 3, + SOCK_RDM = 4, + SOCK_SEQPACKET = 5, + SOCK_DCCP = 6, + SOCK_PACKET = 10, }; -struct trace_event_raw_xdp_exception { - struct trace_entry ent; - int prog_id; - u32 act; - int ifindex; - char __data[0]; +enum { + IPPROTO_IP = 0, + IPPROTO_ICMP = 1, + IPPROTO_IGMP = 2, + IPPROTO_IPIP = 4, + IPPROTO_TCP = 6, + IPPROTO_EGP = 8, + IPPROTO_PUP = 12, + IPPROTO_UDP = 17, + IPPROTO_IDP = 22, + IPPROTO_TP = 29, + IPPROTO_DCCP = 33, + IPPROTO_IPV6 = 41, + IPPROTO_RSVP = 46, + IPPROTO_GRE = 47, + IPPROTO_ESP = 50, + IPPROTO_AH = 51, + IPPROTO_MTP = 92, + IPPROTO_BEETPH = 94, + IPPROTO_ENCAP = 98, + IPPROTO_PIM = 103, + IPPROTO_COMP = 108, + IPPROTO_SCTP = 132, + IPPROTO_UDPLITE = 136, + IPPROTO_MPLS = 137, + IPPROTO_RAW = 255, + IPPROTO_MAX = 256, }; -struct trace_event_raw_xdp_bulk_tx { - struct trace_entry ent; - int ifindex; - u32 act; - int drops; - int sent; - int err; - char __data[0]; +enum sock_flags { + SOCK_DEAD = 0, + SOCK_DONE = 1, + SOCK_URGINLINE = 2, + SOCK_KEEPOPEN = 3, + SOCK_LINGER = 4, + SOCK_DESTROY = 5, + SOCK_BROADCAST = 6, + SOCK_TIMESTAMP = 7, + SOCK_ZAPPED = 8, + SOCK_USE_WRITE_QUEUE = 9, + SOCK_DBG = 10, + SOCK_RCVTSTAMP = 11, + SOCK_RCVTSTAMPNS = 12, + SOCK_LOCALROUTE = 13, + SOCK_QUEUE_SHRUNK = 14, + SOCK_MEMALLOC = 15, + SOCK_TIMESTAMPING_RX_SOFTWARE = 16, + SOCK_FASYNC = 17, + SOCK_RXQ_OVFL = 18, + SOCK_ZEROCOPY = 19, + SOCK_WIFI_STATUS = 20, + SOCK_NOFCS = 21, + SOCK_FILTER_LOCKED = 22, + SOCK_SELECT_ERR_QUEUE = 23, + SOCK_RCU_FREE = 24, + SOCK_TXTIME = 25, + SOCK_XDP = 26, + SOCK_TSTAMP_NEW = 27, }; -struct trace_event_raw_xdp_redirect_template { - struct trace_entry ent; - int prog_id; - u32 act; - int ifindex; - int err; - int to_ifindex; - u32 map_id; - int map_index; - char __data[0]; +struct reuseport_array { + struct bpf_map map; + struct sock *ptrs[0]; }; -struct trace_event_raw_xdp_cpumap_kthread { - struct trace_entry ent; - int map_id; - u32 act; - int cpu; - unsigned int drops; - unsigned int processed; - int sched; - char __data[0]; +struct super_block___2; + +struct module___2; + +struct file_system_type___3 { + const char *name; + int fs_flags; + int (*init_fs_context)(struct fs_context *); + const struct fs_parameter_description *parameters; + struct dentry___2 * (*mount)(struct file_system_type___3 *, int, const char *, void *); + void (*kill_sb)(struct super_block___2 *); + struct module___2 *owner; + struct file_system_type___3 *next; + struct hlist_head fs_supers; + struct lock_class_key s_lock_key; + struct lock_class_key s_umount_key; + struct lock_class_key s_vfs_rename_key; + struct lock_class_key s_writers_key[3]; + struct lock_class_key i_lock_key; + struct lock_class_key i_mutex_key; + struct lock_class_key i_mutex_dir_key; }; -struct trace_event_raw_xdp_cpumap_enqueue { - struct trace_entry ent; - int map_id; - u32 act; - int cpu; - unsigned int drops; - unsigned int processed; - int to_cpu; - char __data[0]; +struct file___2; + +struct kiocb___2; + +struct iov_iter___2; + +struct poll_table_struct___2; + +struct vm_area_struct___2; + +struct file_lock___2; + +struct page___2; + +struct pipe_inode_info___2; + +struct file_operations___2 { + struct module___2 *owner; + loff_t (*llseek)(struct file___2 *, loff_t, int); + ssize_t (*read)(struct file___2 *, char *, size_t, loff_t *); + ssize_t (*write)(struct file___2 *, const char *, size_t, loff_t *); + ssize_t (*read_iter)(struct kiocb___2 *, struct iov_iter___2 *); + ssize_t (*write_iter)(struct kiocb___2 *, struct iov_iter___2 *); + int (*iopoll)(struct kiocb___2 *, bool); + int (*iterate)(struct file___2 *, struct dir_context *); + int (*iterate_shared)(struct file___2 *, struct dir_context *); + __poll_t (*poll)(struct file___2 *, struct poll_table_struct___2 *); + long int (*unlocked_ioctl)(struct file___2 *, unsigned int, long unsigned int); + long int (*compat_ioctl)(struct file___2 *, unsigned int, long unsigned int); + int (*mmap)(struct file___2 *, struct vm_area_struct___2 *); + long unsigned int mmap_supported_flags; + int (*open)(struct inode___2 *, struct file___2 *); + int (*flush)(struct file___2 *, fl_owner_t); + int (*release)(struct inode___2 *, struct file___2 *); + int (*fsync)(struct file___2 *, loff_t, loff_t, int); + int (*fasync)(int, struct file___2 *, int); + int (*lock)(struct file___2 *, int, struct file_lock___2 *); + ssize_t (*sendpage)(struct file___2 *, struct page___2 *, int, size_t, loff_t *, int); + long unsigned int (*get_unmapped_area)(struct file___2 *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); + int (*check_flags)(int); + int (*flock)(struct file___2 *, int, struct file_lock___2 *); + ssize_t (*splice_write)(struct pipe_inode_info___2 *, struct file___2 *, loff_t *, size_t, unsigned int); + ssize_t (*splice_read)(struct file___2 *, loff_t *, struct pipe_inode_info___2 *, size_t, unsigned int); + int (*setlease)(struct file___2 *, long int, struct file_lock___2 **, void **); + long int (*fallocate)(struct file___2 *, int, loff_t, loff_t); + void (*show_fdinfo)(struct seq_file___2 *, struct file___2 *); + ssize_t (*copy_file_range)(struct file___2 *, loff_t, struct file___2 *, loff_t, size_t, unsigned int); + loff_t (*remap_file_range)(struct file___2 *, loff_t, struct file___2 *, loff_t, loff_t, unsigned int); + int (*fadvise)(struct file___2 *, loff_t, loff_t, int); }; -struct trace_event_raw_xdp_devmap_xmit { - struct trace_entry ent; - int map_id; - u32 act; - u32 map_index; - int drops; - int sent; - int from_ifindex; - int to_ifindex; - int err; - char __data[0]; +struct vmacache___2 { + u64 seqnum; + struct vm_area_struct___2 *vmas[4]; }; -struct trace_event_raw_mem_disconnect { - struct trace_entry ent; - const struct xdp_mem_allocator *xa; - u32 mem_id; - u32 mem_type; - const void *allocator; - char __data[0]; +struct page_frag___2 { + struct page___2 *page; + __u32 offset; + __u32 size; }; -struct trace_event_raw_mem_connect { - struct trace_entry ent; - const struct xdp_mem_allocator *xa; - u32 mem_id; - u32 mem_type; - const void *allocator; - const struct xdp_rxq_info *rxq; - int ifindex; - char __data[0]; +struct perf_event___2; + +struct thread_struct___2 { + struct desc_struct tls_array[3]; + long unsigned int sp; + short unsigned int es; + short unsigned int ds; + short unsigned int fsindex; + short unsigned int gsindex; + long unsigned int fsbase; + long unsigned int gsbase; + struct perf_event___2 *ptrace_bps[4]; + long unsigned int debugreg6; + long unsigned int ptrace_dr7; + long unsigned int cr2; + long unsigned int trap_nr; + long unsigned int error_code; + struct io_bitmap *io_bitmap; + long unsigned int iopl_emul; + mm_segment_t addr_limit; + unsigned int sig_on_uaccess_err: 1; + unsigned int uaccess_err: 1; + long: 62; + long: 64; + long: 64; + long: 64; + long: 64; + struct fpu fpu; }; -struct trace_event_raw_mem_return_failed { - struct trace_entry ent; - const struct page *page; - u32 mem_id; - u32 mem_type; - char __data[0]; +struct mm_struct___2; + +struct pid___2; + +struct cred___2; + +struct nsproxy___2; + +struct signal_struct___2; + +struct css_set___2; + +struct perf_event_context___2; + +struct vm_struct___2; + +struct task_struct___2 { + struct thread_info thread_info; + volatile long int state; + void *stack; + refcount_t usage; + unsigned int flags; + unsigned int ptrace; + struct llist_node wake_entry; + int on_cpu; + unsigned int cpu; + unsigned int wakee_flips; + long unsigned int wakee_flip_decay_ts; + struct task_struct___2 *last_wakee; + int recent_used_cpu; + int wake_cpu; + int on_rq; + int prio; + int static_prio; + int normal_prio; + unsigned int rt_priority; + const struct sched_class *sched_class; + struct sched_entity se; + struct sched_rt_entity rt; + struct task_group *sched_task_group; + struct sched_dl_entity dl; + unsigned int btrace_seq; + unsigned int policy; + int nr_cpus_allowed; + const cpumask_t *cpus_ptr; + cpumask_t cpus_mask; + struct sched_info sched_info; + struct list_head tasks; + struct plist_node pushable_tasks; + struct rb_node pushable_dl_tasks; + struct mm_struct___2 *mm; + struct mm_struct___2 *active_mm; + struct vmacache___2 vmacache; + struct task_rss_stat rss_stat; + int exit_state; + int exit_code; + int exit_signal; + int pdeath_signal; + long unsigned int jobctl; + unsigned int personality; + unsigned int sched_reset_on_fork: 1; + unsigned int sched_contributes_to_load: 1; + unsigned int sched_migrated: 1; + unsigned int sched_remote_wakeup: 1; + int: 28; + unsigned int in_execve: 1; + unsigned int in_iowait: 1; + unsigned int restore_sigmask: 1; + unsigned int no_cgroup_migration: 1; + unsigned int frozen: 1; + long unsigned int atomic_flags; + struct restart_block restart_block; + pid_t pid; + pid_t tgid; + long unsigned int stack_canary; + struct task_struct___2 *real_parent; + struct task_struct___2 *parent; + struct list_head children; + struct list_head sibling; + struct task_struct___2 *group_leader; + struct list_head ptraced; + struct list_head ptrace_entry; + struct pid___2 *thread_pid; + struct hlist_node pid_links[4]; + struct list_head thread_group; + struct list_head thread_node; + struct completion *vfork_done; + int *set_child_tid; + int *clear_child_tid; + u64 utime; + u64 stime; + u64 gtime; + struct prev_cputime prev_cputime; + long unsigned int nvcsw; + long unsigned int nivcsw; + u64 start_time; + u64 start_boottime; + long unsigned int min_flt; + long unsigned int maj_flt; + struct posix_cputimers posix_cputimers; + const struct cred___2 *ptracer_cred; + const struct cred___2 *real_cred; + const struct cred___2 *cred; + struct key *cached_requested_key; + char comm[16]; + struct nameidata *nameidata; + struct sysv_sem sysvsem; + struct sysv_shm sysvshm; + struct fs_struct *fs; + struct files_struct *files; + struct nsproxy___2 *nsproxy; + struct signal_struct___2 *signal; + struct sighand_struct *sighand; + sigset_t blocked; + sigset_t real_blocked; + sigset_t saved_sigmask; + struct sigpending pending; + long unsigned int sas_ss_sp; + size_t sas_ss_size; + unsigned int sas_ss_flags; + struct callback_head *task_works; + struct audit_context *audit_context; + kuid_t loginuid; + unsigned int sessionid; + struct seccomp seccomp; + u32 parent_exec_id; + u32 self_exec_id; + spinlock_t alloc_lock; + raw_spinlock_t pi_lock; + struct wake_q_node wake_q; + struct rb_root_cached pi_waiters; + struct task_struct___2 *pi_top_task; + struct rt_mutex_waiter *pi_blocked_on; + void *journal_info; + struct bio_list *bio_list; + struct blk_plug *plug; + struct reclaim_state *reclaim_state; + struct backing_dev_info *backing_dev_info; + struct io_context *io_context; + struct capture_control *capture_control; + long unsigned int ptrace_message; + kernel_siginfo_t *last_siginfo; + struct task_io_accounting ioac; + u64 acct_rss_mem1; + u64 acct_vm_mem1; + u64 acct_timexpd; + nodemask_t mems_allowed; + seqcount_t mems_allowed_seq; + int cpuset_mem_spread_rotor; + int cpuset_slab_spread_rotor; + struct css_set___2 *cgroups; + struct list_head cg_list; + struct robust_list_head *robust_list; + struct compat_robust_list_head *compat_robust_list; + struct list_head pi_state_list; + struct futex_pi_state *pi_state_cache; + struct mutex futex_exit_mutex; + unsigned int futex_state; + struct perf_event_context___2 *perf_event_ctxp[2]; + struct mutex perf_event_mutex; + struct list_head perf_event_list; + struct mempolicy *mempolicy; + short int il_prev; + short int pref_node_fork; + struct rseq *rseq; + u32 rseq_sig; + long unsigned int rseq_event_mask; + struct tlbflush_unmap_batch tlb_ubc; + union { + refcount_t rcu_users; + struct callback_head rcu; + }; + struct pipe_inode_info___2 *splice_pipe; + struct page_frag___2 task_frag; + struct task_delay_info *delays; + int nr_dirtied; + int nr_dirtied_pause; + long unsigned int dirty_paused_when; + u64 timer_slack_ns; + u64 default_timer_slack_ns; + long unsigned int trace; + long unsigned int trace_recursion; + struct uprobe_task *utask; + int pagefault_disabled; + struct task_struct___2 *oom_reaper_list; + struct vm_struct___2 *stack_vm_area; + refcount_t stack_refcount; + void *security; + long: 64; + long: 64; + long: 64; + struct thread_struct___2 thread; }; -struct trace_event_data_offsets_xdp_exception {}; - -struct trace_event_data_offsets_xdp_bulk_tx {}; - -struct trace_event_data_offsets_xdp_redirect_template {}; - -struct trace_event_data_offsets_xdp_cpumap_kthread {}; - -struct trace_event_data_offsets_xdp_cpumap_enqueue {}; - -struct trace_event_data_offsets_xdp_devmap_xmit {}; - -struct trace_event_data_offsets_mem_disconnect {}; - -struct trace_event_data_offsets_mem_connect {}; - -struct trace_event_data_offsets_mem_return_failed {}; - -struct page___2; - typedef struct page___2 *pgtable_t___2; struct address_space___2; -struct mm_struct___2; - struct dev_pagemap___2; struct page___2 { @@ -31222,38 +36430,6 @@ struct page___2 { long: 64; }; -struct perf_event___2; - -struct thread_struct___2 { - struct desc_struct tls_array[3]; - long unsigned int sp; - short unsigned int es; - short unsigned int ds; - short unsigned int fsindex; - short unsigned int gsindex; - long unsigned int fsbase; - long unsigned int gsbase; - struct perf_event___2 *ptrace_bps[4]; - long unsigned int debugreg6; - long unsigned int ptrace_dr7; - long unsigned int cr2; - long unsigned int trap_nr; - long unsigned int error_code; - struct io_bitmap *io_bitmap; - long unsigned int iopl_emul; - mm_segment_t addr_limit; - unsigned int sig_on_uaccess_err: 1; - unsigned int uaccess_err: 1; - long: 62; - long: 64; - long: 64; - long: 64; - long: 64; - struct fpu fpu; -}; - -struct task_struct___2; - struct hw_perf_event___2 { union { struct { @@ -31308,14 +36484,14 @@ typedef void (*perf_overflow_handler_t___2)(struct perf_event___2 *, struct perf struct pmu___2; -struct perf_event_context___2; - struct ring_buffer___2; struct fasync_struct___2; struct pid_namespace___2; +struct bpf_prog___2; + struct trace_event_call___2; struct perf_event___2 { @@ -31381,6 +36557,8 @@ struct perf_event___2 { u64 (*clock)(); perf_overflow_handler_t___2 overflow_handler; void *overflow_handler_context; + perf_overflow_handler_t___2 orig_overflow_handler; + struct bpf_prog___2 *prog; struct trace_event_call___2 *tp_event; struct event_filter *filter; void *security; @@ -31437,10 +36615,6 @@ struct address_space___2 { struct inode_operations___2; -struct file_operations___2; - -struct pipe_inode_info___2; - struct block_device___2; struct inode___2 { @@ -31573,8 +36747,6 @@ struct sb_writers___2 { struct percpu_rw_semaphore___2 rw_sem[3]; }; -struct file_system_type___2; - struct super_operations___2; struct dquot_operations___2; @@ -31589,7 +36761,7 @@ struct super_block___2 { unsigned char s_blocksize_bits; long unsigned int s_blocksize; loff_t s_maxbytes; - struct file_system_type___2 *s_type; + struct file_system_type___3 *s_type; const struct super_operations___2 *s_op; const struct dquot_operations___2 *dq_op; const struct quotactl_ops___2 *s_qcop; @@ -31665,382 +36837,6 @@ struct path___2 { struct dentry___2 *dentry; }; -struct vm_area_struct___2; - -struct vmacache___2 { - u64 seqnum; - struct vm_area_struct___2 *vmas[4]; -}; - -struct vm_operations_struct___2; - -struct file___2; - -struct vm_area_struct___2 { - long unsigned int vm_start; - long unsigned int vm_end; - struct vm_area_struct___2 *vm_next; - struct vm_area_struct___2 *vm_prev; - struct rb_node vm_rb; - long unsigned int rb_subtree_gap; - struct mm_struct___2 *vm_mm; - pgprot_t vm_page_prot; - long unsigned int vm_flags; - struct { - struct rb_node rb; - long unsigned int rb_subtree_last; - } shared; - struct list_head anon_vma_chain; - struct anon_vma *anon_vma; - const struct vm_operations_struct___2 *vm_ops; - long unsigned int vm_pgoff; - struct file___2 *vm_file; - void *vm_private_data; - atomic_long_t swap_readahead_info; - struct mempolicy *vm_policy; - struct vm_userfaultfd_ctx vm_userfaultfd_ctx; -}; - -struct page_frag___2 { - struct page___2 *page; - __u32 offset; - __u32 size; -}; - -struct core_state___2; - -struct mm_struct___2 { - struct { - struct vm_area_struct___2 *mmap; - struct rb_root mm_rb; - u64 vmacache_seqnum; - long unsigned int (*get_unmapped_area)(struct file___2 *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); - long unsigned int mmap_base; - long unsigned int mmap_legacy_base; - long unsigned int mmap_compat_base; - long unsigned int mmap_compat_legacy_base; - long unsigned int task_size; - long unsigned int highest_vm_end; - pgd_t *pgd; - atomic_t membarrier_state; - atomic_t mm_users; - atomic_t mm_count; - atomic_long_t pgtables_bytes; - int map_count; - spinlock_t page_table_lock; - struct rw_semaphore mmap_sem; - struct list_head mmlist; - long unsigned int hiwater_rss; - long unsigned int hiwater_vm; - long unsigned int total_vm; - long unsigned int locked_vm; - atomic64_t pinned_vm; - long unsigned int data_vm; - long unsigned int exec_vm; - long unsigned int stack_vm; - long unsigned int def_flags; - spinlock_t arg_lock; - long unsigned int start_code; - long unsigned int end_code; - long unsigned int start_data; - long unsigned int end_data; - long unsigned int start_brk; - long unsigned int brk; - long unsigned int start_stack; - long unsigned int arg_start; - long unsigned int arg_end; - long unsigned int env_start; - long unsigned int env_end; - long unsigned int saved_auxv[46]; - struct mm_rss_stat rss_stat; - struct linux_binfmt *binfmt; - mm_context_t context; - long unsigned int flags; - struct core_state___2 *core_state; - spinlock_t ioctx_lock; - struct kioctx_table *ioctx_table; - struct user_namespace___2 *user_ns; - struct file___2 *exe_file; - struct mmu_notifier_mm *mmu_notifier_mm; - atomic_t tlb_flush_pending; - bool tlb_flush_batched; - struct uprobes_state uprobes_state; - atomic_long_t hugetlb_usage; - struct work_struct async_put_work; - }; - long unsigned int cpu_bitmap[0]; -}; - -struct pid___2; - -struct cred___2; - -struct nsproxy___2; - -struct signal_struct___2; - -struct css_set___2; - -struct vm_struct___2; - -struct task_struct___2 { - struct thread_info thread_info; - volatile long int state; - void *stack; - refcount_t usage; - unsigned int flags; - unsigned int ptrace; - struct llist_node wake_entry; - int on_cpu; - unsigned int cpu; - unsigned int wakee_flips; - long unsigned int wakee_flip_decay_ts; - struct task_struct___2 *last_wakee; - int recent_used_cpu; - int wake_cpu; - int on_rq; - int prio; - int static_prio; - int normal_prio; - unsigned int rt_priority; - const struct sched_class *sched_class; - struct sched_entity se; - struct sched_rt_entity rt; - struct task_group *sched_task_group; - struct sched_dl_entity dl; - unsigned int btrace_seq; - unsigned int policy; - int nr_cpus_allowed; - const cpumask_t *cpus_ptr; - cpumask_t cpus_mask; - struct sched_info sched_info; - struct list_head tasks; - struct plist_node pushable_tasks; - struct rb_node pushable_dl_tasks; - struct mm_struct___2 *mm; - struct mm_struct___2 *active_mm; - struct vmacache___2 vmacache; - struct task_rss_stat rss_stat; - int exit_state; - int exit_code; - int exit_signal; - int pdeath_signal; - long unsigned int jobctl; - unsigned int personality; - unsigned int sched_reset_on_fork: 1; - unsigned int sched_contributes_to_load: 1; - unsigned int sched_migrated: 1; - unsigned int sched_remote_wakeup: 1; - int: 28; - unsigned int in_execve: 1; - unsigned int in_iowait: 1; - unsigned int restore_sigmask: 1; - unsigned int no_cgroup_migration: 1; - unsigned int frozen: 1; - long unsigned int atomic_flags; - struct restart_block restart_block; - pid_t pid; - pid_t tgid; - long unsigned int stack_canary; - struct task_struct___2 *real_parent; - struct task_struct___2 *parent; - struct list_head children; - struct list_head sibling; - struct task_struct___2 *group_leader; - struct list_head ptraced; - struct list_head ptrace_entry; - struct pid___2 *thread_pid; - struct hlist_node pid_links[4]; - struct list_head thread_group; - struct list_head thread_node; - struct completion *vfork_done; - int *set_child_tid; - int *clear_child_tid; - u64 utime; - u64 stime; - u64 gtime; - struct prev_cputime prev_cputime; - long unsigned int nvcsw; - long unsigned int nivcsw; - u64 start_time; - u64 start_boottime; - long unsigned int min_flt; - long unsigned int maj_flt; - struct posix_cputimers posix_cputimers; - const struct cred___2 *ptracer_cred; - const struct cred___2 *real_cred; - const struct cred___2 *cred; - struct key *cached_requested_key; - char comm[16]; - struct nameidata *nameidata; - struct sysv_sem sysvsem; - struct sysv_shm sysvshm; - struct fs_struct *fs; - struct files_struct *files; - struct nsproxy___2 *nsproxy; - struct signal_struct___2 *signal; - struct sighand_struct *sighand; - sigset_t blocked; - sigset_t real_blocked; - sigset_t saved_sigmask; - struct sigpending pending; - long unsigned int sas_ss_sp; - size_t sas_ss_size; - unsigned int sas_ss_flags; - struct callback_head *task_works; - struct audit_context *audit_context; - kuid_t loginuid; - unsigned int sessionid; - struct seccomp seccomp; - u32 parent_exec_id; - u32 self_exec_id; - spinlock_t alloc_lock; - raw_spinlock_t pi_lock; - struct wake_q_node wake_q; - struct rb_root_cached pi_waiters; - struct task_struct___2 *pi_top_task; - struct rt_mutex_waiter *pi_blocked_on; - void *journal_info; - struct bio_list *bio_list; - struct blk_plug *plug; - struct reclaim_state *reclaim_state; - struct backing_dev_info *backing_dev_info; - struct io_context *io_context; - struct capture_control *capture_control; - long unsigned int ptrace_message; - kernel_siginfo_t *last_siginfo; - struct task_io_accounting ioac; - u64 acct_rss_mem1; - u64 acct_vm_mem1; - u64 acct_timexpd; - nodemask_t mems_allowed; - seqcount_t mems_allowed_seq; - int cpuset_mem_spread_rotor; - int cpuset_slab_spread_rotor; - struct css_set___2 *cgroups; - struct list_head cg_list; - struct robust_list_head *robust_list; - struct compat_robust_list_head *compat_robust_list; - struct list_head pi_state_list; - struct futex_pi_state *pi_state_cache; - struct mutex futex_exit_mutex; - unsigned int futex_state; - struct perf_event_context___2 *perf_event_ctxp[2]; - struct mutex perf_event_mutex; - struct list_head perf_event_list; - struct mempolicy *mempolicy; - short int il_prev; - short int pref_node_fork; - struct rseq *rseq; - u32 rseq_sig; - long unsigned int rseq_event_mask; - struct tlbflush_unmap_batch tlb_ubc; - union { - refcount_t rcu_users; - struct callback_head rcu; - }; - struct pipe_inode_info___2 *splice_pipe; - struct page_frag___2 task_frag; - struct task_delay_info *delays; - int nr_dirtied; - int nr_dirtied_pause; - long unsigned int dirty_paused_when; - u64 timer_slack_ns; - u64 default_timer_slack_ns; - long unsigned int trace; - long unsigned int trace_recursion; - struct uprobe_task *utask; - int pagefault_disabled; - struct task_struct___2 *oom_reaper_list; - struct vm_struct___2 *stack_vm_area; - refcount_t stack_refcount; - void *security; - long: 64; - long: 64; - long: 64; - struct thread_struct___2 thread; -}; - -struct dev_pagemap_ops___2; - -struct dev_pagemap___2 { - struct vmem_altmap altmap; - struct resource res; - struct percpu_ref *ref; - struct percpu_ref internal_ref; - struct completion done; - enum memory_type type; - unsigned int flags; - const struct dev_pagemap_ops___2 *ops; -}; - -struct fown_struct___2 { - rwlock_t lock; - struct pid___2 *pid; - enum pid_type pid_type; - kuid_t uid; - kuid_t euid; - int signum; -}; - -struct file___2 { - union { - struct llist_node fu_llist; - struct callback_head fu_rcuhead; - } f_u; - struct path___2 f_path; - struct inode___2 *f_inode; - const struct file_operations___2 *f_op; - spinlock_t f_lock; - enum rw_hint f_write_hint; - atomic_long_t f_count; - unsigned int f_flags; - fmode_t f_mode; - struct mutex f_pos_lock; - loff_t f_pos; - struct fown_struct___2 f_owner; - const struct cred___2 *f_cred; - struct file_ra_state f_ra; - u64 f_version; - void *f_security; - void *private_data; - struct list_head f_ep_links; - struct list_head f_tfile_llink; - struct address_space___2 *f_mapping; - errseq_t f_wb_err; -}; - -struct vm_fault___2; - -struct vm_operations_struct___2 { - void (*open)(struct vm_area_struct___2 *); - void (*close)(struct vm_area_struct___2 *); - int (*split)(struct vm_area_struct___2 *, long unsigned int); - int (*mremap)(struct vm_area_struct___2 *); - vm_fault_t (*fault)(struct vm_fault___2 *); - vm_fault_t (*huge_fault)(struct vm_fault___2 *, enum page_entry_size); - void (*map_pages)(struct vm_fault___2 *, long unsigned int, long unsigned int); - long unsigned int (*pagesize)(struct vm_area_struct___2 *); - vm_fault_t (*page_mkwrite)(struct vm_fault___2 *); - vm_fault_t (*pfn_mkwrite)(struct vm_fault___2 *); - int (*access)(struct vm_area_struct___2 *, long unsigned int, void *, int, int); - const char * (*name)(struct vm_area_struct___2 *); - int (*set_policy)(struct vm_area_struct___2 *, struct mempolicy *); - struct mempolicy * (*get_policy)(struct vm_area_struct___2 *, long unsigned int); - struct page___2 * (*find_special_page)(struct vm_area_struct___2 *, long unsigned int); -}; - -struct core_thread___2 { - struct task_struct___2 *task; - struct core_thread___2 *next; -}; - -struct core_state___2 { - atomic_t nr_threads; - struct core_thread___2 dumper; - struct completion startup; -}; - struct proc_ns_operations___2; struct ns_common___2 { @@ -32072,6 +36868,177 @@ struct user_namespace___2 { int ucount_max[9]; }; +struct vm_operations_struct___2; + +struct vm_area_struct___2 { + long unsigned int vm_start; + long unsigned int vm_end; + struct vm_area_struct___2 *vm_next; + struct vm_area_struct___2 *vm_prev; + struct rb_node vm_rb; + long unsigned int rb_subtree_gap; + struct mm_struct___2 *vm_mm; + pgprot_t vm_page_prot; + long unsigned int vm_flags; + struct { + struct rb_node rb; + long unsigned int rb_subtree_last; + } shared; + struct list_head anon_vma_chain; + struct anon_vma *anon_vma; + const struct vm_operations_struct___2 *vm_ops; + long unsigned int vm_pgoff; + struct file___2 *vm_file; + void *vm_private_data; + atomic_long_t swap_readahead_info; + struct mempolicy *vm_policy; + struct vm_userfaultfd_ctx vm_userfaultfd_ctx; +}; + +struct core_state___2; + +struct mm_struct___2 { + struct { + struct vm_area_struct___2 *mmap; + struct rb_root mm_rb; + u64 vmacache_seqnum; + long unsigned int (*get_unmapped_area)(struct file___2 *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); + long unsigned int mmap_base; + long unsigned int mmap_legacy_base; + long unsigned int mmap_compat_base; + long unsigned int mmap_compat_legacy_base; + long unsigned int task_size; + long unsigned int highest_vm_end; + pgd_t *pgd; + atomic_t membarrier_state; + atomic_t mm_users; + atomic_t mm_count; + atomic_long_t pgtables_bytes; + int map_count; + spinlock_t page_table_lock; + struct rw_semaphore mmap_sem; + struct list_head mmlist; + long unsigned int hiwater_rss; + long unsigned int hiwater_vm; + long unsigned int total_vm; + long unsigned int locked_vm; + atomic64_t pinned_vm; + long unsigned int data_vm; + long unsigned int exec_vm; + long unsigned int stack_vm; + long unsigned int def_flags; + spinlock_t arg_lock; + long unsigned int start_code; + long unsigned int end_code; + long unsigned int start_data; + long unsigned int end_data; + long unsigned int start_brk; + long unsigned int brk; + long unsigned int start_stack; + long unsigned int arg_start; + long unsigned int arg_end; + long unsigned int env_start; + long unsigned int env_end; + long unsigned int saved_auxv[46]; + struct mm_rss_stat rss_stat; + struct linux_binfmt *binfmt; + mm_context_t context; + long unsigned int flags; + struct core_state___2 *core_state; + spinlock_t ioctx_lock; + struct kioctx_table *ioctx_table; + struct user_namespace___2 *user_ns; + struct file___2 *exe_file; + struct mmu_notifier_mm *mmu_notifier_mm; + atomic_t tlb_flush_pending; + bool tlb_flush_batched; + struct uprobes_state uprobes_state; + atomic_long_t hugetlb_usage; + struct work_struct async_put_work; + }; + long unsigned int cpu_bitmap[0]; +}; + +struct dev_pagemap_ops___2; + +struct dev_pagemap___2 { + struct vmem_altmap altmap; + struct resource res; + struct percpu_ref *ref; + struct percpu_ref internal_ref; + struct completion done; + enum memory_type type; + unsigned int flags; + const struct dev_pagemap_ops___2 *ops; +}; + +struct fown_struct___2 { + rwlock_t lock; + struct pid___2 *pid; + enum pid_type pid_type; + kuid_t uid; + kuid_t euid; + int signum; +}; + +struct file___2 { + union { + struct llist_node fu_llist; + struct callback_head fu_rcuhead; + } f_u; + struct path___2 f_path; + struct inode___2 *f_inode; + const struct file_operations___2 *f_op; + spinlock_t f_lock; + enum rw_hint f_write_hint; + atomic_long_t f_count; + unsigned int f_flags; + fmode_t f_mode; + struct mutex f_pos_lock; + loff_t f_pos; + struct fown_struct___2 f_owner; + const struct cred___2 *f_cred; + struct file_ra_state f_ra; + u64 f_version; + void *f_security; + void *private_data; + struct list_head f_ep_links; + struct list_head f_tfile_llink; + struct address_space___2 *f_mapping; + errseq_t f_wb_err; +}; + +struct vm_fault___2; + +struct vm_operations_struct___2 { + void (*open)(struct vm_area_struct___2 *); + void (*close)(struct vm_area_struct___2 *); + int (*split)(struct vm_area_struct___2 *, long unsigned int); + int (*mremap)(struct vm_area_struct___2 *); + vm_fault_t (*fault)(struct vm_fault___2 *); + vm_fault_t (*huge_fault)(struct vm_fault___2 *, enum page_entry_size); + void (*map_pages)(struct vm_fault___2 *, long unsigned int, long unsigned int); + long unsigned int (*pagesize)(struct vm_area_struct___2 *); + vm_fault_t (*page_mkwrite)(struct vm_fault___2 *); + vm_fault_t (*pfn_mkwrite)(struct vm_fault___2 *); + int (*access)(struct vm_area_struct___2 *, long unsigned int, void *, int, int); + const char * (*name)(struct vm_area_struct___2 *); + int (*set_policy)(struct vm_area_struct___2 *, struct mempolicy *); + struct mempolicy * (*get_policy)(struct vm_area_struct___2 *, long unsigned int); + struct page___2 * (*find_special_page)(struct vm_area_struct___2 *, long unsigned int); +}; + +struct core_thread___2 { + struct task_struct___2 *task; + struct core_thread___2 *next; +}; + +struct core_state___2 { + atomic_t nr_threads; + struct core_thread___2 dumper; + struct completion startup; +}; + struct vm_fault___2 { struct vm_area_struct___2 *vma; unsigned int flags; @@ -32631,6 +37598,11 @@ struct pipe_inode_info___2 { struct user_struct *user; }; +union thread_union___2 { + struct task_struct___2 task; + long unsigned int stack[2048]; +}; + struct kiocb___2 { struct file___2 *ki_filp; loff_t ki_pos; @@ -32669,8 +37641,6 @@ struct dquot___2 { struct mem_dqblk dq_dqb; }; -struct module___2; - struct quota_format_type___2 { int qf_fmt_id; const struct quota_format_ops___2 *qf_ops; @@ -32791,6 +37761,8 @@ struct module___2 { tracepoint_ptr_t *tracepoints_ptrs; unsigned int num_srcu_structs; struct srcu_struct **srcu_struct_ptrs; + unsigned int num_bpf_raw_events; + struct bpf_raw_event_map *bpf_raw_events; struct jump_entry *jump_entries; unsigned int num_jump_entries; unsigned int num_trace_bprintk_fmt; @@ -32805,10 +37777,15 @@ struct module___2 { atomic_t refcnt; struct error_injection_entry *ei_funcs; unsigned int num_ei_funcs; + long: 32; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct iov_iter___2; - struct address_space_operations___2 { int (*writepage)(struct page___2 *, struct writeback_control *); int (*readpage)(struct file___2 *, struct page___2 *); @@ -32880,47 +37857,6 @@ struct block_device___2 { struct mutex bd_fsfreeze_mutex; }; -struct poll_table_struct___2; - -struct file_lock___2; - -struct seq_file___2; - -struct file_operations___2 { - struct module___2 *owner; - loff_t (*llseek)(struct file___2 *, loff_t, int); - ssize_t (*read)(struct file___2 *, char *, size_t, loff_t *); - ssize_t (*write)(struct file___2 *, const char *, size_t, loff_t *); - ssize_t (*read_iter)(struct kiocb___2 *, struct iov_iter___2 *); - ssize_t (*write_iter)(struct kiocb___2 *, struct iov_iter___2 *); - int (*iopoll)(struct kiocb___2 *, bool); - int (*iterate)(struct file___2 *, struct dir_context *); - int (*iterate_shared)(struct file___2 *, struct dir_context *); - __poll_t (*poll)(struct file___2 *, struct poll_table_struct___2 *); - long int (*unlocked_ioctl)(struct file___2 *, unsigned int, long unsigned int); - long int (*compat_ioctl)(struct file___2 *, unsigned int, long unsigned int); - int (*mmap)(struct file___2 *, struct vm_area_struct___2 *); - long unsigned int mmap_supported_flags; - int (*open)(struct inode___2 *, struct file___2 *); - int (*flush)(struct file___2 *, fl_owner_t); - int (*release)(struct inode___2 *, struct file___2 *); - int (*fsync)(struct file___2 *, loff_t, loff_t, int); - int (*fasync)(int, struct file___2 *, int); - int (*lock)(struct file___2 *, int, struct file_lock___2 *); - ssize_t (*sendpage)(struct file___2 *, struct page___2 *, int, size_t, loff_t *, int); - long unsigned int (*get_unmapped_area)(struct file___2 *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); - int (*check_flags)(int); - int (*flock)(struct file___2 *, int, struct file_lock___2 *); - ssize_t (*splice_write)(struct pipe_inode_info___2 *, struct file___2 *, loff_t *, size_t, unsigned int); - ssize_t (*splice_read)(struct file___2 *, loff_t *, struct pipe_inode_info___2 *, size_t, unsigned int); - int (*setlease)(struct file___2 *, long int, struct file_lock___2 **, void **); - long int (*fallocate)(struct file___2 *, int, loff_t, loff_t); - void (*show_fdinfo)(struct seq_file___2 *, struct file___2 *); - ssize_t (*copy_file_range)(struct file___2 *, loff_t, struct file___2 *, loff_t, size_t, unsigned int); - loff_t (*remap_file_range)(struct file___2 *, loff_t, struct file___2 *, loff_t, loff_t, unsigned int); - int (*fadvise)(struct file___2 *, loff_t, loff_t, int); -}; - struct inode_operations___2 { struct dentry___2 * (*lookup)(struct inode___2 *, struct dentry___2 *, unsigned int); const char * (*get_link)(struct dentry___2 *, struct inode___2 *, struct delayed_call *); @@ -33005,25 +37941,6 @@ struct fasync_struct___2 { struct callback_head fa_rcu; }; -struct file_system_type___2 { - const char *name; - int fs_flags; - int (*init_fs_context)(struct fs_context *); - const struct fs_parameter_description *parameters; - struct dentry___2 * (*mount)(struct file_system_type___2 *, int, const char *, void *); - void (*kill_sb)(struct super_block___2 *); - struct module___2 *owner; - struct file_system_type___2 *next; - struct hlist_head fs_supers; - struct lock_class_key s_lock_key; - struct lock_class_key s_umount_key; - struct lock_class_key s_vfs_rename_key; - struct lock_class_key s_writers_key[3]; - struct lock_class_key i_lock_key; - struct lock_class_key i_mutex_key; - struct lock_class_key i_mutex_dir_key; -}; - struct super_operations___2 { struct inode___2 * (*alloc_inode)(struct super_block___2 *); void (*destroy_inode)(struct inode___2 *); @@ -33060,8 +37977,6 @@ struct poll_table_struct___2 { __poll_t _key; }; -struct seq_operations___2; - struct seq_file___2 { char *buf; size_t size; @@ -33072,7 +37987,7 @@ struct seq_file___2 { loff_t read_pos; u64 version; struct mutex lock; - const struct seq_operations___2 *op; + const struct seq_operations *op; int poll_event; const struct file___2 *file; void *private; @@ -33085,6 +38000,12 @@ struct dev_pagemap_ops___2 { vm_fault_t (*migrate_to_ram)(struct vm_fault___2 *); }; +struct kobj_attribute___3 { + struct attribute attr; + ssize_t (*show)(struct kobject___2 *, struct kobj_attribute___3 *, char *); + ssize_t (*store)(struct kobject___2 *, struct kobj_attribute___3 *, const char *, size_t); +}; + typedef void compound_page_dtor___2(struct page___2 *); struct kernfs_root___2; @@ -33406,6 +38327,11 @@ struct device_node___2 { void *data; }; +struct node___3 { + struct device___2 dev; + struct list_head access_list; +}; + struct fd___2 { struct file___2 *file; unsigned int flags; @@ -33602,6 +38528,12 @@ struct netns_ipv6___2 { spinlock_t fib6_gc_lock; unsigned int ip6_rt_gc_expire; long unsigned int ip6_rt_last_gc; + unsigned int fib6_rules_require_fldissect; + bool fib6_has_custom_rules; + struct rt6_info *ip6_prohibit_entry; + struct rt6_info *ip6_blk_hole_entry; + struct fib6_table *fib6_local_tbl; + struct fib_rules_ops *fib6_rules_ops; struct sock **icmp_sk; struct sock *ndisc_sk; struct sock *tcp_sk; @@ -33619,6 +38551,9 @@ struct netns_ipv6___2 { u32 seq; } ip6addrlbl_table; long: 64; + long: 64; + long: 64; + long: 64; }; struct netns_nf_frag___2 { @@ -33664,8 +38599,6 @@ struct netns_xfrm___2 { long: 64; }; -struct bpf_prog___2; - struct net___2 { refcount_t passive; refcount_t count; @@ -33717,18 +38650,11 @@ struct net___2 { long: 64; long: 64; long: 64; - long: 64; - long: 64; - long: 64; struct netns_xfrm___2 xfrm; + struct netns_xdp xdp; struct sock *diag_nlsk; long: 64; long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; }; struct cgroup_namespace___2 { @@ -33758,13 +38684,6 @@ struct ucounts___2 { atomic_t ucount[9]; }; -struct seq_operations___2 { - void * (*start)(struct seq_file___2 *, loff_t *); - void (*stop)(struct seq_file___2 *, void *); - void * (*next)(struct seq_file___2 *, void *, loff_t *); - int (*show)(struct seq_file___2 *, void *); -}; - enum perf_event_read_format { PERF_FORMAT_TOTAL_TIME_ENABLED = 1, PERF_FORMAT_TOTAL_TIME_RUNNING = 2, @@ -33821,11 +38740,50 @@ enum perf_record_ksymbol_type { PERF_RECORD_KSYMBOL_TYPE_MAX = 2, }; -enum perf_bpf_event_type { - PERF_BPF_EVENT_UNKNOWN = 0, - PERF_BPF_EVENT_PROG_LOAD = 1, - PERF_BPF_EVENT_PROG_UNLOAD = 2, - PERF_BPF_EVENT_MAX = 3, +struct perf_cpu_context___2; + +struct perf_output_handle___2; + +struct pmu___2 { + struct list_head entry; + struct module___2 *module; + struct device___2 *dev; + const struct attribute_group___2 **attr_groups; + const struct attribute_group___2 **attr_update; + const char *name; + int type; + int capabilities; + int *pmu_disable_count; + struct perf_cpu_context___2 *pmu_cpu_context; + atomic_t exclusive_cnt; + int task_ctx_nr; + int hrtimer_interval_ms; + unsigned int nr_addr_filters; + void (*pmu_enable)(struct pmu___2 *); + void (*pmu_disable)(struct pmu___2 *); + int (*event_init)(struct perf_event___2 *); + void (*event_mapped)(struct perf_event___2 *, struct mm_struct___2 *); + void (*event_unmapped)(struct perf_event___2 *, struct mm_struct___2 *); + int (*add)(struct perf_event___2 *, int); + void (*del)(struct perf_event___2 *, int); + void (*start)(struct perf_event___2 *, int); + void (*stop)(struct perf_event___2 *, int); + void (*read)(struct perf_event___2 *); + void (*start_txn)(struct pmu___2 *, unsigned int); + int (*commit_txn)(struct pmu___2 *); + void (*cancel_txn)(struct pmu___2 *); + int (*event_idx)(struct perf_event___2 *); + void (*sched_task)(struct perf_event_context___2 *, bool); + size_t task_ctx_size; + void (*swap_task_ctx)(struct perf_event_context___2 *, struct perf_event_context___2 *); + void * (*setup_aux)(struct perf_event___2 *, void **, int, bool); + void (*free_aux)(void *); + long int (*snapshot_aux)(struct perf_event___2 *, struct perf_output_handle___2 *, long unsigned int); + int (*addr_filters_validate)(struct list_head *); + void (*addr_filters_sync)(struct perf_event___2 *); + int (*aux_output_match)(struct perf_event___2 *); + int (*filter_match)(struct perf_event___2 *); + int (*check_period)(struct perf_event___2 *, u64); }; struct kernel_param_ops___2 { @@ -34241,6 +39199,14 @@ struct bpf_prog_ops___2 { int (*test_run)(struct bpf_prog___2 *, const union bpf_attr *, union bpf_attr *); }; +struct bpf_verifier_ops___2 { + const struct bpf_func_proto * (*get_func_proto)(enum bpf_func_id, const struct bpf_prog___2 *); + bool (*is_valid_access)(int, int, enum bpf_access_type, const struct bpf_prog___2 *, struct bpf_insn_access_aux *); + int (*gen_prologue)(struct bpf_insn *, bool, const struct bpf_prog___2 *); + int (*gen_ld_abs)(const struct bpf_insn *, struct bpf_insn *); + u32 (*convert_ctx_access)(enum bpf_access_type, const struct bpf_insn *, struct bpf_insn *, struct bpf_prog___2 *, u32 *); +}; + struct bpf_prog_offload___2 { struct bpf_prog___2 *prog; struct net_device___2 *netdev; @@ -34391,6 +39357,15 @@ struct sk_buff___2 { struct skb_ext *extensions; }; +struct cgroup_bpf___2 { + struct bpf_prog_array___2 *effective[26]; + struct list_head progs[26]; + u32 flags[26]; + struct bpf_prog_array___2 *inactive; + struct percpu_ref refcnt; + struct work_struct release_work; +}; + struct cgroup_file___2 { struct kernfs_node___2 *kn; long unsigned int notified_at; @@ -34454,7 +39429,7 @@ struct cgroup___2 { wait_queue_head_t offline_waitq; struct work_struct release_agent_work; struct psi_group psi; - struct cgroup_bpf bpf; + struct cgroup_bpf___2 bpf; atomic_t congestion_count; struct cgroup_freezer_state freezer; u64 ancestor_ids[0]; @@ -34541,52 +39516,6 @@ struct cftype___2 { __poll_t (*poll)(struct kernfs_open_file___2 *, struct poll_table_struct___2 *); }; -struct perf_cpu_context___2; - -struct perf_output_handle___2; - -struct pmu___2 { - struct list_head entry; - struct module___2 *module; - struct device___2 *dev; - const struct attribute_group___2 **attr_groups; - const struct attribute_group___2 **attr_update; - const char *name; - int type; - int capabilities; - int *pmu_disable_count; - struct perf_cpu_context___2 *pmu_cpu_context; - atomic_t exclusive_cnt; - int task_ctx_nr; - int hrtimer_interval_ms; - unsigned int nr_addr_filters; - void (*pmu_enable)(struct pmu___2 *); - void (*pmu_disable)(struct pmu___2 *); - int (*event_init)(struct perf_event___2 *); - void (*event_mapped)(struct perf_event___2 *, struct mm_struct___2 *); - void (*event_unmapped)(struct perf_event___2 *, struct mm_struct___2 *); - int (*add)(struct perf_event___2 *, int); - void (*del)(struct perf_event___2 *, int); - void (*start)(struct perf_event___2 *, int); - void (*stop)(struct perf_event___2 *, int); - void (*read)(struct perf_event___2 *); - void (*start_txn)(struct pmu___2 *, unsigned int); - int (*commit_txn)(struct pmu___2 *); - void (*cancel_txn)(struct pmu___2 *); - int (*event_idx)(struct perf_event___2 *); - void (*sched_task)(struct perf_event_context___2 *, bool); - size_t task_ctx_size; - void (*swap_task_ctx)(struct perf_event_context___2 *, struct perf_event_context___2 *); - void * (*setup_aux)(struct perf_event___2 *, void **, int, bool); - void (*free_aux)(void *); - long int (*snapshot_aux)(struct perf_event___2 *, struct perf_output_handle___2 *, long unsigned int); - int (*addr_filters_validate)(struct list_head *); - void (*addr_filters_sync)(struct perf_event___2 *); - int (*aux_output_match)(struct perf_event___2 *); - int (*filter_match)(struct perf_event___2 *); - int (*check_period)(struct perf_event___2 *, u64); -}; - struct perf_cpu_context___2 { struct perf_event_context___2 ctx; struct perf_event_context___2 *task_ctx; @@ -34668,6 +39597,12 @@ struct ring_buffer___2 { void *data_pages[0]; }; +struct bpf_perf_event_data_kern___2 { + bpf_user_pt_regs_t *regs; + struct perf_sample_data *data; + struct perf_event___2 *event; +}; + struct perf_pmu_events_attr___2 { struct device_attribute___2 attr; u64 id; @@ -34838,6 +39773,16 @@ struct inet_frag_queue___2 { struct callback_head rcu; }; +struct pernet_operations___2 { + struct list_head list; + int (*init)(struct net___2 *); + void (*pre_exit)(struct net___2 *); + void (*exit)(struct net___2 *); + void (*exit_batch)(struct list_head *); + unsigned int *id; + size_t size; +}; + struct xdp_rxq_info___2 { struct net_device___2 *dev; u32 queue_index; @@ -34915,7 +39860,7 @@ struct netdev_queue___2 { long unsigned int tx_maxrate; long unsigned int trans_timeout; struct net_device___2 *sb_dev; - long: 64; + struct xdp_umem *umem; spinlock_t _xmit_lock; int xmit_lock_owner; long unsigned int trans_start; @@ -34985,6 +39930,14 @@ struct netdev_rx_queue___2 { long: 64; long: 64; struct xdp_rxq_info___2 xdp_rxq; + struct xdp_umem *umem; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; struct netdev_bpf___2 { @@ -35588,6 +40541,8 @@ struct xol_area { long unsigned int vaddr; }; +typedef long unsigned int vm_flags_t; + struct compact_control; struct capture_control { @@ -35595,8 +40550,6 @@ struct capture_control { struct page___2 *page; }; -typedef int filler_t(void *, struct page___2 *); - struct page_vma_mapped_walk { struct page___2 *page; struct vm_area_struct___2 *vma; @@ -35677,10 +40630,6 @@ struct static_key_deferred { struct delayed_work work; }; -typedef void (*dr_release_t___2)(struct device___2 *, void *); - -typedef int (*dr_match_t___2)(struct device___2 *, void *, void *); - enum rseq_cpu_id_state { RSEQ_CPU_ID_UNINITIALIZED = 4294967295, RSEQ_CPU_ID_REGISTRATION_FAILED = 4294967294, @@ -35723,6 +40672,10 @@ struct trace_event_data_offsets_rseq_update {}; struct trace_event_data_offsets_rseq_ip_fixup {}; +typedef void (*btf_trace_rseq_update)(void *, struct task_struct___2 *); + +typedef void (*btf_trace_rseq_ip_fixup)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); + struct __key_reference_with_attributes; typedef struct __key_reference_with_attributes *key_ref_t; @@ -35782,9 +40735,11 @@ struct kernel_pkey_query { __u16 max_dec_size; }; +struct asymmetric_key_subtype; + struct pkcs7_message; -typedef struct pglist_data___2 pg_data_t___2; +typedef struct pglist_data___2 pg_data_t; struct xa_node { unsigned char shift; @@ -35866,6 +40821,8 @@ struct fid { }; }; +typedef void (*poll_queue_proc___3)(struct file___2 *, wait_queue_head_t *, struct poll_table_struct *); + struct trace_event_raw_mm_filemap_op_page_cache { struct trace_entry ent; long unsigned int pfn; @@ -35899,6 +40856,14 @@ struct trace_event_data_offsets_filemap_set_wb_err {}; struct trace_event_data_offsets_file_check_and_advance_wb_err {}; +typedef void (*btf_trace_mm_filemap_delete_from_page_cache)(void *, struct page___2 *); + +typedef void (*btf_trace_mm_filemap_add_to_page_cache)(void *, struct page___2 *); + +typedef void (*btf_trace_filemap_set_wb_err)(void *, struct address_space___2 *, errseq_t); + +typedef void (*btf_trace_file_check_and_advance_wb_err)(void *, struct file___2 *, errseq_t); + struct wait_page_key { struct page___2 *page; int bit_nr; @@ -35968,10 +40933,17 @@ struct kmem_cache_node { struct list_head full; }; -struct zap_details { - struct address_space___2 *check_mapping; - long unsigned int first_index; - long unsigned int last_index; +enum slab_state { + DOWN = 0, + PARTIAL = 1, + PARTIAL_NODE = 2, + UP = 3, + FULL = 4, +}; + +struct kmalloc_info_struct { + const char *name[3]; + unsigned int size; }; enum oom_constraint { @@ -36105,23 +41077,31 @@ struct trace_event_data_offsets_skip_task_reaping {}; struct trace_event_data_offsets_compact_retry {}; +typedef void (*btf_trace_oom_score_adj_update)(void *, struct task_struct___2 *); + +typedef void (*btf_trace_reclaim_retry_zone)(void *, struct zoneref___2 *, int, long unsigned int, long unsigned int, long unsigned int, int, bool); + +typedef void (*btf_trace_mark_victim)(void *, int); + +typedef void (*btf_trace_wake_reaper)(void *, int); + +typedef void (*btf_trace_start_task_reaping)(void *, int); + +typedef void (*btf_trace_finish_task_reaping)(void *, int); + +typedef void (*btf_trace_skip_task_reaping)(void *, int); + +typedef void (*btf_trace_compact_retry)(void *, int, enum compact_priority, enum compact_result, int, int, bool); + enum wb_congested_state { WB_async_congested = 0, WB_sync_congested = 1, }; -typedef void (*poll_queue_proc___3)(struct file___2 *, wait_queue_head_t *, struct poll_table_struct *); - enum { XA_CHECK_SCHED = 4096, }; -struct fprop_global { - struct percpu_counter events; - unsigned int period; - seqcount_t sequence; -}; - enum wb_state { WB_registered = 0, WB_writeback_running = 1, @@ -36139,15 +41119,6 @@ struct wb_lock_cookie { long unsigned int flags; }; -struct wb_domain { - spinlock_t lock; - struct fprop_global completions; - struct timer_list period_timer; - long unsigned int period_time; - long unsigned int dirty_limit_tstamp; - long unsigned int dirty_limit; -}; - typedef int (*writepage_t)(struct page___2 *, struct writeback_control *, void *); struct dirty_throttle_control { @@ -36183,6 +41154,10 @@ struct trace_event_data_offsets_mm_lru_insertion {}; struct trace_event_data_offsets_mm_lru_activate {}; +typedef void (*btf_trace_mm_lru_insertion)(void *, struct page___2 *, int); + +typedef void (*btf_trace_mm_lru_activate)(void *, struct page___2 *); + enum lruvec_flags { LRUVEC_CONGESTED = 0, }; @@ -36211,7 +41186,7 @@ enum mem_cgroup_protection { }; struct mem_cgroup_reclaim_cookie { - pg_data_t___2 *pgdat; + pg_data_t *pgdat; unsigned int generation; }; @@ -36386,6 +41361,34 @@ struct trace_event_data_offsets_mm_vmscan_inactive_list_is_low {}; struct trace_event_data_offsets_mm_vmscan_node_reclaim_begin {}; +typedef void (*btf_trace_mm_vmscan_kswapd_sleep)(void *, int); + +typedef void (*btf_trace_mm_vmscan_kswapd_wake)(void *, int, int, int); + +typedef void (*btf_trace_mm_vmscan_wakeup_kswapd)(void *, int, int, int, gfp_t); + +typedef void (*btf_trace_mm_vmscan_direct_reclaim_begin)(void *, int, gfp_t); + +typedef void (*btf_trace_mm_vmscan_direct_reclaim_end)(void *, long unsigned int); + +typedef void (*btf_trace_mm_shrink_slab_start)(void *, struct shrinker *, struct shrink_control *, long int, long unsigned int, long long unsigned int, long unsigned int, int); + +typedef void (*btf_trace_mm_shrink_slab_end)(void *, struct shrinker *, int, int, long int, long int, long int); + +typedef void (*btf_trace_mm_vmscan_lru_isolate)(void *, int, int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, isolate_mode_t, int); + +typedef void (*btf_trace_mm_vmscan_writepage)(void *, struct page___2 *); + +typedef void (*btf_trace_mm_vmscan_lru_shrink_inactive)(void *, int, long unsigned int, long unsigned int, struct reclaim_stat *, int, int); + +typedef void (*btf_trace_mm_vmscan_lru_shrink_active)(void *, int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, int, int); + +typedef void (*btf_trace_mm_vmscan_inactive_list_is_low)(void *, int, int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, int); + +typedef void (*btf_trace_mm_vmscan_node_reclaim_begin)(void *, int, int, gfp_t); + +typedef void (*btf_trace_mm_vmscan_node_reclaim_end)(void *, long unsigned int); + struct scan_control { long unsigned int nr_to_reclaim; nodemask_t *nodemask; @@ -36455,10 +41458,6 @@ struct shared_policy { rwlock_t lock; }; -struct xattr; - -typedef int (*initxattrs)(struct inode___2 *, const struct xattr *, void *); - struct xattr { const char *name; void *value; @@ -36506,7 +41505,7 @@ struct shmem_inode_info { struct shared_policy policy; struct simple_xattrs xattrs; atomic_t stop_eviction; - struct inode___2 vfs_inode; + struct inode vfs_inode; }; struct shmem_sb_info { @@ -36534,8 +41533,6 @@ enum sgp_type { SGP_FALLOC = 5, }; -typedef void (*poll_queue_proc___4)(struct file *, wait_queue_head_t *, struct poll_table_struct___2 *); - struct shmem_falloc { wait_queue_head_t *waitq; long unsigned int start; @@ -36585,6 +41582,8 @@ struct contig_page_info { long unsigned int free_blocks_suitable; }; +typedef s8 pto_T_____20; + enum mminit_level { MMINIT_WARNING = 0, MMINIT_VERIFY = 1, @@ -36609,6 +41608,14 @@ struct pcpu_alloc_info { struct pcpu_group_info groups[0]; }; +typedef void * (*pcpu_fc_alloc_fn_t)(unsigned int, size_t, size_t); + +typedef void (*pcpu_fc_free_fn_t)(void *, size_t); + +typedef void (*pcpu_fc_populate_pte_fn_t)(long unsigned int); + +typedef int pcpu_fc_cpu_distance_fn_t(unsigned int, unsigned int); + struct trace_event_raw_percpu_alloc_percpu { struct trace_entry ent; bool reserved; @@ -36660,6 +41667,16 @@ struct trace_event_data_offsets_percpu_create_chunk {}; struct trace_event_data_offsets_percpu_destroy_chunk {}; +typedef void (*btf_trace_percpu_alloc_percpu)(void *, bool, bool, size_t, size_t, void *, int, void *); + +typedef void (*btf_trace_percpu_free_percpu)(void *, void *, int, void *); + +typedef void (*btf_trace_percpu_alloc_percpu_fail)(void *, bool, bool, size_t, size_t); + +typedef void (*btf_trace_percpu_create_chunk)(void *, void *); + +typedef void (*btf_trace_percpu_destroy_chunk)(void *, void *); + struct pcpu_block_md { int scan_hint; int scan_hint_start; @@ -36795,18 +41812,31 @@ struct trace_event_data_offsets_mm_page_alloc_extfrag {}; struct trace_event_data_offsets_rss_stat {}; -enum slab_state { - DOWN = 0, - PARTIAL = 1, - PARTIAL_NODE = 2, - UP = 3, - FULL = 4, -}; +typedef void (*btf_trace_kmalloc)(void *, long unsigned int, const void *, size_t, size_t, gfp_t); -struct kmalloc_info_struct { - const char *name[3]; - unsigned int size; -}; +typedef void (*btf_trace_kmem_cache_alloc)(void *, long unsigned int, const void *, size_t, size_t, gfp_t); + +typedef void (*btf_trace_kmalloc_node)(void *, long unsigned int, const void *, size_t, size_t, gfp_t, int); + +typedef void (*btf_trace_kmem_cache_alloc_node)(void *, long unsigned int, const void *, size_t, size_t, gfp_t, int); + +typedef void (*btf_trace_kfree)(void *, long unsigned int, const void *); + +typedef void (*btf_trace_kmem_cache_free)(void *, long unsigned int, const void *); + +typedef void (*btf_trace_mm_page_free)(void *, struct page___2 *, unsigned int); + +typedef void (*btf_trace_mm_page_free_batched)(void *, struct page___2 *); + +typedef void (*btf_trace_mm_page_alloc)(void *, struct page___2 *, unsigned int, gfp_t, int); + +typedef void (*btf_trace_mm_page_alloc_zone_locked)(void *, struct page___2 *, unsigned int, int); + +typedef void (*btf_trace_mm_page_pcpu_drain)(void *, struct page___2 *, unsigned int, int); + +typedef void (*btf_trace_mm_page_alloc_extfrag)(void *, struct page___2 *, int, int, int, int); + +typedef void (*btf_trace_rss_stat)(void *, struct mm_struct___2 *, int, long int); struct slabinfo { long unsigned int active_objs; @@ -36821,15 +41851,6 @@ struct slabinfo { unsigned int cache_order; }; -struct node___2 { - struct device dev; - struct list_head access_list; -}; - -typedef struct page___2 *new_page_t(struct page___2 *, long unsigned int); - -typedef void free_page_t(struct page___2 *, long unsigned int); - struct alloc_context { struct zonelist___2 *zonelist; nodemask_t *nodemask; @@ -36936,6 +41957,34 @@ struct trace_event_data_offsets_mm_compaction_kcompactd_sleep {}; struct trace_event_data_offsets_kcompactd_wake_template {}; +typedef void (*btf_trace_mm_compaction_isolate_migratepages)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); + +typedef void (*btf_trace_mm_compaction_isolate_freepages)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); + +typedef void (*btf_trace_mm_compaction_migratepages)(void *, long unsigned int, int, struct list_head *); + +typedef void (*btf_trace_mm_compaction_begin)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int, bool); + +typedef void (*btf_trace_mm_compaction_end)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int, bool, int); + +typedef void (*btf_trace_mm_compaction_try_to_compact_pages)(void *, int, gfp_t, int); + +typedef void (*btf_trace_mm_compaction_finished)(void *, struct zone___2 *, int, int); + +typedef void (*btf_trace_mm_compaction_suitable)(void *, struct zone___2 *, int, int); + +typedef void (*btf_trace_mm_compaction_deferred)(void *, struct zone___2 *, int); + +typedef void (*btf_trace_mm_compaction_defer_compaction)(void *, struct zone___2 *, int); + +typedef void (*btf_trace_mm_compaction_defer_reset)(void *, struct zone___2 *, int); + +typedef void (*btf_trace_mm_compaction_kcompactd_sleep)(void *, int); + +typedef void (*btf_trace_mm_compaction_wakeup_kcompactd)(void *, int, int, enum zone_type); + +typedef void (*btf_trace_mm_compaction_kcompactd_wake)(void *, int, int, enum zone_type); + typedef enum { ISOLATE_ABORT = 0, ISOLATE_NONE = 1, @@ -36969,6 +42018,12 @@ struct follow_page_context { unsigned int page_mask; }; +struct zap_details { + struct address_space___2 *check_mapping; + long unsigned int first_index; + long unsigned int last_index; +}; + typedef int (*pte_fn_t)(pte_t *, long unsigned int, void *); enum { @@ -37020,6 +42075,8 @@ enum { HUGETLB_ANONHUGE_INODE = 2, }; +struct attribute_group___3; + struct rmap_walk_control { void *arg; bool (*rmap_one)(struct page___2 *, struct vm_area_struct___2 *, long unsigned int, void *); @@ -37077,6 +42134,8 @@ struct vmap_block { struct list_head purge; }; +typedef struct vmap_area *pto_T_____21; + struct page_frag_cache { void *va; __u16 offset; @@ -37176,8 +42235,6 @@ enum string_size_units { STRING_UNITS_2 = 1, }; -typedef void (*node_registration_func_t)(struct node___2 *); - struct resv_map { struct kref refs; spinlock_t lock; @@ -37408,6 +42465,10 @@ struct buffer_head { atomic_t b_count; }; +typedef struct page___2 *new_page_t(struct page___2 *, long unsigned int); + +typedef void free_page_t(struct page___2 *, long unsigned int); + enum bh_state_bits { BH_Uptodate = 0, BH_Dirty = 1, @@ -37440,6 +42501,8 @@ struct trace_event_raw_mm_migrate_pages { struct trace_event_data_offsets_mm_migrate_pages {}; +typedef void (*btf_trace_mm_migrate_pages)(void *, long unsigned int, long unsigned int, enum migrate_mode, int); + struct hugetlbfs_inode_info { struct shared_policy policy; struct inode___2 vfs_inode; @@ -37448,6 +42511,8 @@ struct hugetlbfs_inode_info { typedef s32 compat_off_t; +struct fs_context_operations___2; + struct open_flags { int open_flag; umode_t mode; @@ -37490,7 +42555,7 @@ enum vfs_get_super_keying { vfs_get_independent_super = 3, }; -typedef struct kobject___2 *kobj_probe_t(dev_t, int *, void *); +struct kobj_map; struct char_device_struct { struct char_device_struct *next; @@ -37501,8 +42566,6 @@ struct char_device_struct { struct cdev *cdev; }; -struct kobj_map; - struct stat { __kernel_ulong_t st_dev; __kernel_ulong_t st_ino; @@ -37625,7 +42688,7 @@ enum inode_i_mutex_lock_class { struct pseudo_fs_context { const struct super_operations *ops; const struct xattr_handler **xattr; - const struct dentry_operations___2 *dops; + const struct dentry_operations *dops; long unsigned int magic; }; @@ -37903,7 +42966,7 @@ struct poll_table_entry { struct poll_table_page; struct poll_wqueues { - poll_table___2 pt; + poll_table pt; struct poll_table_page *table; struct task_struct___2 *polling_task; int triggered; @@ -37918,36 +42981,6 @@ struct poll_table_page { struct poll_table_entry entries[0]; }; -struct ip_ra_chain { - struct ip_ra_chain *next; - struct sock *sk; - union { - void (*destructor)(struct sock *); - struct sock *saved_sk; - }; - struct callback_head rcu; -}; - -struct fib_table { - struct hlist_node tb_hlist; - u32 tb_id; - int tb_num_default; - struct callback_head rcu; - long unsigned int *tb_data; - long unsigned int __data[0]; -}; - -struct inet_peer_base { - struct rb_root rb_root; - seqlock_t lock; - int total; -}; - -struct dst_metrics { - u32 metrics[17]; - refcount_t refcnt; -}; - enum poll_time_type { PT_TIMEVAL = 0, PT_OLD_TIMEVAL = 1, @@ -38012,7 +43045,7 @@ struct select_data { struct list_head dispose; }; -typedef long int pao_T_____4; +typedef long int pao_T_____6; struct fsxattr { __u32 fsx_xflags; @@ -38033,7 +43066,7 @@ enum file_time_flags { struct proc_mounts { struct mnt_namespace *ns; struct path root; - int (*show)(struct seq_file *, struct vfsmount___2 *); + int (*show)(struct seq_file *, struct vfsmount *); void *cached_mount; u64 cached_event; loff_t cached_index; @@ -38045,12 +43078,6 @@ enum umount_tree_flags { UMOUNT_CONNECTED = 4, }; -struct tree_descr { - const char *name; - const struct file_operations *ops; - int mode; -}; - struct simple_transaction_argresp { ssize_t size; char data[0]; @@ -38073,7 +43100,7 @@ struct wb_completion { struct wb_writeback_work { long int nr_pages; - struct super_block___2 *sb; + struct super_block *sb; long unsigned int *older_than_this; enum writeback_sync_modes sync_mode; unsigned int tagged_writepages: 1; @@ -38291,6 +43318,66 @@ struct trace_event_data_offsets_writeback_single_inode_template {}; struct trace_event_data_offsets_writeback_inode_template {}; +typedef void (*btf_trace_writeback_dirty_page)(void *, struct page___2 *, struct address_space___2 *); + +typedef void (*btf_trace_wait_on_page_writeback)(void *, struct page___2 *, struct address_space___2 *); + +typedef void (*btf_trace_writeback_mark_inode_dirty)(void *, struct inode___2 *, int); + +typedef void (*btf_trace_writeback_dirty_inode_start)(void *, struct inode___2 *, int); + +typedef void (*btf_trace_writeback_dirty_inode)(void *, struct inode___2 *, int); + +typedef void (*btf_trace_writeback_write_inode_start)(void *, struct inode___2 *, struct writeback_control *); + +typedef void (*btf_trace_writeback_write_inode)(void *, struct inode___2 *, struct writeback_control *); + +typedef void (*btf_trace_writeback_queue)(void *, struct bdi_writeback *, struct wb_writeback_work *); + +typedef void (*btf_trace_writeback_exec)(void *, struct bdi_writeback *, struct wb_writeback_work *); + +typedef void (*btf_trace_writeback_start)(void *, struct bdi_writeback *, struct wb_writeback_work *); + +typedef void (*btf_trace_writeback_written)(void *, struct bdi_writeback *, struct wb_writeback_work *); + +typedef void (*btf_trace_writeback_wait)(void *, struct bdi_writeback *, struct wb_writeback_work *); + +typedef void (*btf_trace_writeback_pages_written)(void *, long int); + +typedef void (*btf_trace_writeback_wake_background)(void *, struct bdi_writeback *); + +typedef void (*btf_trace_writeback_bdi_register)(void *, struct backing_dev_info *); + +typedef void (*btf_trace_wbc_writepage)(void *, struct writeback_control *, struct backing_dev_info *); + +typedef void (*btf_trace_writeback_queue_io)(void *, struct bdi_writeback *, struct wb_writeback_work *, int); + +typedef void (*btf_trace_global_dirty_state)(void *, long unsigned int, long unsigned int); + +typedef void (*btf_trace_bdi_dirty_ratelimit)(void *, struct bdi_writeback *, long unsigned int, long unsigned int); + +typedef void (*btf_trace_balance_dirty_pages)(void *, struct bdi_writeback *, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long int, long unsigned int); + +typedef void (*btf_trace_writeback_sb_inodes_requeue)(void *, struct inode___2 *); + +typedef void (*btf_trace_writeback_congestion_wait)(void *, unsigned int, unsigned int); + +typedef void (*btf_trace_writeback_wait_iff_congested)(void *, unsigned int, unsigned int); + +typedef void (*btf_trace_writeback_single_inode_start)(void *, struct inode___2 *, struct writeback_control *, long unsigned int); + +typedef void (*btf_trace_writeback_single_inode)(void *, struct inode___2 *, struct writeback_control *, long unsigned int); + +typedef void (*btf_trace_writeback_lazytime)(void *, struct inode___2 *); + +typedef void (*btf_trace_writeback_lazytime_iput)(void *, struct inode___2 *); + +typedef void (*btf_trace_writeback_dirty_inode_enqueue)(void *, struct inode___2 *); + +typedef void (*btf_trace_sb_mark_inode_writeback)(void *, struct inode___2 *); + +typedef void (*btf_trace_sb_clear_inode_writeback)(void *, struct inode___2 *); + struct splice_desc { size_t total_len; unsigned int len; @@ -38457,6 +43544,11 @@ struct iomap_page_ops { void (*page_done)(struct inode___2 *, loff_t, unsigned int, struct page___2 *, struct iomap___2 *); }; +struct decrypt_bh_ctx { + struct work_struct work; + struct buffer_head *bh; +}; + struct bh_lru { struct buffer_head *bhs[16]; }; @@ -38466,6 +43558,8 @@ struct bh_accounting { int ratelimit; }; +typedef struct buffer_head *pto_T_____22; + enum { DISK_EVENT_MEDIA_CHANGE = 1, DISK_EVENT_EJECT_REQUEST = 2, @@ -38478,7 +43572,7 @@ enum { struct bdev_inode { struct block_device bdev; - struct inode___2 vfs_inode; + struct inode vfs_inode; }; struct blkdev_dio { @@ -38502,7 +43596,7 @@ struct bd_holder_disk { struct blk_integrity; -typedef int dio_iodone_t(struct kiocb___2 *, loff_t, ssize_t, void *); +typedef int dio_iodone_t(struct kiocb *, loff_t, ssize_t, void *); typedef void dio_submit_t(struct bio *, struct inode___2 *, loff_t); @@ -38527,12 +43621,12 @@ struct dio_submit { loff_t logical_offset_in_bio; sector_t final_block_in_bio; sector_t next_block_for_io; - struct page___2 *cur_page; + struct page *cur_page; unsigned int cur_page_offset; unsigned int cur_page_len; sector_t cur_page_block; loff_t cur_page_fs_offset; - struct iov_iter___2 *iter; + struct iov_iter *iter; unsigned int head; unsigned int tail; size_t from; @@ -38558,10 +43652,10 @@ struct dio { long unsigned int refcount; struct bio *bio_list; struct task_struct___2 *waiter; - struct kiocb___2 *iocb; + struct kiocb *iocb; ssize_t result; union { - struct page___2 *pages[64]; + struct page *pages[64]; struct work_struct complete_work; }; long: 64; @@ -38603,9 +43697,9 @@ struct proc_dir_entry { struct completion *pde_unload_completion; const struct inode_operations___2 *proc_iops; const struct file_operations___2 *proc_fops; - const struct dentry_operations___2 *proc_dops; + const struct dentry_operations *proc_dops; union { - const struct seq_operations___2 *seq_ops; + const struct seq_operations *seq_ops; int (*single_show)(struct seq_file___2 *, void *); }; proc_write_t write; @@ -38752,7 +43846,7 @@ struct eppoll_entry { }; struct ep_pqueue { - poll_table___2 pt; + poll_table pt; struct epitem *epi; }; @@ -38891,7 +43985,7 @@ struct kioctx { unsigned int nr_events; long unsigned int mmap_base; long unsigned int mmap_size; - struct page___2 **ring_pages; + struct page **ring_pages; long int nr_pages; struct rcu_work free_rwork; struct ctx_rq_wait *rq_wait; @@ -38933,7 +44027,7 @@ struct kioctx { long: 64; long: 64; }; - struct page___2 *internal_pages[8]; + struct page *internal_pages[8]; struct file *aio_ring_file; unsigned int id; long: 32; @@ -39019,45 +44113,6 @@ struct user_msghdr { unsigned int msg_flags; }; -enum sock_type { - SOCK_STREAM = 1, - SOCK_DGRAM = 2, - SOCK_RAW = 3, - SOCK_RDM = 4, - SOCK_SEQPACKET = 5, - SOCK_DCCP = 6, - SOCK_PACKET = 10, -}; - -enum { - IPPROTO_IP = 0, - IPPROTO_ICMP = 1, - IPPROTO_IGMP = 2, - IPPROTO_IPIP = 4, - IPPROTO_TCP = 6, - IPPROTO_EGP = 8, - IPPROTO_PUP = 12, - IPPROTO_UDP = 17, - IPPROTO_IDP = 22, - IPPROTO_TP = 29, - IPPROTO_DCCP = 33, - IPPROTO_IPV6 = 41, - IPPROTO_RSVP = 46, - IPPROTO_GRE = 47, - IPPROTO_ESP = 50, - IPPROTO_AH = 51, - IPPROTO_MTP = 92, - IPPROTO_BEETPH = 94, - IPPROTO_ENCAP = 98, - IPPROTO_PIM = 103, - IPPROTO_COMP = 108, - IPPROTO_SCTP = 132, - IPPROTO_UDPLITE = 136, - IPPROTO_MPLS = 137, - IPPROTO_RAW = 255, - IPPROTO_MAX = 256, -}; - struct scm_fp_list { short int count; short int max; @@ -39195,6 +44250,26 @@ struct trace_event_data_offsets_io_uring_complete {}; struct trace_event_data_offsets_io_uring_submit_sqe {}; +typedef void (*btf_trace_io_uring_create)(void *, int, void *, u32, u32, u32); + +typedef void (*btf_trace_io_uring_register)(void *, void *, unsigned int, unsigned int, unsigned int, bool, long int); + +typedef void (*btf_trace_io_uring_file_get)(void *, void *, int); + +typedef void (*btf_trace_io_uring_queue_async_work)(void *, void *, int, void *, struct io_wq_work *, unsigned int); + +typedef void (*btf_trace_io_uring_defer)(void *, void *, void *, long long unsigned int); + +typedef void (*btf_trace_io_uring_link)(void *, void *, void *, void *); + +typedef void (*btf_trace_io_uring_cqring_wait)(void *, void *, int); + +typedef void (*btf_trace_io_uring_fail_link)(void *, void *, void *); + +typedef void (*btf_trace_io_uring_complete)(void *, void *, u64, long int); + +typedef void (*btf_trace_io_uring_submit_sqe)(void *, void *, u64, bool, bool); + struct io_uring_sqe { __u8 opcode; __u8 flags; @@ -39320,8 +44395,6 @@ struct io_wq_data { put_work_fn *put_work; }; -typedef bool work_cancel_fn(struct io_wq_work *, void *); - struct io_uring { u32 head; long: 32; @@ -39364,7 +44437,7 @@ struct io_rings { struct io_mapped_ubuf { u64 ubuf; size_t len; - struct bio_vec___2 *bvec; + struct bio_vec *bvec; unsigned int nr_bvecs; }; @@ -39422,7 +44495,7 @@ struct io_ring_ctx { unsigned int cq_mask; atomic_t cq_timeouts; struct wait_queue_head cq_wait; - struct fasync_struct___2 *cq_fasync; + struct fasync_struct *cq_fasync; struct eventfd_ctx___2 *cq_ev_fd; long: 64; }; @@ -39444,7 +44517,7 @@ struct io_ring_ctx { }; struct io_rw { - struct kiocb___2 kiocb; + struct kiocb kiocb; u64 addr; u64 len; }; @@ -39583,7 +44656,7 @@ struct io_submit_state { }; struct io_poll_table { - struct poll_table_struct___2 pt; + struct poll_table_struct pt; struct io_kiocb *req; int error; }; @@ -39600,6 +44673,8 @@ struct io_wq_work_list { struct io_wq_work_node *last; }; +typedef bool work_cancel_fn(struct io_wq_work *, void *); + enum { IO_WORKER_F_UP = 1, IO_WORKER_F_RUNNING = 2, @@ -39773,6 +44848,30 @@ struct trace_event_data_offsets_generic_add_lease {}; struct trace_event_data_offsets_leases_conflict {}; +typedef void (*btf_trace_locks_get_lock_context)(void *, struct inode___2 *, int, struct file_lock_context *); + +typedef void (*btf_trace_posix_lock_inode)(void *, struct inode___2 *, struct file_lock *, int); + +typedef void (*btf_trace_fcntl_setlk)(void *, struct inode___2 *, struct file_lock *, int); + +typedef void (*btf_trace_locks_remove_posix)(void *, struct inode___2 *, struct file_lock *, int); + +typedef void (*btf_trace_flock_lock_inode)(void *, struct inode___2 *, struct file_lock *, int); + +typedef void (*btf_trace_break_lease_noblock)(void *, struct inode___2 *, struct file_lock *); + +typedef void (*btf_trace_break_lease_block)(void *, struct inode___2 *, struct file_lock *); + +typedef void (*btf_trace_break_lease_unblock)(void *, struct inode___2 *, struct file_lock *); + +typedef void (*btf_trace_generic_delete_lease)(void *, struct inode___2 *, struct file_lock *); + +typedef void (*btf_trace_time_out_leases)(void *, struct inode___2 *, struct file_lock *); + +typedef void (*btf_trace_generic_add_lease)(void *, struct inode___2 *, struct file_lock *); + +typedef void (*btf_trace_leases_conflict)(void *, bool, struct file_lock *, struct file_lock *); + struct file_lock_list_struct { spinlock_t lock; struct hlist_head hlist; @@ -39835,42 +44934,6 @@ struct compat_nfs4_mount_data_v1 { compat_uptr_t auth_flavours; }; -struct serial_icounter_struct { - int cts; - int dsr; - int rng; - int dcd; - int rx; - int tx; - int frame; - int overrun; - int parity; - int brk; - int buf_overrun; - int reserved[9]; -}; - -struct serial_struct { - int type; - int line; - unsigned int port; - int irq; - int flags; - int xmit_fifo_size; - int custom_divisor; - int baud_base; - short unsigned int close_delay; - char io_type; - char reserved_char[1]; - int hub6; - short unsigned int closing_wait; - short unsigned int closing_wait2; - unsigned char *iomem_base; - short unsigned int iomem_reg_shift; - unsigned int port_high; - long unsigned int iomap_base; -}; - enum { VERBOSE_STATUS = 1, }; @@ -39889,7 +44952,7 @@ typedef struct { char *mask; const char *interpreter; char *name; - struct dentry___2 *dentry; + struct dentry *dentry; struct file *interp_file; } Node; @@ -39897,17 +44960,6 @@ typedef unsigned int __kernel_uid_t; typedef unsigned int __kernel_gid_t; -struct elf64_phdr { - Elf64_Word p_type; - Elf64_Word p_flags; - Elf64_Off p_offset; - Elf64_Addr p_vaddr; - Elf64_Addr p_paddr; - Elf64_Xword p_filesz; - Elf64_Xword p_memsz; - Elf64_Xword p_align; -}; - struct elf_prpsinfo { char pr_state; char pr_sname; @@ -39951,40 +45003,6 @@ struct elf_note_info { int thread_notes; }; -typedef __u32 Elf32_Addr; - -typedef __u16 Elf32_Half; - -typedef __u32 Elf32_Off; - -struct elf32_hdr { - unsigned char e_ident[16]; - Elf32_Half e_type; - Elf32_Half e_machine; - Elf32_Word e_version; - Elf32_Addr e_entry; - Elf32_Off e_phoff; - Elf32_Off e_shoff; - Elf32_Word e_flags; - Elf32_Half e_ehsize; - Elf32_Half e_phentsize; - Elf32_Half e_phnum; - Elf32_Half e_shentsize; - Elf32_Half e_shnum; - Elf32_Half e_shstrndx; -}; - -struct elf32_phdr { - Elf32_Word p_type; - Elf32_Off p_offset; - Elf32_Addr p_vaddr; - Elf32_Addr p_paddr; - Elf32_Word p_filesz; - Elf32_Word p_memsz; - Elf32_Word p_flags; - Elf32_Word p_align; -}; - struct elf32_shdr { Elf32_Word sh_name; Elf32_Word sh_type; @@ -40088,18 +45106,6 @@ struct posix_acl_xattr_header { __le32 a_version; }; -struct xdr_buf { - struct kvec head[1]; - struct kvec tail[1]; - struct bio_vec *bvec; - struct page___2 **pages; - unsigned int page_base; - unsigned int page_len; - unsigned int flags; - unsigned int buflen; - unsigned int len; -}; - struct xdr_array2_desc; typedef int (*xdr_xcode_elem_t)(struct xdr_array2_desc *, void *); @@ -40195,6 +45201,22 @@ struct trace_event_data_offsets_iomap_class {}; struct trace_event_data_offsets_iomap_apply {}; +typedef void (*btf_trace_iomap_readpage)(void *, struct inode___2 *, int); + +typedef void (*btf_trace_iomap_readpages)(void *, struct inode___2 *, int); + +typedef void (*btf_trace_iomap_writepage)(void *, struct inode___2 *, struct page___2 *, long unsigned int, unsigned int); + +typedef void (*btf_trace_iomap_releasepage)(void *, struct inode___2 *, struct page___2 *, long unsigned int, unsigned int); + +typedef void (*btf_trace_iomap_invalidatepage)(void *, struct inode___2 *, struct page___2 *, long unsigned int, unsigned int); + +typedef void (*btf_trace_iomap_apply_dstmap)(void *, struct inode___2 *, struct iomap___2 *); + +typedef void (*btf_trace_iomap_apply_srcmap)(void *, struct inode___2 *, struct iomap___2 *); + +typedef void (*btf_trace_iomap_apply)(void *, struct inode___2 *, loff_t, loff_t, unsigned int, const void *, void *, long unsigned int); + struct iomap_ops { int (*iomap_begin)(struct inode___2 *, loff_t, loff_t, unsigned int, struct iomap___2 *, struct iomap___2 *); int (*iomap_end)(struct inode___2 *, loff_t, loff_t, ssize_t, unsigned int, struct iomap___2 *); @@ -40561,8 +45583,8 @@ enum { struct proc_maps_private { struct inode___2 *inode; struct task_struct *task; - struct mm_struct___2 *mm; - struct vm_area_struct___2 *tail_vma; + struct mm_struct *mm; + struct vm_area_struct *tail_vma; struct mempolicy *task_mempolicy; }; @@ -40679,7 +45701,7 @@ struct pid_entry { unsigned int len; umode_t mode; const struct inode_operations___2 *iop; - const struct file_operations___2 *fop; + const struct file_operations *fop; union proc_op op; }; @@ -40715,14 +45737,6 @@ struct vmcore { loff_t offset; }; -typedef struct elf32_hdr Elf32_Ehdr; - -typedef struct elf32_phdr Elf32_Phdr; - -typedef struct elf64_phdr Elf64_Phdr; - -typedef struct elf32_note Elf32_Nhdr; - typedef struct elf64_note Elf64_Nhdr; struct kernfs_iattrs { @@ -40735,7 +45749,7 @@ struct kernfs_iattrs { }; struct kernfs_super_info { - struct super_block___2 *sb; + struct super_block *sb; struct kernfs_root___2 *root; const void *ns; struct list_head node; @@ -41149,6 +46163,14 @@ struct blockgroup_lock { struct bgl_lock locks[128]; }; +struct fsverity_operations { + int (*begin_enable_verity)(struct file___2 *); + int (*end_enable_verity)(struct file___2 *, const void *, size_t, u64); + int (*get_verity_descriptor)(struct inode___2 *, void *, size_t); + struct page___2 * (*read_merkle_tree_page)(struct inode___2 *, long unsigned int); + int (*write_merkle_tree_block)(struct inode___2 *, const void *, u64, int); +}; + typedef int ext4_grpblk_t; typedef long long unsigned int ext4_fsblk_t; @@ -41434,7 +46456,7 @@ struct ext4_sb_info { struct proc_dir_entry *s_proc; struct kobject___2 s_kobj; struct completion s_kobj_unregister; - struct super_block___2 *s_sb; + struct super_block *s_sb; struct journal_s *s_journal; struct list_head s_orphan; struct mutex s_orphan_lock; @@ -41534,7 +46556,7 @@ struct ext4_locality_group { }; struct ext4_li_request { - struct super_block___2 *lr_super; + struct super_block *lr_super; struct ext4_sb_info *lr_sbi; ext4_group_t lr_next_group; struct list_head lr_request; @@ -41542,6 +46564,8 @@ struct ext4_li_request { long unsigned int lr_timeout; }; +struct iomap_ops___2; + struct shash_desc { struct crypto_shash *tfm; void *__ctx[0]; @@ -41554,12 +46578,6 @@ struct ext4_map_blocks { unsigned int m_flags; }; -typedef enum { - EXT4_IGET_NORMAL = 0, - EXT4_IGET_SPECIAL = 1, - EXT4_IGET_HANDLE = 2, -} ext4_iget_flags; - struct ext4_system_zone { struct rb_node node; ext4_fsblk_t start_blk; @@ -41645,7 +46663,7 @@ struct ext4_io_end_vec { struct ext4_io_end { struct list_head list; handle_t *handle; - struct inode___2 *inode; + struct inode *inode; struct bio *bio; unsigned int flag; atomic_t count; @@ -41775,8 +46793,6 @@ struct ext4_fsmap_head { typedef int (*ext4_fsmap_format_t)(struct ext4_fsmap *, void *); -typedef int (*ext4_mballoc_query_range_fn)(struct super_block___2 *, ext4_group_t, ext4_grpblk_t, ext4_grpblk_t, void *); - struct ext4_getfsmap_info { struct ext4_fsmap_head *gfi_head; ext4_fsmap_format_t gfi_formatter; @@ -41792,7 +46808,7 @@ struct ext4_getfsmap_info { }; struct ext4_getfsmap_dev { - int (*gfd_fn)(struct super_block___2 *, struct ext4_fsmap *, struct ext4_getfsmap_info *); + int (*gfd_fn)(struct super_block *, struct ext4_fsmap *, struct ext4_getfsmap_info *); u32 gfd_dev; }; @@ -41925,6 +46941,8 @@ typedef __kernel_uid16_t uid16_t; typedef __kernel_gid16_t gid16_t; +typedef int get_block_t___2(struct inode *, sector_t, struct buffer_head *, int); + struct ext4_io_submit { struct writeback_control *io_wbc; struct bio *io_bio; @@ -41932,13 +46950,19 @@ struct ext4_io_submit { sector_t io_next_block; }; +typedef enum { + EXT4_IGET_NORMAL = 0, + EXT4_IGET_SPECIAL = 1, + EXT4_IGET_HANDLE = 2, +} ext4_iget_flags; + struct ext4_xattr_inode_array { unsigned int count; - struct inode___2 *inodes[0]; + struct inode *inodes[0]; }; struct mpage_da_data { - struct inode___2 *inode; + struct inode *inode; struct writeback_control *wbc; long unsigned int first_page; long unsigned int next_page; @@ -42010,7 +47034,7 @@ struct fsmap_head { }; struct getfsmap_info { - struct super_block___2 *gi_sb; + struct super_block *gi_sb; struct fsmap_head *gi_data; unsigned int gi_idx; __u32 gi_last_flags; @@ -42041,7 +47065,7 @@ struct ext4_prealloc_space { ext4_grpblk_t pa_free; short unsigned int pa_type; spinlock_t *pa_obj_lock; - struct inode___2 *pa_inode; + struct inode *pa_inode; }; enum { @@ -42057,8 +47081,8 @@ struct ext4_free_extent { }; struct ext4_allocation_context { - struct inode___2 *ac_inode; - struct super_block___2 *ac_sb; + struct inode *ac_inode; + struct super_block *ac_sb; struct ext4_free_extent ac_o_ex; struct ext4_free_extent ac_g_ex; struct ext4_free_extent ac_b_ex; @@ -42072,23 +47096,25 @@ struct ext4_allocation_context { __u8 ac_criteria; __u8 ac_2order; __u8 ac_op; - struct page___2 *ac_bitmap_page; - struct page___2 *ac_buddy_page; + struct page *ac_bitmap_page; + struct page *ac_buddy_page; struct ext4_prealloc_space *ac_pa; struct ext4_locality_group *ac_lg; }; struct ext4_buddy { - struct page___2 *bd_buddy_page; + struct page *bd_buddy_page; void *bd_buddy; - struct page___2 *bd_bitmap_page; + struct page *bd_bitmap_page; void *bd_bitmap; struct ext4_group_info *bd_info; - struct super_block___2 *bd_sb; + struct super_block *bd_sb; __u16 bd_blkbits; ext4_group_t bd_group; }; +typedef int (*ext4_mballoc_query_range_fn)(struct super_block *, ext4_group_t, ext4_grpblk_t, ext4_grpblk_t, void *); + struct sg { struct ext4_group_info info; ext4_grpblk_t counters[18]; @@ -42116,7 +47142,7 @@ struct mmp_struct { struct mmpd_data { struct buffer_head *bh; - struct super_block___2 *sb; + struct super_block *sb; }; struct fscrypt_name { @@ -42207,9 +47233,9 @@ struct dx_tail { }; struct ext4_renament { - struct inode___2 *dir; - struct dentry___2 *dentry; - struct inode___2 *inode; + struct inode *dir; + struct dentry *dentry; + struct inode *inode; bool is_dir; int dir_nlink_delta; struct buffer_head *bh; @@ -42260,7 +47286,7 @@ struct ext4_lazy_init { struct ext4_journal_cb_entry { struct list_head jce_list; - void (*jce_func)(struct super_block___2 *, struct ext4_journal_cb_entry *, int); + void (*jce_func)(struct super_block *, struct ext4_journal_cb_entry *, int); }; struct trace_event_raw_ext4_other_inode_update_time { @@ -43260,2330 +48286,1690 @@ struct trace_event_data_offsets_ext4_shutdown {}; struct trace_event_data_offsets_ext4_error {}; -enum { - Opt_bsd_df = 0, - Opt_minix_df = 1, - Opt_grpid = 2, - Opt_nogrpid = 3, - Opt_resgid = 4, - Opt_resuid = 5, - Opt_sb = 6, - Opt_err_cont = 7, - Opt_err_panic = 8, - Opt_err_ro = 9, - Opt_nouid32 = 10, - Opt_debug = 11, - Opt_removed = 12, - Opt_user_xattr = 13, - Opt_nouser_xattr = 14, - Opt_acl = 15, - Opt_noacl = 16, - Opt_auto_da_alloc = 17, - Opt_noauto_da_alloc = 18, - Opt_noload = 19, - Opt_commit = 20, - Opt_min_batch_time = 21, - Opt_max_batch_time = 22, - Opt_journal_dev = 23, - Opt_journal_path = 24, - Opt_journal_checksum = 25, - Opt_journal_async_commit = 26, - Opt_abort = 27, - Opt_data_journal = 28, - Opt_data_ordered = 29, - Opt_data_writeback = 30, - Opt_data_err_abort = 31, - Opt_data_err_ignore = 32, - Opt_test_dummy_encryption = 33, - Opt_usrjquota = 34, - Opt_grpjquota = 35, - Opt_offusrjquota = 36, - Opt_offgrpjquota = 37, - Opt_jqfmt_vfsold = 38, - Opt_jqfmt_vfsv0 = 39, - Opt_jqfmt_vfsv1 = 40, - Opt_quota = 41, - Opt_noquota = 42, - Opt_barrier = 43, - Opt_nobarrier = 44, - Opt_err___2 = 45, - Opt_usrquota = 46, - Opt_grpquota = 47, - Opt_prjquota = 48, - Opt_i_version = 49, - Opt_dax = 50, - Opt_stripe = 51, - Opt_delalloc = 52, - Opt_nodelalloc = 53, - Opt_warn_on_error = 54, - Opt_nowarn_on_error = 55, - Opt_mblk_io_submit = 56, - Opt_lazytime = 57, - Opt_nolazytime = 58, - Opt_debug_want_extra_isize = 59, - Opt_nomblk_io_submit = 60, - Opt_block_validity = 61, - Opt_noblock_validity = 62, - Opt_inode_readahead_blks = 63, - Opt_journal_ioprio = 64, - Opt_dioread_nolock = 65, - Opt_dioread_lock = 66, - Opt_discard = 67, - Opt_nodiscard = 68, - Opt_init_itable = 69, - Opt_noinit_itable = 70, - Opt_max_dir_size_kb = 71, - Opt_nojournal_checksum = 72, - Opt_nombcache = 73, -}; +typedef void (*btf_trace_ext4_other_inode_update_time)(void *, struct inode *, ino_t); -struct mount_opts { - int token; - int mount_opt; - int flags; -}; +typedef void (*btf_trace_ext4_free_inode)(void *, struct inode *); -struct ext4_mount_options { - long unsigned int s_mount_opt; - long unsigned int s_mount_opt2; - kuid_t s_resuid; - kgid_t s_resgid; - long unsigned int s_commit_interval; - u32 s_min_batch_time; - u32 s_max_batch_time; - int s_jquota_fmt; - char *s_qf_names[3]; -}; +typedef void (*btf_trace_ext4_request_inode)(void *, struct inode *, int); -enum { - attr_noop = 0, - attr_delayed_allocation_blocks = 1, - attr_session_write_kbytes = 2, - attr_lifetime_write_kbytes = 3, - attr_reserved_clusters = 4, - attr_inode_readahead = 5, - attr_trigger_test_error = 6, - attr_first_error_time = 7, - attr_last_error_time = 8, - attr_feature = 9, - attr_pointer_ui = 10, - attr_pointer_atomic = 11, - attr_journal_task = 12, -}; +typedef void (*btf_trace_ext4_allocate_inode)(void *, struct inode *, struct inode *, int); -enum { - ptr_explicit = 0, - ptr_ext4_sb_info_offset = 1, - ptr_ext4_super_block_offset = 2, -}; +typedef void (*btf_trace_ext4_evict_inode)(void *, struct inode *); -struct ext4_attr { - struct attribute attr; - short int attr_id; - short int attr_ptr; - union { - int offset; - void *explicit_ptr; - } u; -}; +typedef void (*btf_trace_ext4_drop_inode)(void *, struct inode *, int); -struct ext4_xattr_header { - __le32 h_magic; - __le32 h_refcount; - __le32 h_blocks; - __le32 h_hash; - __le32 h_checksum; - __u32 h_reserved[3]; -}; +typedef void (*btf_trace_ext4_nfs_commit_metadata)(void *, struct inode *); -struct ext4_xattr_block_find { - struct ext4_xattr_search s; - struct buffer_head *bh; -}; +typedef void (*btf_trace_ext4_mark_inode_dirty)(void *, struct inode *, long unsigned int); -typedef struct { - __le16 e_tag; - __le16 e_perm; - __le32 e_id; -} ext4_acl_entry; +typedef void (*btf_trace_ext4_begin_ordered_truncate)(void *, struct inode *, loff_t); -typedef struct { - __le32 a_version; -} ext4_acl_header; +typedef void (*btf_trace_ext4_write_begin)(void *, struct inode *, loff_t, unsigned int, unsigned int); -struct commit_header { - __be32 h_magic; - __be32 h_blocktype; - __be32 h_sequence; - unsigned char h_chksum_type; - unsigned char h_chksum_size; - unsigned char h_padding[2]; - __be32 h_chksum[8]; - __be64 h_commit_sec; - __be32 h_commit_nsec; -}; +typedef void (*btf_trace_ext4_da_write_begin)(void *, struct inode *, loff_t, unsigned int, unsigned int); -struct journal_block_tag3_s { - __be32 t_blocknr; - __be32 t_flags; - __be32 t_blocknr_high; - __be32 t_checksum; -}; +typedef void (*btf_trace_ext4_write_end)(void *, struct inode *, loff_t, unsigned int, unsigned int); -typedef struct journal_block_tag3_s journal_block_tag3_t; +typedef void (*btf_trace_ext4_journalled_write_end)(void *, struct inode *, loff_t, unsigned int, unsigned int); -struct journal_block_tag_s { - __be32 t_blocknr; - __be16 t_checksum; - __be16 t_flags; - __be32 t_blocknr_high; -}; +typedef void (*btf_trace_ext4_da_write_end)(void *, struct inode *, loff_t, unsigned int, unsigned int); -typedef struct journal_block_tag_s journal_block_tag_t; +typedef void (*btf_trace_ext4_writepages)(void *, struct inode *, struct writeback_control *); -struct jbd2_journal_block_tail { - __be32 t_checksum; -}; +typedef void (*btf_trace_ext4_da_write_pages)(void *, struct inode *, long unsigned int, struct writeback_control *); -struct jbd2_journal_revoke_header_s { - journal_header_t r_header; - __be32 r_count; -}; +typedef void (*btf_trace_ext4_da_write_pages_extent)(void *, struct inode *, struct ext4_map_blocks *); -typedef struct jbd2_journal_revoke_header_s jbd2_journal_revoke_header_t; +typedef void (*btf_trace_ext4_writepages_result)(void *, struct inode *, struct writeback_control *, int, int); -struct recovery_info { - tid_t start_transaction; - tid_t end_transaction; - int nr_replays; - int nr_revokes; - int nr_revoke_hits; -}; +typedef void (*btf_trace_ext4_writepage)(void *, struct page *); -enum passtype { - PASS_SCAN = 0, - PASS_REVOKE = 1, - PASS_REPLAY = 2, -}; +typedef void (*btf_trace_ext4_readpage)(void *, struct page *); -struct jbd2_revoke_table_s { - int hash_size; - int hash_shift; - struct list_head *hash_table; -}; +typedef void (*btf_trace_ext4_releasepage)(void *, struct page *); -struct jbd2_revoke_record_s { - struct list_head hash; - tid_t sequence; - long long unsigned int blocknr; -}; +typedef void (*btf_trace_ext4_invalidatepage)(void *, struct page *, unsigned int, unsigned int); -struct trace_event_raw_jbd2_checkpoint { - struct trace_entry ent; - dev_t dev; - int result; - char __data[0]; -}; +typedef void (*btf_trace_ext4_journalled_invalidatepage)(void *, struct page *, unsigned int, unsigned int); -struct trace_event_raw_jbd2_commit { - struct trace_entry ent; - dev_t dev; - char sync_commit; - int transaction; - char __data[0]; -}; +typedef void (*btf_trace_ext4_discard_blocks)(void *, struct super_block *, long long unsigned int, long long unsigned int); -struct trace_event_raw_jbd2_end_commit { - struct trace_entry ent; - dev_t dev; - char sync_commit; - int transaction; - int head; - char __data[0]; -}; +typedef void (*btf_trace_ext4_mb_new_inode_pa)(void *, struct ext4_allocation_context *, struct ext4_prealloc_space *); -struct trace_event_raw_jbd2_submit_inode_data { - struct trace_entry ent; - dev_t dev; - ino_t ino; - char __data[0]; -}; +typedef void (*btf_trace_ext4_mb_new_group_pa)(void *, struct ext4_allocation_context *, struct ext4_prealloc_space *); -struct trace_event_raw_jbd2_handle_start_class { - struct trace_entry ent; - dev_t dev; - long unsigned int tid; - unsigned int type; - unsigned int line_no; - int requested_blocks; - char __data[0]; -}; +typedef void (*btf_trace_ext4_mb_release_inode_pa)(void *, struct ext4_prealloc_space *, long long unsigned int, unsigned int); -struct trace_event_raw_jbd2_handle_extend { - struct trace_entry ent; - dev_t dev; - long unsigned int tid; - unsigned int type; - unsigned int line_no; - int buffer_credits; - int requested_blocks; - char __data[0]; -}; +typedef void (*btf_trace_ext4_mb_release_group_pa)(void *, struct super_block *, struct ext4_prealloc_space *); -struct trace_event_raw_jbd2_handle_stats { - struct trace_entry ent; - dev_t dev; - long unsigned int tid; - unsigned int type; - unsigned int line_no; - int interval; - int sync; - int requested_blocks; - int dirtied_blocks; - char __data[0]; -}; +typedef void (*btf_trace_ext4_discard_preallocations)(void *, struct inode *); -struct trace_event_raw_jbd2_run_stats { - struct trace_entry ent; - dev_t dev; - long unsigned int tid; - long unsigned int wait; - long unsigned int request_delay; - long unsigned int running; - long unsigned int locked; - long unsigned int flushing; - long unsigned int logging; - __u32 handle_count; - __u32 blocks; - __u32 blocks_logged; - char __data[0]; -}; +typedef void (*btf_trace_ext4_mb_discard_preallocations)(void *, struct super_block *, int); -struct trace_event_raw_jbd2_checkpoint_stats { - struct trace_entry ent; - dev_t dev; - long unsigned int tid; - long unsigned int chp_time; - __u32 forced_to_close; - __u32 written; - __u32 dropped; - char __data[0]; -}; +typedef void (*btf_trace_ext4_request_blocks)(void *, struct ext4_allocation_request *); -struct trace_event_raw_jbd2_update_log_tail { - struct trace_entry ent; - dev_t dev; - tid_t tail_sequence; - tid_t first_tid; - long unsigned int block_nr; - long unsigned int freed; - char __data[0]; -}; +typedef void (*btf_trace_ext4_allocate_blocks)(void *, struct ext4_allocation_request *, long long unsigned int); -struct trace_event_raw_jbd2_write_superblock { - struct trace_entry ent; - dev_t dev; - int write_op; - char __data[0]; -}; +typedef void (*btf_trace_ext4_free_blocks)(void *, struct inode *, __u64, long unsigned int, int); -struct trace_event_raw_jbd2_lock_buffer_stall { - struct trace_entry ent; - dev_t dev; - long unsigned int stall_ms; - char __data[0]; -}; +typedef void (*btf_trace_ext4_sync_file_enter)(void *, struct file *, int); -struct trace_event_data_offsets_jbd2_checkpoint {}; +typedef void (*btf_trace_ext4_sync_file_exit)(void *, struct inode *, int); -struct trace_event_data_offsets_jbd2_commit {}; +typedef void (*btf_trace_ext4_sync_fs)(void *, struct super_block *, int); -struct trace_event_data_offsets_jbd2_end_commit {}; +typedef void (*btf_trace_ext4_alloc_da_blocks)(void *, struct inode *); -struct trace_event_data_offsets_jbd2_submit_inode_data {}; +typedef void (*btf_trace_ext4_mballoc_alloc)(void *, struct ext4_allocation_context *); -struct trace_event_data_offsets_jbd2_handle_start_class {}; +typedef void (*btf_trace_ext4_mballoc_prealloc)(void *, struct ext4_allocation_context *); -struct trace_event_data_offsets_jbd2_handle_extend {}; +typedef void (*btf_trace_ext4_mballoc_discard)(void *, struct super_block *, struct inode *, ext4_group_t, ext4_grpblk_t, ext4_grpblk_t); -struct trace_event_data_offsets_jbd2_handle_stats {}; +typedef void (*btf_trace_ext4_mballoc_free)(void *, struct super_block *, struct inode *, ext4_group_t, ext4_grpblk_t, ext4_grpblk_t); -struct trace_event_data_offsets_jbd2_run_stats {}; +typedef void (*btf_trace_ext4_forget)(void *, struct inode *, int, __u64); -struct trace_event_data_offsets_jbd2_checkpoint_stats {}; +typedef void (*btf_trace_ext4_da_update_reserve_space)(void *, struct inode *, int, int); -struct trace_event_data_offsets_jbd2_update_log_tail {}; +typedef void (*btf_trace_ext4_da_reserve_space)(void *, struct inode *); + +typedef void (*btf_trace_ext4_da_release_space)(void *, struct inode *, int); + +typedef void (*btf_trace_ext4_mb_bitmap_load)(void *, struct super_block *, long unsigned int); + +typedef void (*btf_trace_ext4_mb_buddy_bitmap_load)(void *, struct super_block *, long unsigned int); + +typedef void (*btf_trace_ext4_read_block_bitmap_load)(void *, struct super_block *, long unsigned int); + +typedef void (*btf_trace_ext4_load_inode_bitmap)(void *, struct super_block *, long unsigned int); + +typedef void (*btf_trace_ext4_direct_IO_enter)(void *, struct inode *, loff_t, long unsigned int, int); + +typedef void (*btf_trace_ext4_direct_IO_exit)(void *, struct inode *, loff_t, long unsigned int, int, int); + +typedef void (*btf_trace_ext4_fallocate_enter)(void *, struct inode *, loff_t, loff_t, int); + +typedef void (*btf_trace_ext4_punch_hole)(void *, struct inode *, loff_t, loff_t, int); + +typedef void (*btf_trace_ext4_zero_range)(void *, struct inode *, loff_t, loff_t, int); + +typedef void (*btf_trace_ext4_fallocate_exit)(void *, struct inode *, loff_t, unsigned int, int); + +typedef void (*btf_trace_ext4_unlink_enter)(void *, struct inode *, struct dentry *); + +typedef void (*btf_trace_ext4_unlink_exit)(void *, struct dentry *, int); + +typedef void (*btf_trace_ext4_truncate_enter)(void *, struct inode *); + +typedef void (*btf_trace_ext4_truncate_exit)(void *, struct inode *); + +typedef void (*btf_trace_ext4_ext_convert_to_initialized_enter)(void *, struct inode *, struct ext4_map_blocks *, struct ext4_extent *); + +typedef void (*btf_trace_ext4_ext_convert_to_initialized_fastpath)(void *, struct inode *, struct ext4_map_blocks *, struct ext4_extent *, struct ext4_extent *); + +typedef void (*btf_trace_ext4_ext_map_blocks_enter)(void *, struct inode *, ext4_lblk_t, unsigned int, unsigned int); + +typedef void (*btf_trace_ext4_ind_map_blocks_enter)(void *, struct inode *, ext4_lblk_t, unsigned int, unsigned int); + +typedef void (*btf_trace_ext4_ext_map_blocks_exit)(void *, struct inode *, unsigned int, struct ext4_map_blocks *, int); + +typedef void (*btf_trace_ext4_ind_map_blocks_exit)(void *, struct inode *, unsigned int, struct ext4_map_blocks *, int); + +typedef void (*btf_trace_ext4_ext_load_extent)(void *, struct inode *, ext4_lblk_t, ext4_fsblk_t); -struct trace_event_data_offsets_jbd2_write_superblock {}; +typedef void (*btf_trace_ext4_load_inode)(void *, struct inode *); -struct trace_event_data_offsets_jbd2_lock_buffer_stall {}; +typedef void (*btf_trace_ext4_journal_start)(void *, struct super_block *, int, int, int, long unsigned int); -struct jbd2_stats_proc_session { - journal_t *journal; - struct transaction_stats_s *stats; - int start; - int max; -}; +typedef void (*btf_trace_ext4_journal_start_reserved)(void *, struct super_block *, int, long unsigned int); -struct ramfs_mount_opts { - umode_t mode; -}; +typedef void (*btf_trace_ext4_trim_extent)(void *, struct super_block *, ext4_group_t, ext4_grpblk_t, ext4_grpblk_t); -struct ramfs_fs_info { - struct ramfs_mount_opts mount_opts; -}; +typedef void (*btf_trace_ext4_trim_all_free)(void *, struct super_block *, ext4_group_t, ext4_grpblk_t, ext4_grpblk_t); -enum ramfs_param { - Opt_mode___3 = 0, -}; +typedef void (*btf_trace_ext4_ext_handle_unwritten_extents)(void *, struct inode *, struct ext4_map_blocks *, int, unsigned int, ext4_fsblk_t); -enum hugetlbfs_size_type { - NO_SIZE = 0, - SIZE_STD = 1, - SIZE_PERCENT = 2, -}; +typedef void (*btf_trace_ext4_get_implied_cluster_alloc_exit)(void *, struct super_block *, struct ext4_map_blocks *, int); -struct hugetlbfs_fs_context { - struct hstate *hstate; - long long unsigned int max_size_opt; - long long unsigned int min_size_opt; - long int max_hpages; - long int nr_inodes; - long int min_hpages; - enum hugetlbfs_size_type max_val_type; - enum hugetlbfs_size_type min_val_type; - kuid_t uid; - kgid_t gid; - umode_t mode; -}; +typedef void (*btf_trace_ext4_ext_put_in_cache)(void *, struct inode *, ext4_lblk_t, unsigned int, ext4_fsblk_t); -enum hugetlb_param { - Opt_gid___4 = 0, - Opt_min_size = 1, - Opt_mode___4 = 2, - Opt_nr_inodes___2 = 3, - Opt_pagesize = 4, - Opt_size___2 = 5, - Opt_uid___3 = 6, -}; +typedef void (*btf_trace_ext4_ext_in_cache)(void *, struct inode *, ext4_lblk_t, int); -typedef u16 wchar_t; +typedef void (*btf_trace_ext4_find_delalloc_range)(void *, struct inode *, ext4_lblk_t, ext4_lblk_t, int, int, ext4_lblk_t); -struct nls_table { - const char *charset; - const char *alias; - int (*uni2char)(wchar_t, unsigned char *, int); - int (*char2uni)(const unsigned char *, int, wchar_t *); - const unsigned char *charset2lower; - const unsigned char *charset2upper; - struct module *owner; - struct nls_table *next; -}; +typedef void (*btf_trace_ext4_get_reserved_cluster_alloc)(void *, struct inode *, ext4_lblk_t, unsigned int); -struct fat_mount_options { - kuid_t fs_uid; - kgid_t fs_gid; - short unsigned int fs_fmask; - short unsigned int fs_dmask; - short unsigned int codepage; - int time_offset; - char *iocharset; - short unsigned int shortname; - unsigned char name_check; - unsigned char errors; - unsigned char nfs; - short unsigned int allow_utime; - unsigned int quiet: 1; - unsigned int showexec: 1; - unsigned int sys_immutable: 1; - unsigned int dotsOK: 1; - unsigned int isvfat: 1; - unsigned int utf8: 1; - unsigned int unicode_xlate: 1; - unsigned int numtail: 1; - unsigned int flush: 1; - unsigned int nocase: 1; - unsigned int usefree: 1; - unsigned int tz_set: 1; - unsigned int rodir: 1; - unsigned int discard: 1; - unsigned int dos1xfloppy: 1; -}; +typedef void (*btf_trace_ext4_ext_show_extent)(void *, struct inode *, ext4_lblk_t, ext4_fsblk_t, short unsigned int); -struct fatent_operations; +typedef void (*btf_trace_ext4_remove_blocks)(void *, struct inode *, struct ext4_extent *, ext4_lblk_t, ext4_fsblk_t, struct partial_cluster *); -struct msdos_sb_info { - short unsigned int sec_per_clus; - short unsigned int cluster_bits; - unsigned int cluster_size; - unsigned char fats; - unsigned char fat_bits; - short unsigned int fat_start; - long unsigned int fat_length; - long unsigned int dir_start; - short unsigned int dir_entries; - long unsigned int data_start; - long unsigned int max_cluster; - long unsigned int root_cluster; - long unsigned int fsinfo_sector; - struct mutex fat_lock; - struct mutex nfs_build_inode_lock; - struct mutex s_lock; - unsigned int prev_free; - unsigned int free_clusters; - unsigned int free_clus_valid; - struct fat_mount_options options; - struct nls_table *nls_disk; - struct nls_table *nls_io; - const void *dir_ops; - int dir_per_block; - int dir_per_block_bits; - unsigned int vol_id; - int fatent_shift; - const struct fatent_operations *fatent_ops; - struct inode___2 *fat_inode; - struct inode___2 *fsinfo_inode; - struct ratelimit_state ratelimit; - spinlock_t inode_hash_lock; - struct hlist_head inode_hashtable[256]; - spinlock_t dir_hash_lock; - struct hlist_head dir_hashtable[256]; - unsigned int dirty; - struct callback_head rcu; -}; +typedef void (*btf_trace_ext4_ext_rm_leaf)(void *, struct inode *, ext4_lblk_t, struct ext4_extent *, struct partial_cluster *); -struct fat_entry; +typedef void (*btf_trace_ext4_ext_rm_idx)(void *, struct inode *, ext4_fsblk_t); -struct fatent_operations { - void (*ent_blocknr)(struct super_block___2 *, int, int *, sector_t *); - void (*ent_set_ptr)(struct fat_entry *, int); - int (*ent_bread)(struct super_block___2 *, struct fat_entry *, int, sector_t); - int (*ent_get)(struct fat_entry *); - void (*ent_put)(struct fat_entry *, int); - int (*ent_next)(struct fat_entry *); -}; +typedef void (*btf_trace_ext4_ext_remove_space)(void *, struct inode *, ext4_lblk_t, ext4_lblk_t, int); -struct msdos_inode_info { - spinlock_t cache_lru_lock; - struct list_head cache_lru; - int nr_caches; - unsigned int cache_valid_id; - loff_t mmu_private; - int i_start; - int i_logstart; - int i_attrs; - loff_t i_pos; - struct hlist_node i_fat_hash; - struct hlist_node i_dir_hash; - struct rw_semaphore truncate_lock; - struct inode___2 vfs_inode; -}; +typedef void (*btf_trace_ext4_ext_remove_space_done)(void *, struct inode *, ext4_lblk_t, ext4_lblk_t, int, struct partial_cluster *, __le16); -struct fat_entry { - int entry; - union { - u8 *ent12_p[2]; - __le16 *ent16_p; - __le32 *ent32_p; - } u; - int nr_bhs; - struct buffer_head *bhs[2]; - struct inode___2 *fat_inode; -}; +typedef void (*btf_trace_ext4_es_insert_extent)(void *, struct inode *, struct extent_status *); -struct fat_cache { - struct list_head cache_list; - int nr_contig; - int fcluster; - int dcluster; -}; +typedef void (*btf_trace_ext4_es_cache_extent)(void *, struct inode *, struct extent_status *); -struct fat_cache_id { - unsigned int id; - int nr_contig; - int fcluster; - int dcluster; -}; +typedef void (*btf_trace_ext4_es_remove_extent)(void *, struct inode *, ext4_lblk_t, ext4_lblk_t); -struct compat_dirent { - u32 d_ino; - compat_off_t d_off; - u16 d_reclen; - char d_name[256]; -}; +typedef void (*btf_trace_ext4_es_find_extent_range_enter)(void *, struct inode *, ext4_lblk_t); -enum utf16_endian { - UTF16_HOST_ENDIAN = 0, - UTF16_LITTLE_ENDIAN = 1, - UTF16_BIG_ENDIAN = 2, -}; +typedef void (*btf_trace_ext4_es_find_extent_range_exit)(void *, struct inode *, struct extent_status *); -struct __fat_dirent { - long int d_ino; - __kernel_off_t d_off; - short unsigned int d_reclen; - char d_name[256]; -}; +typedef void (*btf_trace_ext4_es_lookup_extent_enter)(void *, struct inode *, ext4_lblk_t); -struct msdos_dir_entry { - __u8 name[11]; - __u8 attr; - __u8 lcase; - __u8 ctime_cs; - __le16 ctime; - __le16 cdate; - __le16 adate; - __le16 starthi; - __le16 time; - __le16 date; - __le16 start; - __le32 size; -}; +typedef void (*btf_trace_ext4_es_lookup_extent_exit)(void *, struct inode *, struct extent_status *, int); -struct msdos_dir_slot { - __u8 id; - __u8 name0_4[10]; - __u8 attr; - __u8 reserved; - __u8 alias_checksum; - __u8 name5_10[12]; - __le16 start; - __u8 name11_12[4]; -}; +typedef void (*btf_trace_ext4_es_shrink_count)(void *, struct super_block *, int, int); -struct fat_slot_info { - loff_t i_pos; - loff_t slot_off; - int nr_slots; - struct msdos_dir_entry *de; - struct buffer_head *bh; -}; +typedef void (*btf_trace_ext4_es_shrink_scan_enter)(void *, struct super_block *, int, int); -typedef long long unsigned int llu; +typedef void (*btf_trace_ext4_es_shrink_scan_exit)(void *, struct super_block *, int, int); -enum { - PARSE_INVALID = 1, - PARSE_NOT_LONGNAME = 2, - PARSE_EOF = 3, -}; +typedef void (*btf_trace_ext4_collapse_range)(void *, struct inode *, loff_t, loff_t); -struct fat_ioctl_filldir_callback { - struct dir_context ctx; - void *dirent; - int result; - const char *longname; - int long_len; - const char *shortname; - int short_len; -}; +typedef void (*btf_trace_ext4_insert_range)(void *, struct inode *, loff_t, loff_t); -struct fat_boot_sector { - __u8 ignored[3]; - __u8 system_id[8]; - __u8 sector_size[2]; - __u8 sec_per_clus; - __le16 reserved; - __u8 fats; - __u8 dir_entries[2]; - __u8 sectors[2]; - __u8 media; - __le16 fat_length; - __le16 secs_track; - __le16 heads; - __le32 hidden; - __le32 total_sect; - union { - struct { - __u8 drive_number; - __u8 state; - __u8 signature; - __u8 vol_id[4]; - __u8 vol_label[11]; - __u8 fs_type[8]; - } fat16; - struct { - __le32 length; - __le16 flags; - __u8 version[2]; - __le32 root_cluster; - __le16 info_sector; - __le16 backup_boot; - __le16 reserved2[6]; - __u8 drive_number; - __u8 state; - __u8 signature; - __u8 vol_id[4]; - __u8 vol_label[11]; - __u8 fs_type[8]; - } fat32; - }; -}; +typedef void (*btf_trace_ext4_es_shrink)(void *, struct super_block *, int, u64, int, int); -struct fat_boot_fsinfo { - __le32 signature1; - __le32 reserved1[120]; - __le32 signature2; - __le32 free_clusters; - __le32 next_cluster; - __le32 reserved2[4]; -}; +typedef void (*btf_trace_ext4_es_insert_delayed_block)(void *, struct inode *, struct extent_status *, bool); -struct fat_bios_param_block { - u16 fat_sector_size; - u8 fat_sec_per_clus; - u16 fat_reserved; - u8 fat_fats; - u16 fat_dir_entries; - u16 fat_sectors; - u16 fat_fat_length; - u32 fat_total_sect; - u8 fat16_state; - u32 fat16_vol_id; - u32 fat32_length; - u32 fat32_root_cluster; - u16 fat32_info_sector; - u8 fat32_state; - u32 fat32_vol_id; -}; +typedef void (*btf_trace_ext4_fsmap_low_key)(void *, struct super_block *, u32, u32, u64, u64, u64); -struct fat_floppy_defaults { - unsigned int nr_sectors; - unsigned int sec_per_clus; - unsigned int dir_entries; - unsigned int media; - unsigned int fat_length; -}; +typedef void (*btf_trace_ext4_fsmap_high_key)(void *, struct super_block *, u32, u32, u64, u64, u64); -enum { - Opt_check_n = 0, - Opt_check_r = 1, - Opt_check_s = 2, - Opt_uid___4 = 3, - Opt_gid___5 = 4, - Opt_umask = 5, - Opt_dmask = 6, - Opt_fmask = 7, - Opt_allow_utime = 8, - Opt_codepage = 9, - Opt_usefree = 10, - Opt_nocase = 11, - Opt_quiet = 12, - Opt_showexec = 13, - Opt_debug___2 = 14, - Opt_immutable = 15, - Opt_dots = 16, - Opt_nodots = 17, - Opt_charset = 18, - Opt_shortname_lower = 19, - Opt_shortname_win95 = 20, - Opt_shortname_winnt = 21, - Opt_shortname_mixed = 22, - Opt_utf8_no = 23, - Opt_utf8_yes = 24, - Opt_uni_xl_no = 25, - Opt_uni_xl_yes = 26, - Opt_nonumtail_no = 27, - Opt_nonumtail_yes = 28, - Opt_obsolete = 29, - Opt_flush = 30, - Opt_tz_utc = 31, - Opt_rodir = 32, - Opt_err_cont___2 = 33, - Opt_err_panic___2 = 34, - Opt_err_ro___2 = 35, - Opt_discard___2 = 36, - Opt_nfs = 37, - Opt_time_offset = 38, - Opt_nfs_stale_rw = 39, - Opt_nfs_nostale_ro = 40, - Opt_err___3 = 41, - Opt_dos1xfloppy = 42, -}; +typedef void (*btf_trace_ext4_fsmap_mapping)(void *, struct super_block *, u32, u32, u64, u64, u64); -struct fat_fid { - u32 i_gen; - u32 i_pos_low; - u16 i_pos_hi; - u16 parent_i_pos_hi; - u32 parent_i_pos_low; - u32 parent_i_gen; -}; +typedef void (*btf_trace_ext4_getfsmap_low_key)(void *, struct super_block *, struct ext4_fsmap *); -struct shortname_info { - unsigned char lower: 1; - unsigned char upper: 1; - unsigned char valid: 1; -}; +typedef void (*btf_trace_ext4_getfsmap_high_key)(void *, struct super_block *, struct ext4_fsmap *); -struct iso_directory_record { - __u8 length[1]; - __u8 ext_attr_length[1]; - __u8 extent[8]; - __u8 size[8]; - __u8 date[7]; - __u8 flags[1]; - __u8 file_unit_size[1]; - __u8 interleave[1]; - __u8 volume_sequence_number[4]; - __u8 name_len[1]; - char name[0]; -}; +typedef void (*btf_trace_ext4_getfsmap_mapping)(void *, struct super_block *, struct ext4_fsmap *); -struct iso_inode_info { - long unsigned int i_iget5_block; - long unsigned int i_iget5_offset; - unsigned int i_first_extent; - unsigned char i_file_format; - unsigned char i_format_parm[3]; - long unsigned int i_next_section_block; - long unsigned int i_next_section_offset; - off_t i_section_size; - struct inode___2 vfs_inode; -}; +typedef void (*btf_trace_ext4_shutdown)(void *, struct super_block *, long unsigned int); -struct isofs_sb_info { - long unsigned int s_ninodes; - long unsigned int s_nzones; - long unsigned int s_firstdatazone; - long unsigned int s_log_zone_size; - long unsigned int s_max_size; - int s_rock_offset; - s32 s_sbsector; - unsigned char s_joliet_level; - unsigned char s_mapping; - unsigned char s_check; - unsigned char s_session; - unsigned int s_high_sierra: 1; - unsigned int s_rock: 2; - unsigned int s_utf8: 1; - unsigned int s_cruft: 1; - unsigned int s_nocompress: 1; - unsigned int s_hide: 1; - unsigned int s_showassoc: 1; - unsigned int s_overriderockperm: 1; - unsigned int s_uid_set: 1; - unsigned int s_gid_set: 1; - umode_t s_fmode; - umode_t s_dmode; - kgid_t s_gid; - kuid_t s_uid; - struct nls_table *s_nls_iocharset; -}; +typedef void (*btf_trace_ext4_error)(void *, struct super_block *, const char *, unsigned int); -struct cdrom_msf0 { - __u8 minute; - __u8 second; - __u8 frame; +enum { + Opt_bsd_df = 0, + Opt_minix_df = 1, + Opt_grpid = 2, + Opt_nogrpid = 3, + Opt_resgid = 4, + Opt_resuid = 5, + Opt_sb = 6, + Opt_err_cont = 7, + Opt_err_panic = 8, + Opt_err_ro = 9, + Opt_nouid32 = 10, + Opt_debug = 11, + Opt_removed = 12, + Opt_user_xattr = 13, + Opt_nouser_xattr = 14, + Opt_acl = 15, + Opt_noacl = 16, + Opt_auto_da_alloc = 17, + Opt_noauto_da_alloc = 18, + Opt_noload = 19, + Opt_commit = 20, + Opt_min_batch_time = 21, + Opt_max_batch_time = 22, + Opt_journal_dev = 23, + Opt_journal_path = 24, + Opt_journal_checksum = 25, + Opt_journal_async_commit = 26, + Opt_abort = 27, + Opt_data_journal = 28, + Opt_data_ordered = 29, + Opt_data_writeback = 30, + Opt_data_err_abort = 31, + Opt_data_err_ignore = 32, + Opt_test_dummy_encryption = 33, + Opt_usrjquota = 34, + Opt_grpjquota = 35, + Opt_offusrjquota = 36, + Opt_offgrpjquota = 37, + Opt_jqfmt_vfsold = 38, + Opt_jqfmt_vfsv0 = 39, + Opt_jqfmt_vfsv1 = 40, + Opt_quota = 41, + Opt_noquota = 42, + Opt_barrier = 43, + Opt_nobarrier = 44, + Opt_err___2 = 45, + Opt_usrquota = 46, + Opt_grpquota = 47, + Opt_prjquota = 48, + Opt_i_version = 49, + Opt_dax = 50, + Opt_stripe = 51, + Opt_delalloc = 52, + Opt_nodelalloc = 53, + Opt_warn_on_error = 54, + Opt_nowarn_on_error = 55, + Opt_mblk_io_submit = 56, + Opt_lazytime = 57, + Opt_nolazytime = 58, + Opt_debug_want_extra_isize = 59, + Opt_nomblk_io_submit = 60, + Opt_block_validity = 61, + Opt_noblock_validity = 62, + Opt_inode_readahead_blks = 63, + Opt_journal_ioprio = 64, + Opt_dioread_nolock = 65, + Opt_dioread_lock = 66, + Opt_discard = 67, + Opt_nodiscard = 68, + Opt_init_itable = 69, + Opt_noinit_itable = 70, + Opt_max_dir_size_kb = 71, + Opt_nojournal_checksum = 72, + Opt_nombcache = 73, }; -union cdrom_addr { - struct cdrom_msf0 msf; - int lba; +struct mount_opts { + int token; + int mount_opt; + int flags; }; -struct cdrom_tocentry { - __u8 cdte_track; - __u8 cdte_adr: 4; - __u8 cdte_ctrl: 4; - __u8 cdte_format; - union cdrom_addr cdte_addr; - __u8 cdte_datamode; +struct ext4_mount_options { + long unsigned int s_mount_opt; + long unsigned int s_mount_opt2; + kuid_t s_resuid; + kgid_t s_resgid; + long unsigned int s_commit_interval; + u32 s_min_batch_time; + u32 s_max_batch_time; + int s_jquota_fmt; + char *s_qf_names[3]; }; -struct cdrom_multisession { - union cdrom_addr addr; - __u8 xa_flag; - __u8 addr_format; +enum { + attr_noop = 0, + attr_delayed_allocation_blocks = 1, + attr_session_write_kbytes = 2, + attr_lifetime_write_kbytes = 3, + attr_reserved_clusters = 4, + attr_inode_readahead = 5, + attr_trigger_test_error = 6, + attr_first_error_time = 7, + attr_last_error_time = 8, + attr_feature = 9, + attr_pointer_ui = 10, + attr_pointer_atomic = 11, + attr_journal_task = 12, }; -struct iso_volume_descriptor { - __u8 type[1]; - char id[5]; - __u8 version[1]; - __u8 data[2041]; +enum { + ptr_explicit = 0, + ptr_ext4_sb_info_offset = 1, + ptr_ext4_super_block_offset = 2, }; -struct iso_primary_descriptor { - __u8 type[1]; - char id[5]; - __u8 version[1]; - __u8 unused1[1]; - char system_id[32]; - char volume_id[32]; - __u8 unused2[8]; - __u8 volume_space_size[8]; - __u8 unused3[32]; - __u8 volume_set_size[4]; - __u8 volume_sequence_number[4]; - __u8 logical_block_size[4]; - __u8 path_table_size[8]; - __u8 type_l_path_table[4]; - __u8 opt_type_l_path_table[4]; - __u8 type_m_path_table[4]; - __u8 opt_type_m_path_table[4]; - __u8 root_directory_record[34]; - char volume_set_id[128]; - char publisher_id[128]; - char preparer_id[128]; - char application_id[128]; - char copyright_file_id[37]; - char abstract_file_id[37]; - char bibliographic_file_id[37]; - __u8 creation_date[17]; - __u8 modification_date[17]; - __u8 expiration_date[17]; - __u8 effective_date[17]; - __u8 file_structure_version[1]; - __u8 unused4[1]; - __u8 application_data[512]; - __u8 unused5[653]; +struct ext4_attr { + struct attribute attr; + short int attr_id; + short int attr_ptr; + union { + int offset; + void *explicit_ptr; + } u; }; -struct iso_supplementary_descriptor { - __u8 type[1]; - char id[5]; - __u8 version[1]; - __u8 flags[1]; - char system_id[32]; - char volume_id[32]; - __u8 unused2[8]; - __u8 volume_space_size[8]; - __u8 escape[32]; - __u8 volume_set_size[4]; - __u8 volume_sequence_number[4]; - __u8 logical_block_size[4]; - __u8 path_table_size[8]; - __u8 type_l_path_table[4]; - __u8 opt_type_l_path_table[4]; - __u8 type_m_path_table[4]; - __u8 opt_type_m_path_table[4]; - __u8 root_directory_record[34]; - char volume_set_id[128]; - char publisher_id[128]; - char preparer_id[128]; - char application_id[128]; - char copyright_file_id[37]; - char abstract_file_id[37]; - char bibliographic_file_id[37]; - __u8 creation_date[17]; - __u8 modification_date[17]; - __u8 expiration_date[17]; - __u8 effective_date[17]; - __u8 file_structure_version[1]; - __u8 unused4[1]; - __u8 application_data[512]; - __u8 unused5[653]; +struct ext4_xattr_header { + __le32 h_magic; + __le32 h_refcount; + __le32 h_blocks; + __le32 h_hash; + __le32 h_checksum; + __u32 h_reserved[3]; }; -struct hs_volume_descriptor { - __u8 foo[8]; - __u8 type[1]; - char id[5]; - __u8 version[1]; - __u8 data[2033]; +struct ext4_xattr_block_find { + struct ext4_xattr_search s; + struct buffer_head *bh; }; -struct hs_primary_descriptor { - __u8 foo[8]; - __u8 type[1]; - __u8 id[5]; - __u8 version[1]; - __u8 unused1[1]; - char system_id[32]; - char volume_id[32]; - __u8 unused2[8]; - __u8 volume_space_size[8]; - __u8 unused3[32]; - __u8 volume_set_size[4]; - __u8 volume_sequence_number[4]; - __u8 logical_block_size[4]; - __u8 path_table_size[8]; - __u8 type_l_path_table[4]; - __u8 unused4[28]; - __u8 root_directory_record[34]; -}; +typedef struct { + __le16 e_tag; + __le16 e_perm; + __le32 e_id; +} ext4_acl_entry; -enum isofs_file_format { - isofs_file_normal = 0, - isofs_file_sparse = 1, - isofs_file_compressed = 2, -}; +typedef struct { + __le32 a_version; +} ext4_acl_header; -struct iso9660_options { - unsigned int rock: 1; - unsigned int joliet: 1; - unsigned int cruft: 1; - unsigned int hide: 1; - unsigned int showassoc: 1; - unsigned int nocompress: 1; - unsigned int overriderockperm: 1; - unsigned int uid_set: 1; - unsigned int gid_set: 1; - unsigned int utf8: 1; - unsigned char map; - unsigned char check; - unsigned int blocksize; - umode_t fmode; - umode_t dmode; - kgid_t gid; - kuid_t uid; - char *iocharset; - s32 session; - s32 sbsector; +struct commit_header { + __be32 h_magic; + __be32 h_blocktype; + __be32 h_sequence; + unsigned char h_chksum_type; + unsigned char h_chksum_size; + unsigned char h_padding[2]; + __be32 h_chksum[8]; + __be64 h_commit_sec; + __be32 h_commit_nsec; }; -enum { - Opt_block = 0, - Opt_check_r___2 = 1, - Opt_check_s___2 = 2, - Opt_cruft = 3, - Opt_gid___6 = 4, - Opt_ignore = 5, - Opt_iocharset = 6, - Opt_map_a = 7, - Opt_map_n = 8, - Opt_map_o = 9, - Opt_mode___5 = 10, - Opt_nojoliet = 11, - Opt_norock = 12, - Opt_sb___2 = 13, - Opt_session = 14, - Opt_uid___5 = 15, - Opt_unhide = 16, - Opt_utf8 = 17, - Opt_err___4 = 18, - Opt_nocompress = 19, - Opt_hide = 20, - Opt_showassoc = 21, - Opt_dmode = 22, - Opt_overriderockperm = 23, +struct journal_block_tag3_s { + __be32 t_blocknr; + __be32 t_flags; + __be32 t_blocknr_high; + __be32 t_checksum; }; -struct isofs_iget5_callback_data { - long unsigned int block; - long unsigned int offset; -}; +typedef struct journal_block_tag3_s journal_block_tag3_t; -struct SU_SP_s { - __u8 magic[2]; - __u8 skip; +struct journal_block_tag_s { + __be32 t_blocknr; + __be16 t_checksum; + __be16 t_flags; + __be32 t_blocknr_high; }; -struct SU_CE_s { - __u8 extent[8]; - __u8 offset[8]; - __u8 size[8]; -}; +typedef struct journal_block_tag_s journal_block_tag_t; -struct SU_ER_s { - __u8 len_id; - __u8 len_des; - __u8 len_src; - __u8 ext_ver; - __u8 data[0]; +struct jbd2_journal_block_tail { + __be32 t_checksum; }; -struct RR_RR_s { - __u8 flags[1]; +struct jbd2_journal_revoke_header_s { + journal_header_t r_header; + __be32 r_count; }; -struct RR_PX_s { - __u8 mode[8]; - __u8 n_links[8]; - __u8 uid[8]; - __u8 gid[8]; -}; +typedef struct jbd2_journal_revoke_header_s jbd2_journal_revoke_header_t; -struct RR_PN_s { - __u8 dev_high[8]; - __u8 dev_low[8]; +struct recovery_info { + tid_t start_transaction; + tid_t end_transaction; + int nr_replays; + int nr_revokes; + int nr_revoke_hits; }; -struct SL_component { - __u8 flags; - __u8 len; - __u8 text[0]; +enum passtype { + PASS_SCAN = 0, + PASS_REVOKE = 1, + PASS_REPLAY = 2, }; -struct RR_SL_s { - __u8 flags; - struct SL_component link; +struct jbd2_revoke_table_s { + int hash_size; + int hash_shift; + struct list_head *hash_table; }; -struct RR_NM_s { - __u8 flags; - char name[0]; +struct jbd2_revoke_record_s { + struct list_head hash; + tid_t sequence; + long long unsigned int blocknr; }; -struct RR_CL_s { - __u8 location[8]; +struct trace_event_raw_jbd2_checkpoint { + struct trace_entry ent; + dev_t dev; + int result; + char __data[0]; }; -struct RR_PL_s { - __u8 location[8]; +struct trace_event_raw_jbd2_commit { + struct trace_entry ent; + dev_t dev; + char sync_commit; + int transaction; + char __data[0]; }; -struct stamp { - __u8 time[7]; +struct trace_event_raw_jbd2_end_commit { + struct trace_entry ent; + dev_t dev; + char sync_commit; + int transaction; + int head; + char __data[0]; }; -struct RR_TF_s { - __u8 flags; - struct stamp times[0]; +struct trace_event_raw_jbd2_submit_inode_data { + struct trace_entry ent; + dev_t dev; + ino_t ino; + char __data[0]; }; -struct RR_ZF_s { - __u8 algorithm[2]; - __u8 parms[2]; - __u8 real_size[8]; +struct trace_event_raw_jbd2_handle_start_class { + struct trace_entry ent; + dev_t dev; + long unsigned int tid; + unsigned int type; + unsigned int line_no; + int requested_blocks; + char __data[0]; }; -struct rock_ridge { - __u8 signature[2]; - __u8 len; - __u8 version; - union { - struct SU_SP_s SP; - struct SU_CE_s CE; - struct SU_ER_s ER; - struct RR_RR_s RR; - struct RR_PX_s PX; - struct RR_PN_s PN; - struct RR_SL_s SL; - struct RR_NM_s NM; - struct RR_CL_s CL; - struct RR_PL_s PL; - struct RR_TF_s TF; - struct RR_ZF_s ZF; - } u; +struct trace_event_raw_jbd2_handle_extend { + struct trace_entry ent; + dev_t dev; + long unsigned int tid; + unsigned int type; + unsigned int line_no; + int buffer_credits; + int requested_blocks; + char __data[0]; }; -struct rock_state { - void *buffer; - unsigned char *chr; - int len; - int cont_size; - int cont_extent; - int cont_offset; - int cont_loops; - struct inode___2 *inode; +struct trace_event_raw_jbd2_handle_stats { + struct trace_entry ent; + dev_t dev; + long unsigned int tid; + unsigned int type; + unsigned int line_no; + int interval; + int sync; + int requested_blocks; + int dirtied_blocks; + char __data[0]; }; -struct isofs_fid { - u32 block; - u16 offset; - u16 parent_offset; - u32 generation; - u32 parent_block; - u32 parent_generation; +struct trace_event_raw_jbd2_run_stats { + struct trace_entry ent; + dev_t dev; + long unsigned int tid; + long unsigned int wait; + long unsigned int request_delay; + long unsigned int running; + long unsigned int locked; + long unsigned int flushing; + long unsigned int logging; + __u32 handle_count; + __u32 blocks; + __u32 blocks_logged; + char __data[0]; }; -typedef unsigned char Byte; - -typedef long unsigned int uLong; - -struct internal_state; +struct trace_event_raw_jbd2_checkpoint_stats { + struct trace_entry ent; + dev_t dev; + long unsigned int tid; + long unsigned int chp_time; + __u32 forced_to_close; + __u32 written; + __u32 dropped; + char __data[0]; +}; -struct z_stream_s { - const Byte *next_in; - uLong avail_in; - uLong total_in; - Byte *next_out; - uLong avail_out; - uLong total_out; - char *msg; - struct internal_state *state; - void *workspace; - int data_type; - uLong adler; - uLong reserved; +struct trace_event_raw_jbd2_update_log_tail { + struct trace_entry ent; + dev_t dev; + tid_t tail_sequence; + tid_t first_tid; + long unsigned int block_nr; + long unsigned int freed; + char __data[0]; }; -struct internal_state { - int dummy; +struct trace_event_raw_jbd2_write_superblock { + struct trace_entry ent; + dev_t dev; + int write_op; + char __data[0]; }; -typedef struct z_stream_s z_stream; +struct trace_event_raw_jbd2_lock_buffer_stall { + struct trace_entry ent; + dev_t dev; + long unsigned int stall_ms; + char __data[0]; +}; -typedef z_stream *z_streamp; +struct trace_event_data_offsets_jbd2_checkpoint {}; -typedef __kernel_old_time_t time_t; +struct trace_event_data_offsets_jbd2_commit {}; -struct rpc_timer { - struct list_head list; - long unsigned int expires; - struct delayed_work dwork; -}; +struct trace_event_data_offsets_jbd2_end_commit {}; -struct rpc_wait_queue { - spinlock_t lock; - struct list_head tasks[4]; - unsigned char maxpriority; - unsigned char priority; - unsigned char nr; - short unsigned int qlen; - struct rpc_timer timer_list; - const char *name; -}; +struct trace_event_data_offsets_jbd2_submit_inode_data {}; -struct nfs_seqid_counter { - ktime_t create_time; - int owner_id; - int flags; - u32 counter; - spinlock_t lock; - struct list_head list; - struct rpc_wait_queue wait; -}; +struct trace_event_data_offsets_jbd2_handle_start_class {}; -struct nfs4_stateid_struct { - union { - char data[16]; - struct { - __be32 seqid; - char other[12]; - }; - }; - enum { - NFS4_INVALID_STATEID_TYPE = 0, - NFS4_SPECIAL_STATEID_TYPE = 1, - NFS4_OPEN_STATEID_TYPE = 2, - NFS4_LOCK_STATEID_TYPE = 3, - NFS4_DELEGATION_STATEID_TYPE = 4, - NFS4_LAYOUT_STATEID_TYPE = 5, - NFS4_PNFS_DS_STATEID_TYPE = 6, - NFS4_REVOKED_STATEID_TYPE = 7, - } type; -}; +struct trace_event_data_offsets_jbd2_handle_extend {}; -typedef struct nfs4_stateid_struct nfs4_stateid; +struct trace_event_data_offsets_jbd2_handle_stats {}; -struct nfs4_state; +struct trace_event_data_offsets_jbd2_run_stats {}; -struct nfs4_lock_state { - struct list_head ls_locks; - struct nfs4_state *ls_state; - long unsigned int ls_flags; - struct nfs_seqid_counter ls_seqid; - nfs4_stateid ls_stateid; - refcount_t ls_count; - fl_owner_t ls_owner; -}; +struct trace_event_data_offsets_jbd2_checkpoint_stats {}; -struct in_addr { - __be32 s_addr; -}; +struct trace_event_data_offsets_jbd2_update_log_tail {}; -struct sockaddr_in { - __kernel_sa_family_t sin_family; - __be16 sin_port; - struct in_addr sin_addr; - unsigned char __pad[8]; -}; +struct trace_event_data_offsets_jbd2_write_superblock {}; -struct sockaddr_in6 { - short unsigned int sin6_family; - __be16 sin6_port; - __be32 sin6_flowinfo; - struct in6_addr sin6_addr; - __u32 sin6_scope_id; -}; +struct trace_event_data_offsets_jbd2_lock_buffer_stall {}; -typedef u32 rpc_authflavor_t; +typedef void (*btf_trace_jbd2_checkpoint)(void *, journal_t *, int); -enum rpc_auth_flavors { - RPC_AUTH_NULL = 0, - RPC_AUTH_UNIX = 1, - RPC_AUTH_SHORT = 2, - RPC_AUTH_DES = 3, - RPC_AUTH_KRB = 4, - RPC_AUTH_GSS = 6, - RPC_AUTH_MAXFLAVOR = 8, - RPC_AUTH_GSS_KRB5 = 390003, - RPC_AUTH_GSS_KRB5I = 390004, - RPC_AUTH_GSS_KRB5P = 390005, - RPC_AUTH_GSS_LKEY = 390006, - RPC_AUTH_GSS_LKEYI = 390007, - RPC_AUTH_GSS_LKEYP = 390008, - RPC_AUTH_GSS_SPKM = 390009, - RPC_AUTH_GSS_SPKMI = 390010, - RPC_AUTH_GSS_SPKMP = 390011, -}; +typedef void (*btf_trace_jbd2_start_commit)(void *, journal_t *, transaction_t *); -struct xdr_netobj { - unsigned int len; - u8 *data; -}; +typedef void (*btf_trace_jbd2_commit_locking)(void *, journal_t *, transaction_t *); -struct rpc_rqst; +typedef void (*btf_trace_jbd2_commit_flushing)(void *, journal_t *, transaction_t *); -struct xdr_stream { - __be32 *p; - struct xdr_buf *buf; - __be32 *end; - struct kvec *iov; - struct kvec scratch; - struct page___2 **page_ptr; - unsigned int nwords; - struct rpc_rqst *rqst; -}; +typedef void (*btf_trace_jbd2_commit_logging)(void *, journal_t *, transaction_t *); -struct rpc_xprt; +typedef void (*btf_trace_jbd2_drop_transaction)(void *, journal_t *, transaction_t *); -struct rpc_task; +typedef void (*btf_trace_jbd2_end_commit)(void *, journal_t *, transaction_t *); -struct rpc_cred; +typedef void (*btf_trace_jbd2_submit_inode_data)(void *, struct inode *); -struct rpc_rqst { - struct rpc_xprt *rq_xprt; - struct xdr_buf rq_snd_buf; - struct xdr_buf rq_rcv_buf; - struct rpc_task *rq_task; - struct rpc_cred *rq_cred; - __be32 rq_xid; - int rq_cong; - u32 rq_seqno; - int rq_enc_pages_num; - struct page___2 **rq_enc_pages; - void (*rq_release_snd_buf)(struct rpc_rqst *); - union { - struct list_head rq_list; - struct rb_node rq_recv; - }; - struct list_head rq_xmit; - struct list_head rq_xmit2; - void *rq_buffer; - size_t rq_callsize; - void *rq_rbuffer; - size_t rq_rcvsize; - size_t rq_xmit_bytes_sent; - size_t rq_reply_bytes_recvd; - struct xdr_buf rq_private_buf; - long unsigned int rq_majortimeo; - long unsigned int rq_timeout; - ktime_t rq_rtt; - unsigned int rq_retries; - unsigned int rq_connect_cookie; - atomic_t rq_pin; - u32 rq_bytes_sent; - ktime_t rq_xtime; - int rq_ntrans; -}; +typedef void (*btf_trace_jbd2_handle_start)(void *, dev_t, long unsigned int, unsigned int, unsigned int, int); -typedef void (*kxdreproc_t)(struct rpc_rqst *, struct xdr_stream *, const void *); +typedef void (*btf_trace_jbd2_handle_restart)(void *, dev_t, long unsigned int, unsigned int, unsigned int, int); -typedef int (*kxdrdproc_t)(struct rpc_rqst *, struct xdr_stream *, void *); +typedef void (*btf_trace_jbd2_handle_extend)(void *, dev_t, long unsigned int, unsigned int, unsigned int, int, int); -struct rpc_procinfo; +typedef void (*btf_trace_jbd2_handle_stats)(void *, dev_t, long unsigned int, unsigned int, unsigned int, int, int, int, int); -struct rpc_message { - const struct rpc_procinfo *rpc_proc; - void *rpc_argp; - void *rpc_resp; - const struct cred___2 *rpc_cred; -}; +typedef void (*btf_trace_jbd2_run_stats)(void *, dev_t, long unsigned int, struct transaction_run_stats_s *); -struct rpc_procinfo { - u32 p_proc; - kxdreproc_t p_encode; - kxdrdproc_t p_decode; - unsigned int p_arglen; - unsigned int p_replen; - unsigned int p_timer; - u32 p_statidx; - const char *p_name; -}; +typedef void (*btf_trace_jbd2_checkpoint_stats)(void *, dev_t, long unsigned int, struct transaction_chp_stats_s *); -struct rpc_wait { - struct list_head list; - struct list_head links; - struct list_head timer_list; -}; +typedef void (*btf_trace_jbd2_update_log_tail)(void *, journal_t *, tid_t, long unsigned int, long unsigned int); -struct rpc_call_ops; +typedef void (*btf_trace_jbd2_write_superblock)(void *, journal_t *, int); -struct rpc_clnt; +typedef void (*btf_trace_jbd2_lock_buffer_stall)(void *, dev_t, long unsigned int); -struct rpc_task { - atomic_t tk_count; - int tk_status; - struct list_head tk_task; - void (*tk_callback)(struct rpc_task *); - void (*tk_action)(struct rpc_task *); - long unsigned int tk_timeout; - long unsigned int tk_runstate; - struct rpc_wait_queue *tk_waitqueue; - union { - struct work_struct tk_work; - struct rpc_wait tk_wait; - } u; - int tk_rpc_status; - struct rpc_message tk_msg; - void *tk_calldata; - const struct rpc_call_ops *tk_ops; - struct rpc_clnt *tk_client; - struct rpc_xprt *tk_xprt; - struct rpc_cred *tk_op_cred; - struct rpc_rqst *tk_rqstp; - struct workqueue_struct *tk_workqueue; - ktime_t tk_start; - pid_t tk_owner; - short unsigned int tk_flags; - short unsigned int tk_timeouts; - short unsigned int tk_pid; - unsigned char tk_priority: 2; - unsigned char tk_garb_retry: 2; - unsigned char tk_cred_retry: 2; - unsigned char tk_rebind_retry: 2; +struct jbd2_stats_proc_session { + journal_t *journal; + struct transaction_stats_s *stats; + int start; + int max; }; -struct rpc_call_ops { - void (*rpc_call_prepare)(struct rpc_task *, void *); - void (*rpc_call_done)(struct rpc_task *, void *); - void (*rpc_count_stats)(struct rpc_task *, void *); - void (*rpc_release)(void *); +struct ramfs_mount_opts { + umode_t mode; }; -struct rpc_pipe_dir_head { - struct list_head pdh_entries; - struct dentry___2 *pdh_dentry; +struct ramfs_fs_info { + struct ramfs_mount_opts mount_opts; }; -struct rpc_rtt { - long unsigned int timeo; - long unsigned int srtt[5]; - long unsigned int sdrtt[5]; - int ntimeouts[5]; +enum ramfs_param { + Opt_mode___3 = 0, }; -struct rpc_timeout { - long unsigned int to_initval; - long unsigned int to_maxval; - long unsigned int to_increment; - unsigned int to_retries; - unsigned char to_exponential; +enum hugetlbfs_size_type { + NO_SIZE = 0, + SIZE_STD = 1, + SIZE_PERCENT = 2, }; -struct rpc_xprt_switch; - -struct rpc_xprt_iter_ops; +struct hugetlbfs_fs_context { + struct hstate *hstate; + long long unsigned int max_size_opt; + long long unsigned int min_size_opt; + long int max_hpages; + long int nr_inodes; + long int min_hpages; + enum hugetlbfs_size_type max_val_type; + enum hugetlbfs_size_type min_val_type; + kuid_t uid; + kgid_t gid; + umode_t mode; +}; -struct rpc_xprt_iter { - struct rpc_xprt_switch *xpi_xpswitch; - struct rpc_xprt *xpi_cursor; - const struct rpc_xprt_iter_ops *xpi_ops; +enum hugetlb_param { + Opt_gid___4 = 0, + Opt_min_size = 1, + Opt_mode___4 = 2, + Opt_nr_inodes___2 = 3, + Opt_pagesize = 4, + Opt_size___2 = 5, + Opt_uid___3 = 6, }; -struct rpc_auth; +typedef u16 wchar_t; -struct rpc_stat; +struct nls_table { + const char *charset; + const char *alias; + int (*uni2char)(wchar_t, unsigned char *, int); + int (*char2uni)(const unsigned char *, int, wchar_t *); + const unsigned char *charset2lower; + const unsigned char *charset2upper; + struct module *owner; + struct nls_table *next; +}; -struct rpc_iostats; +struct fat_mount_options { + kuid_t fs_uid; + kgid_t fs_gid; + short unsigned int fs_fmask; + short unsigned int fs_dmask; + short unsigned int codepage; + int time_offset; + char *iocharset; + short unsigned int shortname; + unsigned char name_check; + unsigned char errors; + unsigned char nfs; + short unsigned int allow_utime; + unsigned int quiet: 1; + unsigned int showexec: 1; + unsigned int sys_immutable: 1; + unsigned int dotsOK: 1; + unsigned int isvfat: 1; + unsigned int utf8: 1; + unsigned int unicode_xlate: 1; + unsigned int numtail: 1; + unsigned int flush: 1; + unsigned int nocase: 1; + unsigned int usefree: 1; + unsigned int tz_set: 1; + unsigned int rodir: 1; + unsigned int discard: 1; + unsigned int dos1xfloppy: 1; +}; -struct rpc_program; +struct fatent_operations; -struct rpc_clnt { - atomic_t cl_count; - unsigned int cl_clid; - struct list_head cl_clients; - struct list_head cl_tasks; - spinlock_t cl_lock; - struct rpc_xprt *cl_xprt; - const struct rpc_procinfo *cl_procinfo; - u32 cl_prog; - u32 cl_vers; - u32 cl_maxproc; - struct rpc_auth *cl_auth; - struct rpc_stat *cl_stats; - struct rpc_iostats *cl_metrics; - unsigned int cl_softrtry: 1; - unsigned int cl_softerr: 1; - unsigned int cl_discrtry: 1; - unsigned int cl_noretranstimeo: 1; - unsigned int cl_autobind: 1; - unsigned int cl_chatty: 1; - struct rpc_rtt *cl_rtt; - const struct rpc_timeout *cl_timeout; - atomic_t cl_swapper; - int cl_nodelen; - char cl_nodename[65]; - struct rpc_pipe_dir_head cl_pipedir_objects; - struct rpc_clnt *cl_parent; - struct rpc_rtt cl_rtt_default; - struct rpc_timeout cl_timeout_default; - const struct rpc_program *cl_program; - const char *cl_principal; - struct rpc_xprt_iter cl_xpi; - const struct cred___2 *cl_cred; +struct msdos_sb_info { + short unsigned int sec_per_clus; + short unsigned int cluster_bits; + unsigned int cluster_size; + unsigned char fats; + unsigned char fat_bits; + short unsigned int fat_start; + long unsigned int fat_length; + long unsigned int dir_start; + short unsigned int dir_entries; + long unsigned int data_start; + long unsigned int max_cluster; + long unsigned int root_cluster; + long unsigned int fsinfo_sector; + struct mutex fat_lock; + struct mutex nfs_build_inode_lock; + struct mutex s_lock; + unsigned int prev_free; + unsigned int free_clusters; + unsigned int free_clus_valid; + struct fat_mount_options options; + struct nls_table *nls_disk; + struct nls_table *nls_io; + const void *dir_ops; + int dir_per_block; + int dir_per_block_bits; + unsigned int vol_id; + int fatent_shift; + const struct fatent_operations *fatent_ops; + struct inode *fat_inode; + struct inode *fsinfo_inode; + struct ratelimit_state ratelimit; + spinlock_t inode_hash_lock; + struct hlist_head inode_hashtable[256]; + spinlock_t dir_hash_lock; + struct hlist_head dir_hashtable[256]; + unsigned int dirty; + struct callback_head rcu; }; -struct rpc_xprt_ops; +struct fat_entry; -struct svc_xprt; +struct fatent_operations { + void (*ent_blocknr)(struct super_block *, int, int *, sector_t *); + void (*ent_set_ptr)(struct fat_entry *, int); + int (*ent_bread)(struct super_block *, struct fat_entry *, int, sector_t); + int (*ent_get)(struct fat_entry *); + void (*ent_put)(struct fat_entry *, int); + int (*ent_next)(struct fat_entry *); +}; -struct rpc_xprt { - struct kref kref; - const struct rpc_xprt_ops *ops; - const struct rpc_timeout *timeout; - struct __kernel_sockaddr_storage addr; - size_t addrlen; - int prot; - long unsigned int cong; - long unsigned int cwnd; - size_t max_payload; - struct rpc_wait_queue binding; - struct rpc_wait_queue sending; - struct rpc_wait_queue pending; - struct rpc_wait_queue backlog; - struct list_head free; - unsigned int max_reqs; - unsigned int min_reqs; - unsigned int num_reqs; - long unsigned int state; - unsigned char resvport: 1; - unsigned char reuseport: 1; - atomic_t swapper; - unsigned int bind_index; - struct list_head xprt_switch; - long unsigned int bind_timeout; - long unsigned int reestablish_timeout; - unsigned int connect_cookie; - struct work_struct task_cleanup; - struct timer_list timer; - long unsigned int last_used; - long unsigned int idle_timeout; - long unsigned int connect_timeout; - long unsigned int max_reconnect_timeout; - atomic_long_t queuelen; - spinlock_t transport_lock; - spinlock_t reserve_lock; - spinlock_t queue_lock; - u32 xid; - struct rpc_task *snd_task; - struct list_head xmit_queue; - struct svc_xprt *bc_xprt; - struct rb_root recv_queue; - struct { - long unsigned int bind_count; - long unsigned int connect_count; - long unsigned int connect_start; - long unsigned int connect_time; - long unsigned int sends; - long unsigned int recvs; - long unsigned int bad_xids; - long unsigned int max_slots; - long long unsigned int req_u; - long long unsigned int bklog_u; - long long unsigned int sending_u; - long long unsigned int pending_u; - } stat; - struct net___2 *xprt_net; - const char *servername; - const char *address_strings[6]; - struct callback_head rcu; +struct msdos_inode_info { + spinlock_t cache_lru_lock; + struct list_head cache_lru; + int nr_caches; + unsigned int cache_valid_id; + loff_t mmu_private; + int i_start; + int i_logstart; + int i_attrs; + loff_t i_pos; + struct hlist_node i_fat_hash; + struct hlist_node i_dir_hash; + struct rw_semaphore truncate_lock; + struct inode vfs_inode; }; -struct rpc_credops; +struct fat_entry { + int entry; + union { + u8 *ent12_p[2]; + __le16 *ent16_p; + __le32 *ent32_p; + } u; + int nr_bhs; + struct buffer_head *bhs[2]; + struct inode *fat_inode; +}; -struct rpc_cred { - struct hlist_node cr_hash; - struct list_head cr_lru; - struct callback_head cr_rcu; - struct rpc_auth *cr_auth; - const struct rpc_credops *cr_ops; - long unsigned int cr_expire; - long unsigned int cr_flags; - refcount_t cr_count; - const struct cred___2 *cr_cred; +struct fat_cache { + struct list_head cache_list; + int nr_contig; + int fcluster; + int dcluster; }; -struct rpc_task_setup { - struct rpc_task *task; - struct rpc_clnt *rpc_client; - struct rpc_xprt *rpc_xprt; - struct rpc_cred *rpc_op_cred; - const struct rpc_message *rpc_message; - const struct rpc_call_ops *callback_ops; - void *callback_data; - struct workqueue_struct *workqueue; - short unsigned int flags; - signed char priority; +struct fat_cache_id { + unsigned int id; + int nr_contig; + int fcluster; + int dcluster; }; -enum rpc_display_format_t { - RPC_DISPLAY_ADDR = 0, - RPC_DISPLAY_PORT = 1, - RPC_DISPLAY_PROTO = 2, - RPC_DISPLAY_HEX_ADDR = 3, - RPC_DISPLAY_HEX_PORT = 4, - RPC_DISPLAY_NETID = 5, - RPC_DISPLAY_MAX = 6, +struct compat_dirent { + u32 d_ino; + compat_off_t d_off; + u16 d_reclen; + char d_name[256]; }; -struct rpc_xprt_ops { - void (*set_buffer_size)(struct rpc_xprt *, size_t, size_t); - int (*reserve_xprt)(struct rpc_xprt *, struct rpc_task *); - void (*release_xprt)(struct rpc_xprt *, struct rpc_task *); - void (*alloc_slot)(struct rpc_xprt *, struct rpc_task *); - void (*free_slot)(struct rpc_xprt *, struct rpc_rqst *); - void (*rpcbind)(struct rpc_task *); - void (*set_port)(struct rpc_xprt *, short unsigned int); - void (*connect)(struct rpc_xprt *, struct rpc_task *); - int (*buf_alloc)(struct rpc_task *); - void (*buf_free)(struct rpc_task *); - void (*prepare_request)(struct rpc_rqst *); - int (*send_request)(struct rpc_rqst *); - void (*wait_for_reply_request)(struct rpc_task *); - void (*timer)(struct rpc_xprt *, struct rpc_task *); - void (*release_request)(struct rpc_task *); - void (*close)(struct rpc_xprt *); - void (*destroy)(struct rpc_xprt *); - void (*set_connect_timeout)(struct rpc_xprt *, long unsigned int, long unsigned int); - void (*print_stats)(struct rpc_xprt *, struct seq_file *); - int (*enable_swap)(struct rpc_xprt *); - void (*disable_swap)(struct rpc_xprt *); - void (*inject_disconnect)(struct rpc_xprt *); - int (*bc_setup)(struct rpc_xprt *, unsigned int); - size_t (*bc_maxpayload)(struct rpc_xprt *); - unsigned int (*bc_num_slots)(struct rpc_xprt *); - void (*bc_free_rqst)(struct rpc_rqst *); - void (*bc_destroy)(struct rpc_xprt *, unsigned int); +enum utf16_endian { + UTF16_HOST_ENDIAN = 0, + UTF16_LITTLE_ENDIAN = 1, + UTF16_BIG_ENDIAN = 2, }; -enum xprt_transports { - XPRT_TRANSPORT_UDP = 17, - XPRT_TRANSPORT_TCP = 6, - XPRT_TRANSPORT_BC_TCP = 2147483654, - XPRT_TRANSPORT_RDMA = 256, - XPRT_TRANSPORT_BC_RDMA = 2147483904, - XPRT_TRANSPORT_LOCAL = 257, +struct __fat_dirent { + long int d_ino; + __kernel_off_t d_off; + short unsigned int d_reclen; + char d_name[256]; +}; + +struct msdos_dir_entry { + __u8 name[11]; + __u8 attr; + __u8 lcase; + __u8 ctime_cs; + __le16 ctime; + __le16 cdate; + __le16 adate; + __le16 starthi; + __le16 time; + __le16 date; + __le16 start; + __le32 size; }; -struct svc_xprt_class; +struct msdos_dir_slot { + __u8 id; + __u8 name0_4[10]; + __u8 attr; + __u8 reserved; + __u8 alias_checksum; + __u8 name5_10[12]; + __le16 start; + __u8 name11_12[4]; +}; -struct svc_xprt_ops; +struct fat_slot_info { + loff_t i_pos; + loff_t slot_off; + int nr_slots; + struct msdos_dir_entry *de; + struct buffer_head *bh; +}; -struct svc_serv; +typedef long long unsigned int llu; -struct svc_xprt { - struct svc_xprt_class *xpt_class; - const struct svc_xprt_ops *xpt_ops; - struct kref xpt_ref; - struct list_head xpt_list; - struct list_head xpt_ready; - long unsigned int xpt_flags; - struct svc_serv *xpt_server; - atomic_t xpt_reserved; - atomic_t xpt_nr_rqsts; - struct mutex xpt_mutex; - spinlock_t xpt_lock; - void *xpt_auth_cache; - struct list_head xpt_deferred; - struct __kernel_sockaddr_storage xpt_local; - size_t xpt_locallen; - struct __kernel_sockaddr_storage xpt_remote; - size_t xpt_remotelen; - char xpt_remotebuf[58]; - struct list_head xpt_users; - struct net___2 *xpt_net; - const struct cred___2 *xpt_cred; - struct rpc_xprt *xpt_bc_xprt; - struct rpc_xprt_switch *xpt_bc_xps; +enum { + PARSE_INVALID = 1, + PARSE_NOT_LONGNAME = 2, + PARSE_EOF = 3, }; -struct rpc_xprt_switch { - spinlock_t xps_lock; - struct kref xps_kref; - unsigned int xps_nxprts; - unsigned int xps_nactive; - atomic_long_t xps_queuelen; - struct list_head xps_xprt_list; - struct net___2 *xps_net; - const struct rpc_xprt_iter_ops *xps_iter_ops; - struct callback_head xps_rcu; +struct fat_ioctl_filldir_callback { + struct dir_context ctx; + void *dirent; + int result; + const char *longname; + int long_len; + const char *shortname; + int short_len; }; -struct auth_cred { - const struct cred___2 *cred; - const char *principal; +struct fat_boot_sector { + __u8 ignored[3]; + __u8 system_id[8]; + __u8 sector_size[2]; + __u8 sec_per_clus; + __le16 reserved; + __u8 fats; + __u8 dir_entries[2]; + __u8 sectors[2]; + __u8 media; + __le16 fat_length; + __le16 secs_track; + __le16 heads; + __le32 hidden; + __le32 total_sect; + union { + struct { + __u8 drive_number; + __u8 state; + __u8 signature; + __u8 vol_id[4]; + __u8 vol_label[11]; + __u8 fs_type[8]; + } fat16; + struct { + __le32 length; + __le16 flags; + __u8 version[2]; + __le32 root_cluster; + __le16 info_sector; + __le16 backup_boot; + __le16 reserved2[6]; + __u8 drive_number; + __u8 state; + __u8 signature; + __u8 vol_id[4]; + __u8 vol_label[11]; + __u8 fs_type[8]; + } fat32; + }; }; -struct rpc_authops; +struct fat_boot_fsinfo { + __le32 signature1; + __le32 reserved1[120]; + __le32 signature2; + __le32 free_clusters; + __le32 next_cluster; + __le32 reserved2[4]; +}; -struct rpc_cred_cache; +struct fat_bios_param_block { + u16 fat_sector_size; + u8 fat_sec_per_clus; + u16 fat_reserved; + u8 fat_fats; + u16 fat_dir_entries; + u16 fat_sectors; + u16 fat_fat_length; + u32 fat_total_sect; + u8 fat16_state; + u32 fat16_vol_id; + u32 fat32_length; + u32 fat32_root_cluster; + u16 fat32_info_sector; + u8 fat32_state; + u32 fat32_vol_id; +}; -struct rpc_auth { - unsigned int au_cslack; - unsigned int au_rslack; - unsigned int au_verfsize; - unsigned int au_ralign; - unsigned int au_flags; - const struct rpc_authops *au_ops; - rpc_authflavor_t au_flavor; - refcount_t au_count; - struct rpc_cred_cache *au_credcache; +struct fat_floppy_defaults { + unsigned int nr_sectors; + unsigned int sec_per_clus; + unsigned int dir_entries; + unsigned int media; + unsigned int fat_length; }; -struct rpc_credops { - const char *cr_name; - int (*cr_init)(struct rpc_auth *, struct rpc_cred *); - void (*crdestroy)(struct rpc_cred *); - int (*crmatch)(struct auth_cred *, struct rpc_cred *, int); - int (*crmarshal)(struct rpc_task *, struct xdr_stream *); - int (*crrefresh)(struct rpc_task *); - int (*crvalidate)(struct rpc_task *, struct xdr_stream *); - int (*crwrap_req)(struct rpc_task *, struct xdr_stream *); - int (*crunwrap_resp)(struct rpc_task *, struct xdr_stream *); - int (*crkey_timeout)(struct rpc_cred *); - char * (*crstringify_acceptor)(struct rpc_cred *); - bool (*crneed_reencode)(struct rpc_task *); +enum { + Opt_check_n = 0, + Opt_check_r = 1, + Opt_check_s = 2, + Opt_uid___4 = 3, + Opt_gid___5 = 4, + Opt_umask = 5, + Opt_dmask = 6, + Opt_fmask = 7, + Opt_allow_utime = 8, + Opt_codepage = 9, + Opt_usefree = 10, + Opt_nocase = 11, + Opt_quiet = 12, + Opt_showexec = 13, + Opt_debug___2 = 14, + Opt_immutable = 15, + Opt_dots = 16, + Opt_nodots = 17, + Opt_charset = 18, + Opt_shortname_lower = 19, + Opt_shortname_win95 = 20, + Opt_shortname_winnt = 21, + Opt_shortname_mixed = 22, + Opt_utf8_no = 23, + Opt_utf8_yes = 24, + Opt_uni_xl_no = 25, + Opt_uni_xl_yes = 26, + Opt_nonumtail_no = 27, + Opt_nonumtail_yes = 28, + Opt_obsolete = 29, + Opt_flush = 30, + Opt_tz_utc = 31, + Opt_rodir = 32, + Opt_err_cont___2 = 33, + Opt_err_panic___2 = 34, + Opt_err_ro___2 = 35, + Opt_discard___2 = 36, + Opt_nfs = 37, + Opt_time_offset = 38, + Opt_nfs_stale_rw = 39, + Opt_nfs_nostale_ro = 40, + Opt_err___3 = 41, + Opt_dos1xfloppy = 42, }; -struct rpc_auth_create_args; +struct fat_fid { + u32 i_gen; + u32 i_pos_low; + u16 i_pos_hi; + u16 parent_i_pos_hi; + u32 parent_i_pos_low; + u32 parent_i_gen; +}; -struct rpcsec_gss_info; +struct shortname_info { + unsigned char lower: 1; + unsigned char upper: 1; + unsigned char valid: 1; +}; -struct rpc_authops { - struct module___2 *owner; - rpc_authflavor_t au_flavor; - char *au_name; - struct rpc_auth * (*create)(const struct rpc_auth_create_args *, struct rpc_clnt *); - void (*destroy)(struct rpc_auth *); - int (*hash_cred)(struct auth_cred *, unsigned int); - struct rpc_cred * (*lookup_cred)(struct rpc_auth *, struct auth_cred *, int); - struct rpc_cred * (*crcreate)(struct rpc_auth *, struct auth_cred *, int, gfp_t); - int (*list_pseudoflavors)(rpc_authflavor_t *, int); - rpc_authflavor_t (*info2flavor)(struct rpcsec_gss_info *); - int (*flavor2info)(rpc_authflavor_t, struct rpcsec_gss_info *); - int (*key_timeout)(struct rpc_auth *, struct rpc_cred *); +struct iso_directory_record { + __u8 length[1]; + __u8 ext_attr_length[1]; + __u8 extent[8]; + __u8 size[8]; + __u8 date[7]; + __u8 flags[1]; + __u8 file_unit_size[1]; + __u8 interleave[1]; + __u8 volume_sequence_number[4]; + __u8 name_len[1]; + char name[0]; }; -struct rpc_auth_create_args { - rpc_authflavor_t pseudoflavor; - const char *target_name; +struct iso_inode_info { + long unsigned int i_iget5_block; + long unsigned int i_iget5_offset; + unsigned int i_first_extent; + unsigned char i_file_format; + unsigned char i_format_parm[3]; + long unsigned int i_next_section_block; + long unsigned int i_next_section_offset; + off_t i_section_size; + struct inode vfs_inode; }; -struct rpcsec_gss_oid { - unsigned int len; - u8 data[32]; +struct isofs_sb_info { + long unsigned int s_ninodes; + long unsigned int s_nzones; + long unsigned int s_firstdatazone; + long unsigned int s_log_zone_size; + long unsigned int s_max_size; + int s_rock_offset; + s32 s_sbsector; + unsigned char s_joliet_level; + unsigned char s_mapping; + unsigned char s_check; + unsigned char s_session; + unsigned int s_high_sierra: 1; + unsigned int s_rock: 2; + unsigned int s_utf8: 1; + unsigned int s_cruft: 1; + unsigned int s_nocompress: 1; + unsigned int s_hide: 1; + unsigned int s_showassoc: 1; + unsigned int s_overriderockperm: 1; + unsigned int s_uid_set: 1; + unsigned int s_gid_set: 1; + umode_t s_fmode; + umode_t s_dmode; + kgid_t s_gid; + kuid_t s_uid; + struct nls_table *s_nls_iocharset; }; -struct rpcsec_gss_info { - struct rpcsec_gss_oid oid; - u32 qop; - u32 service; +struct cdrom_msf0 { + __u8 minute; + __u8 second; + __u8 frame; }; -struct rpc_stat { - const struct rpc_program *program; - unsigned int netcnt; - unsigned int netudpcnt; - unsigned int nettcpcnt; - unsigned int nettcpconn; - unsigned int netreconn; - unsigned int rpccnt; - unsigned int rpcretrans; - unsigned int rpcauthrefresh; - unsigned int rpcgarbage; +union cdrom_addr { + struct cdrom_msf0 msf; + int lba; }; -struct rpc_version; +struct cdrom_tocentry { + __u8 cdte_track; + __u8 cdte_adr: 4; + __u8 cdte_ctrl: 4; + __u8 cdte_format; + union cdrom_addr cdte_addr; + __u8 cdte_datamode; +}; -struct rpc_program { - const char *name; - u32 number; - unsigned int nrvers; - const struct rpc_version **version; - struct rpc_stat *stats; - const char *pipe_dir_name; +struct cdrom_multisession { + union cdrom_addr addr; + __u8 xa_flag; + __u8 addr_format; }; -struct svc_program; +struct iso_volume_descriptor { + __u8 type[1]; + char id[5]; + __u8 version[1]; + __u8 data[2041]; +}; -struct svc_stat { - struct svc_program *program; - unsigned int netcnt; - unsigned int netudpcnt; - unsigned int nettcpcnt; - unsigned int nettcpconn; - unsigned int rpccnt; - unsigned int rpcbadfmt; - unsigned int rpcbadauth; - unsigned int rpcbadclnt; +struct iso_primary_descriptor { + __u8 type[1]; + char id[5]; + __u8 version[1]; + __u8 unused1[1]; + char system_id[32]; + char volume_id[32]; + __u8 unused2[8]; + __u8 volume_space_size[8]; + __u8 unused3[32]; + __u8 volume_set_size[4]; + __u8 volume_sequence_number[4]; + __u8 logical_block_size[4]; + __u8 path_table_size[8]; + __u8 type_l_path_table[4]; + __u8 opt_type_l_path_table[4]; + __u8 type_m_path_table[4]; + __u8 opt_type_m_path_table[4]; + __u8 root_directory_record[34]; + char volume_set_id[128]; + char publisher_id[128]; + char preparer_id[128]; + char application_id[128]; + char copyright_file_id[37]; + char abstract_file_id[37]; + char bibliographic_file_id[37]; + __u8 creation_date[17]; + __u8 modification_date[17]; + __u8 expiration_date[17]; + __u8 effective_date[17]; + __u8 file_structure_version[1]; + __u8 unused4[1]; + __u8 application_data[512]; + __u8 unused5[653]; }; -struct svc_version; +struct iso_supplementary_descriptor { + __u8 type[1]; + char id[5]; + __u8 version[1]; + __u8 flags[1]; + char system_id[32]; + char volume_id[32]; + __u8 unused2[8]; + __u8 volume_space_size[8]; + __u8 escape[32]; + __u8 volume_set_size[4]; + __u8 volume_sequence_number[4]; + __u8 logical_block_size[4]; + __u8 path_table_size[8]; + __u8 type_l_path_table[4]; + __u8 opt_type_l_path_table[4]; + __u8 type_m_path_table[4]; + __u8 opt_type_m_path_table[4]; + __u8 root_directory_record[34]; + char volume_set_id[128]; + char publisher_id[128]; + char preparer_id[128]; + char application_id[128]; + char copyright_file_id[37]; + char abstract_file_id[37]; + char bibliographic_file_id[37]; + __u8 creation_date[17]; + __u8 modification_date[17]; + __u8 expiration_date[17]; + __u8 effective_date[17]; + __u8 file_structure_version[1]; + __u8 unused4[1]; + __u8 application_data[512]; + __u8 unused5[653]; +}; -struct svc_rqst; +struct hs_volume_descriptor { + __u8 foo[8]; + __u8 type[1]; + char id[5]; + __u8 version[1]; + __u8 data[2033]; +}; -struct svc_process_info; +struct hs_primary_descriptor { + __u8 foo[8]; + __u8 type[1]; + __u8 id[5]; + __u8 version[1]; + __u8 unused1[1]; + char system_id[32]; + char volume_id[32]; + __u8 unused2[8]; + __u8 volume_space_size[8]; + __u8 unused3[32]; + __u8 volume_set_size[4]; + __u8 volume_sequence_number[4]; + __u8 logical_block_size[4]; + __u8 path_table_size[8]; + __u8 type_l_path_table[4]; + __u8 unused4[28]; + __u8 root_directory_record[34]; +}; -struct svc_program { - struct svc_program *pg_next; - u32 pg_prog; - unsigned int pg_lovers; - unsigned int pg_hivers; - unsigned int pg_nvers; - const struct svc_version **pg_vers; - char *pg_name; - char *pg_class; - struct svc_stat *pg_stats; - int (*pg_authenticate)(struct svc_rqst *); - __be32 (*pg_init_request)(struct svc_rqst *, const struct svc_program *, struct svc_process_info *); - int (*pg_rpcbind_set)(struct net___2 *, const struct svc_program *, u32, int, short unsigned int, short unsigned int); +enum isofs_file_format { + isofs_file_normal = 0, + isofs_file_sparse = 1, + isofs_file_compressed = 2, }; -struct rpc_pipe_msg { - struct list_head list; - void *data; - size_t len; - size_t copied; - int errno; +struct iso9660_options { + unsigned int rock: 1; + unsigned int joliet: 1; + unsigned int cruft: 1; + unsigned int hide: 1; + unsigned int showassoc: 1; + unsigned int nocompress: 1; + unsigned int overriderockperm: 1; + unsigned int uid_set: 1; + unsigned int gid_set: 1; + unsigned int utf8: 1; + unsigned char map; + unsigned char check; + unsigned int blocksize; + umode_t fmode; + umode_t dmode; + kgid_t gid; + kuid_t uid; + char *iocharset; + s32 session; + s32 sbsector; }; -struct rpc_pipe_ops { - ssize_t (*upcall)(struct file___2 *, struct rpc_pipe_msg *, char *, size_t); - ssize_t (*downcall)(struct file___2 *, const char *, size_t); - void (*release_pipe)(struct inode___2 *); - int (*open_pipe)(struct inode___2 *); - void (*destroy_msg)(struct rpc_pipe_msg *); +enum { + Opt_block = 0, + Opt_check_r___2 = 1, + Opt_check_s___2 = 2, + Opt_cruft = 3, + Opt_gid___6 = 4, + Opt_ignore = 5, + Opt_iocharset = 6, + Opt_map_a = 7, + Opt_map_n = 8, + Opt_map_o = 9, + Opt_mode___5 = 10, + Opt_nojoliet = 11, + Opt_norock = 12, + Opt_sb___2 = 13, + Opt_session = 14, + Opt_uid___5 = 15, + Opt_unhide = 16, + Opt_utf8 = 17, + Opt_err___4 = 18, + Opt_nocompress = 19, + Opt_hide = 20, + Opt_showassoc = 21, + Opt_dmode = 22, + Opt_overriderockperm = 23, }; -struct rpc_pipe { - struct list_head pipe; - struct list_head in_upcall; - struct list_head in_downcall; - int pipelen; - int nreaders; - int nwriters; - int flags; - struct delayed_work queue_timeout; - const struct rpc_pipe_ops *ops; - spinlock_t lock; - struct dentry___2 *dentry; +struct isofs_iget5_callback_data { + long unsigned int block; + long unsigned int offset; }; -struct rpc_xprt_iter_ops { - void (*xpi_rewind)(struct rpc_xprt_iter *); - struct rpc_xprt * (*xpi_xprt)(struct rpc_xprt_iter *); - struct rpc_xprt * (*xpi_next)(struct rpc_xprt_iter *); +struct SU_SP_s { + __u8 magic[2]; + __u8 skip; }; -struct rpc_iostats { - spinlock_t om_lock; - long unsigned int om_ops; - long unsigned int om_ntrans; - long unsigned int om_timeouts; - long long unsigned int om_bytes_sent; - long long unsigned int om_bytes_recv; - ktime_t om_queue; - ktime_t om_rtt; - ktime_t om_execute; - long unsigned int om_error_status; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; +struct SU_CE_s { + __u8 extent[8]; + __u8 offset[8]; + __u8 size[8]; }; -struct rpc_version { - u32 number; - unsigned int nrprocs; - const struct rpc_procinfo *procs; - unsigned int *counts; +struct SU_ER_s { + __u8 len_id; + __u8 len_des; + __u8 len_src; + __u8 ext_ver; + __u8 data[0]; }; -struct rpc_create_args { - struct net___2 *net; - int protocol; - struct sockaddr *address; - size_t addrsize; - struct sockaddr *saddress; - const struct rpc_timeout *timeout; - const char *servername; - const char *nodename; - const struct rpc_program *program; - u32 prognumber; - u32 version; - rpc_authflavor_t authflavor; - u32 nconnect; - long unsigned int flags; - char *client_name; - struct svc_xprt *bc_xprt; - const struct cred___2 *cred; +struct RR_RR_s { + __u8 flags[1]; }; -struct nfs_fh { - short unsigned int size; - unsigned char data[128]; +struct RR_PX_s { + __u8 mode[8]; + __u8 n_links[8]; + __u8 uid[8]; + __u8 gid[8]; }; -enum nfs3_stable_how { - NFS_UNSTABLE = 0, - NFS_DATA_SYNC = 1, - NFS_FILE_SYNC = 2, - NFS_INVALID_STABLE_HOW = 4294967295, +struct RR_PN_s { + __u8 dev_high[8]; + __u8 dev_low[8]; }; -struct nfs4_label { - uint32_t lfs; - uint32_t pi; - u32 len; - char *label; +struct SL_component { + __u8 flags; + __u8 len; + __u8 text[0]; }; -typedef struct { - char data[8]; -} nfs4_verifier; - -struct gss_api_mech; - -struct gss_ctx { - struct gss_api_mech *mech_type; - void *internal_ctx_id; +struct RR_SL_s { + __u8 flags; + struct SL_component link; }; -struct gss_api_ops; - -struct pf_desc; - -struct gss_api_mech { - struct list_head gm_list; - struct module___2 *gm_owner; - struct rpcsec_gss_oid gm_oid; - char *gm_name; - const struct gss_api_ops *gm_ops; - int gm_pf_num; - struct pf_desc *gm_pfs; - const char *gm_upcall_enctypes; +struct RR_NM_s { + __u8 flags; + char name[0]; }; -struct pf_desc { - u32 pseudoflavor; - u32 qop; - u32 service; - char *name; - char *auth_domain_name; - bool datatouch; +struct RR_CL_s { + __u8 location[8]; }; -struct gss_api_ops { - int (*gss_import_sec_context)(const void *, size_t, struct gss_ctx *, time_t *, gfp_t); - u32 (*gss_get_mic)(struct gss_ctx *, struct xdr_buf *, struct xdr_netobj *); - u32 (*gss_verify_mic)(struct gss_ctx *, struct xdr_buf *, struct xdr_netobj *); - u32 (*gss_wrap)(struct gss_ctx *, int, struct xdr_buf *, struct page___2 **); - u32 (*gss_unwrap)(struct gss_ctx *, int, struct xdr_buf *); - void (*gss_delete_sec_context)(void *); +struct RR_PL_s { + __u8 location[8]; }; -struct nfs4_string { - unsigned int len; - char *data; +struct stamp { + __u8 time[7]; }; -struct nfs_fsid { - uint64_t major; - uint64_t minor; +struct RR_TF_s { + __u8 flags; + struct stamp times[0]; }; -struct nfs4_threshold { - __u32 bm; - __u32 l_type; - __u64 rd_sz; - __u64 wr_sz; - __u64 rd_io_sz; - __u64 wr_io_sz; +struct RR_ZF_s { + __u8 algorithm[2]; + __u8 parms[2]; + __u8 real_size[8]; }; -struct nfs_fattr { - unsigned int valid; - umode_t mode; - __u32 nlink; - kuid_t uid; - kgid_t gid; - dev_t rdev; - __u64 size; +struct rock_ridge { + __u8 signature[2]; + __u8 len; + __u8 version; union { - struct { - __u32 blocksize; - __u32 blocks; - } nfs2; - struct { - __u64 used; - } nfs3; - } du; - struct nfs_fsid fsid; - __u64 fileid; - __u64 mounted_on_fileid; - struct timespec64 atime; - struct timespec64 mtime; - struct timespec64 ctime; - __u64 change_attr; - __u64 pre_change_attr; - __u64 pre_size; - struct timespec64 pre_mtime; - struct timespec64 pre_ctime; - long unsigned int time_start; - long unsigned int gencount; - struct nfs4_string *owner_name; - struct nfs4_string *group_name; - struct nfs4_threshold *mdsthreshold; + struct SU_SP_s SP; + struct SU_CE_s CE; + struct SU_ER_s ER; + struct RR_RR_s RR; + struct RR_PX_s PX; + struct RR_PN_s PN; + struct RR_SL_s SL; + struct RR_NM_s NM; + struct RR_CL_s CL; + struct RR_PL_s PL; + struct RR_TF_s TF; + struct RR_ZF_s ZF; + } u; }; -struct nfs_fsinfo { - struct nfs_fattr *fattr; - __u32 rtmax; - __u32 rtpref; - __u32 rtmult; - __u32 wtmax; - __u32 wtpref; - __u32 wtmult; - __u32 dtpref; - __u64 maxfilesize; - struct timespec64 time_delta; - __u32 lease_time; - __u32 nlayouttypes; - __u32 layouttype[8]; - __u32 blksize; - __u32 clone_blksize; +struct rock_state { + void *buffer; + unsigned char *chr; + int len; + int cont_size; + int cont_extent; + int cont_offset; + int cont_loops; + struct inode *inode; }; -struct nfs_fsstat { - struct nfs_fattr *fattr; - __u64 tbytes; - __u64 fbytes; - __u64 abytes; - __u64 tfiles; - __u64 ffiles; - __u64 afiles; +struct isofs_fid { + u32 block; + u16 offset; + u16 parent_offset; + u32 generation; + u32 parent_block; + u32 parent_generation; }; -struct nfs_pathconf { - struct nfs_fattr *fattr; - __u32 max_link; - __u32 max_namelen; -}; +typedef unsigned char Byte; -struct nfs4_change_info { - u32 atomic; - u64 before; - u64 after; -}; +typedef long unsigned int uLong; -struct nfs4_slot; +struct internal_state; -struct nfs4_sequence_args { - struct nfs4_slot *sa_slot; - u8 sa_cache_this: 1; - u8 sa_privileged: 1; +struct z_stream_s { + const Byte *next_in; + uLong avail_in; + uLong total_in; + Byte *next_out; + uLong avail_out; + uLong total_out; + char *msg; + struct internal_state *state; + void *workspace; + int data_type; + uLong adler; + uLong reserved; }; -struct nfs4_sequence_res { - struct nfs4_slot *sr_slot; - long unsigned int sr_timestamp; - int sr_status; - u32 sr_status_flags; - u32 sr_highest_slotid; - u32 sr_target_highest_slotid; +struct internal_state { + int dummy; }; -struct pnfs_layout_range { - u32 iomode; - u64 offset; - u64 length; -}; +typedef struct z_stream_s z_stream; -struct nfs_open_context; +typedef __kernel_old_time_t time_t; -struct nfs_lock_context { - refcount_t count; +struct nfs_seqid_counter { + ktime_t create_time; + int owner_id; + int flags; + u32 counter; + spinlock_t lock; struct list_head list; - struct nfs_open_context *open_context; - fl_owner_t lockowner; - atomic_t io_count; - struct callback_head callback_head; + struct rpc_wait_queue wait; }; -struct nfs_open_context { - struct nfs_lock_context lock_context; - fl_owner_t flock_owner; - struct dentry___2 *dentry; - const struct cred___2 *cred; - struct rpc_cred *ll_cred; - struct nfs4_state *state; - fmode_t mode; - long unsigned int flags; - int error; - struct list_head list; - struct nfs4_threshold *mdsthreshold; - struct callback_head callback_head; +struct nfs4_lock_state { + struct list_head ls_locks; + struct nfs4_state *ls_state; + long unsigned int ls_flags; + struct nfs_seqid_counter ls_seqid; + nfs4_stateid ls_stateid; + refcount_t ls_count; + fl_owner_t ls_owner; }; -struct nlm_host; +struct in_addr { + __be32 s_addr; +}; -struct nfs_auth_info { - unsigned int flavor_len; - rpc_authflavor_t flavors[12]; +struct sockaddr_in { + __kernel_sa_family_t sin_family; + __be16 sin_port; + struct in_addr sin_addr; + unsigned char __pad[8]; }; -struct pnfs_layoutdriver_type; +struct sockaddr_in6 { + short unsigned int sin6_family; + __be16 sin6_port; + __be32 sin6_flowinfo; + struct in6_addr sin6_addr; + __u32 sin6_scope_id; +}; -struct nfs_client; +enum rpc_auth_flavors { + RPC_AUTH_NULL = 0, + RPC_AUTH_UNIX = 1, + RPC_AUTH_SHORT = 2, + RPC_AUTH_DES = 3, + RPC_AUTH_KRB = 4, + RPC_AUTH_GSS = 6, + RPC_AUTH_MAXFLAVOR = 8, + RPC_AUTH_GSS_KRB5 = 390003, + RPC_AUTH_GSS_KRB5I = 390004, + RPC_AUTH_GSS_KRB5P = 390005, + RPC_AUTH_GSS_LKEY = 390006, + RPC_AUTH_GSS_LKEYI = 390007, + RPC_AUTH_GSS_LKEYP = 390008, + RPC_AUTH_GSS_SPKM = 390009, + RPC_AUTH_GSS_SPKMI = 390010, + RPC_AUTH_GSS_SPKMP = 390011, +}; -struct nfs_iostats; +struct xdr_netobj { + unsigned int len; + u8 *data; +}; -struct nfs_server { - struct nfs_client *nfs_client; - struct list_head client_link; - struct list_head master_link; - struct rpc_clnt *client; - struct rpc_clnt *client_acl; - struct nlm_host *nlm_host; - struct nfs_iostats *io_stats; - atomic_long_t writeback; - int flags; - unsigned int caps; - unsigned int rsize; - unsigned int rpages; - unsigned int wsize; - unsigned int wpages; - unsigned int wtmult; - unsigned int dtsize; - short unsigned int port; - unsigned int bsize; - unsigned int acregmin; - unsigned int acregmax; - unsigned int acdirmin; - unsigned int acdirmax; - unsigned int namelen; - unsigned int options; - unsigned int clone_blksize; - struct nfs_fsid fsid; - __u64 maxfilesize; - struct timespec64 time_delta; - long unsigned int mount_time; - struct super_block___2 *super; - dev_t s_dev; - struct nfs_auth_info auth_info; - u32 pnfs_blksize; - u32 attr_bitmask[3]; - u32 attr_bitmask_nl[3]; - u32 exclcreat_bitmask[3]; - u32 cache_consistency_bitmask[3]; - u32 acl_bitmask; - u32 fh_expire_type; - struct pnfs_layoutdriver_type *pnfs_curr_ld; - struct rpc_wait_queue roc_rpcwaitq; - void *pnfs_ld_data; - struct rb_root state_owners; - struct ida openowner_id; - struct ida lockowner_id; - struct list_head state_owners_lru; - struct list_head layouts; - struct list_head delegations; - struct list_head ss_copies; - long unsigned int mig_gen; - long unsigned int mig_status; - void (*destroy)(struct nfs_server *); - atomic_t active; - struct __kernel_sockaddr_storage mountd_address; - size_t mountd_addrlen; - u32 mountd_version; - short unsigned int mountd_port; - short unsigned int mountd_protocol; - struct rpc_wait_queue uoc_rpcwaitq; - unsigned int read_hdrsize; - const struct cred___2 *cred; +struct rpc_task_setup { + struct rpc_task *task; + struct rpc_clnt *rpc_client; + struct rpc_xprt *rpc_xprt; + struct rpc_cred *rpc_op_cred; + const struct rpc_message *rpc_message; + const struct rpc_call_ops *callback_ops; + void *callback_data; + struct workqueue_struct *workqueue; + short unsigned int flags; + signed char priority; }; -struct pnfs_layout_hdr; +enum rpc_display_format_t { + RPC_DISPLAY_ADDR = 0, + RPC_DISPLAY_PORT = 1, + RPC_DISPLAY_PROTO = 2, + RPC_DISPLAY_HEX_ADDR = 3, + RPC_DISPLAY_HEX_PORT = 4, + RPC_DISPLAY_NETID = 5, + RPC_DISPLAY_MAX = 6, +}; -struct nfs41_server_owner; +enum xprt_transports { + XPRT_TRANSPORT_UDP = 17, + XPRT_TRANSPORT_TCP = 6, + XPRT_TRANSPORT_BC_TCP = 2147483654, + XPRT_TRANSPORT_RDMA = 256, + XPRT_TRANSPORT_BC_RDMA = 2147483904, + XPRT_TRANSPORT_LOCAL = 257, +}; -struct nfs41_server_scope; +struct svc_xprt_class; -struct nfs41_impl_id; +struct svc_xprt_ops; -struct nfs_rpc_ops; +struct svc_serv; -struct nfs_subversion; +struct svc_xprt { + struct svc_xprt_class *xpt_class; + const struct svc_xprt_ops *xpt_ops; + struct kref xpt_ref; + struct list_head xpt_list; + struct list_head xpt_ready; + long unsigned int xpt_flags; + struct svc_serv *xpt_server; + atomic_t xpt_reserved; + atomic_t xpt_nr_rqsts; + struct mutex xpt_mutex; + spinlock_t xpt_lock; + void *xpt_auth_cache; + struct list_head xpt_deferred; + struct __kernel_sockaddr_storage xpt_local; + size_t xpt_locallen; + struct __kernel_sockaddr_storage xpt_remote; + size_t xpt_remotelen; + char xpt_remotebuf[58]; + struct list_head xpt_users; + struct net *xpt_net; + const struct cred *xpt_cred; + struct rpc_xprt *xpt_bc_xprt; + struct rpc_xprt_switch *xpt_bc_xps; +}; -struct idmap; +struct svc_program; -struct nfs4_minor_version_ops; +struct svc_stat { + struct svc_program *program; + unsigned int netcnt; + unsigned int netudpcnt; + unsigned int nettcpcnt; + unsigned int nettcpconn; + unsigned int rpccnt; + unsigned int rpcbadfmt; + unsigned int rpcbadauth; + unsigned int rpcbadclnt; +}; -struct nfs4_slot_table; +struct svc_version; -struct nfs4_session; +struct svc_rqst; -struct nfs_client { - refcount_t cl_count; - atomic_t cl_mds_count; - int cl_cons_state; - long unsigned int cl_res_state; - long unsigned int cl_flags; - struct __kernel_sockaddr_storage cl_addr; - size_t cl_addrlen; - char *cl_hostname; - char *cl_acceptor; - struct list_head cl_share_link; - struct list_head cl_superblocks; - struct rpc_clnt *cl_rpcclient; - const struct nfs_rpc_ops *rpc_ops; - int cl_proto; - struct nfs_subversion *cl_nfs_mod; - u32 cl_minorversion; - unsigned int cl_nconnect; - const char *cl_principal; - struct list_head cl_ds_clients; - u64 cl_clientid; - nfs4_verifier cl_confirm; - long unsigned int cl_state; - spinlock_t cl_lock; - long unsigned int cl_lease_time; - long unsigned int cl_last_renewal; - struct delayed_work cl_renewd; - struct rpc_wait_queue cl_rpcwaitq; - struct idmap *cl_idmap; - const char *cl_owner_id; - u32 cl_cb_ident; - const struct nfs4_minor_version_ops *cl_mvops; - long unsigned int cl_mig_gen; - struct nfs4_slot_table *cl_slot_tbl; - u32 cl_seqid; - u32 cl_exchange_flags; - struct nfs4_session *cl_session; - bool cl_preserve_clid; - struct nfs41_server_owner *cl_serverowner; - struct nfs41_server_scope *cl_serverscope; - struct nfs41_impl_id *cl_implid; - long unsigned int cl_sp4_flags; - char cl_ipaddr[48]; - struct net___2 *cl_net; - struct list_head pending_cb_stateids; -}; +struct svc_process_info; -struct pnfs_layout_segment { - struct list_head pls_list; - struct list_head pls_lc_list; - struct pnfs_layout_range pls_range; - refcount_t pls_refcount; - u32 pls_seq; - long unsigned int pls_flags; - struct pnfs_layout_hdr *pls_layout; +struct svc_program { + struct svc_program *pg_next; + u32 pg_prog; + unsigned int pg_lovers; + unsigned int pg_hivers; + unsigned int pg_nvers; + const struct svc_version **pg_vers; + char *pg_name; + char *pg_class; + struct svc_stat *pg_stats; + int (*pg_authenticate)(struct svc_rqst *); + __be32 (*pg_init_request)(struct svc_rqst *, const struct svc_program *, struct svc_process_info *); + int (*pg_rpcbind_set)(struct net *, const struct svc_program *, u32, int, short unsigned int, short unsigned int); }; -struct nfs_seqid { - struct nfs_seqid_counter *sequence; +struct rpc_pipe_msg { struct list_head list; - struct rpc_task *task; + void *data; + size_t len; + size_t copied; + int errno; }; -struct nfs_write_verifier { - char data[8]; +struct rpc_pipe_ops { + ssize_t (*upcall)(struct file *, struct rpc_pipe_msg *, char *, size_t); + ssize_t (*downcall)(struct file *, const char *, size_t); + void (*release_pipe)(struct inode *); + int (*open_pipe)(struct inode *); + void (*destroy_msg)(struct rpc_pipe_msg *); }; -struct nfs_writeverf { - struct nfs_write_verifier verifier; - enum nfs3_stable_how committed; +struct rpc_pipe { + struct list_head pipe; + struct list_head in_upcall; + struct list_head in_downcall; + int pipelen; + int nreaders; + int nwriters; + int flags; + struct delayed_work queue_timeout; + const struct rpc_pipe_ops *ops; + spinlock_t lock; + struct dentry *dentry; }; -struct nfs_pgio_args { - struct nfs4_sequence_args seq_args; - struct nfs_fh *fh; - struct nfs_open_context *context; - struct nfs_lock_context *lock_context; - nfs4_stateid stateid; - __u64 offset; - __u32 count; - unsigned int pgbase; - struct page___2 **pages; - union { - unsigned int replen; - struct { - const u32 *bitmask; - enum nfs3_stable_how stable; - }; - }; +struct rpc_iostats { + spinlock_t om_lock; + long unsigned int om_ops; + long unsigned int om_ntrans; + long unsigned int om_timeouts; + long long unsigned int om_bytes_sent; + long long unsigned int om_bytes_recv; + ktime_t om_queue; + ktime_t om_rtt; + ktime_t om_execute; + long unsigned int om_error_status; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; }; -struct nfs_pgio_res { - struct nfs4_sequence_res seq_res; - struct nfs_fattr *fattr; - __u32 count; - __u32 op_status; - union { - struct { - unsigned int replen; - int eof; - }; - struct { - struct nfs_writeverf *verf; - const struct nfs_server *server; - }; - }; +struct rpc_create_args { + struct net *net; + int protocol; + struct sockaddr *address; + size_t addrsize; + struct sockaddr *saddress; + const struct rpc_timeout *timeout; + const char *servername; + const char *nodename; + const struct rpc_program *program; + u32 prognumber; + u32 version; + rpc_authflavor_t authflavor; + u32 nconnect; + long unsigned int flags; + char *client_name; + struct svc_xprt *bc_xprt; + const struct cred *cred; }; -struct nfs_commitargs { - struct nfs4_sequence_args seq_args; - struct nfs_fh *fh; - __u64 offset; - __u32 count; - const u32 *bitmask; +struct gss_api_mech; + +struct gss_ctx { + struct gss_api_mech *mech_type; + void *internal_ctx_id; }; -struct nfs_commitres { - struct nfs4_sequence_res seq_res; - __u32 op_status; - struct nfs_fattr *fattr; - struct nfs_writeverf *verf; - const struct nfs_server *server; +struct gss_api_ops; + +struct pf_desc; + +struct gss_api_mech { + struct list_head gm_list; + struct module *gm_owner; + struct rpcsec_gss_oid gm_oid; + char *gm_name; + const struct gss_api_ops *gm_ops; + int gm_pf_num; + struct pf_desc *gm_pfs; + const char *gm_upcall_enctypes; }; -struct nfs_removeargs { - struct nfs4_sequence_args seq_args; - const struct nfs_fh *fh; - struct qstr name; +struct pf_desc { + u32 pseudoflavor; + u32 qop; + u32 service; + char *name; + char *auth_domain_name; + bool datatouch; }; -struct nfs_removeres { - struct nfs4_sequence_res seq_res; - struct nfs_server *server; - struct nfs_fattr *dir_attr; - struct nfs4_change_info cinfo; +struct gss_api_ops { + int (*gss_import_sec_context)(const void *, size_t, struct gss_ctx *, time_t *, gfp_t); + u32 (*gss_get_mic)(struct gss_ctx *, struct xdr_buf *, struct xdr_netobj *); + u32 (*gss_verify_mic)(struct gss_ctx *, struct xdr_buf *, struct xdr_netobj *); + u32 (*gss_wrap)(struct gss_ctx *, int, struct xdr_buf *, struct page **); + u32 (*gss_unwrap)(struct gss_ctx *, int, struct xdr_buf *); + void (*gss_delete_sec_context)(void *); }; -struct nfs_renameargs { - struct nfs4_sequence_args seq_args; - const struct nfs_fh *old_dir; - const struct nfs_fh *new_dir; - const struct qstr *old_name; - const struct qstr *new_name; +struct pnfs_layout_range { + u32 iomode; + u64 offset; + u64 length; }; -struct nfs_renameres { - struct nfs4_sequence_res seq_res; - struct nfs_server *server; - struct nfs4_change_info old_cinfo; - struct nfs_fattr *old_fattr; - struct nfs4_change_info new_cinfo; - struct nfs_fattr *new_fattr; +struct pnfs_layout_hdr; + +struct pnfs_layout_segment { + struct list_head pls_list; + struct list_head pls_lc_list; + struct pnfs_layout_range pls_range; + refcount_t pls_refcount; + u32 pls_seq; + long unsigned int pls_flags; + struct pnfs_layout_hdr *pls_layout; }; -struct nfs_entry { - __u64 ino; - __u64 cookie; - __u64 prev_cookie; - const char *name; - unsigned int len; - int eof; - struct nfs_fh *fh; - struct nfs_fattr *fattr; - struct nfs4_label *label; - unsigned char d_type; - struct nfs_server *server; +struct nfs_seqid { + struct nfs_seqid_counter *sequence; + struct list_head list; + struct rpc_task *task; }; struct nfs4_pathname { @@ -45605,59 +49991,9 @@ struct nfs4_fs_locations { struct nfs4_fs_location locations[10]; }; -struct pnfs_ds_commit_info {}; - -struct nfs_page_array { - struct page___2 **pagevec; - unsigned int npages; - struct page___2 *page_array[8]; -}; - -struct nfs_page; - -struct nfs_pgio_completion_ops; - -struct nfs_rw_ops; - -struct nfs_io_completion; - -struct nfs_direct_req; - -struct nfs_pgio_header { - struct inode___2 *inode; - const struct cred___2 *cred; - struct list_head pages; - struct nfs_page *req; - struct nfs_writeverf verf; - fmode_t rw_mode; - struct pnfs_layout_segment *lseg; - loff_t io_start; - const struct rpc_call_ops *mds_ops; - void (*release)(struct nfs_pgio_header *); - const struct nfs_pgio_completion_ops *completion_ops; - const struct nfs_rw_ops *rw_ops; - struct nfs_io_completion *io_completion; - struct nfs_direct_req *dreq; - int pnfs_error; - int error; - unsigned int good_bytes; - long unsigned int flags; - struct rpc_task task; - struct nfs_fattr fattr; - struct nfs_pgio_args args; - struct nfs_pgio_res res; - long unsigned int timestamp; - int (*pgio_done_cb)(struct rpc_task *, struct nfs_pgio_header *); - __u64 mds_offset; - struct nfs_page_array page_array; - struct nfs_client *ds_clp; - int ds_commit_idx; - int pgio_mirror_idx; -}; - struct nfs_page { struct list_head wb_list; - struct page___2 *wb_page; + struct page *wb_page; struct nfs_lock_context *wb_lock_context; long unsigned int wb_index; unsigned int wb_offset; @@ -45671,176 +50007,21 @@ struct nfs_page { short unsigned int wb_nio; }; -struct nfs_pgio_completion_ops { - void (*error_cleanup)(struct list_head *, int); - void (*init_hdr)(struct nfs_pgio_header *); - void (*completion)(struct nfs_pgio_header *); - void (*reschedule_io)(struct nfs_pgio_header *); -}; - -struct nfs_rw_ops { - struct nfs_pgio_header * (*rw_alloc_header)(); - void (*rw_free_header)(struct nfs_pgio_header *); - int (*rw_done)(struct rpc_task *, struct nfs_pgio_header *, struct inode___2 *); - void (*rw_result)(struct rpc_task *, struct nfs_pgio_header *); - void (*rw_initiate)(struct nfs_pgio_header *, struct rpc_message *, const struct nfs_rpc_ops *, struct rpc_task_setup *, int); -}; - -struct nfs_mds_commit_info { - atomic_t rpcs_out; - atomic_long_t ncommit; - struct list_head list; -}; - -struct nfs_commit_data; - -struct nfs_commit_info; - -struct nfs_commit_completion_ops { - void (*completion)(struct nfs_commit_data *); - void (*resched_write)(struct nfs_commit_info *, struct nfs_page *); -}; - -struct nfs_commit_data { - struct rpc_task task; - struct inode___2 *inode; - const struct cred___2 *cred; - struct nfs_fattr fattr; - struct nfs_writeverf verf; - struct list_head pages; - struct list_head list; - struct nfs_direct_req *dreq; - struct nfs_commitargs args; - struct nfs_commitres res; - struct nfs_open_context *context; - struct pnfs_layout_segment *lseg; - struct nfs_client *ds_clp; - int ds_commit_index; - loff_t lwb; - const struct rpc_call_ops *mds_ops; - const struct nfs_commit_completion_ops *completion_ops; - int (*commit_done_cb)(struct rpc_task *, struct nfs_commit_data *); - long unsigned int flags; -}; - -struct nfs_commit_info { - struct inode___2 *inode; - struct nfs_mds_commit_info *mds; - struct pnfs_ds_commit_info *ds; - struct nfs_direct_req *dreq; - const struct nfs_commit_completion_ops *completion_ops; -}; - -struct nfs_unlinkdata { - struct nfs_removeargs args; - struct nfs_removeres res; - struct dentry___2 *dentry; - wait_queue_head_t wq; - const struct cred___2 *cred; - struct nfs_fattr dir_attr; - long int timeout; -}; - -struct nfs_renamedata { - struct nfs_renameargs args; - struct nfs_renameres res; - const struct cred___2 *cred; - struct inode___2 *old_dir; - struct dentry___2 *old_dentry; - struct nfs_fattr old_fattr; - struct inode___2 *new_dir; - struct dentry___2 *new_dentry; - struct nfs_fattr new_fattr; - void (*complete)(struct rpc_task *, struct nfs_renamedata *); - long int timeout; - bool cancelled; -}; - -struct nlmclnt_operations; - -struct nfs_mount_info; - -struct nfs_access_entry; - -struct nfs_client_initdata; - -struct nfs_rpc_ops { - u32 version; - const struct dentry_operations___2 *dentry_ops; - const struct inode_operations___2 *dir_inode_ops; - const struct inode_operations___2 *file_inode_ops; - const struct file_operations___2 *file_ops; - const struct nlmclnt_operations *nlmclnt_ops; - int (*getroot)(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); - struct vfsmount___2 * (*submount)(struct nfs_server *, struct dentry___2 *, struct nfs_fh *, struct nfs_fattr *); - struct dentry___2 * (*try_mount)(int, const char *, struct nfs_mount_info *, struct nfs_subversion *); - int (*getattr)(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *, struct inode___2 *); - int (*setattr)(struct dentry___2 *, struct nfs_fattr *, struct iattr *); - int (*lookup)(struct inode___2 *, const struct qstr *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *); - int (*lookupp)(struct inode___2 *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *); - int (*access)(struct inode___2 *, struct nfs_access_entry *); - int (*readlink)(struct inode___2 *, struct page___2 *, unsigned int, unsigned int); - int (*create)(struct inode___2 *, struct dentry___2 *, struct iattr *, int); - int (*remove)(struct inode___2 *, struct dentry___2 *); - void (*unlink_setup)(struct rpc_message *, struct dentry___2 *, struct inode___2 *); - void (*unlink_rpc_prepare)(struct rpc_task *, struct nfs_unlinkdata *); - int (*unlink_done)(struct rpc_task *, struct inode___2 *); - void (*rename_setup)(struct rpc_message *, struct dentry___2 *, struct dentry___2 *); - void (*rename_rpc_prepare)(struct rpc_task *, struct nfs_renamedata *); - int (*rename_done)(struct rpc_task *, struct inode___2 *, struct inode___2 *); - int (*link)(struct inode___2 *, struct inode___2 *, const struct qstr *); - int (*symlink)(struct inode___2 *, struct dentry___2 *, struct page___2 *, unsigned int, struct iattr *); - int (*mkdir)(struct inode___2 *, struct dentry___2 *, struct iattr *); - int (*rmdir)(struct inode___2 *, const struct qstr *); - int (*readdir)(struct dentry___2 *, const struct cred___2 *, u64, struct page___2 **, unsigned int, bool); - int (*mknod)(struct inode___2 *, struct dentry___2 *, struct iattr *, dev_t); - int (*statfs)(struct nfs_server *, struct nfs_fh *, struct nfs_fsstat *); - int (*fsinfo)(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); - int (*pathconf)(struct nfs_server *, struct nfs_fh *, struct nfs_pathconf *); - int (*set_capabilities)(struct nfs_server *, struct nfs_fh *); - int (*decode_dirent)(struct xdr_stream *, struct nfs_entry *, bool); - int (*pgio_rpc_prepare)(struct rpc_task *, struct nfs_pgio_header *); - void (*read_setup)(struct nfs_pgio_header *, struct rpc_message *); - int (*read_done)(struct rpc_task *, struct nfs_pgio_header *); - void (*write_setup)(struct nfs_pgio_header *, struct rpc_message *, struct rpc_clnt **); - int (*write_done)(struct rpc_task *, struct nfs_pgio_header *); - void (*commit_setup)(struct nfs_commit_data *, struct rpc_message *, struct rpc_clnt **); - void (*commit_rpc_prepare)(struct rpc_task *, struct nfs_commit_data *); - int (*commit_done)(struct rpc_task *, struct nfs_commit_data *); - int (*lock)(struct file___2 *, int, struct file_lock *); - int (*lock_check_bounds)(const struct file_lock *); - void (*clear_acl_cache)(struct inode___2 *); - void (*close_context)(struct nfs_open_context *, int); - struct inode___2 * (*open_context)(struct inode___2 *, struct nfs_open_context *, int, struct iattr *, int *); - int (*have_delegation)(struct inode___2 *, fmode_t); - struct nfs_client * (*alloc_client)(const struct nfs_client_initdata *); - struct nfs_client * (*init_client)(struct nfs_client *, const struct nfs_client_initdata *); - void (*free_client)(struct nfs_client *); - struct nfs_server * (*create_server)(struct nfs_mount_info *, struct nfs_subversion *); - struct nfs_server * (*clone_server)(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, rpc_authflavor_t); -}; - -struct nlmclnt_operations { - void (*nlmclnt_alloc_call)(void *); - bool (*nlmclnt_unlock_prepare)(struct rpc_task *, void *); - void (*nlmclnt_release_call)(void *); -}; - struct nfs_parsed_mount_data; struct nfs_clone_mount; struct nfs_mount_info { - void (*fill_super)(struct super_block___2 *, struct nfs_mount_info *); - int (*set_security)(struct super_block___2 *, struct dentry___2 *, struct nfs_mount_info *); + void (*fill_super)(struct super_block *, struct nfs_mount_info *); + int (*set_security)(struct super_block *, struct dentry *, struct nfs_mount_info *); struct nfs_parsed_mount_data *parsed; struct nfs_clone_mount *cloned; struct nfs_fh *mntfh; }; struct nfs_subversion { - struct module___2 *owner; - struct file_system_type___2 *nfs_fs; + struct module *owner; + struct file_system_type *nfs_fs; const struct rpc_version *rpc_vers; const struct nfs_rpc_ops *rpc_ops; const struct super_operations *sops; @@ -45848,54 +50029,6 @@ struct nfs_subversion { struct list_head list; }; -struct nfs_access_entry { - struct rb_node rb_node; - struct list_head lru; - const struct cred___2 *cred; - __u32 mask; - struct callback_head callback_head; -}; - -struct nfs_client_initdata { - long unsigned int init_flags; - const char *hostname; - const struct sockaddr *addr; - const char *nodename; - const char *ip_addr; - size_t addrlen; - struct nfs_subversion *nfs_mod; - int proto; - u32 minorversion; - unsigned int nconnect; - struct net___2 *net; - const struct rpc_timeout *timeparms; - const struct cred___2 *cred; -}; - -struct nfs4_state_recovery_ops; - -struct nfs4_state_maintenance_ops; - -struct nfs4_mig_recovery_ops; - -struct nfs4_minor_version_ops { - u32 minor_version; - unsigned int init_caps; - int (*init_client)(struct nfs_client *); - void (*shutdown_client)(struct nfs_client *); - bool (*match_stateid)(const nfs4_stateid *, const nfs4_stateid *); - int (*find_root_sec)(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *); - void (*free_lock_state)(struct nfs_server *, struct nfs4_lock_state *); - int (*test_and_free_expired)(struct nfs_server *, nfs4_stateid *, const struct cred___2 *); - struct nfs_seqid * (*alloc_seqid)(struct nfs_seqid_counter *, gfp_t); - void (*session_trunk)(struct rpc_clnt *, struct rpc_xprt *, void *); - const struct rpc_call_ops *call_sync_ops; - const struct nfs4_state_recovery_ops *reboot_recovery_ops; - const struct nfs4_state_recovery_ops *nograce_recovery_ops; - const struct nfs4_state_maintenance_ops *state_renewal_ops; - const struct nfs4_mig_recovery_ops *mig_recovery_ops; -}; - struct nfs_iostats { long long unsigned int bytes[8]; long unsigned int events[27]; @@ -45913,7 +50046,7 @@ struct nfs4_state { struct list_head inode_states; struct list_head lock_states; struct nfs4_state_owner *owner; - struct inode___2 *inode; + struct inode *inode; long unsigned int flags; spinlock_t state_lock; seqlock_t seqlock; @@ -45928,6 +50061,11 @@ struct nfs4_state { struct callback_head callback_head; }; +struct nlmsvc_binding { + __be32 (*fopen)(struct svc_rqst *, struct nfs_fh *, struct file **); + void (*fclose)(struct file *); +}; + struct svc_cred { kuid_t cr_uid; kgid_t cr_gid; @@ -45976,10 +50114,10 @@ struct svc_rqst { size_t rq_xprt_hlen; struct xdr_buf rq_arg; struct xdr_buf rq_res; - struct page___2 *rq_pages[260]; - struct page___2 **rq_respages; - struct page___2 **rq_next_page; - struct page___2 **rq_page_end; + struct page *rq_pages[260]; + struct page **rq_respages; + struct page **rq_next_page; + struct page **rq_page_end; struct kvec rq_vec[259]; __be32 rq_xid; u32 rq_prog; @@ -45999,9 +50137,9 @@ struct svc_rqst { struct auth_domain *rq_client; struct auth_domain *rq_gssclient; struct svc_cacherep *rq_cacherep; - struct task_struct___2 *rq_task; + struct task_struct *rq_task; spinlock_t rq_lock; - struct net___2 *rq_bc_net; + struct net *rq_bc_net; }; struct nlmclnt_initdata { @@ -46011,9 +50149,9 @@ struct nlmclnt_initdata { short unsigned int protocol; u32 nfs_version; int noresvport; - struct net___2 *net; + struct net *net; const struct nlmclnt_operations *nlmclnt_ops; - const struct cred___2 *cred; + const struct cred *cred; }; struct cache_head { @@ -46025,7 +50163,7 @@ struct cache_head { }; struct cache_detail { - struct module___2 *owner; + struct module *owner; int hash_size; struct hlist_head *hash_table; spinlock_t hash_lock; @@ -46051,9 +50189,9 @@ struct cache_detail { time_t last_warn; union { struct proc_dir_entry *procfs; - struct dentry___2 *pipefs; + struct dentry *pipefs; }; - struct net___2 *net; + struct net *net; }; struct cache_deferred_req { @@ -46074,7 +50212,7 @@ struct auth_domain { struct auth_ops { char *name; - struct module___2 *owner; + struct module *owner; int flavour; int (*accept)(struct svc_rqst *, __be32 *); int (*release)(struct svc_rqst *); @@ -46105,11 +50243,11 @@ struct svc_pool { }; struct svc_serv_ops { - void (*svo_shutdown)(struct svc_serv *, struct net___2 *); + void (*svo_shutdown)(struct svc_serv *, struct net *); int (*svo_function)(void *); void (*svo_enqueue_xprt)(struct svc_xprt *); int (*svo_setup)(struct svc_serv *, struct svc_pool *, int); - struct module___2 *svo_module; + struct module *svo_module; }; struct svc_serv { @@ -46177,8 +50315,16 @@ struct svc_version { int (*vs_dispatch)(struct svc_rqst *, __be32 *); }; +struct svc_pool_map { + int count; + int mode; + unsigned int npools; + unsigned int *pool_to; + unsigned int *to_pool; +}; + struct svc_xprt_ops { - struct svc_xprt * (*xpo_create)(struct svc_serv *, struct net___2 *, struct sockaddr *, int, int); + struct svc_xprt * (*xpo_create)(struct svc_serv *, struct net *, struct sockaddr *, int, int); struct svc_xprt * (*xpo_accept)(struct svc_xprt *); int (*xpo_has_wspace)(struct svc_xprt *); int (*xpo_recvfrom)(struct svc_rqst *); @@ -46192,7 +50338,7 @@ struct svc_xprt_ops { struct svc_xprt_class { const char *xcl_name; - struct module___2 *xcl_owner; + struct module *xcl_owner; const struct svc_xprt_ops *xcl_ops; struct list_head xcl_list; u32 xcl_max_payload; @@ -46204,20 +50350,20 @@ struct nfs4_state_recovery_ops { int state_flag_bit; int (*recover_open)(struct nfs4_state_owner *, struct nfs4_state *); int (*recover_lock)(struct nfs4_state *, struct file_lock *); - int (*establish_clid)(struct nfs_client *, const struct cred___2 *); - int (*reclaim_complete)(struct nfs_client *, const struct cred___2 *); - int (*detect_trunking)(struct nfs_client *, struct nfs_client **, const struct cred___2 *); + int (*establish_clid)(struct nfs_client *, const struct cred *); + int (*reclaim_complete)(struct nfs_client *, const struct cred *); + int (*detect_trunking)(struct nfs_client *, struct nfs_client **, const struct cred *); }; struct nfs4_state_maintenance_ops { - int (*sched_state_renewal)(struct nfs_client *, const struct cred___2 *, unsigned int); - const struct cred___2 * (*get_state_renewal_cred)(struct nfs_client *); - int (*renew_lease)(struct nfs_client *, const struct cred___2 *); + int (*sched_state_renewal)(struct nfs_client *, const struct cred *, unsigned int); + const struct cred * (*get_state_renewal_cred)(struct nfs_client *); + int (*renew_lease)(struct nfs_client *, const struct cred *); }; struct nfs4_mig_recovery_ops { - int (*get_locations)(struct inode___2 *, struct nfs4_fs_locations *, struct page___2 *, const struct cred___2 *); - int (*fsid_present)(struct inode___2 *, const struct cred___2 *); + int (*get_locations)(struct inode *, struct nfs4_fs_locations *, struct page *, const struct cred *); + int (*fsid_present)(struct inode *, const struct cred *); }; struct nfs4_state_owner { @@ -46225,7 +50371,7 @@ struct nfs4_state_owner { struct list_head so_lru; long unsigned int so_expires; struct rb_node so_server_node; - const struct cred___2 *so_cred; + const struct cred *so_cred; spinlock_t so_lock; atomic_t so_count; long unsigned int so_flags; @@ -46278,9 +50424,49 @@ enum nfs_stat_eventcounters { __NFSIOS_COUNTSMAX = 27, }; +struct nfs_pageio_descriptor; + +struct nfs_pageio_ops { + void (*pg_init)(struct nfs_pageio_descriptor *, struct nfs_page *); + size_t (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *); + int (*pg_doio)(struct nfs_pageio_descriptor *); + unsigned int (*pg_get_mirror_count)(struct nfs_pageio_descriptor *, struct nfs_page *); + void (*pg_cleanup)(struct nfs_pageio_descriptor *); +}; + +struct nfs_pgio_mirror { + struct list_head pg_list; + long unsigned int pg_bytes_written; + size_t pg_count; + size_t pg_bsize; + unsigned int pg_base; + unsigned char pg_recoalesce: 1; +}; + +struct nfs_pageio_descriptor { + struct inode *pg_inode; + const struct nfs_pageio_ops *pg_ops; + const struct nfs_rw_ops *pg_rw_ops; + int pg_ioflags; + int pg_error; + const struct rpc_call_ops *pg_rpc_callops; + const struct nfs_pgio_completion_ops *pg_completion_ops; + struct pnfs_layout_segment *pg_lseg; + struct nfs_io_completion *pg_io_completion; + struct nfs_direct_req *pg_dreq; + unsigned int pg_bsize; + u32 pg_mirror_count; + struct nfs_pgio_mirror *pg_mirrors; + struct nfs_pgio_mirror pg_mirrors_static[1]; + struct nfs_pgio_mirror *pg_mirrors_dynamic; + u32 pg_mirror_idx; + short unsigned int pg_maxretrans; + unsigned char pg_moreio: 1; +}; + struct nfs_clone_mount { - const struct super_block___2 *sb; - const struct dentry___2 *dentry; + const struct super_block *sb; + const struct dentry *dentry; struct nfs_fh *fh; struct nfs_fattr *fattr; char *hostname; @@ -46328,7 +50514,7 @@ struct nfs_parsed_mount_data { short unsigned int nconnect; } nfs_server; void *lsm_opts; - struct net___2 *net; + struct net *net; }; struct bl_dev_msg { @@ -46358,13 +50544,11 @@ struct nfs_net { }; struct nfs_netns_client { - struct kobject___2 kobject; - struct net___2 *net; + struct kobject kobject; + struct net *net; const char *identifier; }; -typedef int filler_t___2(void *, struct page *); - struct nfs_open_dir_context { struct list_head list; const struct cred *cred; @@ -46420,6 +50604,8 @@ struct nfs_delegation { struct callback_head rcu; }; +struct svc_version___2; + struct nfs_cache_array_entry { u64 cookie; u64 ino; @@ -46452,6 +50638,8 @@ typedef struct { bool eof; } nfs_readdir_descriptor_t; +typedef long long unsigned int pao_T_____7; + struct nfs_find_desc { struct nfs_fh *fh; struct nfs_fattr *fattr; @@ -46725,55 +50913,11 @@ enum { PG_CONTENDED2 = 12, }; -struct nfs_pageio_descriptor; - -struct nfs_pageio_ops { - void (*pg_init)(struct nfs_pageio_descriptor *, struct nfs_page *); - size_t (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *); - int (*pg_doio)(struct nfs_pageio_descriptor *); - unsigned int (*pg_get_mirror_count)(struct nfs_pageio_descriptor *, struct nfs_page *); - void (*pg_cleanup)(struct nfs_pageio_descriptor *); -}; - -struct nfs_pgio_mirror { - struct list_head pg_list; - long unsigned int pg_bytes_written; - size_t pg_count; - size_t pg_bsize; - unsigned int pg_base; - unsigned char pg_recoalesce: 1; -}; - -struct nfs_pageio_descriptor { - struct inode *pg_inode; - const struct nfs_pageio_ops *pg_ops; - const struct nfs_rw_ops *pg_rw_ops; - int pg_ioflags; - int pg_error; - const struct rpc_call_ops *pg_rpc_callops; - const struct nfs_pgio_completion_ops *pg_completion_ops; - struct pnfs_layout_segment *pg_lseg; - struct nfs_io_completion *pg_io_completion; - struct nfs_direct_req *pg_dreq; - unsigned int pg_bsize; - u32 pg_mirror_count; - struct nfs_pgio_mirror *pg_mirrors; - struct nfs_pgio_mirror pg_mirrors_static[1]; - struct nfs_pgio_mirror *pg_mirrors_dynamic; - u32 pg_mirror_idx; - short unsigned int pg_maxretrans; - unsigned char pg_moreio: 1; -}; - -typedef void (*rpc_action)(struct rpc_task *); - struct nfs_readdesc { struct nfs_pageio_descriptor *pgio; struct nfs_open_context *ctx; }; -typedef int (*writepage_t___2)(struct page *, struct writeback_control *, void *); - struct nfs_io_completion { void (*complete)(void *); void *data; @@ -47212,6 +51356,110 @@ struct trace_event_data_offsets_nfs_fh_to_dentry {}; struct trace_event_data_offsets_nfs_xdr_status {}; +typedef void (*btf_trace_nfs_refresh_inode_enter)(void *, const struct inode *); + +typedef void (*btf_trace_nfs_refresh_inode_exit)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs_revalidate_inode_enter)(void *, const struct inode *); + +typedef void (*btf_trace_nfs_revalidate_inode_exit)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs_invalidate_mapping_enter)(void *, const struct inode *); + +typedef void (*btf_trace_nfs_invalidate_mapping_exit)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs_getattr_enter)(void *, const struct inode *); + +typedef void (*btf_trace_nfs_getattr_exit)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs_setattr_enter)(void *, const struct inode *); + +typedef void (*btf_trace_nfs_setattr_exit)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs_writeback_page_enter)(void *, const struct inode *); + +typedef void (*btf_trace_nfs_writeback_page_exit)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs_writeback_inode_enter)(void *, const struct inode *); + +typedef void (*btf_trace_nfs_writeback_inode_exit)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs_fsync_enter)(void *, const struct inode *); + +typedef void (*btf_trace_nfs_fsync_exit)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs_access_enter)(void *, const struct inode *); + +typedef void (*btf_trace_nfs_access_exit)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs_lookup_enter)(void *, const struct inode *, const struct dentry *, unsigned int); + +typedef void (*btf_trace_nfs_lookup_exit)(void *, const struct inode *, const struct dentry *, unsigned int, int); + +typedef void (*btf_trace_nfs_lookup_revalidate_enter)(void *, const struct inode *, const struct dentry *, unsigned int); + +typedef void (*btf_trace_nfs_lookup_revalidate_exit)(void *, const struct inode *, const struct dentry *, unsigned int, int); + +typedef void (*btf_trace_nfs_atomic_open_enter)(void *, const struct inode *, const struct nfs_open_context *, unsigned int); + +typedef void (*btf_trace_nfs_atomic_open_exit)(void *, const struct inode *, const struct nfs_open_context *, unsigned int, int); + +typedef void (*btf_trace_nfs_create_enter)(void *, const struct inode *, const struct dentry *, unsigned int); + +typedef void (*btf_trace_nfs_create_exit)(void *, const struct inode *, const struct dentry *, unsigned int, int); + +typedef void (*btf_trace_nfs_mknod_enter)(void *, const struct inode *, const struct dentry *); + +typedef void (*btf_trace_nfs_mknod_exit)(void *, const struct inode *, const struct dentry *, int); + +typedef void (*btf_trace_nfs_mkdir_enter)(void *, const struct inode *, const struct dentry *); + +typedef void (*btf_trace_nfs_mkdir_exit)(void *, const struct inode *, const struct dentry *, int); + +typedef void (*btf_trace_nfs_rmdir_enter)(void *, const struct inode *, const struct dentry *); + +typedef void (*btf_trace_nfs_rmdir_exit)(void *, const struct inode *, const struct dentry *, int); + +typedef void (*btf_trace_nfs_remove_enter)(void *, const struct inode *, const struct dentry *); + +typedef void (*btf_trace_nfs_remove_exit)(void *, const struct inode *, const struct dentry *, int); + +typedef void (*btf_trace_nfs_unlink_enter)(void *, const struct inode *, const struct dentry *); + +typedef void (*btf_trace_nfs_unlink_exit)(void *, const struct inode *, const struct dentry *, int); + +typedef void (*btf_trace_nfs_symlink_enter)(void *, const struct inode *, const struct dentry *); + +typedef void (*btf_trace_nfs_symlink_exit)(void *, const struct inode *, const struct dentry *, int); + +typedef void (*btf_trace_nfs_link_enter)(void *, const struct inode *, const struct inode *, const struct dentry *); + +typedef void (*btf_trace_nfs_link_exit)(void *, const struct inode *, const struct inode *, const struct dentry *, int); + +typedef void (*btf_trace_nfs_rename_enter)(void *, const struct inode *, const struct dentry *, const struct inode *, const struct dentry *); + +typedef void (*btf_trace_nfs_rename_exit)(void *, const struct inode *, const struct dentry *, const struct inode *, const struct dentry *, int); + +typedef void (*btf_trace_nfs_sillyrename_rename)(void *, const struct inode *, const struct dentry *, const struct inode *, const struct dentry *, int); + +typedef void (*btf_trace_nfs_sillyrename_unlink)(void *, const struct nfs_unlinkdata *, int); + +typedef void (*btf_trace_nfs_initiate_read)(void *, const struct inode *, loff_t, long unsigned int); + +typedef void (*btf_trace_nfs_readpage_done)(void *, const struct inode *, int, loff_t, bool); + +typedef void (*btf_trace_nfs_initiate_write)(void *, const struct inode *, loff_t, long unsigned int, enum nfs3_stable_how); + +typedef void (*btf_trace_nfs_writeback_done)(void *, const struct inode *, int, loff_t, struct nfs_writeverf *); + +typedef void (*btf_trace_nfs_initiate_commit)(void *, const struct nfs_commit_data *); + +typedef void (*btf_trace_nfs_commit_done)(void *, const struct nfs_commit_data *); + +typedef void (*btf_trace_nfs_fh_to_dentry)(void *, const struct super_block *, const struct nfs_fh *, u64, int); + +typedef void (*btf_trace_nfs_xdr_status)(void *, const struct xdr_stream *, int); + enum { FILEID_HIGH_OFF = 0, FILEID_LOW_OFF = 1, @@ -48329,7 +52577,7 @@ struct nfs4_call_sync_data { struct nfs4_open_createattrs { struct nfs4_label *label; struct iattr *sattr; - __u32 verf[2]; + const __u32 verf[2]; }; struct nfs4_closedata { @@ -48991,6 +53239,108 @@ struct trace_event_data_offsets_nfs4_write_event {}; struct trace_event_data_offsets_nfs4_commit_event {}; +typedef void (*btf_trace_nfs4_setclientid)(void *, const struct nfs_client *, int); + +typedef void (*btf_trace_nfs4_setclientid_confirm)(void *, const struct nfs_client *, int); + +typedef void (*btf_trace_nfs4_renew)(void *, const struct nfs_client *, int); + +typedef void (*btf_trace_nfs4_renew_async)(void *, const struct nfs_client *, int); + +typedef void (*btf_trace_nfs4_setup_sequence)(void *, const struct nfs4_session *, const struct nfs4_sequence_args *); + +typedef void (*btf_trace_nfs4_state_mgr)(void *, const struct nfs_client *); + +typedef void (*btf_trace_nfs4_state_mgr_failed)(void *, const struct nfs_client *, const char *, int); + +typedef void (*btf_trace_nfs4_xdr_status)(void *, const struct xdr_stream *, u32, int); + +typedef void (*btf_trace_nfs4_open_reclaim)(void *, const struct nfs_open_context *, int, int); + +typedef void (*btf_trace_nfs4_open_expired)(void *, const struct nfs_open_context *, int, int); + +typedef void (*btf_trace_nfs4_open_file)(void *, const struct nfs_open_context *, int, int); + +typedef void (*btf_trace_nfs4_cached_open)(void *, const struct nfs4_state *); + +typedef void (*btf_trace_nfs4_close)(void *, const struct nfs4_state *, const struct nfs_closeargs *, const struct nfs_closeres *, int); + +typedef void (*btf_trace_nfs4_get_lock)(void *, const struct file_lock *, const struct nfs4_state *, int, int); + +typedef void (*btf_trace_nfs4_unlock)(void *, const struct file_lock *, const struct nfs4_state *, int, int); + +typedef void (*btf_trace_nfs4_set_lock)(void *, const struct file_lock *, const struct nfs4_state *, const nfs4_stateid *, int, int); + +typedef void (*btf_trace_nfs4_state_lock_reclaim)(void *, const struct nfs4_state *, const struct nfs4_lock_state *); + +typedef void (*btf_trace_nfs4_set_delegation)(void *, const struct inode *, fmode_t); + +typedef void (*btf_trace_nfs4_reclaim_delegation)(void *, const struct inode *, fmode_t); + +typedef void (*btf_trace_nfs4_delegreturn_exit)(void *, const struct nfs4_delegreturnargs *, const struct nfs4_delegreturnres *, int); + +typedef void (*btf_trace_nfs4_lookup)(void *, const struct inode *, const struct qstr *, int); + +typedef void (*btf_trace_nfs4_symlink)(void *, const struct inode *, const struct qstr *, int); + +typedef void (*btf_trace_nfs4_mkdir)(void *, const struct inode *, const struct qstr *, int); + +typedef void (*btf_trace_nfs4_mknod)(void *, const struct inode *, const struct qstr *, int); + +typedef void (*btf_trace_nfs4_remove)(void *, const struct inode *, const struct qstr *, int); + +typedef void (*btf_trace_nfs4_get_fs_locations)(void *, const struct inode *, const struct qstr *, int); + +typedef void (*btf_trace_nfs4_secinfo)(void *, const struct inode *, const struct qstr *, int); + +typedef void (*btf_trace_nfs4_lookupp)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs4_rename)(void *, const struct inode *, const struct qstr *, const struct inode *, const struct qstr *, int); + +typedef void (*btf_trace_nfs4_access)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs4_readlink)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs4_readdir)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs4_get_acl)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs4_set_acl)(void *, const struct inode *, int); + +typedef void (*btf_trace_nfs4_setattr)(void *, const struct inode *, const nfs4_stateid *, int); + +typedef void (*btf_trace_nfs4_delegreturn)(void *, const struct inode *, const nfs4_stateid *, int); + +typedef void (*btf_trace_nfs4_open_stateid_update)(void *, const struct inode *, const nfs4_stateid *, int); + +typedef void (*btf_trace_nfs4_open_stateid_update_wait)(void *, const struct inode *, const nfs4_stateid *, int); + +typedef void (*btf_trace_nfs4_getattr)(void *, const struct nfs_server *, const struct nfs_fh *, const struct nfs_fattr *, int); + +typedef void (*btf_trace_nfs4_lookup_root)(void *, const struct nfs_server *, const struct nfs_fh *, const struct nfs_fattr *, int); + +typedef void (*btf_trace_nfs4_fsinfo)(void *, const struct nfs_server *, const struct nfs_fh *, const struct nfs_fattr *, int); + +typedef void (*btf_trace_nfs4_cb_getattr)(void *, const struct nfs_client *, const struct nfs_fh *, const struct inode *, int); + +typedef void (*btf_trace_nfs4_cb_recall)(void *, const struct nfs_client *, const struct nfs_fh *, const struct inode *, const nfs4_stateid *, int); + +typedef void (*btf_trace_nfs4_cb_layoutrecall_file)(void *, const struct nfs_client *, const struct nfs_fh *, const struct inode *, const nfs4_stateid *, int); + +typedef void (*btf_trace_nfs4_map_name_to_uid)(void *, const char *, int, u32, int); + +typedef void (*btf_trace_nfs4_map_group_to_gid)(void *, const char *, int, u32, int); + +typedef void (*btf_trace_nfs4_map_uid_to_name)(void *, const char *, int, u32, int); + +typedef void (*btf_trace_nfs4_map_gid_to_group)(void *, const char *, int, u32, int); + +typedef void (*btf_trace_nfs4_read)(void *, const struct nfs_pgio_header *, int); + +typedef void (*btf_trace_nfs4_write)(void *, const struct nfs_pgio_header *, int); + +typedef void (*btf_trace_nfs4_commit)(void *, const struct nfs_commit_data *, int); + struct getdents_callback___2 { struct dir_context ctx; char *name; @@ -48999,19 +53349,17 @@ struct getdents_callback___2 { int sequence; }; -struct nlm_host___2; - struct nlm_lockowner { struct list_head list; refcount_t count; - struct nlm_host___2 *host; + struct nlm_host *host; fl_owner_t owner; uint32_t pid; }; struct nsm_handle; -struct nlm_host___2 { +struct nlm_host { struct hlist_node h_hash; struct __kernel_sockaddr_storage h_addr; size_t h_addrlen; @@ -49112,7 +53460,7 @@ struct nlm_block; struct nlm_rqst { refcount_t a_count; unsigned int a_flags; - struct nlm_host___2 *a_host; + struct nlm_host *a_host; struct nlm_args a_args; struct nlm_res a_res; struct nlm_block *a_block; @@ -49129,7 +53477,7 @@ struct nlm_block { struct list_head b_flist; struct nlm_rqst *b_call; struct svc_serv *b_daemon; - struct nlm_host___2 *b_host; + struct nlm_host *b_host; long unsigned int b_when; unsigned int b_id; unsigned char b_granted; @@ -49155,7 +53503,7 @@ struct nlm_file { struct nlm_wait { struct list_head b_list; wait_queue_head_t b_wait; - struct nlm_host___2 *b_host; + struct nlm_host *b_host; struct file_lock *b_lock; short unsigned int b_reclaim; __be32 b_status; @@ -49227,43 +53575,6 @@ struct in_device { struct callback_head callback_head; }; -enum netdev_cmd { - NETDEV_UP = 1, - NETDEV_DOWN = 2, - NETDEV_REBOOT = 3, - NETDEV_CHANGE = 4, - NETDEV_REGISTER = 5, - NETDEV_UNREGISTER = 6, - NETDEV_CHANGEMTU = 7, - NETDEV_CHANGEADDR = 8, - NETDEV_PRE_CHANGEADDR = 9, - NETDEV_GOING_DOWN = 10, - NETDEV_CHANGENAME = 11, - NETDEV_FEAT_CHANGE = 12, - NETDEV_BONDING_FAILOVER = 13, - NETDEV_PRE_UP = 14, - NETDEV_PRE_TYPE_CHANGE = 15, - NETDEV_POST_TYPE_CHANGE = 16, - NETDEV_POST_INIT = 17, - NETDEV_RELEASE = 18, - NETDEV_NOTIFY_PEERS = 19, - NETDEV_JOIN = 20, - NETDEV_CHANGEUPPER = 21, - NETDEV_RESEND_IGMP = 22, - NETDEV_PRECHANGEMTU = 23, - NETDEV_CHANGEINFODATA = 24, - NETDEV_BONDING_INFO = 25, - NETDEV_PRECHANGEUPPER = 26, - NETDEV_CHANGELOWERSTATE = 27, - NETDEV_UDP_TUNNEL_PUSH_INFO = 28, - NETDEV_UDP_TUNNEL_DROP_INFO = 29, - NETDEV_CHANGE_TX_QUEUE_LEN = 30, - NETDEV_CVLAN_FILTER_PUSH_INFO = 31, - NETDEV_CVLAN_FILTER_DROP_INFO = 32, - NETDEV_SVLAN_FILTER_PUSH_INFO = 33, - NETDEV_SVLAN_FILTER_DROP_INFO = 34, -}; - struct in_ifaddr { struct hlist_node hash; struct in_ifaddr *ifa_next; @@ -49313,22 +53624,21 @@ struct inet6_ifaddr { struct in6_addr peer_addr; }; -struct nlmsvc_binding { - __be32 (*fopen)(struct svc_rqst *, struct nfs_fh *, struct file **); - void (*fclose)(struct file *); -}; - -typedef int (*nlm_host_match_fn_t)(void *, struct nlm_host___2 *); +typedef int (*nlm_host_match_fn_t)(void *, struct nlm_host *); struct nlm_share { struct nlm_share *s_next; - struct nlm_host___2 *s_host; + struct nlm_host *s_host; struct nlm_file *s_file; struct xdr_netobj s_owner; u32 s_access; u32 s_mode; }; +struct rpc_version___2; + +struct rpc_program___2; + enum { NSMPROC_NULL = 0, NSMPROC_STAT = 1, @@ -49437,17 +53747,6 @@ enum { Opt_ignore___2 = 11, }; -struct autofs_packet_hdr { - int proto_version; - int type; -}; - -struct autofs_packet_expire { - struct autofs_packet_hdr hdr; - int len; - char name[256]; -}; - enum { AUTOFS_IOC_READY_CMD = 96, AUTOFS_IOC_FAIL_CMD = 97, @@ -49469,6 +53768,11 @@ enum { AUTOFS_IOC_ASKUMOUNT_CMD = 112, }; +struct autofs_packet_hdr { + int proto_version; + int type; +}; + struct autofs_packet_missing { struct autofs_packet_hdr hdr; autofs_wqt_t wait_queue_token; @@ -49476,6 +53780,12 @@ struct autofs_packet_missing { char name[256]; }; +struct autofs_packet_expire { + struct autofs_packet_hdr hdr; + int len; + char name[256]; +}; + struct autofs_packet_expire_multi { struct autofs_packet_hdr hdr; autofs_wqt_t wait_queue_token; @@ -49618,6 +53928,8 @@ enum { typedef int (*ioctl_fn)(struct file *, struct autofs_sb_info *, struct autofs_dev_ioctl *); +typedef struct vfsmount * (*debugfs_automount_t)(struct dentry *, void *); + struct debugfs_fsdata { const struct file_operations *real_fops; refcount_t active_users; @@ -49721,11 +54033,6 @@ struct compat_ipc_perm { short unsigned int seq; }; -struct rhlist_head { - struct rhash_head rhead; - struct rhlist_head *next; -}; - struct ipc_perm { __kernel_key_t key; __kernel_uid_t uid; @@ -50547,6 +54854,13 @@ union security_list_options { int (*audit_rule_known)(struct audit_krule *); int (*audit_rule_match)(u32, u32, u32, void *); void (*audit_rule_free)(void *); + int (*bpf)(int, union bpf_attr *, unsigned int); + int (*bpf_map)(struct bpf_map *, fmode_t); + int (*bpf_prog)(struct bpf_prog *); + int (*bpf_map_alloc_security)(struct bpf_map *); + void (*bpf_map_free_security)(struct bpf_map *); + int (*bpf_prog_alloc_security)(struct bpf_prog_aux *); + void (*bpf_prog_free_security)(struct bpf_prog_aux *); int (*locked_down)(enum lockdown_reason); int (*perf_event_open)(struct perf_event_attr *, int); int (*perf_event_alloc)(struct perf_event *); @@ -50746,6 +55060,13 @@ struct security_hook_heads { struct hlist_head audit_rule_known; struct hlist_head audit_rule_match; struct hlist_head audit_rule_free; + struct hlist_head bpf; + struct hlist_head bpf_map; + struct hlist_head bpf_prog; + struct hlist_head bpf_map_alloc_security; + struct hlist_head bpf_map_free_security; + struct hlist_head bpf_prog_alloc_security; + struct hlist_head bpf_prog_free_security; struct hlist_head locked_down; struct hlist_head perf_event_open; struct hlist_head perf_event_alloc; @@ -50788,7 +55109,7 @@ enum lsm_event { LSM_POLICY_CHANGE = 0, }; -typedef int (*initxattrs___2)(struct inode *, const struct xattr *, void *); +typedef int (*initxattrs)(struct inode *, const struct xattr *, void *); enum ib_uverbs_write_cmds { IB_USER_VERBS_CMD_GET_CONTEXT = 0, @@ -50866,6 +55187,14 @@ enum ib_uverbs_access_flags { IB_UVERBS_ACCESS_HUGETLB = 128, }; +union ib_gid { + u8 raw[16]; + struct { + __be64 subnet_prefix; + __be64 interface_id; + } global; +}; + struct lsm_network_audit { int netif; struct sock *sk; @@ -51046,6 +55375,12 @@ struct avc_callback_node { typedef __u16 __sum16; +typedef u16 u_int16_t; + +struct rhltable { + struct rhashtable ht; +}; + enum sctp_endpoint_type { SCTP_EP_TYPE_SOCKET = 0, SCTP_EP_TYPE_ASSOCIATION = 1, @@ -51103,37 +55438,19 @@ struct sctp_endpoint { u32 peer_secid; }; -struct inet_listen_hashbucket { - spinlock_t lock; - unsigned int count; - union { - struct hlist_head head; - struct hlist_nulls_head nulls_head; - }; -}; - -struct inet_ehash_bucket; - -struct inet_bind_hashbucket; - -struct inet_hashinfo { - struct inet_ehash_bucket *ehash; - spinlock_t *ehash_locks; - unsigned int ehash_mask; - unsigned int ehash_locks_mask; - struct kmem_cache *bind_bucket_cachep; - struct inet_bind_hashbucket *bhash; - unsigned int bhash_size; - unsigned int lhash2_mask; - struct inet_listen_hashbucket *lhash2; - long: 64; - struct inet_listen_hashbucket listening_hash[32]; +enum ip_conntrack_info { + IP_CT_ESTABLISHED = 0, + IP_CT_RELATED = 1, + IP_CT_NEW = 2, + IP_CT_IS_REPLY = 3, + IP_CT_ESTABLISHED_REPLY = 3, + IP_CT_RELATED_REPLY = 4, + IP_CT_NUMBER = 5, + IP_CT_UNTRACKED = 7, }; -struct tcp_fastopen_context { - siphash_key_t key[2]; - int num; - struct callback_head rcu; +struct nf_conntrack { + atomic_t use; }; struct nf_hook_state; @@ -51174,12 +55491,6 @@ enum nf_nat_manip_type { NF_NAT_MANIP_DST = 1, }; -enum ip_conntrack_dir { - IP_CT_DIR_ORIGINAL = 0, - IP_CT_DIR_REPLY = 1, - IP_CT_DIR_MAX = 2, -}; - struct nf_conn; struct nf_nat_hook { @@ -51188,6 +55499,175 @@ struct nf_nat_hook { unsigned int (*manip_pkt)(struct sk_buff *, struct nf_conn *, enum nf_nat_manip_type, enum ip_conntrack_dir); }; +union nf_inet_addr { + __u32 all[4]; + __be32 ip; + __be32 ip6[4]; + struct in_addr in; + struct in6_addr in6; +}; + +union nf_conntrack_man_proto { + __be16 all; + struct { + __be16 port; + } tcp; + struct { + __be16 port; + } udp; + struct { + __be16 id; + } icmp; + struct { + __be16 port; + } dccp; + struct { + __be16 port; + } sctp; + struct { + __be16 key; + } gre; +}; + +struct nf_conntrack_man { + union nf_inet_addr u3; + union nf_conntrack_man_proto u; + u_int16_t l3num; +}; + +struct nf_conntrack_tuple { + struct nf_conntrack_man src; + struct { + union nf_inet_addr u3; + union { + __be16 all; + struct { + __be16 port; + } tcp; + struct { + __be16 port; + } udp; + struct { + u_int8_t type; + u_int8_t code; + } icmp; + struct { + __be16 port; + } dccp; + struct { + __be16 port; + } sctp; + struct { + __be16 key; + } gre; + } u; + u_int8_t protonum; + u_int8_t dir; + } dst; +}; + +struct nf_conntrack_tuple_hash { + struct hlist_nulls_node hnnode; + struct nf_conntrack_tuple tuple; +}; + +typedef u32 u_int32_t; + +typedef u64 u_int64_t; + +struct nf_ct_dccp { + u_int8_t role[2]; + u_int8_t state; + u_int8_t last_pkt; + u_int8_t last_dir; + u_int64_t handshake_seq; +}; + +struct ip_ct_sctp { + enum sctp_conntrack state; + __be32 vtag[2]; +}; + +struct ip_ct_tcp_state { + u_int32_t td_end; + u_int32_t td_maxend; + u_int32_t td_maxwin; + u_int32_t td_maxack; + u_int8_t td_scale; + u_int8_t flags; +}; + +struct ip_ct_tcp { + struct ip_ct_tcp_state seen[2]; + u_int8_t state; + u_int8_t last_dir; + u_int8_t retrans; + u_int8_t last_index; + u_int32_t last_seq; + u_int32_t last_ack; + u_int32_t last_end; + u_int16_t last_win; + u_int8_t last_wscale; + u_int8_t last_flags; +}; + +struct nf_ct_udp { + long unsigned int stream_ts; +}; + +struct nf_ct_gre { + unsigned int stream_timeout; + unsigned int timeout; +}; + +union nf_conntrack_proto { + struct nf_ct_dccp dccp; + struct ip_ct_sctp sctp; + struct ip_ct_tcp tcp; + struct nf_ct_udp udp; + struct nf_ct_gre gre; + unsigned int tmpl_padto; +}; + +struct nf_ct_ext; + +struct nf_conn { + struct nf_conntrack ct_general; + spinlock_t lock; + u32 timeout; + struct nf_conntrack_tuple_hash tuplehash[2]; + long unsigned int status; + u16 cpu; + possible_net_t ct_net; + struct hlist_node nat_bysource; + u8 __nfct_init_offset[0]; + struct nf_conn *master; + u_int32_t secmark; + struct nf_ct_ext *ext; + union nf_conntrack_proto proto; +}; + +struct nf_conntrack_zone { + u16 id; + u8 flags; + u8 dir; +}; + +struct nf_ct_hook { + int (*update)(struct net *, struct sk_buff *); + void (*destroy)(struct nf_conntrack *); + bool (*get_tuple_skb)(struct nf_conntrack_tuple *, const struct sk_buff *); +}; + +struct nfnl_ct_hook { + struct nf_conn * (*get_ct)(const struct sk_buff *, enum ip_conntrack_info *); + size_t (*build_size)(const struct nf_conn *); + int (*build)(struct sk_buff *, struct nf_conn *, enum ip_conntrack_info, u_int16_t, u_int16_t); + int (*parse)(const struct nlattr *, struct nf_conn *); + int (*attach_expect)(const struct nlattr *, struct nf_conn *, u32, u32); + void (*seq_adjust)(struct sk_buff *, struct nf_conn *, enum ip_conntrack_info, s32); +}; + enum nf_ip_hook_priorities { NF_IP_PRI_FIRST = 2147483648, NF_IP_PRI_RAW_BEFORE_DEFRAG = 4294966846, @@ -51223,33 +55703,6 @@ enum nf_ip6_hook_priorities { NF_IP6_PRI_LAST = 2147483647, }; -enum { - TCPF_ESTABLISHED = 2, - TCPF_SYN_SENT = 4, - TCPF_SYN_RECV = 8, - TCPF_FIN_WAIT1 = 16, - TCPF_FIN_WAIT2 = 32, - TCPF_TIME_WAIT = 64, - TCPF_CLOSE = 128, - TCPF_CLOSE_WAIT = 256, - TCPF_LAST_ACK = 512, - TCPF_LISTEN = 1024, - TCPF_CLOSING = 2048, - TCPF_NEW_SYN_RECV = 4096, -}; - -struct sock_reuseport { - struct callback_head rcu; - u16 max_socks; - u16 num_socks; - unsigned int synq_overflow_ts; - unsigned int reuseport_id; - unsigned int bind_inany: 1; - unsigned int has_conns: 1; - struct bpf_prog *prog; - struct sock *socks[0]; -}; - struct socket_alloc { struct socket socket; struct inode vfs_inode; @@ -51556,15 +56009,6 @@ struct ip6_flowlabel { struct net *fl_net; }; -struct inet_ehash_bucket { - struct hlist_nulls_head chain; -}; - -struct inet_bind_hashbucket { - spinlock_t lock; - struct hlist_head chain; -}; - struct inet_skb_parm { int iif; struct ip_options opt; @@ -51572,28 +56016,6 @@ struct inet_skb_parm { u16 frag_max_size; }; -struct ack_sample { - u32 pkts_acked; - s32 rtt_us; - u32 in_flight; -}; - -struct rate_sample { - u64 prior_mstamp; - u32 prior_delivered; - s32 delivered; - long int interval_us; - u32 snd_interval_us; - u32 rcv_interval_us; - long int rtt_us; - int losses; - u32 acked_sacked; - u32 prior_in_flight; - bool is_app_limited; - bool is_retrans; - bool is_ack_delayed; -}; - struct nf_ipv6_ops { void (*route_input)(struct sk_buff *); int (*fragment)(struct net *, struct sock *, struct sk_buff *, int (*)(struct net *, struct sock *, struct sk_buff *)); @@ -51615,6 +56037,11 @@ struct tty_file_private { struct list_head list; }; +struct icmp_err { + int errno; + unsigned int fatal: 1; +}; + struct netlbl_lsm_cache { refcount_t refcount; void (*free)(const void *); @@ -52436,6 +56863,28 @@ struct sctp_bind_bucket { struct net *net; }; +struct sctp_bind_hashbucket { + spinlock_t lock; + struct hlist_head chain; +}; + +struct sctp_hashbucket { + rwlock_t lock; + struct hlist_head chain; +}; + +struct sctp_globals { + struct list_head address_families; + struct sctp_hashbucket *ep_hashtable; + struct sctp_bind_hashbucket *port_hashtable; + struct rhltable transport_hashtable; + int ep_hashsize; + int port_hashsize; + __u16 max_instreams; + __u16 max_outstreams; + bool checksum_disable; +}; + enum sctp_socket_type { SCTP_SOCKET_UDP = 0, SCTP_SOCKET_UDP_HIGH_BANDWIDTH = 1, @@ -52758,6 +57207,10 @@ struct key_security_struct { u32 sid; }; +struct bpf_security_struct { + u32 sid; +}; + struct perf_event_security_struct { u32 sid; }; @@ -52941,11 +57394,6 @@ struct nlmsg_perm { u32 perm; }; -struct netdev_notifier_info { - struct net_device *dev; - struct netlink_ext_ack *extack; -}; - struct netif_security_struct { struct net *ns; int ifindex; @@ -53439,8 +57887,6 @@ struct unix_sock { spinlock_t lock; long unsigned int gc_flags; long: 64; - long: 64; - long: 64; struct socket_wq peer_wq; wait_queue_entry_t peer_wake; long: 64; @@ -54129,6 +58575,8 @@ struct rsa_mpi_key { MPI d; }; +struct crypto_template___2; + struct asn1_decoder___2; struct rsa_asn1_template { @@ -54602,7 +59050,7 @@ struct asymmetric_key_ids { struct public_key_signature; -struct asymmetric_key_subtype { +struct asymmetric_key_subtype___2 { struct module *owner; const char *name; short unsigned int name_len; @@ -54996,6 +59444,8 @@ enum { BLK_MQ_REQ_PREEMPT = 8, }; +struct blk_integrity_profile; + struct trace_event_raw_block_buffer { struct trace_entry ent; dev_t dev; @@ -55167,6 +59617,42 @@ struct trace_event_data_offsets_block_bio_remap {}; struct trace_event_data_offsets_block_rq_remap {}; +typedef void (*btf_trace_block_touch_buffer)(void *, struct buffer_head *); + +typedef void (*btf_trace_block_dirty_buffer)(void *, struct buffer_head *); + +typedef void (*btf_trace_block_rq_requeue)(void *, struct request_queue *, struct request *); + +typedef void (*btf_trace_block_rq_complete)(void *, struct request *, int, unsigned int); + +typedef void (*btf_trace_block_rq_insert)(void *, struct request_queue *, struct request *); + +typedef void (*btf_trace_block_rq_issue)(void *, struct request_queue *, struct request *); + +typedef void (*btf_trace_block_bio_bounce)(void *, struct request_queue *, struct bio *); + +typedef void (*btf_trace_block_bio_complete)(void *, struct request_queue *, struct bio *, int); + +typedef void (*btf_trace_block_bio_backmerge)(void *, struct request_queue *, struct request *, struct bio *); + +typedef void (*btf_trace_block_bio_frontmerge)(void *, struct request_queue *, struct request *, struct bio *); + +typedef void (*btf_trace_block_bio_queue)(void *, struct request_queue *, struct bio *); + +typedef void (*btf_trace_block_getrq)(void *, struct request_queue *, struct bio *, int); + +typedef void (*btf_trace_block_sleeprq)(void *, struct request_queue *, struct bio *, int); + +typedef void (*btf_trace_block_plug)(void *, struct request_queue *); + +typedef void (*btf_trace_block_unplug)(void *, struct request_queue *, unsigned int, bool); + +typedef void (*btf_trace_block_split)(void *, struct request_queue *, struct bio *, unsigned int); + +typedef void (*btf_trace_block_bio_remap)(void *, struct request_queue *, struct bio *, dev_t, sector_t); + +typedef void (*btf_trace_block_rq_remap)(void *, struct request_queue *, struct request *, dev_t, sector_t); + struct queue_sysfs_entry { struct attribute attr; ssize_t (*show)(struct request_queue *, char *); @@ -55205,8 +59691,6 @@ struct req_iterator { typedef bool (*sb_for_each_fn)(struct sbitmap *, unsigned int, void *); -typedef bool busy_iter_fn(struct blk_mq_hw_ctx *, struct request *, void *, bool); - enum { BLK_MQ_UNIQUE_TAG_BITS = 16, BLK_MQ_UNIQUE_TAG_MASK = 65535, @@ -55244,6 +59728,8 @@ struct sbq_wait { struct wait_queue_entry wait; }; +typedef bool busy_iter_fn(struct blk_mq_hw_ctx *, struct request *, void *, bool); + typedef bool busy_tag_iter_fn(struct request *, void *, bool); struct bt_iter_data { @@ -55387,8 +59873,6 @@ struct badblocks { sector_t size; }; -typedef struct kobject *kobj_probe_t___2(dev_t, int *, void *); - struct blk_major_name { struct blk_major_name *next; int major; @@ -55664,6 +60148,10 @@ struct compat_sg_io_hdr { compat_uint_t info; }; +enum { + OMAX_SB_LEN = 16, +}; + struct bsg_device { struct request_queue *queue; spinlock_t lock; @@ -55721,6 +60209,12 @@ struct trace_event_data_offsets_kyber_adjust {}; struct trace_event_data_offsets_kyber_throttled {}; +typedef void (*btf_trace_kyber_latency)(void *, struct request_queue *, const char *, const char *, unsigned int, unsigned int, unsigned int, unsigned int); + +typedef void (*btf_trace_kyber_adjust)(void *, struct request_queue *, const char *, unsigned int); + +typedef void (*btf_trace_kyber_throttled)(void *, struct request_queue *, const char *); + enum { KYBER_READ = 0, KYBER_WRITE = 1, @@ -55837,6 +60331,8 @@ struct show_busy_params { struct blk_mq_hw_ctx *hctx; }; +typedef void (*swap_func_t)(void *, void *, int); + typedef int (*cmp_r_func_t)(const void *, const void *, const void *); typedef __kernel_long_t __kernel_ptrdiff_t; @@ -55892,10 +60388,6 @@ struct __kfifo { void *data; }; -struct rhltable { - struct rhashtable ht; -}; - struct rhashtable_walker { struct list_head list; struct bucket_table *tbl; @@ -56008,6 +60500,8 @@ struct genpool_data_fixed { long unsigned int offset; }; +typedef z_stream *z_streamp; + typedef struct { unsigned char op; unsigned char bits; @@ -56087,17 +60581,17 @@ union uu { typedef unsigned int uInt; +struct inflate_workspace { + struct inflate_state inflate_state; + unsigned char working_window[32768]; +}; + typedef enum { CODES = 0, LENS = 1, DISTS = 2, } codetype; -struct inflate_workspace { - struct inflate_state inflate_state; - unsigned char working_window[32768]; -}; - typedef unsigned char uch; typedef short unsigned int ush; @@ -56491,6 +60985,8 @@ struct xz_dec_bcj___2 { } temp; }; +typedef s32 pao_T_____8; + struct ei_entry { struct list_head list; long unsigned int start_addr; @@ -56563,6 +61059,8 @@ struct font_desc { int pref; }; +typedef u16 ucs2_char_t; + struct msr { union { struct { @@ -56600,6 +61098,12 @@ struct trace_event_raw_msr_trace_class { struct trace_event_data_offsets_msr_trace_class {}; +typedef void (*btf_trace_read_msr)(void *, unsigned int, u64, int); + +typedef void (*btf_trace_write_msr)(void *, unsigned int, u64, int); + +typedef void (*btf_trace_rdpmc)(void *, unsigned int, u64, int); + struct pci_sriov { int pos; int nres; @@ -56747,14 +61251,6 @@ enum { PCI_SCAN_ALL_PCIE_DEVS = 64, }; -enum pcie_bus_config_types { - PCIE_BUS_TUNE_OFF = 0, - PCIE_BUS_DEFAULT = 1, - PCIE_BUS_SAFE = 2, - PCIE_BUS_PERFORMANCE = 3, - PCIE_BUS_PEER2PEER = 4, -}; - struct hotplug_slot_ops { int (*enable_slot)(struct hotplug_slot *); int (*disable_slot)(struct hotplug_slot *); @@ -56863,12 +61359,6 @@ enum pci_ers_result { PCI_ERS_RESULT_NO_AER_DRIVER = 6, }; -enum dev_dma_attr { - DEV_DMA_NOT_SUPPORTED = 0, - DEV_DMA_NON_COHERENT = 1, - DEV_DMA_COHERENT = 2, -}; - struct pcie_device { int irq; struct pci_dev *port; @@ -57192,28 +61682,6 @@ enum hpx_type3_cfg_loc { HPX_CFG_MAX = 5, }; -enum device_link_state { - DL_STATE_NONE = 4294967295, - DL_STATE_DORMANT = 0, - DL_STATE_AVAILABLE = 1, - DL_STATE_CONSUMER_PROBE = 2, - DL_STATE_ACTIVE = 3, - DL_STATE_SUPPLIER_UNBIND = 4, -}; - -struct device_link { - struct device *supplier; - struct list_head s_node; - struct device *consumer; - struct list_head c_node; - enum device_link_state status; - u32 flags; - refcount_t rpm_active; - struct kref kref; - struct callback_head callback_head; - bool supplier_preactivated; -}; - enum pci_irq_reroute_variant { INTEL_IRQ_REROUTE_VARIANT = 1, MAX_IRQ_REROUTE_VARIANTS = 3, @@ -57369,8 +61837,6 @@ struct pci_dev_acs_ops { int (*disable_acs_redir)(struct pci_dev *); }; -typedef acpi_status (*acpi_walk_callback)(acpi_handle, u32, void *, void **); - struct msix_entry { u32 vector; u16 entry; @@ -57703,114 +62169,6 @@ union hdmi_infoframe { struct hdmi_drm_infoframe drm; }; -struct console_font { - unsigned int width; - unsigned int height; - unsigned int charcount; - unsigned char *data; -}; - -struct vt_mode { - char mode; - char waitv; - short int relsig; - short int acqsig; - short int frsig; -}; - -struct uni_pagedir; - -struct uni_screen; - -struct vc_data { - struct tty_port port; - short unsigned int vc_num; - unsigned int vc_cols; - unsigned int vc_rows; - unsigned int vc_size_row; - unsigned int vc_scan_lines; - long unsigned int vc_origin; - long unsigned int vc_scr_end; - long unsigned int vc_visible_origin; - unsigned int vc_top; - unsigned int vc_bottom; - const struct consw *vc_sw; - short unsigned int *vc_screenbuf; - unsigned int vc_screenbuf_size; - unsigned char vc_mode; - unsigned char vc_attr; - unsigned char vc_def_color; - unsigned char vc_color; - unsigned char vc_s_color; - unsigned char vc_ulcolor; - unsigned char vc_itcolor; - unsigned char vc_halfcolor; - unsigned int vc_cursor_type; - short unsigned int vc_complement_mask; - short unsigned int vc_s_complement_mask; - unsigned int vc_x; - unsigned int vc_y; - unsigned int vc_saved_x; - unsigned int vc_saved_y; - long unsigned int vc_pos; - short unsigned int vc_hi_font_mask; - struct console_font vc_font; - short unsigned int vc_video_erase_char; - unsigned int vc_state; - unsigned int vc_npar; - unsigned int vc_par[16]; - struct vt_mode vt_mode; - struct pid *vt_pid; - int vt_newvt; - wait_queue_head_t paste_wait; - unsigned int vc_charset: 1; - unsigned int vc_s_charset: 1; - unsigned int vc_disp_ctrl: 1; - unsigned int vc_toggle_meta: 1; - unsigned int vc_decscnm: 1; - unsigned int vc_decom: 1; - unsigned int vc_decawm: 1; - unsigned int vc_deccm: 1; - unsigned int vc_decim: 1; - unsigned int vc_intensity: 2; - unsigned int vc_italic: 1; - unsigned int vc_underline: 1; - unsigned int vc_blink: 1; - unsigned int vc_reverse: 1; - unsigned int vc_s_intensity: 2; - unsigned int vc_s_italic: 1; - unsigned int vc_s_underline: 1; - unsigned int vc_s_blink: 1; - unsigned int vc_s_reverse: 1; - unsigned int vc_priv: 3; - unsigned int vc_need_wrap: 1; - unsigned int vc_can_do_color: 1; - unsigned int vc_report_mouse: 2; - unsigned char vc_utf: 1; - unsigned char vc_utf_count; - int vc_utf_char; - unsigned int vc_tab_stop[8]; - unsigned char vc_palette[48]; - short unsigned int *vc_translate; - unsigned char vc_G0_charset; - unsigned char vc_G1_charset; - unsigned char vc_saved_G0; - unsigned char vc_saved_G1; - unsigned int vc_resize_user; - unsigned int vc_bell_pitch; - unsigned int vc_bell_duration; - short unsigned int vc_cur_blink_ms; - struct vc_data **vc_display_fg; - struct uni_pagedir *vc_uni_pagedir; - struct uni_pagedir **vc_uni_pagedir_loc; - struct uni_screen *vc_uni_screen; -}; - -struct vc { - struct vc_data *d; - struct work_struct SAK_work; -}; - struct vgastate { void *vgabase; long unsigned int membase; @@ -57844,71 +62202,6 @@ struct linux_logo { const unsigned char *data; }; -struct fb_fix_screeninfo { - char id[16]; - long unsigned int smem_start; - __u32 smem_len; - __u32 type; - __u32 type_aux; - __u32 visual; - __u16 xpanstep; - __u16 ypanstep; - __u16 ywrapstep; - __u32 line_length; - long unsigned int mmio_start; - __u32 mmio_len; - __u32 accel; - __u16 capabilities; - __u16 reserved[2]; -}; - -struct fb_bitfield { - __u32 offset; - __u32 length; - __u32 msb_right; -}; - -struct fb_var_screeninfo { - __u32 xres; - __u32 yres; - __u32 xres_virtual; - __u32 yres_virtual; - __u32 xoffset; - __u32 yoffset; - __u32 bits_per_pixel; - __u32 grayscale; - struct fb_bitfield red; - struct fb_bitfield green; - struct fb_bitfield blue; - struct fb_bitfield transp; - __u32 nonstd; - __u32 activate; - __u32 height; - __u32 width; - __u32 accel_flags; - __u32 pixclock; - __u32 left_margin; - __u32 right_margin; - __u32 upper_margin; - __u32 lower_margin; - __u32 hsync_len; - __u32 vsync_len; - __u32 sync; - __u32 vmode; - __u32 rotate; - __u32 colorspace; - __u32 reserved[4]; -}; - -struct fb_cmap { - __u32 start; - __u32 len; - __u16 *red; - __u16 *green; - __u16 *blue; - __u16 *transp; -}; - enum { FB_BLANK_UNBLANK = 0, FB_BLANK_NORMAL = 1, @@ -57917,283 +62210,11 @@ enum { FB_BLANK_POWERDOWN = 4, }; -struct fb_copyarea { - __u32 dx; - __u32 dy; - __u32 width; - __u32 height; - __u32 sx; - __u32 sy; -}; - -struct fb_fillrect { - __u32 dx; - __u32 dy; - __u32 width; - __u32 height; - __u32 color; - __u32 rop; -}; - -struct fb_image { - __u32 dx; - __u32 dy; - __u32 width; - __u32 height; - __u32 fg_color; - __u32 bg_color; - __u8 depth; - const char *data; - struct fb_cmap cmap; -}; - -struct fbcurpos { - __u16 x; - __u16 y; -}; - -struct fb_cursor { - __u16 set; - __u16 enable; - __u16 rop; - const char *mask; - struct fbcurpos hot; - struct fb_image image; -}; - -struct fb_chroma { - __u32 redx; - __u32 greenx; - __u32 bluex; - __u32 whitex; - __u32 redy; - __u32 greeny; - __u32 bluey; - __u32 whitey; -}; - -struct fb_videomode; - -struct fb_monspecs { - struct fb_chroma chroma; - struct fb_videomode *modedb; - __u8 manufacturer[4]; - __u8 monitor[14]; - __u8 serial_no[14]; - __u8 ascii[14]; - __u32 modedb_len; - __u32 model; - __u32 serial; - __u32 year; - __u32 week; - __u32 hfmin; - __u32 hfmax; - __u32 dclkmin; - __u32 dclkmax; - __u16 input; - __u16 dpms; - __u16 signal; - __u16 vfmin; - __u16 vfmax; - __u16 gamma; - __u16 gtf: 1; - __u16 misc; - __u8 version; - __u8 revision; - __u8 max_x; - __u8 max_y; -}; - -struct fb_videomode { - const char *name; - u32 refresh; - u32 xres; - u32 yres; - u32 pixclock; - u32 left_margin; - u32 right_margin; - u32 upper_margin; - u32 lower_margin; - u32 hsync_len; - u32 vsync_len; - u32 sync; - u32 vmode; - u32 flag; -}; - -struct fb_info; - struct fb_event { struct fb_info *info; void *data; }; -struct fb_pixmap { - u8 *addr; - u32 size; - u32 offset; - u32 buf_align; - u32 scan_align; - u32 access_align; - u32 flags; - u32 blit_x; - u32 blit_y; - void (*writeio)(struct fb_info *, void *, void *, unsigned int); - void (*readio)(struct fb_info *, void *, void *, unsigned int); -}; - -struct fb_deferred_io; - -struct fb_ops; - -struct fb_tile_ops; - -struct apertures_struct; - -struct fb_info { - atomic_t count; - int node; - int flags; - int fbcon_rotate_hint; - struct mutex lock; - struct mutex mm_lock; - struct fb_var_screeninfo var; - struct fb_fix_screeninfo fix; - struct fb_monspecs monspecs; - struct work_struct queue; - struct fb_pixmap pixmap; - struct fb_pixmap sprite; - struct fb_cmap cmap; - struct list_head modelist; - struct fb_videomode *mode; - struct delayed_work deferred_work; - struct fb_deferred_io *fbdefio; - struct fb_ops *fbops; - struct device *device; - struct device *dev; - int class_flag; - struct fb_tile_ops *tileops; - union { - char *screen_base; - char *screen_buffer; - }; - long unsigned int screen_size; - void *pseudo_palette; - u32 state; - void *fbcon_par; - void *par; - struct apertures_struct *apertures; - bool skip_vt_switch; -}; - -struct fb_blit_caps { - u32 x; - u32 y; - u32 len; - u32 flags; -}; - -struct fb_deferred_io { - long unsigned int delay; - struct mutex lock; - struct list_head pagelist; - void (*first_io)(struct fb_info *); - void (*deferred_io)(struct fb_info *, struct list_head *); -}; - -struct fb_ops { - struct module *owner; - int (*fb_open)(struct fb_info *, int); - int (*fb_release)(struct fb_info *, int); - ssize_t (*fb_read)(struct fb_info *, char *, size_t, loff_t *); - ssize_t (*fb_write)(struct fb_info *, const char *, size_t, loff_t *); - int (*fb_check_var)(struct fb_var_screeninfo *, struct fb_info *); - int (*fb_set_par)(struct fb_info *); - int (*fb_setcolreg)(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, struct fb_info *); - int (*fb_setcmap)(struct fb_cmap *, struct fb_info *); - int (*fb_blank)(int, struct fb_info *); - int (*fb_pan_display)(struct fb_var_screeninfo *, struct fb_info *); - void (*fb_fillrect)(struct fb_info *, const struct fb_fillrect *); - void (*fb_copyarea)(struct fb_info *, const struct fb_copyarea *); - void (*fb_imageblit)(struct fb_info *, const struct fb_image *); - int (*fb_cursor)(struct fb_info *, struct fb_cursor *); - int (*fb_sync)(struct fb_info *); - int (*fb_ioctl)(struct fb_info *, unsigned int, long unsigned int); - int (*fb_compat_ioctl)(struct fb_info *, unsigned int, long unsigned int); - int (*fb_mmap)(struct fb_info *, struct vm_area_struct *); - void (*fb_get_caps)(struct fb_info *, struct fb_blit_caps *, struct fb_var_screeninfo *); - void (*fb_destroy)(struct fb_info *); - int (*fb_debug_enter)(struct fb_info *); - int (*fb_debug_leave)(struct fb_info *); -}; - -struct fb_tilemap { - __u32 width; - __u32 height; - __u32 depth; - __u32 length; - const __u8 *data; -}; - -struct fb_tilerect { - __u32 sx; - __u32 sy; - __u32 width; - __u32 height; - __u32 index; - __u32 fg; - __u32 bg; - __u32 rop; -}; - -struct fb_tilearea { - __u32 sx; - __u32 sy; - __u32 dx; - __u32 dy; - __u32 width; - __u32 height; -}; - -struct fb_tileblit { - __u32 sx; - __u32 sy; - __u32 width; - __u32 height; - __u32 fg; - __u32 bg; - __u32 length; - __u32 *indices; -}; - -struct fb_tilecursor { - __u32 sx; - __u32 sy; - __u32 mode; - __u32 shape; - __u32 fg; - __u32 bg; -}; - -struct fb_tile_ops { - void (*fb_settile)(struct fb_info *, struct fb_tilemap *); - void (*fb_tilecopy)(struct fb_info *, struct fb_tilearea *); - void (*fb_tilefill)(struct fb_info *, struct fb_tilerect *); - void (*fb_tileblit)(struct fb_info *, struct fb_tileblit *); - void (*fb_tilecursor)(struct fb_info *, struct fb_tilecursor *); - int (*fb_get_tilemax)(struct fb_info *); -}; - -struct aperture { - resource_size_t base; - resource_size_t size; -}; - -struct apertures_struct { - unsigned int count; - struct aperture ranges[0]; -}; - enum backlight_update_reason { BACKLIGHT_UPDATE_HOTKEY = 0, BACKLIGHT_UPDATE_SYSFS = 1, @@ -58305,13 +62326,6 @@ struct fb_cmap32 { compat_caddr_t transp; }; -struct dmt_videomode { - u32 dmt_id; - u32 std_2byte_code; - u32 cvt_3byte_code; - const struct fb_videomode *mode; -}; - struct broken_edid { u8 manufacturer[4]; u32 model; @@ -58501,6 +62515,31 @@ struct acpi_madt_generic_distributor { u8 reserved2[3]; }; +typedef int (*acpi_tbl_table_handler)(struct acpi_table_header *); + +struct transaction; + +struct acpi_ec { + acpi_handle handle; + int gpe; + int irq; + long unsigned int command_addr; + long unsigned int data_addr; + bool global_lock; + long unsigned int flags; + long unsigned int reference_count; + struct mutex mutex; + wait_queue_head_t wait; + struct list_head list; + struct transaction *curr; + spinlock_t lock; + struct work_struct work; + long unsigned int timestamp; + long unsigned int nr_pending_queries; + bool busy_polling; + unsigned int polling_guard; +}; + enum acpi_subtable_type { ACPI_SUBTABLE_COMMON = 0, ACPI_SUBTABLE_HMAT = 1, @@ -58528,7 +62567,7 @@ struct acpi_platform_list { u32 data; }; -typedef u32 (*acpi_interface_handler)(acpi_string, u32); +typedef char *acpi_string; struct acpi_osi_entry { char string[64]; @@ -58545,6 +62584,8 @@ struct acpi_osi_config { unsigned int darwin_cmdline: 1; }; +typedef u32 acpi_name; + struct acpi_predefined_names { const char *name; u8 type; @@ -58555,16 +62596,30 @@ typedef u32 (*acpi_osd_handler)(void *); typedef void (*acpi_osd_exec_callback)(void *); +typedef u32 (*acpi_sci_handler)(void *); + +typedef void (*acpi_gbl_event_handler)(u32, acpi_handle, u32, void *); + +typedef u32 (*acpi_event_handler)(void *); + typedef u32 (*acpi_gpe_handler)(acpi_handle, u32, void *); typedef void (*acpi_notify_handler)(acpi_handle, u32, void *); typedef void (*acpi_object_handler)(acpi_handle, void *); +typedef acpi_status (*acpi_init_handler)(acpi_handle, u32); + +typedef acpi_status (*acpi_exception_handler)(acpi_status, acpi_name, u16, u32, void *); + +typedef acpi_status (*acpi_table_handler)(u32, void *, void *); + typedef acpi_status (*acpi_adr_space_handler)(u32, acpi_physical_address, u32, u64 *, void *, void *); typedef acpi_status (*acpi_adr_space_setup)(acpi_handle, u32, void *, void **); +typedef u32 (*acpi_interface_handler)(acpi_string, u32); + struct acpi_pci_id { u16 segment; u16 bus; @@ -58580,6 +62635,20 @@ struct acpi_mem_space_context { acpi_size mapped_length; }; +struct acpi_table_facs { + char signature[4]; + u32 length; + u32 hardware_signature; + u32 firmware_waking_vector; + u32 global_lock; + u32 flags; + u64 xfirmware_waking_vector; + u8 version; + u8 reserved[3]; + u32 ospm_flags; + u8 reserved1[24]; +}; + typedef enum { OSL_GLOBAL_LOCK_HANDLER = 0, OSL_NOTIFY_HANDLER = 1, @@ -58590,6 +62659,18 @@ typedef enum { OSL_EC_BURST_HANDLER = 6, } acpi_execute_type; +struct acpi_rw_lock { + void *writer_mutex; + void *reader_mutex; + u32 num_readers; +}; + +struct acpi_mutex_info { + void *mutex; + u32 use_count; + u64 thread_id; +}; + union acpi_operand_object; struct acpi_namespace_node { @@ -58986,6 +63067,13 @@ union acpi_operand_object { struct acpi_namespace_node node; }; +struct acpi_table_list { + struct acpi_table_desc *tables; + u32 current_table_count; + u32 max_table_count; + u8 flags; +}; + union acpi_parse_object; union acpi_generic_state; @@ -59064,6 +63152,12 @@ struct acpi_walk_state { acpi_parse_upwards ascending_callback; }; +struct acpi_sci_handler_info { + struct acpi_sci_handler_info *next; + acpi_sci_handler address; + void *context; +}; + struct acpi_gpe_handler_info { acpi_gpe_handler address; void *context; @@ -59128,6 +63222,18 @@ struct acpi_gpe_xrupt_info { u32 interrupt_number; }; +struct acpi_fixed_event_handler { + acpi_event_handler handler; + void *context; +}; + +struct acpi_fixed_event_info { + u8 status_register_id; + u8 enable_register_id; + u16 status_bit_mask; + u16 enable_bit_mask; +}; + struct acpi_common_state { void *next; u8 descriptor_type; @@ -59325,6 +63431,13 @@ union acpi_generic_state { struct acpi_notify_info notify; }; +struct acpi_address_range { + struct acpi_address_range *next; + struct acpi_namespace_node *region_node; + acpi_physical_address start_address; + acpi_physical_address end_address; +}; + struct acpi_opcode_info { u32 parse_args; u32 runtime_args; @@ -59334,6 +63447,24 @@ struct acpi_opcode_info { u8 type; }; +struct acpi_comment_node { + char *comment; + struct acpi_comment_node *next; +}; + +struct acpi_bit_register_info { + u8 parent_register; + u8 bit_position; + u16 access_bit_mask; +}; + +struct acpi_interface_info { + char *name; + struct acpi_interface_info *next; + u8 flags; + u8 value; +}; + struct acpi_os_dpc { acpi_osd_exec_callback function; void *context; @@ -59354,6 +63485,11 @@ struct acpi_hp_work { u32 src; }; +struct acpi_object_list { + u32 count; + union acpi_object *pointer; +}; + struct acpi_pld_info { u8 revision; u8 ignore_color; @@ -59419,20 +63555,6 @@ struct nvs_page { typedef u32 acpi_event_status; -struct acpi_table_facs { - char signature[4]; - u32 length; - u32 hardware_signature; - u32 firmware_waking_vector; - u32 global_lock; - u32 flags; - u64 xfirmware_waking_vector; - u8 version; - u8 reserved[3]; - u32 ospm_flags; - u8 reserved1[24]; -}; - struct lpi_device_info { char *name; int enabled; @@ -59479,10 +63601,6 @@ struct acpi_device_physical_node { bool put_online: 1; }; -typedef u32 (*acpi_event_handler)(void *); - -typedef acpi_status (*acpi_table_handler)(u32, void *, void *); - enum acpi_bus_device_type { ACPI_BUS_TYPE_DEVICE = 0, ACPI_BUS_TYPE_POWER = 1, @@ -59501,6 +63619,12 @@ struct acpi_osc_context { struct acpi_buffer ret; }; +enum dev_dma_attr { + DEV_DMA_NOT_SUPPORTED = 0, + DEV_DMA_NON_COHERENT = 1, + DEV_DMA_COHERENT = 2, +}; + struct acpi_pnp_device_id { u32 length; char *string; @@ -59952,8 +64076,6 @@ struct acpi_resource { union acpi_resource_data data; } __attribute__((packed)); -typedef acpi_status (*acpi_walk_resource_callback)(struct acpi_resource *, void *); - enum acpi_reconfig_event { ACPI_RECONFIG_DEVICE_ADD = 0, ACPI_RECONFIG_DEVICE_REMOVE = 1, @@ -59999,309 +64121,6 @@ struct res_proc_context { int error; }; -struct thermal_cooling_device_ops; - -struct thermal_cooling_device { - int id; - char type[20]; - struct device device; - struct device_node *np; - void *devdata; - void *stats; - const struct thermal_cooling_device_ops *ops; - bool updated; - struct mutex lock; - struct list_head thermal_instances; - struct list_head node; -}; - -enum thermal_device_mode { - THERMAL_DEVICE_DISABLED = 0, - THERMAL_DEVICE_ENABLED = 1, -}; - -enum thermal_trip_type { - THERMAL_TRIP_ACTIVE = 0, - THERMAL_TRIP_PASSIVE = 1, - THERMAL_TRIP_HOT = 2, - THERMAL_TRIP_CRITICAL = 3, -}; - -enum thermal_trend { - THERMAL_TREND_STABLE = 0, - THERMAL_TREND_RAISING = 1, - THERMAL_TREND_DROPPING = 2, - THERMAL_TREND_RAISE_FULL = 3, - THERMAL_TREND_DROP_FULL = 4, -}; - -enum thermal_notify_event { - THERMAL_EVENT_UNSPECIFIED = 0, - THERMAL_EVENT_TEMP_SAMPLE = 1, - THERMAL_TRIP_VIOLATED = 2, - THERMAL_TRIP_CHANGED = 3, - THERMAL_DEVICE_DOWN = 4, - THERMAL_DEVICE_UP = 5, - THERMAL_DEVICE_POWER_CAPABILITY_CHANGED = 6, - THERMAL_TABLE_CHANGED = 7, -}; - -struct thermal_zone_device; - -struct thermal_zone_device_ops { - int (*bind)(struct thermal_zone_device *, struct thermal_cooling_device *); - int (*unbind)(struct thermal_zone_device *, struct thermal_cooling_device *); - int (*get_temp)(struct thermal_zone_device *, int *); - int (*set_trips)(struct thermal_zone_device *, int, int); - int (*get_mode)(struct thermal_zone_device *, enum thermal_device_mode *); - int (*set_mode)(struct thermal_zone_device *, enum thermal_device_mode); - int (*get_trip_type)(struct thermal_zone_device *, int, enum thermal_trip_type *); - int (*get_trip_temp)(struct thermal_zone_device *, int, int *); - int (*set_trip_temp)(struct thermal_zone_device *, int, int); - int (*get_trip_hyst)(struct thermal_zone_device *, int, int *); - int (*set_trip_hyst)(struct thermal_zone_device *, int, int); - int (*get_crit_temp)(struct thermal_zone_device *, int *); - int (*set_emul_temp)(struct thermal_zone_device *, int); - int (*get_trend)(struct thermal_zone_device *, int, enum thermal_trend *); - int (*notify)(struct thermal_zone_device *, int, enum thermal_trip_type); -}; - -struct thermal_attr; - -struct thermal_zone_params; - -struct thermal_governor; - -struct thermal_zone_device { - int id; - char type[20]; - struct device device; - struct attribute_group trips_attribute_group; - struct thermal_attr *trip_temp_attrs; - struct thermal_attr *trip_type_attrs; - struct thermal_attr *trip_hyst_attrs; - void *devdata; - int trips; - long unsigned int trips_disabled; - int passive_delay; - int polling_delay; - int temperature; - int last_temperature; - int emul_temperature; - int passive; - int prev_low_trip; - int prev_high_trip; - unsigned int forced_passive; - atomic_t need_update; - struct thermal_zone_device_ops *ops; - struct thermal_zone_params *tzp; - struct thermal_governor *governor; - void *governor_data; - struct list_head thermal_instances; - struct ida ida; - struct mutex lock; - struct list_head node; - struct delayed_work poll_queue; - enum thermal_notify_event notify_event; -}; - -struct thermal_cooling_device_ops { - int (*get_max_state)(struct thermal_cooling_device *, long unsigned int *); - int (*get_cur_state)(struct thermal_cooling_device *, long unsigned int *); - int (*set_cur_state)(struct thermal_cooling_device *, long unsigned int); - int (*get_requested_power)(struct thermal_cooling_device *, struct thermal_zone_device *, u32 *); - int (*state2power)(struct thermal_cooling_device *, struct thermal_zone_device *, long unsigned int, u32 *); - int (*power2state)(struct thermal_cooling_device *, struct thermal_zone_device *, u32, long unsigned int *); -}; - -struct thermal_attr { - struct device_attribute attr; - char name[20]; -}; - -struct thermal_bind_params; - -struct thermal_zone_params { - char governor_name[20]; - bool no_hwmon; - int num_tbps; - struct thermal_bind_params *tbp; - u32 sustainable_power; - s32 k_po; - s32 k_pu; - s32 k_i; - s32 k_d; - s32 integral_cutoff; - int slope; - int offset; -}; - -struct thermal_governor { - char name[20]; - int (*bind_to_tz)(struct thermal_zone_device *); - void (*unbind_from_tz)(struct thermal_zone_device *); - int (*throttle)(struct thermal_zone_device *, int); - struct list_head governor_list; -}; - -struct thermal_bind_params { - struct thermal_cooling_device *cdev; - int weight; - int trip_mask; - long unsigned int *binding_limits; - int (*match)(struct thermal_zone_device *, struct thermal_cooling_device *); -}; - -struct acpi_lpi_state { - u32 min_residency; - u32 wake_latency; - u32 flags; - u32 arch_flags; - u32 res_cnt_freq; - u32 enable_parent_state; - u64 address; - u8 index; - u8 entry_method; - char desc[32]; -}; - -struct acpi_processor_power { - int count; - union { - struct acpi_processor_cx states[8]; - struct acpi_lpi_state lpi_states[8]; - }; - int timer_broadcast_on_state; -}; - -struct acpi_psd_package { - u64 num_entries; - u64 revision; - u64 domain; - u64 coord_type; - u64 num_processors; -}; - -struct acpi_pct_register { - u8 descriptor; - u16 length; - u8 space_id; - u8 bit_width; - u8 bit_offset; - u8 reserved; - u64 address; -} __attribute__((packed)); - -struct acpi_processor_px { - u64 core_frequency; - u64 power; - u64 transition_latency; - u64 bus_master_latency; - u64 control; - u64 status; -}; - -struct acpi_processor_performance { - unsigned int state; - unsigned int platform_limit; - struct acpi_pct_register control_register; - struct acpi_pct_register status_register; - short: 16; - unsigned int state_count; - int: 32; - struct acpi_processor_px *states; - struct acpi_psd_package domain_info; - cpumask_var_t shared_cpu_map; - unsigned int shared_type; - int: 32; -} __attribute__((packed)); - -struct acpi_tsd_package { - u64 num_entries; - u64 revision; - u64 domain; - u64 coord_type; - u64 num_processors; -}; - -struct acpi_processor_tx_tss { - u64 freqpercentage; - u64 power; - u64 transition_latency; - u64 control; - u64 status; -}; - -struct acpi_processor_tx { - u16 power; - u16 performance; -}; - -struct acpi_processor; - -struct acpi_processor_throttling { - unsigned int state; - unsigned int platform_limit; - struct acpi_pct_register control_register; - struct acpi_pct_register status_register; - short: 16; - unsigned int state_count; - int: 32; - struct acpi_processor_tx_tss *states_tss; - struct acpi_tsd_package domain_info; - cpumask_var_t shared_cpu_map; - int (*acpi_processor_get_throttling)(struct acpi_processor *); - int (*acpi_processor_set_throttling)(struct acpi_processor *, int, bool); - u32 address; - u8 duty_offset; - u8 duty_width; - u8 tsd_valid_flag; - char: 8; - unsigned int shared_type; - struct acpi_processor_tx states[16]; - int: 32; -} __attribute__((packed)); - -struct acpi_processor_lx { - int px; - int tx; -}; - -struct acpi_processor_limit { - struct acpi_processor_lx state; - struct acpi_processor_lx thermal; - struct acpi_processor_lx user; -}; - -struct acpi_processor { - acpi_handle handle; - u32 acpi_id; - phys_cpuid_t phys_id; - u32 id; - u32 pblk; - int performance_platform_limit; - int throttling_platform_limit; - struct acpi_processor_flags flags; - struct acpi_processor_power power; - struct acpi_processor_performance *performance; - struct acpi_processor_throttling throttling; - struct acpi_processor_limit limit; - struct thermal_cooling_device *cdev; - struct device *dev; - struct freq_qos_request perflib_req; - struct freq_qos_request thermal_req; -}; - -struct acpi_processor_errata { - u8 smp; - struct { - u8 throttle: 1; - u8 fdma: 1; - u8 reserved: 6; - u32 bmisx; - } piix4; -}; - struct acpi_table_ecdt { struct acpi_table_header header; struct acpi_generic_address control; @@ -60311,29 +64130,6 @@ struct acpi_table_ecdt { u8 id[1]; } __attribute__((packed)); -struct transaction; - -struct acpi_ec { - acpi_handle handle; - int gpe; - int irq; - long unsigned int command_addr; - long unsigned int data_addr; - bool global_lock; - long unsigned int flags; - long unsigned int reference_count; - struct mutex mutex; - wait_queue_head_t wait; - struct list_head list; - struct transaction *curr; - spinlock_t lock; - struct work_struct work; - long unsigned int timestamp; - long unsigned int nr_pending_queries; - bool busy_polling; - unsigned int polling_guard; -}; - struct transaction { const u8 *wdata; u8 *rdata; @@ -60473,6 +64269,73 @@ struct prt_quirk { const char *actual_source; }; +struct clk_core; + +struct clk_init_data; + +struct clk_hw { + struct clk_core *core; + struct clk *clk; + const struct clk_init_data *init; +}; + +struct clk_rate_request { + long unsigned int rate; + long unsigned int min_rate; + long unsigned int max_rate; + long unsigned int best_parent_rate; + struct clk_hw *best_parent_hw; +}; + +struct clk_duty { + unsigned int num; + unsigned int den; +}; + +struct clk_ops { + int (*prepare)(struct clk_hw *); + void (*unprepare)(struct clk_hw *); + int (*is_prepared)(struct clk_hw *); + void (*unprepare_unused)(struct clk_hw *); + int (*enable)(struct clk_hw *); + void (*disable)(struct clk_hw *); + int (*is_enabled)(struct clk_hw *); + void (*disable_unused)(struct clk_hw *); + int (*save_context)(struct clk_hw *); + void (*restore_context)(struct clk_hw *); + long unsigned int (*recalc_rate)(struct clk_hw *, long unsigned int); + long int (*round_rate)(struct clk_hw *, long unsigned int, long unsigned int *); + int (*determine_rate)(struct clk_hw *, struct clk_rate_request *); + int (*set_parent)(struct clk_hw *, u8); + u8 (*get_parent)(struct clk_hw *); + int (*set_rate)(struct clk_hw *, long unsigned int, long unsigned int); + int (*set_rate_and_parent)(struct clk_hw *, long unsigned int, long unsigned int, u8); + long unsigned int (*recalc_accuracy)(struct clk_hw *, long unsigned int); + int (*get_phase)(struct clk_hw *); + int (*set_phase)(struct clk_hw *, int); + int (*get_duty_cycle)(struct clk_hw *, struct clk_duty *); + int (*set_duty_cycle)(struct clk_hw *, struct clk_duty *); + void (*init)(struct clk_hw *); + void (*debug_init)(struct clk_hw *, struct dentry *); +}; + +struct clk_parent_data { + const struct clk_hw *hw; + const char *fw_name; + const char *name; + int index; +}; + +struct clk_init_data { + const char *name; + const struct clk_ops *ops; + const char * const *parent_names; + const struct clk_parent_data *parent_data; + const struct clk_hw **parent_hws; + u8 num_parents; + long unsigned int flags; +}; + struct apd_private_data; struct apd_device_desc { @@ -60550,8 +64413,6 @@ struct acpi_ged_event { acpi_handle handle; }; -typedef void (*acpi_gbl_event_handler)(u32, acpi_handle, u32, void *); - struct acpi_table_bert { struct acpi_table_header header; u32 region_length; @@ -60631,6 +64492,66 @@ struct lpit_residency_info { void *iomem_addr; }; +enum { + ACPI_REFCLASS_LOCAL = 0, + ACPI_REFCLASS_ARG = 1, + ACPI_REFCLASS_REFOF = 2, + ACPI_REFCLASS_INDEX = 3, + ACPI_REFCLASS_TABLE = 4, + ACPI_REFCLASS_NAME = 5, + ACPI_REFCLASS_DEBUG = 6, + ACPI_REFCLASS_MAX = 6, +}; + +struct acpi_common_descriptor { + void *common_pointer; + u8 descriptor_type; +}; + +union acpi_descriptor { + struct acpi_common_descriptor common; + union acpi_operand_object object; + struct acpi_namespace_node node; + union acpi_parse_object op; +}; + +struct acpi_create_field_info { + struct acpi_namespace_node *region_node; + struct acpi_namespace_node *field_node; + struct acpi_namespace_node *register_node; + struct acpi_namespace_node *data_register_node; + struct acpi_namespace_node *connection_node; + u8 *resource_buffer; + u32 bank_value; + u32 field_bit_position; + u32 field_bit_length; + u16 resource_length; + u16 pin_number_index; + u8 field_flags; + u8 attribute; + u8 field_type; + u8 access_length; +}; + +struct acpi_init_walk_info { + u32 table_index; + u32 object_count; + u32 method_count; + u32 serial_method_count; + u32 non_serial_method_count; + u32 serialized_method_count; + u32 device_count; + u32 op_region_count; + u32 field_count; + u32 buffer_count; + u32 package_count; + u32 op_region_init; + u32 field_init; + u32 buffer_init; + u32 package_init; + acpi_owner_id owner_id; +}; + struct acpi_name_info { char name[4]; u16 argument_list; @@ -60697,76 +64618,6 @@ struct acpi_evaluate_info { u8 flags; }; -enum { - ACPI_REFCLASS_LOCAL = 0, - ACPI_REFCLASS_ARG = 1, - ACPI_REFCLASS_REFOF = 2, - ACPI_REFCLASS_INDEX = 3, - ACPI_REFCLASS_TABLE = 4, - ACPI_REFCLASS_NAME = 5, - ACPI_REFCLASS_DEBUG = 6, - ACPI_REFCLASS_MAX = 6, -}; - -struct acpi_common_descriptor { - void *common_pointer; - u8 descriptor_type; -}; - -union acpi_descriptor { - struct acpi_common_descriptor common; - union acpi_operand_object object; - struct acpi_namespace_node node; - union acpi_parse_object op; -}; - -typedef enum { - ACPI_IMODE_LOAD_PASS1 = 1, - ACPI_IMODE_LOAD_PASS2 = 2, - ACPI_IMODE_EXECUTE = 3, -} acpi_interpreter_mode; - -struct acpi_create_field_info { - struct acpi_namespace_node *region_node; - struct acpi_namespace_node *field_node; - struct acpi_namespace_node *register_node; - struct acpi_namespace_node *data_register_node; - struct acpi_namespace_node *connection_node; - u8 *resource_buffer; - u32 bank_value; - u32 field_bit_position; - u32 field_bit_length; - u16 resource_length; - u16 pin_number_index; - u8 field_flags; - u8 attribute; - u8 field_type; - u8 access_length; -}; - -struct acpi_init_walk_info { - u32 table_index; - u32 object_count; - u32 method_count; - u32 serial_method_count; - u32 non_serial_method_count; - u32 serialized_method_count; - u32 device_count; - u32 op_region_count; - u32 field_count; - u32 buffer_count; - u32 package_count; - u32 op_region_init; - u32 field_init; - u32 buffer_init; - u32 package_init; - acpi_owner_id owner_id; -}; - -typedef u32 acpi_name; - -typedef acpi_status (*acpi_exception_handler)(acpi_status, acpi_name, u16, u32, void *); - enum { AML_FIELD_ACCESS_ANY = 0, AML_FIELD_ACCESS_BYTE = 1, @@ -60776,21 +64627,13 @@ enum { AML_FIELD_ACCESS_BUFFER = 5, }; -typedef acpi_status (*acpi_execute_op)(struct acpi_walk_state *); - -struct acpi_fixed_event_handler { - acpi_event_handler handler; - void *context; -}; - -struct acpi_fixed_event_info { - u8 status_register_id; - u8 enable_register_id; - u16 status_bit_mask; - u16 enable_bit_mask; -}; +typedef enum { + ACPI_IMODE_LOAD_PASS1 = 1, + ACPI_IMODE_LOAD_PASS2 = 2, + ACPI_IMODE_EXECUTE = 3, +} acpi_interpreter_mode; -typedef u32 acpi_mutex_handle; +typedef acpi_status (*acpi_execute_op)(struct acpi_walk_state *); struct acpi_gpe_walk_info { struct acpi_namespace_node *gpe_device; @@ -60821,14 +64664,6 @@ struct acpi_reg_walk_info { acpi_adr_space_type space_id; }; -typedef u32 (*acpi_sci_handler)(void *); - -struct acpi_sci_handler_info { - struct acpi_sci_handler_info *next; - acpi_sci_handler address; - void *context; -}; - enum { AML_FIELD_UPDATE_PRESERVE = 0, AML_FIELD_UPDATE_WRITE_AS_ONES = 32, @@ -60869,12 +64704,6 @@ typedef enum { ACPI_TRACE_AML_REGION = 2, } acpi_trace_event_type; -struct acpi_bit_register_info { - u8 parent_register; - u8 bit_position; - u16 access_bit_mask; -}; - struct acpi_port_info { char *name; u16 start; @@ -60887,8 +64716,6 @@ struct acpi_pci_device { struct acpi_pci_device *next; }; -typedef acpi_status (*acpi_init_handler)(acpi_handle, u32); - struct acpi_device_walk_info { struct acpi_table_desc *table_desc; struct acpi_evaluate_info *evaluate_info; @@ -60897,15 +64724,6 @@ struct acpi_device_walk_info { u32 num_INI; }; -typedef acpi_status (*acpi_pkg_callback)(u8, union acpi_operand_object *, union acpi_generic_state *, void *); - -struct acpi_table_list { - struct acpi_table_desc *tables; - u32 current_table_count; - u32 max_table_count; - u8 flags; -}; - enum acpi_return_package_types { ACPI_PTYPE1_FIXED = 1, ACPI_PTYPE1_VAR = 2, @@ -60948,11 +64766,7 @@ struct acpi_namestring_info { u8 fully_qualified; }; -struct acpi_rw_lock { - void *writer_mutex; - void *reader_mutex; - u32 num_readers; -}; +typedef acpi_status (*acpi_walk_callback)(acpi_handle, u32, void *, void **); struct acpi_get_devices_info { acpi_walk_callback user_function; @@ -61361,8 +65175,6 @@ enum { typedef u16 acpi_rs_length; -typedef acpi_status (*acpi_walk_aml_callback)(u8 *, u32, u32, u8, void **); - typedef u32 acpi_rsdesc_size; struct acpi_vendor_uuid { @@ -61370,6 +65182,8 @@ struct acpi_vendor_uuid { u8 data[16]; }; +typedef acpi_status (*acpi_walk_resource_callback)(struct acpi_resource *, void *); + struct acpi_vendor_walk_info { struct acpi_vendor_uuid *uuid; struct acpi_buffer *buffer; @@ -61403,13 +65217,6 @@ struct acpi_table_rsdp { u8 reserved[3]; } __attribute__((packed)); -struct acpi_address_range { - struct acpi_address_range *next; - struct acpi_namespace_node *region_node; - acpi_physical_address start_address; - acpi_physical_address end_address; -}; - struct acpi_pkg_info { u8 *free_space; acpi_size length; @@ -61421,23 +65228,11 @@ struct acpi_exception_info { char *name; }; -struct acpi_mutex_info { - void *mutex; - u32 use_count; - u64 thread_id; -}; +typedef acpi_status (*acpi_pkg_callback)(u8, union acpi_operand_object *, union acpi_generic_state *, void *); -struct acpi_comment_node { - char *comment; - struct acpi_comment_node *next; -}; +typedef u32 acpi_mutex_handle; -struct acpi_interface_info { - char *name; - struct acpi_interface_info *next; - u8 flags; - u8 value; -}; +typedef acpi_status (*acpi_walk_aml_callback)(u8 *, u32, u32, u8, void **); enum led_brightness { LED_OFF = 0, @@ -62340,16 +66135,6 @@ struct acpi_offsets { u8 mode; }; -struct acpi_table_bgrt { - struct acpi_table_header header; - u16 version; - u8 status; - u8 image_type; - u64 image_address; - u32 image_offset_x; - u32 image_offset_y; -}; - struct acpi_pcct_hw_reduced { struct acpi_subtable_header header; u32 platform_interrupt; @@ -62602,8 +66387,6 @@ struct clk_bulk_devres { int num_clks; }; -struct clk_hw; - struct clk_lookup { struct list_head node; const char *dev_id; @@ -62612,73 +66395,6 @@ struct clk_lookup { struct clk_hw *clk_hw; }; -struct clk_core; - -struct clk_init_data; - -struct clk_hw { - struct clk_core *core; - struct clk *clk; - const struct clk_init_data *init; -}; - -struct clk_rate_request { - long unsigned int rate; - long unsigned int min_rate; - long unsigned int max_rate; - long unsigned int best_parent_rate; - struct clk_hw *best_parent_hw; -}; - -struct clk_duty { - unsigned int num; - unsigned int den; -}; - -struct clk_ops { - int (*prepare)(struct clk_hw *); - void (*unprepare)(struct clk_hw *); - int (*is_prepared)(struct clk_hw *); - void (*unprepare_unused)(struct clk_hw *); - int (*enable)(struct clk_hw *); - void (*disable)(struct clk_hw *); - int (*is_enabled)(struct clk_hw *); - void (*disable_unused)(struct clk_hw *); - int (*save_context)(struct clk_hw *); - void (*restore_context)(struct clk_hw *); - long unsigned int (*recalc_rate)(struct clk_hw *, long unsigned int); - long int (*round_rate)(struct clk_hw *, long unsigned int, long unsigned int *); - int (*determine_rate)(struct clk_hw *, struct clk_rate_request *); - int (*set_parent)(struct clk_hw *, u8); - u8 (*get_parent)(struct clk_hw *); - int (*set_rate)(struct clk_hw *, long unsigned int, long unsigned int); - int (*set_rate_and_parent)(struct clk_hw *, long unsigned int, long unsigned int, u8); - long unsigned int (*recalc_accuracy)(struct clk_hw *, long unsigned int); - int (*get_phase)(struct clk_hw *); - int (*set_phase)(struct clk_hw *, int); - int (*get_duty_cycle)(struct clk_hw *, struct clk_duty *); - int (*set_duty_cycle)(struct clk_hw *, struct clk_duty *); - void (*init)(struct clk_hw *); - void (*debug_init)(struct clk_hw *, struct dentry *); -}; - -struct clk_parent_data { - const struct clk_hw *hw; - const char *fw_name; - const char *name; - int index; -}; - -struct clk_init_data { - const char *name; - const struct clk_ops *ops; - const char * const *parent_names; - const struct clk_parent_data *parent_data; - const struct clk_hw **parent_hws; - u8 num_parents; - long unsigned int flags; -}; - struct clk_lookup_alloc { struct clk_lookup cl; char dev_id[20]; @@ -62810,6 +66526,38 @@ struct trace_event_data_offsets_clk_duty_cycle { u32 name; }; +typedef void (*btf_trace_clk_enable)(void *, struct clk_core *); + +typedef void (*btf_trace_clk_enable_complete)(void *, struct clk_core *); + +typedef void (*btf_trace_clk_disable)(void *, struct clk_core *); + +typedef void (*btf_trace_clk_disable_complete)(void *, struct clk_core *); + +typedef void (*btf_trace_clk_prepare)(void *, struct clk_core *); + +typedef void (*btf_trace_clk_prepare_complete)(void *, struct clk_core *); + +typedef void (*btf_trace_clk_unprepare)(void *, struct clk_core *); + +typedef void (*btf_trace_clk_unprepare_complete)(void *, struct clk_core *); + +typedef void (*btf_trace_clk_set_rate)(void *, struct clk_core *, long unsigned int); + +typedef void (*btf_trace_clk_set_rate_complete)(void *, struct clk_core *, long unsigned int); + +typedef void (*btf_trace_clk_set_parent)(void *, struct clk_core *, struct clk_core *); + +typedef void (*btf_trace_clk_set_parent_complete)(void *, struct clk_core *, struct clk_core *); + +typedef void (*btf_trace_clk_set_phase)(void *, struct clk_core *, int); + +typedef void (*btf_trace_clk_set_phase_complete)(void *, struct clk_core *, int); + +typedef void (*btf_trace_clk_set_duty_cycle)(void *, struct clk_core *, struct clk_duty *); + +typedef void (*btf_trace_clk_set_duty_cycle_complete)(void *, struct clk_core *, struct clk_duty *); + struct clk_div_table { unsigned int val; unsigned int div; @@ -63714,20 +67462,10 @@ struct unimapdesc { struct unipair *entries; }; -struct kbentry { - unsigned char kb_table; - unsigned char kb_index; - short unsigned int kb_value; -}; - -struct kbsentry { - unsigned char kb_func; - unsigned char kb_string[512]; -}; - -struct kbkeycode { - unsigned int scancode; - unsigned int keycode; +struct kbdiacruc { + unsigned int diacr; + unsigned int base; + unsigned int result; }; struct kbd_repeat { @@ -63777,12 +67515,6 @@ struct vt_setactivate { struct vt_mode mode; }; -struct vt_spawn_console { - spinlock_t lock; - struct pid *pid; - int sig; -}; - struct vt_event_wait { struct list_head list; struct vt_event event; @@ -63850,6 +67582,17 @@ struct kbd_struct { unsigned char modeflags: 5; }; +struct kbentry { + unsigned char kb_table; + unsigned char kb_index; + short unsigned int kb_value; +}; + +struct kbsentry { + unsigned char kb_func; + unsigned char kb_string[512]; +}; + struct kbdiacr { unsigned char diacr; unsigned char base; @@ -63861,17 +67604,16 @@ struct kbdiacrs { struct kbdiacr kbdiacr[256]; }; -struct kbdiacruc { - unsigned int diacr; - unsigned int base; - unsigned int result; -}; - struct kbdiacrsuc { unsigned int kb_cnt; struct kbdiacruc kbdiacruc[256]; }; +struct kbkeycode { + unsigned int scancode; + unsigned int keycode; +}; + typedef void k_handler_fn(struct vc_data *, unsigned char, char); typedef void fn_handler_fn(struct vc_data *); @@ -63951,151 +67693,6 @@ struct interval { uint32_t last; }; -struct serial_rs485 { - __u32 flags; - __u32 delay_rts_before_send; - __u32 delay_rts_after_send; - __u32 padding[5]; -}; - -struct serial_iso7816 { - __u32 flags; - __u32 tg; - __u32 sc_fi; - __u32 sc_di; - __u32 clk; - __u32 reserved[5]; -}; - -struct circ_buf { - char *buf; - int head; - int tail; -}; - -struct uart_port; - -struct uart_ops { - unsigned int (*tx_empty)(struct uart_port *); - void (*set_mctrl)(struct uart_port *, unsigned int); - unsigned int (*get_mctrl)(struct uart_port *); - void (*stop_tx)(struct uart_port *); - void (*start_tx)(struct uart_port *); - void (*throttle)(struct uart_port *); - void (*unthrottle)(struct uart_port *); - void (*send_xchar)(struct uart_port *, char); - void (*stop_rx)(struct uart_port *); - void (*enable_ms)(struct uart_port *); - void (*break_ctl)(struct uart_port *, int); - int (*startup)(struct uart_port *); - void (*shutdown)(struct uart_port *); - void (*flush_buffer)(struct uart_port *); - void (*set_termios)(struct uart_port *, struct ktermios *, struct ktermios *); - void (*set_ldisc)(struct uart_port *, struct ktermios *); - void (*pm)(struct uart_port *, unsigned int, unsigned int); - const char * (*type)(struct uart_port *); - void (*release_port)(struct uart_port *); - int (*request_port)(struct uart_port *); - void (*config_port)(struct uart_port *, int); - int (*verify_port)(struct uart_port *, struct serial_struct *); - int (*ioctl)(struct uart_port *, unsigned int, long unsigned int); -}; - -struct uart_icount { - __u32 cts; - __u32 dsr; - __u32 rng; - __u32 dcd; - __u32 rx; - __u32 tx; - __u32 frame; - __u32 overrun; - __u32 parity; - __u32 brk; - __u32 buf_overrun; -}; - -typedef unsigned int upf_t; - -typedef unsigned int upstat_t; - -struct uart_state; - -struct uart_port { - spinlock_t lock; - long unsigned int iobase; - unsigned char *membase; - unsigned int (*serial_in)(struct uart_port *, int); - void (*serial_out)(struct uart_port *, int, int); - void (*set_termios)(struct uart_port *, struct ktermios *, struct ktermios *); - void (*set_ldisc)(struct uart_port *, struct ktermios *); - unsigned int (*get_mctrl)(struct uart_port *); - void (*set_mctrl)(struct uart_port *, unsigned int); - unsigned int (*get_divisor)(struct uart_port *, unsigned int, unsigned int *); - void (*set_divisor)(struct uart_port *, unsigned int, unsigned int, unsigned int); - int (*startup)(struct uart_port *); - void (*shutdown)(struct uart_port *); - void (*throttle)(struct uart_port *); - void (*unthrottle)(struct uart_port *); - int (*handle_irq)(struct uart_port *); - void (*pm)(struct uart_port *, unsigned int, unsigned int); - void (*handle_break)(struct uart_port *); - int (*rs485_config)(struct uart_port *, struct serial_rs485 *); - int (*iso7816_config)(struct uart_port *, struct serial_iso7816 *); - unsigned int irq; - long unsigned int irqflags; - unsigned int uartclk; - unsigned int fifosize; - unsigned char x_char; - unsigned char regshift; - unsigned char iotype; - unsigned char quirks; - unsigned int read_status_mask; - unsigned int ignore_status_mask; - struct uart_state *state; - struct uart_icount icount; - struct console *cons; - long unsigned int sysrq; - unsigned int sysrq_ch; - upf_t flags; - upstat_t status; - int hw_stopped; - unsigned int mctrl; - unsigned int timeout; - unsigned int type; - const struct uart_ops *ops; - unsigned int custom_divisor; - unsigned int line; - unsigned int minor; - resource_size_t mapbase; - resource_size_t mapsize; - struct device *dev; - unsigned char hub6; - unsigned char suspended; - unsigned char unused[2]; - const char *name; - struct attribute_group *attr_group; - const struct attribute_group **tty_groups; - struct serial_rs485 rs485; - struct serial_iso7816 iso7816; - void *private_data; -}; - -enum uart_pm_state { - UART_PM_STATE_ON = 0, - UART_PM_STATE_OFF = 3, - UART_PM_STATE_UNDEFINED = 4, -}; - -struct uart_state { - struct tty_port port; - enum uart_pm_state pm_state; - struct circ_buf xmit; - atomic_t refcount; - wait_queue_head_t remove_wait; - struct uart_port *uart_port; -}; - struct uart_driver { struct module *owner; const char *driver_name; @@ -64113,20 +67710,6 @@ struct uart_match { struct uart_driver *driver; }; -struct earlycon_device { - struct console *con; - struct uart_port port; - char options[16]; - unsigned int baud; -}; - -struct earlycon_id { - char name[15]; - char name_term; - char compatible[128]; - int (*setup)(struct earlycon_device *, const char *); -}; - enum hwparam_type { hwparam_ioport = 0, hwparam_iomem = 1, @@ -64514,8 +68097,6 @@ struct mid8250 { struct hsu_dma_chip dma_chip; }; -typedef int splice_actor___2(struct pipe_inode_info *, struct pipe_buffer *, struct splice_desc *); - struct memdev { const char *name; umode_t mode; @@ -64648,6 +68229,36 @@ struct trace_event_data_offsets_random_read {}; struct trace_event_data_offsets_urandom_read {}; +typedef void (*btf_trace_add_device_randomness)(void *, int, long unsigned int); + +typedef void (*btf_trace_mix_pool_bytes)(void *, const char *, int, long unsigned int); + +typedef void (*btf_trace_mix_pool_bytes_nolock)(void *, const char *, int, long unsigned int); + +typedef void (*btf_trace_credit_entropy_bits)(void *, const char *, int, int, long unsigned int); + +typedef void (*btf_trace_push_to_pool)(void *, const char *, int, int); + +typedef void (*btf_trace_debit_entropy)(void *, const char *, int); + +typedef void (*btf_trace_add_input_randomness)(void *, int); + +typedef void (*btf_trace_add_disk_randomness)(void *, dev_t, int); + +typedef void (*btf_trace_xfer_secondary_pool)(void *, const char *, int, int, int, int); + +typedef void (*btf_trace_get_random_bytes)(void *, int, long unsigned int); + +typedef void (*btf_trace_get_random_bytes_arch)(void *, int, long unsigned int); + +typedef void (*btf_trace_extract_entropy)(void *, const char *, int, int, long unsigned int); + +typedef void (*btf_trace_extract_entropy_user)(void *, const char *, int, int, long unsigned int); + +typedef void (*btf_trace_random_read)(void *, int, int, int, int); + +typedef void (*btf_trace_urandom_read)(void *, int, int, int); + struct poolinfo { int poolbitshift; int poolwords; @@ -64885,6 +68496,13 @@ struct gatt_mask { u32 type; }; +struct aper_size_info_16 { + int size; + int num_entries; + int page_order; + u16 size_value; +}; + struct agp_bridge_driver { struct module *owner; const void *aperture_sizes; @@ -65017,13 +68635,6 @@ struct aper_size_info_8 { u8 size_value; }; -struct aper_size_info_16 { - int size; - int num_entries; - int page_order; - u16 size_value; -}; - struct aper_size_info_32 { int size; int num_entries; @@ -65149,6 +68760,28 @@ struct intel_gtt_driver_description { const struct intel_gtt_driver *gtt_driver; }; +enum device_link_state { + DL_STATE_NONE = 4294967295, + DL_STATE_DORMANT = 0, + DL_STATE_AVAILABLE = 1, + DL_STATE_CONSUMER_PROBE = 2, + DL_STATE_ACTIVE = 3, + DL_STATE_SUPPLIER_UNBIND = 4, +}; + +struct device_link { + struct device *supplier; + struct list_head s_node; + struct device *consumer; + struct list_head c_node; + enum device_link_state status; + u32 flags; + refcount_t rpm_active; + struct kref kref; + struct callback_head callback_head; + bool supplier_preactivated; +}; + struct iommu_group { struct kobject kobj; struct kobject *devices_kobj; @@ -65320,6 +68953,20 @@ struct trace_event_data_offsets_iommu_error { u32 driver; }; +typedef void (*btf_trace_add_device_to_group)(void *, int, struct device *); + +typedef void (*btf_trace_remove_device_from_group)(void *, int, struct device *); + +typedef void (*btf_trace_attach_device_to_domain)(void *, struct device *); + +typedef void (*btf_trace_detach_device_from_domain)(void *, struct device *); + +typedef void (*btf_trace_map)(void *, long unsigned int, phys_addr_t, size_t); + +typedef void (*btf_trace_unmap)(void *, long unsigned int, size_t, size_t); + +typedef void (*btf_trace_io_page_fault)(void *, struct device *, long unsigned int, int); + struct iova { struct rb_node node; long unsigned int pfn_hi; @@ -65416,6 +69063,12 @@ struct amd_iommu_device_info { u32 flags; }; +struct irq_remap_table { + raw_spinlock_t lock; + unsigned int min_index; + u32 *table; +}; + struct amd_iommu_fault { u64 address; u32 pasid; @@ -65530,12 +69183,6 @@ enum { IRQ_REMAP_X2APIC_MODE = 1, }; -struct irq_remap_table { - raw_spinlock_t lock; - unsigned int min_index; - u32 *table; -}; - struct devid_map { struct list_head list; u8 id; @@ -65951,6 +69598,18 @@ struct trace_event_data_offsets_dma_unmap { u32 dev_name; }; +typedef void (*btf_trace_map_single)(void *, struct device *, dma_addr_t, phys_addr_t, size_t); + +typedef void (*btf_trace_map_sg)(void *, struct device *, dma_addr_t, phys_addr_t, size_t); + +typedef void (*btf_trace_bounce_map_single)(void *, struct device *, dma_addr_t, phys_addr_t, size_t); + +typedef void (*btf_trace_unmap_single)(void *, struct device *, dma_addr_t, size_t); + +typedef void (*btf_trace_unmap_sg)(void *, struct device *, dma_addr_t, size_t); + +typedef void (*btf_trace_bounce_unmap_single)(void *, struct device *, dma_addr_t, size_t); + struct i2c_msg { __u16 addr; __u16 flags; @@ -66425,6 +70084,62 @@ struct drm_format_info { bool is_yuv; }; +struct drm_mm; + +struct drm_mm_node { + long unsigned int color; + u64 start; + u64 size; + struct drm_mm *mm; + struct list_head node_list; + struct list_head hole_stack; + struct rb_node rb; + struct rb_node rb_hole_size; + struct rb_node rb_hole_addr; + u64 __subtree_last; + u64 hole_size; + long unsigned int flags; +}; + +struct drm_vma_offset_node { + rwlock_t vm_lock; + struct drm_mm_node vm_node; + struct rb_root vm_files; + bool readonly: 1; +}; + +struct dma_fence; + +struct dma_resv_list; + +struct dma_resv { + struct ww_mutex lock; + seqcount_t seq; + struct dma_fence *fence_excl; + struct dma_resv_list *fence; +}; + +struct dma_buf; + +struct dma_buf_attachment; + +struct drm_gem_object_funcs; + +struct drm_gem_object { + struct kref refcount; + unsigned int handle_count; + struct drm_device *dev; + struct file *filp; + struct drm_vma_offset_node vma_node; + size_t size; + int name; + struct dma_buf *dma_buf; + struct dma_buf_attachment *import_attach; + struct dma_resv *resv; + struct dma_resv _resv; + const struct drm_gem_object_funcs *funcs; +}; + enum drm_connector_force { DRM_FORCE_UNSPECIFIED = 0, DRM_FORCE_OFF = 1, @@ -66912,10 +70627,6 @@ struct drm_mode_config_helper_funcs { void (*atomic_commit_tail)(struct drm_atomic_state *); }; -struct dma_buf; - -struct dma_buf_attachment; - struct drm_ioctl_desc; struct drm_driver { @@ -67057,8 +70768,6 @@ enum drm_color_range { DRM_COLOR_RANGE_MAX = 2, }; -struct dma_fence; - struct drm_plane_state { struct drm_plane *plane; struct drm_crtc *crtc; @@ -67396,56 +71105,6 @@ enum drm_driver_feature { DRIVER_KMS_LEGACY_CONTEXT = 2147483648, }; -struct drm_mm; - -struct drm_mm_node { - long unsigned int color; - u64 start; - u64 size; - struct drm_mm *mm; - struct list_head node_list; - struct list_head hole_stack; - struct rb_node rb; - struct rb_node rb_hole_size; - struct rb_node rb_hole_addr; - u64 __subtree_last; - u64 hole_size; - long unsigned int flags; -}; - -struct drm_vma_offset_node { - rwlock_t vm_lock; - struct drm_mm_node vm_node; - struct rb_root vm_files; - bool readonly: 1; -}; - -struct dma_resv_list; - -struct dma_resv { - struct ww_mutex lock; - seqcount_t seq; - struct dma_fence *fence_excl; - struct dma_resv_list *fence; -}; - -struct drm_gem_object_funcs; - -struct drm_gem_object { - struct kref refcount; - unsigned int handle_count; - struct drm_device *dev; - struct file *filp; - struct drm_vma_offset_node vma_node; - size_t size; - int name; - struct dma_buf *dma_buf; - struct dma_buf_attachment *import_attach; - struct dma_resv *resv; - struct dma_resv _resv; - const struct drm_gem_object_funcs *funcs; -}; - enum drm_ioctl_flags { DRM_AUTH = 1, DRM_MASTER = 2, @@ -68289,6 +71948,15 @@ struct dma_buf_attachment { void *priv; }; +struct ww_class { + atomic_long_t stamp; + struct lock_class_key acquire_key; + struct lock_class_key mutex_key; + const char *acquire_name; + const char *mutex_name; + unsigned int is_wait_die; +}; + struct dma_resv_list { struct callback_head rcu; u32 shared_count; @@ -68428,15 +72096,6 @@ struct drm_gem_open { __u64 size; }; -struct ww_class { - atomic_long_t stamp; - struct lock_class_key acquire_key; - struct lock_class_key mutex_key; - const char *acquire_name; - const char *mutex_name; - unsigned int is_wait_die; -}; - struct drm_version { int version_major; int version_minor; @@ -68861,6 +72520,12 @@ struct trace_event_data_offsets_drm_vblank_event_queued {}; struct trace_event_data_offsets_drm_vblank_event_delivered {}; +typedef void (*btf_trace_drm_vblank_event)(void *, int, unsigned int, ktime_t, bool); + +typedef void (*btf_trace_drm_vblank_event_queued)(void *, struct drm_file *, int, unsigned int); + +typedef void (*btf_trace_drm_vblank_event_delivered)(void *, struct drm_file *, int, unsigned int); + struct dma_buf_export_info { const char *exp_name; struct module *owner; @@ -74039,6 +77704,8 @@ struct reg_whitelist { u8 size; }; +struct resource___2; + struct remap_pfn { struct mm_struct *mm; long unsigned int pfn; @@ -74548,8 +78215,6 @@ struct drm_i915_gem_caching { __u32 caching; }; -struct i915_vma_work; - struct drm_i915_gem_relocation_entry { __u32 target_handle; __u32 delta; @@ -75361,12 +79026,86 @@ struct trace_event_data_offsets_i915_ppgtt {}; struct trace_event_data_offsets_i915_context {}; +typedef void (*btf_trace_intel_pipe_enable)(void *, struct intel_crtc *); + +typedef void (*btf_trace_intel_pipe_disable)(void *, struct intel_crtc *); + +typedef void (*btf_trace_intel_pipe_crc)(void *, struct intel_crtc *, const u32 *); + +typedef void (*btf_trace_intel_cpu_fifo_underrun)(void *, struct drm_i915_private *, enum pipe); + +typedef void (*btf_trace_intel_pch_fifo_underrun)(void *, struct drm_i915_private *, enum pipe); + +typedef void (*btf_trace_intel_memory_cxsr)(void *, struct drm_i915_private *, bool, bool); + +typedef void (*btf_trace_g4x_wm)(void *, struct intel_crtc *, const struct g4x_wm_values *); + +typedef void (*btf_trace_vlv_wm)(void *, struct intel_crtc *, const struct vlv_wm_values *); + +typedef void (*btf_trace_vlv_fifo_size)(void *, struct intel_crtc *, u32, u32, u32); + +typedef void (*btf_trace_intel_update_plane)(void *, struct drm_plane *, struct intel_crtc *); + +typedef void (*btf_trace_intel_disable_plane)(void *, struct drm_plane *, struct intel_crtc *); + +typedef void (*btf_trace_i915_pipe_update_start)(void *, struct intel_crtc *); + +typedef void (*btf_trace_i915_pipe_update_vblank_evaded)(void *, struct intel_crtc *); + +typedef void (*btf_trace_i915_pipe_update_end)(void *, struct intel_crtc *, u32, int); + +typedef void (*btf_trace_i915_gem_object_create)(void *, struct drm_i915_gem_object *); + +typedef void (*btf_trace_i915_gem_shrink)(void *, struct drm_i915_private *, long unsigned int, unsigned int); + +typedef void (*btf_trace_i915_vma_bind)(void *, struct i915_vma *, unsigned int); + +typedef void (*btf_trace_i915_vma_unbind)(void *, struct i915_vma *); + +typedef void (*btf_trace_i915_gem_object_pwrite)(void *, struct drm_i915_gem_object *, u64, u64); + +typedef void (*btf_trace_i915_gem_object_pread)(void *, struct drm_i915_gem_object *, u64, u64); + +typedef void (*btf_trace_i915_gem_object_fault)(void *, struct drm_i915_gem_object *, u64, bool, bool); + +typedef void (*btf_trace_i915_gem_object_clflush)(void *, struct drm_i915_gem_object *); + +typedef void (*btf_trace_i915_gem_object_destroy)(void *, struct drm_i915_gem_object *); + +typedef void (*btf_trace_i915_gem_evict)(void *, struct i915_address_space *, u64, u64, unsigned int); + +typedef void (*btf_trace_i915_gem_evict_node)(void *, struct i915_address_space *, struct drm_mm_node *, unsigned int); + +typedef void (*btf_trace_i915_gem_evict_vm)(void *, struct i915_address_space *); + +typedef void (*btf_trace_i915_request_queue)(void *, struct i915_request *, u32); + +typedef void (*btf_trace_i915_request_add)(void *, struct i915_request *); + +typedef void (*btf_trace_i915_request_retire)(void *, struct i915_request *); + +typedef void (*btf_trace_i915_request_wait_begin)(void *, struct i915_request *, unsigned int); + +typedef void (*btf_trace_i915_request_wait_end)(void *, struct i915_request *); + +typedef void (*btf_trace_i915_reg_rw)(void *, bool, i915_reg_t, u64, int, bool); + +typedef void (*btf_trace_intel_gpu_freq_change)(void *, u32); + +typedef void (*btf_trace_i915_ppgtt_create)(void *, struct i915_address_space *); + +typedef void (*btf_trace_i915_ppgtt_release)(void *, struct i915_address_space *); + +typedef void (*btf_trace_i915_context_create)(void *, struct i915_gem_context *); + +typedef void (*btf_trace_i915_context_free)(void *, struct i915_gem_context *); + struct i915_global_vma { struct i915_global base; struct kmem_cache *slab_vmas; }; -struct i915_vma_work___2 { +struct i915_vma_work { struct dma_fence_work base; struct i915_vma *vma; enum i915_cache_level cache_level; @@ -75401,7 +79140,7 @@ struct uc_fw_blob { struct uc_fw_platform_requirement { enum intel_platform p; u8 rev; - struct uc_fw_blob blobs[2]; + const struct uc_fw_blob blobs[2]; } __attribute__((packed)); enum intel_guc_msg_type { @@ -76474,7 +80213,7 @@ struct intel_quirk { struct intel_dmi_quirk { void (*hook)(struct drm_i915_private *); - struct dmi_system_id (*dmi_id_list)[0]; + const struct dmi_system_id (*dmi_id_list)[0]; }; struct opregion_header { @@ -77332,6 +81071,15 @@ struct flex { u32 value; }; +enum { + START_TS = 0, + NOW_TS = 1, + DELTA_TS = 2, + JUMP_PREDICATE = 3, + DELTA_TARGET = 4, + N_CS_GPR = 5, +}; + struct compress { struct pagevec pool; struct z_stream_s zstream; @@ -77637,12 +81385,14 @@ struct cpu_attr { const struct cpumask * const map; }; +typedef struct kobject *kobj_probe_t(dev_t, int *, void *); + struct probe { struct probe *next; dev_t dev; long unsigned int range; struct module *owner; - kobj_probe_t___2 *get; + kobj_probe_t *get; int (*lock)(dev_t, void *); void *data; }; @@ -77652,6 +81402,10 @@ struct kobj_map___2 { struct mutex *lock; }; +typedef void (*dr_release_t)(struct device *, void *); + +typedef int (*dr_match_t)(struct device *, void *, void *); + struct devres_node { struct list_head entry; dr_release_t release; @@ -78038,6 +81792,8 @@ struct firmware_work { enum fw_opt opt_flags; }; +typedef void (*node_registration_func_t)(struct node *); + struct node_access_nodes { struct device dev; struct list_head list_node; @@ -78405,6 +82161,36 @@ struct trace_event_data_offsets_regcache_drop_region { u32 name; }; +typedef void (*btf_trace_regmap_reg_write)(void *, struct regmap *, unsigned int, unsigned int); + +typedef void (*btf_trace_regmap_reg_read)(void *, struct regmap *, unsigned int, unsigned int); + +typedef void (*btf_trace_regmap_reg_read_cache)(void *, struct regmap *, unsigned int, unsigned int); + +typedef void (*btf_trace_regmap_hw_read_start)(void *, struct regmap *, unsigned int, int); + +typedef void (*btf_trace_regmap_hw_read_done)(void *, struct regmap *, unsigned int, int); + +typedef void (*btf_trace_regmap_hw_write_start)(void *, struct regmap *, unsigned int, int); + +typedef void (*btf_trace_regmap_hw_write_done)(void *, struct regmap *, unsigned int, int); + +typedef void (*btf_trace_regcache_sync)(void *, struct regmap *, const char *, const char *); + +typedef void (*btf_trace_regmap_cache_only)(void *, struct regmap *, bool); + +typedef void (*btf_trace_regmap_cache_bypass)(void *, struct regmap *, bool); + +typedef void (*btf_trace_regmap_async_write_start)(void *, struct regmap *, unsigned int, int); + +typedef void (*btf_trace_regmap_async_io_complete)(void *, struct regmap *); + +typedef void (*btf_trace_regmap_async_complete_start)(void *, struct regmap *); + +typedef void (*btf_trace_regmap_async_complete_done)(void *, struct regmap *); + +typedef void (*btf_trace_regcache_drop_region)(void *, struct regmap *, unsigned int, unsigned int); + struct regcache_rbtree_node { void *block; long int *cache_present; @@ -78577,6 +82363,20 @@ struct trace_event_data_offsets_dma_fence { u32 timeline; }; +typedef void (*btf_trace_dma_fence_emit)(void *, struct dma_fence *); + +typedef void (*btf_trace_dma_fence_init)(void *, struct dma_fence *); + +typedef void (*btf_trace_dma_fence_destroy)(void *, struct dma_fence *); + +typedef void (*btf_trace_dma_fence_enable_signal)(void *, struct dma_fence *); + +typedef void (*btf_trace_dma_fence_signaled)(void *, struct dma_fence *); + +typedef void (*btf_trace_dma_fence_wait_start)(void *, struct dma_fence *); + +typedef void (*btf_trace_dma_fence_wait_end)(void *, struct dma_fence *); + struct default_wait_cb { struct dma_fence_cb base; struct task_struct *task; @@ -79077,6 +82877,16 @@ struct trace_event_data_offsets_scsi_cmd_done_timeout_template { struct trace_event_data_offsets_scsi_eh_wakeup {}; +typedef void (*btf_trace_scsi_dispatch_cmd_start)(void *, struct scsi_cmnd *); + +typedef void (*btf_trace_scsi_dispatch_cmd_error)(void *, struct scsi_cmnd *, int); + +typedef void (*btf_trace_scsi_dispatch_cmd_done)(void *, struct scsi_cmnd *); + +typedef void (*btf_trace_scsi_dispatch_cmd_timeout)(void *, struct scsi_cmnd *); + +typedef void (*btf_trace_scsi_eh_wakeup)(void *, struct Scsi_Host *); + struct scsi_transport_template { struct transport_container host_attrs; struct transport_container target_attrs; @@ -79541,8 +83351,6 @@ struct scsi_cd { struct gendisk *disk; }; -typedef struct scsi_cd Scsi_CD; - struct cdrom_ti { __u8 cdti_trk0; __u8 cdti_ind0; @@ -79555,6 +83363,8 @@ struct cdrom_tochdr { __u8 cdth_trk1; }; +typedef struct scsi_cd Scsi_CD; + struct ccs_modesel_head { __u8 _r1; __u8 medium; @@ -80878,6 +84688,18 @@ struct trace_event_data_offsets_ata_eh_link_autopsy {}; struct trace_event_data_offsets_ata_eh_link_autopsy_qc {}; +typedef void (*btf_trace_ata_qc_issue)(void *, struct ata_queued_cmd *); + +typedef void (*btf_trace_ata_qc_complete_internal)(void *, struct ata_queued_cmd *); + +typedef void (*btf_trace_ata_qc_complete_failed)(void *, struct ata_queued_cmd *); + +typedef void (*btf_trace_ata_qc_complete_done)(void *, struct ata_queued_cmd *); + +typedef void (*btf_trace_ata_eh_link_autopsy)(void *, struct ata_device *, unsigned int, unsigned int); + +typedef void (*btf_trace_ata_eh_link_autopsy_qc)(void *, struct ata_queued_cmd *); + enum { ATA_READID_POSTRESET = 1, ATA_DNXFER_PIO = 0, @@ -81422,7 +85244,7 @@ enum piix_controller_ids { struct piix_map_db { const u32 mask; const u16 port_enable; - int map[0]; + const int map[0]; }; struct piix_host_priv { @@ -81562,12 +85384,6 @@ enum { NETDEV_FEATURE_COUNT = 56, }; -typedef struct bio_vec skb_frag_t; - -struct skb_shared_hwtstamps { - ktime_t hwtstamp; -}; - enum { SKBTX_HW_TSTAMP = 1, SKBTX_SW_TSTAMP = 2, @@ -81578,44 +85394,6 @@ enum { SKBTX_SCHED_TSTAMP = 64, }; -struct skb_shared_info { - __u8 __unused; - __u8 meta_len; - __u8 nr_frags; - __u8 tx_flags; - short unsigned int gso_size; - short unsigned int gso_segs; - struct sk_buff *frag_list; - struct skb_shared_hwtstamps hwtstamps; - unsigned int gso_type; - u32 tskey; - atomic_t dataref; - void *destructor_arg; - skb_frag_t frags[17]; -}; - -enum net_device_flags { - IFF_UP = 1, - IFF_BROADCAST = 2, - IFF_DEBUG = 4, - IFF_LOOPBACK = 8, - IFF_POINTOPOINT = 16, - IFF_NOTRAILERS = 32, - IFF_RUNNING = 64, - IFF_NOARP = 128, - IFF_PROMISC = 256, - IFF_ALLMULTI = 512, - IFF_MASTER = 1024, - IFF_SLAVE = 2048, - IFF_MULTICAST = 4096, - IFF_PORTSEL = 8192, - IFF_AUTOMEDIA = 16384, - IFF_DYNAMIC = 32768, - IFF_LOWER_UP = 65536, - IFF_DORMANT = 131072, - IFF_ECHO = 262144, -}; - enum netdev_priv_flags { IFF_802_1Q_VLAN = 1, IFF_EBRIDGE = 2, @@ -81853,6 +85631,8 @@ struct trace_event_raw_mdio_access { struct trace_event_data_offsets_mdio_access {}; +typedef void (*btf_trace_mdio_access)(void *, struct mii_bus *, char, u8, unsigned int, u16, int); + struct mdio_driver { struct mdio_driver_common mdiodrv; int (*probe)(struct mdio_device *); @@ -81922,17 +85702,6 @@ struct netdev_hw_addr { struct callback_head callback_head; }; -enum gro_result { - GRO_MERGED = 0, - GRO_MERGED_FREE = 1, - GRO_HELD = 2, - GRO_NORMAL = 3, - GRO_DROP = 4, - GRO_CONSUMED = 5, -}; - -typedef enum gro_result gro_result_t; - enum netdev_queue_state_t { __QUEUE_STATE_DRV_XOFF = 0, __QUEUE_STATE_STACK_XOFF = 1, @@ -82667,12 +86436,12 @@ struct subsys_tbl_ent { struct tg3_dev_id { u32 vendor; u32 device; + u32 rev; }; struct tg3_dev_id___2 { u32 vendor; u32 device; - u32 rev; }; struct mem_entry { @@ -83119,6 +86888,13 @@ struct nic { long: 64; }; +enum led_state { + led_on = 1, + led_off = 4, + led_on_559 = 5, + led_on_557 = 7, +}; + struct vlan_hdr { __be16 h_vlan_TCI; __be16 h_vlan_encapsulated_proto; @@ -87527,8 +91303,6 @@ enum { PCMCIA_NUM_RESOURCES = 6, }; -typedef unsigned char cisdata_t; - struct cistpl_longlink_mfc_t { u_char nfn; struct { @@ -87674,6 +91448,8 @@ typedef long unsigned int u_long; typedef struct pccard_io_map pccard_io_map; +typedef unsigned char cisdata_t; + struct cistpl_longlink_t { u_int addr; }; @@ -89347,6 +93123,10 @@ struct mon_text_ptr { char *pbuf; }; +enum { + NAMESZ = 10, +}; + struct iso_rec { int error_count; int numdesc; @@ -90765,6 +94545,112 @@ struct trace_event_data_offsets_xhci_log_doorbell {}; struct trace_event_data_offsets_xhci_dbc_log_request {}; +typedef void (*btf_trace_xhci_dbg_address)(void *, struct va_format *); + +typedef void (*btf_trace_xhci_dbg_context_change)(void *, struct va_format *); + +typedef void (*btf_trace_xhci_dbg_quirks)(void *, struct va_format *); + +typedef void (*btf_trace_xhci_dbg_reset_ep)(void *, struct va_format *); + +typedef void (*btf_trace_xhci_dbg_cancel_urb)(void *, struct va_format *); + +typedef void (*btf_trace_xhci_dbg_init)(void *, struct va_format *); + +typedef void (*btf_trace_xhci_dbg_ring_expansion)(void *, struct va_format *); + +typedef void (*btf_trace_xhci_address_ctx)(void *, struct xhci_hcd *, struct xhci_container_ctx *, unsigned int); + +typedef void (*btf_trace_xhci_handle_event)(void *, struct xhci_ring *, struct xhci_generic_trb *); + +typedef void (*btf_trace_xhci_handle_command)(void *, struct xhci_ring *, struct xhci_generic_trb *); + +typedef void (*btf_trace_xhci_handle_transfer)(void *, struct xhci_ring *, struct xhci_generic_trb *); + +typedef void (*btf_trace_xhci_queue_trb)(void *, struct xhci_ring *, struct xhci_generic_trb *); + +typedef void (*btf_trace_xhci_dbc_handle_event)(void *, struct xhci_ring *, struct xhci_generic_trb *); + +typedef void (*btf_trace_xhci_dbc_handle_transfer)(void *, struct xhci_ring *, struct xhci_generic_trb *); + +typedef void (*btf_trace_xhci_dbc_gadget_ep_queue)(void *, struct xhci_ring *, struct xhci_generic_trb *); + +typedef void (*btf_trace_xhci_free_virt_device)(void *, struct xhci_virt_device *); + +typedef void (*btf_trace_xhci_alloc_virt_device)(void *, struct xhci_virt_device *); + +typedef void (*btf_trace_xhci_setup_device)(void *, struct xhci_virt_device *); + +typedef void (*btf_trace_xhci_setup_addressable_virt_device)(void *, struct xhci_virt_device *); + +typedef void (*btf_trace_xhci_stop_device)(void *, struct xhci_virt_device *); + +typedef void (*btf_trace_xhci_urb_enqueue)(void *, struct urb *); + +typedef void (*btf_trace_xhci_urb_giveback)(void *, struct urb *); + +typedef void (*btf_trace_xhci_urb_dequeue)(void *, struct urb *); + +typedef void (*btf_trace_xhci_handle_cmd_stop_ep)(void *, struct xhci_ep_ctx *); + +typedef void (*btf_trace_xhci_handle_cmd_set_deq_ep)(void *, struct xhci_ep_ctx *); + +typedef void (*btf_trace_xhci_handle_cmd_reset_ep)(void *, struct xhci_ep_ctx *); + +typedef void (*btf_trace_xhci_handle_cmd_config_ep)(void *, struct xhci_ep_ctx *); + +typedef void (*btf_trace_xhci_add_endpoint)(void *, struct xhci_ep_ctx *); + +typedef void (*btf_trace_xhci_alloc_dev)(void *, struct xhci_slot_ctx *); + +typedef void (*btf_trace_xhci_free_dev)(void *, struct xhci_slot_ctx *); + +typedef void (*btf_trace_xhci_handle_cmd_disable_slot)(void *, struct xhci_slot_ctx *); + +typedef void (*btf_trace_xhci_discover_or_reset_device)(void *, struct xhci_slot_ctx *); + +typedef void (*btf_trace_xhci_setup_device_slot)(void *, struct xhci_slot_ctx *); + +typedef void (*btf_trace_xhci_handle_cmd_addr_dev)(void *, struct xhci_slot_ctx *); + +typedef void (*btf_trace_xhci_handle_cmd_reset_dev)(void *, struct xhci_slot_ctx *); + +typedef void (*btf_trace_xhci_handle_cmd_set_deq)(void *, struct xhci_slot_ctx *); + +typedef void (*btf_trace_xhci_configure_endpoint)(void *, struct xhci_slot_ctx *); + +typedef void (*btf_trace_xhci_address_ctrl_ctx)(void *, struct xhci_input_control_ctx *); + +typedef void (*btf_trace_xhci_configure_endpoint_ctrl_ctx)(void *, struct xhci_input_control_ctx *); + +typedef void (*btf_trace_xhci_ring_alloc)(void *, struct xhci_ring *); + +typedef void (*btf_trace_xhci_ring_free)(void *, struct xhci_ring *); + +typedef void (*btf_trace_xhci_ring_expansion)(void *, struct xhci_ring *); + +typedef void (*btf_trace_xhci_inc_enq)(void *, struct xhci_ring *); + +typedef void (*btf_trace_xhci_inc_deq)(void *, struct xhci_ring *); + +typedef void (*btf_trace_xhci_handle_port_status)(void *, u32, u32); + +typedef void (*btf_trace_xhci_get_port_status)(void *, u32, u32); + +typedef void (*btf_trace_xhci_hub_status_data)(void *, u32, u32); + +typedef void (*btf_trace_xhci_ring_ep_doorbell)(void *, u32, u32); + +typedef void (*btf_trace_xhci_ring_host_doorbell)(void *, u32, u32); + +typedef void (*btf_trace_xhci_dbc_alloc_request)(void *, struct dbc_request *); + +typedef void (*btf_trace_xhci_dbc_free_request)(void *, struct dbc_request *); + +typedef void (*btf_trace_xhci_dbc_queue_request)(void *, struct dbc_request *); + +typedef void (*btf_trace_xhci_dbc_giveback_request)(void *, struct dbc_request *); + struct xhci_regset { char name[32]; struct debugfs_regset32 regset; @@ -91204,13 +95090,6 @@ struct key_entry { }; }; -struct led_init_data { - struct fwnode_handle *fwnode; - const char *default_label; - const char *devicename; - bool devname_mandatory; -}; - struct input_led { struct led_classdev cdev; struct input_handle *handle; @@ -91808,6 +95687,30 @@ struct trace_event_data_offsets_rtc_offset_class {}; struct trace_event_data_offsets_rtc_timer_class {}; +typedef void (*btf_trace_rtc_set_time)(void *, time64_t, int); + +typedef void (*btf_trace_rtc_read_time)(void *, time64_t, int); + +typedef void (*btf_trace_rtc_set_alarm)(void *, time64_t, int); + +typedef void (*btf_trace_rtc_read_alarm)(void *, time64_t, int); + +typedef void (*btf_trace_rtc_irq_set_freq)(void *, int, int); + +typedef void (*btf_trace_rtc_irq_set_state)(void *, int, int); + +typedef void (*btf_trace_rtc_alarm_irq_enable)(void *, unsigned int, int); + +typedef void (*btf_trace_rtc_set_offset)(void *, long int, int); + +typedef void (*btf_trace_rtc_read_offset)(void *, long int, int); + +typedef void (*btf_trace_rtc_timer_enqueue)(void *, struct rtc_timer *); + +typedef void (*btf_trace_rtc_timer_dequeue)(void *, struct rtc_timer *); + +typedef void (*btf_trace_rtc_timer_fired)(void *, struct rtc_timer *); + enum { none = 0, day = 1, @@ -91958,17 +95861,25 @@ struct trace_event_data_offsets_i2c_reply { struct trace_event_data_offsets_i2c_result {}; +typedef void (*btf_trace_i2c_write)(void *, const struct i2c_adapter *, const struct i2c_msg *, int); + +typedef void (*btf_trace_i2c_read)(void *, const struct i2c_adapter *, const struct i2c_msg *, int); + +typedef void (*btf_trace_i2c_reply)(void *, const struct i2c_adapter *, const struct i2c_msg *, int); + +typedef void (*btf_trace_i2c_result)(void *, const struct i2c_adapter *, int, int); + struct i2c_dummy_devres { struct i2c_client *client; }; +struct class_compat___2; + struct i2c_cmd_arg { unsigned int cmd; void *arg; }; -struct class_compat___2; - struct i2c_smbus_alert_setup { int irq; }; @@ -92028,6 +95939,14 @@ struct trace_event_data_offsets_smbus_reply {}; struct trace_event_data_offsets_smbus_result {}; +typedef void (*btf_trace_smbus_write)(void *, const struct i2c_adapter *, u16, short unsigned int, char, u8, int, const union i2c_smbus_data *); + +typedef void (*btf_trace_smbus_read)(void *, const struct i2c_adapter *, u16, short unsigned int, char, u8, int); + +typedef void (*btf_trace_smbus_reply)(void *, const struct i2c_adapter *, u16, short unsigned int, char, u8, int, const union i2c_smbus_data *, int); + +typedef void (*btf_trace_smbus_result)(void *, const struct i2c_adapter *, u16, short unsigned int, char, u8, int, int); + struct i2c_acpi_handler_data { struct acpi_connection_info info; struct i2c_adapter *adapter; @@ -92500,6 +96419,12 @@ struct trace_event_data_offsets_hwmon_attr_show_string { u32 label; }; +typedef void (*btf_trace_hwmon_attr_show)(void *, int, const char *, long int); + +typedef void (*btf_trace_hwmon_attr_store)(void *, int, const char *, long int); + +typedef void (*btf_trace_hwmon_attr_show_string)(void *, int, const char *, const char *); + struct hwmon_device { const char *name; struct device dev; @@ -92554,6 +96479,12 @@ struct trace_event_data_offsets_thermal_zone_trip { u32 thermal_zone; }; +typedef void (*btf_trace_thermal_temperature)(void *, struct thermal_zone_device *); + +typedef void (*btf_trace_cdev_update)(void *, struct thermal_cooling_device *, long unsigned int); + +typedef void (*btf_trace_thermal_zone_trip)(void *, struct thermal_zone_device *, int, enum thermal_trip_type); + struct thermal_instance { int id; char name[20]; @@ -94280,12 +98211,6 @@ struct smca_mce_desc { unsigned int num_descs; }; -struct freq_attr { - struct attribute attr; - ssize_t (*show)(struct cpufreq_policy *, char *); - ssize_t (*store)(struct cpufreq_policy *, const char *, size_t); -}; - struct cpufreq_driver { char name[16]; u8 flags; @@ -94518,9 +98443,9 @@ struct cpuidle_governor { char name[16]; struct list_head governor_list; unsigned int rating; - int (*enable)(struct cpuidle_driver *, struct cpuidle_device *); - void (*disable)(struct cpuidle_driver *, struct cpuidle_device *); - int (*select)(struct cpuidle_driver *, struct cpuidle_device *, bool *); + int (*enable)(struct cpuidle_driver___2 *, struct cpuidle_device *); + void (*disable)(struct cpuidle_driver___2 *, struct cpuidle_device *); + int (*select)(struct cpuidle_driver___2 *, struct cpuidle_device *, bool *); void (*reflect)(struct cpuidle_device *, int); }; @@ -94560,6 +98485,13 @@ struct menu_device { int interval_ptr; }; +struct led_init_data { + struct fwnode_handle *fwnode; + const char *default_label; + const char *devicename; + bool devname_mandatory; +}; + struct led_properties { u32 color; bool color_present; @@ -94684,6 +98616,8 @@ typedef struct { efi_memory_desc_t entry[0]; } efi_memory_attributes_table_t; +typedef int (*efi_memattr_perm_setter)(struct mm_struct *, efi_memory_desc_t *); + struct linux_efi_tpm_eventlog { u32 size; u32 final_events_preboot_size; @@ -95197,7 +99131,7 @@ struct lg4ff_wheel { struct lg4ff_compat_mode_switch { const u8 cmd_count; - u8 cmd[0]; + const u8 cmd[0]; }; struct lg4ff_wheel_ident_info { @@ -95820,6 +99754,14 @@ struct trace_event_data_offsets_aer_event { u32 dev_name; }; +typedef void (*btf_trace_mc_event)(void *, const unsigned int, const char *, const char *, const int, const u8, const s8, const s8, const s8, long unsigned int, const u8, long unsigned int, const char *); + +typedef void (*btf_trace_arm_event)(void *, const struct cper_sec_proc_arm *); + +typedef void (*btf_trace_non_standard_event)(void *, const guid_t *, const guid_t *, const char *, const u8, const u8 *, const u32); + +typedef void (*btf_trace_aer_event)(void *, const char *, const u32, const u8, const u8, struct aer_header_log_regs *); + struct nvmem_cell_lookup { const char *nvmem_name; const char *cell_name; @@ -96950,6 +100892,12 @@ struct snd_pcm_hw_constraints { struct snd_pcm_hw_rule *rules; }; +struct snd_pcm_hw_constraint_list { + const unsigned int *list; + unsigned int count; + unsigned int mask; +}; + struct snd_pcm_runtime { struct snd_pcm_substream *trigger_master; struct timespec trigger_tstamp; @@ -97041,9 +100989,10 @@ struct snd_pcm { bool no_device_suspend; }; -typedef u32 u_int32_t; - -typedef u64 u_int64_t; +struct snd_pcm_chmap_elem { + unsigned char channels; + unsigned char map[15]; +}; enum { SNDRV_PCM_MMAP_OFFSET_DATA = 0, @@ -97123,12 +101072,6 @@ struct snd_pcm_file { unsigned int user_pversion; }; -struct snd_pcm_hw_constraint_list { - const unsigned int *list; - unsigned int count; - unsigned int mask; -}; - struct snd_pcm_hw_params_old { unsigned int flags; unsigned int masks[3]; @@ -97333,11 +101276,6 @@ struct snd_pcm_hw_constraint_ranges { unsigned int mask; }; -struct snd_pcm_chmap_elem { - unsigned char channels; - unsigned char map[15]; -}; - struct snd_pcm_chmap { struct snd_pcm *pcm; int stream; @@ -98624,6 +102562,18 @@ struct trace_event_data_offsets_azx_get_position {}; struct trace_event_data_offsets_azx_pcm {}; +typedef void (*btf_trace_azx_pcm_trigger)(void *, struct azx *, struct azx_dev *, int); + +typedef void (*btf_trace_azx_get_position)(void *, struct azx *, struct azx_dev *, unsigned int, unsigned int); + +typedef void (*btf_trace_azx_pcm_open)(void *, struct azx *, struct azx_dev *); + +typedef void (*btf_trace_azx_pcm_close)(void *, struct azx *, struct azx_dev *); + +typedef void (*btf_trace_azx_pcm_hw_params)(void *, struct azx *, struct azx_dev *); + +typedef void (*btf_trace_azx_pcm_prepare)(void *, struct azx *, struct azx_dev *); + enum { SNDRV_HWDEP_IFACE_OPL2 = 0, SNDRV_HWDEP_IFACE_OPL3 = 1, @@ -98697,6 +102647,14 @@ struct trace_event_raw_hda_pm { struct trace_event_data_offsets_hda_pm {}; +typedef void (*btf_trace_azx_suspend)(void *, struct azx *); + +typedef void (*btf_trace_azx_resume)(void *, struct azx *); + +typedef void (*btf_trace_azx_runtime_suspend)(void *, struct azx *); + +typedef void (*btf_trace_azx_runtime_resume)(void *, struct azx *); + enum { POS_FIX_AUTO = 0, POS_FIX_LPIB = 1, @@ -98848,6 +102806,16 @@ struct trace_event_data_offsets_hda_unsol_event { struct trace_event_data_offsets_hdac_stream {}; +typedef void (*btf_trace_hda_send_cmd)(void *, struct hdac_bus *, unsigned int); + +typedef void (*btf_trace_hda_get_response)(void *, struct hdac_bus *, unsigned int, unsigned int); + +typedef void (*btf_trace_hda_unsol_event)(void *, struct hdac_bus *, u32, u32); + +typedef void (*btf_trace_snd_hdac_stream_start)(void *, struct hdac_bus *, struct hdac_stream *); + +typedef void (*btf_trace_snd_hdac_stream_stop)(void *, struct hdac_bus *, struct hdac_stream *); + struct component_match___2; struct nhlt_specific_cfg { @@ -98934,11 +102902,6 @@ struct pci_check_idx_range { int end; }; -struct pci_raw_ops { - int (*read)(unsigned int, unsigned int, unsigned int, int, int, u32 *); - int (*write)(unsigned int, unsigned int, unsigned int, int, int, u32); -}; - struct pci_mmcfg_region { struct list_head list; struct resource res; @@ -99234,37 +103197,6 @@ struct scm_ts_pktinfo { __u32 reserved[2]; }; -enum sock_flags { - SOCK_DEAD = 0, - SOCK_DONE = 1, - SOCK_URGINLINE = 2, - SOCK_KEEPOPEN = 3, - SOCK_LINGER = 4, - SOCK_DESTROY = 5, - SOCK_BROADCAST = 6, - SOCK_TIMESTAMP = 7, - SOCK_ZAPPED = 8, - SOCK_USE_WRITE_QUEUE = 9, - SOCK_DBG = 10, - SOCK_RCVTSTAMP = 11, - SOCK_RCVTSTAMPNS = 12, - SOCK_LOCALROUTE = 13, - SOCK_QUEUE_SHRUNK = 14, - SOCK_MEMALLOC = 15, - SOCK_TIMESTAMPING_RX_SOFTWARE = 16, - SOCK_FASYNC = 17, - SOCK_RXQ_OVFL = 18, - SOCK_ZEROCOPY = 19, - SOCK_WIFI_STATUS = 20, - SOCK_NOFCS = 21, - SOCK_FILTER_LOCKED = 22, - SOCK_SELECT_ERR_QUEUE = 23, - SOCK_RCU_FREE = 24, - SOCK_TXTIME = 25, - SOCK_XDP = 26, - SOCK_TSTAMP_NEW = 27, -}; - struct sock_skb_cb { u32 dropcount; }; @@ -99639,6 +103571,12 @@ struct xfrm_address_filter { __u8 dplen; }; +struct offload_callbacks { + struct sk_buff * (*gso_segment)(struct sk_buff *, netdev_features_t); + struct sk_buff * (*gro_receive)(struct list_head *, struct sk_buff *); + int (*gro_complete)(struct sk_buff *, int); +}; + struct xfrm_state_walk { struct list_head all; u8 state; @@ -100242,6 +104180,19 @@ struct net_protocol { unsigned int icmp_strict_tag_validation: 1; }; +struct inet6_protocol { + void (*early_demux)(struct sk_buff *); + void (*early_demux_handler)(struct sk_buff *); + int (*handler)(struct sk_buff *); + int (*err_handler)(struct sk_buff *, struct inet6_skb_parm *, u8, u8, int, __be32); + unsigned int flags; +}; + +struct net_offload { + struct offload_callbacks callbacks; + unsigned int flags; +}; + struct rt6_exception_bucket { struct hlist_head chain; int depth; @@ -100378,10 +104329,6 @@ struct ts_config { void (*finish)(struct ts_config *, struct ts_state *); }; -struct nf_conntrack { - atomic_t use; -}; - enum { SKB_FCLONE_UNAVAILABLE = 0, SKB_FCLONE_ORIG = 1, @@ -100404,11 +104351,6 @@ struct skb_seq_state { __u8 *frag_data; }; -struct skb_checksum_ops { - __wsum (*update)(const void *, int, __wsum); - __wsum (*combine)(__wsum, __wsum, int, int); -}; - struct skb_gso_cb { union { int mac_offset; @@ -100607,10 +104549,6 @@ enum { __NETNSA_MAX = 6, }; -typedef int (*rtnl_doit_func)(struct sk_buff *, struct nlmsghdr *, struct netlink_ext_ack *); - -typedef int (*rtnl_dumpit_func)(struct sk_buff *, struct netlink_callback *); - enum rtnl_link_flags { RTNL_FLAG_DOIT_UNLOCKED = 1, }; @@ -100634,8 +104572,6 @@ struct rtnl_net_dump_cb { int s_idx; }; -typedef u16 u_int16_t; - struct flow_dissector_key_control { u16 thoff; u16 addr_type; @@ -100790,51 +104726,6 @@ struct flow_keys_digest { u8 data[16]; }; -struct bpf_flow_keys; - -struct bpf_flow_dissector { - struct bpf_flow_keys *flow_keys; - const struct sk_buff *skb; - void *data; - void *data_end; -}; - -struct bpf_flow_keys { - __u16 nhoff; - __u16 thoff; - __u16 addr_proto; - __u8 is_frag; - __u8 is_first_frag; - __u8 is_encap; - __u8 ip_proto; - __be16 n_proto; - __be16 sport; - __be16 dport; - union { - struct { - __be32 ipv4_src; - __be32 ipv4_dst; - }; - struct { - __u32 ipv6_src[4]; - __u32 ipv6_dst[4]; - }; - }; - __u32 flags; - __be32 flow_label; -}; - -enum ip_conntrack_info { - IP_CT_ESTABLISHED = 0, - IP_CT_RELATED = 1, - IP_CT_NEW = 2, - IP_CT_IS_REPLY = 3, - IP_CT_ESTABLISHED_REPLY = 3, - IP_CT_RELATED_REPLY = 4, - IP_CT_NUMBER = 5, - IP_CT_UNTRACKED = 7, -}; - struct xt_table_info; struct xt_table { @@ -100845,38 +104736,7 @@ struct xt_table { u_int8_t af; int priority; int (*table_init)(struct net *); - char name[32]; -}; - -union nf_inet_addr { - __u32 all[4]; - __be32 ip; - __be32 ip6[4]; - struct in_addr in; - struct in6_addr in6; -}; - -struct ip_ct_tcp_state { - u_int32_t td_end; - u_int32_t td_maxend; - u_int32_t td_maxwin; - u_int32_t td_maxack; - u_int8_t td_scale; - u_int8_t flags; -}; - -struct ip_ct_tcp { - struct ip_ct_tcp_state seen[2]; - u_int8_t state; - u_int8_t last_dir; - u_int8_t retrans; - u_int8_t last_index; - u_int32_t last_seq; - u_int32_t last_ack; - u_int32_t last_end; - u_int16_t last_win; - u_int8_t last_wscale; - u_int8_t last_flags; + const char name[32]; }; enum bpf_ret_code { @@ -101357,139 +105217,6 @@ struct batadv_unicast_packet { __u8 dest[6]; }; -union nf_conntrack_man_proto { - __be16 all; - struct { - __be16 port; - } tcp; - struct { - __be16 port; - } udp; - struct { - __be16 id; - } icmp; - struct { - __be16 port; - } dccp; - struct { - __be16 port; - } sctp; - struct { - __be16 key; - } gre; -}; - -struct nf_conntrack_man { - union nf_inet_addr u3; - union nf_conntrack_man_proto u; - u_int16_t l3num; -}; - -struct nf_conntrack_tuple { - struct nf_conntrack_man src; - struct { - union nf_inet_addr u3; - union { - __be16 all; - struct { - __be16 port; - } tcp; - struct { - __be16 port; - } udp; - struct { - u_int8_t type; - u_int8_t code; - } icmp; - struct { - __be16 port; - } dccp; - struct { - __be16 port; - } sctp; - struct { - __be16 key; - } gre; - } u; - u_int8_t protonum; - u_int8_t dir; - } dst; -}; - -struct nf_conntrack_tuple_hash { - struct hlist_nulls_node hnnode; - struct nf_conntrack_tuple tuple; -}; - -struct nf_ct_dccp { - u_int8_t role[2]; - u_int8_t state; - u_int8_t last_pkt; - u_int8_t last_dir; - u_int64_t handshake_seq; -}; - -enum sctp_conntrack { - SCTP_CONNTRACK_NONE = 0, - SCTP_CONNTRACK_CLOSED = 1, - SCTP_CONNTRACK_COOKIE_WAIT = 2, - SCTP_CONNTRACK_COOKIE_ECHOED = 3, - SCTP_CONNTRACK_ESTABLISHED = 4, - SCTP_CONNTRACK_SHUTDOWN_SENT = 5, - SCTP_CONNTRACK_SHUTDOWN_RECD = 6, - SCTP_CONNTRACK_SHUTDOWN_ACK_SENT = 7, - SCTP_CONNTRACK_HEARTBEAT_SENT = 8, - SCTP_CONNTRACK_HEARTBEAT_ACKED = 9, - SCTP_CONNTRACK_MAX = 10, -}; - -struct ip_ct_sctp { - enum sctp_conntrack state; - __be32 vtag[2]; -}; - -struct nf_ct_udp { - long unsigned int stream_ts; -}; - -struct nf_ct_gre { - unsigned int stream_timeout; - unsigned int timeout; -}; - -union nf_conntrack_proto { - struct nf_ct_dccp dccp; - struct ip_ct_sctp sctp; - struct ip_ct_tcp tcp; - struct nf_ct_udp udp; - struct nf_ct_gre gre; - unsigned int tmpl_padto; -}; - -struct nf_ct_ext; - -struct nf_conn { - struct nf_conntrack ct_general; - spinlock_t lock; - u32 timeout; - struct nf_conntrack_tuple_hash tuplehash[2]; - long unsigned int status; - u16 cpu; - possible_net_t ct_net; - struct hlist_node nat_bysource; - u8 __nfct_init_offset[0]; - struct nf_conn *master; - u_int32_t secmark; - struct nf_ct_ext *ext; - union nf_conntrack_proto proto; -}; - -struct nf_conntrack_zone { - u16 id; - u8 flags; - u8 dir; -}; - struct xt_table_info { unsigned int size; unsigned int number; @@ -101501,6 +105228,27 @@ struct xt_table_info { unsigned char entries[0]; }; +struct nf_conntrack_l4proto { + u_int8_t l4proto; + bool allow_clash; + u16 nlattr_size; + bool (*can_early_drop)(const struct nf_conn *); + int (*to_nlattr)(struct sk_buff *, struct nlattr *, struct nf_conn *); + int (*from_nlattr)(struct nlattr **, struct nf_conn *); + int (*tuple_to_nlattr)(struct sk_buff *, const struct nf_conntrack_tuple *); + unsigned int (*nlattr_tuple_size)(); + int (*nlattr_to_tuple)(struct nlattr **, struct nf_conntrack_tuple *); + const struct nla_policy *nla_policy; + struct { + int (*nlattr_to_obj)(struct nlattr **, struct net *, void *); + int (*obj_to_nlattr)(struct sk_buff *, const void *); + u16 obj_size; + u16 nlattr_max; + const struct nla_policy *nla_policy; + } ctnl_timeout; + void (*print_conntrack)(struct seq_file *, struct nf_conn *); +}; + struct nf_ct_ext { u8 offset[4]; u8 len; @@ -101543,15 +105291,6 @@ enum nf_dev_hooks { NF_NETDEV_NUMHOOKS = 1, }; -struct xdp_buff { - void *data; - void *data_end; - void *data_meta; - void *data_hard_start; - long unsigned int handle; - struct xdp_rxq_info *rxq; -}; - struct ifbond { __s32 bond_mode; __s32 num_slaves; @@ -101585,6 +105324,17 @@ enum { NAPIF_STATE_IN_BUSY_POLL = 64, }; +enum gro_result { + GRO_MERGED = 0, + GRO_MERGED_FREE = 1, + GRO_HELD = 2, + GRO_NORMAL = 3, + GRO_DROP = 4, + GRO_CONSUMED = 5, +}; + +typedef enum gro_result gro_result_t; + struct udp_tunnel_info { short unsigned int type; sa_family_t sa_family; @@ -101602,12 +105352,6 @@ struct packet_type { struct list_head list; }; -struct offload_callbacks { - struct sk_buff * (*gso_segment)(struct sk_buff *, netdev_features_t); - struct sk_buff * (*gro_receive)(struct list_head *, struct sk_buff *); - int (*gro_complete)(struct sk_buff *, int); -}; - struct packet_offload { __be16 type; u16 priority; @@ -101671,15 +105415,6 @@ struct tcf_walker { int (*fn)(struct tcf_proto *, void *, struct tcf_walker *); }; -struct qdisc_skb_cb { - struct { - unsigned int pkt_len; - u16 slave_dev_queue_mapping; - u16 tc_classid; - }; - unsigned char data[20]; -}; - struct udp_hslot; struct udp_table { @@ -101745,6 +105480,12 @@ struct netdev_adjacent { struct callback_head rcu; }; +typedef struct sk_buff *pto_T_____23; + +typedef __u32 pao_T_____9; + +typedef u16 pao_T_____10; + struct ethtool_value { __u32 cmd; __u32 data; @@ -101986,48 +105727,6 @@ struct ethtool_rx_flow_spec_input { u32 rss_ctx; }; -struct xsk_queue; - -struct xdp_umem_page; - -struct xdp_umem_fq_reuse; - -struct xdp_umem { - struct xsk_queue *fq; - struct xsk_queue *cq; - struct xdp_umem_page *pages; - u64 chunk_mask; - u64 size; - u32 headroom; - u32 chunk_size_nohr; - struct user_struct *user; - long unsigned int address; - refcount_t users; - struct work_struct work; - struct page **pgs; - u32 npgs; - u16 queue_id; - u8 need_wakeup; - u8 flags; - int id; - struct net_device *dev; - struct xdp_umem_fq_reuse *fq_reuse; - bool zc; - spinlock_t xsk_list_lock; - struct list_head xsk_list; -}; - -struct xdp_umem_page { - void *addr; - dma_addr_t dma; -}; - -struct xdp_umem_fq_reuse { - u32 nentries; - u32 length; - u64 handles[0]; -}; - struct ethtool_link_usettings { struct ethtool_link_settings base; struct { @@ -102617,6 +106316,10 @@ struct ifinfomsg { unsigned int ifi_change; }; +typedef int (*rtnl_doit_func)(struct sk_buff *, struct nlmsghdr *, struct netlink_ext_ack *); + +typedef int (*rtnl_dumpit_func)(struct sk_buff *, struct netlink_callback *); + struct rtnl_af_ops { struct list_head list; int family; @@ -102650,126 +106353,6 @@ struct seg6_pernet_data { struct in6_addr *tun_src; }; -enum bpf_func_id { - BPF_FUNC_unspec = 0, - BPF_FUNC_map_lookup_elem = 1, - BPF_FUNC_map_update_elem = 2, - BPF_FUNC_map_delete_elem = 3, - BPF_FUNC_probe_read = 4, - BPF_FUNC_ktime_get_ns = 5, - BPF_FUNC_trace_printk = 6, - BPF_FUNC_get_prandom_u32 = 7, - BPF_FUNC_get_smp_processor_id = 8, - BPF_FUNC_skb_store_bytes = 9, - BPF_FUNC_l3_csum_replace = 10, - BPF_FUNC_l4_csum_replace = 11, - BPF_FUNC_tail_call = 12, - BPF_FUNC_clone_redirect = 13, - BPF_FUNC_get_current_pid_tgid = 14, - BPF_FUNC_get_current_uid_gid = 15, - BPF_FUNC_get_current_comm = 16, - BPF_FUNC_get_cgroup_classid = 17, - BPF_FUNC_skb_vlan_push = 18, - BPF_FUNC_skb_vlan_pop = 19, - BPF_FUNC_skb_get_tunnel_key = 20, - BPF_FUNC_skb_set_tunnel_key = 21, - BPF_FUNC_perf_event_read = 22, - BPF_FUNC_redirect = 23, - BPF_FUNC_get_route_realm = 24, - BPF_FUNC_perf_event_output = 25, - BPF_FUNC_skb_load_bytes = 26, - BPF_FUNC_get_stackid = 27, - BPF_FUNC_csum_diff = 28, - BPF_FUNC_skb_get_tunnel_opt = 29, - BPF_FUNC_skb_set_tunnel_opt = 30, - BPF_FUNC_skb_change_proto = 31, - BPF_FUNC_skb_change_type = 32, - BPF_FUNC_skb_under_cgroup = 33, - BPF_FUNC_get_hash_recalc = 34, - BPF_FUNC_get_current_task = 35, - BPF_FUNC_probe_write_user = 36, - BPF_FUNC_current_task_under_cgroup = 37, - BPF_FUNC_skb_change_tail = 38, - BPF_FUNC_skb_pull_data = 39, - BPF_FUNC_csum_update = 40, - BPF_FUNC_set_hash_invalid = 41, - BPF_FUNC_get_numa_node_id = 42, - BPF_FUNC_skb_change_head = 43, - BPF_FUNC_xdp_adjust_head = 44, - BPF_FUNC_probe_read_str = 45, - BPF_FUNC_get_socket_cookie = 46, - BPF_FUNC_get_socket_uid = 47, - BPF_FUNC_set_hash = 48, - BPF_FUNC_setsockopt = 49, - BPF_FUNC_skb_adjust_room = 50, - BPF_FUNC_redirect_map = 51, - BPF_FUNC_sk_redirect_map = 52, - BPF_FUNC_sock_map_update = 53, - BPF_FUNC_xdp_adjust_meta = 54, - BPF_FUNC_perf_event_read_value = 55, - BPF_FUNC_perf_prog_read_value = 56, - BPF_FUNC_getsockopt = 57, - BPF_FUNC_override_return = 58, - BPF_FUNC_sock_ops_cb_flags_set = 59, - BPF_FUNC_msg_redirect_map = 60, - BPF_FUNC_msg_apply_bytes = 61, - BPF_FUNC_msg_cork_bytes = 62, - BPF_FUNC_msg_pull_data = 63, - BPF_FUNC_bind = 64, - BPF_FUNC_xdp_adjust_tail = 65, - BPF_FUNC_skb_get_xfrm_state = 66, - BPF_FUNC_get_stack = 67, - BPF_FUNC_skb_load_bytes_relative = 68, - BPF_FUNC_fib_lookup = 69, - BPF_FUNC_sock_hash_update = 70, - BPF_FUNC_msg_redirect_hash = 71, - BPF_FUNC_sk_redirect_hash = 72, - BPF_FUNC_lwt_push_encap = 73, - BPF_FUNC_lwt_seg6_store_bytes = 74, - BPF_FUNC_lwt_seg6_adjust_srh = 75, - BPF_FUNC_lwt_seg6_action = 76, - BPF_FUNC_rc_repeat = 77, - BPF_FUNC_rc_keydown = 78, - BPF_FUNC_skb_cgroup_id = 79, - BPF_FUNC_get_current_cgroup_id = 80, - BPF_FUNC_get_local_storage = 81, - BPF_FUNC_sk_select_reuseport = 82, - BPF_FUNC_skb_ancestor_cgroup_id = 83, - BPF_FUNC_sk_lookup_tcp = 84, - BPF_FUNC_sk_lookup_udp = 85, - BPF_FUNC_sk_release = 86, - BPF_FUNC_map_push_elem = 87, - BPF_FUNC_map_pop_elem = 88, - BPF_FUNC_map_peek_elem = 89, - BPF_FUNC_msg_push_data = 90, - BPF_FUNC_msg_pop_data = 91, - BPF_FUNC_rc_pointer_rel = 92, - BPF_FUNC_spin_lock = 93, - BPF_FUNC_spin_unlock = 94, - BPF_FUNC_sk_fullsock = 95, - BPF_FUNC_tcp_sock = 96, - BPF_FUNC_skb_ecn_set_ce = 97, - BPF_FUNC_get_listener_sock = 98, - BPF_FUNC_skc_lookup_tcp = 99, - BPF_FUNC_tcp_check_syncookie = 100, - BPF_FUNC_sysctl_get_name = 101, - BPF_FUNC_sysctl_get_current_value = 102, - BPF_FUNC_sysctl_get_new_value = 103, - BPF_FUNC_sysctl_set_new_value = 104, - BPF_FUNC_strtol = 105, - BPF_FUNC_strtoul = 106, - BPF_FUNC_sk_storage_get = 107, - BPF_FUNC_sk_storage_delete = 108, - BPF_FUNC_send_signal = 109, - BPF_FUNC_tcp_gen_syncookie = 110, - BPF_FUNC_skb_output = 111, - BPF_FUNC_probe_read_user = 112, - BPF_FUNC_probe_read_kernel = 113, - BPF_FUNC_probe_read_user_str = 114, - BPF_FUNC_probe_read_kernel_str = 115, - __BPF_FUNC_MAX_ID = 116, -}; - enum { BPF_F_RECOMPUTE_CSUM = 1, BPF_F_INVALIDATE_HASH = 2, @@ -102799,12 +106382,6 @@ enum { BPF_F_SEQ_NUMBER = 8, }; -enum { - BPF_F_INDEX_MASK = 4294967295, - BPF_F_CURRENT_CPU = 4294967295, - BPF_F_CTXLEN_MASK = 0, -}; - enum { BPF_F_ADJ_ROOM_FIXED_GSO = 1, BPF_F_ADJ_ROOM_ENCAP_L3_IPV4 = 2, @@ -102828,58 +106405,10 @@ enum bpf_hdr_start_off { BPF_HDR_START_NET = 1, }; -struct bpf_sock { - __u32 bound_dev_if; - __u32 family; - __u32 type; - __u32 protocol; - __u32 mark; - __u32 priority; - __u32 src_ip4; - __u32 src_ip6[4]; - __u32 src_port; - __u32 dst_port; - __u32 dst_ip4; - __u32 dst_ip6[4]; - __u32 state; -}; - -struct __sk_buff { - __u32 len; - __u32 pkt_type; - __u32 mark; - __u32 queue_mapping; - __u32 protocol; - __u32 vlan_present; - __u32 vlan_tci; - __u32 vlan_proto; - __u32 priority; - __u32 ingress_ifindex; - __u32 ifindex; - __u32 tc_index; - __u32 cb[5]; - __u32 hash; - __u32 tc_classid; - __u32 data; - __u32 data_end; - __u32 napi_id; - __u32 family; - __u32 remote_ip4; - __u32 local_ip4; - __u32 remote_ip6[4]; - __u32 local_ip6[4]; - __u32 remote_port; - __u32 local_port; - __u32 data_meta; - union { - struct bpf_flow_keys *flow_keys; - }; - __u64 tstamp; - __u32 wire_len; - __u32 gso_segs; - union { - struct bpf_sock *sk; - }; +enum bpf_lwt_encap_mode { + BPF_LWT_ENCAP_SEG6 = 0, + BPF_LWT_ENCAP_SEG6_INLINE = 1, + BPF_LWT_ENCAP_IP = 2, }; struct bpf_tunnel_key { @@ -102960,97 +106489,6 @@ enum sk_action { SK_PASS = 1, }; -struct sk_msg_md { - union { - void *data; - }; - union { - void *data_end; - }; - __u32 family; - __u32 remote_ip4; - __u32 local_ip4; - __u32 remote_ip6[4]; - __u32 local_ip6[4]; - __u32 remote_port; - __u32 local_port; - __u32 size; -}; - -struct sk_reuseport_md { - union { - void *data; - }; - union { - void *data_end; - }; - __u32 len; - __u32 eth_protocol; - __u32 ip_protocol; - __u32 bind_inany; - __u32 hash; -}; - -struct bpf_sock_addr { - __u32 user_family; - __u32 user_ip4; - __u32 user_ip6[4]; - __u32 user_port; - __u32 family; - __u32 type; - __u32 protocol; - __u32 msg_src_ip4; - __u32 msg_src_ip6[4]; - union { - struct bpf_sock *sk; - }; -}; - -struct bpf_sock_ops { - __u32 op; - union { - __u32 args[4]; - __u32 reply; - __u32 replylong[4]; - }; - __u32 family; - __u32 remote_ip4; - __u32 local_ip4; - __u32 remote_ip6[4]; - __u32 local_ip6[4]; - __u32 remote_port; - __u32 local_port; - __u32 is_fullsock; - __u32 snd_cwnd; - __u32 srtt_us; - __u32 bpf_sock_ops_cb_flags; - __u32 state; - __u32 rtt_min; - __u32 snd_ssthresh; - __u32 rcv_nxt; - __u32 snd_nxt; - __u32 snd_una; - __u32 mss_cache; - __u32 ecn_flags; - __u32 rate_delivered; - __u32 rate_interval_us; - __u32 packets_out; - __u32 retrans_out; - __u32 total_retrans; - __u32 segs_in; - __u32 data_segs_in; - __u32 segs_out; - __u32 data_segs_out; - __u32 lost_out; - __u32 sacked_out; - __u32 sk_txhash; - __u64 bytes_received; - __u64 bytes_acked; - union { - struct bpf_sock *sk; - }; -}; - enum { BPF_SOCK_OPS_RTO_CB_FLAG = 1, BPF_SOCK_OPS_RETRANS_CB_FLAG = 2, @@ -103123,63 +106561,6 @@ struct bpf_fib_lookup { __u8 dmac[6]; }; -enum bpf_access_type { - BPF_READ = 1, - BPF_WRITE = 2, -}; - -enum bpf_reg_type { - NOT_INIT = 0, - SCALAR_VALUE = 1, - PTR_TO_CTX = 2, - CONST_PTR_TO_MAP = 3, - PTR_TO_MAP_VALUE = 4, - PTR_TO_MAP_VALUE_OR_NULL = 5, - PTR_TO_STACK = 6, - PTR_TO_PACKET_META = 7, - PTR_TO_PACKET = 8, - PTR_TO_PACKET_END = 9, - PTR_TO_FLOW_KEYS = 10, - PTR_TO_SOCKET = 11, - PTR_TO_SOCKET_OR_NULL = 12, - PTR_TO_SOCK_COMMON = 13, - PTR_TO_SOCK_COMMON_OR_NULL = 14, - PTR_TO_TCP_SOCK = 15, - PTR_TO_TCP_SOCK_OR_NULL = 16, - PTR_TO_TP_BUFFER = 17, - PTR_TO_XDP_SOCK = 18, - PTR_TO_BTF_ID = 19, -}; - -struct bpf_verifier_log; - -struct bpf_insn_access_aux { - enum bpf_reg_type reg_type; - union { - int ctx_field_size; - u32 btf_id; - }; - struct bpf_verifier_log *log; -}; - -struct bpf_verifier_ops { - const struct bpf_func_proto * (*get_func_proto)(enum bpf_func_id, const struct bpf_prog *); - bool (*is_valid_access)(int, int, enum bpf_access_type, const struct bpf_prog *, struct bpf_insn_access_aux *); - int (*gen_prologue)(struct bpf_insn *, bool, const struct bpf_prog *); - int (*gen_ld_abs)(const struct bpf_insn *, struct bpf_insn *); - u32 (*convert_ctx_access)(enum bpf_access_type, const struct bpf_insn *, struct bpf_insn *, struct bpf_prog *, u32 *); -}; - -struct sk_reuseport_kern { - struct sk_buff *skb; - struct sock *sk; - struct sock *selected_sk; - void *data_end; - u32 hash; - u32 reuseport_id; - bool bind_inany; -}; - enum rt_scope_t { RT_SCOPE_UNIVERSE = 0, RT_SCOPE_SITE = 200, @@ -103197,35 +106578,7 @@ enum rt_class_t { RT_TABLE_MAX = 4294967295, }; -struct bpf_skb_data_end { - struct qdisc_skb_cb qdisc_cb; - void *data_meta; - void *data_end; -}; - -struct bpf_sock_addr_kern { - struct sock *sk; - struct sockaddr *uaddr; - u64 tmp_reg; - void *t_ctx; -}; - -struct bpf_sock_ops_kern { - struct sock *sk; - u32 op; - union { - u32 args[4]; - u32 reply; - u32 replylong[4]; - }; - u32 is_fullsock; - u64 temp; -}; - -struct ipv6_bpf_stub { - int (*inet6_bind)(struct sock *, struct sockaddr *, int, bool, bool); - struct sock * (*udp6_lib_lookup)(struct net *, const struct in6_addr *, __be16, const struct in6_addr *, __be16, int, int, struct udp_table *, struct sk_buff *); -}; +typedef int (*bpf_aux_classic_check_t)(struct sock_filter *, unsigned int); struct fib_result { __be32 prefix; @@ -103287,56 +106640,45 @@ struct tcp_skb_cb { }; }; -struct sk_msg_sg { - u32 start; - u32 curr; - u32 end; - u32 size; - u32 copybreak; - long unsigned int copy; - struct scatterlist data[19]; -}; - -struct sk_msg { - struct sk_msg_sg sg; - void *data; - void *data_end; - u32 apply_bytes; - u32 cork_bytes; - u32 flags; - struct sk_buff *skb; - struct sock *sk_redir; - struct sock *sk; - struct list_head list; -}; - struct _bpf_dtab_netdev { struct net_device *dev; }; -struct xdp_sock { - struct sock sk; - struct xsk_queue *rx; - struct net_device *dev; - struct xdp_umem *umem; - struct list_head flush_node; - u16 queue_id; - bool zc; - enum { - XSK_READY = 0, - XSK_BOUND = 1, - XSK_UNBOUND = 2, - } state; - struct mutex mutex; - long: 64; - long: 64; - struct xsk_queue *tx; - struct list_head list; - spinlock_t tx_completion_lock; - spinlock_t rx_lock; - u64 rx_dropped; - struct list_head map_list; - spinlock_t map_list_lock; +struct ipv6_sr_hdr { + __u8 nexthdr; + __u8 hdrlen; + __u8 type; + __u8 segments_left; + __u8 first_segment; + __u8 flags; + __u16 tag; + struct in6_addr segments[0]; +}; + +enum { + SEG6_LOCAL_ACTION_UNSPEC = 0, + SEG6_LOCAL_ACTION_END = 1, + SEG6_LOCAL_ACTION_END_X = 2, + SEG6_LOCAL_ACTION_END_T = 3, + SEG6_LOCAL_ACTION_END_DX2 = 4, + SEG6_LOCAL_ACTION_END_DX6 = 5, + SEG6_LOCAL_ACTION_END_DX4 = 6, + SEG6_LOCAL_ACTION_END_DT6 = 7, + SEG6_LOCAL_ACTION_END_DT4 = 8, + SEG6_LOCAL_ACTION_END_B6 = 9, + SEG6_LOCAL_ACTION_END_B6_ENCAP = 10, + SEG6_LOCAL_ACTION_END_BM = 11, + SEG6_LOCAL_ACTION_END_S = 12, + SEG6_LOCAL_ACTION_END_AS = 13, + SEG6_LOCAL_ACTION_END_AM = 14, + SEG6_LOCAL_ACTION_END_BPF = 15, + __SEG6_LOCAL_ACTION_MAX = 16, +}; + +struct seg6_bpf_srh_state { + struct ipv6_sr_hdr *srh; + u16 hdrlen; + bool valid; }; typedef u64 (*btf_bpf_skb_get_pay_offset)(struct sk_buff *); @@ -103452,6 +106794,10 @@ typedef u64 (*btf_bpf_skb_set_tunnel_opt)(struct sk_buff *, const u8 *, u32); typedef u64 (*btf_bpf_skb_under_cgroup)(struct sk_buff *, struct bpf_map *, u32); +typedef u64 (*btf_bpf_skb_cgroup_id)(const struct sk_buff *); + +typedef u64 (*btf_bpf_skb_ancestor_cgroup_id)(const struct sk_buff *, int); + typedef u64 (*btf_bpf_xdp_event_output)(struct xdp_buff *, struct bpf_map *, u64, void *, u64); typedef u64 (*btf_bpf_get_socket_cookie)(struct sk_buff *); @@ -103482,6 +106828,12 @@ typedef u64 (*btf_bpf_lwt_in_push_encap)(struct sk_buff *, u32, void *, u32); typedef u64 (*btf_bpf_lwt_xmit_push_encap)(struct sk_buff *, u32, void *, u32); +typedef u64 (*btf_bpf_lwt_seg6_store_bytes)(struct sk_buff *, u32, const void *, u32); + +typedef u64 (*btf_bpf_lwt_seg6_action)(struct sk_buff *, u32, void *, u32); + +typedef u64 (*btf_bpf_lwt_seg6_adjust_srh)(struct sk_buff *, u32, s32); + typedef u64 (*btf_bpf_skc_lookup_tcp)(struct sk_buff *, struct bpf_sock_tuple *, u32, u64, u64); typedef u64 (*btf_bpf_sk_lookup_tcp)(struct sk_buff *, struct bpf_sock_tuple *, u32, u64, u64); @@ -103518,9 +106870,9 @@ typedef u64 (*btf_sk_reuseport_load_bytes)(const struct sk_reuseport_kern *, u32 typedef u64 (*btf_sk_reuseport_load_bytes_relative)(const struct sk_reuseport_kern *, u32, void *, u32, u32); -struct bpf_dtab_netdev; +struct bpf_dtab_netdev___2; -struct bpf_cpu_map_entry; +struct bpf_cpu_map_entry___2; struct sock_diag_req { __u8 sdiag_family; @@ -103578,37 +106930,6 @@ struct xdp_attachment_info { u32 flags; }; -struct ptr_ring { - int producer; - spinlock_t producer_lock; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - int consumer_head; - int consumer_tail; - spinlock_t consumer_lock; - long: 32; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - int size; - int batch; - void **queue; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; - long: 64; -}; - struct pp_alloc_cache { u32 count; void *cache[128]; @@ -103795,6 +107116,105 @@ struct netdev_queue_attribute { ssize_t (*store)(struct netdev_queue *, const char *, size_t); }; +struct strp_stats { + long long unsigned int msgs; + long long unsigned int bytes; + unsigned int mem_fail; + unsigned int need_more_hdr; + unsigned int msg_too_big; + unsigned int msg_timeouts; + unsigned int bad_hdr_len; +}; + +struct strparser; + +struct strp_callbacks { + int (*parse_msg)(struct strparser *, struct sk_buff *); + void (*rcv_msg)(struct strparser *, struct sk_buff *); + int (*read_sock_done)(struct strparser *, int); + void (*abort_parser)(struct strparser *, int); + void (*lock)(struct strparser *); + void (*unlock)(struct strparser *); +}; + +struct strparser { + struct sock *sk; + u32 stopped: 1; + u32 paused: 1; + u32 aborted: 1; + u32 interrupted: 1; + u32 unrecov_intr: 1; + struct sk_buff **skb_nextp; + struct sk_buff *skb_head; + unsigned int need_bytes; + struct delayed_work msg_timer_work; + struct work_struct work; + struct strp_stats stats; + struct strp_callbacks cb; +}; + +enum __sk_action { + __SK_DROP = 0, + __SK_PASS = 1, + __SK_REDIRECT = 2, + __SK_NONE = 3, +}; + +struct sk_psock_progs { + struct bpf_prog *msg_parser; + struct bpf_prog *skb_parser; + struct bpf_prog *skb_verdict; +}; + +enum sk_psock_state_bits { + SK_PSOCK_TX_ENABLED = 0, +}; + +struct sk_psock_link { + struct list_head list; + struct bpf_map *map; + void *link_raw; +}; + +struct sk_psock_parser { + struct strparser strp; + bool enabled; + void (*saved_data_ready)(struct sock *); +}; + +struct sk_psock_work_state { + struct sk_buff *skb; + u32 len; + u32 off; +}; + +struct sk_psock { + struct sock *sk; + struct sock *sk_redir; + u32 apply_bytes; + u32 cork_bytes; + u32 eval; + struct sk_msg *cork; + struct sk_psock_progs progs; + struct sk_psock_parser parser; + struct sk_buff_head ingress_skb; + struct list_head ingress_msg; + long unsigned int state; + struct list_head link; + spinlock_t link_lock; + refcount_t refcnt; + void (*saved_unhash)(struct sock *); + void (*saved_close)(struct sock *, long int); + void (*saved_write_space)(struct sock *); + struct proto *sk_proto; + struct sk_psock_work_state work_state; + struct work_struct work; + union { + struct callback_head rcu; + struct work_struct gc; + }; +}; + struct fib_rule_uid_range { __u32 start; __u32 end; @@ -103874,6 +107294,12 @@ struct trace_event_data_offsets_consume_skb {}; struct trace_event_data_offsets_skb_copy_datagram_iovec {}; +typedef void (*btf_trace_kfree_skb)(void *, struct sk_buff *, void *); + +typedef void (*btf_trace_consume_skb)(void *, struct sk_buff *); + +typedef void (*btf_trace_skb_copy_datagram_iovec)(void *, const struct sk_buff *, int); + struct trace_event_raw_net_dev_start_xmit { struct trace_entry ent; u32 __data_loc_name; @@ -103974,6 +107400,42 @@ struct trace_event_data_offsets_net_dev_rx_verbose_template { struct trace_event_data_offsets_net_dev_rx_exit_template {}; +typedef void (*btf_trace_net_dev_start_xmit)(void *, const struct sk_buff *, const struct net_device *); + +typedef void (*btf_trace_net_dev_xmit)(void *, struct sk_buff *, int, struct net_device *, unsigned int); + +typedef void (*btf_trace_net_dev_xmit_timeout)(void *, struct net_device *, int); + +typedef void (*btf_trace_net_dev_queue)(void *, struct sk_buff *); + +typedef void (*btf_trace_netif_receive_skb)(void *, struct sk_buff *); + +typedef void (*btf_trace_netif_rx)(void *, struct sk_buff *); + +typedef void (*btf_trace_napi_gro_frags_entry)(void *, const struct sk_buff *); + +typedef void (*btf_trace_napi_gro_receive_entry)(void *, const struct sk_buff *); + +typedef void (*btf_trace_netif_receive_skb_entry)(void *, const struct sk_buff *); + +typedef void (*btf_trace_netif_receive_skb_list_entry)(void *, const struct sk_buff *); + +typedef void (*btf_trace_netif_rx_entry)(void *, const struct sk_buff *); + +typedef void (*btf_trace_netif_rx_ni_entry)(void *, const struct sk_buff *); + +typedef void (*btf_trace_napi_gro_frags_exit)(void *, int); + +typedef void (*btf_trace_napi_gro_receive_exit)(void *, int); + +typedef void (*btf_trace_netif_receive_skb_exit)(void *, int); + +typedef void (*btf_trace_netif_rx_exit)(void *, int); + +typedef void (*btf_trace_netif_rx_ni_exit)(void *, int); + +typedef void (*btf_trace_netif_receive_skb_list_exit)(void *, int); + struct trace_event_raw_napi_poll { struct trace_entry ent; struct napi_struct *napi; @@ -103987,6 +107449,8 @@ struct trace_event_data_offsets_napi_poll { u32 dev_name; }; +typedef void (*btf_trace_napi_poll)(void *, struct napi_struct *, int, int); + enum tcp_ca_state { TCP_CA_Open = 0, TCP_CA_Disorder = 1, @@ -104039,6 +107503,12 @@ struct trace_event_data_offsets_sock_exceed_buf_limit {}; struct trace_event_data_offsets_inet_sock_set_state {}; +typedef void (*btf_trace_sock_rcvqueue_full)(void *, struct sock *, struct sk_buff *); + +typedef void (*btf_trace_sock_exceed_buf_limit)(void *, struct sock *, struct proto *, long int, int); + +typedef void (*btf_trace_inet_sock_set_state)(void *, const struct sock *, const int, const int); + struct trace_event_raw_udp_fail_queue_rcv_skb { struct trace_entry ent; int rc; @@ -104048,6 +107518,8 @@ struct trace_event_raw_udp_fail_queue_rcv_skb { struct trace_event_data_offsets_udp_fail_queue_rcv_skb {}; +typedef void (*btf_trace_udp_fail_queue_rcv_skb)(void *, int, struct sock *); + struct trace_event_raw_tcp_event_sk_skb { struct trace_entry ent; const void *skbaddr; @@ -104115,6 +107587,20 @@ struct trace_event_data_offsets_tcp_retransmit_synack {}; struct trace_event_data_offsets_tcp_probe {}; +typedef void (*btf_trace_tcp_retransmit_skb)(void *, const struct sock *, const struct sk_buff *); + +typedef void (*btf_trace_tcp_send_reset)(void *, const struct sock *, const struct sk_buff *); + +typedef void (*btf_trace_tcp_receive_reset)(void *, struct sock *); + +typedef void (*btf_trace_tcp_destroy_sock)(void *, struct sock *); + +typedef void (*btf_trace_tcp_rcv_space_adjust)(void *, struct sock *); + +typedef void (*btf_trace_tcp_retransmit_synack)(void *, const struct sock *, const struct request_sock *); + +typedef void (*btf_trace_tcp_probe)(void *, struct sock *, struct sk_buff *); + struct trace_event_raw_fib_table_lookup { struct trace_entry ent; u32 tb_id; @@ -104139,6 +107625,8 @@ struct trace_event_data_offsets_fib_table_lookup { u32 name; }; +typedef void (*btf_trace_fib_table_lookup)(void *, u32, const struct flowi4 *, const struct fib_nh_common *, int); + struct trace_event_raw_qdisc_dequeue { struct trace_entry ent; struct Qdisc *qdisc; @@ -104154,6 +107642,8 @@ struct trace_event_raw_qdisc_dequeue { struct trace_event_data_offsets_qdisc_dequeue {}; +typedef void (*btf_trace_qdisc_dequeue)(void *, struct Qdisc *, const struct netdev_queue *, int, struct sk_buff *); + struct trace_event_raw_neigh_create { struct trace_entry ent; u32 family; @@ -104221,6 +107711,132 @@ struct trace_event_data_offsets_neigh__update { u32 dev; }; +typedef void (*btf_trace_neigh_create)(void *, struct neigh_table *, struct net_device *, const void *, const struct neighbour *, bool); + +typedef void (*btf_trace_neigh_update)(void *, struct neighbour *, const u8 *, u8, u32, u32); + +typedef void (*btf_trace_neigh_update_done)(void *, struct neighbour *, int); + +typedef void (*btf_trace_neigh_timer_handler)(void *, struct neighbour *, int); + +typedef void (*btf_trace_neigh_event_send_done)(void *, struct neighbour *, int); + +typedef void (*btf_trace_neigh_event_send_dead)(void *, struct neighbour *, int); + +typedef void (*btf_trace_neigh_cleanup_and_release)(void *, struct neighbour *, int); + +enum lwtunnel_encap_types { + LWTUNNEL_ENCAP_NONE = 0, + LWTUNNEL_ENCAP_MPLS = 1, + LWTUNNEL_ENCAP_IP = 2, + LWTUNNEL_ENCAP_ILA = 3, + LWTUNNEL_ENCAP_IP6 = 4, + LWTUNNEL_ENCAP_SEG6 = 5, + LWTUNNEL_ENCAP_BPF = 6, + LWTUNNEL_ENCAP_SEG6_LOCAL = 7, + __LWTUNNEL_ENCAP_MAX = 8, +}; + +struct rtnexthop { + short unsigned int rtnh_len; + unsigned char rtnh_flags; + unsigned char rtnh_hops; + int rtnh_ifindex; +}; + +struct lwtunnel_encap_ops { + int (*build_state)(struct nlattr *, unsigned int, const void *, struct lwtunnel_state **, struct netlink_ext_ack *); + void (*destroy_state)(struct lwtunnel_state *); + int (*output)(struct net *, struct sock *, struct sk_buff *); + int (*input)(struct sk_buff *); + int (*fill_encap)(struct sk_buff *, struct lwtunnel_state *); + int (*get_encap_size)(struct lwtunnel_state *); + int (*cmp_encap)(struct lwtunnel_state *, struct lwtunnel_state *); + int (*xmit)(struct sk_buff *); + struct module *owner; +}; + +enum { + LWT_BPF_PROG_UNSPEC = 0, + LWT_BPF_PROG_FD = 1, + LWT_BPF_PROG_NAME = 2, + __LWT_BPF_PROG_MAX = 3, +}; + +enum { + LWT_BPF_UNSPEC = 0, + LWT_BPF_IN = 1, + LWT_BPF_OUT = 2, + LWT_BPF_XMIT = 3, + LWT_BPF_XMIT_HEADROOM = 4, + __LWT_BPF_MAX = 5, +}; + +enum { + LWTUNNEL_XMIT_DONE = 0, + LWTUNNEL_XMIT_CONTINUE = 1, +}; + +struct bpf_lwt_prog { + struct bpf_prog *prog; + char *name; +}; + +struct bpf_lwt { + struct bpf_lwt_prog in; + struct bpf_lwt_prog out; + struct bpf_lwt_prog xmit; + int family; +}; + +struct bpf_stab { + struct bpf_map map; + struct sock **sks; + struct sk_psock_progs progs; + raw_spinlock_t lock; + long: 32; + long: 64; + long: 64; + long: 64; +}; + +typedef u64 (*btf_bpf_sock_map_update)(struct bpf_sock_ops_kern *, struct bpf_map *, void *, u64); + +typedef u64 (*btf_bpf_sk_redirect_map)(struct sk_buff *, struct bpf_map *, u32, u64); + +typedef u64 (*btf_bpf_msg_redirect_map)(struct sk_msg *, struct bpf_map *, u32, u64); + +struct bpf_htab_elem { + struct callback_head rcu; + u32 hash; + struct sock *sk; + struct hlist_node node; + u8 key[0]; +}; + +struct bpf_htab_bucket { + struct hlist_head head; + raw_spinlock_t lock; +}; + +struct bpf_htab___2 { + struct bpf_map map; + struct bpf_htab_bucket *buckets; + u32 buckets_num; + u32 elem_size; + struct sk_psock_progs progs; + atomic_t count; + long: 32; + long: 64; + long: 64; +}; + +typedef u64 (*btf_bpf_sock_hash_update)(struct bpf_sock_ops_kern *, struct bpf_map *, void *, u64); + +typedef u64 (*btf_bpf_sk_redirect_hash)(struct sk_buff *, struct bpf_map *, void *, u64); + +typedef u64 (*btf_bpf_msg_redirect_hash)(struct sk_msg *, struct bpf_map *, void *, u64); + struct dst_cache_pcpu { long unsigned int refresh_ts; struct dst_entry *dst; @@ -104242,6 +107858,64 @@ struct gro_cell { struct napi_struct napi; }; +enum { + BPF_SK_STORAGE_GET_F_CREATE = 1, +}; + +struct bpf_sk_storage_data; + +struct bpf_sk_storage { + struct bpf_sk_storage_data *cache[16]; + struct hlist_head list; + struct sock *sk; + struct callback_head rcu; + raw_spinlock_t lock; +}; + +struct bucket___2 { + struct hlist_head list; + raw_spinlock_t lock; +}; + +struct bpf_sk_storage_map { + struct bpf_map map; + struct bucket___2 *buckets; + u32 bucket_log; + u16 elem_size; + u16 cache_idx; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct bpf_sk_storage_data { + struct bpf_sk_storage_map *smap; + u8 data[0]; +}; + +struct bpf_sk_storage_elem { + struct hlist_node map_node; + struct hlist_node snode; + struct bpf_sk_storage *sk_storage; + struct callback_head rcu; + long: 64; + struct bpf_sk_storage_data sdata; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +typedef u64 (*btf_bpf_sk_storage_get)(struct bpf_map *, struct sock *, void *, u64); + +typedef u64 (*btf_bpf_sk_storage_delete)(struct bpf_map *, struct sock *); + struct group_req { __u32 gr_interface; struct __kernel_sockaddr_storage gr_group; @@ -104757,6 +108431,181 @@ struct tcf_skbedit { struct tcf_skbedit_params *params; }; +struct nf_conntrack_tuple_mask { + struct { + union nf_inet_addr u3; + union nf_conntrack_man_proto u; + } src; +}; + +struct nf_conntrack_l4proto___2; + +struct nf_conntrack_helper; + +struct nf_conntrack_expect { + struct hlist_node lnode; + struct hlist_node hnode; + struct nf_conntrack_tuple tuple; + struct nf_conntrack_tuple_mask mask; + void (*expectfn)(struct nf_conn *, struct nf_conntrack_expect *); + struct nf_conntrack_helper *helper; + struct nf_conn *master; + struct timer_list timeout; + refcount_t use; + unsigned int flags; + unsigned int class; + union nf_inet_addr saved_addr; + union nf_conntrack_man_proto saved_proto; + enum ip_conntrack_dir dir; + struct callback_head rcu; +}; + +struct PptpControlHeader { + __be16 messageType; + __u16 reserved; +}; + +struct PptpStartSessionRequest { + __be16 protocolVersion; + __u16 reserved1; + __be32 framingCapability; + __be32 bearerCapability; + __be16 maxChannels; + __be16 firmwareRevision; + __u8 hostName[64]; + __u8 vendorString[64]; +}; + +struct PptpStartSessionReply { + __be16 protocolVersion; + __u8 resultCode; + __u8 generalErrorCode; + __be32 framingCapability; + __be32 bearerCapability; + __be16 maxChannels; + __be16 firmwareRevision; + __u8 hostName[64]; + __u8 vendorString[64]; +}; + +struct PptpStopSessionRequest { + __u8 reason; + __u8 reserved1; + __u16 reserved2; +}; + +struct PptpStopSessionReply { + __u8 resultCode; + __u8 generalErrorCode; + __u16 reserved1; +}; + +struct PptpOutCallRequest { + __be16 callID; + __be16 callSerialNumber; + __be32 minBPS; + __be32 maxBPS; + __be32 bearerType; + __be32 framingType; + __be16 packetWindow; + __be16 packetProcDelay; + __be16 phoneNumberLength; + __u16 reserved1; + __u8 phoneNumber[64]; + __u8 subAddress[64]; +}; + +struct PptpOutCallReply { + __be16 callID; + __be16 peersCallID; + __u8 resultCode; + __u8 generalErrorCode; + __be16 causeCode; + __be32 connectSpeed; + __be16 packetWindow; + __be16 packetProcDelay; + __be32 physChannelID; +}; + +struct PptpInCallRequest { + __be16 callID; + __be16 callSerialNumber; + __be32 callBearerType; + __be32 physChannelID; + __be16 dialedNumberLength; + __be16 dialingNumberLength; + __u8 dialedNumber[64]; + __u8 dialingNumber[64]; + __u8 subAddress[64]; +}; + +struct PptpInCallReply { + __be16 callID; + __be16 peersCallID; + __u8 resultCode; + __u8 generalErrorCode; + __be16 packetWindow; + __be16 packetProcDelay; + __u16 reserved; +}; + +struct PptpInCallConnected { + __be16 peersCallID; + __u16 reserved; + __be32 connectSpeed; + __be16 packetWindow; + __be16 packetProcDelay; + __be32 callFramingType; +}; + +struct PptpClearCallRequest { + __be16 callID; + __u16 reserved; +}; + +struct PptpCallDisconnectNotify { + __be16 callID; + __u8 resultCode; + __u8 generalErrorCode; + __be16 causeCode; + __u16 reserved; + __u8 callStatistics[128]; +}; + +struct PptpWanErrorNotify { + __be16 peersCallID; + __u16 reserved; + __be32 crcErrors; + __be32 framingErrors; + __be32 hardwareOverRuns; + __be32 bufferOverRuns; + __be32 timeoutErrors; + __be32 alignmentErrors; +}; + +struct PptpSetLinkInfo { + __be16 peersCallID; + __u16 reserved; + __be32 sendAccm; + __be32 recvAccm; +}; + +union pptp_ctrl_union { + struct PptpStartSessionRequest sreq; + struct PptpStartSessionReply srep; + struct PptpStopSessionRequest streq; + struct PptpStopSessionReply strep; + struct PptpOutCallRequest ocreq; + struct PptpOutCallReply ocack; + struct PptpInCallRequest icreq; + struct PptpInCallReply icack; + struct PptpInCallConnected iccon; + struct PptpClearCallRequest clrreq; + struct PptpCallDisconnectNotify disc; + struct PptpWanErrorNotify wanerr; + struct PptpSetLinkInfo setlink; +}; + struct nf_nat_range2 { unsigned int flags; union nf_inet_addr min_addr; @@ -104850,10 +108699,111 @@ struct tc_action_net { const struct tc_action_ops *ops; }; +struct tc_act_bpf { + __u32 index; + __u32 capab; + int action; + int refcnt; + int bindcnt; +}; + +enum { + TCA_ACT_BPF_UNSPEC = 0, + TCA_ACT_BPF_TM = 1, + TCA_ACT_BPF_PARMS = 2, + TCA_ACT_BPF_OPS_LEN = 3, + TCA_ACT_BPF_OPS = 4, + TCA_ACT_BPF_FD = 5, + TCA_ACT_BPF_NAME = 6, + TCA_ACT_BPF_PAD = 7, + TCA_ACT_BPF_TAG = 8, + TCA_ACT_BPF_ID = 9, + __TCA_ACT_BPF_MAX = 10, +}; + +struct tcf_bpf { + struct tc_action common; + struct bpf_prog *filter; + union { + u32 bpf_fd; + u16 bpf_num_ops; + }; + struct sock_filter *bpf_ops; + const char *bpf_name; +}; + +struct tcf_bpf_cfg { + struct bpf_prog *filter; + struct sock_filter *bpf_ops; + const char *bpf_name; + u16 bpf_num_ops; + bool is_ebpf; +}; + struct tc_fifo_qopt { __u32 limit; }; +enum { + TCA_BPF_UNSPEC = 0, + TCA_BPF_ACT = 1, + TCA_BPF_POLICE = 2, + TCA_BPF_CLASSID = 3, + TCA_BPF_OPS_LEN = 4, + TCA_BPF_OPS = 5, + TCA_BPF_FD = 6, + TCA_BPF_NAME = 7, + TCA_BPF_FLAGS = 8, + TCA_BPF_FLAGS_GEN = 9, + TCA_BPF_TAG = 10, + TCA_BPF_ID = 11, + __TCA_BPF_MAX = 12, +}; + +struct flow_cls_common_offload { + u32 chain_index; + __be16 protocol; + u32 prio; + struct netlink_ext_ack *extack; +}; + +enum tc_clsbpf_command { + TC_CLSBPF_OFFLOAD = 0, + TC_CLSBPF_STATS = 1, +}; + +struct tc_cls_bpf_offload { + struct flow_cls_common_offload common; + enum tc_clsbpf_command command; + struct tcf_exts *exts; + struct bpf_prog *prog; + struct bpf_prog *oldprog; + const char *name; + bool exts_integrated; +}; + +struct cls_bpf_head { + struct list_head plist; + struct idr handle_idr; + struct callback_head rcu; +}; + +struct cls_bpf_prog { + struct bpf_prog *filter; + struct list_head link; + struct tcf_result res; + bool exts_integrated; + u32 gen_flags; + unsigned int in_hw_count; + struct tcf_exts exts; + u32 handle; + u16 bpf_num_ops; + struct sock_filter *bpf_ops; + const char *bpf_name; + struct tcf_proto *tp; + struct rcu_work rwork; +}; + struct tcf_ematch_tree_hdr { __u16 nmatches; __u16 progid; @@ -105084,24 +109034,19 @@ struct genl_dumpit_info { struct nlattr **attrs; }; -struct nf_hook_entries_rcu_head { - struct callback_head head; - void *allocation; +struct trace_event_raw_bpf_test_finish { + struct trace_entry ent; + int err; + char __data[0]; }; -struct nf_ct_hook { - int (*update)(struct net *, struct sk_buff *); - void (*destroy)(struct nf_conntrack *); - bool (*get_tuple_skb)(struct nf_conntrack_tuple *, const struct sk_buff *); -}; +struct trace_event_data_offsets_bpf_test_finish {}; -struct nfnl_ct_hook { - struct nf_conn * (*get_ct)(const struct sk_buff *, enum ip_conntrack_info *); - size_t (*build_size)(const struct nf_conn *); - int (*build)(struct sk_buff *, struct nf_conn *, enum ip_conntrack_info, u_int16_t, u_int16_t); - int (*parse)(const struct nlattr *, struct nf_conn *); - int (*attach_expect)(const struct nlattr *, struct nf_conn *, u32, u32); - void (*seq_adjust)(struct sk_buff *, struct nf_conn *, enum ip_conntrack_info, s32); +typedef void (*btf_trace_bpf_test_finish)(void *, int *); + +struct nf_hook_entries_rcu_head { + struct callback_head head; + void *allocation; }; struct nf_loginfo { @@ -105382,54 +109327,6 @@ enum ip_conntrack_events { __IPCT_MAX = 12, }; -struct nf_conntrack_tuple_mask { - struct { - union nf_inet_addr u3; - union nf_conntrack_man_proto u; - } src; -}; - -struct nf_conntrack_l4proto { - u_int8_t l4proto; - bool allow_clash; - u16 nlattr_size; - bool (*can_early_drop)(const struct nf_conn *); - int (*to_nlattr)(struct sk_buff *, struct nlattr *, struct nf_conn *); - int (*from_nlattr)(struct nlattr **, struct nf_conn *); - int (*tuple_to_nlattr)(struct sk_buff *, const struct nf_conntrack_tuple *); - unsigned int (*nlattr_tuple_size)(); - int (*nlattr_to_tuple)(struct nlattr **, struct nf_conntrack_tuple *); - const struct nla_policy *nla_policy; - struct { - int (*nlattr_to_obj)(struct nlattr **, struct net *, void *); - int (*obj_to_nlattr)(struct sk_buff *, const void *); - u16 obj_size; - u16 nlattr_max; - const struct nla_policy *nla_policy; - } ctnl_timeout; - void (*print_conntrack)(struct seq_file *, struct nf_conn *); -}; - -struct nf_conntrack_helper; - -struct nf_conntrack_expect { - struct hlist_node lnode; - struct hlist_node hnode; - struct nf_conntrack_tuple tuple; - struct nf_conntrack_tuple_mask mask; - void (*expectfn)(struct nf_conn *, struct nf_conntrack_expect *); - struct nf_conntrack_helper *helper; - struct nf_conn *master; - struct timer_list timeout; - refcount_t use; - unsigned int flags; - unsigned int class; - union nf_inet_addr saved_addr; - union nf_conntrack_man_proto saved_proto; - enum ip_conntrack_dir dir; - struct callback_head rcu; -}; - struct nf_conntrack_expect_policy; struct nf_conntrack_helper { @@ -105566,7 +109463,24 @@ enum nf_ct_sysctl_index { NF_SYSCTL_CT_PROTO_TIMEOUT_UDP_STREAM = 23, NF_SYSCTL_CT_PROTO_TIMEOUT_ICMP = 24, NF_SYSCTL_CT_PROTO_TIMEOUT_ICMPV6 = 25, - __NF_SYSCTL_CT_LAST_SYSCTL = 26, + NF_SYSCTL_CT_PROTO_TIMEOUT_SCTP_CLOSED = 26, + NF_SYSCTL_CT_PROTO_TIMEOUT_SCTP_COOKIE_WAIT = 27, + NF_SYSCTL_CT_PROTO_TIMEOUT_SCTP_COOKIE_ECHOED = 28, + NF_SYSCTL_CT_PROTO_TIMEOUT_SCTP_ESTABLISHED = 29, + NF_SYSCTL_CT_PROTO_TIMEOUT_SCTP_SHUTDOWN_SENT = 30, + NF_SYSCTL_CT_PROTO_TIMEOUT_SCTP_SHUTDOWN_RECD = 31, + NF_SYSCTL_CT_PROTO_TIMEOUT_SCTP_SHUTDOWN_ACK_SENT = 32, + NF_SYSCTL_CT_PROTO_TIMEOUT_SCTP_HEARTBEAT_SENT = 33, + NF_SYSCTL_CT_PROTO_TIMEOUT_SCTP_HEARTBEAT_ACKED = 34, + NF_SYSCTL_CT_PROTO_TIMEOUT_DCCP_REQUEST = 35, + NF_SYSCTL_CT_PROTO_TIMEOUT_DCCP_RESPOND = 36, + NF_SYSCTL_CT_PROTO_TIMEOUT_DCCP_PARTOPEN = 37, + NF_SYSCTL_CT_PROTO_TIMEOUT_DCCP_OPEN = 38, + NF_SYSCTL_CT_PROTO_TIMEOUT_DCCP_CLOSEREQ = 39, + NF_SYSCTL_CT_PROTO_TIMEOUT_DCCP_CLOSING = 40, + NF_SYSCTL_CT_PROTO_TIMEOUT_DCCP_TIMEWAIT = 41, + NF_SYSCTL_CT_PROTO_DCCP_LOOSE = 42, + __NF_SYSCTL_CT_LAST_SYSCTL = 43, }; enum ip_conntrack_expect_events { @@ -105718,6 +109632,95 @@ struct icmp6hdr { } icmp6_dataun; }; +enum ct_dccp_roles { + CT_DCCP_ROLE_CLIENT = 0, + CT_DCCP_ROLE_SERVER = 1, + __CT_DCCP_ROLE_MAX = 2, +}; + +struct dccp_hdr_ext { + __be32 dccph_seq_low; +}; + +struct dccp_hdr_ack_bits { + __be16 dccph_reserved1; + __be16 dccph_ack_nr_high; + __be32 dccph_ack_nr_low; +}; + +enum dccp_pkt_type { + DCCP_PKT_REQUEST = 0, + DCCP_PKT_RESPONSE = 1, + DCCP_PKT_DATA = 2, + DCCP_PKT_ACK = 3, + DCCP_PKT_DATAACK = 4, + DCCP_PKT_CLOSEREQ = 5, + DCCP_PKT_CLOSE = 6, + DCCP_PKT_RESET = 7, + DCCP_PKT_SYNC = 8, + DCCP_PKT_SYNCACK = 9, + DCCP_PKT_INVALID = 10, +}; + +enum ctattr_protoinfo_dccp { + CTA_PROTOINFO_DCCP_UNSPEC = 0, + CTA_PROTOINFO_DCCP_STATE = 1, + CTA_PROTOINFO_DCCP_ROLE = 2, + CTA_PROTOINFO_DCCP_HANDSHAKE_SEQ = 3, + CTA_PROTOINFO_DCCP_PAD = 4, + __CTA_PROTOINFO_DCCP_MAX = 5, +}; + +enum { + SCTP_CHUNK_FLAG_T = 1, +}; + +enum { + SCTP_MIB_NUM = 0, + SCTP_MIB_CURRESTAB = 1, + SCTP_MIB_ACTIVEESTABS = 2, + SCTP_MIB_PASSIVEESTABS = 3, + SCTP_MIB_ABORTEDS = 4, + SCTP_MIB_SHUTDOWNS = 5, + SCTP_MIB_OUTOFBLUES = 6, + SCTP_MIB_CHECKSUMERRORS = 7, + SCTP_MIB_OUTCTRLCHUNKS = 8, + SCTP_MIB_OUTORDERCHUNKS = 9, + SCTP_MIB_OUTUNORDERCHUNKS = 10, + SCTP_MIB_INCTRLCHUNKS = 11, + SCTP_MIB_INORDERCHUNKS = 12, + SCTP_MIB_INUNORDERCHUNKS = 13, + SCTP_MIB_FRAGUSRMSGS = 14, + SCTP_MIB_REASMUSRMSGS = 15, + SCTP_MIB_OUTSCTPPACKS = 16, + SCTP_MIB_INSCTPPACKS = 17, + SCTP_MIB_T1_INIT_EXPIREDS = 18, + SCTP_MIB_T1_COOKIE_EXPIREDS = 19, + SCTP_MIB_T2_SHUTDOWN_EXPIREDS = 20, + SCTP_MIB_T3_RTX_EXPIREDS = 21, + SCTP_MIB_T4_RTO_EXPIREDS = 22, + SCTP_MIB_T5_SHUTDOWN_GUARD_EXPIREDS = 23, + SCTP_MIB_DELAY_SACK_EXPIREDS = 24, + SCTP_MIB_AUTOCLOSE_EXPIREDS = 25, + SCTP_MIB_T1_RETRANSMITS = 26, + SCTP_MIB_T3_RETRANSMITS = 27, + SCTP_MIB_PMTUD_RETRANSMITS = 28, + SCTP_MIB_FAST_RETRANSMITS = 29, + SCTP_MIB_IN_PKT_SOFTIRQ = 30, + SCTP_MIB_IN_PKT_BACKLOG = 31, + SCTP_MIB_IN_PKT_DISCARDS = 32, + SCTP_MIB_IN_DATA_CHUNK_DISCARDS = 33, + __SCTP_MIB_MAX = 34, +}; + +enum ctattr_protoinfo_sctp { + CTA_PROTOINFO_SCTP_UNSPEC = 0, + CTA_PROTOINFO_SCTP_STATE = 1, + CTA_PROTOINFO_SCTP_VTAG_ORIGINAL = 2, + CTA_PROTOINFO_SCTP_VTAG_REPLY = 3, + __CTA_PROTOINFO_SCTP_MAX = 4, +}; + enum cntl_msg_types { IPCTNL_MSG_CT_NEW = 0, IPCTNL_MSG_CT_GET = 1, @@ -106029,28 +110032,6 @@ enum ctattr_protonat { __CTA_PROTONAT_MAX = 3, }; -struct sctp_bind_hashbucket { - spinlock_t lock; - struct hlist_head chain; -}; - -struct sctp_hashbucket { - rwlock_t lock; - struct hlist_head chain; -}; - -struct sctp_globals { - struct list_head address_families; - struct sctp_hashbucket *ep_hashtable; - struct sctp_bind_hashbucket *port_hashtable; - struct rhltable transport_hashtable; - int ep_hashsize; - int port_hashsize; - __u16 max_instreams; - __u16 max_outstreams; - bool checksum_disable; -}; - struct masq_dev_work { struct work_struct work; struct net *net; @@ -106066,7 +110047,7 @@ struct xt_mtdtor_param; struct xt_match { struct list_head list; - char name[29]; + const char name[29]; u_int8_t revision; bool (*match)(const struct sk_buff *, struct xt_action_param *); int (*checkentry)(const struct xt_mtchk_param *); @@ -106105,7 +110086,7 @@ struct xt_tgdtor_param; struct xt_target { struct list_head list; - char name[29]; + const char name[29]; u_int8_t revision; unsigned int (*target)(struct sk_buff *, const struct xt_action_param *); int (*checkentry)(const struct xt_tgchk_param *); @@ -106388,6 +110369,29 @@ struct xt_tcpmss_info { __u16 mss; }; +struct xt_bpf_info { + __u16 bpf_program_num_elem; + struct sock_filter bpf_program[64]; + struct bpf_prog *filter; +}; + +enum xt_bpf_modes { + XT_BPF_MODE_BYTECODE = 0, + XT_BPF_MODE_FD_PINNED = 1, + XT_BPF_MODE_FD_ELF = 2, +}; + +struct xt_bpf_info_v1 { + __u16 mode; + __u16 bpf_program_num_elem; + __s32 fd; + union { + struct sock_filter bpf_program[64]; + char path[512]; + }; + struct bpf_prog *filter; +}; + enum { XT_CONNTRACK_STATE = 1, XT_CONNTRACK_PROTO = 2, @@ -106683,11 +110687,6 @@ struct fib_prop { u8 scope; }; -struct net_offload { - struct offload_callbacks callbacks; - unsigned int flags; -}; - struct raw_hashinfo { rwlock_t lock; struct hlist_head ht[256]; @@ -106769,11 +110768,6 @@ struct ip_reply_arg { kuid_t uid; }; -enum { - LWTUNNEL_XMIT_DONE = 0, - LWTUNNEL_XMIT_CONTINUE = 1, -}; - struct ip_mreq_source { __be32 imr_multiaddr; __be32 imr_interface; @@ -106794,6 +110788,28 @@ struct in_pktinfo { struct in_addr ipi_addr; }; +enum { + BPFILTER_IPT_SO_SET_REPLACE = 64, + BPFILTER_IPT_SO_SET_ADD_COUNTERS = 65, + BPFILTER_IPT_SET_MAX = 66, +}; + +enum { + BPFILTER_IPT_SO_GET_INFO = 64, + BPFILTER_IPT_SO_GET_ENTRIES = 65, + BPFILTER_IPT_SO_GET_REVISION_MATCH = 66, + BPFILTER_IPT_SO_GET_REVISION_TARGET = 67, + BPFILTER_IPT_GET_MAX = 68, +}; + +struct bpfilter_umh_ops { + struct umh_info info; + struct mutex lock; + int (*sockopt)(struct sock *, int, char *, unsigned int, bool); + int (*start)(); + bool stop; +}; + struct inet_timewait_sock { struct sock_common __tw_common; __u32 tw_mark; @@ -107067,11 +111083,6 @@ struct tcp_timewait_sock { struct tcp_md5sig_key *tw_md5_key; }; -struct icmp_err { - int errno; - unsigned int fatal: 1; -}; - enum tcp_tw_status { TCP_TW_SUCCESS = 0, TCP_TW_RST = 1, @@ -107211,8 +111222,6 @@ struct udp_sock { void (*encap_destroy)(struct sock *); struct sk_buff * (*gro_receive)(struct sock *, struct list_head *, struct sk_buff *); int (*gro_complete)(struct sock *, struct sk_buff *, int); - long: 64; - long: 64; struct sk_buff_head reader_queue; int forward_deficit; long: 32; @@ -107269,6 +111278,10 @@ struct arpreq { char arp_dev[16]; }; +typedef struct { + char ax25_call[7]; +} ax25_address; + enum { AX25_VALUES_IPDEFMODE = 0, AX25_VALUES_AXDEFMODE = 1, @@ -107287,12 +111300,31 @@ enum { AX25_MAX_VALUES = 14, }; +struct ax25_dev { + struct ax25_dev *next; + struct net_device *dev; + struct net_device *forward; + struct ctl_table_header *sysheader; + int values[14]; +}; + +typedef struct ax25_dev ax25_dev; + enum { XFRM_LOOKUP_ICMP = 1, XFRM_LOOKUP_QUEUE = 2, XFRM_LOOKUP_KEEP_DST_REF = 4, }; +struct pingv6_ops { + int (*ipv6_recv_error)(struct sock *, struct msghdr *, int, int *); + void (*ip6_datagram_recv_common_ctl)(struct sock *, struct msghdr *, struct sk_buff *); + void (*ip6_datagram_recv_specific_ctl)(struct sock *, struct msghdr *, struct sk_buff *); + int (*icmpv6_err_convert)(u8, u8, int *); + void (*ipv6_icmp_error)(struct sock *, struct sk_buff *, int, __be16, u32, u8 *); + int (*ipv6_chk_addr)(struct net *, const struct in6_addr *, const struct net_device *, int); +}; + struct icmp_bxm { struct sk_buff *skb; int offset; @@ -107383,15 +111415,6 @@ struct devinet_sysctl_table { struct ctl_table devinet_vars[33]; }; -struct pingv6_ops { - int (*ipv6_recv_error)(struct sock *, struct msghdr *, int, int *); - void (*ip6_datagram_recv_common_ctl)(struct sock *, struct msghdr *, struct sk_buff *); - void (*ip6_datagram_recv_specific_ctl)(struct sock *, struct msghdr *, struct sk_buff *); - int (*icmpv6_err_convert)(u8, u8, int *); - void (*ipv6_icmp_error)(struct sock *, struct sk_buff *, int, __be16, u32, u8 *); - int (*ipv6_chk_addr)(struct net *, const struct in6_addr *, const struct net_device *, int); -}; - struct igmphdr { __u8 type; __u8 code; @@ -107442,13 +111465,6 @@ struct igmp_mcf_iter_state { struct ip_mc_list *im; }; -struct rtnexthop { - short unsigned int rtnh_len; - unsigned char rtnh_flags; - unsigned char rtnh_hops; - int rtnh_ifindex; -}; - struct fib_config { u8 fc_dst_len; u8 fc_tos; @@ -107509,18 +111525,6 @@ struct fib_nh_notifier_info { struct fib_nh *fib_nh; }; -enum lwtunnel_encap_types { - LWTUNNEL_ENCAP_NONE = 0, - LWTUNNEL_ENCAP_MPLS = 1, - LWTUNNEL_ENCAP_IP = 2, - LWTUNNEL_ENCAP_ILA = 3, - LWTUNNEL_ENCAP_IP6 = 4, - LWTUNNEL_ENCAP_SEG6 = 5, - LWTUNNEL_ENCAP_BPF = 6, - LWTUNNEL_ENCAP_SEG6_LOCAL = 7, - __LWTUNNEL_ENCAP_MAX = 8, -}; - struct fib_alias { struct hlist_node fa_list; struct fib_info *fa_info; @@ -107621,16 +111625,61 @@ struct ping_table { rwlock_t lock; }; -struct lwtunnel_encap_ops { - int (*build_state)(struct nlattr *, unsigned int, const void *, struct lwtunnel_state **, struct netlink_ext_ack *); - void (*destroy_state)(struct lwtunnel_state *); - int (*output)(struct net *, struct sock *, struct sk_buff *); - int (*input)(struct sk_buff *); - int (*fill_encap)(struct sk_buff *, struct lwtunnel_state *); - int (*get_encap_size)(struct lwtunnel_state *); - int (*cmp_encap)(struct lwtunnel_state *, struct lwtunnel_state *); - int (*xmit)(struct sk_buff *); - struct module *owner; +enum lwtunnel_ip_t { + LWTUNNEL_IP_UNSPEC = 0, + LWTUNNEL_IP_ID = 1, + LWTUNNEL_IP_DST = 2, + LWTUNNEL_IP_SRC = 3, + LWTUNNEL_IP_TTL = 4, + LWTUNNEL_IP_TOS = 5, + LWTUNNEL_IP_FLAGS = 6, + LWTUNNEL_IP_PAD = 7, + LWTUNNEL_IP_OPTS = 8, + __LWTUNNEL_IP_MAX = 9, +}; + +enum lwtunnel_ip6_t { + LWTUNNEL_IP6_UNSPEC = 0, + LWTUNNEL_IP6_ID = 1, + LWTUNNEL_IP6_DST = 2, + LWTUNNEL_IP6_SRC = 3, + LWTUNNEL_IP6_HOPLIMIT = 4, + LWTUNNEL_IP6_TC = 5, + LWTUNNEL_IP6_FLAGS = 6, + LWTUNNEL_IP6_PAD = 7, + LWTUNNEL_IP6_OPTS = 8, + __LWTUNNEL_IP6_MAX = 9, +}; + +enum { + LWTUNNEL_IP_OPTS_UNSPEC = 0, + LWTUNNEL_IP_OPTS_GENEVE = 1, + LWTUNNEL_IP_OPTS_VXLAN = 2, + LWTUNNEL_IP_OPTS_ERSPAN = 3, + __LWTUNNEL_IP_OPTS_MAX = 4, +}; + +enum { + LWTUNNEL_IP_OPT_GENEVE_UNSPEC = 0, + LWTUNNEL_IP_OPT_GENEVE_CLASS = 1, + LWTUNNEL_IP_OPT_GENEVE_TYPE = 2, + LWTUNNEL_IP_OPT_GENEVE_DATA = 3, + __LWTUNNEL_IP_OPT_GENEVE_MAX = 4, +}; + +enum { + LWTUNNEL_IP_OPT_VXLAN_UNSPEC = 0, + LWTUNNEL_IP_OPT_VXLAN_GBP = 1, + __LWTUNNEL_IP_OPT_VXLAN_MAX = 2, +}; + +enum { + LWTUNNEL_IP_OPT_ERSPAN_UNSPEC = 0, + LWTUNNEL_IP_OPT_ERSPAN_VER = 1, + LWTUNNEL_IP_OPT_ERSPAN_INDEX = 2, + LWTUNNEL_IP_OPT_ERSPAN_DIR = 3, + LWTUNNEL_IP_OPT_ERSPAN_HWID = 4, + __LWTUNNEL_IP_OPT_ERSPAN_MAX = 5, }; struct ip6_tnl_encap_ops { @@ -107639,6 +111688,20 @@ struct ip6_tnl_encap_ops { int (*err_handler)(struct sk_buff *, struct inet6_skb_parm *, u8, u8, int, __be32); }; +struct geneve_opt { + __be16 opt_class; + u8 type; + u8 length: 5; + u8 r3: 1; + u8 r2: 1; + u8 r1: 1; + u8 opt_data[0]; +}; + +struct vxlan_metadata { + u32 gbp; +}; + struct erspan_md2 { __be32 timestamp; __be16 sgt; @@ -107651,6 +111714,14 @@ struct erspan_md2 { __u8 hwid: 4; }; +struct erspan_metadata { + int version; + union { + __be32 index; + struct erspan_md2 md2; + } u; +}; + struct nhmsg { unsigned char nh_family; unsigned char nh_scope; @@ -107775,14 +111846,6 @@ struct ip_tunnel_net { int type; }; -struct inet6_protocol { - void (*early_demux)(struct sk_buff *); - void (*early_demux_handler)(struct sk_buff *); - int (*handler)(struct sk_buff *); - int (*err_handler)(struct sk_buff *, struct inet6_skb_parm *, u8, u8, int, __be32); - unsigned int flags; -}; - struct snmp_mib { const char *name; int entry; @@ -108003,8 +112066,6 @@ struct compat_sioc_vif_req { compat_ulong_t obytes; }; -typedef u64 pao_T_____5; - struct rta_mfc_stats { __u64 mfcs_packets; __u64 mfcs_bytes; @@ -108158,6 +112219,124 @@ struct bictcp { u32 curr_rtt; }; +struct tls_crypto_info { + __u16 version; + __u16 cipher_type; +}; + +struct tls12_crypto_info_aes_gcm_128 { + struct tls_crypto_info info; + unsigned char iv[8]; + unsigned char key[16]; + unsigned char salt[4]; + unsigned char rec_seq[8]; +}; + +struct tls12_crypto_info_aes_gcm_256 { + struct tls_crypto_info info; + unsigned char iv[8]; + unsigned char key[32]; + unsigned char salt[4]; + unsigned char rec_seq[8]; +}; + +struct tls_rec { + struct list_head list; + int tx_ready; + int tx_flags; + struct sk_msg msg_plaintext; + struct sk_msg msg_encrypted; + struct scatterlist sg_aead_in[2]; + struct scatterlist sg_aead_out[2]; + char content_type; + struct scatterlist sg_content_type; + char aad_space[13]; + u8 iv_data[16]; + struct aead_request aead_req; + u8 aead_req_ctx[0]; +}; + +struct tx_work { + struct delayed_work work; + struct sock *sk; +}; + +struct tls_sw_context_tx { + struct crypto_aead *aead_send; + struct crypto_wait async_wait; + struct tx_work tx_work; + struct tls_rec *open_rec; + struct list_head tx_list; + atomic_t encrypt_pending; + int async_notify; + u8 async_capable: 1; + long unsigned int tx_bitmask; +}; + +struct cipher_context { + char *iv; + char *rec_seq; +}; + +union tls_crypto_context { + struct tls_crypto_info info; + union { + struct tls12_crypto_info_aes_gcm_128 aes_gcm_128; + struct tls12_crypto_info_aes_gcm_256 aes_gcm_256; + }; +}; + +struct tls_prot_info { + u16 version; + u16 cipher_type; + u16 prepend_size; + u16 tag_size; + u16 overhead_size; + u16 iv_size; + u16 salt_size; + u16 rec_seq_size; + u16 aad_size; + u16 tail_size; +}; + +struct tls_context { + struct tls_prot_info prot_info; + u8 tx_conf: 3; + u8 rx_conf: 3; + int (*push_pending_record)(struct sock *, int); + void (*sk_write_space)(struct sock *); + void *priv_ctx_tx; + void *priv_ctx_rx; + struct net_device *netdev; + struct cipher_context tx; + struct cipher_context rx; + struct scatterlist *partially_sent_record; + u16 partially_sent_offset; + bool in_tcp_sendpages; + bool pending_open_record_frags; + struct mutex tx_lock; + long unsigned int flags; + struct proto *sk_proto; + void (*sk_destruct)(struct sock *); + union tls_crypto_context crypto_send; + union tls_crypto_context crypto_recv; + struct list_head list; + refcount_t refcount; + struct callback_head rcu; +}; + +enum { + TCP_BPF_IPV4 = 0, + TCP_BPF_IPV6 = 1, + TCP_BPF_NUM_PROTS = 2, +}; + +enum { + TCP_BPF_BASE = 0, + TCP_BPF_TX = 1, + TCP_BPF_NUM_CFGS = 2, +}; + struct netlbl_audit { u32 secid; kuid_t loginuid; @@ -108814,11 +112993,6 @@ struct unix_stream_read_state { unsigned int splice_flags; }; -struct ipv6_params { - __s32 disable_ipv6; - __s32 autoconf; -}; - enum flowlabel_reflect { FLOWLABEL_REFLECT_ESTABLISHED = 1, FLOWLABEL_REFLECT_TCP_RESET = 2, @@ -108853,13 +113027,6 @@ struct ip6_frag_state { u8 nexthdr; }; -struct ip6_ra_chain { - struct ip6_ra_chain *next; - struct sock *sk; - int sel; - void (*destructor)(struct sock *); -}; - struct ipcm6_cookie { struct sockcm_cookie sockc; __s16 hlimit; @@ -109240,8 +113407,6 @@ struct rt6_exception { struct callback_head rcu; }; -typedef struct rt6_info * (*pol_lookup_t)(struct net *, struct fib6_table *, struct flowi6 *, const struct sk_buff *, int); - struct rt6_rtnl_dump_arg { struct sk_buff *skb; struct netlink_callback *cb; @@ -109280,6 +113445,8 @@ struct trace_event_data_offsets_fib6_table_lookup { u32 name; }; +typedef void (*btf_trace_fib6_table_lookup)(void *, const struct net *, const struct fib6_result *, struct fib6_table *, const struct flowi6 *); + enum rt6_nud_state { RT6_NUD_FAIL_HARD = 4294967293, RT6_NUD_FAIL_PROBE = 4294967294, @@ -109455,17 +113622,6 @@ struct ip6_mtuinfo { __u32 ip6m_mtu; }; -struct ipv6_sr_hdr { - __u8 nexthdr; - __u8 hdrlen; - __u8 type; - __u8 segments_left; - __u8 first_segment; - __u8 flags; - __u16 tag; - struct in6_addr segments[0]; -}; - struct nduseroptmsg { unsigned char nduseropt_family; unsigned char nduseropt_pad1; @@ -109519,8 +113675,6 @@ struct raw6_frag_vec { char c[4]; }; -typedef void ip6_icmp_send_t(struct sk_buff *, u8, u8, __u32, const struct in6_addr *); - struct icmpv6_msg { struct sk_buff *skb; int offset; @@ -109657,8 +113811,21 @@ struct br_input_skb_cb { u8 src_port_isolated: 1; }; +struct nf_br_ops { + int (*br_dev_xmit_hook)(struct sk_buff *); +}; + struct nf_bridge_frag_data; +typedef struct rt6_info * (*pol_lookup_t)(struct net *, struct fib6_table *, struct flowi6 *, const struct sk_buff *, int); + +struct fib6_rule { + struct fib_rule common; + struct rt6key src; + struct rt6key dst; + u8 tclass; +}; + struct calipso_doi; struct netlbl_calipso_ops { @@ -109704,6 +113871,76 @@ struct calipso_map_cache_entry { struct list_head list; }; +enum { + SEG6_IPTUNNEL_UNSPEC = 0, + SEG6_IPTUNNEL_SRH = 1, + __SEG6_IPTUNNEL_MAX = 2, +}; + +struct seg6_iptunnel_encap { + int mode; + struct ipv6_sr_hdr srh[0]; +}; + +enum { + SEG6_IPTUN_MODE_INLINE = 0, + SEG6_IPTUN_MODE_ENCAP = 1, + SEG6_IPTUN_MODE_L2ENCAP = 2, +}; + +struct seg6_lwt { + struct dst_cache cache; + struct seg6_iptunnel_encap tuninfo[0]; +}; + +enum { + SEG6_LOCAL_UNSPEC = 0, + SEG6_LOCAL_ACTION = 1, + SEG6_LOCAL_SRH = 2, + SEG6_LOCAL_TABLE = 3, + SEG6_LOCAL_NH4 = 4, + SEG6_LOCAL_NH6 = 5, + SEG6_LOCAL_IIF = 6, + SEG6_LOCAL_OIF = 7, + SEG6_LOCAL_BPF = 8, + __SEG6_LOCAL_MAX = 9, +}; + +enum { + SEG6_LOCAL_BPF_PROG_UNSPEC = 0, + SEG6_LOCAL_BPF_PROG = 1, + SEG6_LOCAL_BPF_PROG_NAME = 2, + __SEG6_LOCAL_BPF_PROG_MAX = 3, +}; + +struct seg6_local_lwt; + +struct seg6_action_desc { + int action; + long unsigned int attrs; + int (*input)(struct sk_buff *, struct seg6_local_lwt *); + int static_headroom; +}; + +struct seg6_local_lwt { + int action; + struct ipv6_sr_hdr *srh; + int table; + struct in_addr nh4; + struct in6_addr nh6; + int iif; + int oif; + struct bpf_lwt_prog bpf; + int headroom; + struct seg6_action_desc *desc; +}; + +struct seg6_action_param { + int (*parse)(struct nlattr **, struct seg6_local_lwt *); + int (*put)(struct sk_buff *, struct seg6_local_lwt *); + int (*cmp)(struct seg6_local_lwt *, struct seg6_local_lwt *); +}; + struct ah_data { int icv_full_len; int icv_trunc_len; @@ -109879,14 +114116,14 @@ struct sit_net { struct net_device *fb_tunnel_dev; }; -struct metadata_dst___2; - enum { IP6_FH_F_FRAG = 1, IP6_FH_F_AUTH = 2, IP6_FH_F_SKIP_RH = 4, }; +typedef void ip6_icmp_send_t(struct sk_buff *, u8, u8, __u32, const struct in6_addr *); + struct sockaddr_pkt { short unsigned int spkt_family; unsigned char spkt_device[14]; @@ -110163,8 +114400,6 @@ struct packet_sock { long: 64; long: 64; long: 64; - long: 64; - long: 64; struct packet_type prot_hook; atomic_t tp_drops; long: 32; @@ -110343,6 +114578,8 @@ struct rpc_buffer { char data[0]; }; +typedef void (*rpc_action)(struct rpc_task *); + struct trace_event_raw_rpc_task_status { struct trace_entry ent; unsigned int task_id; @@ -110785,6 +115022,124 @@ struct trace_event_data_offsets_svc_deferred_event { u32 addr; }; +typedef void (*btf_trace_rpc_call_status)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc_bind_status)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc_connect_status)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc_request)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc_task_begin)(void *, const struct rpc_task *, const void *); + +typedef void (*btf_trace_rpc_task_run_action)(void *, const struct rpc_task *, const void *); + +typedef void (*btf_trace_rpc_task_complete)(void *, const struct rpc_task *, const void *); + +typedef void (*btf_trace_rpc_task_end)(void *, const struct rpc_task *, const void *); + +typedef void (*btf_trace_rpc_task_sleep)(void *, const struct rpc_task *, const struct rpc_wait_queue *); + +typedef void (*btf_trace_rpc_task_wakeup)(void *, const struct rpc_task *, const struct rpc_wait_queue *); + +typedef void (*btf_trace_rpc_bad_callhdr)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc_bad_verifier)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc__prog_unavail)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc__prog_mismatch)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc__proc_unavail)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc__garbage_args)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc__unparsable)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc__mismatch)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc__stale_creds)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc__bad_creds)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc__auth_tooweak)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpc_stats_latency)(void *, const struct rpc_task *, ktime_t, ktime_t, ktime_t); + +typedef void (*btf_trace_rpc_xdr_overflow)(void *, const struct xdr_stream *, size_t); + +typedef void (*btf_trace_rpc_xdr_alignment)(void *, const struct xdr_stream *, size_t, unsigned int); + +typedef void (*btf_trace_rpc_reply_pages)(void *, const struct rpc_rqst *); + +typedef void (*btf_trace_rpc_socket_state_change)(void *, struct rpc_xprt *, struct socket *); + +typedef void (*btf_trace_rpc_socket_connect)(void *, struct rpc_xprt *, struct socket *, int); + +typedef void (*btf_trace_rpc_socket_error)(void *, struct rpc_xprt *, struct socket *, int); + +typedef void (*btf_trace_rpc_socket_reset_connection)(void *, struct rpc_xprt *, struct socket *, int); + +typedef void (*btf_trace_rpc_socket_close)(void *, struct rpc_xprt *, struct socket *); + +typedef void (*btf_trace_rpc_socket_shutdown)(void *, struct rpc_xprt *, struct socket *); + +typedef void (*btf_trace_xprt_timer)(void *, const struct rpc_xprt *, __be32, int); + +typedef void (*btf_trace_xprt_lookup_rqst)(void *, const struct rpc_xprt *, __be32, int); + +typedef void (*btf_trace_xprt_complete_rqst)(void *, const struct rpc_xprt *, __be32, int); + +typedef void (*btf_trace_xprt_transmit)(void *, const struct rpc_rqst *, int); + +typedef void (*btf_trace_xprt_enq_xmit)(void *, const struct rpc_task *, int); + +typedef void (*btf_trace_xprt_ping)(void *, const struct rpc_xprt *, int); + +typedef void (*btf_trace_xprt_reserve_xprt)(void *, const struct rpc_xprt *, const struct rpc_task *); + +typedef void (*btf_trace_xprt_release_xprt)(void *, const struct rpc_xprt *, const struct rpc_task *); + +typedef void (*btf_trace_xprt_reserve_cong)(void *, const struct rpc_xprt *, const struct rpc_task *); + +typedef void (*btf_trace_xprt_release_cong)(void *, const struct rpc_xprt *, const struct rpc_task *); + +typedef void (*btf_trace_xprt_get_cong)(void *, const struct rpc_xprt *, const struct rpc_task *); + +typedef void (*btf_trace_xprt_put_cong)(void *, const struct rpc_xprt *, const struct rpc_task *); + +typedef void (*btf_trace_xs_stream_read_data)(void *, struct rpc_xprt *, ssize_t, size_t); + +typedef void (*btf_trace_xs_stream_read_request)(void *, struct sock_xprt *); + +typedef void (*btf_trace_svc_recv)(void *, struct svc_rqst *, int); + +typedef void (*btf_trace_svc_authenticate)(void *, const struct svc_rqst *, int, __be32); + +typedef void (*btf_trace_svc_process)(void *, const struct svc_rqst *, const char *); + +typedef void (*btf_trace_svc_defer)(void *, const struct svc_rqst *); + +typedef void (*btf_trace_svc_drop)(void *, const struct svc_rqst *); + +typedef void (*btf_trace_svc_send)(void *, struct svc_rqst *, int); + +typedef void (*btf_trace_svc_xprt_do_enqueue)(void *, struct svc_xprt *, struct svc_rqst *); + +typedef void (*btf_trace_svc_xprt_no_write_space)(void *, struct svc_xprt *); + +typedef void (*btf_trace_svc_xprt_dequeue)(void *, struct svc_rqst *); + +typedef void (*btf_trace_svc_wake_up)(void *, int); + +typedef void (*btf_trace_svc_handle_xprt)(void *, struct svc_xprt *, int); + +typedef void (*btf_trace_svc_stats_latency)(void *, const struct svc_rqst *); + +typedef void (*btf_trace_svc_drop_deferred)(void *, const struct svc_deferred_req *); + +typedef void (*btf_trace_svc_revisit_deferred)(void *, const struct svc_deferred_req *); + struct rpc_cred_cache { struct hlist_head *hashtable; unsigned int hashbits; @@ -110798,14 +115153,6 @@ enum { SVC_POOL_PERNODE = 2, }; -struct svc_pool_map { - int count; - int mode; - unsigned int npools; - unsigned int *pool_to; - unsigned int *to_pool; -}; - struct unix_domain { struct auth_domain h; }; @@ -111313,6 +115660,46 @@ struct trace_event_data_offsets_rpcgss_oid_to_mech { u32 oid; }; +typedef void (*btf_trace_rpcgss_import_ctx)(void *, int); + +typedef void (*btf_trace_rpcgss_get_mic)(void *, const struct rpc_task *, u32); + +typedef void (*btf_trace_rpcgss_verify_mic)(void *, const struct rpc_task *, u32); + +typedef void (*btf_trace_rpcgss_wrap)(void *, const struct rpc_task *, u32); + +typedef void (*btf_trace_rpcgss_unwrap)(void *, const struct rpc_task *, u32); + +typedef void (*btf_trace_rpcgss_accept_upcall)(void *, __be32, u32, u32); + +typedef void (*btf_trace_rpcgss_unwrap_failed)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpcgss_bad_seqno)(void *, const struct rpc_task *, u32, u32); + +typedef void (*btf_trace_rpcgss_seqno)(void *, const struct rpc_task *); + +typedef void (*btf_trace_rpcgss_need_reencode)(void *, const struct rpc_task *, u32, bool); + +typedef void (*btf_trace_rpcgss_upcall_msg)(void *, const char *); + +typedef void (*btf_trace_rpcgss_upcall_result)(void *, u32, int); + +typedef void (*btf_trace_rpcgss_context)(void *, long unsigned int, long unsigned int, unsigned int, unsigned int, const u8 *); + +typedef void (*btf_trace_rpcgss_createauth)(void *, unsigned int, int); + +typedef void (*btf_trace_rpcgss_oid_to_mech)(void *, const char *); + +struct strp_msg { + int full_len; + int offset; +}; + +struct _strp_msg { + struct strp_msg strp; + int accum_len; +}; + enum nl80211_commands { NL80211_CMD_UNSPEC = 0, NL80211_CMD_GET_WIPHY = 1, @@ -112079,6 +116466,8 @@ enum nl80211_preamble { NL80211_PREAMBLE_DMG = 3, }; +typedef int (*sk_read_actor_t___2)(read_descriptor_t *, struct sk_buff___2 *, unsigned int, size_t); + enum ieee80211_bss_type { IEEE80211_BSS_TYPE_ESS = 0, IEEE80211_BSS_TYPE_PBSS = 1, @@ -112131,7 +116520,7 @@ struct wireless_dev { struct wiphy *wiphy; enum nl80211_iftype iftype; struct list_head list; - struct net_device *netdev; + struct net_device___2 *netdev; u32 identifier; struct list_head mgmt_registrations; spinlock_t mgmt_registrations_lock; @@ -112556,7 +116945,7 @@ struct sta_txpwr { struct station_parameters { const u8 *supported_rates; - struct net_device *vlan; + struct net_device___2 *vlan; u32 sta_flags_mask; u32 sta_flags_set; u32 sta_modify_mask; @@ -112885,13 +117274,13 @@ struct wiphy { struct ieee80211_supported_band *bands[4]; void (*reg_notifier)(struct wiphy *, struct regulatory_request *); const struct ieee80211_regdomain *regd; - struct device dev; + struct device___2 dev; bool registered; - struct dentry *debugfsdir; + struct dentry___2 *debugfsdir; const struct ieee80211_ht_cap *ht_capa_mod_mask; const struct ieee80211_vht_cap *vht_capa_mod_mask; struct list_head wdev_list; - possible_net_t _net; + possible_net_t___2 _net; const struct wiphy_coalesce_support *coalesce; const struct wiphy_vendor_command *vendor_commands; const struct nl80211_vendor_cmd_info *vendor_events; @@ -112952,7 +117341,7 @@ struct cfg80211_sched_scan_request { s8 relative_rssi; struct cfg80211_bss_select_adjust rssi_adjust; struct wiphy *wiphy; - struct net_device *dev; + struct net_device___2 *dev; long unsigned int scan_start; bool report_results; struct callback_head callback_head; @@ -113325,110 +117714,110 @@ struct cfg80211_ops { void (*set_wakeup)(struct wiphy *, bool); struct wireless_dev * (*add_virtual_intf)(struct wiphy *, const char *, unsigned char, enum nl80211_iftype, struct vif_params *); int (*del_virtual_intf)(struct wiphy *, struct wireless_dev *); - int (*change_virtual_intf)(struct wiphy *, struct net_device *, enum nl80211_iftype, struct vif_params *); - int (*add_key)(struct wiphy *, struct net_device *, u8, bool, const u8 *, struct key_params *); - int (*get_key)(struct wiphy *, struct net_device *, u8, bool, const u8 *, void *, void (*)(void *, struct key_params *)); - int (*del_key)(struct wiphy *, struct net_device *, u8, bool, const u8 *); - int (*set_default_key)(struct wiphy *, struct net_device *, u8, bool, bool); - int (*set_default_mgmt_key)(struct wiphy *, struct net_device *, u8); - int (*start_ap)(struct wiphy *, struct net_device *, struct cfg80211_ap_settings *); - int (*change_beacon)(struct wiphy *, struct net_device *, struct cfg80211_beacon_data *); - int (*stop_ap)(struct wiphy *, struct net_device *); - int (*add_station)(struct wiphy *, struct net_device *, const u8 *, struct station_parameters *); - int (*del_station)(struct wiphy *, struct net_device *, struct station_del_parameters *); - int (*change_station)(struct wiphy *, struct net_device *, const u8 *, struct station_parameters *); - int (*get_station)(struct wiphy *, struct net_device *, const u8 *, struct station_info *); - int (*dump_station)(struct wiphy *, struct net_device *, int, u8 *, struct station_info *); - int (*add_mpath)(struct wiphy *, struct net_device *, const u8 *, const u8 *); - int (*del_mpath)(struct wiphy *, struct net_device *, const u8 *); - int (*change_mpath)(struct wiphy *, struct net_device *, const u8 *, const u8 *); - int (*get_mpath)(struct wiphy *, struct net_device *, u8 *, u8 *, struct mpath_info *); - int (*dump_mpath)(struct wiphy *, struct net_device *, int, u8 *, u8 *, struct mpath_info *); - int (*get_mpp)(struct wiphy *, struct net_device *, u8 *, u8 *, struct mpath_info *); - int (*dump_mpp)(struct wiphy *, struct net_device *, int, u8 *, u8 *, struct mpath_info *); - int (*get_mesh_config)(struct wiphy *, struct net_device *, struct mesh_config *); - int (*update_mesh_config)(struct wiphy *, struct net_device *, u32, const struct mesh_config *); - int (*join_mesh)(struct wiphy *, struct net_device *, const struct mesh_config *, const struct mesh_setup *); - int (*leave_mesh)(struct wiphy *, struct net_device *); - int (*join_ocb)(struct wiphy *, struct net_device *, struct ocb_setup *); - int (*leave_ocb)(struct wiphy *, struct net_device *); - int (*change_bss)(struct wiphy *, struct net_device *, struct bss_parameters *); - int (*set_txq_params)(struct wiphy *, struct net_device *, struct ieee80211_txq_params *); - int (*libertas_set_mesh_channel)(struct wiphy *, struct net_device *, struct ieee80211_channel *); + int (*change_virtual_intf)(struct wiphy *, struct net_device___2 *, enum nl80211_iftype, struct vif_params *); + int (*add_key)(struct wiphy *, struct net_device___2 *, u8, bool, const u8 *, struct key_params *); + int (*get_key)(struct wiphy *, struct net_device___2 *, u8, bool, const u8 *, void *, void (*)(void *, struct key_params *)); + int (*del_key)(struct wiphy *, struct net_device___2 *, u8, bool, const u8 *); + int (*set_default_key)(struct wiphy *, struct net_device___2 *, u8, bool, bool); + int (*set_default_mgmt_key)(struct wiphy *, struct net_device___2 *, u8); + int (*start_ap)(struct wiphy *, struct net_device___2 *, struct cfg80211_ap_settings *); + int (*change_beacon)(struct wiphy *, struct net_device___2 *, struct cfg80211_beacon_data *); + int (*stop_ap)(struct wiphy *, struct net_device___2 *); + int (*add_station)(struct wiphy *, struct net_device___2 *, const u8 *, struct station_parameters *); + int (*del_station)(struct wiphy *, struct net_device___2 *, struct station_del_parameters *); + int (*change_station)(struct wiphy *, struct net_device___2 *, const u8 *, struct station_parameters *); + int (*get_station)(struct wiphy *, struct net_device___2 *, const u8 *, struct station_info *); + int (*dump_station)(struct wiphy *, struct net_device___2 *, int, u8 *, struct station_info *); + int (*add_mpath)(struct wiphy *, struct net_device___2 *, const u8 *, const u8 *); + int (*del_mpath)(struct wiphy *, struct net_device___2 *, const u8 *); + int (*change_mpath)(struct wiphy *, struct net_device___2 *, const u8 *, const u8 *); + int (*get_mpath)(struct wiphy *, struct net_device___2 *, u8 *, u8 *, struct mpath_info *); + int (*dump_mpath)(struct wiphy *, struct net_device___2 *, int, u8 *, u8 *, struct mpath_info *); + int (*get_mpp)(struct wiphy *, struct net_device___2 *, u8 *, u8 *, struct mpath_info *); + int (*dump_mpp)(struct wiphy *, struct net_device___2 *, int, u8 *, u8 *, struct mpath_info *); + int (*get_mesh_config)(struct wiphy *, struct net_device___2 *, struct mesh_config *); + int (*update_mesh_config)(struct wiphy *, struct net_device___2 *, u32, const struct mesh_config *); + int (*join_mesh)(struct wiphy *, struct net_device___2 *, const struct mesh_config *, const struct mesh_setup *); + int (*leave_mesh)(struct wiphy *, struct net_device___2 *); + int (*join_ocb)(struct wiphy *, struct net_device___2 *, struct ocb_setup *); + int (*leave_ocb)(struct wiphy *, struct net_device___2 *); + int (*change_bss)(struct wiphy *, struct net_device___2 *, struct bss_parameters *); + int (*set_txq_params)(struct wiphy *, struct net_device___2 *, struct ieee80211_txq_params *); + int (*libertas_set_mesh_channel)(struct wiphy *, struct net_device___2 *, struct ieee80211_channel *); int (*set_monitor_channel)(struct wiphy *, struct cfg80211_chan_def *); int (*scan)(struct wiphy *, struct cfg80211_scan_request *); void (*abort_scan)(struct wiphy *, struct wireless_dev *); - int (*auth)(struct wiphy *, struct net_device *, struct cfg80211_auth_request *); - int (*assoc)(struct wiphy *, struct net_device *, struct cfg80211_assoc_request *); - int (*deauth)(struct wiphy *, struct net_device *, struct cfg80211_deauth_request *); - int (*disassoc)(struct wiphy *, struct net_device *, struct cfg80211_disassoc_request *); - int (*connect)(struct wiphy *, struct net_device *, struct cfg80211_connect_params *); - int (*update_connect_params)(struct wiphy *, struct net_device *, struct cfg80211_connect_params *, u32); - int (*disconnect)(struct wiphy *, struct net_device *, u16); - int (*join_ibss)(struct wiphy *, struct net_device *, struct cfg80211_ibss_params *); - int (*leave_ibss)(struct wiphy *, struct net_device *); - int (*set_mcast_rate)(struct wiphy *, struct net_device *, int *); + int (*auth)(struct wiphy *, struct net_device___2 *, struct cfg80211_auth_request *); + int (*assoc)(struct wiphy *, struct net_device___2 *, struct cfg80211_assoc_request *); + int (*deauth)(struct wiphy *, struct net_device___2 *, struct cfg80211_deauth_request *); + int (*disassoc)(struct wiphy *, struct net_device___2 *, struct cfg80211_disassoc_request *); + int (*connect)(struct wiphy *, struct net_device___2 *, struct cfg80211_connect_params *); + int (*update_connect_params)(struct wiphy *, struct net_device___2 *, struct cfg80211_connect_params *, u32); + int (*disconnect)(struct wiphy *, struct net_device___2 *, u16); + int (*join_ibss)(struct wiphy *, struct net_device___2 *, struct cfg80211_ibss_params *); + int (*leave_ibss)(struct wiphy *, struct net_device___2 *); + int (*set_mcast_rate)(struct wiphy *, struct net_device___2 *, int *); int (*set_wiphy_params)(struct wiphy *, u32); int (*set_tx_power)(struct wiphy *, struct wireless_dev *, enum nl80211_tx_power_setting, int); int (*get_tx_power)(struct wiphy *, struct wireless_dev *, int *); - int (*set_wds_peer)(struct wiphy *, struct net_device *, const u8 *); + int (*set_wds_peer)(struct wiphy *, struct net_device___2 *, const u8 *); void (*rfkill_poll)(struct wiphy *); - int (*set_bitrate_mask)(struct wiphy *, struct net_device *, const u8 *, const struct cfg80211_bitrate_mask *); - int (*dump_survey)(struct wiphy *, struct net_device *, int, struct survey_info *); - int (*set_pmksa)(struct wiphy *, struct net_device *, struct cfg80211_pmksa *); - int (*del_pmksa)(struct wiphy *, struct net_device *, struct cfg80211_pmksa *); - int (*flush_pmksa)(struct wiphy *, struct net_device *); + int (*set_bitrate_mask)(struct wiphy *, struct net_device___2 *, const u8 *, const struct cfg80211_bitrate_mask *); + int (*dump_survey)(struct wiphy *, struct net_device___2 *, int, struct survey_info *); + int (*set_pmksa)(struct wiphy *, struct net_device___2 *, struct cfg80211_pmksa *); + int (*del_pmksa)(struct wiphy *, struct net_device___2 *, struct cfg80211_pmksa *); + int (*flush_pmksa)(struct wiphy *, struct net_device___2 *); int (*remain_on_channel)(struct wiphy *, struct wireless_dev *, struct ieee80211_channel *, unsigned int, u64 *); int (*cancel_remain_on_channel)(struct wiphy *, struct wireless_dev *, u64); int (*mgmt_tx)(struct wiphy *, struct wireless_dev *, struct cfg80211_mgmt_tx_params *, u64 *); int (*mgmt_tx_cancel_wait)(struct wiphy *, struct wireless_dev *, u64); - int (*set_power_mgmt)(struct wiphy *, struct net_device *, bool, int); - int (*set_cqm_rssi_config)(struct wiphy *, struct net_device *, s32, u32); - int (*set_cqm_rssi_range_config)(struct wiphy *, struct net_device *, s32, s32); - int (*set_cqm_txe_config)(struct wiphy *, struct net_device *, u32, u32, u32); + int (*set_power_mgmt)(struct wiphy *, struct net_device___2 *, bool, int); + int (*set_cqm_rssi_config)(struct wiphy *, struct net_device___2 *, s32, u32); + int (*set_cqm_rssi_range_config)(struct wiphy *, struct net_device___2 *, s32, s32); + int (*set_cqm_txe_config)(struct wiphy *, struct net_device___2 *, u32, u32, u32); void (*mgmt_frame_register)(struct wiphy *, struct wireless_dev *, u16, bool); int (*set_antenna)(struct wiphy *, u32, u32); int (*get_antenna)(struct wiphy *, u32 *, u32 *); - int (*sched_scan_start)(struct wiphy *, struct net_device *, struct cfg80211_sched_scan_request *); - int (*sched_scan_stop)(struct wiphy *, struct net_device *, u64); - int (*set_rekey_data)(struct wiphy *, struct net_device *, struct cfg80211_gtk_rekey_data *); - int (*tdls_mgmt)(struct wiphy *, struct net_device *, const u8 *, u8, u8, u16, u32, bool, const u8 *, size_t); - int (*tdls_oper)(struct wiphy *, struct net_device *, const u8 *, enum nl80211_tdls_operation); - int (*probe_client)(struct wiphy *, struct net_device *, const u8 *, u64 *); - int (*set_noack_map)(struct wiphy *, struct net_device *, u16); + int (*sched_scan_start)(struct wiphy *, struct net_device___2 *, struct cfg80211_sched_scan_request *); + int (*sched_scan_stop)(struct wiphy *, struct net_device___2 *, u64); + int (*set_rekey_data)(struct wiphy *, struct net_device___2 *, struct cfg80211_gtk_rekey_data *); + int (*tdls_mgmt)(struct wiphy *, struct net_device___2 *, const u8 *, u8, u8, u16, u32, bool, const u8 *, size_t); + int (*tdls_oper)(struct wiphy *, struct net_device___2 *, const u8 *, enum nl80211_tdls_operation); + int (*probe_client)(struct wiphy *, struct net_device___2 *, const u8 *, u64 *); + int (*set_noack_map)(struct wiphy *, struct net_device___2 *, u16); int (*get_channel)(struct wiphy *, struct wireless_dev *, struct cfg80211_chan_def *); int (*start_p2p_device)(struct wiphy *, struct wireless_dev *); void (*stop_p2p_device)(struct wiphy *, struct wireless_dev *); - int (*set_mac_acl)(struct wiphy *, struct net_device *, const struct cfg80211_acl_data *); - int (*start_radar_detection)(struct wiphy *, struct net_device *, struct cfg80211_chan_def *, u32); - void (*end_cac)(struct wiphy *, struct net_device *); - int (*update_ft_ies)(struct wiphy *, struct net_device *, struct cfg80211_update_ft_ies_params *); + int (*set_mac_acl)(struct wiphy *, struct net_device___2 *, const struct cfg80211_acl_data *); + int (*start_radar_detection)(struct wiphy *, struct net_device___2 *, struct cfg80211_chan_def *, u32); + void (*end_cac)(struct wiphy *, struct net_device___2 *); + int (*update_ft_ies)(struct wiphy *, struct net_device___2 *, struct cfg80211_update_ft_ies_params *); int (*crit_proto_start)(struct wiphy *, struct wireless_dev *, enum nl80211_crit_proto_id, u16); void (*crit_proto_stop)(struct wiphy *, struct wireless_dev *); int (*set_coalesce)(struct wiphy *, struct cfg80211_coalesce *); - int (*channel_switch)(struct wiphy *, struct net_device *, struct cfg80211_csa_settings *); - int (*set_qos_map)(struct wiphy *, struct net_device *, struct cfg80211_qos_map *); - int (*set_ap_chanwidth)(struct wiphy *, struct net_device *, struct cfg80211_chan_def *); - int (*add_tx_ts)(struct wiphy *, struct net_device *, u8, const u8 *, u8, u16); - int (*del_tx_ts)(struct wiphy *, struct net_device *, u8, const u8 *); - int (*tdls_channel_switch)(struct wiphy *, struct net_device *, const u8 *, u8, struct cfg80211_chan_def *); - void (*tdls_cancel_channel_switch)(struct wiphy *, struct net_device *, const u8 *); + int (*channel_switch)(struct wiphy *, struct net_device___2 *, struct cfg80211_csa_settings *); + int (*set_qos_map)(struct wiphy *, struct net_device___2 *, struct cfg80211_qos_map *); + int (*set_ap_chanwidth)(struct wiphy *, struct net_device___2 *, struct cfg80211_chan_def *); + int (*add_tx_ts)(struct wiphy *, struct net_device___2 *, u8, const u8 *, u8, u16); + int (*del_tx_ts)(struct wiphy *, struct net_device___2 *, u8, const u8 *); + int (*tdls_channel_switch)(struct wiphy *, struct net_device___2 *, const u8 *, u8, struct cfg80211_chan_def *); + void (*tdls_cancel_channel_switch)(struct wiphy *, struct net_device___2 *, const u8 *); int (*start_nan)(struct wiphy *, struct wireless_dev *, struct cfg80211_nan_conf *); void (*stop_nan)(struct wiphy *, struct wireless_dev *); int (*add_nan_func)(struct wiphy *, struct wireless_dev *, struct cfg80211_nan_func *); void (*del_nan_func)(struct wiphy *, struct wireless_dev *, u64); int (*nan_change_conf)(struct wiphy *, struct wireless_dev *, struct cfg80211_nan_conf *, u32); - int (*set_multicast_to_unicast)(struct wiphy *, struct net_device *, const bool); + int (*set_multicast_to_unicast)(struct wiphy *, struct net_device___2 *, const bool); int (*get_txq_stats)(struct wiphy *, struct wireless_dev *, struct cfg80211_txq_stats *); - int (*set_pmk)(struct wiphy *, struct net_device *, const struct cfg80211_pmk_conf *); - int (*del_pmk)(struct wiphy *, struct net_device *, const u8 *); - int (*external_auth)(struct wiphy *, struct net_device *, struct cfg80211_external_auth_params *); - int (*tx_control_port)(struct wiphy *, struct net_device *, const u8 *, size_t, const u8 *, const __be16, const bool); - int (*get_ftm_responder_stats)(struct wiphy *, struct net_device *, struct cfg80211_ftm_responder_stats *); + int (*set_pmk)(struct wiphy *, struct net_device___2 *, const struct cfg80211_pmk_conf *); + int (*del_pmk)(struct wiphy *, struct net_device___2 *, const u8 *); + int (*external_auth)(struct wiphy *, struct net_device___2 *, struct cfg80211_external_auth_params *); + int (*tx_control_port)(struct wiphy *, struct net_device___2 *, const u8 *, size_t, const u8 *, const __be16, const bool); + int (*get_ftm_responder_stats)(struct wiphy *, struct net_device___2 *, struct cfg80211_ftm_responder_stats *); int (*start_pmsr)(struct wiphy *, struct wireless_dev *, struct cfg80211_pmsr_request *); void (*abort_pmsr)(struct wiphy *, struct wireless_dev *, struct cfg80211_pmsr_request *); - int (*update_owe_info)(struct wiphy *, struct net_device *, struct cfg80211_update_owe_info *); - int (*probe_mesh_link)(struct wiphy *, struct net_device *, const u8 *, size_t); + int (*update_owe_info)(struct wiphy *, struct net_device___2 *, struct cfg80211_update_owe_info *); + int (*probe_mesh_link)(struct wiphy *, struct net_device___2 *, const u8 *, size_t); }; enum wiphy_flags { @@ -113517,7 +117906,7 @@ struct wiphy_vendor_command { struct nl80211_vendor_cmd_info info; u32 flags; int (*doit)(struct wiphy *, struct wireless_dev *, const void *, int); - int (*dumpit)(struct wiphy *, struct wireless_dev *, struct sk_buff *, const void *, int, long unsigned int *); + int (*dumpit)(struct wiphy *, struct wireless_dev *, struct sk_buff___2 *, const void *, int, long unsigned int *); const struct nla_policy *policy; unsigned int maxattr; }; @@ -113633,7 +118022,7 @@ struct cfg80211_registered_device { u32 bss_generation; u32 bss_entries; struct cfg80211_scan_request *scan_req; - struct sk_buff *scan_msg; + struct sk_buff___2 *scan_msg; struct list_head sched_scan_req_list; time64_t suspend_at; struct work_struct scan_done_wk; @@ -113690,6 +118079,86 @@ struct cfg80211_beacon_registration { u32 nlportid; }; +struct iw_param { + __s32 value; + __u8 fixed; + __u8 disabled; + __u16 flags; +}; + +struct iw_point { + void *pointer; + __u16 length; + __u16 flags; +}; + +struct iw_freq { + __s32 m; + __s16 e; + __u8 i; + __u8 flags; +}; + +struct iw_quality { + __u8 qual; + __u8 level; + __u8 noise; + __u8 updated; +}; + +struct iw_discarded { + __u32 nwid; + __u32 code; + __u32 fragment; + __u32 retries; + __u32 misc; +}; + +struct iw_missed { + __u32 beacon; +}; + +struct iw_statistics { + __u16 status; + struct iw_quality qual; + struct iw_discarded discard; + struct iw_missed miss; +}; + +union iwreq_data { + char name[16]; + struct iw_point essid; + struct iw_param nwid; + struct iw_freq freq; + struct iw_param sens; + struct iw_param bitrate; + struct iw_param txpower; + struct iw_param rts; + struct iw_param frag; + __u32 mode; + struct iw_param retry; + struct iw_point encoding; + struct iw_param power; + struct iw_quality qual; + struct sockaddr ap_addr; + struct sockaddr addr; + struct iw_param param; + struct iw_point data; +}; + +struct iw_request_info { + __u16 cmd; + __u16 flags; +}; + +typedef int (*iw_handler)(struct net_device___2 *, struct iw_request_info *, union iwreq_data *, char *); + +struct iw_handler_def { + const iw_handler *standard; + __u16 num_standard; + struct iw_statistics * (*get_wireless_stats)(struct net_device___2 *); +}; + struct radiotap_align_size { uint8_t align: 4; uint8_t size: 4; @@ -114184,6 +118653,12 @@ struct fwdb_country { __be16 coll_ptr; }; +struct fwdb_header { + __be32 magic; + __be32 version; + struct fwdb_country country[0]; +}; + struct fwdb_collection { u8 len; u8 n_rules; @@ -114221,12 +118696,6 @@ struct fwdb_rule { __be16 wmm_ptr; }; -struct fwdb_header { - __be32 magic; - __be32 version; - struct fwdb_country country[0]; -}; - enum nl80211_scan_flags { NL80211_SCAN_FLAG_LOW_PRIORITY = 1, NL80211_SCAN_FLAG_FLUSH = 2, @@ -117308,7 +121777,343 @@ struct trace_event_data_offsets_cfg80211_update_owe_info_event { struct trace_event_data_offsets_rdev_probe_mesh_link {}; -typedef int (*sk_read_actor_t___2)(read_descriptor_t *, struct sk_buff___2 *, unsigned int, size_t); +typedef void (*btf_trace_rdev_suspend)(void *, struct wiphy *, struct cfg80211_wowlan *); + +typedef void (*btf_trace_rdev_return_int)(void *, struct wiphy *, int); + +typedef void (*btf_trace_rdev_scan)(void *, struct wiphy *, struct cfg80211_scan_request *); + +typedef void (*btf_trace_rdev_resume)(void *, struct wiphy *); + +typedef void (*btf_trace_rdev_return_void)(void *, struct wiphy *); + +typedef void (*btf_trace_rdev_get_antenna)(void *, struct wiphy *); + +typedef void (*btf_trace_rdev_rfkill_poll)(void *, struct wiphy *); + +typedef void (*btf_trace_rdev_set_wakeup)(void *, struct wiphy *, bool); + +typedef void (*btf_trace_rdev_add_virtual_intf)(void *, struct wiphy *, char *, enum nl80211_iftype); + +typedef void (*btf_trace_rdev_return_wdev)(void *, struct wiphy *, struct wireless_dev *); + +typedef void (*btf_trace_rdev_del_virtual_intf)(void *, struct wiphy *, struct wireless_dev *); + +typedef void (*btf_trace_rdev_change_virtual_intf)(void *, struct wiphy *, struct net_device___2 *, enum nl80211_iftype); + +typedef void (*btf_trace_rdev_get_key)(void *, struct wiphy *, struct net_device___2 *, u8, bool, const u8 *); + +typedef void (*btf_trace_rdev_del_key)(void *, struct wiphy *, struct net_device___2 *, u8, bool, const u8 *); + +typedef void (*btf_trace_rdev_add_key)(void *, struct wiphy *, struct net_device___2 *, u8, bool, const u8 *, u8); + +typedef void (*btf_trace_rdev_set_default_key)(void *, struct wiphy *, struct net_device___2 *, u8, bool, bool); + +typedef void (*btf_trace_rdev_set_default_mgmt_key)(void *, struct wiphy *, struct net_device___2 *, u8); + +typedef void (*btf_trace_rdev_start_ap)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_ap_settings *); + +typedef void (*btf_trace_rdev_change_beacon)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_beacon_data *); + +typedef void (*btf_trace_rdev_stop_ap)(void *, struct wiphy *, struct net_device___2 *); + +typedef void (*btf_trace_rdev_set_rekey_data)(void *, struct wiphy *, struct net_device___2 *); + +typedef void (*btf_trace_rdev_get_mesh_config)(void *, struct wiphy *, struct net_device___2 *); + +typedef void (*btf_trace_rdev_leave_mesh)(void *, struct wiphy *, struct net_device___2 *); + +typedef void (*btf_trace_rdev_leave_ibss)(void *, struct wiphy *, struct net_device___2 *); + +typedef void (*btf_trace_rdev_leave_ocb)(void *, struct wiphy *, struct net_device___2 *); + +typedef void (*btf_trace_rdev_flush_pmksa)(void *, struct wiphy *, struct net_device___2 *); + +typedef void (*btf_trace_rdev_end_cac)(void *, struct wiphy *, struct net_device___2 *); + +typedef void (*btf_trace_rdev_add_station)(void *, struct wiphy *, struct net_device___2 *, u8 *, struct station_parameters *); + +typedef void (*btf_trace_rdev_change_station)(void *, struct wiphy *, struct net_device___2 *, u8 *, struct station_parameters *); + +typedef void (*btf_trace_rdev_del_station)(void *, struct wiphy *, struct net_device___2 *, struct station_del_parameters *); + +typedef void (*btf_trace_rdev_get_station)(void *, struct wiphy *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_rdev_del_mpath)(void *, struct wiphy *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_rdev_set_wds_peer)(void *, struct wiphy *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_rdev_dump_station)(void *, struct wiphy *, struct net_device___2 *, int, u8 *); + +typedef void (*btf_trace_rdev_return_int_station_info)(void *, struct wiphy *, int, struct station_info *); + +typedef void (*btf_trace_rdev_add_mpath)(void *, struct wiphy *, struct net_device___2 *, u8 *, u8 *); + +typedef void (*btf_trace_rdev_change_mpath)(void *, struct wiphy *, struct net_device___2 *, u8 *, u8 *); + +typedef void (*btf_trace_rdev_get_mpath)(void *, struct wiphy *, struct net_device___2 *, u8 *, u8 *); + +typedef void (*btf_trace_rdev_dump_mpath)(void *, struct wiphy *, struct net_device___2 *, int, u8 *, u8 *); + +typedef void (*btf_trace_rdev_get_mpp)(void *, struct wiphy *, struct net_device___2 *, u8 *, u8 *); + +typedef void (*btf_trace_rdev_dump_mpp)(void *, struct wiphy *, struct net_device___2 *, int, u8 *, u8 *); + +typedef void (*btf_trace_rdev_return_int_mpath_info)(void *, struct wiphy *, int, struct mpath_info *); + +typedef void (*btf_trace_rdev_return_int_mesh_config)(void *, struct wiphy *, int, struct mesh_config *); + +typedef void (*btf_trace_rdev_update_mesh_config)(void *, struct wiphy *, struct net_device___2 *, u32, const struct mesh_config *); + +typedef void (*btf_trace_rdev_join_mesh)(void *, struct wiphy *, struct net_device___2 *, const struct mesh_config *, const struct mesh_setup *); + +typedef void (*btf_trace_rdev_change_bss)(void *, struct wiphy *, struct net_device___2 *, struct bss_parameters *); + +typedef void (*btf_trace_rdev_set_txq_params)(void *, struct wiphy *, struct net_device___2 *, struct ieee80211_txq_params *); + +typedef void (*btf_trace_rdev_libertas_set_mesh_channel)(void *, struct wiphy *, struct net_device___2 *, struct ieee80211_channel *); + +typedef void (*btf_trace_rdev_set_monitor_channel)(void *, struct wiphy *, struct cfg80211_chan_def *); + +typedef void (*btf_trace_rdev_auth)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_auth_request *); + +typedef void (*btf_trace_rdev_assoc)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_assoc_request *); + +typedef void (*btf_trace_rdev_deauth)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_deauth_request *); + +typedef void (*btf_trace_rdev_disassoc)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_disassoc_request *); + +typedef void (*btf_trace_rdev_mgmt_tx_cancel_wait)(void *, struct wiphy *, struct wireless_dev *, u64); + +typedef void (*btf_trace_rdev_set_power_mgmt)(void *, struct wiphy *, struct net_device___2 *, bool, int); + +typedef void (*btf_trace_rdev_connect)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_connect_params *); + +typedef void (*btf_trace_rdev_update_connect_params)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_connect_params *, u32); + +typedef void (*btf_trace_rdev_set_cqm_rssi_config)(void *, struct wiphy *, struct net_device___2 *, s32, u32); + +typedef void (*btf_trace_rdev_set_cqm_rssi_range_config)(void *, struct wiphy *, struct net_device___2 *, s32, s32); + +typedef void (*btf_trace_rdev_set_cqm_txe_config)(void *, struct wiphy *, struct net_device___2 *, u32, u32, u32); + +typedef void (*btf_trace_rdev_disconnect)(void *, struct wiphy *, struct net_device___2 *, u16); + +typedef void (*btf_trace_rdev_join_ibss)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_ibss_params *); + +typedef void (*btf_trace_rdev_join_ocb)(void *, struct wiphy *, struct net_device___2 *, const struct ocb_setup *); + +typedef void (*btf_trace_rdev_set_wiphy_params)(void *, struct wiphy *, u32); + +typedef void (*btf_trace_rdev_get_tx_power)(void *, struct wiphy *, struct wireless_dev *); + +typedef void (*btf_trace_rdev_set_tx_power)(void *, struct wiphy *, struct wireless_dev *, enum nl80211_tx_power_setting, int); + +typedef void (*btf_trace_rdev_return_int_int)(void *, struct wiphy *, int, int); + +typedef void (*btf_trace_rdev_set_bitrate_mask)(void *, struct wiphy *, struct net_device___2 *, const u8 *, const struct cfg80211_bitrate_mask *); + +typedef void (*btf_trace_rdev_mgmt_frame_register)(void *, struct wiphy *, struct wireless_dev *, u16, bool); + +typedef void (*btf_trace_rdev_return_int_tx_rx)(void *, struct wiphy *, int, u32, u32); + +typedef void (*btf_trace_rdev_return_void_tx_rx)(void *, struct wiphy *, u32, u32, u32, u32); + +typedef void (*btf_trace_rdev_set_antenna)(void *, struct wiphy *, u32, u32); + +typedef void (*btf_trace_rdev_sched_scan_start)(void *, struct wiphy *, struct net_device___2 *, u64); + +typedef void (*btf_trace_rdev_sched_scan_stop)(void *, struct wiphy *, struct net_device___2 *, u64); + +typedef void (*btf_trace_rdev_tdls_mgmt)(void *, struct wiphy *, struct net_device___2 *, u8 *, u8, u8, u16, u32, bool, const u8 *, size_t); + +typedef void (*btf_trace_rdev_dump_survey)(void *, struct wiphy *, struct net_device___2 *, int); + +typedef void (*btf_trace_rdev_return_int_survey_info)(void *, struct wiphy *, int, struct survey_info *); + +typedef void (*btf_trace_rdev_tdls_oper)(void *, struct wiphy *, struct net_device___2 *, u8 *, enum nl80211_tdls_operation); + +typedef void (*btf_trace_rdev_probe_client)(void *, struct wiphy *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_rdev_set_pmksa)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_pmksa *); + +typedef void (*btf_trace_rdev_del_pmksa)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_pmksa *); + +typedef void (*btf_trace_rdev_remain_on_channel)(void *, struct wiphy *, struct wireless_dev *, struct ieee80211_channel *, unsigned int); + +typedef void (*btf_trace_rdev_return_int_cookie)(void *, struct wiphy *, int, u64); + +typedef void (*btf_trace_rdev_cancel_remain_on_channel)(void *, struct wiphy *, struct wireless_dev *, u64); + +typedef void (*btf_trace_rdev_mgmt_tx)(void *, struct wiphy *, struct wireless_dev *, struct cfg80211_mgmt_tx_params *); + +typedef void (*btf_trace_rdev_tx_control_port)(void *, struct wiphy *, struct net_device___2 *, const u8 *, size_t, const u8 *, __be16, bool); + +typedef void (*btf_trace_rdev_set_noack_map)(void *, struct wiphy *, struct net_device___2 *, u16); + +typedef void (*btf_trace_rdev_get_channel)(void *, struct wiphy *, struct wireless_dev *); + +typedef void (*btf_trace_rdev_return_chandef)(void *, struct wiphy *, int, struct cfg80211_chan_def *); + +typedef void (*btf_trace_rdev_start_p2p_device)(void *, struct wiphy *, struct wireless_dev *); + +typedef void (*btf_trace_rdev_stop_p2p_device)(void *, struct wiphy *, struct wireless_dev *); + +typedef void (*btf_trace_rdev_start_nan)(void *, struct wiphy *, struct wireless_dev *, struct cfg80211_nan_conf *); + +typedef void (*btf_trace_rdev_nan_change_conf)(void *, struct wiphy *, struct wireless_dev *, struct cfg80211_nan_conf *, u32); + +typedef void (*btf_trace_rdev_stop_nan)(void *, struct wiphy *, struct wireless_dev *); + +typedef void (*btf_trace_rdev_add_nan_func)(void *, struct wiphy *, struct wireless_dev *, const struct cfg80211_nan_func *); + +typedef void (*btf_trace_rdev_del_nan_func)(void *, struct wiphy *, struct wireless_dev *, u64); + +typedef void (*btf_trace_rdev_set_mac_acl)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_acl_data *); + +typedef void (*btf_trace_rdev_update_ft_ies)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_update_ft_ies_params *); + +typedef void (*btf_trace_rdev_crit_proto_start)(void *, struct wiphy *, struct wireless_dev *, enum nl80211_crit_proto_id, u16); + +typedef void (*btf_trace_rdev_crit_proto_stop)(void *, struct wiphy *, struct wireless_dev *); + +typedef void (*btf_trace_rdev_channel_switch)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_csa_settings *); + +typedef void (*btf_trace_rdev_set_qos_map)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_qos_map *); + +typedef void (*btf_trace_rdev_set_ap_chanwidth)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_chan_def *); + +typedef void (*btf_trace_rdev_add_tx_ts)(void *, struct wiphy *, struct net_device___2 *, u8, const u8 *, u8, u16); + +typedef void (*btf_trace_rdev_del_tx_ts)(void *, struct wiphy *, struct net_device___2 *, u8, const u8 *); + +typedef void (*btf_trace_rdev_tdls_channel_switch)(void *, struct wiphy *, struct net_device___2 *, const u8 *, u8, struct cfg80211_chan_def *); + +typedef void (*btf_trace_rdev_tdls_cancel_channel_switch)(void *, struct wiphy *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_rdev_set_pmk)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_pmk_conf *); + +typedef void (*btf_trace_rdev_del_pmk)(void *, struct wiphy *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_rdev_external_auth)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_external_auth_params *); + +typedef void (*btf_trace_rdev_start_radar_detection)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_chan_def *, u32); + +typedef void (*btf_trace_rdev_set_mcast_rate)(void *, struct wiphy *, struct net_device___2 *, int *); + +typedef void (*btf_trace_rdev_set_coalesce)(void *, struct wiphy *, struct cfg80211_coalesce *); + +typedef void (*btf_trace_rdev_abort_scan)(void *, struct wiphy *, struct wireless_dev *); + +typedef void (*btf_trace_rdev_set_multicast_to_unicast)(void *, struct wiphy *, struct net_device___2 *, const bool); + +typedef void (*btf_trace_rdev_get_txq_stats)(void *, struct wiphy *, struct wireless_dev *); + +typedef void (*btf_trace_rdev_get_ftm_responder_stats)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_ftm_responder_stats *); + +typedef void (*btf_trace_rdev_start_pmsr)(void *, struct wiphy *, struct wireless_dev *, u64); + +typedef void (*btf_trace_rdev_abort_pmsr)(void *, struct wiphy *, struct wireless_dev *, u64); + +typedef void (*btf_trace_cfg80211_return_bool)(void *, bool); + +typedef void (*btf_trace_cfg80211_notify_new_peer_candidate)(void *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_cfg80211_send_rx_auth)(void *, struct net_device___2 *); + +typedef void (*btf_trace_cfg80211_send_rx_assoc)(void *, struct net_device___2 *, struct cfg80211_bss *); + +typedef void (*btf_trace_cfg80211_rx_unprot_mlme_mgmt)(void *, struct net_device___2 *, const u8 *, int); + +typedef void (*btf_trace_cfg80211_rx_mlme_mgmt)(void *, struct net_device___2 *, const u8 *, int); + +typedef void (*btf_trace_cfg80211_tx_mlme_mgmt)(void *, struct net_device___2 *, const u8 *, int); + +typedef void (*btf_trace_cfg80211_send_auth_timeout)(void *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_cfg80211_send_assoc_timeout)(void *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_cfg80211_michael_mic_failure)(void *, struct net_device___2 *, const u8 *, enum nl80211_key_type, int, const u8 *); + +typedef void (*btf_trace_cfg80211_ready_on_channel)(void *, struct wireless_dev *, u64, struct ieee80211_channel *, unsigned int); + +typedef void (*btf_trace_cfg80211_ready_on_channel_expired)(void *, struct wireless_dev *, u64, struct ieee80211_channel *); + +typedef void (*btf_trace_cfg80211_tx_mgmt_expired)(void *, struct wireless_dev *, u64, struct ieee80211_channel *); + +typedef void (*btf_trace_cfg80211_new_sta)(void *, struct net_device___2 *, const u8 *, struct station_info *); + +typedef void (*btf_trace_cfg80211_del_sta)(void *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_cfg80211_rx_mgmt)(void *, struct wireless_dev *, int, int); + +typedef void (*btf_trace_cfg80211_mgmt_tx_status)(void *, struct wireless_dev *, u64, bool); + +typedef void (*btf_trace_cfg80211_rx_control_port)(void *, struct net_device___2 *, struct sk_buff___2 *, bool); + +typedef void (*btf_trace_cfg80211_cqm_rssi_notify)(void *, struct net_device___2 *, enum nl80211_cqm_rssi_threshold_event, s32); + +typedef void (*btf_trace_cfg80211_reg_can_beacon)(void *, struct wiphy *, struct cfg80211_chan_def *, enum nl80211_iftype, bool); + +typedef void (*btf_trace_cfg80211_chandef_dfs_required)(void *, struct wiphy *, struct cfg80211_chan_def *); + +typedef void (*btf_trace_cfg80211_ch_switch_notify)(void *, struct net_device___2 *, struct cfg80211_chan_def *); + +typedef void (*btf_trace_cfg80211_ch_switch_started_notify)(void *, struct net_device___2 *, struct cfg80211_chan_def *); + +typedef void (*btf_trace_cfg80211_radar_event)(void *, struct wiphy *, struct cfg80211_chan_def *); + +typedef void (*btf_trace_cfg80211_cac_event)(void *, struct net_device___2 *, enum nl80211_radar_event); + +typedef void (*btf_trace_cfg80211_rx_spurious_frame)(void *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_cfg80211_rx_unexpected_4addr_frame)(void *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_cfg80211_ibss_joined)(void *, struct net_device___2 *, const u8 *, struct ieee80211_channel *); + +typedef void (*btf_trace_cfg80211_probe_status)(void *, struct net_device___2 *, const u8 *, u64, bool); + +typedef void (*btf_trace_cfg80211_cqm_pktloss_notify)(void *, struct net_device___2 *, const u8 *, u32); + +typedef void (*btf_trace_cfg80211_gtk_rekey_notify)(void *, struct net_device___2 *, const u8 *); + +typedef void (*btf_trace_cfg80211_pmksa_candidate_notify)(void *, struct net_device___2 *, int, const u8 *, bool); + +typedef void (*btf_trace_cfg80211_report_obss_beacon)(void *, struct wiphy *, const u8 *, size_t, int, int); + +typedef void (*btf_trace_cfg80211_tdls_oper_request)(void *, struct wiphy *, struct net_device___2 *, const u8 *, enum nl80211_tdls_operation, u16); + +typedef void (*btf_trace_cfg80211_scan_done)(void *, struct cfg80211_scan_request *, struct cfg80211_scan_info *); + +typedef void (*btf_trace_cfg80211_sched_scan_stopped)(void *, struct wiphy *, u64); + +typedef void (*btf_trace_cfg80211_sched_scan_results)(void *, struct wiphy *, u64); + +typedef void (*btf_trace_cfg80211_get_bss)(void *, struct wiphy *, struct ieee80211_channel *, const u8 *, const u8 *, size_t, enum ieee80211_bss_type, enum ieee80211_privacy); + +typedef void (*btf_trace_cfg80211_inform_bss_frame)(void *, struct wiphy *, struct cfg80211_inform_bss *, struct ieee80211_mgmt *, size_t); + +typedef void (*btf_trace_cfg80211_return_bss)(void *, struct cfg80211_bss *); + +typedef void (*btf_trace_cfg80211_return_uint)(void *, unsigned int); + +typedef void (*btf_trace_cfg80211_return_u32)(void *, u32); + +typedef void (*btf_trace_cfg80211_report_wowlan_wakeup)(void *, struct wiphy *, struct wireless_dev *, struct cfg80211_wowlan_wakeup *); + +typedef void (*btf_trace_cfg80211_ft_event)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_ft_event_params *); + +typedef void (*btf_trace_cfg80211_stop_iface)(void *, struct wiphy *, struct wireless_dev *); + +typedef void (*btf_trace_cfg80211_pmsr_report)(void *, struct wiphy *, struct wireless_dev *, u64, const u8 *); + +typedef void (*btf_trace_cfg80211_pmsr_complete)(void *, struct wiphy *, struct wireless_dev *, u64); + +typedef void (*btf_trace_rdev_update_owe_info)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_update_owe_info *); + +typedef void (*btf_trace_cfg80211_update_owe_info_event)(void *, struct wiphy *, struct net_device___2 *, struct cfg80211_update_owe_info *); + +typedef void (*btf_trace_rdev_probe_mesh_link)(void *, struct wiphy *, struct net_device___2 *, const u8 *, const u8 *, size_t); enum nl80211_peer_measurement_status { NL80211_PMSR_STATUS_SUCCESS = 0, @@ -119430,8 +124235,6 @@ enum { SCAN_HW_CANCELLED = 5, }; -typedef struct bio_vec___2 skb_frag_t___2; - struct ieee80211_bar { __le16 frame_control; __le16 duration; @@ -121578,6 +126381,258 @@ struct trace_event_data_offsets_drv_get_ftm_responder_stats { u32 vif_name; }; +typedef void (*btf_trace_drv_return_void)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_drv_return_int)(void *, struct ieee80211_local *, int); + +typedef void (*btf_trace_drv_return_bool)(void *, struct ieee80211_local *, bool); + +typedef void (*btf_trace_drv_return_u32)(void *, struct ieee80211_local *, u32); + +typedef void (*btf_trace_drv_return_u64)(void *, struct ieee80211_local *, u64); + +typedef void (*btf_trace_drv_start)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_drv_get_et_strings)(void *, struct ieee80211_local *, u32); + +typedef void (*btf_trace_drv_get_et_sset_count)(void *, struct ieee80211_local *, u32); + +typedef void (*btf_trace_drv_get_et_stats)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_drv_suspend)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_drv_resume)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_drv_set_wakeup)(void *, struct ieee80211_local *, bool); + +typedef void (*btf_trace_drv_stop)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_drv_add_interface)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_change_interface)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, enum nl80211_iftype, bool); + +typedef void (*btf_trace_drv_remove_interface)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_config)(void *, struct ieee80211_local *, u32); + +typedef void (*btf_trace_drv_bss_info_changed)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_bss_conf *, u32); + +typedef void (*btf_trace_drv_prepare_multicast)(void *, struct ieee80211_local *, int); + +typedef void (*btf_trace_drv_configure_filter)(void *, struct ieee80211_local *, unsigned int, unsigned int *, u64); + +typedef void (*btf_trace_drv_config_iface_filter)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, unsigned int, unsigned int); + +typedef void (*btf_trace_drv_set_tim)(void *, struct ieee80211_local *, struct ieee80211_sta *, bool); + +typedef void (*btf_trace_drv_set_key)(void *, struct ieee80211_local *, enum set_key_cmd, struct ieee80211_sub_if_data *, struct ieee80211_sta *, struct ieee80211_key_conf *); + +typedef void (*btf_trace_drv_update_tkip_key)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_key_conf *, struct ieee80211_sta *, u32); + +typedef void (*btf_trace_drv_hw_scan)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_cancel_hw_scan)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_sched_scan_start)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_sched_scan_stop)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_sw_scan_start)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, const u8 *); + +typedef void (*btf_trace_drv_sw_scan_complete)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_get_stats)(void *, struct ieee80211_local *, struct ieee80211_low_level_stats *, int); + +typedef void (*btf_trace_drv_get_key_seq)(void *, struct ieee80211_local *, struct ieee80211_key_conf *); + +typedef void (*btf_trace_drv_set_frag_threshold)(void *, struct ieee80211_local *, u32); + +typedef void (*btf_trace_drv_set_rts_threshold)(void *, struct ieee80211_local *, u32); + +typedef void (*btf_trace_drv_set_coverage_class)(void *, struct ieee80211_local *, s16); + +typedef void (*btf_trace_drv_sta_notify)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, enum sta_notify_cmd, struct ieee80211_sta *); + +typedef void (*btf_trace_drv_sta_state)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_sta *, enum ieee80211_sta_state, enum ieee80211_sta_state); + +typedef void (*btf_trace_drv_sta_set_txpwr)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_sta *); + +typedef void (*btf_trace_drv_sta_rc_update)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_sta *, u32); + +typedef void (*btf_trace_drv_sta_statistics)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_sta *); + +typedef void (*btf_trace_drv_sta_add)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_sta *); + +typedef void (*btf_trace_drv_sta_remove)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_sta *); + +typedef void (*btf_trace_drv_sta_pre_rcu_remove)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_sta *); + +typedef void (*btf_trace_drv_sync_rx_queues)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_sta *); + +typedef void (*btf_trace_drv_sta_rate_tbl_update)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_sta *); + +typedef void (*btf_trace_drv_conf_tx)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, u16, const struct ieee80211_tx_queue_params *); + +typedef void (*btf_trace_drv_get_tsf)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_set_tsf)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, u64); + +typedef void (*btf_trace_drv_offset_tsf)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, s64); + +typedef void (*btf_trace_drv_reset_tsf)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_tx_last_beacon)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_drv_ampdu_action)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_ampdu_params *); + +typedef void (*btf_trace_drv_get_survey)(void *, struct ieee80211_local *, int, struct survey_info *); + +typedef void (*btf_trace_drv_flush)(void *, struct ieee80211_local *, u32, bool); + +typedef void (*btf_trace_drv_channel_switch)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_channel_switch *); + +typedef void (*btf_trace_drv_set_antenna)(void *, struct ieee80211_local *, u32, u32, int); + +typedef void (*btf_trace_drv_get_antenna)(void *, struct ieee80211_local *, u32, u32, int); + +typedef void (*btf_trace_drv_remain_on_channel)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_channel *, unsigned int, enum ieee80211_roc_type); + +typedef void (*btf_trace_drv_cancel_remain_on_channel)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_set_ringparam)(void *, struct ieee80211_local *, u32, u32); + +typedef void (*btf_trace_drv_get_ringparam)(void *, struct ieee80211_local *, u32 *, u32 *, u32 *, u32 *); + +typedef void (*btf_trace_drv_tx_frames_pending)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_drv_offchannel_tx_cancel_wait)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_drv_set_bitrate_mask)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, const struct cfg80211_bitrate_mask *); + +typedef void (*btf_trace_drv_set_rekey_data)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct cfg80211_gtk_rekey_data *); + +typedef void (*btf_trace_drv_event_callback)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, const struct ieee80211_event *); + +typedef void (*btf_trace_drv_release_buffered_frames)(void *, struct ieee80211_local *, struct ieee80211_sta *, u16, int, enum ieee80211_frame_release_type, bool); + +typedef void (*btf_trace_drv_allow_buffered_frames)(void *, struct ieee80211_local *, struct ieee80211_sta *, u16, int, enum ieee80211_frame_release_type, bool); + +typedef void (*btf_trace_drv_mgd_prepare_tx)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, u16); + +typedef void (*btf_trace_drv_mgd_protect_tdls_discover)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_add_chanctx)(void *, struct ieee80211_local *, struct ieee80211_chanctx *); + +typedef void (*btf_trace_drv_remove_chanctx)(void *, struct ieee80211_local *, struct ieee80211_chanctx *); + +typedef void (*btf_trace_drv_change_chanctx)(void *, struct ieee80211_local *, struct ieee80211_chanctx *, u32); + +typedef void (*btf_trace_drv_switch_vif_chanctx)(void *, struct ieee80211_local *, struct ieee80211_vif_chanctx_switch *, int, enum ieee80211_chanctx_switch_mode); + +typedef void (*btf_trace_drv_assign_vif_chanctx)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_chanctx *); + +typedef void (*btf_trace_drv_unassign_vif_chanctx)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_chanctx *); + +typedef void (*btf_trace_drv_start_ap)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_bss_conf *); + +typedef void (*btf_trace_drv_stop_ap)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_reconfig_complete)(void *, struct ieee80211_local *, enum ieee80211_reconfig_type); + +typedef void (*btf_trace_drv_ipv6_addr_change)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_join_ibss)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_bss_conf *); + +typedef void (*btf_trace_drv_leave_ibss)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_get_expected_throughput)(void *, struct ieee80211_sta *); + +typedef void (*btf_trace_drv_start_nan)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct cfg80211_nan_conf *); + +typedef void (*btf_trace_drv_stop_nan)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_nan_change_conf)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct cfg80211_nan_conf *, u32); + +typedef void (*btf_trace_drv_add_nan_func)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, const struct cfg80211_nan_func *); + +typedef void (*btf_trace_drv_del_nan_func)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, u8); + +typedef void (*btf_trace_drv_start_pmsr)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_abort_pmsr)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_api_start_tx_ba_session)(void *, struct ieee80211_sta *, u16); + +typedef void (*btf_trace_api_start_tx_ba_cb)(void *, struct ieee80211_sub_if_data *, const u8 *, u16); + +typedef void (*btf_trace_api_stop_tx_ba_session)(void *, struct ieee80211_sta *, u16); + +typedef void (*btf_trace_api_stop_tx_ba_cb)(void *, struct ieee80211_sub_if_data *, const u8 *, u16); + +typedef void (*btf_trace_api_restart_hw)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_api_beacon_loss)(void *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_api_connection_loss)(void *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_api_cqm_rssi_notify)(void *, struct ieee80211_sub_if_data *, enum nl80211_cqm_rssi_threshold_event, s32); + +typedef void (*btf_trace_api_cqm_beacon_loss_notify)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_api_scan_completed)(void *, struct ieee80211_local *, bool); + +typedef void (*btf_trace_api_sched_scan_results)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_api_sched_scan_stopped)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_api_sta_block_awake)(void *, struct ieee80211_local *, struct ieee80211_sta *, bool); + +typedef void (*btf_trace_api_chswitch_done)(void *, struct ieee80211_sub_if_data *, bool); + +typedef void (*btf_trace_api_ready_on_channel)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_api_remain_on_channel_expired)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_api_gtk_rekey_notify)(void *, struct ieee80211_sub_if_data *, const u8 *, const u8 *); + +typedef void (*btf_trace_api_enable_rssi_reports)(void *, struct ieee80211_sub_if_data *, int, int); + +typedef void (*btf_trace_api_eosp)(void *, struct ieee80211_local *, struct ieee80211_sta *); + +typedef void (*btf_trace_api_send_eosp_nullfunc)(void *, struct ieee80211_local *, struct ieee80211_sta *, u8); + +typedef void (*btf_trace_api_sta_set_buffered)(void *, struct ieee80211_local *, struct ieee80211_sta *, u8, bool); + +typedef void (*btf_trace_wake_queue)(void *, struct ieee80211_local *, u16, enum queue_stop_reason); + +typedef void (*btf_trace_stop_queue)(void *, struct ieee80211_local *, u16, enum queue_stop_reason); + +typedef void (*btf_trace_drv_set_default_unicast_key)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, int); + +typedef void (*btf_trace_api_radar_detected)(void *, struct ieee80211_local *); + +typedef void (*btf_trace_drv_channel_switch_beacon)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct cfg80211_chan_def *); + +typedef void (*btf_trace_drv_pre_channel_switch)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_channel_switch *); + +typedef void (*btf_trace_drv_post_channel_switch)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_abort_channel_switch)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *); + +typedef void (*btf_trace_drv_channel_switch_rx_beacon)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_channel_switch *); + +typedef void (*btf_trace_drv_get_txpower)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, int, int); + +typedef void (*btf_trace_drv_tdls_channel_switch)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_sta *, u8, struct cfg80211_chan_def *); + +typedef void (*btf_trace_drv_tdls_cancel_channel_switch)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_sta *); + +typedef void (*btf_trace_drv_tdls_recv_channel_switch)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct ieee80211_tdls_ch_sw_params *); + +typedef void (*btf_trace_drv_wake_tx_queue)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct txq_info *); + +typedef void (*btf_trace_drv_get_ftm_responder_stats)(void *, struct ieee80211_local *, struct ieee80211_sub_if_data *, struct cfg80211_ftm_responder_stats *); + enum ieee80211_he_mcs_support { IEEE80211_HE_MCS_SUPPORT_0_7 = 0, IEEE80211_HE_MCS_SUPPORT_0_9 = 1, @@ -122045,7 +127100,161 @@ enum { dns_key_error = 1, }; -struct warn_args___2; +struct sockaddr_xdp { + __u16 sxdp_family; + __u16 sxdp_flags; + __u32 sxdp_ifindex; + __u32 sxdp_queue_id; + __u32 sxdp_shared_umem_fd; +}; + +struct xdp_ring_offset { + __u64 producer; + __u64 consumer; + __u64 desc; + __u64 flags; +}; + +struct xdp_mmap_offsets { + struct xdp_ring_offset rx; + struct xdp_ring_offset tx; + struct xdp_ring_offset fr; + struct xdp_ring_offset cr; +}; + +struct xdp_umem_reg { + __u64 addr; + __u64 len; + __u32 chunk_size; + __u32 headroom; + __u32 flags; +}; + +struct xdp_statistics { + __u64 rx_dropped; + __u64 rx_invalid_descs; + __u64 tx_invalid_descs; +}; + +struct xdp_options { + __u32 flags; +}; + +struct xdp_desc { + __u64 addr; + __u32 len; + __u32 options; +}; + +struct xdp_ring; + +struct xsk_queue { + u64 chunk_mask; + u64 size; + u32 ring_mask; + u32 nentries; + u32 prod_head; + u32 prod_tail; + u32 cons_head; + u32 cons_tail; + struct xdp_ring *ring; + u64 invalid_descs; +}; + +struct xdp_ring { + u32 producer; + long: 32; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + u32 consumer; + u32 flags; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct xdp_rxtx_ring { + struct xdp_ring ptrs; + struct xdp_desc desc[0]; +}; + +struct xdp_umem_ring { + struct xdp_ring ptrs; + u64 desc[0]; +}; + +struct xdp_ring_offset_v1 { + __u64 producer; + __u64 consumer; + __u64 desc; +}; + +struct xdp_mmap_offsets_v1 { + struct xdp_ring_offset_v1 rx; + struct xdp_ring_offset_v1 tx; + struct xdp_ring_offset_v1 fr; + struct xdp_ring_offset_v1 cr; +}; + +struct xdp_diag_req { + __u8 sdiag_family; + __u8 sdiag_protocol; + __u16 pad; + __u32 xdiag_ino; + __u32 xdiag_show; + __u32 xdiag_cookie[2]; +}; + +struct xdp_diag_msg { + __u8 xdiag_family; + __u8 xdiag_type; + __u16 pad; + __u32 xdiag_ino; + __u32 xdiag_cookie[2]; +}; + +enum { + XDP_DIAG_NONE = 0, + XDP_DIAG_INFO = 1, + XDP_DIAG_UID = 2, + XDP_DIAG_RX_RING = 3, + XDP_DIAG_TX_RING = 4, + XDP_DIAG_UMEM = 5, + XDP_DIAG_UMEM_FILL_RING = 6, + XDP_DIAG_UMEM_COMPLETION_RING = 7, + XDP_DIAG_MEMINFO = 8, + __XDP_DIAG_MAX = 9, +}; + +struct xdp_diag_info { + __u32 ifindex; + __u32 queue_id; +}; + +struct xdp_diag_ring { + __u32 entries; +}; + +struct xdp_diag_umem { + __u64 size; + __u32 id; + __u32 num_pages; + __u32 chunk_size; + __u32 headroom; + __u32 ifindex; + __u32 queue_id; + __u32 flags; + __u32 refs; +}; struct compress_format { unsigned char magic[2]; @@ -122208,13 +127417,13 @@ enum { st_wordstart = 0, st_wordcmp = 1, st_wordskip = 2, + st_bufcpy = 3, }; enum { st_wordstart___2 = 0, st_wordcmp___2 = 1, st_wordskip___2 = 2, - st_bufcpy = 3, }; struct in6_addr___2; From 7fd2fa68b52e0f38dd4915bf786d67445941eedd Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Tue, 10 Mar 2020 16:49:53 +0100 Subject: [PATCH 050/278] Factor out ebpf::parse_tracepoint function And moving it to common.cc in order to be able to make automated tests for it. Following patches are adding automated test for this function and it seems too much to link in all the clang/llvm stuff to the test binary just for single function test. Adding ebpf::parse_tracepoint that takes istream of the tracepoint format data and returns tracepoint struct as std::string. No functional change is intended or expected. Signed-off-by: Jiri Olsa --- src/cc/common.cc | 107 +++++++++++++++++++ src/cc/common.h | 2 + src/cc/frontends/clang/tp_frontend_action.cc | 107 +------------------ 3 files changed, 112 insertions(+), 104 deletions(-) diff --git a/src/cc/common.cc b/src/cc/common.cc index ab7528ce0..4e059aa29 100644 --- a/src/cc/common.cc +++ b/src/cc/common.cc @@ -63,4 +63,111 @@ std::string get_pid_exe(pid_t pid) { return std::string(exe_path); } +enum class field_kind_t { + common, + data_loc, + regular, + invalid +}; + +static inline field_kind_t _get_field_kind(std::string const& line, + std::string& field_type, + std::string& field_name) { + auto field_pos = line.find("field:"); + if (field_pos == std::string::npos) + return field_kind_t::invalid; + + auto field_semi_pos = line.find(';', field_pos); + if (field_semi_pos == std::string::npos) + return field_kind_t::invalid; + + auto offset_pos = line.find("offset:", field_semi_pos); + if (offset_pos == std::string::npos) + return field_kind_t::invalid; + + auto semi_pos = line.find(';', offset_pos); + if (semi_pos == std::string::npos) + return field_kind_t::invalid; + + auto size_pos = line.find("size:", semi_pos); + if (size_pos == std::string::npos) + return field_kind_t::invalid; + + semi_pos = line.find(';', size_pos); + if (semi_pos == std::string::npos) + return field_kind_t::invalid; + + auto size_str = line.substr(size_pos + 5, + semi_pos - size_pos - 5); + int size = std::stoi(size_str, nullptr); + + auto field = line.substr(field_pos + 6/*"field:"*/, + field_semi_pos - field_pos - 6); + auto pos = field.find_last_of("\t "); + if (pos == std::string::npos) + return field_kind_t::invalid; + + field_type = field.substr(0, pos); + field_name = field.substr(pos + 1); + if (field_type.find("__data_loc") != std::string::npos) + return field_kind_t::data_loc; + if (field_name.find("common_") == 0) + return field_kind_t::common; + // do not change type definition for array + if (field_name.find("[") != std::string::npos) + return field_kind_t::regular; + + // adjust the field_type based on the size of field + // otherwise, incorrect value may be retrieved for big endian + // and the field may have incorrect structure offset. + if (size == 2) { + if (field_type == "char" || field_type == "int8_t") + field_type = "s16"; + if (field_type == "unsigned char" || field_type == "uint8_t") + field_type = "u16"; + } else if (size == 4) { + if (field_type == "char" || field_type == "short" || + field_type == "int8_t" || field_type == "int16_t") + field_type = "s32"; + if (field_type == "unsigned char" || field_type == "unsigned short" || + field_type == "uint8_t" || field_type == "uint16_t") + field_type = "u32"; + } else if (size == 8) { + if (field_type == "char" || field_type == "short" || field_type == "int" || + field_type == "int8_t" || field_type == "int16_t" || + field_type == "int32_t" || field_type == "pid_t") + field_type = "s64"; + if (field_type == "unsigned char" || field_type == "unsigned short" || + field_type == "unsigned int" || field_type == "uint8_t" || + field_type == "uint16_t" || field_type == "uint32_t" || + field_type == "unsigned" || field_type == "u32" || + field_type == "uid_t" || field_type == "gid_t") + field_type = "u64"; + } + + return field_kind_t::regular; +} + +std::string parse_tracepoint(std::istream &input, std::string const& category, + std::string const& event) { + std::string tp_struct = "struct tracepoint__" + category + "__" + event + " {\n"; + tp_struct += "\tu64 __do_not_use__;\n"; + for (std::string line; getline(input, line); ) { + std::string field_type, field_name; + switch (_get_field_kind(line, field_type, field_name)) { + case field_kind_t::invalid: + case field_kind_t::common: + continue; + case field_kind_t::data_loc: + tp_struct += "\tint data_loc_" + field_name + ";\n"; + break; + case field_kind_t::regular: + tp_struct += "\t" + field_type + " " + field_name + ";\n"; + break; + } + } + + tp_struct += "};\n"; + return tp_struct; +} } // namespace ebpf diff --git a/src/cc/common.h b/src/cc/common.h index 2ef250a2b..bfba4c926 100644 --- a/src/cc/common.h +++ b/src/cc/common.h @@ -39,4 +39,6 @@ std::vector get_possible_cpus(); std::string get_pid_exe(pid_t pid); +std::string parse_tracepoint(std::istream &input, std::string const& category, + std::string const& event); } // namespace ebpf diff --git a/src/cc/frontends/clang/tp_frontend_action.cc b/src/cc/frontends/clang/tp_frontend_action.cc index 6a78aaca1..456283589 100644 --- a/src/cc/frontends/clang/tp_frontend_action.cc +++ b/src/cc/frontends/clang/tp_frontend_action.cc @@ -30,6 +30,7 @@ #include "frontend_action_common.h" #include "tp_frontend_action.h" +#include "common.h" namespace ebpf { @@ -42,6 +43,7 @@ using std::vector; using std::regex; using std::smatch; using std::regex_search; +using std::istream; using std::ifstream; using namespace clang; @@ -49,91 +51,6 @@ TracepointTypeVisitor::TracepointTypeVisitor(ASTContext &C, Rewriter &rewriter) : diag_(C.getDiagnostics()), rewriter_(rewriter), out_(llvm::errs()) { } -enum class field_kind_t { - common, - data_loc, - regular, - invalid -}; - -static inline field_kind_t _get_field_kind(string const& line, - string& field_type, - string& field_name) { - auto field_pos = line.find("field:"); - if (field_pos == string::npos) - return field_kind_t::invalid; - - auto field_semi_pos = line.find(';', field_pos); - if (field_semi_pos == string::npos) - return field_kind_t::invalid; - - auto offset_pos = line.find("offset:", field_semi_pos); - if (offset_pos == string::npos) - return field_kind_t::invalid; - - auto semi_pos = line.find(';', offset_pos); - if (semi_pos == string::npos) - return field_kind_t::invalid; - - auto size_pos = line.find("size:", semi_pos); - if (size_pos == string::npos) - return field_kind_t::invalid; - - semi_pos = line.find(';', size_pos); - if (semi_pos == string::npos) - return field_kind_t::invalid; - - auto size_str = line.substr(size_pos + 5, - semi_pos - size_pos - 5); - int size = std::stoi(size_str, nullptr); - - auto field = line.substr(field_pos + 6/*"field:"*/, - field_semi_pos - field_pos - 6); - auto pos = field.find_last_of("\t "); - if (pos == string::npos) - return field_kind_t::invalid; - - field_type = field.substr(0, pos); - field_name = field.substr(pos + 1); - if (field_type.find("__data_loc") != string::npos) - return field_kind_t::data_loc; - if (field_name.find("common_") == 0) - return field_kind_t::common; - // do not change type definition for array - if (field_name.find("[") != string::npos) - return field_kind_t::regular; - - // adjust the field_type based on the size of field - // otherwise, incorrect value may be retrieved for big endian - // and the field may have incorrect structure offset. - if (size == 2) { - if (field_type == "char" || field_type == "int8_t") - field_type = "s16"; - if (field_type == "unsigned char" || field_type == "uint8_t") - field_type = "u16"; - } else if (size == 4) { - if (field_type == "char" || field_type == "short" || - field_type == "int8_t" || field_type == "int16_t") - field_type = "s32"; - if (field_type == "unsigned char" || field_type == "unsigned short" || - field_type == "uint8_t" || field_type == "uint16_t") - field_type = "u32"; - } else if (size == 8) { - if (field_type == "char" || field_type == "short" || field_type == "int" || - field_type == "int8_t" || field_type == "int16_t" || - field_type == "int32_t" || field_type == "pid_t") - field_type = "s64"; - if (field_type == "unsigned char" || field_type == "unsigned short" || - field_type == "unsigned int" || field_type == "uint8_t" || - field_type == "uint16_t" || field_type == "uint32_t" || - field_type == "unsigned" || field_type == "u32" || - field_type == "uid_t" || field_type == "gid_t") - field_type = "u64"; - } - - return field_kind_t::regular; -} - string TracepointTypeVisitor::GenerateTracepointStruct( SourceLocation loc, string const& category, string const& event) { string format_file = "/sys/kernel/debug/tracing/events/" + @@ -142,25 +59,7 @@ string TracepointTypeVisitor::GenerateTracepointStruct( if (!input) return ""; - string tp_struct = "struct tracepoint__" + category + "__" + event + " {\n"; - tp_struct += "\tu64 __do_not_use__;\n"; - for (string line; getline(input, line); ) { - string field_type, field_name; - switch (_get_field_kind(line, field_type, field_name)) { - case field_kind_t::invalid: - case field_kind_t::common: - continue; - case field_kind_t::data_loc: - tp_struct += "\tint data_loc_" + field_name + ";\n"; - break; - case field_kind_t::regular: - tp_struct += "\t" + field_type + " " + field_name + ";\n"; - break; - } - } - - tp_struct += "};\n"; - return tp_struct; + return ebpf::parse_tracepoint(input, category, event); } static inline bool _is_tracepoint_struct_type(string const& type_name, From b9099c51ca570f33a5a9baef6f4f566c126b2b16 Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Tue, 10 Mar 2020 14:39:05 +0100 Subject: [PATCH 051/278] Add test for ebpf::parse_tracepoint function The test prepares tracepoint format file and run ebpf::parse_tracepoint on it. Then it compares expected struct output with actual function result. Signed-off-by: Jiri Olsa --- tests/cc/CMakeLists.txt | 3 +- tests/cc/test_parse_tracepoint.cc | 69 +++++++++++++++++++++++++++++++ 2 files changed, 71 insertions(+), 1 deletion(-) create mode 100644 tests/cc/test_parse_tracepoint.cc diff --git a/tests/cc/CMakeLists.txt b/tests/cc/CMakeLists.txt index 0435e646a..d7c3930bc 100644 --- a/tests/cc/CMakeLists.txt +++ b/tests/cc/CMakeLists.txt @@ -31,7 +31,8 @@ set(TEST_LIBBCC_SOURCES test_sock_table.cc test_usdt_args.cc test_usdt_probes.cc - utils.cc) + utils.cc + test_parse_tracepoint.cc) add_executable(test_libbcc ${TEST_LIBBCC_SOURCES}) diff --git a/tests/cc/test_parse_tracepoint.cc b/tests/cc/test_parse_tracepoint.cc new file mode 100644 index 000000000..bc8afca1c --- /dev/null +++ b/tests/cc/test_parse_tracepoint.cc @@ -0,0 +1,69 @@ +#include "BPF.h" +#include "catch.hpp" +#include "common.h" + +TEST_CASE("test tracepoint parser", "[TracepointParser]") { + std::string format = + "name: sys_enter_read\n" + "ID: 650\n" + "format:\n" + " field:unsigned short common_type; offset:0; size:2; signed:0;\n" + " field:unsigned char common_flags; offset:2; size:1; signed:0;\n" + " field:unsigned char common_preempt_count; offset:3; size:1; signed:0;\n" + " field:int common_pid; offset:4; size:4; signed:1;\n" + "\n" + " field:int __syscall_nr; offset:8; size:4; signed:1;\n" + " field:unsigned int fd; offset:16; size:8; signed:0;\n" + " field:char * buf; offset:24; size:8; signed:0;\n" + " field:size_t count; offset:32; size:8; signed:0;\n" + "\n" + "print fmt: \"fd: 0x%08lx, buf: 0x%08lx, count: 0x%08lx\", ((unsigned long)(REC->fd)), ((unsigned long)(REC->buf)), ((unsigned long)(REC->count))\n"; + + std::string expected = + "struct tracepoint__syscalls__sys_enter_read {\n" + "\tu64 __do_not_use__;\n" + "\tint __syscall_nr;\n" + "\tu64 fd;\n" + "\tchar * buf;\n" + "\tsize_t count;\n" + "};\n"; + + { + std::istringstream input(format); + std::string result = ebpf::parse_tracepoint(input, "syscalls", "sys_enter_read"); + REQUIRE(expected == result); + } + + format = + "name: signal_deliver\n" + "ID: 114\n" + "format:\n" + " field:unsigned short common_type; offset:0; size:2; signed:0;\n" + " field:unsigned char common_flags; offset:2; size:1; signed:0;\n" + " field:unsigned char common_preempt_count; offset:3; size:1; signed:0;\n" + " field:int common_pid; offset:4; size:4; signed:1;\n" + "\n" + " field:int sig; offset:8; size:4; signed:1;\n" + " field:int errno; offset:12; size:4; signed:1;\n" + " field:int code; offset:16; size:4; signed:1;\n" + " field:unsigned long sa_handler; offset:24; size:8; signed:0;\n" + " field:unsigned long sa_flags; offset:32; size:8; signed:0;\n" + "\n" + "print fmt: \"sig=%d errno=%d code=%d sa_handler=%lx sa_flags=%lx\", REC->sig, REC->errno, REC->code, REC->sa_handler, REC->sa_flags\n"; + + expected = + "struct tracepoint__signal__signal_deliver {\n" + "\tu64 __do_not_use__;\n" + "\tint sig;\n" + "\tint errno;\n" + "\tint code;\n" + "\tunsigned long sa_handler;\n" + "\tunsigned long sa_flags;\n" + "};\n"; + + { + std::istringstream input(format); + std::string result = ebpf::parse_tracepoint(input, "signal", "signal_deliver"); + REQUIRE(expected == result); + } +} From b8423e66ce450418c6142aab61ee9330e1fcefcc Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Tue, 10 Mar 2020 17:33:49 +0100 Subject: [PATCH 052/278] Strengthen tracepoint format parsing There's issue in current RHEL real time kernel with tracepoint format, which makes bcc-tools to return wrong data. Two new 'common_' fields were added and it causes 2 issues for tracepoint format parser. First issue - is the gap between common fields and other fields, which is not picked up by the parser, so the resulted struct is not aligned with the data. Second issue - is the fact that current parser covers common fields with: u64 __do_not_use__ so the new common fields are not accounted for. This issue is solved in the following patch. I kept both issues and fixes separated to make the change readable. There's a 'not described gap' in the sched_wakeup's format file and probably in other formats as well: Having: # cat /sys/kernel/debug/tracing/events/sched/sched_wakeup/format name: sched_wakeup ID: 310 format: field:unsigned short common_type; offset:0; size:2; signed:0; field:unsigned char common_flags; offset:2; size:1; signed:0; field:unsigned char common_preempt_count; offset:3; size:1; signed:0; field:int common_pid; offset:4; size:4; signed:1; field:unsigned char common_migrate_disable; offset:8; size:1; signed:0; field:unsigned char common_preempt_lazy_count; offset:9; size:1; signed:0; field:char comm[16]; offset:12; size:16; signed:1; field:pid_t pid; offset:28; size:4; signed:1; field:int prio; offset:32; size:4; signed:1; field:int success; offset:36; size:4; signed:1; field:int target_cpu; offset:40; size:4; signed:1; There's "common_preempt_lazy_count" field on offset 9 with size 1: common_preempt_lazy_count; offset:9; size:1; and it's followed by "comm" field on offset 12: field:char comm[16]; offset:12; size:16; signed:1; which makes 2 bytes gap in between, that might confuse some applications like bpftrace or bcc-tools library. The tracepoint parser makes struct out of the field descriptions, but does not account for such gaps. I posted patch to fix this [1] in RT kernel, but that might take a while, and we could easily fix our tracepoint parser to workaround this issue. Adding code to detect this gaps and add 1 byte __pad_X fields, where X is the offset number. [1] https://lore.kernel.org/linux-rt-users/20200221153541.681468-1-jolsa@kernel.org/ Signed-off-by: Jiri Olsa --- src/cc/common.cc | 49 +++++++++++++++++++++++-------- tests/cc/test_parse_tracepoint.cc | 8 +++++ 2 files changed, 44 insertions(+), 13 deletions(-) diff --git a/src/cc/common.cc b/src/cc/common.cc index 4e059aa29..35bb6fed9 100644 --- a/src/cc/common.cc +++ b/src/cc/common.cc @@ -67,12 +67,14 @@ enum class field_kind_t { common, data_loc, regular, - invalid + invalid, + pad, }; static inline field_kind_t _get_field_kind(std::string const& line, std::string& field_type, - std::string& field_name) { + std::string& field_name, + int *last_offset) { auto field_pos = line.find("field:"); if (field_pos == std::string::npos) return field_kind_t::invalid; @@ -89,6 +91,10 @@ static inline field_kind_t _get_field_kind(std::string const& line, if (semi_pos == std::string::npos) return field_kind_t::invalid; + auto offset_str = line.substr(offset_pos + 7, + semi_pos - offset_pos - 7); + int offset = std::stoi(offset_str, nullptr); + auto size_pos = line.find("size:", semi_pos); if (size_pos == std::string::npos) return field_kind_t::invalid; @@ -101,6 +107,13 @@ static inline field_kind_t _get_field_kind(std::string const& line, semi_pos - size_pos - 5); int size = std::stoi(size_str, nullptr); + if (*last_offset < offset) { + *last_offset += 1; + return field_kind_t::pad; + } + + *last_offset = offset + size; + auto field = line.substr(field_pos + 6/*"field:"*/, field_semi_pos - field_pos - 6); auto pos = field.find_last_of("\t "); @@ -152,19 +165,29 @@ std::string parse_tracepoint(std::istream &input, std::string const& category, std::string const& event) { std::string tp_struct = "struct tracepoint__" + category + "__" + event + " {\n"; tp_struct += "\tu64 __do_not_use__;\n"; + int last_offset = 0; for (std::string line; getline(input, line); ) { std::string field_type, field_name; - switch (_get_field_kind(line, field_type, field_name)) { - case field_kind_t::invalid: - case field_kind_t::common: - continue; - case field_kind_t::data_loc: - tp_struct += "\tint data_loc_" + field_name + ";\n"; - break; - case field_kind_t::regular: - tp_struct += "\t" + field_type + " " + field_name + ";\n"; - break; - } + field_kind_t kind; + + do { + kind = _get_field_kind(line, field_type, field_name, &last_offset); + + switch (kind) { + case field_kind_t::invalid: + case field_kind_t::common: + continue; + case field_kind_t::data_loc: + tp_struct += "\tint data_loc_" + field_name + ";\n"; + break; + case field_kind_t::regular: + tp_struct += "\t" + field_type + " " + field_name + ";\n"; + break; + case field_kind_t::pad: + tp_struct += "\tchar __pad_" + std::to_string(last_offset - 1) + ";\n"; + break; + } + } while (kind == field_kind_t::pad); } tp_struct += "};\n"; diff --git a/tests/cc/test_parse_tracepoint.cc b/tests/cc/test_parse_tracepoint.cc index bc8afca1c..878d08372 100644 --- a/tests/cc/test_parse_tracepoint.cc +++ b/tests/cc/test_parse_tracepoint.cc @@ -23,6 +23,10 @@ TEST_CASE("test tracepoint parser", "[TracepointParser]") { "struct tracepoint__syscalls__sys_enter_read {\n" "\tu64 __do_not_use__;\n" "\tint __syscall_nr;\n" + "\tchar __pad_12;\n" + "\tchar __pad_13;\n" + "\tchar __pad_14;\n" + "\tchar __pad_15;\n" "\tu64 fd;\n" "\tchar * buf;\n" "\tsize_t count;\n" @@ -57,6 +61,10 @@ TEST_CASE("test tracepoint parser", "[TracepointParser]") { "\tint sig;\n" "\tint errno;\n" "\tint code;\n" + "\tchar __pad_20;\n" + "\tchar __pad_21;\n" + "\tchar __pad_22;\n" + "\tchar __pad_23;\n" "\tunsigned long sa_handler;\n" "\tunsigned long sa_flags;\n" "};\n"; From 0a9d6db96c6410d2ef741507255f5258d6406032 Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Wed, 11 Mar 2020 15:25:08 +0100 Subject: [PATCH 053/278] Add support for new common fields Current parser covers common fields with: u64 __do_not_use__ so the new common fields are not accounted for. Keeping the 'u64 __do_not_use__' field for backward compatibility (who knows who's actualy using it) and adding new fields, like: char __do_not_use__X for each byte of extra common fields, where X is the offset of the field. With this fix the bcc-tools correctly parses tracepoints on RT kernel and it's usable again. Signed-off-by: Jiri Olsa --- src/cc/common.cc | 7 ++++++- tests/cc/test_parse_tracepoint.cc | 34 +++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 1 deletion(-) diff --git a/src/cc/common.cc b/src/cc/common.cc index 35bb6fed9..a006b6e4a 100644 --- a/src/cc/common.cc +++ b/src/cc/common.cc @@ -165,7 +165,7 @@ std::string parse_tracepoint(std::istream &input, std::string const& category, std::string const& event) { std::string tp_struct = "struct tracepoint__" + category + "__" + event + " {\n"; tp_struct += "\tu64 __do_not_use__;\n"; - int last_offset = 0; + int last_offset = 0, common_offset = 8; for (std::string line; getline(input, line); ) { std::string field_type, field_name; field_kind_t kind; @@ -175,7 +175,12 @@ std::string parse_tracepoint(std::istream &input, std::string const& category, switch (kind) { case field_kind_t::invalid: + continue; case field_kind_t::common: + for (;common_offset < last_offset; common_offset++) + { + tp_struct += "\tchar __do_not_use__" + std::to_string(common_offset) + ";\n"; + } continue; case field_kind_t::data_loc: tp_struct += "\tint data_loc_" + field_name + ";\n"; diff --git a/tests/cc/test_parse_tracepoint.cc b/tests/cc/test_parse_tracepoint.cc index 878d08372..8191b03dd 100644 --- a/tests/cc/test_parse_tracepoint.cc +++ b/tests/cc/test_parse_tracepoint.cc @@ -74,4 +74,38 @@ TEST_CASE("test tracepoint parser", "[TracepointParser]") { std::string result = ebpf::parse_tracepoint(input, "signal", "signal_deliver"); REQUIRE(expected == result); } + + format = + " field:unsigned short common_type; offset:0; size:2; signed:0;\n" + " field:unsigned char common_flags; offset:2; size:1; signed:0;\n" + " field:unsigned char common_preempt_count; offset:3; size:1; signed:0;\n" + " field:int common_pid; offset:4; size:4; signed:1;\n" + " field:unsigned char common_migrate_disable; offset:8; size:1; signed:0;\n" + " field:unsigned char common_preempt_lazy_count; offset:9; size:1; signed:0;\n" + + " field:char comm[16]; offset:12; size:16; signed:1;\n" + " field:pid_t pid; offset:28; size:4; signed:1;\n" + " field:int prio; offset:32; size:4; signed:1;\n" + " field:int success; offset:36; size:4; signed:1;\n" + " field:int target_cpu; offset:40; size:4; signed:1;\n"; + + expected = + "struct tracepoint__sched__sched_wakeup {\n" + "\tu64 __do_not_use__;\n" + "\tchar __do_not_use__8;\n" + "\tchar __do_not_use__9;\n" + "\tchar __pad_10;\n" + "\tchar __pad_11;\n" + "\tchar comm[16];\n" + "\tpid_t pid;\n" + "\tint prio;\n" + "\tint success;\n" + "\tint target_cpu;\n" + "};\n"; + + { + std::istringstream input(format); + std::string result = ebpf::parse_tracepoint(input, "sched", "sched_wakeup"); + REQUIRE(expected == result); + } } From 5302614d31645db8fb5466e95ba7e6500c2c46c2 Mon Sep 17 00:00:00 2001 From: Andrii Nakryiko Date: Tue, 17 Mar 2020 16:46:57 -0700 Subject: [PATCH 054/278] libbpf: update to latest libbpf version Pull in latest libbpf changes. In particular, containing BPF_KRETPROBE fix. Signed-off-by: Andrii Nakryiko --- src/cc/libbpf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cc/libbpf b/src/cc/libbpf index 9a424bea4..9f0d55c24 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit 9a424bea428bd7cde6f1bdaa2ee41f48e5686774 +Subproject commit 9f0d55c24afbd7b3aaf04cc3f99299115e4d0a98 From ca1b0af0eff9d994a49606899c2f110a68addeca Mon Sep 17 00:00:00 2001 From: gist-banana <50163926+gist-banana@users.noreply.github.com> Date: Wed, 18 Mar 2020 14:22:34 +0900 Subject: [PATCH 055/278] adding example/networking/net_monitor.py Aggregates incoming network traffic outputs source ip, destination ip, the number of their network traffic, and current time Co-authored-by: gist-banana --- examples/networking/net_monitor.py | 133 +++++++++++++++++++++++++++++ 1 file changed, 133 insertions(+) create mode 100644 examples/networking/net_monitor.py diff --git a/examples/networking/net_monitor.py b/examples/networking/net_monitor.py new file mode 100644 index 000000000..969ca284f --- /dev/null +++ b/examples/networking/net_monitor.py @@ -0,0 +1,133 @@ +#!/usr/bin/python +# +# net_monitor.py Aggregates incoming network traffic +# outputs source ip, destination ip, the number of their network traffic, and current time +# how to use : net_monitor.py +# +# Copyright (c) 2020 YoungEun Choe + +from bcc import BPF +import time +from ast import literal_eval +import sys + +def help(): + print("execute: {0} ".format(sys.argv[0])) + print("e.g.: {0} eno1\n".format(sys.argv[0])) + exit(1) + +if len(sys.argv) != 2: + help() +elif len(sys.argv) == 2: + INTERFACE = sys.argv[1] + +bpf_text = """ + +#include +#include +#include +#include + +#define IP_TCP 6 +#define IP_UDP 17 +#define IP_ICMP 1 +#define ETH_HLEN 14 + +BPF_PERF_OUTPUT(skb_events); +BPF_HASH(packet_cnt, u64, long, 256); + +int packet_monitor(struct __sk_buff *skb) { + u8 *cursor = 0; + u32 saddr, daddr; + long* count = 0; + long one = 1; + u64 pass_value = 0; + + struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); + + struct ip_t *ip = cursor_advance(cursor, sizeof(*ip)); + if (ip->nextp != IP_TCP) + { + if (ip -> nextp != IP_UDP) + { + if (ip -> nextp != IP_ICMP) + return 0; + } + } + + saddr = ip -> src; + daddr = ip -> dst; + + pass_value = saddr; + pass_value = pass_value << 32; + pass_value = pass_value + daddr; + + count = packet_cnt.lookup(&pass_value); + if (count) // check if this map exists + *count += 1; + else // if the map for the key doesn't exist, create one + { + packet_cnt.update(&pass_value, &one); + } + return -1; +} + +""" + +from ctypes import * +import ctypes as ct +import sys +import socket +import os +import struct + +OUTPUT_INTERVAL = 1 + +bpf = BPF(text=bpf_text) + +function_skb_matching = bpf.load_func("packet_monitor", BPF.SOCKET_FILTER) + +BPF.attach_raw_socket(function_skb_matching, INTERFACE) + + # retrieeve packet_cnt map +packet_cnt = bpf.get_table('packet_cnt') # retrieeve packet_cnt map + +def decimal_to_human(input_value): + input_value = int(input_value) + hex_value = hex(input_value)[2:] + pt3 = literal_eval((str('0x'+str(hex_value[-2:])))) + pt2 = literal_eval((str('0x'+str(hex_value[-4:-2])))) + pt1 = literal_eval((str('0x'+str(hex_value[-6:-4])))) + pt0 = literal_eval((str('0x'+str(hex_value[-8:-6])))) + result = str(pt0)+'.'+str(pt1)+'.'+str(pt2)+'.'+str(pt3) + return result + +try: + while True : + time.sleep(OUTPUT_INTERVAL) + packet_cnt_output = packet_cnt.items() + output_len = len(packet_cnt_output) + print('\n') + for i in range(0,output_len): + if (len(str(packet_cnt_output[i][0]))) != 30: + continue + temp = int(str(packet_cnt_output[i][0])[8:-2]) # initial output omitted from the kernel space program + temp = int(str(bin(temp))[2:]) # raw file + src = int(str(temp)[:32],2) # part1 + dst = int(str(temp)[32:],2) + pkt_num = str(packet_cnt_output[i][1])[7:-1] + + monitor_result = 'source address : ' + decimal_to_human(str(src)) + ' ' + 'destination address : ' + \ + decimal_to_human(str(dst)) + ' ' + pkt_num + ' ' + 'time : ' + str(time.localtime()[0])+\ + ';'+str(time.localtime()[1]).zfill(2)+';'+str(time.localtime()[2]).zfill(2)+';'+\ + str(time.localtime()[3]).zfill(2)+';'+str(time.localtime()[4]).zfill(2)+';'+\ + str(time.localtime()[5]).zfill(2) + print(monitor_result) + + # time.time() outputs time elapsed since 00:00 hours, 1st, Jan., 1970. + packet_cnt.clear() # delete map entires after printing output. confiremd it deletes values and keys too + +except KeyboardInterrupt: + sys.stdout.close() + pass + From 4c1136ee6c08eb9fef86ebaafe2544692472b5b7 Mon Sep 17 00:00:00 2001 From: FUJI Goro Date: Wed, 18 Mar 2020 14:26:43 +0900 Subject: [PATCH 056/278] Make -DCMAKE_INSTALL_PREFIX=/usr as the default (#2800) * make -DCMAKE_INSTALL_PREFIX=/usr as the default * remove -DCMAKE_INSTALL_PEREFIX=/usr from INSTALL.md as it gets the default --- CMakeLists.txt | 4 ++++ INSTALL.md | 15 +++++++-------- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f1916b55c..ad0070548 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -7,6 +7,10 @@ if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE Release) endif() +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "/usr" CACHE PATH "path to install" FORCE) +endif() + enable_testing() # populate submodules (libbpf) diff --git a/INSTALL.md b/INSTALL.md index fbbab742d..dc9e4d2ca 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -356,7 +356,7 @@ sudo apt-get -y install luajit luajit-5.1-dev ``` git clone https://github.com/iovisor/bcc.git mkdir bcc/build; cd bcc/build -cmake .. -DCMAKE_INSTALL_PREFIX=/usr +cmake .. make sudo make install cmake -DPYTHON_CMD=python3 .. # build python3 binding @@ -399,7 +399,7 @@ sudo dnf install -y clang clang-devel llvm llvm-devel llvm-static ncurses-devel ``` git clone https://github.com/iovisor/bcc.git mkdir bcc/build; cd bcc/build -cmake .. -DCMAKE_INSTALL_PREFIX=/usr +cmake .. make sudo make install ``` @@ -420,8 +420,7 @@ sudo zypper in lua51-luajit-devel # for lua support in openSUSE Tumbleweed ``` git clone https://github.com/iovisor/bcc.git mkdir bcc/build; cd bcc/build -cmake -DCMAKE_INSTALL_PREFIX=/usr \ - -DLUAJIT_INCLUDE_DIR=`pkg-config --variable=includedir luajit` \ # for lua support +cmake -DLUAJIT_INCLUDE_DIR=`pkg-config --variable=includedir luajit` \ # for lua support .. make sudo make install @@ -461,13 +460,13 @@ mkdir llvm-build cd llvm-build cmake3 -G "Unix Makefiles" -DLLVM_TARGETS_TO_BUILD="BPF;X86" \ - -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr ../llvm-7.0.1.src + -DCMAKE_BUILD_TYPE=Release ../llvm-7.0.1.src make sudo make install cd ../clang-build cmake3 -G "Unix Makefiles" -DLLVM_TARGETS_TO_BUILD="BPF;X86" \ - -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr ../cfe-7.0.1.src + -DCMAKE_BUILD_TYPE=Release ../cfe-7.0.1.src make sudo make install cd .. @@ -489,7 +488,7 @@ For permanently enable scl environment, please check https://access.redhat.com/s ``` git clone https://github.com/iovisor/bcc.git mkdir bcc/build; cd bcc/build -cmake .. -DCMAKE_INSTALL_PREFIX=/usr +cmake .. make sudo make install ``` @@ -522,7 +521,7 @@ tar xf clang* git clone https://github.com/iovisor/bcc.git pushd . mkdir bcc/build; cd bcc/build -cmake3 .. -DCMAKE_INSTALL_PREFIX=/usr +cmake3 .. time make sudo make install popd From f82ea454ea55ad73ee3284a0bd6fc3b45a7d73a8 Mon Sep 17 00:00:00 2001 From: Alban Crequy Date: Wed, 18 Mar 2020 16:15:02 +0100 Subject: [PATCH 057/278] tools: add option --cgroupmap to profile.py --- man/man8/profile.8 | 11 +++++++++-- tools/profile.py | 19 +++++++++++++++++++ tools/profile_example.txt | 16 ++++++++++++++-- 3 files changed, 42 insertions(+), 4 deletions(-) diff --git a/man/man8/profile.8 b/man/man8/profile.8 index 88311e7e2..823ff6996 100644 --- a/man/man8/profile.8 +++ b/man/man8/profile.8 @@ -1,9 +1,9 @@ -.TH profile 8 "2016-07-17" "USER COMMANDS" +.TH profile 8 "2020-03-18" "USER COMMANDS" .SH NAME profile \- Profile CPU usage by sampling stack traces. Uses Linux eBPF/bcc. .SH SYNOPSIS .B profile [\-adfh] [\-p PID | \-L TID] [\-U | \-K] [\-F FREQUENCY | \-c COUNT] -.B [\-\-stack\-storage\-size COUNT] [duration] +.B [\-\-stack\-storage\-size COUNT] [\-\-cgroupmap CGROUPMAP] [duration] .SH DESCRIPTION This is a CPU profiler. It works by taking samples of stack traces at timed intervals. It will help you understand and quantify CPU usage: which code is @@ -62,6 +62,9 @@ The maximum number of unique stack traces that the kernel will count (default \-C cpu Collect stacks only from specified cpu. .TP +\-\-cgroupmap MAPPATH +Profile cgroups in this BPF map only (filtered in-kernel). +.TP duration Duration to trace, in seconds. .SH EXAMPLES @@ -97,6 +100,10 @@ Profile for 5 seconds and output in folded stack format (suitable as input for f Profile kernel stacks only: # .B profile -K +.TP +Profile a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +# +.B profile \-\-cgroupmap /sys/fs/bpf/test01 .SH DEBUGGING See "[unknown]" frames with bogus addresses? This can happen for different reasons. Your best approach is to get Linux perf to work first, and then to diff --git a/tools/profile.py b/tools/profile.py index 11f3e98da..2067933af 100755 --- a/tools/profile.py +++ b/tools/profile.py @@ -72,6 +72,7 @@ def stack_id_err(stack_id): ./profile -L 185 # only profile thread with TID 185 ./profile -U # only show user space stacks (no kernel) ./profile -K # only show kernel space stacks (no user) + ./profile --cgroupmap ./mappath # only trace cgroups in this BPF map """ parser = argparse.ArgumentParser( description="Profile CPU stack traces at a timed interval", @@ -112,6 +113,8 @@ def stack_id_err(stack_id): help="cpu number to run profile on") parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) +parser.add_argument("--cgroupmap", + help="trace cgroups in this BPF map only") # option logic args = parser.parse_args() @@ -143,6 +146,10 @@ def stack_id_err(stack_id): BPF_HASH(counts, struct key_t); BPF_STACK_TRACE(stack_traces, STACK_STORAGE_SIZE); +#if CGROUPSET +BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); +#endif + // This code gets a bit complex. Probably not suitable for casual hacking. int do_perf_event(struct bpf_perf_event_data *ctx) { @@ -156,6 +163,13 @@ def stack_id_err(stack_id): if (!(THREAD_FILTER)) return 0; +#if CGROUPSET + u64 cgroupid = bpf_get_current_cgroup_id(); + if (cgroupset.lookup(&cgroupid) == NULL) { + return 0; + } +#endif + // create map key struct key_t key = {.pid = tgid}; bpf_get_current_comm(&key.name, sizeof(key.name)); @@ -232,6 +246,11 @@ def stack_id_err(stack_id): stack_context = "user + kernel" bpf_text = bpf_text.replace('USER_STACK_GET', user_stack_get) bpf_text = bpf_text.replace('KERNEL_STACK_GET', kernel_stack_get) +if args.cgroupmap: + bpf_text = bpf_text.replace('CGROUPSET', '1') + bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) +else: + bpf_text = bpf_text.replace('CGROUPSET', '0') sample_freq = 0 sample_period = 0 diff --git a/tools/profile_example.txt b/tools/profile_example.txt index 9b1e5c2b9..bb3c5aec9 100644 --- a/tools/profile_example.txt +++ b/tools/profile_example.txt @@ -703,12 +703,21 @@ WARNING: 8 stack traces could not be displayed. Consider increasing --stack-stor Run ./profile -h to see the default. +The --cgroupmap option filters based on a cgroup set. It is meant to be used +with an externally created map. + +# ./profile --cgroupmap /sys/fs/bpf/test01 + +For more details, see docs/filtering_by_cgroups.md + USAGE message: # ./profile -h -usage: profile.py [-h] [-p PID | -L TID] [-U | -K] [-F FREQUENCY | -c COUNT] [-d] [-a] - [-I] [-f] [--stack-storage-size STACK_STORAGE_SIZE] [-C CPU] +usage: profile.py [-h] [-p PID | -L TID] [-U | -K] [-F FREQUENCY | -c COUNT] + [-d] [-a] [-I] [-f] + [--stack-storage-size STACK_STORAGE_SIZE] [-C CPU] + [--cgroupmap CGROUPMAP] [duration] Profile CPU stack traces at a timed interval @@ -739,6 +748,8 @@ optional arguments: the number of unique stack traces that can be stored and displayed (default 16384) -C CPU, --cpu CPU cpu number to run profile on + --cgroupmap CGROUPMAP + trace cgroups in this BPF map only examples: ./profile # profile stack traces at 49 Hertz until Ctrl-C @@ -750,3 +761,4 @@ examples: ./profile -L 185 # only profile thread with TID 185 ./profile -U # only show user space stacks (no kernel) ./profile -K # only show kernel space stacks (no user) + ./profile --cgroupmap ./mappath # only trace cgroups in this BPF map From e1d53a3ab329ee3504dd58db09859baea0ca724a Mon Sep 17 00:00:00 2001 From: Dale Hamel Date: Thu, 12 Mar 2020 15:02:09 -0400 Subject: [PATCH 058/278] Do not prepend /proc multiple times in bcc_resolve_symname --- src/cc/bcc_syms.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cc/bcc_syms.cc b/src/cc/bcc_syms.cc index 45d3f2c53..fe9853df2 100644 --- a/src/cc/bcc_syms.cc +++ b/src/cc/bcc_syms.cc @@ -730,7 +730,7 @@ int bcc_resolve_symname(const char *module, const char *symname, } if (sym->module == NULL) return -1; - if (pid != 0 && pid != -1) { + if (pid != 0 && pid != -1 && strstr(sym->module, "/proc") != sym->module){ char *temp = (char*)sym->module; sym->module = strdup(tfm::format("/proc/%d/root%s", pid, sym->module).c_str()); free(temp); From 1cd3952b7c2bc7ab0e545f42711402b9f8fe65d8 Mon Sep 17 00:00:00 2001 From: Dale Hamel Date: Fri, 13 Mar 2020 19:45:24 -0400 Subject: [PATCH 059/278] Add regression test for bcc resolve symbol names --- tests/cc/test_usdt_probes.cc | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/cc/test_usdt_probes.cc b/tests/cc/test_usdt_probes.cc index bcae53a61..79beeca8c 100644 --- a/tests/cc/test_usdt_probes.cc +++ b/tests/cc/test_usdt_probes.cc @@ -362,5 +362,11 @@ TEST_CASE("test probing running Ruby process in namespaces", res = bpf.detach_usdt(u, ruby_pid); REQUIRE(res.code() == 0); + + struct bcc_symbol sym; + std::string pid_root= "/proc/" + std::to_string(ruby_pid) + "/root/"; + std::string module = pid_root + "usr/local/bin/ruby"; + REQUIRE(bcc_resolve_symname(module.c_str(), "rb_gc_mark", 0x0, ruby_pid, nullptr, &sym) == 0); + REQUIRE(std::string(sym.module).find(pid_root, 1) == std::string::npos); } } From c2772a334bd10f6e7f66b7d79c269ab9ca5e525c Mon Sep 17 00:00:00 2001 From: Wenbo Zhang Date: Wed, 18 Mar 2020 01:48:59 -0400 Subject: [PATCH 060/278] libbpf-tools: add CO-RE xfsslower Signed-off-by: Wenbo Zhang --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 2 +- libbpf-tools/xfsslower.bpf.c | 160 +++++++++++++++++++++ libbpf-tools/xfsslower.c | 262 +++++++++++++++++++++++++++++++++++ libbpf-tools/xfsslower.h | 24 ++++ 5 files changed, 448 insertions(+), 1 deletion(-) create mode 100644 libbpf-tools/xfsslower.bpf.c create mode 100644 libbpf-tools/xfsslower.c create mode 100644 libbpf-tools/xfsslower.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 2e888747e..5199edda3 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -2,3 +2,4 @@ /drsnoop /opensnoop /runqslower +/xfsslower diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 1d2b153af..0f83b02a0 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -9,7 +9,7 @@ INCLUDES := -I$(OUTPUT) CFLAGS := -g -O2 -Wall ARCH := $(shell uname -m | sed 's/x86_64/x86/') -APPS = drsnoop opensnoop runqslower +APPS = drsnoop opensnoop runqslower xfsslower .PHONY: all all: $(APPS) diff --git a/libbpf-tools/xfsslower.bpf.c b/libbpf-tools/xfsslower.bpf.c new file mode 100644 index 000000000..a73a2dc1d --- /dev/null +++ b/libbpf-tools/xfsslower.bpf.c @@ -0,0 +1,160 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include +#include +#include +#include "xfsslower.h" + +#define NULL 0 + +const volatile pid_t targ_tgid = 0; +const volatile __u64 min_lat = 0; + +struct piddata { + u64 ts; + loff_t start; + loff_t end; + struct file *fp; +}; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, 8192); + __type(key, u32); + __type(value, struct piddata); +} start SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY); + __uint(key_size, sizeof(u32)); + __uint(value_size, sizeof(u32)); +} events SEC(".maps"); + +static __always_inline int +probe_entry(struct file *fp, loff_t s, loff_t e) +{ + u64 id = bpf_get_current_pid_tgid(); + struct piddata piddata; + u32 tgid = id >> 32; + u32 pid = id; + + if (!fp) + return 0; + if (targ_tgid && targ_tgid != tgid) + return 0; + + piddata.ts = bpf_ktime_get_ns(); + piddata.start = s; + piddata.end = e; + piddata.fp = fp; + bpf_map_update_elem(&start, &pid, &piddata, 0); + return 0; +} + +SEC("kprobe/xfs_file_read_iter") +int BPF_KPROBE(kprobe__xfs_file_read_iter, struct kiocb *iocb) +{ + struct file *fp = BPF_CORE_READ(iocb, ki_filp); + loff_t start = BPF_CORE_READ(iocb, ki_pos); + + return probe_entry(fp, start, 0); +} + +SEC("kprobe/xfs_file_write_iter") +int BPF_KPROBE(kprobe__xfs_file_write_iter, struct kiocb *iocb) +{ + struct file *fp = BPF_CORE_READ(iocb, ki_filp); + loff_t start = BPF_CORE_READ(iocb, ki_pos); + + return probe_entry(fp, start, 0); +} + +SEC("kprobe/xfs_file_open") +int BPF_KPROBE(kprobe__xfs_file_open, struct inode *inode, struct file *file) +{ + return probe_entry(file, 0, 0); +} + +SEC("kprobe/xfs_file_fsync") +int BPF_KPROBE(kprobe__xfs_file_fsync, struct file *file, loff_t start, + loff_t end) +{ + return probe_entry(file, start, end); +} + +static __always_inline int +probe_exit(struct pt_regs *ctx, char type, ssize_t size) +{ + u64 id = bpf_get_current_pid_tgid(); + u64 end_ns = bpf_ktime_get_ns(); + struct piddata *piddatap; + struct event event = {}; + struct dentry *dentry; + const u8 *qs_name_ptr; + u32 tgid = id >> 32; + struct file *fp; + u32 pid = id; + u64 delta_us; + u32 qs_len; + + if (targ_tgid && targ_tgid != tgid) + return 0; + + piddatap = bpf_map_lookup_elem(&start, &pid); + if (!piddatap) + return 0; /* missed entry */ + + delta_us = (end_ns - piddatap->ts) / 1000; + bpf_map_delete_elem(&start, &pid); + + if ((s64)delta_us < 0 || delta_us <= min_lat * 1000) + return 0; + + fp = piddatap->fp; + dentry = BPF_CORE_READ(fp, f_path.dentry); + qs_len = BPF_CORE_READ(dentry, d_name.len); + qs_name_ptr = BPF_CORE_READ(dentry, d_name.name); + bpf_probe_read_str(&event.file, sizeof(event.file), qs_name_ptr); + bpf_get_current_comm(&event.task, sizeof(event.task)); + event.delta_us = delta_us; + event.end_ns = end_ns; + event.offset = piddatap->start; + if (type != TRACE_FSYNC) + event.size = size; + else + event.size = piddatap->end - piddatap->start; + event.type = type; + event.tgid = tgid; + + /* output */ + bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, + &event, sizeof(event)); + return 0; +} + +SEC("kretprobe/xfs_file_read_iter") +int BPF_KRETPROBE(kretprobe__xfs_file_read_iters, ssize_t ret) +{ + return probe_exit(ctx, TRACE_READ, ret); +} + +SEC("kretprobe/xfs_file_write_iter") +int BPF_KRETPROBE(kretprobe__xfs_file_write_iter, ssize_t ret) +{ + return probe_exit(ctx, TRACE_WRITE, ret); +} + +SEC("kretprobe/xfs_file_open") +int BPF_KRETPROBE(kretprobe__xfs_file_open) +{ + return probe_exit(ctx, TRACE_OPEN, 0); +} + +SEC("kretprobe/xfs_file_fsync") +int BPF_KRETPROBE(kretprobe__xfs_file_sync) +{ + return probe_exit(ctx, TRACE_FSYNC, 0); +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/xfsslower.c b/libbpf-tools/xfsslower.c new file mode 100644 index 000000000..b525eff04 --- /dev/null +++ b/libbpf-tools/xfsslower.c @@ -0,0 +1,262 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on xfsslower(8) from BCC by Brendan Gregg & Dina Goldshtein. +// 9-Mar-2020 Wenbo Zhang Created this. +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "xfsslower.h" +#include "xfsslower.skel.h" +#include "trace_helpers.h" + +#define PERF_BUFFER_PAGES 64 +#define PERF_BUFFER_TIME_MS 10 +#define PERF_POLL_TIMEOUT_MS 100 + +#define NSEC_PER_SEC 1000000000ULL + +static struct env { + pid_t pid; + time_t duration; + __u64 min_lat; + bool csv; + bool verbose; +} env = { + .min_lat = 10000, +}; + +const char *argp_program_version = "xfsslower 0.1"; +const char *argp_program_bug_address = ""; +const char argp_program_doc[] = +"Trace common XFS file operations slower than a threshold.\n" +"\n" +"Usage: xfslower [--help] [-p PID] [-m MIN] [-d DURATION] [-c]\n" +"\n" +"EXAMPLES:\n" +" xfsslower # trace operations slower than 10 ms (default)" +" xfsslower 0 # trace all operations (warning: verbose)\n" +" xfsslower -p 123 # trace pid 123\n" +" xfsslower -c -d 1 # ... 1s, parsable output (csv)"; + +static const struct argp_option opts[] = { + { "csv", 'c', NULL, 0, "Output as csv" }, + { "duration", 'd', "DURATION", 0, "Total duration of trace in seconds" }, + { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help"}, + { "pid", 'p', "PID", 0, "Process PID to trace" }, + { "min", 'm', "MIN", 0, "Min latency of trace in ms (default 10)" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + long long min_lat; + time_t duration; + int pid; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'h': + argp_usage(state); + break; + case 'c': + env.csv = true; + break; + case 'd': + errno = 0; + duration = strtol(arg, NULL, 10); + if (errno || duration <= 0) { + fprintf(stderr, "invalid DURATION: %s\n", arg); + argp_usage(state); + } + env.duration = duration; + break; + case 'm': + errno = 0; + min_lat = strtoll(arg, NULL, 10); + if (errno || min_lat < 0) { + fprintf(stderr, "invalid delay (in ms): %s\n", arg); + } + env.min_lat = min_lat; + break; + case 'p': + errno = 0; + pid = strtol(arg, NULL, 10); + if (errno || pid <= 0) { + fprintf(stderr, "invalid PID: %s\n", arg); + argp_usage(state); + } + env.pid = pid; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static int bump_memlock_rlimit(void) +{ + struct rlimit rlim_new = { + .rlim_cur = RLIM_INFINITY, + .rlim_max = RLIM_INFINITY, + }; + + return setrlimit(RLIMIT_MEMLOCK, &rlim_new); +} + +void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) +{ + const struct event *e = data; + struct tm *tm; + char ts[32]; + time_t t; + + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + + if (env.csv) { + printf("%lld,%s,%d,%c,", e->end_ns, e->task, e->tgid, e->type); + if (e->size == LLONG_MAX) + printf("LL_MAX,"); + else + printf("%ld,", e->size); + printf("%lld,%lld,%s\n", e->offset, e->delta_us, e->file); + } else { + printf("%-8s %-14.14s %-6d %c ", ts, e->task, e->tgid, e->type); + if (e->size == LLONG_MAX) + printf("%-7s ", "LL_MAX"); + else + printf("%-7ld ", e->size); + printf("%-8lld %7.2f %s\n", e->offset / 1024, + (double)e->delta_us / 1000, e->file); + } +} + +void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt) +{ + fprintf(stderr, "lost %llu events on CPU #%d\n", lost_cnt, cpu); +} + +uint64_t get_ktime_ns(void) +{ + struct timespec ts; + + clock_gettime(CLOCK_MONOTONIC, &ts); + return ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec; +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct perf_buffer_opts pb_opts; + struct perf_buffer *pb = NULL; + struct xfsslower_bpf *obj; + __u64 time_end = 0; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = xfsslower_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + return 1; + } + + /* initialize global data (filtering options) */ + obj->rodata->min_lat = env.min_lat; + obj->rodata->targ_tgid = env.pid; + + err = xfsslower_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + err = xfsslower_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs\n"); + goto cleanup; + } + + if (env.csv) + printf("ENDTIME_us,TASK,PID,TYPE,BYTES,OFFSET_b,LATENCY_us,FILE"); + else { + if (env.min_lat) + printf("Tracing XFS operations slower than %llu ms", + env.min_lat); + else + printf("Tracing XFS operations"); + if (env.duration) + printf(" for %ld secs.\n", env.duration); + else + printf("... Hit Ctrl-C to end.\n"); + printf("%-8s %-14s %-6s %1s %-7s %-8s %7s %s", + "TIME", "COMM", "PID", "T", "BYTES", "OFF_KB", "LAT(ms)", + "FILENAME\n"); + } + + pb_opts.sample_cb = handle_event; + pb_opts.lost_cb = handle_lost_events; + pb = perf_buffer__new(bpf_map__fd(obj->maps.events), PERF_BUFFER_PAGES, + &pb_opts); + err = libbpf_get_error(pb); + if (err) { + pb = NULL; + fprintf(stderr, "failed to open perf buffer: %d\n", err); + goto cleanup; + } + + /* setup duration */ + if (env.duration) + time_end = get_ktime_ns() + env.duration * NSEC_PER_SEC; + + /* main: poll */ + while (1) { + usleep(PERF_BUFFER_TIME_MS * 1000); + if ((err = perf_buffer__poll(pb, PERF_POLL_TIMEOUT_MS)) < 0) + break; + if (env.duration && get_ktime_ns() > time_end) + goto cleanup; + } + fprintf(stderr, "failed with polling perf buffer: %d\n", err); + +cleanup: + perf_buffer__free(pb); + xfsslower_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/xfsslower.h b/libbpf-tools/xfsslower.h new file mode 100644 index 000000000..76860fea0 --- /dev/null +++ b/libbpf-tools/xfsslower.h @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __XFSSLOWER_H +#define __XFSSLOWER_H + +#define DNAME_INLINE_LEN 32 +#define TASK_COMM_LEN 16 + +#define TRACE_READ 'R' +#define TRACE_WRITE 'W' +#define TRACE_OPEN 'O' +#define TRACE_FSYNC 'F' + +struct event { + char file[DNAME_INLINE_LEN]; + char task[TASK_COMM_LEN]; + __u64 delta_us; + __u64 end_ns; + __s64 offset; + ssize_t size; + pid_t tgid; + char type; +}; + +#endif /* __DRSNOOP_H */ From 510fc7425ccd0bc53d53a56ae847d786eb15e1ce Mon Sep 17 00:00:00 2001 From: Alban Crequy Date: Thu, 19 Mar 2020 14:07:38 +0100 Subject: [PATCH 061/278] opensnoop: fix --cgroupmap with kfunc Commit c347fe6c9f75 ("Support kfunc in opensnoop.py") introduces an alternative probe on do_sys_open() with kfuncs instead of kprobes. This new implementation is used if the kernel supports it. But it removed the --cgroupmap filter added in commit b2aa29fa3269 ("tools: cgroup filtering in execsnoop/opensnoop"). This patch adds the --cgroupmap filter in the kfunc implementation. --- tools/opensnoop.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tools/opensnoop.py b/tools/opensnoop.py index 4f94d01d5..b28d7d556 100755 --- a/tools/opensnoop.py +++ b/tools/opensnoop.py @@ -177,6 +177,12 @@ PID_TID_FILTER UID_FILTER FLAGS_FILTER +#if CGROUPSET + u64 cgroupid = bpf_get_current_cgroup_id(); + if (cgroupset.lookup(&cgroupid) == NULL) { + return 0; + } +#endif struct data_t data = {}; bpf_get_current_comm(&data.comm, sizeof(data.comm)); From 35c9940ee7297eafa7d8bcc8d9cda29a3b17a25b Mon Sep 17 00:00:00 2001 From: Joey Freeland Date: Sun, 22 Mar 2020 15:36:42 -0700 Subject: [PATCH 062/278] chore: include Amazon Linux 2 binary option in INSTALL --- INSTALL.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/INSTALL.md b/INSTALL.md index dc9e4d2ca..108dc0f4a 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -9,6 +9,7 @@ - [openSUSE](#opensuse---binary) - [RHEL](#rhel---binary) - [Amazon Linux 1](#Amazon-Linux-1---Binary) + - [Amazon Linux 2](#Amazon-Linux-2---Binary) * [Source](#source) - [Debian](#debian---source) - [Ubuntu](#ubuntu---source) @@ -221,6 +222,15 @@ sudo yum install kernel-devel-$(uname -r | cut -d'.' -f1-5) sudo yum install bcc ``` +## Amazon Linux 2 - Binary +Use case 1. Install BCC for your AMI's default kernel (no reboot required): + Tested on Amazon Linux AMI release 2020.03 (kernel 4.14.154-128.181.amzn2.x86_64) +``` +sudo amazon-linux-extras enable BCC +sudo yum install kernel-devel-$(uname -r) +sudo yum install bcc +``` + # Source ## libbpf Submodule From 6b8a89673dbba9b9203a6555735e451dd9477836 Mon Sep 17 00:00:00 2001 From: Jerome Marchand Date: Thu, 19 Mar 2020 14:40:15 +0100 Subject: [PATCH 063/278] tools: fix alignment of ipv6_key_t in tcptop Fixes the following error on aarch64: bpf: Failed to load program: Permission denied ; struct sock *sk = ctx->regs[0]; int copied = ctx->regs[1]; 0: (79) r8 = *(u64 *)(r1 +8) ... ; struct ipv6_key_t ipv6_key = {.pid = pid}; 79: (63) *(u32 *)(r10 -48) = r7 ; struct ipv6_key_t ipv6_key = {.pid = pid}; 80: (7b) *(u64 *)(r10 +8) = r9 invalid stack off=8 size=8 processed 96 insns (limit 1000000) max_states_per_insn 0 total_states 7 peak_states 7 mark_read 4 --- tools/tcptop.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/tcptop.py b/tools/tcptop.py index 2d4b7572e..9fb3ca2b3 100755 --- a/tools/tcptop.py +++ b/tools/tcptop.py @@ -88,11 +88,12 @@ def range_check(string): BPF_HASH(ipv4_recv_bytes, struct ipv4_key_t); struct ipv6_key_t { - u32 pid; unsigned __int128 saddr; unsigned __int128 daddr; + u32 pid; u16 lport; u16 dport; + u64 __pad__; }; BPF_HASH(ipv6_send_bytes, struct ipv6_key_t); BPF_HASH(ipv6_recv_bytes, struct ipv6_key_t); From 1b0fe40663e48b315e75a9b1ed74820207f76658 Mon Sep 17 00:00:00 2001 From: Mark Kogan Date: Tue, 24 Mar 2020 15:13:12 +0200 Subject: [PATCH 064/278] Change the default sort order to Descending currently with ascending sort the useful information is commonly beyond the bottom of the terminal window and it is necessary to reverse the sort manually every execution. Signed-off-by: Mark Kogan --- tools/cachetop.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/cachetop.py b/tools/cachetop.py index 00b11a8c8..803e2a06b 100755 --- a/tools/cachetop.py +++ b/tools/cachetop.py @@ -136,7 +136,7 @@ def handle_loop(stdscr, args): stdscr.nodelay(1) # set default sorting field sort_field = FIELDS.index(DEFAULT_FIELD) - sort_reverse = False + sort_reverse = True # load BPF program bpf_text = """ From 9adda7092054e1637a68e61e391ac755416a2fb1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mauricio=20V=C3=A1squez?= Date: Thu, 26 Mar 2020 14:36:22 -0500 Subject: [PATCH 065/278] tools/capable: fix compilation error MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 9d7feeed87c5 ("tools: add option --unique to capable.py") introduced a compilation error when the --unique flag is passed. Signed-off-by: Mauricio Vásquez --- tools/capable.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/capable.py b/tools/capable.py index c19cddb93..3852e2247 100755 --- a/tools/capable.py +++ b/tools/capable.py @@ -193,7 +193,7 @@ def __getattr__(self, name): struct repeat_t repeat = {0,}; repeat.cap = cap; #if CGROUPSET - repeat.cgroupid = bpf_get_current_cgroup_id(), + repeat.cgroupid = bpf_get_current_cgroup_id(); #else repeat.tgid = tgid; #endif From 85f5e7d5673e3273f61550d806d348626dffc140 Mon Sep 17 00:00:00 2001 From: Wenbo Zhang Date: Wed, 25 Mar 2020 03:48:35 -0400 Subject: [PATCH 066/278] libbpf-tools: add CO-RE filelife Signed-off-by: Wenbo Zhang --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 2 +- libbpf-tools/filelife.bpf.c | 82 +++++++++++++++++ libbpf-tools/filelife.c | 172 ++++++++++++++++++++++++++++++++++++ libbpf-tools/filelife.h | 15 ++++ 5 files changed, 271 insertions(+), 1 deletion(-) create mode 100644 libbpf-tools/filelife.bpf.c create mode 100644 libbpf-tools/filelife.c create mode 100644 libbpf-tools/filelife.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 5199edda3..b0d4470f3 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -1,5 +1,6 @@ /.output /drsnoop +/filelife /opensnoop /runqslower /xfsslower diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 0f83b02a0..aa73ba5ae 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -9,7 +9,7 @@ INCLUDES := -I$(OUTPUT) CFLAGS := -g -O2 -Wall ARCH := $(shell uname -m | sed 's/x86_64/x86/') -APPS = drsnoop opensnoop runqslower xfsslower +APPS = drsnoop filelife opensnoop runqslower xfsslower .PHONY: all all: $(APPS) diff --git a/libbpf-tools/filelife.bpf.c b/libbpf-tools/filelife.bpf.c new file mode 100644 index 000000000..04217a697 --- /dev/null +++ b/libbpf-tools/filelife.bpf.c @@ -0,0 +1,82 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include +#include +#include +#include "filelife.h" + +const volatile pid_t targ_tgid = 0; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, 8192); + __type(key, struct dentry *); + __type(value, u64); +} start SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY); + __uint(key_size, sizeof(u32)); + __uint(value_size, sizeof(u32)); +} events SEC(".maps"); + +static __always_inline int +probe_create(struct inode *dir, struct dentry *dentry) +{ + u64 id = bpf_get_current_pid_tgid(); + u32 tgid = id >> 32; + u64 ts; + + if (targ_tgid && targ_tgid != tgid) + return 0; + + ts = bpf_ktime_get_ns(); + bpf_map_update_elem(&start, &dentry, &ts, 0); + return 0; +} + +SEC("kprobe/vfs_create") +int BPF_KPROBE(kprobe__vfs_create, struct inode *dir, struct dentry *dentry) +{ + return probe_create(dir, dentry); +} + +SEC("kprobe/security_inode_create") +int BPF_KPROBE(kprobe__security_inode_create, struct inode *dir, + struct dentry *dentry) +{ + return probe_create(dir, dentry); +} + +SEC("kprobe/vfs_unlink") +int BPF_KPROBE(kprobe__vfs_unlink, struct inode *dir, struct dentry *dentry) +{ + u64 id = bpf_get_current_pid_tgid(); + struct event event = {}; + const u8 *qs_name_ptr; + u32 tgid = id >> 32; + u64 *tsp, delta_ns; + u32 qs_len; + + tsp = bpf_map_lookup_elem(&start, &dentry); + if (!tsp) + return 0; // missed entry + + delta_ns = bpf_ktime_get_ns() - *tsp; + bpf_map_delete_elem(&start, &dentry); + + qs_name_ptr = BPF_CORE_READ(dentry, d_name.name); + qs_len = BPF_CORE_READ(dentry, d_name.len); + bpf_probe_read_str(&event.file, sizeof(event.file), qs_name_ptr); + bpf_get_current_comm(&event.task, sizeof(event.task)); + event.delta_ns = delta_ns; + event.tgid = tgid; + + /* output */ + bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, + &event, sizeof(event)); + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/filelife.c b/libbpf-tools/filelife.c new file mode 100644 index 000000000..f21a68455 --- /dev/null +++ b/libbpf-tools/filelife.c @@ -0,0 +1,172 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on filelife(8) from BCC by Brendan Gregg & Allan McAleavy. +// 20-Mar-2020 Wenbo Zhang Created this. +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "filelife.h" +#include "filelife.skel.h" + +#define PERF_BUFFER_PAGES 16 +#define PERF_POLL_TIMEOUT_MS 100 + +static struct env { + pid_t pid; + bool verbose; +} env = { }; + +const char *argp_program_version = "filelife 0.1"; +const char *argp_program_bug_address = ""; +const char argp_program_doc[] = +"Trace the lifespan of short-lived files.\n" +"\n" +"USAGE: filelife [-p PID]\n" +"\n" +"EXAMPLES:\n" +" filelife # trace all events\n" +" filelife -p 123 # trace pid 123\n"; + +static const struct argp_option opts[] = { + { "pid", 'p', "PID", 0, "Process PID to trace" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + int pid; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'p': + errno = 0; + pid = strtol(arg, NULL, 10); + if (errno || pid <= 0) { + fprintf(stderr, "invalid PID: %s\n", arg); + argp_usage(state); + } + env.pid = pid; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static int bump_memlock_rlimit(void) +{ + struct rlimit rlim_new = { + .rlim_cur = RLIM_INFINITY, + .rlim_max = RLIM_INFINITY, + }; + + return setrlimit(RLIMIT_MEMLOCK, &rlim_new); +} + +void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) +{ + const struct event *e = data; + struct tm *tm; + char ts[32]; + time_t t; + + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + printf("%-8s %-6d %-16s %-7.2f %s\n", + ts, e->tgid, e->task, (double)e->delta_ns / 1000000000, + e->file); +} + +void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt) +{ + fprintf(stderr, "lost %llu events on CPU #%d\n", lost_cnt, cpu); +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct perf_buffer_opts pb_opts; + struct perf_buffer *pb = NULL; + struct filelife_bpf *obj; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = filelife_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + return 1; + } + + /* initialize global data (filtering options) */ + obj->rodata->targ_tgid = env.pid; + + err = filelife_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + err = filelife_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs\n"); + goto cleanup; + } + + printf("Tracing the lifespan of short-lived files ... Hit Ctrl-C to end.\n"); + printf("%-8s %-6s %-16s %-7s %s\n", "TIME", "PID", "COMM", "AGE(s)", "FILE"); + + pb_opts.sample_cb = handle_event; + pb_opts.lost_cb = handle_lost_events; + pb = perf_buffer__new(bpf_map__fd(obj->maps.events), PERF_BUFFER_PAGES, + &pb_opts); + err = libbpf_get_error(pb); + if (err) { + pb = NULL; + fprintf(stderr, "failed to open perf buffer: %d\n", err); + goto cleanup; + } + + while ((err = perf_buffer__poll(pb, PERF_POLL_TIMEOUT_MS)) >= 0) + ; + fprintf(stderr, "error polling perf buffer: %d\n", err); + +cleanup: + perf_buffer__free(pb); + filelife_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/filelife.h b/libbpf-tools/filelife.h new file mode 100644 index 000000000..d9ea7fc94 --- /dev/null +++ b/libbpf-tools/filelife.h @@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __FILELIFE_H +#define __FILELIFE_H + +#define DNAME_INLINE_LEN 32 +#define TASK_COMM_LEN 16 + +struct event { + __u64 delta_ns; + pid_t tgid; + char file[DNAME_INLINE_LEN]; + char task[TASK_COMM_LEN]; +}; + +#endif /* __FILELIFE_H */ From e323254466575e03d753a33c77667011626c389f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C5=82=20Gregorczyk?= Date: Wed, 25 Mar 2020 13:57:48 -0400 Subject: [PATCH 067/278] make -lrt linking optional On Android there is no standalone rt library and relevant symbols are provided by libc (bionic). --- introspection/CMakeLists.txt | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/introspection/CMakeLists.txt b/introspection/CMakeLists.txt index c5983b20d..4328ee117 100644 --- a/introspection/CMakeLists.txt +++ b/introspection/CMakeLists.txt @@ -6,8 +6,14 @@ include_directories(${CMAKE_SOURCE_DIR}/src/cc/api) include_directories(${CMAKE_SOURCE_DIR}/src/cc/libbpf/include/uapi) option(INSTALL_INTROSPECTION "Install BPF introspection tools" ON) +option(BPS_LINK_RT "Pass -lrt to linker when linking bps tool" ON) + +set(bps_libs_to_link bpf-static elf z) +if(BPS_LINK_RT) +list(APPEND bps_libs_to_link rt) +endif() add_executable(bps bps.c) -target_link_libraries(bps bpf-static elf rt z) +target_link_libraries(bps ${bps_libs_to_link}) install (TARGETS bps DESTINATION share/bcc/introspection) From 915d6d7617b20d4af8360c1d53efe8abd8697efa Mon Sep 17 00:00:00 2001 From: Devidas Jadhav Date: Fri, 27 Mar 2020 21:30:20 +0530 Subject: [PATCH 068/278] correcting input to hex using ord funtion --- examples/networking/http_filter/http-parse-complete.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/networking/http_filter/http-parse-complete.py b/examples/networking/http_filter/http-parse-complete.py index abf5f0f2c..324232d54 100644 --- a/examples/networking/http_filter/http-parse-complete.py +++ b/examples/networking/http_filter/http-parse-complete.py @@ -34,7 +34,7 @@ def toHex(s): lst = "" for ch in s: - hv = hex(ch).replace('0x', '') + hv = hex(ord(ch)).replace('0x', '') if len(hv) == 1: hv = '0' + hv lst = lst + hv From 472f9b3bd6bcc63e6e959148320eb76184c51870 Mon Sep 17 00:00:00 2001 From: Devidas Jadhav Date: Sat, 28 Mar 2020 20:07:28 +0530 Subject: [PATCH 069/278] mallocstacks: validating before stacktrace walk --- examples/tracing/mallocstacks.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/examples/tracing/mallocstacks.py b/examples/tracing/mallocstacks.py index 4b10e6c29..15706db33 100755 --- a/examples/tracing/mallocstacks.py +++ b/examples/tracing/mallocstacks.py @@ -67,5 +67,6 @@ for k, v in reversed(sorted(calls.items(), key=lambda c: c[1].value)): print("%d bytes allocated at:" % v.value) - for addr in stack_traces.walk(k.value): - printb(b"\t%s" % b.sym(addr, pid, show_offset=True)) + if k.value > 0 : + for addr in stack_traces.walk(k.value): + printb(b"\t%s" % b.sym(addr, pid, show_offset=True)) From 4f6ecea67b58699b52c315088c5829448add57c5 Mon Sep 17 00:00:00 2001 From: Jean-Philippe Menil Date: Thu, 26 Mar 2020 18:51:25 +0100 Subject: [PATCH 070/278] http-parse-simple.py: fix wrong start position Signed-off-by: Jean-Philippe Menil --- examples/networking/http_filter/http-parse-simple.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/networking/http_filter/http-parse-simple.py b/examples/networking/http_filter/http-parse-simple.py index b702393d1..9d1e9aab0 100644 --- a/examples/networking/http_filter/http-parse-simple.py +++ b/examples/networking/http_filter/http-parse-simple.py @@ -144,7 +144,7 @@ def help(): #print first line of the HTTP GET/POST request #line ends with 0xOD 0xOA (\r\n) #(if we want to print all the header print until \r\n\r\n) - for i in range (payload_offset-1,len(packet_bytearray)-1): + for i in range (payload_offset,len(packet_bytearray)-1): if (packet_bytearray[i]== 0x0A): if (packet_bytearray[i-1] == 0x0D): break From ab54de2e4449027f2b4dccd022adc57bec4fd4eb Mon Sep 17 00:00:00 2001 From: Slava Bacherikov Date: Thu, 12 Mar 2020 21:16:55 +0200 Subject: [PATCH 071/278] libbpf-tools: CO-RE opensnoop minor improvements * allow passing 0 as valid uid * fix type for targ_uid * improve uid validation (uid >= 4294967295 now invalid) --- libbpf-tools/opensnoop.bpf.c | 10 +++++++--- libbpf-tools/opensnoop.c | 8 +++++--- libbpf-tools/opensnoop.h | 1 + 3 files changed, 13 insertions(+), 6 deletions(-) diff --git a/libbpf-tools/opensnoop.bpf.c b/libbpf-tools/opensnoop.bpf.c index 44e591113..8082c3fde 100644 --- a/libbpf-tools/opensnoop.bpf.c +++ b/libbpf-tools/opensnoop.bpf.c @@ -10,7 +10,7 @@ const volatile __u64 min_us = 0; const volatile pid_t targ_pid = 0; const volatile pid_t targ_tgid = 0; -const volatile pid_t targ_uid = 0; +const volatile uid_t targ_uid = 0; const volatile bool targ_failed = false; struct { @@ -26,6 +26,10 @@ struct { __uint(value_size, sizeof(u32)); } events SEC(".maps"); +static __always_inline bool valid_uid(uid_t uid) { + return uid != INVALID_UID; +} + static __always_inline int trace_filtered(u32 tgid, u32 pid) { @@ -36,8 +40,8 @@ int trace_filtered(u32 tgid, u32 pid) return 1; if (targ_pid && targ_pid != pid) return 1; - if (targ_uid) { - uid = bpf_get_current_uid_gid(); + if (valid_uid(targ_uid)) { + uid = (u32)bpf_get_current_uid_gid(); if (targ_uid != uid) { return 1; } diff --git a/libbpf-tools/opensnoop.c b/libbpf-tools/opensnoop.c index b2d7a88a8..0d7330f9c 100644 --- a/libbpf-tools/opensnoop.c +++ b/libbpf-tools/opensnoop.c @@ -39,7 +39,9 @@ static struct env { bool extended; bool failed; char *name; -} env = {}; +} env = { + .uid = INVALID_UID +}; const char *argp_program_version = "opensnoop 0.1"; const char *argp_program_bug_address = ""; @@ -79,7 +81,7 @@ static const struct argp_option opts[] = { static error_t parse_arg(int key, char *arg, struct argp_state *state) { static int pos_args; - int pid, uid, duration; + long int pid, uid, duration; switch (key) { case 'e': @@ -134,7 +136,7 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) case 'u': errno = 0; uid = strtol(arg, NULL, 10); - if (errno || uid <= 0) { + if (errno || uid < 0 || uid >= INVALID_UID) { fprintf(stderr, "Invalid UID %s\n", arg); argp_usage(state); } diff --git a/libbpf-tools/opensnoop.h b/libbpf-tools/opensnoop.h index a1e0c0c32..70bfdfc06 100644 --- a/libbpf-tools/opensnoop.h +++ b/libbpf-tools/opensnoop.h @@ -4,6 +4,7 @@ #define TASK_COMM_LEN 16 #define NAME_MAX 255 +#define INVALID_UID ((uid_t)-1) struct args_t { const char *fname; From 689f90087e0d59caea63e10be04bcf1172a90c4f Mon Sep 17 00:00:00 2001 From: FUJI Goro Date: Sat, 4 Apr 2020 13:33:57 +0900 Subject: [PATCH 072/278] [C++] add BPF::enable_usdt_all() and disble_usdt_all() to handle all the USDT at once (#2854) * add BPF::enable_usdt_all() to enable all the USDT * add detach_usdt_all() to detach all the USDTs --- examples/cpp/FollyRequestContextSwitch.cc | 4 +- src/cc/api/BPF.cc | 138 +++++++++++++--------- src/cc/api/BPF.h | 5 + tests/cc/test_usdt_probes.cc | 14 +++ 4 files changed, 105 insertions(+), 56 deletions(-) diff --git a/examples/cpp/FollyRequestContextSwitch.cc b/examples/cpp/FollyRequestContextSwitch.cc index a1692e661..d2ff02c54 100644 --- a/examples/cpp/FollyRequestContextSwitch.cc +++ b/examples/cpp/FollyRequestContextSwitch.cc @@ -98,7 +98,7 @@ int main(int argc, char** argv) { return 1; } - auto attach_res = bpf->attach_usdt(u); + auto attach_res = bpf->attach_usdt_all(); if (attach_res.code() != 0) { std::cerr << attach_res.msg() << std::endl; return 1; @@ -114,7 +114,7 @@ int main(int argc, char** argv) { shutdown_handler = [&](int s) { std::cerr << "Terminating..." << std::endl; - bpf->detach_usdt(u); + bpf->detach_usdt_all(); delete bpf; exit(0); }; diff --git a/src/cc/api/BPF.cc b/src/cc/api/BPF.cc index 4bb15918c..1c1242c5b 100644 --- a/src/cc/api/BPF.cc +++ b/src/cc/api/BPF.cc @@ -264,46 +264,61 @@ StatusTuple BPF::attach_uprobe(const std::string& binary_path, return StatusTuple::OK(); } +StatusTuple BPF::attach_usdt_without_validation(const USDT& u, pid_t pid) { + auto& probe = *static_cast<::USDT::Probe*>(u.probe_.get()); + if (!probe.enable(u.probe_func_)) + return StatusTuple(-1, "Unable to enable USDT %s" + u.print_name()); + + bool failed = false; + std::string err_msg; + int cnt = 0; + for (const auto& loc : probe.locations_) { + auto res = attach_uprobe(loc.bin_path_, std::string(), u.probe_func_, + loc.address_, BPF_PROBE_ENTRY, pid); + if (!res.ok()) { + failed = true; + err_msg += "USDT " + u.print_name() + " at " + loc.bin_path_ + + " address " + std::to_string(loc.address_); + err_msg += ": " + res.msg() + "\n"; + break; + } + cnt++; + } + if (failed) { + for (int i = 0; i < cnt; i++) { + auto res = detach_uprobe(probe.locations_[i].bin_path_, std::string(), + probe.locations_[i].address_, BPF_PROBE_ENTRY, pid); + if (!res.ok()) + err_msg += "During clean up: " + res.msg() + "\n"; + } + return StatusTuple(-1, err_msg); + } else { + return StatusTuple::OK(); + } +} + StatusTuple BPF::attach_usdt(const USDT& usdt, pid_t pid) { for (const auto& u : usdt_) { if (u == usdt) { - auto& probe = *static_cast<::USDT::Probe*>(u.probe_.get()); - if (!probe.enable(u.probe_func_)) - return StatusTuple(-1, "Unable to enable USDT " + u.print_name()); - - bool failed = false; - std::string err_msg; - int cnt = 0; - for (const auto& loc : probe.locations_) { - auto res = attach_uprobe(loc.bin_path_, std::string(), u.probe_func_, - loc.address_, BPF_PROBE_ENTRY, pid); - if (res.code() != 0) { - failed = true; - err_msg += "USDT " + u.print_name() + " at " + loc.bin_path_ + - " address " + std::to_string(loc.address_); - err_msg += ": " + res.msg() + "\n"; - break; - } - cnt++; - } - if (failed) { - for (int i = 0; i < cnt; i++) { - auto res = - detach_uprobe(probe.locations_[i].bin_path_, std::string(), - probe.locations_[i].address_, BPF_PROBE_ENTRY, pid); - if (res.code() != 0) - err_msg += "During clean up: " + res.msg() + "\n"; - } - return StatusTuple(-1, err_msg); - } else { - return StatusTuple::OK(); - } + return attach_usdt_without_validation(u, pid); } } return StatusTuple(-1, "USDT %s not found", usdt.print_name().c_str()); } +StatusTuple BPF::attach_usdt_all() { + for (const auto& u : usdt_) { + auto res = attach_usdt_without_validation(u, -1); + if (!res.ok()) { + return res; + } + } + + return StatusTuple::OK(); +} + + StatusTuple BPF::attach_tracepoint(const std::string& tracepoint, const std::string& probe_func) { if (tracepoints_.find(tracepoint) != tracepoints_.end()) @@ -475,38 +490,53 @@ StatusTuple BPF::detach_uprobe(const std::string& binary_path, return StatusTuple::OK(); } +StatusTuple BPF::detach_usdt_without_validation(const USDT& u, pid_t pid) { + auto& probe = *static_cast<::USDT::Probe*>(u.probe_.get()); + bool failed = false; + std::string err_msg; + for (const auto& loc : probe.locations_) { + auto res = detach_uprobe(loc.bin_path_, std::string(), loc.address_, + BPF_PROBE_ENTRY, pid); + if (!res.ok()) { + failed = true; + err_msg += "USDT " + u.print_name() + " at " + loc.bin_path_ + + " address " + std::to_string(loc.address_); + err_msg += ": " + res.msg() + "\n"; + } + } + + if (!probe.disable()) { + failed = true; + err_msg += "Unable to disable USDT " + u.print_name(); + } + + if (failed) + return StatusTuple(-1, err_msg); + else + return StatusTuple::OK(); +} + StatusTuple BPF::detach_usdt(const USDT& usdt, pid_t pid) { for (const auto& u : usdt_) { if (u == usdt) { - auto& probe = *static_cast<::USDT::Probe*>(u.probe_.get()); - bool failed = false; - std::string err_msg; - for (const auto& loc : probe.locations_) { - auto res = detach_uprobe(loc.bin_path_, std::string(), loc.address_, - BPF_PROBE_ENTRY, pid); - if (res.code() != 0) { - failed = true; - err_msg += "USDT " + u.print_name() + " at " + loc.bin_path_ + - " address " + std::to_string(loc.address_); - err_msg += ": " + res.msg() + "\n"; - } - } - - if (!probe.disable()) { - failed = true; - err_msg += "Unable to disable USDT " + u.print_name(); - } - - if (failed) - return StatusTuple(-1, err_msg); - else - return StatusTuple::OK(); + return detach_usdt_without_validation(u, pid); } } return StatusTuple(-1, "USDT %s not found", usdt.print_name().c_str()); } +StatusTuple BPF::detach_usdt_all() { + for (const auto& u : usdt_) { + auto ret = detach_usdt_without_validation(u, -1); + if (!ret.ok()) { + return ret; + } + } + + return StatusTuple::OK(); +} + StatusTuple BPF::detach_tracepoint(const std::string& tracepoint) { auto it = tracepoints_.find(tracepoint); if (it == tracepoints_.end()) diff --git a/src/cc/api/BPF.h b/src/cc/api/BPF.h index 4752ca056..85962fa65 100644 --- a/src/cc/api/BPF.h +++ b/src/cc/api/BPF.h @@ -85,7 +85,9 @@ class BPF { pid_t pid = -1, uint64_t symbol_offset = 0); StatusTuple attach_usdt(const USDT& usdt, pid_t pid = -1); + StatusTuple attach_usdt_all(); StatusTuple detach_usdt(const USDT& usdt, pid_t pid = -1); + StatusTuple detach_usdt_all(); StatusTuple attach_tracepoint(const std::string& tracepoint, const std::string& probe_func); @@ -248,6 +250,9 @@ class BPF { std::string get_uprobe_event(const std::string& binary_path, uint64_t offset, bpf_probe_attach_type type, pid_t pid); + StatusTuple attach_usdt_without_validation(const USDT& usdt, pid_t pid); + StatusTuple detach_usdt_without_validation(const USDT& usdt, pid_t pid); + StatusTuple detach_kprobe_event(const std::string& event, open_probe_t& attr); StatusTuple detach_uprobe_event(const std::string& event, open_probe_t& attr); StatusTuple detach_tracepoint_event(const std::string& tracepoint, diff --git a/tests/cc/test_usdt_probes.cc b/tests/cc/test_usdt_probes.cc index 79beeca8c..2eb4a94ad 100644 --- a/tests/cc/test_usdt_probes.cc +++ b/tests/cc/test_usdt_probes.cc @@ -76,6 +76,20 @@ TEST_CASE("test fine a probe in our own binary with C++ API", "[usdt]") { REQUIRE(res.code() == 0); } +TEST_CASE("test fine probes in our own binary with C++ API", "[usdt]") { + ebpf::BPF bpf; + ebpf::USDT u("/proc/self/exe", "libbcc_test", "sample_probe_1", "on_event"); + + auto res = bpf.init("int on_event() { return 0; }", {}, {u}); + REQUIRE(res.ok()); + + res = bpf.attach_usdt_all(); + REQUIRE(res.ok()); + + res = bpf.detach_usdt_all(); + REQUIRE(res.ok()); +} + TEST_CASE("test fine a probe in our Process with C++ API", "[usdt]") { ebpf::BPF bpf; ebpf::USDT u(::getpid(), "libbcc_test", "sample_probe_1", "on_event"); From 495a4a3403371b3fb1f7049a8cefc996621e61aa Mon Sep 17 00:00:00 2001 From: Casey Callendrello Date: Fri, 3 Apr 2020 10:50:08 +0200 Subject: [PATCH 073/278] examples/tracing: add nflatency - netfilter hook metrics This adds a kprobe / kretprobe for chasing down slow netfilter hooks. Since, often, the slowest hooks are on connection initialization and teardown, it is bucketed by TCP flags. (rather than dive deep in to conntrack) Signed-off-by: Casey Callendrello --- examples/tracing/nflatency.py | 238 ++++++++++++++++++++++++++++++++++ 1 file changed, 238 insertions(+) create mode 100755 examples/tracing/nflatency.py diff --git a/examples/tracing/nflatency.py b/examples/tracing/nflatency.py new file mode 100755 index 000000000..767164909 --- /dev/null +++ b/examples/tracing/nflatency.py @@ -0,0 +1,238 @@ +#!/usr/bin/python3 +# +# nflatency Trace netfilter hook latency. +# +# This attaches a kprobe and kretprobe to nf_hook_slow. +# 2020-04-03 Casey Callendrello / + +import argparse +import sys +import time + +from bcc import BPF + +BPF_SRC = """ +#define KBUILD_MODNAME "bpf_hook_nflatency" +#include +#include +#include +#include +#include +#include + +static struct tcphdr *skb_to_tcphdr(const struct sk_buff *skb) +{ + // unstable API. verify logic in tcp_hdr() -> skb_transport_header(). + return (struct tcphdr *)(skb->head + skb->transport_header); +} + +static inline struct iphdr *skb_to_iphdr(const struct sk_buff *skb) +{ + // unstable API. verify logic in ip_hdr() -> skb_network_header(). + return (struct iphdr *)(skb->head + skb->network_header); +} + +static inline struct ipv6hdr *skb_to_ip6hdr(const struct sk_buff *skb) +{ + // unstable API. verify logic in ip_hdr() -> skb_network_header(). + return (struct ipv6hdr *)(skb->head + skb->network_header); +} + +// for correlating between kprobe and kretprobe +struct start_data { + u8 hook; + u8 pf; // netfilter protocol + u8 tcp_state; + u64 ts; +}; +BPF_PERCPU_ARRAY(sts, struct start_data, 1); + +// the histogram keys +typedef struct nf_lat_key { + u8 proto; // see netfilter.h + u8 hook; + u8 tcp_state; +} nf_lat_key_t; + +typedef struct hist_key { + nf_lat_key_t key; + u64 slot; +} hist_key_t; +BPF_HISTOGRAM(dist, hist_key_t); + + +int kprobe__nf_hook_slow(struct pt_regs *ctx, struct sk_buff *skb, struct nf_hook_state *state) { + struct start_data data = {}; + data.ts = bpf_ktime_get_ns(); + data.hook = state->hook; + data.pf = state->pf; + + COND + + u8 ip_proto; + if (skb->protocol == htons(ETH_P_IP)) { + struct iphdr *ip = skb_to_iphdr(skb); + ip_proto = ip->protocol; + + } else if (skb->protocol == htons(ETH_P_IPV6)) { + struct ipv6hdr *ip = skb_to_ip6hdr(skb); + ip_proto = ip->nexthdr; + } + + data.tcp_state = 0; + if (ip_proto == 0x06) { //tcp + struct tcphdr *tcp = skb_to_tcphdr(skb); + u8 tcpflags = ((u_int8_t *)tcp)[13]; + + // FIN or RST + if (((tcpflags & 1) + (tcpflags & 4)) > 0) { + data.tcp_state = 3; + } + // SYN / SACK + else if ((tcpflags & 0x02) > 0) { + data.tcp_state = 1; + if ((tcpflags & 16) > 0) { // ACK + data.tcp_state = 2; + } + } + } + + u32 idx = 0; + sts.update(&idx, &data); + return 0; +} + +int kretprobe__nf_hook_slow(struct pt_regs *ctx) { + u32 idx = 0; + struct start_data *s; + s = sts.lookup(&idx); + if (!s || s->ts == 0) { + return 0; + } + + s->ts = bpf_ktime_get_ns() - s->ts; + + hist_key_t key = {}; + key.key.hook = s->hook; + key.key.proto = s->pf; + key.key.tcp_state = s->tcp_state; + key.slot = bpf_log2l(s->ts / FACTOR ); + dist.increment(key); + + s->ts = 0; + sts.update(&idx, s); + + return 0; +} +""" + +# constants from netfilter.h +NF_HOOKS = { + 0: "PRE_ROUTING", + 1: "LOCAL_IN", + 2: "FORWARD", + 3: "LOCAL_OUT", + 4: "POST_ROUTING", +} + +NF_PROTOS = { + 0: "UNSPEC", + 1: "INET", + 2: "IPV4", + 3: "ARP", + 5: "NETDEV", + 7: "BRIDGE", + 10: "IPV6", + 12: "DECNET", +} + +TCP_FLAGS = { + 0: "other", + 1: "SYN", + 2: "SACK", + 3: "FIN", +} + +EXAMPLES = """examples: + nflatency # print netfilter latency histograms, 1 second refresh + nflatency -p IPV4 -p IPV6 # print only for ipv4 and ipv6 + nflatency -k PRE_ROUTING # only record the PRE_ROUTING hook + nflatency -i 5 -d 10 # run for 10 seconds, printing every 5 +""" + + +parser = argparse.ArgumentParser( + description="Track latency added by netfilter hooks. Where possible, interesting TCP flags are included", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=EXAMPLES) +parser.add_argument("-p", "--proto", + action='append', + help="record this protocol only (multiple parameters allowed)", + choices=NF_PROTOS.values()) +parser.add_argument("-k", "--hook", + action='append', + help="record this netfilter hook only (multiple parameters allowed)", + choices=NF_HOOKS.values()) +parser.add_argument("-i", "--interval", type=int, + help="summary interval, in seconds. Default is 10, unless --duration is supplied") +parser.add_argument("-d", "--duration", type=int, + help="total duration of trace, in seconds") +parser.add_argument("--nano", action="store_true", + help="bucket by nanoseconds instead of milliseconds") + +def main(): + args = parser.parse_args() + + src = build_src(args) + b = BPF(text=src) + dist = b.get_table("dist") + + seconds = 0 + interval = 0 + if not args.interval: + interval = 1 + if args.duration: + interval = args.duration + else: + interval = args.interval + + sys.stderr.write("Tracing netfilter hooks... Hit Ctrl-C to end.\n") + while 1: + try: + dist.print_log2_hist( + section_header="Bucket", + bucket_fn=lambda k: (k.proto, k.hook, k.tcp_state), + section_print_fn=bucket_desc) + if args.duration and seconds >= args.duration: + sys.exit(0) + seconds += interval + time.sleep(interval) + except KeyboardInterrupt: + sys.exit(1) + + +def build_src(args): + cond_src = "" + if args.proto: + predicate = " || ".join(map(lambda x: "data.pf == NFPROTO_%s" % x, args.proto)) + cond_src = "if (!(%s)) { return 0; }\n" % predicate + if args.hook: + predicate = " || ".join(map(lambda x: "data.hook == NF_INET_%s" % x, args.hook)) + cond_src = "%s if (!(%s)) { return 0;}\n" % (cond_src, predicate) + + factor = "1000" + if args.nano: + factor = "1" + + return BPF_SRC.replace('COND', cond_src).replace('FACTOR', factor) + + +def bucket_desc(bucket): + return "%s %s (tcp %s)" % ( + NF_PROTOS[bucket[0]], + NF_HOOKS[bucket[1]], + TCP_FLAGS[bucket[2]]) + + +if __name__ == "__main__": + main() From 533391eaa94c4b3a148bf801b8aea5bb803c1e9d Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Sun, 5 Apr 2020 22:21:21 -0700 Subject: [PATCH 074/278] add test_lpm_trie.py test test_lpm_trie.py has been in the repo for quite some time, but is not included in the unit test. The issue https://github.com/iovisor/bcc/issues/2860 exposed an issue involved in using together with BTF, which requires the key type to be a structure. Let add it as a unit test so we can be sure lpm_trie map is supported properly by bcc. Signed-off-by: Yonghong Song --- tests/python/CMakeLists.txt | 2 ++ tests/python/test_lpm_trie.py | 26 ++++++++++++++++++++++---- 2 files changed, 24 insertions(+), 4 deletions(-) mode change 100644 => 100755 tests/python/test_lpm_trie.py diff --git a/tests/python/CMakeLists.txt b/tests/python/CMakeLists.txt index f323ac1b3..63a341305 100644 --- a/tests/python/CMakeLists.txt +++ b/tests/python/CMakeLists.txt @@ -85,3 +85,5 @@ add_test(NAME py_test_free_bcc_memory WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_D COMMAND ${TEST_WRAPPER} py_test_free_bcc_memory sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_free_bcc_memory.py) add_test(NAME py_test_rlimit WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_test_rlimit sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_rlimit.py) +add_test(NAME py_test_lpm_trie WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMAND ${TEST_WRAPPER} py_test_lpm_trie sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_lpm_trie.py) diff --git a/tests/python/test_lpm_trie.py b/tests/python/test_lpm_trie.py old mode 100644 new mode 100755 index 560cb4b6c..c95b9cedd --- a/tests/python/test_lpm_trie.py +++ b/tests/python/test_lpm_trie.py @@ -3,10 +3,23 @@ # Licensed under the Apache License, Version 2.0 (the "License") import ctypes as ct -import unittest +import distutils.version +import os +from unittest import main, skipUnless, TestCase from bcc import BPF from netaddr import IPAddress +def kernel_version_ge(major, minor): + # True if running kernel is >= X.Y + version = distutils.version.LooseVersion(os.uname()[2]).version + if version[0] > major: + return True + if version[0] < major: + return False + if minor and version[1] < minor: + return False + return True + class KeyV4(ct.Structure): _fields_ = [("prefixlen", ct.c_uint), ("data", ct.c_ubyte * 4)] @@ -15,10 +28,15 @@ class KeyV6(ct.Structure): _fields_ = [("prefixlen", ct.c_uint), ("data", ct.c_ushort * 8)] -class TestLpmTrie(unittest.TestCase): +@skipUnless(kernel_version_ge(4, 11), "requires kernel >= 4.11") +class TestLpmTrie(TestCase): def test_lpm_trie_v4(self): test_prog1 = """ - BPF_LPM_TRIE(trie, u64, int, 16); + struct key_v4 { + u32 prefixlen; + u32 data[4]; + }; + BPF_LPM_TRIE(trie, struct key_v4, int, 16); """ b = BPF(text=test_prog1) t = b["trie"] @@ -71,4 +89,4 @@ def test_lpm_trie_v6(self): v = t[k] if __name__ == "__main__": - unittest.main() + main() From f35dae07bbe48f6233bf50f05ddbf835cc18c86e Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Sun, 5 Apr 2020 23:15:58 -0700 Subject: [PATCH 075/278] adjust layout string in JIT with llvm11 128bit spec support To fix the issue (https://github.com/iovisor/bcc/issues/2827) which exposed a problem with aarch64 frontend and bpf backend regarding __int128 type, the following llvm patch https://reviews.llvm.org/D76587 landed to explicitly support i128 type in bpf layout spec. Adjust the layout string in bpf_module JIT compilation accordingly. Signed-off-by: Yonghong Song --- src/cc/bpf_module.cc | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/cc/bpf_module.cc b/src/cc/bpf_module.cc index d75d8ea5e..8fba8d276 100644 --- a/src/cc/bpf_module.cc +++ b/src/cc/bpf_module.cc @@ -446,10 +446,18 @@ int BPFModule::finalize() { *sections_p; mod->setTargetTriple("bpf-pc-linux"); +#if LLVM_MAJOR_VERSION >= 11 +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + mod->setDataLayout("e-m:e-p:64:64-i64:64-i128:128-n32:64-S128"); +#else + mod->setDataLayout("E-m:e-p:64:64-i64:64-i128:128-n32:64-S128"); +#endif +#else #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ mod->setDataLayout("e-m:e-p:64:64-i64:64-n32:64-S128"); #else mod->setDataLayout("E-m:e-p:64:64-i64:64-n32:64-S128"); +#endif #endif sections_p = rw_engine_enabled_ ? §ions_ : &tmp_sections; From 007ee4930798f854da47f5838097193d75c67ad1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C5=82=20Gregorczyk?= Date: Tue, 24 Mar 2020 21:00:48 -0400 Subject: [PATCH 076/278] Translate virtual addresses to binary addresses for shared libs as well. Quoting https://refspecs.linuxbase.org/elf/elf.pdf: ``` Symbol table entries for different object file types have slightly different interpretations for the st_value member. - In relocatable files, st_value holds alignment constraints for a symbol whose section index is SHN_COMMON. - In relocatable files, st_value holds a section offset for a defined symbol. That is, st_value is an offset from the beginning of the section that st_shndx identifies. - In executable and shared object files, st_value holds a virtual address. To make these files' symbols more useful for the dynamic linker, the section offset (file interpretation) gives way to a virtual address (memory interpretation) for which the section number is irrelevant. ``` This is a problem in practice as well. I run into this while tracing shared libraries on Android with bpftrace. Some of them have text sections mmapped at different offset than file offset which results in probes being placed at wrong offsets. --- src/cc/bcc_syms.cc | 10 ++++---- tests/python/CMakeLists.txt | 2 ++ tests/python/test_uprobes2.py | 47 +++++++++++++++++++++++++++++++++++ 3 files changed, 54 insertions(+), 5 deletions(-) create mode 100755 tests/python/test_uprobes2.py diff --git a/src/cc/bcc_syms.cc b/src/cc/bcc_syms.cc index fe9853df2..49439f43d 100644 --- a/src/cc/bcc_syms.cc +++ b/src/cc/bcc_syms.cc @@ -707,6 +707,7 @@ int bcc_resolve_symname(const char *module, const char *symname, const uint64_t addr, int pid, struct bcc_symbol_option *option, struct bcc_symbol *sym) { + int module_type; static struct bcc_symbol_option default_option = { .use_debug_file = 1, .check_debug_file_crc = 1, @@ -747,11 +748,10 @@ int bcc_resolve_symname(const char *module, const char *symname, if (sym->offset == 0x0) goto invalid_module; - // For executable (ET_EXEC) binaries, translate the virtual address - // to physical address in the binary file. - // For shared object binaries (ET_DYN), the address from symbol table should - // already be physical address in the binary file. - if (bcc_elf_get_type(sym->module) == ET_EXEC) { + // For executable (ET_EXEC) binaries and shared objects (ET_DYN), translate + // the virtual address to physical address in the binary file. + module_type = bcc_elf_get_type(sym->module); + if (module_type == ET_EXEC || module_type == ET_DYN) { struct load_addr_t addr = { .target_addr = sym->offset, .binary_addr = 0x0, diff --git a/tests/python/CMakeLists.txt b/tests/python/CMakeLists.txt index 63a341305..67b3303c9 100644 --- a/tests/python/CMakeLists.txt +++ b/tests/python/CMakeLists.txt @@ -55,6 +55,8 @@ add_test(NAME py_array WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_array sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_array.py) add_test(NAME py_uprobes WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_uprobes sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_uprobes.py) +add_test(NAME py_uprobes_2 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMAND ${TEST_WRAPPER} py_uprobes2 sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_uprobes2.py) add_test(NAME py_test_stackid WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_stackid sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_stackid.py) add_test(NAME py_test_tracepoint WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} diff --git a/tests/python/test_uprobes2.py b/tests/python/test_uprobes2.py new file mode 100755 index 000000000..6118754a6 --- /dev/null +++ b/tests/python/test_uprobes2.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python +# +# USAGE: test_uprobe2.py +# +# Copyright 2020 Facebook, Inc +# Licensed under the Apache License, Version 2.0 (the "License") + +from bcc import BPF +from unittest import main, TestCase +from subprocess import Popen, PIPE +from tempfile import NamedTemporaryFile + + +class TestUprobes(TestCase): + def setUp(self): + lib_text = b""" +__attribute__((__visibility__("default"))) void fun() +{ +} +""" + self.bpf_text = """ +int trace_fun_call(void *ctx) {{ + return 1; +}} +""" + # Compile and run the application + self.ftemp = NamedTemporaryFile(delete=False) + self.ftemp.close() + comp = Popen([ + "gcc", + "-x", "c", + "-shared", + "-Wl,-Ttext-segment,0x2000000", + "-o", self.ftemp.name, + "-" + ], stdin=PIPE) + comp.stdin.write(lib_text) + comp.stdin.close() + self.assertEqual(comp.wait(), 0) + + def test_attach1(self): + b = BPF(text=self.bpf_text) + b.attach_uprobe(name=self.ftemp.name, sym="fun", fn_name="trace_fun_call") + + +if __name__ == "__main__": + main() From 5057bbe6fb00a112c03ac5c5277646fd9602c1b1 Mon Sep 17 00:00:00 2001 From: Tejun Heo Date: Sun, 5 Apr 2020 18:21:26 -0400 Subject: [PATCH 077/278] examples/tracing: add io_latencies - IO latency distribution monitor This adds flexible low overhead latency percentile monitoring for block devices which can be useful in understanding and debugging IO related issues. Signed-off-by: Tejun Heo --- examples/tracing/io_latencies.py | 249 +++++++++++++++++++++++++++++++ 1 file changed, 249 insertions(+) create mode 100755 examples/tracing/io_latencies.py diff --git a/examples/tracing/io_latencies.py b/examples/tracing/io_latencies.py new file mode 100755 index 000000000..f2fef137f --- /dev/null +++ b/examples/tracing/io_latencies.py @@ -0,0 +1,249 @@ +#!/usr/bin/python3 +# +# io_latencies.py Monitor IO latency distribution of a block device. +# +# $ ./io_latencies.py 259:0 +# 259:0 p1 p5 p10 p16 p25 p50 p75 p84 p90 p95 p99 p100 +# read 95us 175us 305us 515us 895us 985us 995us 1.5ms 2.5ms 3.5ms 4.5ms 10ms +# write 5us 5us 5us 15us 25us 135us 765us 855us 885us 895us 965us 1.5ms +# discard 5us 5us 5us 5us 135us 145us 165us 205us 385us 875us 1.5ms 2.5ms +# flush 5us 5us 5us 5us 5us 5us 5us 5us 5us 1.5ms 4.5ms 5.5ms +# +# Copyright (C) 2020 Tejun Heo +# Copyright (C) 2020 Facebook + +from __future__ import print_function +from bcc import BPF +from time import sleep +import argparse +import json +import sys + +description = """ +Monitor IO latency distribution of a block device +""" + +parser = argparse.ArgumentParser(description = description, + formatter_class = argparse.ArgumentDefaultsHelpFormatter) +parser.add_argument('devno', metavar='MAJ:MIN', type=str, + help='Target block device number') +parser.add_argument('-i', '--interval', type=int, default=3, + help='Report interval') +parser.add_argument('-w', '--which', choices=['from-rq-alloc', 'after-rq-alloc', 'on-device'], + default='on-device', help='Which latency to measure') +parser.add_argument('-p', '--pcts', metavar='PCT', type=float, nargs='+', + default=[1, 5, 10, 16, 25, 50, 75, 84, 90, 95, 99, 100], + help='Percentiles to calculate') +parser.add_argument('-j', '--json', action='store_true', + help='Output in json') +parser.add_argument('--verbose', '-v', action='count', default = 0) + +bpf_source = """ +#include +#include +#include + +BPF_PERCPU_ARRAY(rwdf_100ms, u64, 400); +BPF_PERCPU_ARRAY(rwdf_1ms, u64, 400); +BPF_PERCPU_ARRAY(rwdf_10us, u64, 400); + +void kprobe_blk_account_io_done(struct pt_regs *ctx, struct request *rq, u64 now) +{ + unsigned int cmd_flags; + u64 dur; + size_t base, slot; + + if (!rq->__START_TIME_FIELD__) + return; + + if (!rq->rq_disk || + rq->rq_disk->major != __MAJOR__ || + rq->rq_disk->first_minor != __MINOR__) + return; + + cmd_flags = rq->cmd_flags; + switch (cmd_flags & REQ_OP_MASK) { + case REQ_OP_READ: + base = 0; + break; + case REQ_OP_WRITE: + base = 100; + break; + case REQ_OP_DISCARD: + base = 200; + break; + case REQ_OP_FLUSH: + base = 300; + break; + default: + return; + } + + dur = now - rq->__START_TIME_FIELD__; + + slot = min_t(size_t, div_u64(dur, 100 * NSEC_PER_MSEC), 99); + rwdf_100ms.increment(base + slot); + if (slot) + return; + + slot = min_t(size_t, div_u64(dur, NSEC_PER_MSEC), 99); + rwdf_1ms.increment(base + slot); + if (slot) + return; + + slot = min_t(size_t, div_u64(dur, 10 * NSEC_PER_USEC), 99); + rwdf_10us.increment(base + slot); +} +""" + +args = parser.parse_args() +args.pcts.sort() + +if args.which == 'from-rq-alloc': + start_time_field = 'alloc_time_ns' +elif args.which == 'after-rq-alloc': + start_time_field = 'start_time_ns' +elif args.which == 'on-device': + start_time_field = 'io_start_time_ns' +else: + die() + +bpf_source = bpf_source.replace('__START_TIME_FIELD__', start_time_field) +bpf_source = bpf_source.replace('__MAJOR__', str(int(args.devno.split(':')[0]))) +bpf_source = bpf_source.replace('__MINOR__', str(int(args.devno.split(':')[1]))) + +bpf = BPF(text=bpf_source) +bpf.attach_kprobe(event="blk_account_io_done", fn_name="kprobe_blk_account_io_done") + +# times are in usecs +MSEC = 1000 +SEC = 1000 * 1000 + +cur_rwdf_100ms = bpf["rwdf_100ms"] +cur_rwdf_1ms = bpf["rwdf_1ms"] +cur_rwdf_10us = bpf["rwdf_10us"] + +last_rwdf_100ms = [0] * 400 +last_rwdf_1ms = [0] * 400 +last_rwdf_10us = [0] * 400 + +rwdf_100ms = [0] * 400 +rwdf_1ms = [0] * 400 +rwdf_10us = [0] * 400 + +io_type = ["read", "write", "discard", "flush"] + +def find_pct(req, total, slots, idx, counted): + while idx > 0: + idx -= 1 + if slots[idx] > 0: + counted += slots[idx] + if args.verbose > 1: + print('idx={} counted={} pct={:.1f} req={}' + .format(idx, counted, counted / total, req)) + if (counted / total) * 100 >= 100 - req: + break + return (idx, counted) + +def calc_lat_pct(req_pcts, total, lat_100ms, lat_1ms, lat_10us): + pcts = [0] * len(req_pcts) + + if total == 0: + return pcts + + data = [(100 * MSEC, lat_100ms), (MSEC, lat_1ms), (10, lat_10us)] + data_sel = 0 + idx = 100 + counted = 0 + + for pct_idx in reversed(range(len(req_pcts))): + req = req_pcts[pct_idx] + while True: + last_counted = counted + (gran, slots) = data[data_sel] + (idx, counted) = find_pct(req, total, slots, idx, counted) + if args.verbose > 1: + print('pct_idx={} req={} gran={} idx={} counted={} total={}' + .format(pct_idx, req, gran, idx, counted, total)) + if idx > 0 or data_sel == len(data) - 1: + break + counted = last_counted + data_sel += 1 + idx = 100 + + pcts[pct_idx] = gran * idx + gran / 2 + + return pcts + +def format_usec(lat): + if lat > SEC: + return '{:.1f}s'.format(lat / SEC) + elif lat > 10 * MSEC: + return '{:.0f}ms'.format(lat / MSEC) + elif lat > MSEC: + return '{:.1f}ms'.format(lat / MSEC) + elif lat > 0: + return '{:.0f}us'.format(lat) + else: + return '-' + +# 0 interval can be used to test whether this script would run successfully. +if args.interval == 0: + sys.exit(0) + +while True: + sleep(args.interval) + + rwdf_total = [0] * 4; + + for i in range(400): + v = cur_rwdf_100ms.sum(i).value + rwdf_100ms[i] = max(v - last_rwdf_100ms[i], 0) + last_rwdf_100ms[i] = v + + v = cur_rwdf_1ms.sum(i).value + rwdf_1ms[i] = max(v - last_rwdf_1ms[i], 0) + last_rwdf_1ms[i] = v + + v = cur_rwdf_10us.sum(i).value + rwdf_10us[i] = max(v - last_rwdf_10us[i], 0) + last_rwdf_10us[i] = v + + rwdf_total[int(i / 100)] += rwdf_100ms[i] + + rwdf_lat = [] + for i in range(4): + left = i * 100 + right = left + 100 + rwdf_lat.append( + calc_lat_pct(args.pcts, rwdf_total[i], + rwdf_100ms[left:right], + rwdf_1ms[left:right], + rwdf_10us[left:right])) + + if args.verbose: + print('{:7} 100ms {}'.format(io_type[i], rwdf_100ms[left:right])) + print('{:7} 1ms {}'.format(io_type[i], rwdf_1ms[left:right])) + print('{:7} 10us {}'.format(io_type[i], rwdf_10us[left:right])) + + if args.json: + result = {} + for iot in range(4): + lats = {} + for pi in range(len(args.pcts)): + lats[args.pcts[pi]] = rwdf_lat[iot][pi] / SEC + result[io_type[iot]] = lats + print(json.dumps(result), flush=True) + else: + print('\n{:<7}'.format(args.devno), end='') + widths = [] + for pct in args.pcts: + pct_str = 'p{:g}'.format(pct) + widths.append(max(len(pct_str), 5)) + print(' {:>5}'.format(pct_str), end='') + print() + for iot in range(4): + print('{:7}'.format(io_type[iot]), end='') + for pi in range(len(rwdf_lat[iot])): + print(' {:>{}}'.format(format_usec(rwdf_lat[iot][pi]), widths[pi]), end='') + print() From 15d7955e07a942340610f71e44f44046b960e3a8 Mon Sep 17 00:00:00 2001 From: DavadDi Date: Mon, 6 Apr 2020 20:22:29 +0800 Subject: [PATCH 078/278] Update pid filter Update pid filter; u32 pid = bpf_get_current_pid_tgid() >> 32; --- tools/filelife.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/filelife.py b/tools/filelife.py index 2eb4244b1..38b6b12c4 100755 --- a/tools/filelife.py +++ b/tools/filelife.py @@ -57,7 +57,7 @@ // trace file creation time int trace_create(struct pt_regs *ctx, struct inode *dir, struct dentry *dentry) { - u32 pid = bpf_get_current_pid_tgid(); + u32 pid = bpf_get_current_pid_tgid() >> 32; FILTER u64 ts = bpf_ktime_get_ns(); @@ -70,7 +70,7 @@ int trace_unlink(struct pt_regs *ctx, struct inode *dir, struct dentry *dentry) { struct data_t data = {}; - u32 pid = bpf_get_current_pid_tgid(); + u32 pid = bpf_get_current_pid_tgid() >> 32; FILTER From 7a3854319929e7f126b893c74290076cf7a328b1 Mon Sep 17 00:00:00 2001 From: Sylvain Baubeau Date: Mon, 6 Apr 2020 21:48:08 +0200 Subject: [PATCH 079/278] doc: fix wrong references to get_syscall_name --- docs/reference_guide.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 6197963f5..224ffa628 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -290,7 +290,7 @@ Examples in situ: Syntax: ```syscall__SYSCALLNAME``` -```syscall__``` is a special prefix that creates a kprobe for the system call name provided as the remainder. You can use it by declaring a normal C function, then using the Python ```BPF.get_syscall_name(SYSCALLNAME)``` and ```BPF.attach_kprobe()``` to associate it. +```syscall__``` is a special prefix that creates a kprobe for the system call name provided as the remainder. You can use it by declaring a normal C function, then using the Python ```BPF.get_syscall_fnname(SYSCALLNAME)``` and ```BPF.attach_kprobe()``` to associate it. Arguments are specified on the function declaration: ```syscall__SYSCALLNAME(struct pt_regs *ctx, [, argument1 ...])```. @@ -312,7 +312,7 @@ The first argument is always ```struct pt_regs *```, the remainder are the argum Corresponding Python code: ```Python b = BPF(text=bpf_text) -execve_fnname = b.get_syscall_name("execve") +execve_fnname = b.get_syscall_fnname("execve") b.attach_kprobe(event=execve_fnname, fn_name="syscall__execve") ``` From 1515f28a483d62ff056602daacecd7631c98492d Mon Sep 17 00:00:00 2001 From: Tejun Heo Date: Fri, 17 Apr 2020 11:56:26 -0400 Subject: [PATCH 080/278] tools: Move io_iolatencies.py example to tools/biolatpcts.py --- examples/tracing/io_latencies.py => tools/biolatpcts.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) rename examples/tracing/io_latencies.py => tools/biolatpcts.py (98%) diff --git a/examples/tracing/io_latencies.py b/tools/biolatpcts.py similarity index 98% rename from examples/tracing/io_latencies.py rename to tools/biolatpcts.py index f2fef137f..9da2635ea 100755 --- a/examples/tracing/io_latencies.py +++ b/tools/biolatpcts.py @@ -1,8 +1,8 @@ #!/usr/bin/python3 # -# io_latencies.py Monitor IO latency distribution of a block device. +# biolatpcts.py Monitor IO latency distribution of a block device. # -# $ ./io_latencies.py 259:0 +# $ ./biolatpcts.py 259:0 # 259:0 p1 p5 p10 p16 p25 p50 p75 p84 p90 p95 p99 p100 # read 95us 175us 305us 515us 895us 985us 995us 1.5ms 2.5ms 3.5ms 4.5ms 10ms # write 5us 5us 5us 15us 25us 135us 765us 855us 885us 895us 965us 1.5ms From 66ab787b5f853d97bad8fb950b12b11b8e281b7c Mon Sep 17 00:00:00 2001 From: Tejun Heo Date: Fri, 17 Apr 2020 11:23:57 -0400 Subject: [PATCH 081/278] tools/biolatpcts: Use #!/usr/bin/python instead of python3 Nothing in the script requires python3. --- tools/biolatpcts.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/biolatpcts.py b/tools/biolatpcts.py index 9da2635ea..bbb3cd370 100755 --- a/tools/biolatpcts.py +++ b/tools/biolatpcts.py @@ -1,4 +1,4 @@ -#!/usr/bin/python3 +#!/usr/bin/python # # biolatpcts.py Monitor IO latency distribution of a block device. # From 7214903a9c42c3501e50a47d3698b77547036f70 Mon Sep 17 00:00:00 2001 From: Tejun Heo Date: Fri, 17 Apr 2020 10:24:00 -0400 Subject: [PATCH 082/278] tools/biolatpcts: --pcts handling improvements * Multiple arguments parsing conflicts with positional argument and can become confusing. Use a single comma separated list instead. * Instead of converting to floats while parsing arguments, keep the strings verbatim and use them when outputting results. This allows matching the same target percentile string in the output and is helpful when it's consumed by other programs. --- tools/biolatpcts.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/tools/biolatpcts.py b/tools/biolatpcts.py index bbb3cd370..358414d1f 100755 --- a/tools/biolatpcts.py +++ b/tools/biolatpcts.py @@ -31,8 +31,8 @@ help='Report interval') parser.add_argument('-w', '--which', choices=['from-rq-alloc', 'after-rq-alloc', 'on-device'], default='on-device', help='Which latency to measure') -parser.add_argument('-p', '--pcts', metavar='PCT', type=float, nargs='+', - default=[1, 5, 10, 16, 25, 50, 75, 84, 90, 95, 99, 100], +parser.add_argument('-p', '--pcts', metavar='PCT,...', type=str, + default='1,5,10,16,25,50,75,84,90,95,99,100', help='Percentiles to calculate') parser.add_argument('-j', '--json', action='store_true', help='Output in json') @@ -97,7 +97,8 @@ """ args = parser.parse_args() -args.pcts.sort() +args.pcts = args.pcts.split(',') +args.pcts.sort(key=lambda x: float(x)) if args.which == 'from-rq-alloc': start_time_field = 'alloc_time_ns' @@ -157,7 +158,7 @@ def calc_lat_pct(req_pcts, total, lat_100ms, lat_1ms, lat_10us): counted = 0 for pct_idx in reversed(range(len(req_pcts))): - req = req_pcts[pct_idx] + req = float(req_pcts[pct_idx]) while True: last_counted = counted (gran, slots) = data[data_sel] @@ -238,9 +239,8 @@ def format_usec(lat): print('\n{:<7}'.format(args.devno), end='') widths = [] for pct in args.pcts: - pct_str = 'p{:g}'.format(pct) - widths.append(max(len(pct_str), 5)) - print(' {:>5}'.format(pct_str), end='') + widths.append(max(len(pct), 5)) + print(' {:>5}'.format(pct), end='') print() for iot in range(4): print('{:7}'.format(io_type[iot]), end='') From fbf0392d72a6ced87a5e8ea8a84dfddb5a86c6bd Mon Sep 17 00:00:00 2001 From: Tejun Heo Date: Fri, 17 Apr 2020 12:32:09 -0400 Subject: [PATCH 083/278] tools/biolatpcts: Accept device name/node for target device selection MAJ:MIN is cumbersome. Update it to accept DEVNAME and /dev/DEVNAME too. --- tools/biolatpcts.py | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-) diff --git a/tools/biolatpcts.py b/tools/biolatpcts.py index 358414d1f..9db210e8b 100755 --- a/tools/biolatpcts.py +++ b/tools/biolatpcts.py @@ -2,8 +2,8 @@ # # biolatpcts.py Monitor IO latency distribution of a block device. # -# $ ./biolatpcts.py 259:0 -# 259:0 p1 p5 p10 p16 p25 p50 p75 p84 p90 p95 p99 p100 +# $ ./biolatpcts.py /dev/nvme0n1 +# nvme0n1 p1 p5 p10 p16 p25 p50 p75 p84 p90 p95 p99 p100 # read 95us 175us 305us 515us 895us 985us 995us 1.5ms 2.5ms 3.5ms 4.5ms 10ms # write 5us 5us 5us 15us 25us 135us 765us 855us 885us 895us 965us 1.5ms # discard 5us 5us 5us 5us 135us 145us 165us 205us 385us 875us 1.5ms 2.5ms @@ -18,6 +18,7 @@ import argparse import json import sys +import os description = """ Monitor IO latency distribution of a block device @@ -25,8 +26,8 @@ parser = argparse.ArgumentParser(description = description, formatter_class = argparse.ArgumentDefaultsHelpFormatter) -parser.add_argument('devno', metavar='MAJ:MIN', type=str, - help='Target block device number') +parser.add_argument('dev', metavar='DEV', type=str, + help='Target block device (/dev/DEVNAME, DEVNAME or MAJ:MIN)') parser.add_argument('-i', '--interval', type=int, default=3, help='Report interval') parser.add_argument('-w', '--which', choices=['from-rq-alloc', 'after-rq-alloc', 'on-device'], @@ -100,6 +101,18 @@ args.pcts = args.pcts.split(',') args.pcts.sort(key=lambda x: float(x)) +try: + major = int(args.dev.split(':')[0]) + minor = int(args.dev.split(':')[1]) +except Exception: + if '/' in args.dev: + stat = os.stat(args.dev) + else: + stat = os.stat('/dev/' + args.dev) + + major = os.major(stat.st_rdev) + minor = os.minor(stat.st_rdev) + if args.which == 'from-rq-alloc': start_time_field = 'alloc_time_ns' elif args.which == 'after-rq-alloc': @@ -110,8 +123,8 @@ die() bpf_source = bpf_source.replace('__START_TIME_FIELD__', start_time_field) -bpf_source = bpf_source.replace('__MAJOR__', str(int(args.devno.split(':')[0]))) -bpf_source = bpf_source.replace('__MINOR__', str(int(args.devno.split(':')[1]))) +bpf_source = bpf_source.replace('__MAJOR__', str(major)) +bpf_source = bpf_source.replace('__MINOR__', str(minor)) bpf = BPF(text=bpf_source) bpf.attach_kprobe(event="blk_account_io_done", fn_name="kprobe_blk_account_io_done") @@ -236,7 +249,7 @@ def format_usec(lat): result[io_type[iot]] = lats print(json.dumps(result), flush=True) else: - print('\n{:<7}'.format(args.devno), end='') + print('\n{:<7}'.format(os.path.basename(args.dev)), end='') widths = [] for pct in args.pcts: widths.append(max(len(pct), 5)) From 1e9c56f40a44faf72569ddc2e37ca5d554aee93b Mon Sep 17 00:00:00 2001 From: Tejun Heo Date: Fri, 17 Apr 2020 13:37:51 -0400 Subject: [PATCH 084/278] tools/biolatpcts: Add the example file and man page --- man/man8/biolatpcts.8 | 89 ++++++++++++++++++++++++++++++++++++ tools/biolatpcts_example.txt | 68 +++++++++++++++++++++++++++ 2 files changed, 157 insertions(+) create mode 100644 man/man8/biolatpcts.8 create mode 100644 tools/biolatpcts_example.txt diff --git a/man/man8/biolatpcts.8 b/man/man8/biolatpcts.8 new file mode 100644 index 000000000..7a06a11d4 --- /dev/null +++ b/man/man8/biolatpcts.8 @@ -0,0 +1,89 @@ +.TH biolatpcts 8 "2020-04-17" "USER COMMANDS" +.SH NAME +biolatpcts \- Monitor IO latency distribution of a block device. +.SH SYNOPSIS +.B biolatpcts [\-h] [\-i INTERVAL] [\-w which] [\-p PCT,...] [\-j] [\-v] DEV +.SH DESCRIPTION + +biolatpcts traces block device I/O (disk I/O) of the specified device, and +calculates and prints the completion latency distribution percentiles per IO +type periodically. Example: + + # biolatpcts /dev/nvme0n1 + nvme0n1 p1 p5 p10 p16 p25 p50 p75 p84 p90 p95 p99 p100 + read 95us 175us 305us 515us 895us 985us 995us 1.5ms 2.5ms 3.5ms 4.5ms 10ms + write 5us 5us 5us 15us 25us 135us 765us 855us 885us 895us 965us 1.5ms + discard 5us 5us 5us 5us 135us 145us 165us 205us 385us 875us 1.5ms 2.5ms + flush 5us 5us 5us 5us 5us 5us 5us 5us 5us 1.5ms 4.5ms 5.5ms + [...] + +biolatpcts prints a number of pre-set latency percentiles in tabular form +every three seconds. The interval can be changed with the \-i option. + +The latency is measured between issue to the device and completion. The +starting point can be changed with the \-w option. + +Any number of percentiles can be specified using the \-p option. The input +percentile string is used verbatim in the output to ease machine consumption. + +\-j option enables json output. The result for each interval is printed on a +single line. + +This tool works by tracing blk_account_io_done() with kprobe and bucketing the +completion latencies into percpu arrays. It may need updating to match the +changes to the function. + +Since this uses BPF, only the root user can use this tool. +.SH REQUIREMENTS +CONFIG_BPF, CONFIG_KPROBES and bcc. +.SH OPTIONS +\-h +Print usage message. +.TP +\-i INTERVAL, \-\-interval INTERVAL +Report interval. (default: 3) +.TP +\-w {from\-rq\-alloc,after\-rq\-alloc,on\-device}, \-\-which {from\-rq\-alloc,after\-rq\-alloc,on\-device} +Which latency to measure. (default: on-device) +.TP +\-p PCT,..., \-\-pcts PCT,... +Percentiles to calculate. (default: 1,5,10,16,25,50,75,84,90,95,99,100) +.TP +\-j, \-\-json +Output in json. +.TP +\-v, \-\-verbose +Enable debug output. +.TP +DEV +Target block device. /dev/DEVNAME, DEVNAME or MAJ:MIN. +.SH EXAMPLES +.TP +Print sda's I/O latency percentiles every second +# +.B biolatpcts \-i 1 sda +.TP +Print nvme0n1's all-9 I/O latency percentiles in json every second +# +.B biolatpcts \-p 99,99.9,99.99,99.999 \-j \-i 1 /dev/nvme0n1 +.SH OVERHEAD +This traces kernel functions and maintains in-kernel per-cpu latency buckets, +which are asynchronously copied to user-space. This method is very efficient, +and the overhead for most storage I/O rates should be negligible. If you have +an extremely high IOPS storage device, test and quantify the overhead before +use. +.SH SOURCE +This is from bcc. +.IP +https://github.com/iovisor/bcc +.PP +Also look in the bcc distribution for a companion _examples.txt file containing +example usage, output, and commentary for this tool. +.SH OS +Linux +.SH STABILITY +Unstable - in development. +.SH AUTHOR +Tejun Heo +.SH SEE ALSO +biolatency(8), biosnoop(8) diff --git a/tools/biolatpcts_example.txt b/tools/biolatpcts_example.txt new file mode 100644 index 000000000..3176fcc0c --- /dev/null +++ b/tools/biolatpcts_example.txt @@ -0,0 +1,68 @@ +Demonstrations of biolatpcts, the Linux eBPF/bcc version. + + +biolatpcts traces block device I/O (disk I/O), and prints the latency +percentiles per I/O type. Example: + +# ./biolatpcts.py /dev/nvme0n1 +nvme0n1 p1 p5 p10 p16 p25 p50 p75 p84 p90 p95 p99 p100 +read 95us 175us 305us 515us 895us 985us 995us 1.5ms 2.5ms 3.5ms 4.5ms 10ms +write 5us 5us 5us 15us 25us 135us 765us 855us 885us 895us 965us 1.5ms +discard 5us 5us 5us 5us 135us 145us 165us 205us 385us 875us 1.5ms 2.5ms +flush 5us 5us 5us 5us 5us 5us 5us 5us 5us 1.5ms 4.5ms 5.5ms +[...] + +Unless changed with the -i option, the latency percentiles are printed every 3 +seconds. + + +Any number of custom percentiles can be requested with the -p option: + +# ./biolatpcts.py /dev/nvme0n1 -p 01,90.0,99.9,99.99,100.0 + +nvme0n1 01 90.0 99.9 99.99 100.0 +read 5us 4.5ms 16ms 22ms 26ms +write 15us 255us 365us 515us 2.5ms +discard - - - - - +flush 5us 5us 5us 5us 24ms +[...] + +Note that the target percentile strings are preserved as-is to facilitate +exact key matching when the output is consumed by another program. + + +When the output is consumed by another program, parsing can be tedious. The -j +option makes biolatpcts output results in json, one line per interval. + +# ./tools/biolatpcts.py /dev/nvme0n1 -j +{"read": {"1": 2.5e-05, "5": 3.5e-05, "10": 4.5e-05, "16": 0.000145, "25": 0.000195, "50": 0.000355, "75": 0.000605, "84": 0.000775, "90": 0.000965, "95": 0.0015, "99": 0.0025, "100": 0.0235}, "write": {"1": 5e-06, "5": 5e-06, "10": 5e-06, "16": 5e-06, "25": 1.5e-05, "50": 2.5e-05, "75": 4.5e-05, "84": 7.5e-05, "90": 0.000195, "95": 0.000665, "99": 0.0015, "100": 0.0035}, "discard": {"1": 0.0, "5": 0.0, "10": 0.0, "16": 0.0, "25": 0.0, "50": 0.0, "75": 0.0, "84": 0.0, "90": 0.0, "95": 0.0, "99": 0.0, "100": 0.0}, "flush": {"1": 0.0, "5": 0.0, "10": 0.0, "16": 0.0, "25": 0.0, "50": 0.0, "75": 0.0, "84": 0.0, "90": 0.0, "95": 0.0, "99": 0.0, "100": 0.0}} +[...] + + +By default biolatpcts measures the duration each IO was on the device. It can +be changed using the -w option. + + +USAGE message: + +usage: biolatpcts.py [-h] [-i INTERVAL] + [-w {from-rq-alloc,after-rq-alloc,on-device}] + [-p PCT,...] [-j] [--verbose] + DEV + +Monitor IO latency distribution of a block device + +positional arguments: + DEV Target block device (/dev/DEVNAME, DEVNAME or MAJ:MIN) + +optional arguments: + -h, --help show this help message and exit + -i INTERVAL, --interval INTERVAL + Report interval (default: 3) + -w {from-rq-alloc,after-rq-alloc,on-device}, --which {from-rq-alloc,after-rq-alloc,on-device} + Which latency to measure (default: on-device) + -p PCT,..., --pcts PCT,... + Percentiles to calculate (default: + 1,5,10,16,25,50,75,84,90,95,99,100) + -j, --json Output in json (default: False) + --verbose, -v From 10519c74c72b58109a2c14eba59d3cfe985ddc0f Mon Sep 17 00:00:00 2001 From: Tejun Heo Date: Fri, 17 Apr 2020 16:12:47 -0400 Subject: [PATCH 085/278] examples: Add biolatpcts.py example This is simplified version of tools/biolatpcts.py and demonstrates how to obtain and calculate latency percentiles. --- examples/tracing/biolatpcts.py | 124 ++++++++++++++++++++++++ examples/tracing/biolatpcts_example.txt | 17 ++++ 2 files changed, 141 insertions(+) create mode 100755 examples/tracing/biolatpcts.py create mode 100644 examples/tracing/biolatpcts_example.txt diff --git a/examples/tracing/biolatpcts.py b/examples/tracing/biolatpcts.py new file mode 100755 index 000000000..c9bb834e5 --- /dev/null +++ b/examples/tracing/biolatpcts.py @@ -0,0 +1,124 @@ +#!/usr/bin/python +# +# biolatpcts.py IO latency percentile calculation example +# +# Copyright (C) 2020 Tejun Heo +# Copyright (C) 2020 Facebook + +from __future__ import print_function +from bcc import BPF +from time import sleep + +bpf_source = """ +#include +#include +#include + +BPF_PERCPU_ARRAY(lat_100ms, u64, 100); +BPF_PERCPU_ARRAY(lat_1ms, u64, 100); +BPF_PERCPU_ARRAY(lat_10us, u64, 100); + +void kprobe_blk_account_io_done(struct pt_regs *ctx, struct request *rq, u64 now) +{ + unsigned int cmd_flags; + u64 dur; + size_t base, slot; + + if (!rq->io_start_time_ns) + return; + + dur = now - rq->io_start_time_ns; + + slot = min_t(size_t, div_u64(dur, 100 * NSEC_PER_MSEC), 99); + lat_100ms.increment(slot); + if (slot) + return; + + slot = min_t(size_t, div_u64(dur, NSEC_PER_MSEC), 99); + lat_1ms.increment(slot); + if (slot) + return; + + slot = min_t(size_t, div_u64(dur, 10 * NSEC_PER_USEC), 99); + lat_10us.increment(slot); +} +""" + +bpf = BPF(text=bpf_source) +bpf.attach_kprobe(event='blk_account_io_done', fn_name='kprobe_blk_account_io_done') + +cur_lat_100ms = bpf['lat_100ms'] +cur_lat_1ms = bpf['lat_1ms'] +cur_lat_10us = bpf['lat_10us'] + +last_lat_100ms = [0] * 100 +last_lat_1ms = [0] * 100 +last_lat_10us = [0] * 100 + +lat_100ms = [0] * 100 +lat_1ms = [0] * 100 +lat_10us = [0] * 100 + +def find_pct(req, total, slots, idx, counted): + while idx > 0: + idx -= 1 + if slots[idx] > 0: + counted += slots[idx] + if (counted / total) * 100 >= 100 - req: + break + return (idx, counted) + +def calc_lat_pct(req_pcts, total, lat_100ms, lat_1ms, lat_10us): + pcts = [0] * len(req_pcts) + + if total == 0: + return pcts + + data = [(100 * 1000, lat_100ms), (1000, lat_1ms), (10, lat_10us)] + data_sel = 0 + idx = 100 + counted = 0 + + for pct_idx in reversed(range(len(req_pcts))): + req = float(req_pcts[pct_idx]) + while True: + last_counted = counted + (gran, slots) = data[data_sel] + (idx, counted) = find_pct(req, total, slots, idx, counted) + if idx > 0 or data_sel == len(data) - 1: + break + counted = last_counted + data_sel += 1 + idx = 100 + + pcts[pct_idx] = gran * idx + gran / 2 + + return pcts + +print('Block I/O latency percentile example. See tools/biolatpcts.py for the full utility.') + +while True: + sleep(3) + + lat_total = 0; + + for i in range(100): + v = cur_lat_100ms.sum(i).value + lat_100ms[i] = max(v - last_lat_100ms[i], 0) + last_lat_100ms[i] = v + + v = cur_lat_1ms.sum(i).value + lat_1ms[i] = max(v - last_lat_1ms[i], 0) + last_lat_1ms[i] = v + + v = cur_lat_10us.sum(i).value + lat_10us[i] = max(v - last_lat_10us[i], 0) + last_lat_10us[i] = v + + lat_total += lat_100ms[i] + + target_pcts = [50, 75, 90, 99] + pcts = calc_lat_pct(target_pcts, lat_total, lat_100ms, lat_1ms, lat_10us); + for i in range(len(target_pcts)): + print('p{}={}us '.format(target_pcts[i], int(pcts[i])), end='') + print() diff --git a/examples/tracing/biolatpcts_example.txt b/examples/tracing/biolatpcts_example.txt new file mode 100644 index 000000000..f8e858fc7 --- /dev/null +++ b/examples/tracing/biolatpcts_example.txt @@ -0,0 +1,17 @@ +Demonstrations of biolatpcts.py, the Linux eBPF/bcc version. + + +This traces block I/O and uses layered percpu arrays to bucket the completion +latencies. Latency percentiles are calculated periodically from the buckets. + +# ./biolatpcts.py +p50=595.0us p75=685.0us p90=1500.0us p99=2500.0us +p50=55.0us p75=95.0us p90=305.0us p99=2500.0us +p50=385.0us p75=655.0us p90=1500.0us p99=2500.0us +[...] + +The latency is measured from I/O request to the device, to the device +completion. This excludes latency spent queued in the OS. + +This is a simplified example to demonstrate the calculation of latency +percentiles. See tools/biolatpcts.py for the full utility. From f8f230c8162e59202987fb46f2d3d867a5cbef1d Mon Sep 17 00:00:00 2001 From: Fuji Goro Date: Mon, 13 Apr 2020 05:05:21 +0000 Subject: [PATCH 086/278] add attribute readers to class USDT (C++ API) --- src/cc/api/BPF.h | 6 ++++++ tests/cc/test_usdt_probes.cc | 10 ++++++++++ 2 files changed, 16 insertions(+) diff --git a/src/cc/api/BPF.h b/src/cc/api/BPF.h index 85962fa65..9bf31c224 100644 --- a/src/cc/api/BPF.h +++ b/src/cc/api/BPF.h @@ -330,6 +330,12 @@ class USDT { USDT(const USDT& usdt); USDT(USDT&& usdt) noexcept; + const std::string &binary_path() const { return binary_path_; } + pid_t pid() const { return pid_; } + const std::string &provider() const { return provider_; } + const std::string &name() const { return name_; } + const std::string &probe_func() const { return probe_func_; } + StatusTuple init(); bool operator==(const USDT& other) const; diff --git a/tests/cc/test_usdt_probes.cc b/tests/cc/test_usdt_probes.cc index 2eb4a94ad..5652b43f6 100644 --- a/tests/cc/test_usdt_probes.cc +++ b/tests/cc/test_usdt_probes.cc @@ -62,6 +62,16 @@ TEST_CASE("test finding a probe in our own process", "[usdt]") { } } +TEST_CASE("test probe's attributes with C++ API", "[usdt]") { + const ebpf::USDT u("/proc/self/exe", "libbcc_test", "sample_probe_1", "on_event"); + + REQUIRE(u.binary_path() == "/proc/self/exe"); + REQUIRE(u.pid() == -1); + REQUIRE(u.provider() == "libbcc_test"); + REQUIRE(u.name() == "sample_probe_1"); + REQUIRE(u.probe_func() == "on_event"); +} + TEST_CASE("test fine a probe in our own binary with C++ API", "[usdt]") { ebpf::BPF bpf; ebpf::USDT u("/proc/self/exe", "libbcc_test", "sample_probe_1", "on_event"); From 1599c2ef8206988d5df7eeadc3c5138c006ac245 Mon Sep 17 00:00:00 2001 From: Dominique Martinet Date: Fri, 17 Apr 2020 21:16:03 +0200 Subject: [PATCH 087/278] build: fix clang 10 build some distros already packaging clang 10 (checked fedora and arch) no longer ship all the individual libclang*.so component libraries. Instead, clang from 9.0 onwards provides a new lib, libclang-cpp.so, which includes everything we need. Tell cmake to use it if the individual libraries are no longer found. (Build-wise, if both are present it is more efficient to use the individual components so keep these first) --- CMakeLists.txt | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index ad0070548..65e78ffef 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -55,19 +55,19 @@ endif() # clang is linked as a library, but the library path searching is # primitively supported, unlike libLLVM set(CLANG_SEARCH "/opt/local/llvm/lib;/usr/lib/llvm-3.7/lib;${LLVM_LIBRARY_DIRS}") -find_library(libclangAnalysis NAMES clangAnalysis HINTS ${CLANG_SEARCH}) -find_library(libclangAST NAMES clangAST HINTS ${CLANG_SEARCH}) -find_library(libclangBasic NAMES clangBasic HINTS ${CLANG_SEARCH}) -find_library(libclangCodeGen NAMES clangCodeGen HINTS ${CLANG_SEARCH}) -find_library(libclangDriver NAMES clangDriver HINTS ${CLANG_SEARCH}) -find_library(libclangEdit NAMES clangEdit HINTS ${CLANG_SEARCH}) -find_library(libclangFrontend NAMES clangFrontend HINTS ${CLANG_SEARCH}) -find_library(libclangLex NAMES clangLex HINTS ${CLANG_SEARCH}) -find_library(libclangParse NAMES clangParse HINTS ${CLANG_SEARCH}) -find_library(libclangRewrite NAMES clangRewrite HINTS ${CLANG_SEARCH}) -find_library(libclangSema NAMES clangSema HINTS ${CLANG_SEARCH}) -find_library(libclangSerialization NAMES clangSerialization HINTS ${CLANG_SEARCH}) -find_library(libclangASTMatchers NAMES clangASTMatchers HINTS ${CLANG_SEARCH}) +find_library(libclangAnalysis NAMES clangAnalysis clang-cpp HINTS ${CLANG_SEARCH}) +find_library(libclangAST NAMES clangAST clang-cpp HINTS ${CLANG_SEARCH}) +find_library(libclangBasic NAMES clangBasic clang-cpp HINTS ${CLANG_SEARCH}) +find_library(libclangCodeGen NAMES clangCodeGen clang-cpp HINTS ${CLANG_SEARCH}) +find_library(libclangDriver NAMES clangDriver clang-cpp HINTS ${CLANG_SEARCH}) +find_library(libclangEdit NAMES clangEdit clang-cpp HINTS ${CLANG_SEARCH}) +find_library(libclangFrontend NAMES clangFrontend clang-cpp HINTS ${CLANG_SEARCH}) +find_library(libclangLex NAMES clangLex clang-cpp HINTS ${CLANG_SEARCH}) +find_library(libclangParse NAMES clangParse clang-cpp HINTS ${CLANG_SEARCH}) +find_library(libclangRewrite NAMES clangRewrite clang-cpp HINTS ${CLANG_SEARCH}) +find_library(libclangSema NAMES clangSema clang-cpp HINTS ${CLANG_SEARCH}) +find_library(libclangSerialization NAMES clangSerialization clang-cpp HINTS ${CLANG_SEARCH}) +find_library(libclangASTMatchers NAMES clangASTMatchers clang-cpp HINTS ${CLANG_SEARCH}) if(libclangBasic STREQUAL "libclangBasic-NOTFOUND") message(FATAL_ERROR "Unable to find clang libraries") endif() From c1d3a65f0d6dd29aad71ffc87f21345473a2bca3 Mon Sep 17 00:00:00 2001 From: Terence Namusonge Date: Sun, 19 Apr 2020 03:19:47 +0200 Subject: [PATCH 088/278] Added kernel recompile guidance for libbpf CO-RE (#2876) Added kernel recompile guidance for libbpf CO-RE --- libbpf-tools/README.md | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/libbpf-tools/README.md b/libbpf-tools/README.md index 152f72b69..d439e05cf 100644 --- a/libbpf-tools/README.md +++ b/libbpf-tools/README.md @@ -46,7 +46,7 @@ For more reproducible builds, vmlinux.h header file is pre-generated and checked in along the other sources. This is done to avoid dependency on specific user/build server's kernel configuration, because vmlinux.h generation depends on having a kernel with BTF type information built-in -(which is enabled by `CONFIG_DEBUG_INFO_BTF=y` Kconfig option). +(which is enabled by `CONFIG_DEBUG_INFO_BTF=y` Kconfig option See below). vmlinux.h is generated from upstream Linux version at particular minor version tag. E.g., `vmlinux_505.h` is generated from v5.5 tag. Exact set of @@ -73,3 +73,19 @@ Given bpftool package can't yet be expected to be available widely across many distributions, bpftool binary is checked in into BCC repository in bin/ subdirectory. Once bpftool package is more widely available, this can be changed in favor of using pre-packaged version of bpftool. + + +Re-compiling your Kernel with CONFIG_DEBUG_INFO_BTF=y +----------------------------------------------------- +libbpf probes to see if your sys fs exports the file `/sys/kernel/btf/vmlinux` (from Kernel 5.5+) or if you have the ELF version in your system [`code`](https://github.com/libbpf/libbpf/blob/master/src/btf.c) +Please note the ELF file could exist without the BTF info in it. Your Kconfig should contain the options below + +1. Compile options +```code +CONFIG_DEBUG_INFO_BTF=y +CONFIG_DEBUG_INFO=y +``` +2. Also, make sure that you have pahole 1.13 (or preferably 1.16+) during the +kernel build (it comes from dwarves package). Without it, BTF won't be +generated, and on older kernels you'd get only warning, but still would +build kernel successfully From 6d61622f6300fa140647de82122e66b6288fe2ed Mon Sep 17 00:00:00 2001 From: FUJI Goro Date: Sun, 19 Apr 2020 11:19:47 +0900 Subject: [PATCH 089/278] Add `bcc_version.h` to access LIBBCC_VERSION from C/C++ (#2856) add bcc/bcc_version.h to install --- examples/cpp/CMakeLists.txt | 1 + examples/cpp/HelloWorld.cc | 3 +++ src/cc/CMakeLists.txt | 5 +++-- src/cc/bcc_version.h.in | 6 ++++++ 4 files changed, 13 insertions(+), 2 deletions(-) create mode 100644 src/cc/bcc_version.h.in diff --git a/examples/cpp/CMakeLists.txt b/examples/cpp/CMakeLists.txt index c801cc9f9..c804fe93a 100644 --- a/examples/cpp/CMakeLists.txt +++ b/examples/cpp/CMakeLists.txt @@ -1,6 +1,7 @@ # Copyright (c) Facebook, Inc. # Licensed under the Apache License, Version 2.0 (the "License") +include_directories(${CMAKE_BINARY_DIR}/src/cc) include_directories(${CMAKE_SOURCE_DIR}/src/cc) include_directories(${CMAKE_SOURCE_DIR}/src/cc/api) include_directories(${CMAKE_SOURCE_DIR}/src/cc/libbpf/include/uapi) diff --git a/examples/cpp/HelloWorld.cc b/examples/cpp/HelloWorld.cc index 05e5509ee..e229ced32 100644 --- a/examples/cpp/HelloWorld.cc +++ b/examples/cpp/HelloWorld.cc @@ -8,6 +8,7 @@ #include #include +#include "bcc_version.h" #include "BPF.h" const std::string BPF_PROGRAM = R"( @@ -35,6 +36,8 @@ int main() { return 1; } + std::cout << "Starting HelloWorld with BCC " << LIBBCC_VERSION << std::endl; + while (true) { if (std::getline(pipe, line)) { std::cout << line << std::endl; diff --git a/src/cc/CMakeLists.txt b/src/cc/CMakeLists.txt index 56a4bc600..0f02ad625 100644 --- a/src/cc/CMakeLists.txt +++ b/src/cc/CMakeLists.txt @@ -13,7 +13,8 @@ include_directories(${LIBELF_INCLUDE_DIRS}) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/libbpf/include) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/libbpf/include/uapi) add_definitions(${LLVM_DEFINITIONS}) -configure_file(libbcc.pc.in ${CMAKE_CURRENT_BINARY_DIR}/libbcc.pc @ONLY) +configure_file(libbcc.pc.in libbcc.pc @ONLY) +configure_file(bcc_version.h.in bcc_version.h @ONLY) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -DBCC_PROG_TAG_DIR='\"${BCC_PROG_TAG_DIR}\"'") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-result") @@ -66,7 +67,7 @@ endif() set(bcc_table_sources table_storage.cc shared_table.cc bpffs_table.cc json_map_decl_visitor.cc) set(bcc_util_sources common.cc) set(bcc_sym_sources bcc_syms.cc bcc_elf.c bcc_perf_map.c bcc_proc.c) -set(bcc_common_headers libbpf.h perf_reader.h) +set(bcc_common_headers libbpf.h perf_reader.h "${CMAKE_CURRENT_BINARY_DIR}/bcc_version.h") set(bcc_table_headers file_desc.h table_desc.h table_storage.h) set(bcc_api_headers bcc_common.h bpf_module.h bcc_exception.h bcc_syms.h bcc_proc.h bcc_elf.h) diff --git a/src/cc/bcc_version.h.in b/src/cc/bcc_version.h.in new file mode 100644 index 000000000..44c61b20e --- /dev/null +++ b/src/cc/bcc_version.h.in @@ -0,0 +1,6 @@ +#ifndef LIBBCC_VERSION_H +#define LIBBCC_VERSION_H + +#define LIBBCC_VERSION "@REVISION@" + +#endif From d3359b294636579649f200deabe71fd98d4edd35 Mon Sep 17 00:00:00 2001 From: Itay Shakury Date: Mon, 20 Apr 2020 15:52:27 +0300 Subject: [PATCH 090/278] Improve ubuntu installation description --- INSTALL.md | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/INSTALL.md b/INSTALL.md index 108dc0f4a..bf2702ead 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -58,22 +58,24 @@ Kernel compile flags can usually be checked by looking at `/proc/config.gz` or ## Ubuntu - Binary -**Ubuntu Packages** - Versions of bcc are available in the standard Ubuntu -multiverse repository. The Ubuntu packages have slightly different names: where iovisor +Universe repository, as well in iovisor's PPA. The Ubuntu packages have slightly different names: where iovisor packages use `bcc` in the name (e.g. `bcc-tools`), Ubuntu packages use `bpfcc` (e.g. -`bpfcc-tools`). Source packages and the binary packages produced from them can be +`bpfcc-tools`). + +Currently, BCC packages for both the Ubuntu Universe, and the iovisor builds are outdated. This is a known and tracked in: +- [Universe - Ubuntu Launchpad](https://bugs.launchpad.net/ubuntu/+source/bpfcc/+bug/1848137) +- [iovisor - BCC GitHub Issues](https://github.com/iovisor/bcc/issues/2678) +Curently, [building from source](#ubuntu---source) is currently the only way to get up to date packaged version of bcc. + +**Ubuntu Packages** +Source packages and the binary packages produced from them can be found at [packages.ubuntu.com](https://packages.ubuntu.com/search?suite=default§ion=all&arch=any&keywords=bpfcc&searchon=sourcenames). ```bash sudo apt-get install bpfcc-tools linux-headers-$(uname -r) ``` -Some of the BCC tools are currently broken due to outdated packages. This is a -[known bug](https://bugs.launchpad.net/ubuntu/+source/bpfcc/+bug/1848137). -Therefore [building from source](#ubuntu---source) is currently the only way to get fully working tools. - The tools are installed in `/sbin` (`/usr/sbin` in Ubuntu 18.04) with a `-bpfcc` extension. Try running `sudo opensnoop-bpfcc`. **_Note_**: the Ubuntu packages have different names but the package contents, in most cases, conflict @@ -87,7 +89,7 @@ which declares a dependency on `libbpfcc` while the upstream `libbcc` package is `foo` should install without trouble as `libbcc` declares that it provides `libbpfcc`. That said, one should always test such a configuration in case of version incompatibilities. -**Upstream Stable and Signed Packages** +**iovisor packages (Upstream Stable and Signed Packages)** ```bash sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 4052245BD4284CDD From 45e63f2b316cdce2d8cc925f6f14a8726ade9ff6 Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Mon, 20 Apr 2020 11:29:18 -0700 Subject: [PATCH 091/278] fix llvm 11 compilation issues MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The llvm CreateCall used in bcc is deprecated in llvm 11: https://reviews.llvm.org/D76269 The llvm CreateMemCpy is changed in llvm 11 as well: https://reviews.llvm.org/D71473 This caused bcc compilation error. /home/yhs/work/bcc/src/cc/frontends/b/codegen_llvm.cc: In member function ‘ebpf::StatusTuple ebpf::cc::CodegenLLVM::emit_log(ebpf::cc::Method CallExprNode*)’: /home/yhs/work/bcc/src/cc/frontends/b/codegen_llvm.cc:691:39: error: no matching function for call to ‘llvm::IRBuilder<>::CreateCall(llvm::Value*&, std::vector >&)’ expr_ = B.CreateCall(printk_fn, args); ^ ... /home/yhs/work/bcc/src/cc/frontends/b/codegen_llvm.cc: In member function ‘virtual ebpf::StatusTuple ebpf::cc::CodegenLLVM::visit_string_exp_node(ebpf::cc::StringExprNode*)’: /home/yhs/work/bcc/src/cc/frontends/b/codegen_llvm.cc:440:55: error: no matching function for call to ‘llvm::IRBuilder<>::CreateMemCpy(llvm:Value*&, int, llvm::Value*&, int, std::__cxx11::basic_string::size_type)’ B.CreateMemCpy(ptr, 1, global, 1, n->val_.size() + 1); ^ ... This patch fixed the compilation issue. --- src/cc/frontends/b/codegen_llvm.cc | 43 +++++++++++++++++++----------- src/cc/frontends/b/codegen_llvm.h | 4 +++ 2 files changed, 32 insertions(+), 15 deletions(-) diff --git a/src/cc/frontends/b/codegen_llvm.cc b/src/cc/frontends/b/codegen_llvm.cc index fefd4d551..d8c9470a7 100644 --- a/src/cc/frontends/b/codegen_llvm.cc +++ b/src/cc/frontends/b/codegen_llvm.cc @@ -112,6 +112,17 @@ void CodegenLLVM::emit(const char *s) { //fflush(out_); } +CallInst *CodegenLLVM::createCall(Value *callee, ArrayRef args) +{ +#if LLVM_MAJOR_VERSION >= 11 + auto *calleePtrType = cast(callee->getType()); + auto *calleeType = cast(calleePtrType->getElementType()); + return B.CreateCall(calleeType, callee, args); +#else + return B.CreateCall(callee, args); +#endif +} + StatusTuple CodegenLLVM::visit_block_stmt_node(BlockStmtNode *n) { // enter scope @@ -386,7 +397,7 @@ StatusTuple CodegenLLVM::visit_packet_expr_node(PacketExprNode *n) { LoadInst *offset_ptr = B.CreateLoad(offset_mem); Value *skb_hdr_offset = B.CreateAdd(offset_ptr, B.getInt64(bit_offset >> 3)); Value *rhs = B.CreateIntCast(pop_expr(), B.getInt64Ty(), false); - B.CreateCall(store_fn, vector({skb_ptr8, skb_hdr_offset, B.getInt64(bit_offset & 0x7), + createCall(store_fn, vector({skb_ptr8, skb_hdr_offset, B.getInt64(bit_offset & 0x7), B.getInt64(bit_width), rhs})); } else { emit("bpf_dext_pkt(pkt, %s + %zu, %zu, %zu)", n->id_->c_str(), bit_offset >> 3, bit_offset & 0x7, bit_width); @@ -396,7 +407,7 @@ StatusTuple CodegenLLVM::visit_packet_expr_node(PacketExprNode *n) { Value *skb_ptr8 = B.CreateBitCast(skb_ptr, B.getInt8PtrTy()); LoadInst *offset_ptr = B.CreateLoad(offset_mem); Value *skb_hdr_offset = B.CreateAdd(offset_ptr, B.getInt64(bit_offset >> 3)); - expr_ = B.CreateCall(load_fn, vector({skb_ptr8, skb_hdr_offset, + expr_ = createCall(load_fn, vector({skb_ptr8, skb_hdr_offset, B.getInt64(bit_offset & 0x7), B.getInt64(bit_width)})); // this generates extra trunc insns whereas the bpf.load fns already // trunc the values internally in the bpf interpreter @@ -425,7 +436,9 @@ StatusTuple CodegenLLVM::visit_string_expr_node(StringExprNode *n) { Value *global = B.CreateGlobalString(n->val_); Value *ptr = make_alloca(resolve_entry_stack(), B.getInt8Ty(), "", B.getInt64(n->val_.size() + 1)); -#if LLVM_MAJOR_VERSION >= 7 +#if LLVM_MAJOR_VERSION >= 11 + B.CreateMemCpy(ptr, Align(1), global, Align(1), n->val_.size() + 1); +#elif LLVM_MAJOR_VERSION >= 7 B.CreateMemCpy(ptr, 1, global, 1, n->val_.size() + 1); #else B.CreateMemCpy(ptr, global, n->val_.size() + 1, 1); @@ -585,14 +598,14 @@ StatusTuple CodegenLLVM::emit_table_lookup(MethodCallExprNode *n) { Function *lookup_fn = mod_->getFunction("bpf_map_lookup_elem_"); if (!lookup_fn) return mkstatus_(n, "bpf_map_lookup_elem_ undefined"); - CallInst *pseudo_call = B.CreateCall(pseudo_fn, vector({B.getInt64(BPF_PSEUDO_MAP_FD), + CallInst *pseudo_call = createCall(pseudo_fn, vector({B.getInt64(BPF_PSEUDO_MAP_FD), B.getInt64(table_fd_it->second)})); Value *pseudo_map_fd = pseudo_call; TRY2(arg0->accept(this)); Value *key_ptr = B.CreateBitCast(pop_expr(), B.getInt8PtrTy()); - expr_ = B.CreateCall(lookup_fn, vector({pseudo_map_fd, key_ptr})); + expr_ = createCall(lookup_fn, vector({pseudo_map_fd, key_ptr})); if (table->type_id()->name_ == "FIXED_MATCH" || table->type_id()->name_ == "INDEXED") { if (n->args_.size() == 2) { @@ -626,7 +639,7 @@ StatusTuple CodegenLLVM::emit_table_update(MethodCallExprNode *n) { Function *update_fn = mod_->getFunction("bpf_map_update_elem_"); if (!update_fn) return mkstatus_(n, "bpf_map_update_elem_ undefined"); - CallInst *pseudo_call = B.CreateCall(pseudo_fn, vector({B.getInt64(BPF_PSEUDO_MAP_FD), + CallInst *pseudo_call = createCall(pseudo_fn, vector({B.getInt64(BPF_PSEUDO_MAP_FD), B.getInt64(table_fd_it->second)})); Value *pseudo_map_fd = pseudo_call; @@ -637,7 +650,7 @@ StatusTuple CodegenLLVM::emit_table_update(MethodCallExprNode *n) { TRY2(arg1->accept(this)); Value *value_ptr = B.CreateBitCast(pop_expr(), B.getInt8PtrTy()); - expr_ = B.CreateCall(update_fn, vector({pseudo_map_fd, key_ptr, value_ptr, B.getInt64(BPF_ANY)})); + expr_ = createCall(update_fn, vector({pseudo_map_fd, key_ptr, value_ptr, B.getInt64(BPF_ANY)})); } else { return mkstatus_(n, "unsupported"); } @@ -656,7 +669,7 @@ StatusTuple CodegenLLVM::emit_table_delete(MethodCallExprNode *n) { Function *update_fn = mod_->getFunction("bpf_map_update_elem_"); if (!update_fn) return mkstatus_(n, "bpf_map_update_elem_ undefined"); - CallInst *pseudo_call = B.CreateCall(pseudo_fn, vector({B.getInt64(BPF_PSEUDO_MAP_FD), + CallInst *pseudo_call = createCall(pseudo_fn, vector({B.getInt64(BPF_PSEUDO_MAP_FD), B.getInt64(table_fd_it->second)})); Value *pseudo_map_fd = pseudo_call; @@ -664,7 +677,7 @@ StatusTuple CodegenLLVM::emit_table_delete(MethodCallExprNode *n) { Value *key_ptr = B.CreateBitCast(pop_expr(), B.getInt8PtrTy()); if (table->type_id()->name_ == "FIXED_MATCH" || table->type_id()->name_ == "INDEXED") { - expr_ = B.CreateCall(update_fn, vector({pseudo_map_fd, key_ptr})); + expr_ = createCall(update_fn, vector({pseudo_map_fd, key_ptr})); } else { return mkstatus_(n, "unsupported"); } @@ -688,7 +701,7 @@ StatusTuple CodegenLLVM::emit_log(MethodCallExprNode *n) { Value *printk_fn = B.CreateIntToPtr(B.getInt64(BPF_FUNC_trace_printk), PointerType::getUnqual(printk_fn_type)); - expr_ = B.CreateCall(printk_fn, args); + expr_ = createCall(printk_fn, args); return StatusTuple::OK(); } @@ -742,7 +755,7 @@ StatusTuple CodegenLLVM::emit_incr_cksum(MethodCallExprNode *n, size_t sz) { LoadInst *skb_ptr = B.CreateLoad(skb_mem); Value *skb_ptr8 = B.CreateBitCast(skb_ptr, B.getInt8PtrTy()); - expr_ = B.CreateCall(csum_fn, vector({skb_ptr8, offset, old_val, new_val, flags})); + expr_ = createCall(csum_fn, vector({skb_ptr8, offset, old_val, new_val, flags})); return StatusTuple::OK(); } @@ -797,7 +810,7 @@ StatusTuple CodegenLLVM::visit_table_index_expr_node(TableIndexExprNode *n) { TRY2(lookup_struct_type(n->table_->leaf_type_, &leaf_type)); PointerType *leaf_ptype = PointerType::getUnqual(leaf_type); - CallInst *pseudo_call = B.CreateCall(pseudo_fn, vector({B.getInt64(BPF_PSEUDO_MAP_FD), + CallInst *pseudo_call = createCall(pseudo_fn, vector({B.getInt64(BPF_PSEUDO_MAP_FD), B.getInt64(table_fd_it->second)})); Value *pseudo_map_fd = pseudo_call; @@ -805,7 +818,7 @@ StatusTuple CodegenLLVM::visit_table_index_expr_node(TableIndexExprNode *n) { Value *key_ptr = B.CreateBitCast(pop_expr(), B.getInt8PtrTy()); // result = lookup(key) - Value *lookup1 = B.CreateBitCast(B.CreateCall(lookup_fn, vector({pseudo_map_fd, key_ptr})), leaf_ptype); + Value *lookup1 = B.CreateBitCast(createCall(lookup_fn, vector({pseudo_map_fd, key_ptr})), leaf_ptype); Value *result = nullptr; if (n->table_->policy_id()->name_ == "AUTO") { @@ -827,10 +840,10 @@ StatusTuple CodegenLLVM::visit_table_index_expr_node(TableIndexExprNode *n) { B.CreateMemSet(leaf_ptr, B.getInt8(0), B.getInt64(n->table_->leaf_id()->bit_width_ >> 3), 1); #endif // update(key, leaf) - B.CreateCall(update_fn, vector({pseudo_map_fd, key_ptr, leaf_ptr, B.getInt64(BPF_NOEXIST)})); + createCall(update_fn, vector({pseudo_map_fd, key_ptr, leaf_ptr, B.getInt64(BPF_NOEXIST)})); // result = lookup(key) - Value *lookup2 = B.CreateBitCast(B.CreateCall(lookup_fn, vector({pseudo_map_fd, key_ptr})), leaf_ptype); + Value *lookup2 = B.CreateBitCast(createCall(lookup_fn, vector({pseudo_map_fd, key_ptr})), leaf_ptype); B.CreateBr(label_end); B.SetInsertPoint(label_end); diff --git a/src/cc/frontends/b/codegen_llvm.h b/src/cc/frontends/b/codegen_llvm.h index c2947f74e..d77c9de82 100644 --- a/src/cc/frontends/b/codegen_llvm.h +++ b/src/cc/frontends/b/codegen_llvm.h @@ -27,8 +27,10 @@ namespace llvm { class AllocaInst; +template class ArrayRef; class BasicBlock; class BranchInst; +class CallInst; class Constant; class Instruction; class IRBuilderBase; @@ -104,6 +106,8 @@ class CodegenLLVM : public Visitor { StatusTuple lookup_struct_type(StructDeclStmtNode *decl, llvm::StructType **stype) const; StatusTuple lookup_struct_type(VariableDeclStmtNode *n, llvm::StructType **stype, StructDeclStmtNode **decl = nullptr) const; + llvm::CallInst *createCall(llvm::Value *Callee, + llvm::ArrayRef Args); template void emit(const char *fmt, Args&&... params); void emit(const char *s); From df3e7d673da4bd4acab333f28851eccf00ca9f87 Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Mon, 20 Apr 2020 09:25:57 -0700 Subject: [PATCH 092/278] sync to latest libbpf sync to libbpf v0.0.8. Add newer helpers to helpers.h, libbpf.c error reporting and docs. --- docs/kernel-versions.md | 8 +- introspection/bps.c | 1 + src/cc/compat/linux/virtual_bpf.h | 340 +++++++++++++++++++++++------- src/cc/export/helpers.h | 27 ++- src/cc/libbpf | 2 +- src/cc/libbpf.c | 6 + 6 files changed, 304 insertions(+), 80 deletions(-) diff --git a/docs/kernel-versions.md b/docs/kernel-versions.md index 8732ddb60..416f70076 100644 --- a/docs/kernel-versions.md +++ b/docs/kernel-versions.md @@ -165,6 +165,7 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_csum_update()` | 4.9 | | [`36bbef52c7eb`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=36bbef52c7eb646ed6247055a2acd3851e317857) `BPF_FUNC_current_task_under_cgroup()` | 4.9 | | [`60d20f9195b2`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=60d20f9195b260bdf0ac10c275ae9f6016f9c069) `BPF_FUNC_fib_lookup()` | 4.18 | GPL | [`87f5fc7e48dd`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=87f5fc7e48dd3175b30dd03b41564e1a8e136323) +`BPF_FUNC_get_current_ancestor_cgroup_id()` | 5.6 | | [`b4490c5c4e02`](https://github.com/torvalds/linux/commit/b4490c5c4e023f09b7d27c9a9d3e7ad7d09ea6bf) `BPF_FUNC_get_cgroup_classid()` | 4.3 | | [`8d20aabe1c76`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=8d20aabe1c76cccac544d9fcc3ad7823d9e98a2d) `BPF_FUNC_get_current_cgroup_id()` | 4.18 | | [`bf6fa2c893c5`](https://github.com/torvalds/linux/commit/bf6fa2c893c5237b48569a13fa3c673041430b6c) `BPF_FUNC_get_current_comm()` | 4.2 | | [`ffeedafbf023`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=ffeedafbf0236f03aeb2e8db273b3e5ae5f5bc89) @@ -174,6 +175,8 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_get_hash_recalc()` | 4.8 | | [`13c5c240f789`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=13c5c240f789bbd2bcacb14a23771491485ae61f) `BPF_FUNC_get_listener_sock()` | 5.1 | | [`dbafd7ddd623`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/davem/net-next/+/dbafd7ddd62369b2f3926ab847cbf8fc40e800b7) `BPF_FUNC_get_local_storage()` | 4.19 | | [`cd3394317653`](https://github.com/torvalds/linux/commit/cd3394317653837e2eb5c5d0904a8996102af9fc) +`BPF_FUNC_get_netns_cookie()` | 5.6 | | [`b4490c5c4e02`](https://github.com/torvalds/linux/commit/b4490c5c4e023f09b7d27c9a9d3e7ad7d09ea6bf) +`BPF_FUNC_get_ns_current_pid_tgid()` | 5.6 | | [`b4490c5c4e02`](https://github.com/torvalds/linux/commit/b4490c5c4e023f09b7d27c9a9d3e7ad7d09ea6bf) `BPF_FUNC_get_numa_node_id()` | 4.10 | | [`2d0e30c30f84`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=2d0e30c30f84d08dc16f0f2af41f1b8a85f0755e) `BPF_FUNC_get_prandom_u32()` | 4.1 | | [`03e69b508b6f`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=03e69b508b6f7c51743055c9f61d1dfeadf4b635) `BPF_FUNC_get_route_realm()` | 4.4 | | [`c46646d0484f`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=c46646d0484f5d08e2bede9b45034ba5b8b489cc) @@ -218,6 +221,7 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_rc_keydown()` | 4.18 | GPL | [`f4364dcfc86d`](https://git.kernel.org/cgit/linux/kernel/git/bpf/bpf-next.git/commit/?id=f4364dcfc86df7c1ca47b256eaf6b6d0cdd0d936) `BPF_FUNC_rc_pointer_rel()` | 5.0 | GPL | [`01d3240a04f4`](https://github.com/torvalds/linux/commit/01d3240a04f4c09392e13c77b54d4423ebce2d72) `BPF_FUNC_rc_repeat()` | 4.18 | GPL | [`f4364dcfc86d`](https://git.kernel.org/cgit/linux/kernel/git/bpf/bpf-next.git/commit/?id=f4364dcfc86df7c1ca47b256eaf6b6d0cdd0d936) +`BPF_FUNC_read_branch_records()` | 5.6 | GPL | [`fff7b64355ea`](https://github.com/torvalds/linux/commit/fff7b64355eac6e29b50229ad1512315bc04b44e) `BPF_FUNC_redirect()` | 4.4 | | [`27b29f63058d`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=27b29f63058d26c6c1742f1993338280d5a41dc6) `BPF_FUNC_redirect_map()` | 4.14 | | [`97f91a7cf04f`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=97f91a7cf04ff605845c20948b8a80e54cbd3376) `BPF_FUNC_send_signal()` | 5.3 | | [`8b401f9ed244`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=8b401f9ed2441ad9e219953927a842d24ed051fc) @@ -225,6 +229,7 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_set_hash()` | 4.13 | | [`ded092cd73c2`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=ded092cd73c2c56a394b936f86897f29b2e131c0) `BPF_FUNC_set_hash_invalid()` | 4.9 | | [`7a4b28c6cc9f`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=7a4b28c6cc9ffac50f791b99cc7e46106436e5d8) `BPF_FUNC_setsockopt()` | 4.13 | | [`8c4b4c7e9ff0`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=8c4b4c7e9ff0447995750d9329949fa082520269) +`BPF_FUNC_sk_assign()` | 5.6 | | [`cf7fbe660f2d`](https://github.com/torvalds/linux/commit/cf7fbe660f2dbd738ab58aea8e9b0ca6ad232449) `BPF_FUNC_sk_fullsock()` | 5.1 | | [`46f8bc92758c`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=46f8bc92758c6259bcf945e9216098661c1587cd) `BPF_FUNC_sk_lookup_tcp()` | 4.20 | | [`6acc9b432e67`](https://github.com/torvalds/linux/commit/6acc9b432e6714d72d7d77ec7c27f6f8358d0c71) `BPF_FUNC_sk_lookup_udp()` | 4.20 | | [`6acc9b432e67`](https://github.com/torvalds/linux/commit/6acc9b432e6714d72d7d77ec7c27f6f8358d0c71) @@ -275,6 +280,7 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_xdp_adjust_head()` | 4.10 | | [`17bedab27231`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=17bedab2723145d17b14084430743549e6943d03) `BPF_FUNC_xdp_adjust_meta()` | 4.15 | | [`de8f3a83b0a0`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=de8f3a83b0a0fddb2cf56e7a718127e9619ea3da) `BPF_FUNC_xdp_adjust_tail()` | 4.18 | | [`b32cc5b9a346`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=b32cc5b9a346319c171e3ad905e0cddda032b5eb) +`BPF_FUNC_xdp_output()` | 5.6 | GPL | [`d831ee84bfc9`](https://github.com/torvalds/linux/commit/d831ee84bfc9173eecf30dbbc2553ae81b996c60) `BPF_FUNC_override_return()` | 4.16 | GPL | [`9802d86585db`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9802d86585db91655c7d1929a4f6bbe0952ea88e) `BPF_FUNC_sock_ops_cb_flags_set()` | 4.16 | | [`b13d88072172`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b13d880721729384757f235166068c315326f4a1) @@ -321,5 +327,5 @@ The list of program types and supported helper functions can be retrieved with: |Function Group| Functions| |------------------|-------| |`Base functions`| `BPF_FUNC_map_lookup_elem()`
`BPF_FUNC_map_update_elem()`
`BPF_FUNC_map_delete_elem()`
`BPF_FUNC_map_peek_elem()`
`BPF_FUNC_map_pop_elem()`
`BPF_FUNC_map_push_elem()`
`BPF_FUNC_get_prandom_u32()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_get_numa_node_id()`
`BPF_FUNC_tail_call()`
`BPF_FUNC_ktime_get_ns()`
`BPF_FUNC_trace_printk()`
`BPF_FUNC_spin_lock()`
`BPF_FUNC_spin_unlock()` | -|`Tracing functions`|`BPF_FUNC_map_lookup_elem()`
`BPF_FUNC_map_update_elem()`
`BPF_FUNC_map_delete_elem()`
`BPF_FUNC_probe_read()`
`BPF_FUNC_ktime_get_ns()`
`BPF_FUNC_tail_call()`
`BPF_FUNC_get_current_pid_tgid()`
`BPF_FUNC_get_current_task()`
`BPF_FUNC_get_current_uid_gid()`
`BPF_FUNC_get_current_comm()`
`BPF_FUNC_trace_printk()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_get_numa_node_id()`
`BPF_FUNC_perf_event_read()`
`BPF_FUNC_probe_write_user()`
`BPF_FUNC_current_task_under_cgroup()`
`BPF_FUNC_get_prandom_u32()`
`BPF_FUNC_probe_read_str()`
`BPF_FUNC_get_current_cgroup_id()`
`BPF_FUNC_send_signal()`
`BPF_FUNC_probe_read_kernel()`
`BPF_FUNC_probe_read_kernel_str()`
`BPF_FUNC_probe_read_user()`
`BPF_FUNC_probe_read_user_str()`
`BPF_FUNC_send_signal_thread()`| +|`Tracing functions`|`BPF_FUNC_map_lookup_elem()`
`BPF_FUNC_map_update_elem()`
`BPF_FUNC_map_delete_elem()`
`BPF_FUNC_probe_read()`
`BPF_FUNC_ktime_get_ns()`
`BPF_FUNC_tail_call()`
`BPF_FUNC_get_current_pid_tgid()`
`BPF_FUNC_get_current_task()`
`BPF_FUNC_get_current_uid_gid()`
`BPF_FUNC_get_current_comm()`
`BPF_FUNC_trace_printk()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_get_numa_node_id()`
`BPF_FUNC_perf_event_read()`
`BPF_FUNC_probe_write_user()`
`BPF_FUNC_current_task_under_cgroup()`
`BPF_FUNC_get_prandom_u32()`
`BPF_FUNC_probe_read_str()`
`BPF_FUNC_get_current_cgroup_id()`
`BPF_FUNC_send_signal()`
`BPF_FUNC_probe_read_kernel()`
`BPF_FUNC_probe_read_kernel_str()`
`BPF_FUNC_probe_read_user()`
`BPF_FUNC_probe_read_user_str()`
`BPF_FUNC_send_signal_thread()`
`BPF_FUNC_get_ns_current_pid_tgid()`
`BPF_FUNC_xdp_output()`| |`LWT functions`| `BPF_FUNC_skb_load_bytes()`
`BPF_FUNC_skb_pull_data()`
`BPF_FUNC_csum_diff()`
`BPF_FUNC_get_cgroup_classid()`
`BPF_FUNC_get_route_realm()`
`BPF_FUNC_get_hash_recalc()`
`BPF_FUNC_perf_event_output()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_skb_under_cgroup()`| diff --git a/introspection/bps.c b/introspection/bps.c index c5984c459..97868f7f0 100644 --- a/introspection/bps.c +++ b/introspection/bps.c @@ -45,6 +45,7 @@ static const char * const prog_type_strings[] = { [BPF_PROG_TYPE_TRACING] = "tracing", [BPF_PROG_TYPE_STRUCT_OPS] = "struct_ops", [BPF_PROG_TYPE_EXT] = "ext", + [BPF_PROG_TYPE_LSM] = "lsm", }; static const char * const map_type_strings[] = { diff --git a/src/cc/compat/linux/virtual_bpf.h b/src/cc/compat/linux/virtual_bpf.h index 7b6b41d3a..17b07c366 100644 --- a/src/cc/compat/linux/virtual_bpf.h +++ b/src/cc/compat/linux/virtual_bpf.h @@ -74,7 +74,7 @@ struct bpf_insn { /* Key of an a BPF_MAP_TYPE_LPM_TRIE entry */ struct bpf_lpm_trie_key { __u32 prefixlen; /* up to 32 for AF_INET, 128 for AF_INET6 */ - __u8 data[0]; /* Arbitrary size */ + __u8 data[]; /* Arbitrary size */ }; struct bpf_cgroup_storage_key { @@ -112,6 +112,8 @@ enum bpf_cmd { BPF_MAP_LOOKUP_AND_DELETE_BATCH, BPF_MAP_UPDATE_BATCH, BPF_MAP_DELETE_BATCH, + BPF_LINK_CREATE, + BPF_LINK_UPDATE, }; enum bpf_map_type { @@ -182,6 +184,7 @@ enum bpf_prog_type { BPF_PROG_TYPE_TRACING, BPF_PROG_TYPE_STRUCT_OPS, BPF_PROG_TYPE_EXT, + BPF_PROG_TYPE_LSM, }; enum bpf_attach_type { @@ -211,6 +214,8 @@ enum bpf_attach_type { BPF_TRACE_RAW_TP, BPF_TRACE_FENTRY, BPF_TRACE_FEXIT, + BPF_MODIFY_RETURN, + BPF_LSM_MAC, __MAX_BPF_ATTACH_TYPE }; @@ -326,44 +331,46 @@ enum bpf_attach_type { #define BPF_PSEUDO_CALL 1 /* flags for BPF_MAP_UPDATE_ELEM command */ -#define BPF_ANY 0 /* create new element or update existing */ -#define BPF_NOEXIST 1 /* create new element if it didn't exist */ -#define BPF_EXIST 2 /* update existing element */ -#define BPF_F_LOCK 4 /* spin_lock-ed map_lookup/map_update */ +enum { + BPF_ANY = 0, /* create new element or update existing */ + BPF_NOEXIST = 1, /* create new element if it didn't exist */ + BPF_EXIST = 2, /* update existing element */ + BPF_F_LOCK = 4, /* spin_lock-ed map_lookup/map_update */ +}; /* flags for BPF_MAP_CREATE command */ -#define BPF_F_NO_PREALLOC (1U << 0) +enum { + BPF_F_NO_PREALLOC = (1U << 0), /* Instead of having one common LRU list in the * BPF_MAP_TYPE_LRU_[PERCPU_]HASH map, use a percpu LRU list * which can scale and perform better. * Note, the LRU nodes (including free nodes) cannot be moved * across different LRU lists. */ -#define BPF_F_NO_COMMON_LRU (1U << 1) + BPF_F_NO_COMMON_LRU = (1U << 1), /* Specify numa node during map creation */ -#define BPF_F_NUMA_NODE (1U << 2) - -#define BPF_OBJ_NAME_LEN 16U + BPF_F_NUMA_NODE = (1U << 2), /* Flags for accessing BPF object from syscall side. */ -#define BPF_F_RDONLY (1U << 3) -#define BPF_F_WRONLY (1U << 4) + BPF_F_RDONLY = (1U << 3), + BPF_F_WRONLY = (1U << 4), /* Flag for stack_map, store build_id+offset instead of pointer */ -#define BPF_F_STACK_BUILD_ID (1U << 5) + BPF_F_STACK_BUILD_ID = (1U << 5), /* Zero-initialize hash function seed. This should only be used for testing. */ -#define BPF_F_ZERO_SEED (1U << 6) + BPF_F_ZERO_SEED = (1U << 6), /* Flags for accessing BPF object from program side. */ -#define BPF_F_RDONLY_PROG (1U << 7) -#define BPF_F_WRONLY_PROG (1U << 8) + BPF_F_RDONLY_PROG = (1U << 7), + BPF_F_WRONLY_PROG = (1U << 8), /* Clone map from listener for newly accepted socket */ -#define BPF_F_CLONE (1U << 9) + BPF_F_CLONE = (1U << 9), /* Enable memory-mapping BPF map */ -#define BPF_F_MMAPABLE (1U << 10) + BPF_F_MMAPABLE = (1U << 10), +}; /* Flags for BPF_PROG_QUERY. */ @@ -392,6 +399,8 @@ struct bpf_stack_build_id { }; }; +#define BPF_OBJ_NAME_LEN 16U + union bpf_attr { struct { /* anonymous struct used by BPF_MAP_CREATE command */ __u32 map_type; /* one of enum bpf_map_type */ @@ -535,7 +544,7 @@ union bpf_attr { __u32 prog_cnt; } query; - struct { + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ __u64 name; __u32 prog_fd; } raw_tracepoint; @@ -563,6 +572,24 @@ union bpf_attr { __u64 probe_offset; /* output: probe_offset */ __u64 probe_addr; /* output: probe_addr */ } task_fd_query; + + struct { /* struct used by BPF_LINK_CREATE command */ + __u32 prog_fd; /* eBPF program to attach */ + __u32 target_fd; /* object to attach to */ + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + } link_create; + + struct { /* struct used by BPF_LINK_UPDATE command */ + __u32 link_fd; /* link fd */ + /* new program fd to update link with */ + __u32 new_prog_fd; + __u32 flags; /* extra flags */ + /* expected link's program fd; is specified only if + * BPF_F_REPLACE flag is set in flags */ + __u32 old_prog_fd; + } link_update; + } __attribute__((aligned(8))); /* The description below is an attempt at providing documentation to eBPF @@ -1046,9 +1073,9 @@ union bpf_attr { * supports redirection to the egress interface, and accepts no * flag at all. * - * The same effect can be attained with the more generic - * **bpf_redirect_map**\ (), which requires specific maps to be - * used but offers better performance. + * The same effect can also be attained with the more generic + * **bpf_redirect_map**\ (), which uses a BPF map to store the + * redirect target instead of providing it directly to the helper. * Return * For XDP, the helper returns **XDP_REDIRECT** on success or * **XDP_ABORTED** on error. For other program types, the values @@ -1612,13 +1639,11 @@ union bpf_attr { * the caller. Any higher bits in the *flags* argument must be * unset. * - * When used to redirect packets to net devices, this helper - * provides a high performance increase over **bpf_redirect**\ (). - * This is due to various implementation details of the underlying - * mechanisms, one of which is the fact that **bpf_redirect_map**\ - * () tries to send packet as a "bulk" to the device. + * See also bpf_redirect(), which only supports redirecting to an + * ifindex, but doesn't require a map to do so. * Return - * **XDP_REDIRECT** on success, or **XDP_ABORTED** on error. + * **XDP_REDIRECT** on success, or the value of the two lower bits + * of the **flags* argument on error. * * int bpf_sk_redirect_map(struct sk_buff *skb, struct bpf_map *map, u32 key, u64 flags) * Description @@ -2893,6 +2918,114 @@ union bpf_attr { * Obtain the 64bit jiffies * Return * The 64 bit jiffies + * + * int bpf_read_branch_records(struct bpf_perf_event_data *ctx, void *buf, u32 size, u64 flags) + * Description + * For an eBPF program attached to a perf event, retrieve the + * branch records (struct perf_branch_entry) associated to *ctx* + * and store it in the buffer pointed by *buf* up to size + * *size* bytes. + * Return + * On success, number of bytes written to *buf*. On error, a + * negative value. + * + * The *flags* can be set to **BPF_F_GET_BRANCH_RECORDS_SIZE** to + * instead return the number of bytes required to store all the + * branch entries. If this flag is set, *buf* may be NULL. + * + * **-EINVAL** if arguments invalid or **size** not a multiple + * of sizeof(struct perf_branch_entry). + * + * **-ENOENT** if architecture does not support branch records. + * + * int bpf_get_ns_current_pid_tgid(u64 dev, u64 ino, struct bpf_pidns_info *nsdata, u32 size) + * Description + * Returns 0 on success, values for *pid* and *tgid* as seen from the current + * *namespace* will be returned in *nsdata*. + * + * On failure, the returned value is one of the following: + * + * **-EINVAL** if dev and inum supplied don't match dev_t and inode number + * with nsfs of current task, or if dev conversion to dev_t lost high bits. + * + * **-ENOENT** if pidns does not exists for the current task. + * + * int bpf_xdp_output(void *ctx, struct bpf_map *map, u64 flags, void *data, u64 size) + * Description + * Write raw *data* blob into a special BPF perf event held by + * *map* of type **BPF_MAP_TYPE_PERF_EVENT_ARRAY**. This perf + * event must have the following attributes: **PERF_SAMPLE_RAW** + * as **sample_type**, **PERF_TYPE_SOFTWARE** as **type**, and + * **PERF_COUNT_SW_BPF_OUTPUT** as **config**. + * + * The *flags* are used to indicate the index in *map* for which + * the value must be put, masked with **BPF_F_INDEX_MASK**. + * Alternatively, *flags* can be set to **BPF_F_CURRENT_CPU** + * to indicate that the index of the current CPU core should be + * used. + * + * The value to write, of *size*, is passed through eBPF stack and + * pointed by *data*. + * + * *ctx* is a pointer to in-kernel struct xdp_buff. + * + * This helper is similar to **bpf_perf_eventoutput**\ () but + * restricted to raw_tracepoint bpf programs. + * Return + * 0 on success, or a negative error in case of failure. + * + * u64 bpf_get_netns_cookie(void *ctx) + * Description + * Retrieve the cookie (generated by the kernel) of the network + * namespace the input *ctx* is associated with. The network + * namespace cookie remains stable for its lifetime and provides + * a global identifier that can be assumed unique. If *ctx* is + * NULL, then the helper returns the cookie for the initial + * network namespace. The cookie itself is very similar to that + * of bpf_get_socket_cookie() helper, but for network namespaces + * instead of sockets. + * Return + * A 8-byte long opaque number. + * + * u64 bpf_get_current_ancestor_cgroup_id(int ancestor_level) + * Description + * Return id of cgroup v2 that is ancestor of the cgroup associated + * with the current task at the *ancestor_level*. The root cgroup + * is at *ancestor_level* zero and each step down the hierarchy + * increments the level. If *ancestor_level* == level of cgroup + * associated with the current task, then return value will be the + * same as that of **bpf_get_current_cgroup_id**\ (). + * + * The helper is useful to implement policies based on cgroups + * that are upper in hierarchy than immediate cgroup associated + * with the current task. + * + * The format of returned id and helper limitations are same as in + * **bpf_get_current_cgroup_id**\ (). + * Return + * The id is returned or 0 in case the id could not be retrieved. + * + * int bpf_sk_assign(struct sk_buff *skb, struct bpf_sock *sk, u64 flags) + * Description + * Assign the *sk* to the *skb*. When combined with appropriate + * routing configuration to receive the packet towards the socket, + * will cause *skb* to be delivered to the specified socket. + * Subsequent redirection of *skb* via **bpf_redirect**\ (), + * **bpf_clone_redirect**\ () or other methods outside of BPF may + * interfere with successful delivery to the socket. + * + * This operation is only valid from TC ingress path. + * + * The *flags* argument must be zero. + * Return + * 0 on success, or a negative errno in case of failure. + * + * * **-EINVAL** Unsupported flags specified. + * * **-ENOENT** Socket is unavailable for assignment. + * * **-ENETUNREACH** Socket is unreachable (wrong netns). + * * **-EOPNOTSUPP** Unsupported operation, for example a + * call from outside of TC ingress. + * * **-ESOCKTNOSUPPORT** Socket type not supported (reuseport). */ #define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ @@ -3013,7 +3146,13 @@ union bpf_attr { FN(probe_read_kernel_str), \ FN(tcp_send_ack), \ FN(send_signal_thread), \ - FN(jiffies64), + FN(jiffies64), \ + FN(read_branch_records), \ + FN(get_ns_current_pid_tgid), \ + FN(xdp_output), \ + FN(get_netns_cookie), \ + FN(get_current_ancestor_cgroup_id), \ + FN(sk_assign), /* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call @@ -3028,69 +3167,100 @@ enum bpf_func_id { /* All flags used by eBPF helper functions, placed here. */ /* BPF_FUNC_skb_store_bytes flags. */ -#define BPF_F_RECOMPUTE_CSUM (1ULL << 0) -#define BPF_F_INVALIDATE_HASH (1ULL << 1) +enum { + BPF_F_RECOMPUTE_CSUM = (1ULL << 0), + BPF_F_INVALIDATE_HASH = (1ULL << 1), +}; /* BPF_FUNC_l3_csum_replace and BPF_FUNC_l4_csum_replace flags. * First 4 bits are for passing the header field size. */ -#define BPF_F_HDR_FIELD_MASK 0xfULL +enum { + BPF_F_HDR_FIELD_MASK = 0xfULL, +}; /* BPF_FUNC_l4_csum_replace flags. */ -#define BPF_F_PSEUDO_HDR (1ULL << 4) -#define BPF_F_MARK_MANGLED_0 (1ULL << 5) -#define BPF_F_MARK_ENFORCE (1ULL << 6) +enum { + BPF_F_PSEUDO_HDR = (1ULL << 4), + BPF_F_MARK_MANGLED_0 = (1ULL << 5), + BPF_F_MARK_ENFORCE = (1ULL << 6), +}; /* BPF_FUNC_clone_redirect and BPF_FUNC_redirect flags. */ -#define BPF_F_INGRESS (1ULL << 0) +enum { + BPF_F_INGRESS = (1ULL << 0), +}; /* BPF_FUNC_skb_set_tunnel_key and BPF_FUNC_skb_get_tunnel_key flags. */ -#define BPF_F_TUNINFO_IPV6 (1ULL << 0) +enum { + BPF_F_TUNINFO_IPV6 = (1ULL << 0), +}; /* flags for both BPF_FUNC_get_stackid and BPF_FUNC_get_stack. */ -#define BPF_F_SKIP_FIELD_MASK 0xffULL -#define BPF_F_USER_STACK (1ULL << 8) +enum { + BPF_F_SKIP_FIELD_MASK = 0xffULL, + BPF_F_USER_STACK = (1ULL << 8), /* flags used by BPF_FUNC_get_stackid only. */ -#define BPF_F_FAST_STACK_CMP (1ULL << 9) -#define BPF_F_REUSE_STACKID (1ULL << 10) + BPF_F_FAST_STACK_CMP = (1ULL << 9), + BPF_F_REUSE_STACKID = (1ULL << 10), /* flags used by BPF_FUNC_get_stack only. */ -#define BPF_F_USER_BUILD_ID (1ULL << 11) + BPF_F_USER_BUILD_ID = (1ULL << 11), +}; /* BPF_FUNC_skb_set_tunnel_key flags. */ -#define BPF_F_ZERO_CSUM_TX (1ULL << 1) -#define BPF_F_DONT_FRAGMENT (1ULL << 2) -#define BPF_F_SEQ_NUMBER (1ULL << 3) +enum { + BPF_F_ZERO_CSUM_TX = (1ULL << 1), + BPF_F_DONT_FRAGMENT = (1ULL << 2), + BPF_F_SEQ_NUMBER = (1ULL << 3), +}; /* BPF_FUNC_perf_event_output, BPF_FUNC_perf_event_read and * BPF_FUNC_perf_event_read_value flags. */ -#define BPF_F_INDEX_MASK 0xffffffffULL -#define BPF_F_CURRENT_CPU BPF_F_INDEX_MASK +enum { + BPF_F_INDEX_MASK = 0xffffffffULL, + BPF_F_CURRENT_CPU = BPF_F_INDEX_MASK, /* BPF_FUNC_perf_event_output for sk_buff input context. */ -#define BPF_F_CTXLEN_MASK (0xfffffULL << 32) + BPF_F_CTXLEN_MASK = (0xfffffULL << 32), +}; /* Current network namespace */ -#define BPF_F_CURRENT_NETNS (-1L) +enum { + BPF_F_CURRENT_NETNS = (-1L), +}; /* BPF_FUNC_skb_adjust_room flags. */ -#define BPF_F_ADJ_ROOM_FIXED_GSO (1ULL << 0) +enum { + BPF_F_ADJ_ROOM_FIXED_GSO = (1ULL << 0), + BPF_F_ADJ_ROOM_ENCAP_L3_IPV4 = (1ULL << 1), + BPF_F_ADJ_ROOM_ENCAP_L3_IPV6 = (1ULL << 2), + BPF_F_ADJ_ROOM_ENCAP_L4_GRE = (1ULL << 3), + BPF_F_ADJ_ROOM_ENCAP_L4_UDP = (1ULL << 4), +}; -#define BPF_ADJ_ROOM_ENCAP_L2_MASK 0xff -#define BPF_ADJ_ROOM_ENCAP_L2_SHIFT 56 +enum { + BPF_ADJ_ROOM_ENCAP_L2_MASK = 0xff, + BPF_ADJ_ROOM_ENCAP_L2_SHIFT = 56, +}; -#define BPF_F_ADJ_ROOM_ENCAP_L3_IPV4 (1ULL << 1) -#define BPF_F_ADJ_ROOM_ENCAP_L3_IPV6 (1ULL << 2) -#define BPF_F_ADJ_ROOM_ENCAP_L4_GRE (1ULL << 3) -#define BPF_F_ADJ_ROOM_ENCAP_L4_UDP (1ULL << 4) #define BPF_F_ADJ_ROOM_ENCAP_L2(len) (((__u64)len & \ BPF_ADJ_ROOM_ENCAP_L2_MASK) \ << BPF_ADJ_ROOM_ENCAP_L2_SHIFT) /* BPF_FUNC_sysctl_get_name flags. */ -#define BPF_F_SYSCTL_BASE_NAME (1ULL << 0) +enum { + BPF_F_SYSCTL_BASE_NAME = (1ULL << 0), +}; /* BPF_FUNC_sk_storage_get flags */ -#define BPF_SK_STORAGE_GET_F_CREATE (1ULL << 0) +enum { + BPF_SK_STORAGE_GET_F_CREATE = (1ULL << 0), +}; + +/* BPF_FUNC_read_branch_records flags. */ +enum { + BPF_F_GET_BRANCH_RECORDS_SIZE = (1ULL << 0), +}; /* Mode for BPF_FUNC_skb_adjust_room helper. */ enum bpf_adj_room_mode { @@ -3156,6 +3326,7 @@ struct __sk_buff { __u32 wire_len; __u32 gso_segs; __bpf_md_ptr(struct bpf_sock *, sk); + __u32 gso_size; }; struct bpf_tunnel_key { @@ -3508,13 +3679,14 @@ struct bpf_sock_ops { }; /* Definitions for bpf_sock_ops_cb_flags */ -#define BPF_SOCK_OPS_RTO_CB_FLAG (1<<0) -#define BPF_SOCK_OPS_RETRANS_CB_FLAG (1<<1) -#define BPF_SOCK_OPS_STATE_CB_FLAG (1<<2) -#define BPF_SOCK_OPS_RTT_CB_FLAG (1<<3) -#define BPF_SOCK_OPS_ALL_CB_FLAGS 0xF /* Mask of all currently - * supported cb flags - */ +enum { + BPF_SOCK_OPS_RTO_CB_FLAG = (1<<0), + BPF_SOCK_OPS_RETRANS_CB_FLAG = (1<<1), + BPF_SOCK_OPS_STATE_CB_FLAG = (1<<2), + BPF_SOCK_OPS_RTT_CB_FLAG = (1<<3), +/* Mask of all currently supported cb flags */ + BPF_SOCK_OPS_ALL_CB_FLAGS = 0xF, +}; /* List of known BPF sock_ops operators. * New entries can only be added at the end @@ -3593,8 +3765,10 @@ enum { BPF_TCP_MAX_STATES /* Leave at the end! */ }; -#define TCP_BPF_IW 1001 /* Set TCP initial congestion window */ -#define TCP_BPF_SNDCWND_CLAMP 1002 /* Set sndcwnd_clamp */ +enum { + TCP_BPF_IW = 1001, /* Set TCP initial congestion window */ + TCP_BPF_SNDCWND_CLAMP = 1002, /* Set sndcwnd_clamp */ +}; struct bpf_perf_event_value { __u64 counter; @@ -3602,12 +3776,16 @@ struct bpf_perf_event_value { __u64 running; }; -#define BPF_DEVCG_ACC_MKNOD (1ULL << 0) -#define BPF_DEVCG_ACC_READ (1ULL << 1) -#define BPF_DEVCG_ACC_WRITE (1ULL << 2) +enum { + BPF_DEVCG_ACC_MKNOD = (1ULL << 0), + BPF_DEVCG_ACC_READ = (1ULL << 1), + BPF_DEVCG_ACC_WRITE = (1ULL << 2), +}; -#define BPF_DEVCG_DEV_BLOCK (1ULL << 0) -#define BPF_DEVCG_DEV_CHAR (1ULL << 1) +enum { + BPF_DEVCG_DEV_BLOCK = (1ULL << 0), + BPF_DEVCG_DEV_CHAR = (1ULL << 1), +}; struct bpf_cgroup_dev_ctx { /* access_type encoded as (BPF_DEVCG_ACC_* << 16) | BPF_DEVCG_DEV_* */ @@ -3623,8 +3801,10 @@ struct bpf_raw_tracepoint_args { /* DIRECT: Skip the FIB rules and go to FIB table associated with device * OUTPUT: Do lookup from egress perspective; default is ingress */ -#define BPF_FIB_LOOKUP_DIRECT (1U << 0) -#define BPF_FIB_LOOKUP_OUTPUT (1U << 1) +enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), +}; enum { BPF_FIB_LKUP_RET_SUCCESS, /* lookup successful */ @@ -3696,9 +3876,11 @@ enum bpf_task_fd_type { BPF_FD_TYPE_URETPROBE, /* filename + offset */ }; -#define BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG (1U << 0) -#define BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL (1U << 1) -#define BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP (1U << 2) +enum { + BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG = (1U << 0), + BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL = (1U << 1), + BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP = (1U << 2), +}; struct bpf_flow_keys { __u16 nhoff; @@ -3764,5 +3946,9 @@ struct bpf_sockopt { __s32 retval; }; +struct bpf_pidns_info { + __u32 pid; + __u32 tgid; +}; #endif /* _UAPI__LINUX_BPF_H__ */ )********" diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index 590f4d8df..b38b3f200 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -614,11 +614,36 @@ static int (*bpf_probe_read_user_str)(void *dst, __u32 size, static int (*bpf_probe_read_kernel_str)(void *dst, __u32 size, const void *unsafe_ptr) = (void *)BPF_FUNC_probe_read_kernel_str; +static int (*bpf_tcp_send_ack)(void *tp, __u32 rcv_nxt) = + (void *)BPF_FUNC_tcp_send_ack; +static int (*bpf_send_signal_thread)(__u32 sig) = + (void *)BPF_FUNC_send_signal_thread; +static __u64 (*bpf_jiffies64)(void) = (void *)BPF_FUNC_jiffies64; + +struct bpf_perf_event_data; +static int (*bpf_read_branch_records)(struct bpf_perf_event_data *ctx, void *buf, + __u32 size, __u64 flags) = + (void *)BPF_FUNC_read_branch_records; +static int (*bpf_get_ns_current_pid_tgid)(__u64 dev, __u64 ino, + struct bpf_pidns_info *nsdata, + __u32 size) = + (void *)BPF_FUNC_get_ns_current_pid_tgid; + +struct bpf_map; +static int (*bpf_xdp_output)(void *ctx, struct bpf_map *map, __u64 flags, + void *data, __u64 size) = + (void *)BPF_FUNC_xdp_output; +static __u64 (*bpf_get_netns_cookie)(void *ctx) = (void *)BPF_FUNC_get_netns_cookie; +static __u64 (*bpf_get_current_ancestor_cgroup_id)(int ancestor_level) = + (void *)BPF_FUNC_get_current_ancestor_cgroup_id; + +struct sk_buff; +static int (*bpf_sk_assign)(struct sk_buff *skb, struct bpf_sock *sk, __u64 flags) = + (void *)BPF_FUNC_sk_assign; /* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions */ -struct sk_buff; unsigned long long load_byte(void *skb, unsigned long long off) asm("llvm.bpf.load.byte"); unsigned long long load_half(void *skb, diff --git a/src/cc/libbpf b/src/cc/libbpf index 9f0d55c24..6a1615c26 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit 9f0d55c24afbd7b3aaf04cc3f99299115e4d0a98 +Subproject commit 6a1615c263b679c17ecb292fa897f159e826dc10 diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index a610e01da..0ce826748 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -215,6 +215,12 @@ static struct bpf_helper helpers[] = { {"tcp_send_ack", "5.5"}, {"send_signal_thread", "5.5"}, {"jiffies64", "5.5"}, + {"read_branch_records", "5.6"}, + {"get_ns_current_pid_tgid", "5.6"}, + {"xdp_output", "5.6"}, + {"get_netns_cookie", "5.6"}, + {"get_current_ancestor_cgroup_id", "5.6"}, + {"sk_assign", "5.6"}, }; static uint64_t ptr_to_u64(void *ptr) From ceb458d6a07a42d8d6d3c16a3b8e387b5131d610 Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Mon, 20 Apr 2020 18:19:33 -0700 Subject: [PATCH 093/278] prepare for release v0.14.0 added changelog for release v0.14.0 --- debian/changelog | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/debian/changelog b/debian/changelog index 57464abe9..79351d17f 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,14 @@ +bcc (0.14.0-1) unstable; urgency=low + + * Support for kernel up to 5.6 + * new tools: biolatpcts.py + * libbpf-tools: tools based on CORE and libbpf library directly + * add --cgroupmap to various tools, filtering based cgroup + * support kfunc (faster kprobe) for vfsstat, klockstat and opensnoop + * lots of bug fixes and a few additional arguments for tools + + -- Yonghong Song Mon, 20 Apr 2020 17:00:00 +0000 + bcc (0.13.0-1) unstable; urgency=low * Support for kernel up to 5.5 From d2e8ea47352e36f63a9dda281c00fadeb87e890a Mon Sep 17 00:00:00 2001 From: Sandipan Das Date: Tue, 21 Apr 2020 11:13:03 +0530 Subject: [PATCH 094/278] Fix ELF ABI and endianness checks for powerpc64 Earlier, it was assumed that ELF ABI v2 is used only on little-endian powerpc64 environments but it seems this ABI can be used independently of endianness. It is expected that any C preprocessor that conforms to the ELF ABI v2 specification must predefine the _CALL_ELF macro and set its value to 2. Instead of looking at __BYTE_ORDER__ to determine whether to use the Local Entry Point (LEP) of symbols, one should look at the _CALL_ELF macro instead as this is ABI-related. Similarly, _CALL_ELF should be used only for determining the ABI version and not the endianness. Reported-by: Naveen N. Rao Fixes: bbd4180c ("Fix uprobes on powerpc64") Fixes: 10869523 ("clang: Add support to build eBPF for user specified ARCH") Acked-by: Naveen N. Rao Signed-off-by: Sandipan Das --- src/cc/bcc_elf.c | 20 ++++++++++---------- src/cc/bcc_syms.cc | 4 ++-- src/cc/bcc_syms.h | 4 ++-- src/cc/frontends/clang/arch_helper.h | 4 ++-- tests/cc/test_c_api.cc | 4 ++-- 5 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/cc/bcc_elf.c b/src/cc/bcc_elf.c index 584257199..22b37397a 100644 --- a/src/cc/bcc_elf.c +++ b/src/cc/bcc_elf.c @@ -257,16 +257,8 @@ static int list_in_scn(Elf *e, Elf_Scn *section, size_t stridx, size_t symsize, continue; #ifdef __powerpc64__ -#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ - if (opddata && sym.st_shndx == opdidx) { - size_t offset = sym.st_value - opdshdr.sh_addr; - /* Find the function descriptor */ - uint64_t *descr = opddata->d_buf + offset; - /* Read the actual entry point address from the descriptor */ - sym.st_value = *descr; - } -#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ - if (option->use_symbol_type & (1 << STT_PPC64LE_SYM_LEP)) { +#if defined(_CALL_ELF) && _CALL_ELF == 2 + if (option->use_symbol_type & (1 << STT_PPC64_ELFV2_SYM_LEP)) { /* * The PowerPC 64-bit ELF v2 ABI says that the 3 most significant bits * in the st_other field of the symbol table specifies the number of @@ -287,6 +279,14 @@ static int list_in_scn(Elf *e, Elf_Scn *section, size_t stridx, size_t symsize, case 6: sym.st_value += 64; break; } } +#else + if (opddata && sym.st_shndx == opdidx) { + size_t offset = sym.st_value - opdshdr.sh_addr; + /* Find the function descriptor */ + uint64_t *descr = opddata->d_buf + offset; + /* Read the actual entry point address from the descriptor */ + sym.st_value = *descr; + } #endif #endif diff --git a/src/cc/bcc_syms.cc b/src/cc/bcc_syms.cc index 49439f43d..b3a101677 100644 --- a/src/cc/bcc_syms.cc +++ b/src/cc/bcc_syms.cc @@ -712,8 +712,8 @@ int bcc_resolve_symname(const char *module, const char *symname, .use_debug_file = 1, .check_debug_file_crc = 1, .lazy_symbolize = 1, -#if defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ - .use_symbol_type = BCC_SYM_ALL_TYPES | (1 << STT_PPC64LE_SYM_LEP), +#if defined(__powerpc64__) && defined(_CALL_ELF) && _CALL_ELF == 2 + .use_symbol_type = BCC_SYM_ALL_TYPES | (1 << STT_PPC64_ELFV2_SYM_LEP), #else .use_symbol_type = BCC_SYM_ALL_TYPES, #endif diff --git a/src/cc/bcc_syms.h b/src/cc/bcc_syms.h index 352d385bd..80627debe 100644 --- a/src/cc/bcc_syms.h +++ b/src/cc/bcc_syms.h @@ -38,10 +38,10 @@ struct mod_info; #define STT_GNU_IFUNC 10 #endif -#if defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +#if defined(__powerpc64__) && defined(_CALL_ELF) && _CALL_ELF == 2 // Indicate if the Local Entry Point (LEP) should be used as a symbol's // start address -#define STT_PPC64LE_SYM_LEP 31 +#define STT_PPC64_ELFV2_SYM_LEP 31 #endif static const uint32_t BCC_SYM_ALL_TYPES = 65535; diff --git a/src/cc/frontends/clang/arch_helper.h b/src/cc/frontends/clang/arch_helper.h index 76b465102..9240583fe 100644 --- a/src/cc/frontends/clang/arch_helper.h +++ b/src/cc/frontends/clang/arch_helper.h @@ -34,7 +34,7 @@ static void *run_arch_callback(arch_callback_t fn) /* If ARCH is not set, detect from local arch clang is running on */ if (!archenv) { #if defined(__powerpc64__) -#if defined(_CALL_ELF) && _CALL_ELF == 2 +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ return fn(BCC_ARCH_PPC_LE); #else return fn(BCC_ARCH_PPC); @@ -50,7 +50,7 @@ static void *run_arch_callback(arch_callback_t fn) /* Otherwise read it from ARCH */ if (!strcmp(archenv, "powerpc")) { -#if defined(_CALL_ELF) && _CALL_ELF == 2 +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ return fn(BCC_ARCH_PPC_LE); #else return fn(BCC_ARCH_PPC); diff --git a/tests/cc/test_c_api.cc b/tests/cc/test_c_api.cc index d1977bfdd..e456840d1 100644 --- a/tests/cc/test_c_api.cc +++ b/tests/cc/test_c_api.cc @@ -205,8 +205,8 @@ TEST_CASE("resolve symbol addresses for a given PID", "[c_api]") { .use_debug_file = 1, .check_debug_file_crc = 1, .lazy_symbolize = 1, -#if defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ - .use_symbol_type = BCC_SYM_ALL_TYPES | (1 << STT_PPC64LE_SYM_LEP), +#if defined(__powerpc64__) && defined(_CALL_ELF) && _CALL_ELF == 2 + .use_symbol_type = BCC_SYM_ALL_TYPES | (1 << STT_PPC64_ELFV2_SYM_LEP), #else .use_symbol_type = BCC_SYM_ALL_TYPES, #endif From 264b2ccf4e42f7f1b9abb89fb320d0467c509e37 Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Tue, 7 Apr 2020 18:30:44 +0200 Subject: [PATCH 095/278] bcc: Use bpf_probe_read_user in tools and provide backward compatibility s390 has overlapping address space for user and kernel. Hence separation of bpf_probe_read_user and bpf_probe_read_kernel is essential. Commit 6ae08ae3dea2 ("bpf: Add probe_read_{user, kernel} and probe_read_{user, kernel}_str helpers") introduced these changes into the kernel. However, bcc tools does not respect it. As a workaround, perform the following: 1. Use bpf_probe_read_user() explicitly in the bcc tools. 2. When kernel version < 5.5, perform the checks if the bpf_probe_read_user kernel helper is present in the backported kernel as well. If not found, then fallback from bpf_probe_read_user to bpf_probe_read. Signed-off-by: Sumanth Korikkar --- src/cc/export/helpers.h | 9 ++-- src/cc/frontends/clang/b_frontend_action.cc | 49 +++++++++++++++++++-- tools/ttysnoop.py | 2 +- 3 files changed, 52 insertions(+), 8 deletions(-) diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index b38b3f200..b0ffc4f27 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -602,6 +602,7 @@ static long long (*bpf_tcp_gen_syncookie)(struct bpf_sock *sk, void *ip, static int (*bpf_skb_output)(void *ctx, void *map, __u64 flags, void *data, __u64 size) = (void *)BPF_FUNC_skb_output; + static int (*bpf_probe_read_user)(void *dst, __u32 size, const void *unsafe_ptr) = (void *)BPF_FUNC_probe_read_user; @@ -887,8 +888,8 @@ int bpf_usdt_readarg_p(int argc, struct pt_regs *ctx, void *buf, u64 len) asm("l #if defined(__TARGET_ARCH_x86) #define bpf_target_x86 #define bpf_target_defined -#elif defined(__TARGET_ARCH_s930x) -#define bpf_target_s930x +#elif defined(__TARGET_ARCH_s390x) +#define bpf_target_s390x #define bpf_target_defined #elif defined(__TARGET_ARCH_arm64) #define bpf_target_arm64 @@ -905,7 +906,7 @@ int bpf_usdt_readarg_p(int argc, struct pt_regs *ctx, void *buf, u64 len) asm("l #if defined(__x86_64__) #define bpf_target_x86 #elif defined(__s390x__) -#define bpf_target_s930x +#define bpf_target_s390x #elif defined(__aarch64__) #define bpf_target_arm64 #elif defined(__powerpc__) @@ -923,7 +924,7 @@ int bpf_usdt_readarg_p(int argc, struct pt_regs *ctx, void *buf, u64 len) asm("l #define PT_REGS_RC(ctx) ((ctx)->gpr[3]) #define PT_REGS_IP(ctx) ((ctx)->nip) #define PT_REGS_SP(ctx) ((ctx)->gpr[1]) -#elif defined(bpf_target_s930x) +#elif defined(bpf_target_s390x) #define PT_REGS_PARM1(x) ((x)->gprs[2]) #define PT_REGS_PARM2(x) ((x)->gprs[3]) #define PT_REGS_PARM3(x) ((x)->gprs[4]) diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc index 89511effd..6087c807e 100644 --- a/src/cc/frontends/clang/b_frontend_action.cc +++ b/src/cc/frontends/clang/b_frontend_action.cc @@ -37,6 +37,7 @@ #include "bcc_libbpf_inc.h" #include "libbpf.h" +#include "bcc_syms.h" namespace ebpf { @@ -82,6 +83,30 @@ const char **get_call_conv(void) { return ret; } +static std::string check_bpf_probe_read_user(llvm::StringRef probe) { + if (probe.str() == "bpf_probe_read_user" || + probe.str() == "bpf_probe_read_user_str") { +#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 5, 0) + return probe.str(); +#else + // Check for probe_user symbols in backported kernels before fallback + void *resolver = bcc_symcache_new(-1, nullptr); + uint64_t addr = 0; + bool found = bcc_symcache_resolve_name(resolver, nullptr, + "bpf_probe_read_user", &addr) >= 0 ? true: false; + if (found) + return probe.str(); + + if (probe.str() == "bpf_probe_read_user") { + return "bpf_probe_read"; + } else { + return "bpf_probe_read_str"; + } +#endif + } + return ""; +} + using std::map; using std::move; using std::set; @@ -947,6 +972,22 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) { } else if (Call->getCalleeDecl()) { NamedDecl *Decl = dyn_cast(Call->getCalleeDecl()); if (!Decl) return true; + + string text; + + std::string probe = check_bpf_probe_read_user(Decl->getName()); + if (probe != "") { + vector probe_args; + + for (auto arg : Call->arguments()) + probe_args.push_back( + rewriter_.getRewrittenText(expansionRange(arg->getSourceRange()))); + + text = probe + "(" + probe_args[0] + ", " + probe_args[1] + ", " + + probe_args[2] + ")"; + rewriter_.ReplaceText(expansionRange(Call->getSourceRange()), text); + } + if (AsmLabelAttr *A = Decl->getAttr()) { // Functions with the tag asm("llvm.bpf.extra") are implemented in the // rewriter rather than as a macro since they may also include nested @@ -959,10 +1000,10 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) { } vector args; + for (auto arg : Call->arguments()) args.push_back(rewriter_.getRewrittenText(expansionRange(arg->getSourceRange()))); - string text; if (Decl->getName() == "incr_cksum_l3") { text = "bpf_l3_csum_replace_(" + fn_args_[0]->getName().str() + ", (u64)"; text += args[0] + ", " + args[1] + ", " + args[2] + ", sizeof(" + args[2] + "))"; @@ -994,8 +1035,10 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) { text = "({ u64 __addr = 0x0; "; text += "_bpf_readarg_" + current_fn_ + "_" + args[0] + "(" + args[1] + ", &__addr, sizeof(__addr));"; - text += "bpf_probe_read(" + args[2] + ", " + args[3] + - ", (void *)__addr);"; + + text += check_bpf_probe_read_user(StringRef("bpf_probe_read_user")); + + text += "(" + args[2] + ", " + args[3] + ", (void *)__addr);"; text += "})"; rewriter_.ReplaceText(expansionRange(Call->getSourceRange()), text); } else if (Decl->getName() == "bpf_usdt_readarg") { diff --git a/tools/ttysnoop.py b/tools/ttysnoop.py index 058dc7e34..24c118054 100755 --- a/tools/ttysnoop.py +++ b/tools/ttysnoop.py @@ -80,7 +80,7 @@ def usage(): // bpf_probe_read() can only use a fixed size, so truncate to count // in user space: struct data_t data = {}; - bpf_probe_read(&data.buf, BUFSIZE, (void *)buf); + bpf_probe_read_user(&data.buf, BUFSIZE, (void *)buf); if (count > BUFSIZE) data.count = BUFSIZE; else From ac157b474b2e2964ec2cba81574f2bddbd62b42b Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Mon, 20 Apr 2020 08:52:06 -0500 Subject: [PATCH 096/278] bcc: Use direct parameter assignment for syscall probe s390. 1. Commit fa697140f9a2 ("syscalls/x86: Use 'struct pt_regs' based syscall calling convention for 64-bit syscalls") changed the raw parameter passed to the syscall entry function from a list of parameters supplied in user space to a single `pt_regs *` parameter (ARCH_HAS_SYSCALL_WRAPPER) 2. But ARCH_HAS_SYSCALL_WRAPPER in s390 is not used for that purpose. See commit a18f03cd89e9 ("s390: autogenerate compat syscall wrappers") 3. Use direct parameter assignment assumption for s390 syscall probe instead. Signed-off-by: Sumanth Korikkar --- src/cc/frontends/clang/b_frontend_action.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc index 6087c807e..0deaac05d 100644 --- a/src/cc/frontends/clang/b_frontend_action.cc +++ b/src/cc/frontends/clang/b_frontend_action.cc @@ -726,7 +726,7 @@ void BTypeVisitor::rewriteFuncParam(FunctionDecl *D) { // it in case of "syscall__" for other architectures. if (strncmp(D->getName().str().c_str(), "syscall__", 9) == 0 || strncmp(D->getName().str().c_str(), "kprobe____x64_sys_", 18) == 0) { - preamble += "#ifdef CONFIG_ARCH_HAS_SYSCALL_WRAPPER\n"; + preamble += "#if defined(CONFIG_ARCH_HAS_SYSCALL_WRAPPER) && !defined(__s390x__)\n"; genParamIndirectAssign(D, preamble, calling_conv_regs); preamble += "\n#else\n"; genParamDirectAssign(D, preamble, calling_conv_regs); From 023154c7708087ddf6c2031cef5d25c2445b70c4 Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Mon, 20 Apr 2020 05:54:57 -0500 Subject: [PATCH 097/278] bcc/tools: Introduce bpf_probe_read_user to the tools. This is essential for architecture which do have overlapping address space. - bpf_probe_read_kernel() shall be used for reading data from kernel space to the bpf vm. - bpf_probe_read_user() shall be used for reading data from user space to the bpf vm. Signed-off-by: Sumanth Korikkar --- examples/cpp/RecordMySQLQuery.cc | 2 +- examples/lua/bashreadline.c | 3 ++- examples/lua/strlen_count.lua | 2 +- examples/lua/usdt_ruby.lua | 2 +- examples/tracing/mysqld_query.py | 2 +- examples/tracing/nodejs_http_server.py | 2 +- examples/tracing/strlen_count.py | 2 +- examples/tracing/strlen_snoop.py | 2 +- tools/bashreadline.py | 2 +- tools/biosnoop.lua | 3 ++- tools/biosnoop.py | 3 ++- tools/dbslower.py | 12 +++++++++--- tools/execsnoop.py | 4 ++-- tools/funcslower.py | 10 ++++++++++ tools/gethostlatency.py | 2 +- tools/lib/ucalls.py | 8 ++++---- tools/lib/uflow.py | 4 ++-- tools/lib/ugc.py | 4 ++-- tools/lib/uobjnew.py | 4 ++-- tools/lib/uthreads.py | 2 +- tools/mountsnoop.py | 10 +++++----- tools/mysqld_qslower.py | 2 +- tools/opensnoop.py | 6 +++--- tools/sslsniff.py | 4 ++-- tools/statsnoop.py | 2 +- 25 files changed, 59 insertions(+), 40 deletions(-) diff --git a/examples/cpp/RecordMySQLQuery.cc b/examples/cpp/RecordMySQLQuery.cc index 09233ac7c..6d49eee9b 100644 --- a/examples/cpp/RecordMySQLQuery.cc +++ b/examples/cpp/RecordMySQLQuery.cc @@ -34,7 +34,7 @@ int probe_mysql_query(struct pt_regs *ctx, void* thd, char* query, size_t len) { key.ts = bpf_ktime_get_ns(); key.pid = bpf_get_current_pid_tgid(); - bpf_probe_read_str(&key.query, sizeof(key.query), query); + bpf_probe_read_user_str(&key.query, sizeof(key.query), query); int one = 1; queries.update(&key, &one); diff --git a/examples/lua/bashreadline.c b/examples/lua/bashreadline.c index fad33d7dd..917f944d8 100644 --- a/examples/lua/bashreadline.c +++ b/examples/lua/bashreadline.c @@ -15,7 +15,8 @@ int printret(struct pt_regs *ctx) return 0; pid = bpf_get_current_pid_tgid(); data.pid = pid; - bpf_probe_read(&data.str, sizeof(data.str), (void *)PT_REGS_RC(ctx)); + bpf_probe_read_user(&data.str, sizeof(data.str), + (void *)PT_REGS_RC(ctx)); events.perf_submit(ctx, &data, sizeof(data)); return 0; }; diff --git a/examples/lua/strlen_count.lua b/examples/lua/strlen_count.lua index 553d043e7..5a6b00091 100755 --- a/examples/lua/strlen_count.lua +++ b/examples/lua/strlen_count.lua @@ -26,7 +26,7 @@ int printarg(struct pt_regs *ctx) { if (pid != PID) return 0; char str[128] = {}; - bpf_probe_read(&str, sizeof(str), (void *)PT_REGS_PARM1(ctx)); + bpf_probe_read_user(&str, sizeof(str), (void *)PT_REGS_PARM1(ctx)); bpf_trace_printk("strlen(\"%s\")\n", &str); return 0; }; diff --git a/examples/lua/usdt_ruby.lua b/examples/lua/usdt_ruby.lua index 5b5df2d0f..94c059c28 100755 --- a/examples/lua/usdt_ruby.lua +++ b/examples/lua/usdt_ruby.lua @@ -22,7 +22,7 @@ int trace_method(struct pt_regs *ctx) { bpf_usdt_readarg(2, ctx, &addr); char fn_name[128] = {}; - bpf_probe_read(&fn_name, sizeof(fn_name), (void *)addr); + bpf_probe_read_user(&fn_name, sizeof(fn_name), (void *)addr); bpf_trace_printk("%s(...)\n", fn_name); return 0; diff --git a/examples/tracing/mysqld_query.py b/examples/tracing/mysqld_query.py index ace07150d..2f857277b 100755 --- a/examples/tracing/mysqld_query.py +++ b/examples/tracing/mysqld_query.py @@ -34,7 +34,7 @@ * see: https://dev.mysql.com/doc/refman/5.7/en/dba-dtrace-ref-query.html */ bpf_usdt_readarg(1, ctx, &addr); - bpf_probe_read(&query, sizeof(query), (void *)addr); + bpf_probe_read_user(&query, sizeof(query), (void *)addr); bpf_trace_printk("%s\\n", query); return 0; }; diff --git a/examples/tracing/nodejs_http_server.py b/examples/tracing/nodejs_http_server.py index a86ca956c..e32a26ea6 100755 --- a/examples/tracing/nodejs_http_server.py +++ b/examples/tracing/nodejs_http_server.py @@ -26,7 +26,7 @@ uint64_t addr; char path[128]={0}; bpf_usdt_readarg(6, ctx, &addr); - bpf_probe_read(&path, sizeof(path), (void *)addr); + bpf_probe_read_user(&path, sizeof(path), (void *)addr); bpf_trace_printk("path:%s\\n", path); return 0; }; diff --git a/examples/tracing/strlen_count.py b/examples/tracing/strlen_count.py index f1bb1b7ef..8432f5935 100755 --- a/examples/tracing/strlen_count.py +++ b/examples/tracing/strlen_count.py @@ -31,7 +31,7 @@ struct key_t key = {}; u64 zero = 0, *val; - bpf_probe_read(&key.c, sizeof(key.c), (void *)PT_REGS_PARM1(ctx)); + bpf_probe_read_user(&key.c, sizeof(key.c), (void *)PT_REGS_PARM1(ctx)); // could also use `counts.increment(key)` val = counts.lookup_or_try_init(&key, &zero); if (val) { diff --git a/examples/tracing/strlen_snoop.py b/examples/tracing/strlen_snoop.py index c3c7199eb..5b70f66a3 100755 --- a/examples/tracing/strlen_snoop.py +++ b/examples/tracing/strlen_snoop.py @@ -34,7 +34,7 @@ return 0; char str[80] = {}; - bpf_probe_read(&str, sizeof(str), (void *)PT_REGS_PARM1(ctx)); + bpf_probe_read_user(&str, sizeof(str), (void *)PT_REGS_PARM1(ctx)); bpf_trace_printk("%s\\n", &str); return 0; diff --git a/tools/bashreadline.py b/tools/bashreadline.py index b7d98272f..ad9cfdc0a 100755 --- a/tools/bashreadline.py +++ b/tools/bashreadline.py @@ -52,7 +52,7 @@ return 0; pid = bpf_get_current_pid_tgid(); data.pid = pid; - bpf_probe_read(&data.str, sizeof(data.str), (void *)PT_REGS_RC(ctx)); + bpf_probe_read_user(&data.str, sizeof(data.str), (void *)PT_REGS_RC(ctx)); bpf_get_current_comm(&comm, sizeof(comm)); if (comm[0] == 'b' && comm[1] == 'a' && comm[2] == 's' && comm[3] == 'h' && comm[4] == 0 ) { diff --git a/tools/biosnoop.lua b/tools/biosnoop.lua index 705212ee7..21261d0b3 100755 --- a/tools/biosnoop.lua +++ b/tools/biosnoop.lua @@ -84,7 +84,8 @@ int trace_req_completion(struct pt_regs *ctx, struct request *req) valp = infobyreq.lookup(&req); if (valp == 0) { data.len = req->__data_len; - strcpy(data.name,"?"); + data.name[0] = '?'; + data.name[1] = 0; } else { data.pid = valp->pid; data.len = req->__data_len; diff --git a/tools/biosnoop.py b/tools/biosnoop.py index e6f708fae..b550281c8 100755 --- a/tools/biosnoop.py +++ b/tools/biosnoop.py @@ -108,7 +108,8 @@ valp = infobyreq.lookup(&req); if (valp == 0) { data.len = req->__data_len; - strcpy(data.name, "?"); + data.name[0] = '?'; + data.name[1] = 0; } else { if (##QUEUE##) { data.qdelta = *tsp - valp->ts; diff --git a/tools/dbslower.py b/tools/dbslower.py index 2f1b6a8b8..ffbb5e1b6 100755 --- a/tools/dbslower.py +++ b/tools/dbslower.py @@ -127,12 +127,12 @@ tmp.timestamp = bpf_ktime_get_ns(); #if defined(MYSQL56) - bpf_probe_read(&tmp.query, sizeof(tmp.query), (void*) PT_REGS_PARM3(ctx)); + bpf_probe_read_user(&tmp.query, sizeof(tmp.query), (void*) PT_REGS_PARM3(ctx)); #elif defined(MYSQL57) void* st = (void*) PT_REGS_PARM2(ctx); char* query; - bpf_probe_read(&query, sizeof(query), st); - bpf_probe_read(&tmp.query, sizeof(tmp.query), query); + bpf_probe_read_user(&query, sizeof(query), st); + bpf_probe_read_user(&tmp.query, sizeof(tmp.query), query); #else //USDT bpf_usdt_readarg(1, ctx, &tmp.query); #endif @@ -157,7 +157,13 @@ data.pid = pid >> 32; // only process id data.timestamp = tempp->timestamp; data.duration = delta; +#if defined(MYSQL56) || defined(MYSQL57) + // We already copied string to the bpf stack. Hence use bpf_probe_read() bpf_probe_read(&data.query, sizeof(data.query), tempp->query); +#else + // USDT - we didnt copy string to the bpf stack before. + bpf_probe_read_user(&data.query, sizeof(data.query), tempp->query); +#endif events.perf_submit(ctx, &data, sizeof(data)); #ifdef THRESHOLD } diff --git a/tools/execsnoop.py b/tools/execsnoop.py index 26cbce660..9879d2c2f 100755 --- a/tools/execsnoop.py +++ b/tools/execsnoop.py @@ -120,7 +120,7 @@ def parse_uid(user): static int __submit_arg(struct pt_regs *ctx, void *ptr, struct data_t *data) { - bpf_probe_read(data->argv, sizeof(data->argv), ptr); + bpf_probe_read_user(data->argv, sizeof(data->argv), ptr); events.perf_submit(ctx, data, sizeof(struct data_t)); return 1; } @@ -128,7 +128,7 @@ def parse_uid(user): static int submit_arg(struct pt_regs *ctx, void *ptr, struct data_t *data) { const char *argp = NULL; - bpf_probe_read(&argp, sizeof(argp), ptr); + bpf_probe_read_user(&argp, sizeof(argp), ptr); if (argp) { return __submit_arg(ctx, (void *)(argp), data); } diff --git a/tools/funcslower.py b/tools/funcslower.py index bda6a844c..9acd35d12 100755 --- a/tools/funcslower.py +++ b/tools/funcslower.py @@ -82,7 +82,11 @@ u64 id; u64 start_ns; #ifdef GRAB_ARGS +#ifndef __s390x__ u64 args[6]; +#else + u64 args[5]; +#endif #endif }; @@ -94,7 +98,11 @@ u64 retval; char comm[TASK_COMM_LEN]; #ifdef GRAB_ARGS +#ifndef __s390x__ u64 args[6]; +#else + u64 args[5]; +#endif #endif #ifdef USER_STACKS int user_stack_id; @@ -130,7 +138,9 @@ entry.args[2] = PT_REGS_PARM3(ctx); entry.args[3] = PT_REGS_PARM4(ctx); entry.args[4] = PT_REGS_PARM5(ctx); +#ifndef __s390x__ entry.args[5] = PT_REGS_PARM6(ctx); +#endif #endif entryinfo.update(&tgid_pid, &entry); diff --git a/tools/gethostlatency.py b/tools/gethostlatency.py index f7506a868..a6b80801a 100755 --- a/tools/gethostlatency.py +++ b/tools/gethostlatency.py @@ -64,7 +64,7 @@ u32 pid = bpf_get_current_pid_tgid(); if (bpf_get_current_comm(&val.comm, sizeof(val.comm)) == 0) { - bpf_probe_read(&val.host, sizeof(val.host), + bpf_probe_read_user(&val.host, sizeof(val.host), (void *)PT_REGS_PARM1(ctx)); val.pid = bpf_get_current_pid_tgid(); val.ts = bpf_ktime_get_ns(); diff --git a/tools/lib/ucalls.py b/tools/lib/ucalls.py index 307df2527..396d56eb7 100755 --- a/tools/lib/ucalls.py +++ b/tools/lib/ucalls.py @@ -158,9 +158,9 @@ #endif READ_CLASS READ_METHOD - bpf_probe_read(&data.method.clazz, sizeof(data.method.clazz), + bpf_probe_read_user(&data.method.clazz, sizeof(data.method.clazz), (void *)clazz); - bpf_probe_read(&data.method.method, sizeof(data.method.method), + bpf_probe_read_user(&data.method.method, sizeof(data.method.method), (void *)method); #ifndef LATENCY valp = counts.lookup_or_try_init(&data.method, &val); @@ -182,9 +182,9 @@ data.pid = bpf_get_current_pid_tgid(); READ_CLASS READ_METHOD - bpf_probe_read(&data.method.clazz, sizeof(data.method.clazz), + bpf_probe_read_user(&data.method.clazz, sizeof(data.method.clazz), (void *)clazz); - bpf_probe_read(&data.method.method, sizeof(data.method.method), + bpf_probe_read_user(&data.method.method, sizeof(data.method.method), (void *)method); entry_timestamp = entry.lookup(&data); if (!entry_timestamp) { diff --git a/tools/lib/uflow.py b/tools/lib/uflow.py index 4779ba2cc..de3d7e27c 100755 --- a/tools/lib/uflow.py +++ b/tools/lib/uflow.py @@ -81,8 +81,8 @@ READ_CLASS READ_METHOD - bpf_probe_read(&data.clazz, sizeof(data.clazz), (void *)clazz); - bpf_probe_read(&data.method, sizeof(data.method), (void *)method); + bpf_probe_read_user(&data.clazz, sizeof(data.clazz), (void *)clazz); + bpf_probe_read_user(&data.method, sizeof(data.method), (void *)method); FILTER_CLASS FILTER_METHOD diff --git a/tools/lib/ugc.py b/tools/lib/ugc.py index 8841d5faa..8f4c8dee1 100755 --- a/tools/lib/ugc.py +++ b/tools/lib/ugc.py @@ -140,8 +140,8 @@ def format(self, data): u64 manager = 0, pool = 0; bpf_usdt_readarg(1, ctx, &manager); // ptr to manager name bpf_usdt_readarg(3, ctx, &pool); // ptr to pool name - bpf_probe_read(&event.string1, sizeof(event.string1), (void *)manager); - bpf_probe_read(&event.string2, sizeof(event.string2), (void *)pool); + bpf_probe_read_user(&event.string1, sizeof(event.string1), (void *)manager); + bpf_probe_read_user(&event.string2, sizeof(event.string2), (void *)pool); """ def formatter(e): diff --git a/tools/lib/uobjnew.py b/tools/lib/uobjnew.py index b8eed0f74..f75ba0483 100755 --- a/tools/lib/uobjnew.py +++ b/tools/lib/uobjnew.py @@ -98,7 +98,7 @@ u64 classptr = 0, size = 0; bpf_usdt_readarg(2, ctx, &classptr); bpf_usdt_readarg(4, ctx, &size); - bpf_probe_read(&key.name, sizeof(key.name), (void *)classptr); + bpf_probe_read_user(&key.name, sizeof(key.name), (void *)classptr); valp = allocs.lookup_or_try_init(&key, &zero); if (valp) { valp->total_size += size; @@ -132,7 +132,7 @@ struct val_t *valp, zero = {}; u64 classptr = 0; bpf_usdt_readarg(1, ctx, &classptr); - bpf_probe_read(&key.name, sizeof(key.name), (void *)classptr); + bpf_probe_read_user(&key.name, sizeof(key.name), (void *)classptr); valp = allocs.lookup_or_try_init(&key, &zero); if (valp) { valp->num_allocs += 1; // We don't know the size, unfortunately diff --git a/tools/lib/uthreads.py b/tools/lib/uthreads.py index 90d0a745b..9745b3d59 100755 --- a/tools/lib/uthreads.py +++ b/tools/lib/uthreads.py @@ -80,7 +80,7 @@ bpf_usdt_readarg(1, ctx, &nameptr); bpf_usdt_readarg(3, ctx, &id); bpf_usdt_readarg(4, ctx, &native_id); - bpf_probe_read(&te.name, sizeof(te.name), (void *)nameptr); + bpf_probe_read_user(&te.name, sizeof(te.name), (void *)nameptr); te.runtime_id = id; te.native_id = native_id; __builtin_memcpy(&te.type, type, sizeof(te.type)); diff --git a/tools/mountsnoop.py b/tools/mountsnoop.py index 17a2edb61..667ea35cd 100755 --- a/tools/mountsnoop.py +++ b/tools/mountsnoop.py @@ -109,22 +109,22 @@ event.type = EVENT_MOUNT_SOURCE; __builtin_memset(event.str, 0, sizeof(event.str)); - bpf_probe_read(event.str, sizeof(event.str), source); + bpf_probe_read_user(event.str, sizeof(event.str), source); events.perf_submit(ctx, &event, sizeof(event)); event.type = EVENT_MOUNT_TARGET; __builtin_memset(event.str, 0, sizeof(event.str)); - bpf_probe_read(event.str, sizeof(event.str), target); + bpf_probe_read_user(event.str, sizeof(event.str), target); events.perf_submit(ctx, &event, sizeof(event)); event.type = EVENT_MOUNT_TYPE; __builtin_memset(event.str, 0, sizeof(event.str)); - bpf_probe_read(event.str, sizeof(event.str), type); + bpf_probe_read_user(event.str, sizeof(event.str), type); events.perf_submit(ctx, &event, sizeof(event)); event.type = EVENT_MOUNT_DATA; __builtin_memset(event.str, 0, sizeof(event.str)); - bpf_probe_read(event.str, sizeof(event.str), data); + bpf_probe_read_user(event.str, sizeof(event.str), data); events.perf_submit(ctx, &event, sizeof(event)); return 0; @@ -164,7 +164,7 @@ event.type = EVENT_UMOUNT_TARGET; __builtin_memset(event.str, 0, sizeof(event.str)); - bpf_probe_read(event.str, sizeof(event.str), target); + bpf_probe_read_user(event.str, sizeof(event.str), target); events.perf_submit(ctx, &event, sizeof(event)); return 0; diff --git a/tools/mysqld_qslower.py b/tools/mysqld_qslower.py index d867d70fd..33ea7ddd1 100755 --- a/tools/mysqld_qslower.py +++ b/tools/mysqld_qslower.py @@ -81,7 +81,7 @@ def usage(): if (delta >= """ + str(min_ns) + """) { // populate and emit data struct struct data_t data = {.pid = pid, .ts = sp->ts, .delta = delta}; - bpf_probe_read(&data.query, sizeof(data.query), (void *)sp->query); + bpf_probe_read_user(&data.query, sizeof(data.query), (void *)sp->query); events.perf_submit(ctx, &data, sizeof(data)); } diff --git a/tools/opensnoop.py b/tools/opensnoop.py index b28d7d556..995443e3f 100755 --- a/tools/opensnoop.py +++ b/tools/opensnoop.py @@ -152,7 +152,7 @@ return 0; } bpf_probe_read(&data.comm, sizeof(data.comm), valp->comm); - bpf_probe_read(&data.fname, sizeof(data.fname), (void *)valp->fname); + bpf_probe_read_user(&data.fname, sizeof(data.fname), (void *)valp->fname); data.id = valp->id; data.ts = tsp / 1000; data.uid = bpf_get_current_uid_gid(); @@ -167,7 +167,7 @@ """ bpf_text_kfunc= """ -KRETFUNC_PROBE(do_sys_open, int dfd, const char *filename, int flags, int mode, int ret) +KRETFUNC_PROBE(do_sys_open, int dfd, const char __user *filename, int flags, int mode, int ret) { u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part @@ -189,7 +189,7 @@ u64 tsp = bpf_ktime_get_ns(); - bpf_probe_read(&data.fname, sizeof(data.fname), (void *)filename); + bpf_probe_read_user(&data.fname, sizeof(data.fname), (void *)filename); data.id = id; data.ts = tsp / 1000; data.uid = bpf_get_current_uid_gid(); diff --git a/tools/sslsniff.py b/tools/sslsniff.py index e48fbb470..8c027fe34 100755 --- a/tools/sslsniff.py +++ b/tools/sslsniff.py @@ -72,7 +72,7 @@ bpf_get_current_comm(&__data.comm, sizeof(__data.comm)); if ( buf != 0) { - bpf_probe_read(&__data.v0, sizeof(__data.v0), buf); + bpf_probe_read_user(&__data.v0, sizeof(__data.v0), buf); } perf_SSL_write.perf_submit(ctx, &__data, sizeof(__data)); @@ -108,7 +108,7 @@ bpf_get_current_comm(&__data.comm, sizeof(__data.comm)); if (bufp != 0) { - bpf_probe_read(&__data.v0, sizeof(__data.v0), (char *)*bufp); + bpf_probe_read_user(&__data.v0, sizeof(__data.v0), (char *)*bufp); } bufs.delete(&pid); diff --git a/tools/statsnoop.py b/tools/statsnoop.py index 6cdff9459..9c7df0b35 100755 --- a/tools/statsnoop.py +++ b/tools/statsnoop.py @@ -84,7 +84,7 @@ } struct data_t data = {.pid = pid}; - bpf_probe_read(&data.fname, sizeof(data.fname), (void *)valp->fname); + bpf_probe_read_user(&data.fname, sizeof(data.fname), (void *)valp->fname); bpf_get_current_comm(&data.comm, sizeof(data.comm)); data.ts_ns = bpf_ktime_get_ns(); data.ret = PT_REGS_RC(ctx); From aa3a4a6f7c6d59ede1598bc54fb9c83d8ad1f776 Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Wed, 22 Apr 2020 22:29:30 -0500 Subject: [PATCH 098/278] bcc/docs: Add bpf_probe_read_user to docs and tutorials Signed-off-by: Sumanth Korikkar --- docs/reference_guide.md | 38 +++++++++++++++++++++++---- docs/tutorial_bcc_python_developer.md | 6 ++--- 2 files changed, 36 insertions(+), 8 deletions(-) diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 224ffa628..5ac228f4c 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -28,6 +28,8 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [7. bpf_get_current_task()](#7-bpf_get_current_task) - [8. bpf_log2l()](#8-bpf_log2l) - [9. bpf_get_prandom_u32()](#9-bpf_get_prandom_u32) + - [10. bpf_probe_read_user()](#10-bpf_probe_read_user) + - [11. bpf_probe_read_user_str()](#11-bpf_probe_read_user_str) - [Debugging](#debugging) - [1. bpf_override_return()](#1-bpf_override_return) - [Output](#output) @@ -196,7 +198,7 @@ For example: ```C int count(struct pt_regs *ctx) { char buf[64]; - bpf_probe_read(&buf, sizeof(buf), (void *)PT_REGS_PARM1(ctx)); + bpf_probe_read_user(&buf, sizeof(buf), (void *)PT_REGS_PARM1(ctx)); bpf_trace_printk("%s %d", buf, PT_REGS_PARM2(ctx)); return(0); } @@ -242,7 +244,7 @@ int do_trace(struct pt_regs *ctx) { uint64_t addr; char path[128]; bpf_usdt_readarg(6, ctx, &addr); - bpf_probe_read(&path, sizeof(path), (void *)addr); + bpf_probe_read_user(&path, sizeof(path), (void *)addr); bpf_trace_printk("path:%s\\n", path); return 0; }; @@ -372,7 +374,7 @@ Syntax: ```int bpf_probe_read(void *dst, int size, const void *src)``` Return: 0 on success -This copies a memory location to the BPF stack, so that BPF can later operate on it. For safety, all memory reads must pass through bpf_probe_read(). This happens automatically in some cases, such as dereferencing kernel variables, as bcc will rewrite the BPF program to include the necessary bpf_probe_reads(). +This copies size bytes from kernel address space to the BPF stack, so that BPF can later operate on it. For safety, all kernel memory reads must pass through bpf_probe_read(). This happens automatically in some cases, such as dereferencing kernel variables, as bcc will rewrite the BPF program to include the necessary bpf_probe_read(). Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=bpf_probe_read+path%3Aexamples&type=Code), @@ -386,7 +388,7 @@ Return: - \> 0 length of the string including the trailing NULL on success - \< 0 error -This copies a `NULL` terminated string from memory location to BPF stack, so that BPF can later operate on it. In case the string length is smaller than size, the target is not padded with further `NULL` bytes. In case the string length is larger than size, just `size - 1` bytes are copied and the last byte is set to `NULL`. +This copies a `NULL` terminated string from kernel address space to the BPF stack, so that BPF can later operate on it. In case the string length is smaller than size, the target is not padded with further `NULL` bytes. In case the string length is larger than size, just `size - 1` bytes are copied and the last byte is set to `NULL`. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=bpf_probe_read_str+path%3Aexamples&type=Code), @@ -490,6 +492,32 @@ Example in situ: [search /examples](https://github.com/iovisor/bcc/search?q=bpf_get_prandom_u32+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=bpf_get_prandom_u32+path%3Atools&type=Code) +### 10. bpf_probe_read_user() + +Syntax: ```int bpf_probe_read_user(void *dst, int size, const void *src)``` + +Return: 0 on success + +This attempts to safely read size bytes from user address space to the BPF stack, so that BPF can later operate on it. For safety, all user address space memory reads must pass through bpf_probe_read_user(). + +Examples in situ: +[search /examples](https://github.com/iovisor/bcc/search?q=bpf_probe_read_user+path%3Aexamples&type=Code), +[search /tools](https://github.com/iovisor/bcc/search?q=bpf_probe_read_user+path%3Atools&type=Code) + +### 11. bpf_probe_read_user_str() + +Syntax: ```int bpf_probe_read_user_str(void *dst, int size, const void *src)``` + +Return: + - \> 0 length of the string including the trailing NULL on success + - \< 0 error + +This copies a `NULL` terminated string from user address space to the BPF stack, so that BPF can later operate on it. In case the string length is smaller than size, the target is not padded with further `NULL` bytes. In case the string length is larger than size, just `size - 1` bytes are copied and the last byte is set to `NULL`. + +Examples in situ: +[search /examples](https://github.com/iovisor/bcc/search?q=bpf_probe_read_user_str+path%3Aexamples&type=Code), +[search /tools](https://github.com/iovisor/bcc/search?q=bpf_probe_read_user_str+path%3Atools&type=Code) + ## Debugging ### 1. bpf_override_return() @@ -1721,7 +1749,7 @@ See the "Understanding eBPF verifier messages" section in the kernel source unde ## 1. Invalid mem access -This can be due to trying to read memory directly, instead of operating on memory on the BPF stack. All memory reads must be passed via bpf_probe_read() to copy memory into the BPF stack, which can be automatic by the bcc rewriter in some cases of simple dereferencing. bpf_probe_read() does all the required checks. +This can be due to trying to read memory directly, instead of operating on memory on the BPF stack. All kernel memory reads must be passed via bpf_probe_read() to copy kernel memory into the BPF stack, which can be automatic by the bcc rewriter in some cases of simple dereferencing. bpf_probe_read() does all the required checks. Example: diff --git a/docs/tutorial_bcc_python_developer.md b/docs/tutorial_bcc_python_developer.md index a06f4b7f0..5de74dcdc 100644 --- a/docs/tutorial_bcc_python_developer.md +++ b/docs/tutorial_bcc_python_developer.md @@ -556,7 +556,7 @@ int count(struct pt_regs *ctx) { struct key_t key = {}; u64 zero = 0, *val; - bpf_probe_read(&key.c, sizeof(key.c), (void *)PT_REGS_PARM1(ctx)); + bpf_probe_read_user(&key.c, sizeof(key.c), (void *)PT_REGS_PARM1(ctx)); // could also use `counts.increment(key)` val = counts.lookup_or_try_init(&key, &zero); if (val) { @@ -620,7 +620,7 @@ int do_trace(struct pt_regs *ctx) { uint64_t addr; char path[128]={0}; bpf_usdt_readarg(6, ctx, &addr); - bpf_probe_read(&path, sizeof(path), (void *)addr); + bpf_probe_read_user(&path, sizeof(path), (void *)addr); bpf_trace_printk("path:%s\\n", path); return 0; }; @@ -640,7 +640,7 @@ b = BPF(text=bpf_text, usdt_contexts=[u]) Things to learn: 1. ```bpf_usdt_readarg(6, ctx, &addr)```: Read the address of argument 6 from the USDT probe into ```addr```. -1. ```bpf_probe_read(&path, sizeof(path), (void *)addr)```: Now the string ```addr``` points to into our ```path``` variable. +1. ```bpf_probe_read_user(&path, sizeof(path), (void *)addr)```: Now the string ```addr``` points to into our ```path``` variable. 1. ```u = USDT(pid=int(pid))```: Initialize USDT tracing for the given PID. 1. ```u.enable_probe(probe="http__server__request", fn_name="do_trace")```: Attach our ```do_trace()``` BPF C function to the Node.js ```http__server__request``` USDT probe. 1. ```b = BPF(text=bpf_text, usdt_contexts=[u])```: Need to pass in our USDT object, ```u```, to BPF object creation. From 99739b2aa214984b783f61e4bcb3754eda876c1b Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Tue, 28 Apr 2020 12:08:28 -0500 Subject: [PATCH 099/278] bcc/utils: Avoid code duplication of __generate_streq_function bcc tools like trace.py and argdist.py uses _generate_streq_function() functions to convert char * read to bpf_probe_read/bpf_probe_read_user. Refactor it and move the common functionality to utils.py. Signed-off-by: Sumanth Korikkar Acked-by: Ilya Leoshkevich --- src/python/bcc/__init__.py | 2 +- src/python/bcc/utils.py | 48 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 49 insertions(+), 1 deletion(-) diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index 5b3ff7b2c..0aea60003 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -26,7 +26,7 @@ from .libbcc import lib, bcc_symbol, bcc_symbol_option, bcc_stacktrace_build_id, _SYM_CB_TYPE from .table import Table, PerfEventArray from .perf import Perf -from .utils import get_online_cpus, printb, _assert_is_bytes, ArgString +from .utils import get_online_cpus, printb, _assert_is_bytes, ArgString, StrcmpRewrite from .version import __version__ from .disassembler import disassemble_prog, decode_map diff --git a/src/python/bcc/utils.py b/src/python/bcc/utils.py index ef6f81d88..452054233 100644 --- a/src/python/bcc/utils.py +++ b/src/python/bcc/utils.py @@ -15,6 +15,7 @@ import sys import traceback import warnings +import re from .libbcc import lib @@ -97,3 +98,50 @@ def _assert_is_bytes(arg): return ArgString(arg).__bytes__() return arg +class StrcmpRewrite(object): + @staticmethod + def _generate_streq_function(string, probe_read_func, streq_functions, + probeid): + fname = "streq_%d" % probeid + streq_functions += """ +static inline bool %s(char const *ignored, uintptr_t str) { + char needle[] = %s; + char haystack[sizeof(needle)]; + %s(&haystack, sizeof(haystack), (void *)str); + for (int i = 0; i < sizeof(needle) - 1; ++i) { + if (needle[i] != haystack[i]) { + return false; + } + } + return true; +} + """ % (fname, string, probe_read_func) + return fname, streq_functions + + @staticmethod + def rewrite_expr(expr, bin_cmp, is_user, probe_user_list, streq_functions, + probeid): + if bin_cmp: + STRCMP_RE = 'STRCMP\\(\"([^"]+)\\",(.+?)\\)' + else: + STRCMP_RE = 'STRCMP\\(("[^"]+\\"),(.+?)\\)' + matches = re.finditer(STRCMP_RE, expr) + for match in matches: + string = match.group(1) + probe_read_func = "bpf_probe_read" + # if user probe or @user tag is specified, use + # bpf_probe_read_user for char* read + if is_user or \ + match.group(2).strip() in probe_user_list: + probe_read_func = "bpf_probe_read_user" + fname, streq_functions = StrcmpRewrite._generate_streq_function( + string, probe_read_func, + streq_functions, probeid) + probeid += 1 + expr = expr.replace("STRCMP", fname, 1) + rdict = { + "expr" : expr, + "streq_functions" : streq_functions, + "probeid" : probeid + } + return rdict From 306080b9c6370974b0e11ed6bbe47f086c42d7ac Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Mon, 27 Apr 2020 04:37:23 -0500 Subject: [PATCH 100/278] bcc: Add __user attribute to support bpf_probe_read_user in argdist argdist traces probe functions and its parameter values. Add functionality to convert: - All userspace probes char * read to bpf_probe_read_user() - Syscall/kprobes char* params with __user attribute to bpf_probe_read_user() Signed-off-by: Sumanth Korikkar Acked-by: Ilya Leoshkevich --- tools/argdist.py | 47 +++++++++++++++++---------------------- tools/argdist_example.txt | 9 ++++++++ 2 files changed, 30 insertions(+), 26 deletions(-) diff --git a/tools/argdist.py b/tools/argdist.py index 695b5b3c8..0e9078cdb 100755 --- a/tools/argdist.py +++ b/tools/argdist.py @@ -9,7 +9,7 @@ # Licensed under the Apache License, Version 2.0 (the "License") # Copyright (C) 2016 Sasha Goldshtein. -from bcc import BPF, USDT +from bcc import BPF, USDT, StrcmpRewrite from time import sleep, strftime import argparse import re @@ -41,6 +41,10 @@ def _parse_signature(self): param_type = param[0:index + 1].strip() param_name = param[index + 1:].strip() self.param_types[param_name] = param_type + # Maintain list of user params. Then later decide to + # switch to bpf_probe_read or bpf_probe_read_user. + if "__user" in param_type.split(): + self.probe_user_list.add(param_name) def _generate_entry(self): self.entry_probe_func = self.probe_func_name + "_entry" @@ -182,6 +186,8 @@ def __init__(self, tool, type, specifier): self.pid = tool.args.pid self.cumulative = tool.args.cumulative or False self.raw_spec = specifier + self.probe_user_list = set() + self.bin_cmp = False self._validate_specifier() spec_and_label = specifier.split('#') @@ -250,32 +256,16 @@ def _enable_usdt_probe(self): self.usdt_ctx.enable_probe( self.function, self.probe_func_name) - def _generate_streq_function(self, string): - fname = "streq_%d" % Probe.streq_index - Probe.streq_index += 1 - self.streq_functions += """ -static inline bool %s(char const *ignored, char const *str) { - char needle[] = %s; - char haystack[sizeof(needle)]; - bpf_probe_read(&haystack, sizeof(haystack), (void *)str); - for (int i = 0; i < sizeof(needle) - 1; ++i) { - if (needle[i] != haystack[i]) { - return false; - } - } - return true; -} - """ % (fname, string) - return fname - def _substitute_exprs(self): def repl(expr): expr = self._substitute_aliases(expr) - matches = re.finditer('STRCMP\\(("[^"]+\\")', expr) - for match in matches: - string = match.group(1) - fname = self._generate_streq_function(string) - expr = expr.replace("STRCMP", fname, 1) + rdict = StrcmpRewrite.rewrite_expr(expr, + self.bin_cmp, self.library, + self.probe_user_list, self.streq_functions, + Probe.streq_index) + expr = rdict["expr"] + self.streq_functions = rdict["streq_functions"] + Probe.streq_index = rdict["probeid"] return expr.replace("$retval", "PT_REGS_RC(ctx)") for i in range(0, len(self.exprs)): self.exprs[i] = repl(self.exprs[i]) @@ -305,9 +295,14 @@ def _generate_usdt_arg_assignment(self, i): def _generate_field_assignment(self, i): text = self._generate_usdt_arg_assignment(i) if self._is_string(self.expr_types[i]): - return (text + " bpf_probe_read(&__key.v%d.s," + + if self.is_user or \ + self.exprs[i] in self.probe_user_list: + probe_readfunc = "bpf_probe_read_user" + else: + probe_readfunc = "bpf_probe_read" + return (text + " %s(&__key.v%d.s," + " sizeof(__key.v%d.s), (void *)%s);\n") % \ - (i, i, self.exprs[i]) + (probe_readfunc, i, i, self.exprs[i]) else: return text + " __key.v%d = %s;\n" % \ (i, self.exprs[i]) diff --git a/tools/argdist_example.txt b/tools/argdist_example.txt index 7098e56c5..9ddfad3d9 100644 --- a/tools/argdist_example.txt +++ b/tools/argdist_example.txt @@ -449,3 +449,12 @@ argdist -I 'kernel/sched/sched.h' \ in kernel/sched/sched.h which is in kernel source tree and not in kernel-devel package. So this command needs to run at the kernel source tree root directory so that the added header file can be found by the compiler. + +argdist -C 'p::do_sys_open(int dfd, const char __user *filename, int flags, + umode_t mode):char*:filename:STRCMP("sample.txt", filename)' + Trace open of the file "sample.txt". It should be noted that 'filename' + passed to the do_sys_open is a char * user pointer. Hence parameter + 'filename' should be tagged with __user for kprobes (const char __user + *filename). This information distinguishes if the 'filename' should be + copied from userspace to the bpf stack or from kernel space to the bpf + stack. From 7cbd074cb5af6b82f53a5de9936ffaa74fea00f0 Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Mon, 27 Apr 2020 09:09:28 -0500 Subject: [PATCH 101/278] bcc: Support bpf_probe_read_user in trace.py Arguments of a probe point can be either user pointer or kernel pointer. Previously: - tools/trace.py 'do_sys_open "%s", arg2' When reading arg2 as char *, it would resolve to bpf_probe_read. Now: - tools/trace.py 'do_sys_open "%s", arg2@user' - When reading arg2 as char *, it is resolved to bpf_probe_read_user. - tools/trace.py 'do_sys_open (STRCMP("test.txt", arg2@user)) "%s", arg2' - For arg2 char * read, bpf_probe_read_user is utilized To distinguish this, add arg@user. - All userspace probes char *read converted to bpf_probe_read_user - Syscall/kprobes with arg[1-6]@user attribute are converted to bpf_probe_read_user. Signed-off-by: Sumanth Korikkar Acked-by: Ilya Leoshkevich --- tools/trace.py | 79 ++++++++++++++++++++--------------------- tools/trace_example.txt | 17 +++++---- 2 files changed, 48 insertions(+), 48 deletions(-) diff --git a/tools/trace.py b/tools/trace.py index c87edef72..add3f3e85 100755 --- a/tools/trace.py +++ b/tools/trace.py @@ -11,7 +11,7 @@ # Copyright (C) 2016 Sasha Goldshtein. from __future__ import print_function -from bcc import BPF, USDT +from bcc import BPF, USDT, StrcmpRewrite from functools import partial from time import sleep, strftime import time @@ -65,6 +65,7 @@ def __init__(self, probe, string_size, kernel_stack, user_stack, self.string_size = string_size self.kernel_stack = kernel_stack self.user_stack = user_stack + self.probe_user_list = set() Probe.probe_count += 1 self._parse_probe() self.probe_num = Probe.probe_count @@ -260,47 +261,33 @@ def _parse_action(self, action): "$task" : "((struct task_struct *)bpf_get_current_task())" } - def _generate_streq_function(self, string): - fname = "streq_%d" % Probe.streq_index - Probe.streq_index += 1 - self.streq_functions += """ -static inline bool %s(char const *ignored, uintptr_t str) { - char needle[] = %s; - char haystack[sizeof(needle)]; - bpf_probe_read(&haystack, sizeof(haystack), (void *)str); - for (int i = 0; i < sizeof(needle) - 1; ++i) { - if (needle[i] != haystack[i]) { - return false; - } - } - return true; -} - """ % (fname, string) - return fname - def _rewrite_expr(self, expr): - if self.is_syscall_kprobe: - for alias, replacement in Probe.aliases_indarg.items(): - expr = expr.replace(alias, replacement) - else: - for alias, replacement in Probe.aliases_arg.items(): - # For USDT probes, we replace argN values with the - # actual arguments for that probe obtained using - # bpf_readarg_N macros emitted at BPF construction. - if self.probe_type == "u": - continue + # Find the occurances of any arg[1-6]@user. Use it later to + # identify bpf_probe_read_user + for matches in re.finditer(r'(arg[1-6])(@user)', expr): + if matches.group(1).strip() not in self.probe_user_list: + self.probe_user_list.add(matches.group(1).strip()) + # Remove @user occurrences from arg before resolving to its + # corresponding aliases. + expr = re.sub(r'(arg[1-6])@user', r'\1', expr) + rdict = StrcmpRewrite.rewrite_expr(expr, + self.bin_cmp, self.library, + self.probe_user_list, self.streq_functions, + Probe.streq_index) + expr = rdict["expr"] + self.streq_functions = rdict["streq_functions"] + Probe.streq_index = rdict["probeid"] + alias_to_check = Probe.aliases_indarg \ + if self.is_syscall_kprobe \ + else Probe.aliases_arg + # For USDT probes, we replace argN values with the + # actual arguments for that probe obtained using + # bpf_readarg_N macros emitted at BPF construction. + if not self.probe_type == "u": + for alias, replacement in alias_to_check.items(): expr = expr.replace(alias, replacement) for alias, replacement in Probe.aliases_common.items(): expr = expr.replace(alias, replacement) - if self.bin_cmp: - STRCMP_RE = 'STRCMP\\(\"([^"]+)\\"' - else: - STRCMP_RE = 'STRCMP\\(("[^"]+\\")' - matches = re.finditer(STRCMP_RE, expr) - for match in matches: - string = match.group(1) - fname = self._generate_streq_function(string) - expr = expr.replace("STRCMP", fname, 1) return expr p_type = {"u": ct.c_uint, "d": ct.c_int, "lu": ct.c_ulong, @@ -412,14 +399,24 @@ def _generate_field_assign(self, idx): text = (" %s %s = 0;\n" + " bpf_usdt_readarg(%s, ctx, &%s);\n") \ % (arg_ctype, expr, expr[3], expr) - + probe_read_func = "bpf_probe_read" if field_type == "s": + if self.library: + probe_read_func = "bpf_probe_read_user" + else: + alias_to_check = Probe.aliases_indarg \ + if self.is_syscall_kprobe \ + else Probe.aliases_arg + for arg, alias in alias_to_check.items(): + if alias == expr and arg in self.probe_user_list: + probe_read_func = "bpf_probe_read_user" + break return text + """ if (%s != 0) { void *__tmp = (void *)%s; - bpf_probe_read(&__data.v%d, sizeof(__data.v%d), __tmp); + %s(&__data.v%d, sizeof(__data.v%d), __tmp); } - """ % (expr, expr, idx, idx) + """ % (expr, expr, probe_read_func, idx, idx) if field_type in Probe.fmt_types: return text + " __data.v%d = (%s)%s;\n" % \ (idx, Probe.c_type[field_type], expr) diff --git a/tools/trace_example.txt b/tools/trace_example.txt index eb6375079..a16b03959 100644 --- a/tools/trace_example.txt +++ b/tools/trace_example.txt @@ -54,7 +54,7 @@ Event message filter is useful while you only interesting the specific event. Like the program open thousands file and you only want to see the "temp" file and print stack. -# trace 'do_sys_open "%s", arg2' -UK -f temp +# trace 'do_sys_open "%s", arg2@user' -UK -f temp PID TID COMM FUNC - 9557 9557 a.out do_sys_open temp.1 do_sys_open+0x1 [kernel] @@ -71,7 +71,7 @@ PID TID COMM FUNC - Process name filter is porting from tools/opensnoop -# trace 'do_sys_open "%s", arg2' -UK -n out +# trace 'do_sys_open "%s", arg2@user' -UK -n out PID TID COMM FUNC - 9557 9557 a.out do_sys_open temp.1 do_sys_open+0x1 [kernel] @@ -241,7 +241,7 @@ so it always includes this header file. As a final example, let's trace open syscalls for a specific process. By default, tracing is system-wide, but the -p switch overrides this: -# trace -p 2740 'do_sys_open "%s", arg2' -T +# trace -p 2740 'do_sys_open "%s", arg2@user' -T TIME PID COMM FUNC - 05:36:16 15872 ls do_sys_open /etc/ld.so.cache 05:36:16 15872 ls do_sys_open /lib64/libselinux.so.1 @@ -335,11 +335,14 @@ EXAMPLES: trace do_sys_open Trace the open syscall and print a default trace message when entered -trace 'do_sys_open "%s", arg2' - Trace the open syscall and print the filename being opened -trace 'do_sys_open "%s", arg2' -n main +trace 'do_sys_open "%s", arg2@user' + Trace the open syscall and print the filename being opened. @user is + added to arg2 in kprobes to ensure that char * should be copied from + the userspace stack to the bpf stack. If not specified, previous + behaviour is expected. +trace 'do_sys_open "%s", arg2@user' -n main Trace the open syscall and only print event that process names containing "main" -trace 'do_sys_open "%s", arg2' -f config +trace 'do_sys_open "%s", arg2@user' -f config Trace the open syscall and print the filename being opened filtered by "config" trace 'sys_read (arg3 > 20000) "read %d bytes", arg3' Trace the read syscall and print a message for reads >20000 bytes From 09be5b50c1168c2796786029fa159c63f71e2936 Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Tue, 28 Apr 2020 04:24:18 -0500 Subject: [PATCH 102/278] bcc/libbpf: Fix bpf_has_kernel_btf return status bool returns True for negative integers. Hence bcc tools tries to switch to kfunc instead of kprobes, even when the btf data is not found. For libbpf_find_vmlinux_btf_id, When err <= 0 , btf is not found. Signed-off-by: Sumanth Korikkar Acked-by: Ilya Leoshkevich --- src/cc/libbpf.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index 0ce826748..008968c7c 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -1168,7 +1168,7 @@ int bpf_attach_raw_tracepoint(int progfd, const char *tp_name) bool bpf_has_kernel_btf(void) { - return libbpf_find_vmlinux_btf_id("bpf_prog_put", 0); + return libbpf_find_vmlinux_btf_id("bpf_prog_put", 0) > 0; } int bpf_detach_kfunc(int prog_fd, char *func) From 59a753da82f9eab628a5506822a6ff16a6912a88 Mon Sep 17 00:00:00 2001 From: Saleem Date: Sun, 3 May 2020 13:07:43 +0530 Subject: [PATCH 103/278] Add perf event data collection example for an userspace application (#2888) * Add perf event data collection example for an userspace application * Add comments for potential issues in perf_event example --- examples/perf/ipc.py | 180 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 180 insertions(+) create mode 100755 examples/perf/ipc.py diff --git a/examples/perf/ipc.py b/examples/perf/ipc.py new file mode 100755 index 000000000..51d15f6c0 --- /dev/null +++ b/examples/perf/ipc.py @@ -0,0 +1,180 @@ +#!/usr/bin/python +# IPC - Instructions Per Cycles using Perf Events and +# uprobes +# 24-Apr-2020 Saleem Ahmad Created this. + +from bcc import BPF, utils +from optparse import OptionParser + +# load BPF program +code=""" +#include + +struct perf_delta { + u64 clk_delta; + u64 inst_delta; + u64 time_delta; +}; + +/* +Perf Arrays to read counter values for open +perf events. +*/ +BPF_PERF_ARRAY(clk, MAX_CPUS); +BPF_PERF_ARRAY(inst, MAX_CPUS); + +// Perf Output +BPF_PERF_OUTPUT(output); + +// Per Cpu Data to store start values +BPF_PERCPU_ARRAY(data, u64); + +#define CLOCK_ID 0 +#define INSTRUCTION_ID 1 +#define TIME_ID 2 + +void trace_start(struct pt_regs *ctx) { + u32 clk_k = CLOCK_ID; + u32 inst_k = INSTRUCTION_ID; + u32 time = TIME_ID; + + int cpu = bpf_get_smp_processor_id(); + /* + perf_read may return negative values for errors. + If cpu id is greater than BPF_PERF_ARRAY size, + counters values will be very large negative number. + NOTE: Use bpf_perf_event_value is recommended over + bpf_perf_event_read or map.perf_read() due to + issues in ABI. map.perf_read_value() need to be + implemented in future. + */ + u64 clk_start = clk.perf_read(cpu); + u64 inst_start = inst.perf_read(cpu); + u64 time_start = bpf_ktime_get_ns(); + + u64* kptr = NULL; + kptr = data.lookup(&clk_k); + if (kptr) { + data.update(&clk_k, &clk_start); + } else { + data.insert(&clk_k, &clk_start); + } + + kptr = data.lookup(&inst_k); + if (kptr) { + data.update(&inst_k, &inst_start); + } else { + data.insert(&inst_k, &inst_start); + } + + kptr = data.lookup(&time); + if (kptr) { + data.update(&time, &time_start); + } else { + data.insert(&time, &time_start); + } +} + +void trace_end(struct pt_regs* ctx) { + u32 clk_k = CLOCK_ID; + u32 inst_k = INSTRUCTION_ID; + u32 time = TIME_ID; + + int cpu = bpf_get_smp_processor_id(); + /* + perf_read may return negative values for errors. + If cpu id is greater than BPF_PERF_ARRAY size, + counters values will be very large negative number. + NOTE: Use bpf_perf_event_value is recommended over + bpf_perf_event_read or map.perf_read() due to + issues in ABI. map.perf_read_value() need to be + implemented in future. + */ + u64 clk_end = clk.perf_read(cpu); + u64 inst_end = inst.perf_read(cpu); + u64 time_end = bpf_ktime_get_ns(); + + struct perf_delta perf_data = {} ; + u64* kptr = NULL; + kptr = data.lookup(&clk_k); + + // Find elements in map, if not found return + if (kptr) { + perf_data.clk_delta = clk_end - *kptr; + } else { + return; + } + + kptr = data.lookup(&inst_k); + if (kptr) { + perf_data.inst_delta = inst_end - *kptr; + } else { + return; + } + + kptr = data.lookup(&time); + if (kptr) { + perf_data.time_delta = time_end - *kptr; + } else { + return; + } + + output.perf_submit(ctx, &perf_data, sizeof(struct perf_delta)); +} +""" + +usage='Usage: ipc.py [options]\nexample ./ipc.py -l c -s strlen' +parser = OptionParser(usage) +parser.add_option('-l', '--lib', dest='lib_name', help='lib name containing symbol to trace, e.g. c for libc', type=str) +parser.add_option('-s', '--sym', dest='sym', help='symbol to trace', type=str) + +(options, args) = parser.parse_args() +if (not options.lib_name or not options.sym): + parser.print_help() + exit() + +num_cpus = len(utils.get_online_cpus()) + +b = BPF(text=code, cflags=['-DMAX_CPUS=%s' % str(num_cpus)]) + +# Attach Probes at start and end of the trace function +# NOTE: When attaching to a function for tracing, during runtime relocation +# stage by linker, function will be called once to return a different function +# address, which will be called by the process. e.g. in case of strlen +# after relocation stage, __strlen_sse2 is called instread of strlen. +# NOTE: There will be a context switch from userspace to kernel space, +# on caputring counters on USDT probes, so actual IPC might be slightly different. +# This example is to give a reference on how to use perf events with tracing. +b.attach_uprobe(name=options.lib_name, sym=options.sym, fn_name="trace_start") +b.attach_uretprobe(name=options.lib_name, sym=options.sym, fn_name="trace_end") + +def print_data(cpu, data, size): + e = b["output"].event(data) + print("%-8d %-12d %-8.2f %-8s %d" % (e.clk_delta, e.inst_delta, + 1.0* e.inst_delta/e.clk_delta, str(round(e.time_delta * 1e-3, 2)) + ' us', cpu)) + +print("Counters Data") +print("%-8s %-12s %-8s %-8s %s" % ('CLOCK', 'INSTRUCTION', 'IPC', 'TIME', 'CPU')) + +b["output"].open_perf_buffer(print_data) + +# Perf Event for Unhalted Cycles, The hex value is +# combination of event, umask and cmask. Read Intel +# Doc to find the event and cmask. Or use +# perf list --details to get event, umask and cmask +# NOTE: Events can be multiplexed by kernel in case the +# number of counters is greater than supported by CPU +# performance monitoring unit, which can result in inaccurate +# results. Counter values need to be normalized for a more +# accurate value. +PERF_TYPE_RAW = 4 +# Unhalted Clock Cycles +b["clk"].open_perf_event(PERF_TYPE_RAW, 0x0000003C) +# Instruction Retired +b["inst"].open_perf_event(PERF_TYPE_RAW, 0x000000C0) + +while True: + try: + b.perf_buffer_poll() + except KeyboardInterrupt: + exit() From f1c3fc5359ace92f50cc1ce31f24ed83b9122ce8 Mon Sep 17 00:00:00 2001 From: DavadDi Date: Tue, 5 May 2020 12:07:43 +0800 Subject: [PATCH 104/278] Update INSTALL.md --- INSTALL.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/INSTALL.md b/INSTALL.md index bf2702ead..c8254d758 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -500,7 +500,7 @@ For permanently enable scl environment, please check https://access.redhat.com/s ``` git clone https://github.com/iovisor/bcc.git mkdir bcc/build; cd bcc/build -cmake .. +cmake3 .. make sudo make install ``` From 0d93f24ce8f9ee273151acd117a612da00c4d632 Mon Sep 17 00:00:00 2001 From: Alison Chaiken Date: Sun, 3 May 2020 10:59:05 -0700 Subject: [PATCH 105/278] USDT: make path failure message more explicit Make it clear which file the USDT runtime files to find and suggest a fix. --- examples/usdt_sample/usdt_sample.md | 5 +++++ src/cc/usdt/usdt.cc | 4 ++-- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/examples/usdt_sample/usdt_sample.md b/examples/usdt_sample/usdt_sample.md index c6b5a0702..fd5b527b3 100644 --- a/examples/usdt_sample/usdt_sample.md +++ b/examples/usdt_sample/usdt_sample.md @@ -93,6 +93,11 @@ input 4 arg2 = pf_6 4 arg2 = pf_23 5 arg2 = pf_24 + +Should that command fail with the error message "HINT: Binary path usdt_sample_lib1 should be absolute", try instead: + +sudo python tools/argdist.py -p 47575 -i 5 -C 'u:ABSOLUTE-PATH-TO-BCC-REPO/bcc/examples/usdt_sample/build/usdt_sample_lib1/libusdt_sample_lib1.so:operation_start():char*:arg2#input' -z 32 + ``` Use latency.py to trace the operation latencies: diff --git a/src/cc/usdt/usdt.cc b/src/cc/usdt/usdt.cc index c992bbbdf..b32ea1a12 100644 --- a/src/cc/usdt/usdt.cc +++ b/src/cc/usdt/usdt.cc @@ -420,10 +420,10 @@ void *bcc_usdt_new_frompid(int pid, const char *path) { } else { struct stat buffer; if (strlen(path) >= 1 && path[0] != '/') { - fprintf(stderr, "HINT: Binary path should be absolute.\n\n"); + fprintf(stderr, "HINT: Binary path %s should be absolute.\n\n", path); return nullptr; } else if (stat(path, &buffer) == -1) { - fprintf(stderr, "HINT: Specified binary doesn't exist.\n\n"); + fprintf(stderr, "HINT: Specified binary %s doesn't exist.\n\n", path); return nullptr; } ctx = new USDT::Context(pid, path); From a433ef9451f187541012354cf6a2f4cf67646e11 Mon Sep 17 00:00:00 2001 From: sabbene Date: Tue, 5 May 2020 23:55:17 -0700 Subject: [PATCH 106/278] add nfs v3 support to nfsdist.py (#2902) add nfs v3 support to nfsdist.py Co-authored-by: sabbene --- tools/nfsdist.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/tools/nfsdist.py b/tools/nfsdist.py index ff78506f6..2243d4070 100755 --- a/tools/nfsdist.py +++ b/tools/nfsdist.py @@ -137,16 +137,21 @@ # common file functions b.attach_kprobe(event="nfs_file_read", fn_name="trace_entry") b.attach_kprobe(event="nfs_file_write", fn_name="trace_entry") -b.attach_kprobe(event="nfs4_file_open", fn_name="trace_entry") b.attach_kprobe(event="nfs_file_open", fn_name="trace_entry") b.attach_kprobe(event="nfs_getattr", fn_name="trace_entry") b.attach_kretprobe(event="nfs_file_read", fn_name="trace_read_return") b.attach_kretprobe(event="nfs_file_write", fn_name="trace_write_return") -b.attach_kretprobe(event="nfs4_file_open", fn_name="trace_open_return") b.attach_kretprobe(event="nfs_file_open", fn_name="trace_open_return") b.attach_kretprobe(event="nfs_getattr", fn_name="trace_getattr_return") +if BPF.get_kprobe_functions(b'nfs4_file_open'): + b.attach_kprobe(event="nfs4_file_open", fn_name="trace_entry") + b.attach_kretprobe(event="nfs4_file_open", fn_name="trace_open_return") +else: + b.attach_kprobe(event="nfs_file_open", fn_name="trace_entry") + b.attach_kretprobe(event="nfs_file_open", fn_name="trace_open_return") + print("Tracing NFS operation latency... Hit Ctrl-C to end.") # output From b8269aac2130c9cfd6f18b211b5b2af570edbe76 Mon Sep 17 00:00:00 2001 From: Akilesh Kailash Date: Mon, 11 May 2020 11:54:26 -0700 Subject: [PATCH 107/278] Bug #2907 - Fix argdist filtering option for USDT probes --- tools/argdist.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/argdist.py b/tools/argdist.py index 0e9078cdb..0bc1414e0 100755 --- a/tools/argdist.py +++ b/tools/argdist.py @@ -362,8 +362,8 @@ def generate_text(self): u32 __tgid = __pid_tgid >> 32; // upper 32 bits PID_FILTER PREFIX - if (!(FILTER)) return 0; KEY_EXPR + if (!(FILTER)) return 0; COLLECT return 0; } From 0d87484b724e3f20d03c49a48e356e6fd1533c68 Mon Sep 17 00:00:00 2001 From: Chunmei Xu Date: Wed, 6 May 2020 19:40:04 +0800 Subject: [PATCH 108/278] add -fPIC to compile examples/cpp and tests/cc I use clang-8.0.1 and gcc-8.3.1 to compile bcc-0.8.1, without -fPIC, will get errors like this: /usr/bin/ld: CMakeFiles/test_libbcc.dir/test_libbcc.cc.o: relocation R_X86_64_32S against symbol `_ZTVN5Catch21LegacyReporterAdapterE' can not be used when making a PIE object; recompile with -fPIC /usr/bin/ld: CMakeFiles/test_libbcc.dir/test_c_api.cc.o: relocation R_X86_64_32 against `.rodata.str1.1' can not be used when making a PIE object; recompile with -fPIC /usr/bin/ld: CMakeFiles/CGroupTest.dir/CGroupTest.cc.o: relocation R_X86_64_32 against `.rodata.str1.8' can not be used when making a PIE object; recompile with -fPIC Signed-off-by: Chunmei Xu --- examples/cpp/CMakeLists.txt | 3 +++ tests/cc/CMakeLists.txt | 4 ++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/examples/cpp/CMakeLists.txt b/examples/cpp/CMakeLists.txt index c804fe93a..58a4be769 100644 --- a/examples/cpp/CMakeLists.txt +++ b/examples/cpp/CMakeLists.txt @@ -6,6 +6,9 @@ include_directories(${CMAKE_SOURCE_DIR}/src/cc) include_directories(${CMAKE_SOURCE_DIR}/src/cc/api) include_directories(${CMAKE_SOURCE_DIR}/src/cc/libbpf/include/uapi) +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC") + option(INSTALL_CPP_EXAMPLES "Install C++ examples. Those binaries are statically linked and can take plenty of disk space" OFF) add_executable(HelloWorld HelloWorld.cc) diff --git a/tests/cc/CMakeLists.txt b/tests/cc/CMakeLists.txt index d7c3930bc..79b2f16c1 100644 --- a/tests/cc/CMakeLists.txt +++ b/tests/cc/CMakeLists.txt @@ -11,8 +11,8 @@ target_link_libraries(test_static bcc-static) add_test(NAME c_test_static COMMAND ${TEST_WRAPPER} c_test_static sudo ${CMAKE_CURRENT_BINARY_DIR}/test_static) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-result") -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-result") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-result -fPIC") +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-result -fPIC") if(ENABLE_USDT) set(TEST_LIBBCC_SOURCES From 46947c5d4575853ca7ddfc695b53d83c824278e4 Mon Sep 17 00:00:00 2001 From: Anton Protopopov Date: Tue, 12 May 2020 00:30:24 +0000 Subject: [PATCH 109/278] libbpf-tools: convert BCC vfsstat to BPF CO-RE version Signed-off-by: Anton Protopopov --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 2 +- libbpf-tools/vfsstat.bpf.c | 48 ++++++++++ libbpf-tools/vfsstat.c | 188 +++++++++++++++++++++++++++++++++++++ libbpf-tools/vfsstat.h | 15 +++ 5 files changed, 253 insertions(+), 1 deletion(-) create mode 100644 libbpf-tools/vfsstat.bpf.c create mode 100644 libbpf-tools/vfsstat.c create mode 100644 libbpf-tools/vfsstat.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index b0d4470f3..114af02e0 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -3,4 +3,5 @@ /filelife /opensnoop /runqslower +/vfsstat /xfsslower diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index aa73ba5ae..57b714e40 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -9,7 +9,7 @@ INCLUDES := -I$(OUTPUT) CFLAGS := -g -O2 -Wall ARCH := $(shell uname -m | sed 's/x86_64/x86/') -APPS = drsnoop filelife opensnoop runqslower xfsslower +APPS = drsnoop filelife opensnoop runqslower vfsstat xfsslower .PHONY: all all: $(APPS) diff --git a/libbpf-tools/vfsstat.bpf.c b/libbpf-tools/vfsstat.bpf.c new file mode 100644 index 000000000..1ffacebaa --- /dev/null +++ b/libbpf-tools/vfsstat.bpf.c @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Anton Protopopov +// +// Based on vfsstat(8) from BCC by Brendan Gregg +#include "vmlinux.h" +#include +#include +#include "vfsstat.h" + +__u64 stats[S_MAXSTAT] = {}; + +static __always_inline int inc_stats(int key) +{ + __atomic_add_fetch(&stats[key], 1, __ATOMIC_RELAXED); + return 0; +} + +SEC("kprobe/vfs_read") +int BPF_KPROBE(kprobe__vfs_read) +{ + return inc_stats(S_READ); +} + +SEC("kprobe/vfs_write") +int BPF_KPROBE(kprobe__vfs_write) +{ + return inc_stats(S_WRITE); +} + +SEC("kprobe/vfs_fsync") +int BPF_KPROBE(kprobe__vfs_fsync) +{ + return inc_stats(S_FSYNC); +} + +SEC("kprobe/vfs_open") +int BPF_KPROBE(kprobe__vfs_open) +{ + return inc_stats(S_OPEN); +} + +SEC("kprobe/vfs_create") +int BPF_KPROBE(kprobe__vfs_create) +{ + return inc_stats(S_CREATE); +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/vfsstat.c b/libbpf-tools/vfsstat.c new file mode 100644 index 000000000..887ec9ad1 --- /dev/null +++ b/libbpf-tools/vfsstat.c @@ -0,0 +1,188 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Anton Protopopov +// +// Based on vfsstat(8) from BCC by Brendan Gregg +#include +#include +#include +#include +#include +#include "vfsstat.h" +#include "vfsstat.skel.h" + +const char *argp_program_version = "vfsstat 0.1"; +const char *argp_program_bug_address = ""; +static const char argp_program_doc[] = + "\nvfsstat: Count some VFS calls\n" + "\n" + "EXAMPLES:\n" + " vfsstat # interval one second\n" + " vfsstat 5 3 # interval five seconds, three output lines\n"; +static char args_doc[] = "[interval [count]]"; + +static const struct argp_option opts[] = { + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static struct env { + bool verbose; + int count; + int interval; +} env = { + .interval = 1, /* once a second */ +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + long interval; + long count; + + switch (key) { + case 'v': + env.verbose = true; + break; + case ARGP_KEY_ARG: + switch (state->arg_num) { + case 0: + errno = 0; + interval = strtol(arg, NULL, 10); + if (errno || interval <= 0 || interval > INT_MAX) { + fprintf(stderr, "invalid interval: %s\n", arg); + argp_usage(state); + } + env.interval = interval; + break; + case 1: + errno = 0; + count = strtol(arg, NULL, 10); + if (errno || count < 0 || count > INT_MAX) { + fprintf(stderr, "invalid count: %s\n", arg); + argp_usage(state); + } + env.count = count; + break; + default: + argp_usage(state); + break; + } + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +static int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static int bump_memlock_rlimit(void) +{ + struct rlimit rlim_new = { + .rlim_cur = RLIM_INFINITY, + .rlim_max = RLIM_INFINITY, + }; + + return setrlimit(RLIMIT_MEMLOCK, &rlim_new); +} + +static const char *strftime_now(char *s, size_t max, const char *format) +{ + struct tm *tm; + time_t t; + + t = time(NULL); + tm = localtime(&t); + if (tm == NULL) { + fprintf(stderr, "localtime: %s\n", strerror(errno)); + return ""; + } + if (strftime(s, max, format, tm) == 0) { + fprintf(stderr, "strftime error\n"); + return ""; + } + return s; +} + +static const char *stat_types_names[] = { + [S_READ] = "READ", + [S_WRITE] = "WRITE", + [S_FSYNC] = "FSYNC", + [S_OPEN] = "OPEN", + [S_CREATE] = "CREATE", +}; + +static void print_header(void) +{ + printf("%-8s ", "TIME"); + for (int i = 0; i < S_MAXSTAT; i++) + printf(" %6s/s", stat_types_names[i]); + printf("\n"); +} + +static void print_and_reset_stats(__u64 stats[S_MAXSTAT]) +{ + char s[16]; + __u64 val; + + printf("%-8s: ", strftime_now(s, sizeof(s), "%H:%M:%S")); + for (int i = 0; i < S_MAXSTAT; i++) { + val = __atomic_exchange_n(&stats[i], 0, __ATOMIC_RELAXED); + printf(" %8llu", val / env.interval); + } + printf("\n"); +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + .args_doc = args_doc, + }; + struct vfsstat_bpf *obj; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %s\n", + strerror(errno)); + return 1; + } + + obj = vfsstat_bpf__open_and_load(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF object\n"); + return 1; + } + + err = vfsstat_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs: %s\n", + strerror(-err)); + goto cleanup; + } + + print_header(); + do { + sleep(env.interval); + print_and_reset_stats(obj->bss->stats); + } while (!env.count || --env.count); + +cleanup: + vfsstat_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/vfsstat.h b/libbpf-tools/vfsstat.h new file mode 100644 index 000000000..e5a3c16eb --- /dev/null +++ b/libbpf-tools/vfsstat.h @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Anton Protopopov +#ifndef __VFSSTAT_H +#define __VFSSTAT_H + +enum stat_types { + S_READ, + S_WRITE, + S_FSYNC, + S_OPEN, + S_CREATE, + S_MAXSTAT, +}; + +#endif /* __VFSSTAT_H */ From c6342d23e48ae03df78f7c716f55e6ff14e5169b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mauricio=20V=C3=A1squez?= Date: Tue, 19 May 2020 07:59:36 -0500 Subject: [PATCH 110/278] Fix github actions tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Github actions are failing because the docker image used for testing is based in Ubuntu 19.04 that is EOL now. This commit downgrades the version used for testing to 18.04 that is LTS. It also installs the "util-linux" package that includes the "unshare" command. Signed-off-by: Mauricio Vásquez --- Dockerfile.tests | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Dockerfile.tests b/Dockerfile.tests index b4bff710d..251eb5317 100644 --- a/Dockerfile.tests +++ b/Dockerfile.tests @@ -1,19 +1,19 @@ -# Using ubuntu 19.04 for newer `unshare` command used in tests -FROM ubuntu:19.04 +FROM ubuntu:18.04 ARG LLVM_VERSION="8" ENV LLVM_VERSION=$LLVM_VERSION RUN apt-get update && apt-get install -y curl gnupg &&\ llvmRepository="\n\ -deb http://apt.llvm.org/disco/ llvm-toolchain-disco main\n\ -deb-src http://apt.llvm.org/disco/ llvm-toolchain-disco main\n\ -deb http://apt.llvm.org/disco/ llvm-toolchain-disco-${LLVM_VERSION} main\n\ -deb-src http://apt.llvm.org/disco/ llvm-toolchain-disco-${LLVM_VERSION} main\n" &&\ +deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic main\n\ +deb-src http://apt.llvm.org/bionic/ llvm-toolchain-bionic main\n\ +deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-${LLVM_VERSION} main\n\ +deb-src http://apt.llvm.org/bionic/ llvm-toolchain-bionic-${LLVM_VERSION} main\n" &&\ echo $llvmRepository >> /etc/apt/sources.list && \ curl -L https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add - RUN apt-get update && apt-get install -y \ + util-linux \ bison \ binutils-dev \ cmake \ From 8c12794214bf906089f972676eb065e618d581af Mon Sep 17 00:00:00 2001 From: Erwan Velu Date: Wed, 20 May 2020 20:25:32 +0200 Subject: [PATCH 111/278] tools/dirtop: Adding dirtop utility (#2819) This tools is about reporting IOs per directory. That's a clone of filetop but works in a different way : - user specify a set of globs to select a list of directories to watch - dirtop extracts the inode_id of the selected directories - the bpf program receives the list of top directories to consider - when vfs_{read|write} occurs, the bpf program check if one of the parents is part of the list we search for - if it matches, the io is accounted On the python side, the program will reconcilate IOs per directory and print stats. While filetop list the programs and filename, dirtop only list the directory name. A typical usages looks like : [root@host]: dirtop.py -d '/hdfs/uuid/*/yarn' 14:56:33 loadavg: 52.21 48.81 37.78 53/2721 28720 READS WRITES R_Kb W_Kb PATH 36821 7632 238219 149183 /hdfs/uuid/d04fccd8-bc72-4ed9-bda4-c5b6893f1405/yarn 20823 2 196290 3 /hdfs/uuid/b94cbf3f-76b1-4ced-9043-02d450b9887c/yarn 16059 12064 109748 85778 /hdfs/uuid/250b21c8-1714-45fe-8c08-d45d0271c6bd/yarn 14128 20360 106287 81440 /hdfs/uuid/4a833770-767e-43b3-b696-dc98901bce26/yarn 15883 4991 86014 82075 /hdfs/uuid/0cc3683f-4800-4c73-8075-8d77dc7cf116/yarn 11182 4485 28834 116917 /hdfs/uuid/7d512fe7-b20d-464c-a75a-dbf8b687ee1c/yarn 11848 7810 103139 31240 /hdfs/uuid/2c6a7223-cb18-4916-a1b6-8cd02bda1d31/yarn 10418 1272 114842 18 /hdfs/uuid/76dc0b77-e2fd-4476-818f-2b5c3c452396/yarn 10066 6630 93969 20218 /hdfs/uuid/c11da291-28de-4a77-873e-44bb452d238b/yarn 13648 15453 39450 53744 /hdfs/uuid/99c178d5-a209-4af2-8467-7382c7f03c1b/yarn 9509 2049 31363 48219 /hdfs/uuid/a78f846a-58c4-4d10-a9f5-42f16a6134a0/yarn 8112 2178 13765 63479 /hdfs/uuid/bf829d08-1455-45b8-81fa-05c3303e8c45/yarn 4327 0 37544 0 /hdfs/uuid/fada8004-53ff-48df-9396-165d8e42925b/yarn 2238 2742 72 50 /hdfs/uuid/b3b2a2ed-f6c1-4641-86bf-2989dd932411/yarn 3716 0 47 0 /hdfs/uuid/8138a53b-b942-44d3-82df-51575f1a3901/yarn Signed-off-by: Erwan Velu Co-authored-by: Erwan Velu --- README.md | 1 + man/man8/dirtop.8 | 115 +++++++++++++++++ tools/dirtop.py | 264 +++++++++++++++++++++++++++++++++++++++ tools/dirtop_example.txt | 108 ++++++++++++++++ 4 files changed, 488 insertions(+) create mode 100644 man/man8/dirtop.8 create mode 100755 tools/dirtop.py create mode 100644 tools/dirtop_example.txt diff --git a/README.md b/README.md index 6553db792..03a50c4c1 100644 --- a/README.md +++ b/README.md @@ -105,6 +105,7 @@ pair of .c and .py files, and some are directories of files. - tools/[dcsnoop](tools/dcsnoop.py): Trace directory entry cache (dcache) lookups. [Examples](tools/dcsnoop_example.txt). - tools/[dcstat](tools/dcstat.py): Directory entry cache (dcache) stats. [Examples](tools/dcstat_example.txt). - tools/[deadlock](tools/deadlock.py): Detect potential deadlocks on a running process. [Examples](tools/deadlock_example.txt). +- tools/[dirtop](tools/dirtop.py): File reads and writes by directory. Top for directories. [Examples](tools/dirtop_example.txt). - tools/[drsnoop](tools/drsnoop.py): Trace direct reclaim events with PID and latency. [Examples](tools/drsnoop_example.txt). - tools/[execsnoop](tools/execsnoop.py): Trace new processes via exec() syscalls. [Examples](tools/execsnoop_example.txt). - tools/[exitsnoop](tools/exitsnoop.py): Trace process termination (exit and fatal signals). [Examples](tools/exitsnoop_example.txt). diff --git a/man/man8/dirtop.8 b/man/man8/dirtop.8 new file mode 100644 index 000000000..cc61a676f --- /dev/null +++ b/man/man8/dirtop.8 @@ -0,0 +1,115 @@ +.TH dirtop 8 "2020-03-16" "USER COMMANDS" +.SH NAME +dirtop \- File reads and writes by directory. Top for directories. +.SH SYNOPSIS +.B dirtop \-d directory1,directory2,... [\-h] [\-C] [\-r MAXROWS] [\-s {reads,writes,rbytes,wbytes}] [\-p PID] [interval] [count] +.SH DESCRIPTION +This is top for directories. + +This traces file reads and writes, and prints a per-directory summary every interval +(by default, 1 second). By default the summary is sorted on the highest read +throughput (Kbytes). Sorting order can be changed via -s option. + +This uses in-kernel eBPF maps to store per process summaries for efficiency. + +This script works by tracing the __vfs_read() and __vfs_write() functions using +kernel dynamic tracing, which instruments explicit read and write calls. If +files are read or written using another means (eg, via mmap()), then they +will not be visible using this tool. Also, this tool will need updating to +match any code changes to those vfs functions. + +This should be useful for file system workload characterization when analyzing +the performance of applications. + +Note that tracing VFS level reads and writes can be a frequent activity, and +this tool can begin to cost measurable overhead at high I/O rates. + +Since this uses BPF, only the root user can use this tool. +.SH REQUIREMENTS +CONFIG_BPF and bcc. +.SH OPTIONS +.TP +\-d +Defines a list of directories, comma separated, to observe. +Wildcards are allowed if between single bracket. +.TP +\-C +Don't clear the screen. +.TP +\-r MAXROWS +Maximum number of rows to print. Default is 20. +.TP +\-s {reads,writes,rbytes,wbytes} +Sort column. Default is rbytes (read throughput). +.TP +\-p PID +Trace this PID only. +.TP +interval +Interval between updates, seconds. +.TP +count +Number of interval summaries. + +.SH EXAMPLES +.TP +Summarize block device I/O by directory, 1 second screen refresh: +# +.B dirtop.py +.TP +Don't clear the screen, and top 8 rows only: +# +.B dirtop.py -Cr 8 +.TP +5 second summaries, 10 times only: +# +.B dirtop.py 5 10 +.TP +Report read & write IOs generated in mutliple yarn and data directories: +# +.B dirtop.py -d '/hdfs/uuid/*/yarn,/hdfs/uuid/*/data' +.SH FIELDS +.TP +loadavg: +The contents of /proc/loadavg +.TP +READS +Count of reads during interval. +.TP +WRITES +Count of writes during interval. +.TP +R_Kb +Total read Kbytes during interval. +.TP +W_Kb +Total write Kbytes during interval. +.TP +PATH +The path were the IOs were accounted. +.SH OVERHEAD +Depending on the frequency of application reads and writes, overhead can become +significant, in the worst case slowing applications by over 50%. Hopefully for +real world workloads the overhead is much less -- test before use. The reason +for the high overhead is that VFS reads and writes can be a frequent event, and +despite the eBPF overhead being very small per event, if you multiply this +small overhead by a million events per second, it becomes a million times +worse. Literally. You can gauge the number of reads and writes using the +vfsstat(8) tool, also from bcc. +.SH SOURCE +This is from bcc. +.IP +https://github.com/iovisor/bcc +.PP +Also look in the bcc distribution for a companion _examples.txt file containing +example usage, output, and commentary for this tool. +.SH OS +Linux +.SH STABILITY +Unstable - in development. +.SH AUTHOR +Erwan Velu +.SH INSPIRATION +filetop(8) by Brendan Gregg +.SH SEE ALSO +vfsstat(8), vfscount(8), fileslower(8) diff --git a/tools/dirtop.py b/tools/dirtop.py new file mode 100755 index 000000000..d7c9e0c75 --- /dev/null +++ b/tools/dirtop.py @@ -0,0 +1,264 @@ +#!/usr/bin/python +# @lint-avoid-python-3-compatibility-imports +# +# dirtop file reads and writes by directory. +# For Linux, uses BCC, eBPF. +# +# USAGE: dirtop.py -d 'directory1,directory2' [-h] [-C] [-r MAXROWS] [interval] [count] +# +# This uses in-kernel eBPF maps to store per process summaries for efficiency. +# +# Copyright 2016 Netflix, Inc. +# Licensed under the Apache License, Version 2.0 (the "License") +# +# 13-Mar-2020 Erwan Velu Created dirtop from filetop +# 06-Feb-2016 Brendan Gregg Created filetop. + +from __future__ import print_function +from bcc import BPF +from time import sleep, strftime +import argparse +import os +import stat +from subprocess import call + +# arguments +examples = """examples: + ./dirtop -d '/hdfs/uuid/*/yarn' # directory I/O top, 1 second refresh + ./dirtop -d '/hdfs/uuid/*/yarn' -C # don't clear the screen + ./dirtop -d '/hdfs/uuid/*/yarn' 5 # 5 second summaries + ./dirtop -d '/hdfs/uuid/*/yarn' 5 10 # 5 second summaries, 10 times only + ./dirtop -d '/hdfs/uuid/*/yarn,/hdfs/uuid/*/data' # Running dirtop on two set of directories +""" +parser = argparse.ArgumentParser( + description="File reads and writes by process", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=examples) +parser.add_argument("-C", "--noclear", action="store_true", + help="don't clear the screen") +parser.add_argument("-r", "--maxrows", default=20, + help="maximum rows to print, default 20") +parser.add_argument("-s", "--sort", default="all", + choices=["all", "reads", "writes", "rbytes", "wbytes"], + help="sort column, default all") +parser.add_argument("-p", "--pid", type=int, metavar="PID", dest="tgid", + help="trace this PID only") +parser.add_argument("interval", nargs="?", default=1, + help="output interval, in seconds") +parser.add_argument("count", nargs="?", default=99999999, + help="number of outputs") +parser.add_argument("--ebpf", action="store_true", + help=argparse.SUPPRESS) +parser.add_argument("-d", "--root-directories", type=str, required=True, dest="rootdirs", + help="select the directories to observe, separated by commas") +args = parser.parse_args() +interval = int(args.interval) +countdown = int(args.count) +maxrows = int(args.maxrows) +clear = not int(args.noclear) +debug = 0 + +# linux stats +loadavg = "/proc/loadavg" + +# define BPF program +bpf_text = """ +# include +# include + +// the key for the output summary +struct info_t { + unsigned long inode_id; +}; + +// the value of the output summary +struct val_t { + u64 reads; + u64 writes; + u64 rbytes; + u64 wbytes; +}; + +BPF_HASH(counts, struct info_t, struct val_t); + +static int do_entry(struct pt_regs *ctx, struct file *file, + char __user *buf, size_t count, int is_read) +{ + u32 tgid = bpf_get_current_pid_tgid() >> 32; + if (TGID_FILTER) + return 0; + + // The directory inodes we look at + u32 dir_ids[INODES_NUMBER] = DIRECTORY_INODES; + struct info_t info = {.inode_id = 0}; + struct dentry *pde = file->f_path.dentry; + for (int i=0; i<50; i++) { + // If we don't have any parent, we reached the root + if (!pde->d_parent) { + break; + } + pde = pde->d_parent; + // Does the files is part of the directory we look for + for(int dir_id=0; dir_idd_inode->i_ino == dir_ids[dir_id]) { + // Yes, let's export the top directory inode + info.inode_id = pde->d_inode->i_ino; + break; + } + } + } + // If we didn't found any, let's abort + if (info.inode_id == 0) { + return 0; + } + + struct val_t *valp, zero = {}; + valp = counts.lookup_or_try_init(&info, &zero); + if (valp) { + if (is_read) { + valp->reads++; + valp->rbytes += count; + } else { + valp->writes++; + valp->wbytes += count; + } + } + return 0; +} + +int trace_read_entry(struct pt_regs *ctx, struct file *file, + char __user *buf, size_t count) +{ + return do_entry(ctx, file, buf, count, 1); +} + +int trace_write_entry(struct pt_regs *ctx, struct file *file, + char __user *buf, size_t count) +{ + return do_entry(ctx, file, buf, count, 0); +} + +""" + + +def get_searched_ids(root_directories): + """Export the inode numbers of the selected directories.""" + from glob import glob + inode_to_path = {} + inodes = "{" + total_dirs = 0 + for root_directory in root_directories.split(','): + searched_dirs = glob(root_directory, recursive=True) + if not searched_dirs: + continue + + for mydir in searched_dirs: + total_dirs = total_dirs + 1 + # If we pass more than 15 dirs, ebpf program fails + if total_dirs > 15: + print('15 directories limit reached') + break + inode_id = os.lstat(mydir)[stat.ST_INO] + if inode_id in inode_to_path: + if inode_to_path[inode_id] == mydir: + print('Skipping {} as already considered'.format(mydir)) + else: + inodes = "{},{}".format(inodes, inode_id) + inode_to_path[inode_id] = mydir + print('Considering {} with inode_id {}'.format(mydir, inode_id)) + + inodes = inodes + '}' + if len(inode_to_path) == 0: + print('Cannot find any valid directory') + exit() + return inodes.replace('{,', '{'), inode_to_path + + +if args.tgid: + bpf_text = bpf_text.replace('TGID_FILTER', 'tgid != %d' % args.tgid) +else: + bpf_text = bpf_text.replace('TGID_FILTER', '0') + +inodes, inodes_to_path = get_searched_ids(args.rootdirs) +bpf_text = bpf_text.replace("DIRECTORY_INODES", inodes) +bpf_text = bpf_text.replace( + "INODES_NUMBER", '{}'.format(len(inodes.split(',')))) + +if debug or args.ebpf: + print(bpf_text) + if args.ebpf: + exit() + +# initialize BPF +b = BPF(text=bpf_text) +b.attach_kprobe(event="vfs_read", fn_name="trace_read_entry") +b.attach_kprobe(event="vfs_write", fn_name="trace_write_entry") + +DNAME_INLINE_LEN = 32 # linux/dcache.h + +print('Tracing... Output every %d secs. Hit Ctrl-C to end' % interval) + + +def sort_fn(counts): + """Define how to sort the columns""" + if args.sort == "all": + return (counts[1].rbytes + counts[1].wbytes + counts[1].reads + counts[1].writes) + else: + return getattr(counts[1], args.sort) + + +# output +exiting = 0 +while 1: + try: + sleep(interval) + except KeyboardInterrupt: + exiting = 1 + + # header + if clear: + call("clear") + else: + print() + with open(loadavg) as stats: + print("%-8s loadavg: %s" % (strftime("%H:%M:%S"), stats.read())) + + print("%-6s %-6s %-8s %-8s %s" % + ("READS", "WRITES", "R_Kb", "W_Kb", "PATH")) + # by-TID output + counts = b.get_table("counts") + line = 0 + reads = {} + writes = {} + reads_Kb = {} + writes_Kb = {} + for k, v in reversed(sorted(counts.items(), + key=sort_fn)): + # If it's the first time we see this inode + if k.inode_id not in reads: + # let's create a new entry + reads[k.inode_id] = v.reads + writes[k.inode_id] = v.writes + reads_Kb[k.inode_id] = v.rbytes / 1024 + writes_Kb[k.inode_id] = v.wbytes / 1024 + else: + # unless add the current performance metrics + # to the previous ones + reads[k.inode_id] += v.reads + writes[k.inode_id] += v.writes + reads_Kb[k.inode_id] += v.rbytes / 1024 + writes_Kb[k.inode_id] += v.wbytes / 1024 + + for node_id in reads: + print("%-6d %-6d %-8d %-8d %s" % + (reads[node_id], writes[node_id], reads_Kb[node_id], writes_Kb[node_id], inodes_to_path[node_id])) + line += 1 + if line >= maxrows: + break + + counts.clear() + + countdown -= 1 + if exiting or countdown == 0: + print("Detaching...") + exit() diff --git a/tools/dirtop_example.txt b/tools/dirtop_example.txt new file mode 100644 index 000000000..91b0b0338 --- /dev/null +++ b/tools/dirtop_example.txt @@ -0,0 +1,108 @@ +Demonstrations of dirtop, the Linux eBPF/bcc version. + + +dirtop shows reads and writes by directory. For example: + +# ./dirtop.py -d '/hdfs/uuid/*/yarn' +Tracing... Output every 1 secs. Hit Ctrl-C to end + +14:28:12 loadavg: 25.00 22.85 21.22 31/2921 66450 + +READS WRITES R_Kb W_Kb PATH +1030 2852 8 147341 /hdfs/uuid/c11da291-28de-4a77-873e-44bb452d238b/yarn +3308 2459 10980 24893 /hdfs/uuid/bf829d08-1455-45b8-81fa-05c3303e8c45/yarn +2227 7165 6484 11157 /hdfs/uuid/76dc0b77-e2fd-4476-818f-2b5c3c452396/yarn +1985 9576 6431 6616 /hdfs/uuid/99c178d5-a209-4af2-8467-7382c7f03c1b/yarn +1986 398 6474 6486 /hdfs/uuid/7d512fe7-b20d-464c-a75a-dbf8b687ee1c/yarn +764 3685 5 7069 /hdfs/uuid/250b21c8-1714-45fe-8c08-d45d0271c6bd/yarn +432 1603 259 6402 /hdfs/uuid/4a833770-767e-43b3-b696-dc98901bce26/yarn +993 5856 320 129 /hdfs/uuid/b94cbf3f-76b1-4ced-9043-02d450b9887c/yarn +612 5645 4 249 /hdfs/uuid/8138a53b-b942-44d3-82df-51575f1a3901/yarn +818 21 6 166 /hdfs/uuid/fada8004-53ff-48df-9396-165d8e42925b/yarn +174 23 1 171 /hdfs/uuid/d04fccd8-bc72-4ed9-bda4-c5b6893f1405/yarn +376 6281 2 97 /hdfs/uuid/0cc3683f-4800-4c73-8075-8d77dc7cf116/yarn +370 4588 2 96 /hdfs/uuid/a78f846a-58c4-4d10-a9f5-42f16a6134a0/yarn +190 6420 1 86 /hdfs/uuid/2c6a7223-cb18-4916-a1b6-8cd02bda1d31/yarn +178 123 1 17 /hdfs/uuid/b3b2a2ed-f6c1-4641-86bf-2989dd932411/yarn +[...] + +This shows various directories read and written when hadoop runs. +By default the output is sorted by the total read size in Kbytes (R_Kb). +Sorting order can be changed via -s option. +This is instrumenting at the VFS interface, so this is reads and writes that +may return entirely from the file system cache (page cache). + +While not printed, the average read and write size can be calculated by +dividing R_Kb by READS, and the same for writes. + +This script works by tracing the vfs_read() and vfs_write() functions using +kernel dynamic tracing, which instruments explicit read and write calls. If +files are read or written using another means (eg, via mmap()), then they +will not be visible using this tool. + +This should be useful for file system workload characterization when analyzing +the performance of applications. + +Note that tracing VFS level reads and writes can be a frequent activity, and +this tool can begin to cost measurable overhead at high I/O rates. + + +A -C option will stop clearing the screen, and -r with a number will restrict +the output to that many rows (20 by default). For example, not clearing +the screen and showing the top 5 only: + +# ./dirtop -d '/hdfs/uuid/*/yarn' -Cr 5 +Tracing... Output every 1 secs. Hit Ctrl-C to end + +14:29:08 loadavg: 25.66 23.42 21.51 17/2850 67167 + +READS WRITES R_Kb W_Kb PATH +100 8429 0 48243 /hdfs/uuid/b94cbf3f-76b1-4ced-9043-02d450b9887c/yarn +2066 4091 8176 26457 /hdfs/uuid/d04fccd8-bc72-4ed9-bda4-c5b6893f1405/yarn +10 2043 0 8172 /hdfs/uuid/b3b2a2ed-f6c1-4641-86bf-2989dd932411/yarn +38 1368 0 2652 /hdfs/uuid/a78f846a-58c4-4d10-a9f5-42f16a6134a0/yarn +86 19 0 123 /hdfs/uuid/c11da291-28de-4a77-873e-44bb452d238b/yarn + +14:29:09 loadavg: 25.66 23.42 21.51 15/2849 67170 + +READS WRITES R_Kb W_Kb PATH +1204 5619 4388 33767 /hdfs/uuid/b94cbf3f-76b1-4ced-9043-02d450b9887c/yarn +2208 3511 8744 22992 /hdfs/uuid/d04fccd8-bc72-4ed9-bda4-c5b6893f1405/yarn +62 4010 0 21181 /hdfs/uuid/8138a53b-b942-44d3-82df-51575f1a3901/yarn +22 2187 0 8748 /hdfs/uuid/b3b2a2ed-f6c1-4641-86bf-2989dd932411/yarn +74 1097 0 4388 /hdfs/uuid/4a833770-767e-43b3-b696-dc98901bce26/yarn + +[..] + + + +USAGE message: + +# ./dirtop.py -h +usage: dirtop.py [-h] [-C] [-r MAXROWS] [-s {all,reads,writes,rbytes,wbytes}] + [-p PID] -d ROOTDIRS + [interval] [count] + +File reads and writes by process + +positional arguments: + interval output interval, in seconds + count number of outputs + +optional arguments: + -h, --help show this help message and exit + -C, --noclear don't clear the screen + -r MAXROWS, --maxrows MAXROWS + maximum rows to print, default 20 + -s {all,reads,writes,rbytes,wbytes}, --sort {all,reads,writes,rbytes,wbytes} + sort column, default all + -p PID, --pid PID trace this PID only + -d ROOTDIRS, --root-directories ROOTDIRS + select the directories to observe, separated by commas + +examples: + ./dirtop -d '/hdfs/uuid/*/yarn' # directory I/O top, 1 second refresh + ./dirtop -d '/hdfs/uuid/*/yarn' -C # don't clear the screen + ./dirtop -d '/hdfs/uuid/*/yarn' 5 # 5 second summaries + ./dirtop -d '/hdfs/uuid/*/yarn' 5 10 # 5 second summaries, 10 times only + ./dirtop -d '/hdfs/uuid/*/yarn,/hdfs/uuid/*/data' # Running dirtop on two set of directories From fa8142e39a65b626309fe01e5024c9886b7a5059 Mon Sep 17 00:00:00 2001 From: Slava Bacherikov Date: Thu, 12 Mar 2020 21:23:51 +0200 Subject: [PATCH 112/278] libbpf-tools: add CO-RE execsnoop --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 2 +- libbpf-tools/execsnoop.bpf.c | 128 +++++++++++++ libbpf-tools/execsnoop.c | 340 +++++++++++++++++++++++++++++++++++ libbpf-tools/execsnoop.h | 27 +++ 5 files changed, 497 insertions(+), 1 deletion(-) create mode 100644 libbpf-tools/execsnoop.bpf.c create mode 100644 libbpf-tools/execsnoop.c create mode 100644 libbpf-tools/execsnoop.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 114af02e0..50bf5f8b1 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -1,5 +1,6 @@ /.output /drsnoop +/execsnoop /filelife /opensnoop /runqslower diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 57b714e40..819dd2e12 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -9,7 +9,7 @@ INCLUDES := -I$(OUTPUT) CFLAGS := -g -O2 -Wall ARCH := $(shell uname -m | sed 's/x86_64/x86/') -APPS = drsnoop filelife opensnoop runqslower vfsstat xfsslower +APPS = drsnoop execsnoop filelife opensnoop runqslower vfsstat xfsslower .PHONY: all all: $(APPS) diff --git a/libbpf-tools/execsnoop.bpf.c b/libbpf-tools/execsnoop.bpf.c new file mode 100644 index 000000000..40a1bfc30 --- /dev/null +++ b/libbpf-tools/execsnoop.bpf.c @@ -0,0 +1,128 @@ +#include "vmlinux.h" +#include +#include +#include "execsnoop.h" + +const volatile bool ignore_failed = true; +const volatile uid_t targ_uid = INVALID_UID; +const volatile int max_args = DEFAULT_MAXARGS; + +static const struct event empty_event = {}; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, 10240); + __type(key, pid_t); + __type(value, struct event); +} execs SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY); + __uint(key_size, sizeof(u32)); + __uint(value_size, sizeof(u32)); +} events SEC(".maps"); + +static __always_inline bool valid_uid(uid_t uid) { + return uid != INVALID_UID; +} + +SEC("tracepoint/syscalls/sys_enter_execve") +int tracepoint__syscalls__sys_enter_execve(struct trace_event_raw_sys_enter* ctx) +{ + u64 id; + pid_t pid, tgid; + unsigned int ret; + struct event *event; + struct task_struct *task; + const char **args = (const char **)(ctx->args[1]); + const char *argp; + uid_t uid = (u32)bpf_get_current_uid_gid(); + + if (valid_uid(targ_uid) && targ_uid != uid) + return 0; + + id = bpf_get_current_pid_tgid(); + pid = (pid_t)id; + tgid = id >> 32; + if (bpf_map_update_elem(&execs, &pid, &empty_event, BPF_NOEXIST)) + return 0; + + event = bpf_map_lookup_elem(&execs, &pid); + if (!event) + return 0; + + event->pid = pid; + event->tgid = tgid; + event->uid = uid; + task = (struct task_struct*)bpf_get_current_task(); + event->ppid = (pid_t)BPF_CORE_READ(task, real_parent, tgid); + event->args_count = 0; + event->args_size = 0; + + ret = bpf_probe_read_str(event->args, ARGSIZE, (const char*)ctx->args[0]); + if (ret <= ARGSIZE) { + event->args_size += ret; + } else { + /* write an empty string */ + event->args[0] = '\0'; + event->args_size++; + } + + event->args_count++; + #pragma unroll + for (int i = 1; i < TOTAL_MAX_ARGS && i < max_args; i++) { + bpf_probe_read(&argp, sizeof(argp), &args[i]); + if (!argp) + return 0; + + if (event->args_size > LAST_ARG) + return 0; + + ret = bpf_probe_read_str(&event->args[event->args_size], ARGSIZE, argp); + if (ret > ARGSIZE) + return 0; + + event->args_count++; + event->args_size += ret; + } + /* try to read one more argument to check if there is one */ + bpf_probe_read(&argp, sizeof(argp), &args[max_args]); + if (!argp) + return 0; + + /* pointer to max_args+1 isn't null, asume we have more arguments */ + event->args_count++; + return 0; +} + +SEC("tracepoint/syscalls/sys_exit_execve") +int tracepoint__syscalls__sys_exit_execve(struct trace_event_raw_sys_exit* ctx) +{ + u64 id; + pid_t pid; + int ret; + struct event *event; + u32 uid = (u32)bpf_get_current_uid_gid(); + + if (valid_uid(targ_uid) && targ_uid != uid) + return 0; + id = bpf_get_current_pid_tgid(); + pid = (pid_t)id; + event = bpf_map_lookup_elem(&execs, &pid); + if (!event) + return 0; + ret = ctx->ret; + if (ignore_failed && ret < 0) + goto cleanup; + + event->retval = ret; + bpf_get_current_comm(&event->comm, sizeof(event->comm)); + size_t len = EVENT_SIZE(event); + if (len <= sizeof(*event)) + bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, event, len); +cleanup: + bpf_map_delete_elem(&execs, &pid); + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/execsnoop.c b/libbpf-tools/execsnoop.c new file mode 100644 index 000000000..6cf936055 --- /dev/null +++ b/libbpf-tools/execsnoop.c @@ -0,0 +1,340 @@ +// Based on execsnoop(8) from BCC by Brendan Gregg and others. +// +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "execsnoop.h" +#include "execsnoop.skel.h" + +#define PERF_BUFFER_PAGES 64 +#define NSEC_PER_SEC 1000000000L +#define NSEC_PRECISION (NSEC_PER_SEC / 1000) +#define MAX_ARGS_KEY 259 + +static struct env { + bool time; + bool timestamp; + bool fails; + uid_t uid; + bool quote; + const char *name; + const char *line; + bool print_uid; + bool verbose; + int max_args; +} env = { + .max_args = DEFAULT_MAXARGS, + .uid = INVALID_UID +}; + +static struct timespec start_time; + +const char *argp_program_version = "execsnoop 0.1"; +const char *argp_program_bug_address = ""; +const char argp_program_doc[] = +"Trace open family syscalls\n" +"\n" +"USAGE: execsnoop [-h] [-T] [-t] [-x] [-u UID] [-q] [-n NAME] [-l LINE] [-U]\n" +" [--max-args MAX_ARGS]\n" +"\n" +"EXAMPLES:\n" +" ./execsnoop # trace all exec() syscalls\n" +" ./execsnoop -x # include failed exec()s\n" +" ./execsnoop -T # include time (HH:MM:SS)\n" +" ./execsnoop -U # include UID\n" +" ./execsnoop -u 1000 # only trace UID 1000\n" +" ./execsnoop -t # include timestamps\n" +" ./execsnoop -q # add \"quotemarks\" around arguments\n" +" ./execsnoop -n main # only print command lines containing \"main\"\n" +" ./execsnoop -l tpkg # only print command where arguments contains \"tpkg\""; + +static const struct argp_option opts[] = { + { "time", 'T', NULL, 0, "include time column on output (HH:MM:SS)"}, + { "timestamp", 't', NULL, 0, "include timestamp on output"}, + { "fails", 'x', NULL, 0, "include failed exec()s"}, + { "uid", 'u', "UID", 0, "trace this UID only"}, + { "quote", 'q', NULL, 0, "Add quotemarks (\") around arguments"}, + { "name", 'n', "NAME", 0, "only print commands matching this name, any arg"}, + { "line", 'l', "LINE", 0, "only print commands where arg contains this line"}, + { "print-uid", 'U', NULL, 0, "print UID column"}, + { "max-args", MAX_ARGS_KEY, "MAX_ARGS", 0, + "maximum number of arguments parsed and displayed, defaults to 20"}, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + long int uid, max_args; + + switch (key) { + case 'h': + argp_usage(state); + break; + case 'T': + env.time = true; + break; + case 't': + env.timestamp = true; + break; + case 'x': + env.fails = true; + break; + case 'u': + errno = 0; + uid = strtol(arg, NULL, 10); + if (errno || uid < 0 || uid >= INVALID_UID) { + fprintf(stderr, "Invalid UID %s\n", arg); + argp_usage(state); + } + env.uid = uid; + break; + case 'q': + env.quote = true; + break; + case 'n': + env.name = arg; + break; + case 'l': + env.line = arg; + break; + case 'U': + env.print_uid = true; + break; + case 'v': + env.verbose = true; + break; + case MAX_ARGS_KEY: + errno = 0; + max_args = strtol(arg, NULL, 10); + if (errno || max_args < 1 || max_args > TOTAL_MAX_ARGS) { + fprintf(stderr, "Invalid MAX_ARGS %s, should be in [1, %d] range\n", + arg, TOTAL_MAX_ARGS); + + argp_usage(state); + } + env.max_args = max_args; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +static int bump_memlock_rlimit(void) +{ + struct rlimit rlim_new = { + .rlim_cur = RLIM_INFINITY, + .rlim_max = RLIM_INFINITY, + }; + + return setrlimit(RLIMIT_MEMLOCK, &rlim_new); +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void time_since_start() +{ + long nsec, sec; + static struct timespec cur_time; + double time_diff; + + clock_gettime(CLOCK_MONOTONIC, &cur_time); + nsec = cur_time.tv_nsec - start_time.tv_nsec; + sec = cur_time.tv_sec - start_time.tv_sec; + if (nsec < 0) { + nsec += NSEC_PER_SEC; + sec--; + } + time_diff = sec + (double)nsec / NSEC_PER_SEC; + printf("%-8.3f", time_diff); +} + +static void inline quoted_symbol(char c) { + switch(c) { + case '"': + putchar('\\'); + putchar('"'); + break; + case '\t': + putchar('\\'); + putchar('t'); + break; + case '\n': + putchar('\\'); + putchar('n'); + break; + default: + putchar(c); + break; + } +} + +static void print_args(const struct event *e, bool quote) +{ + int args_counter = 0; + + if (env.quote) + putchar('"'); + + for (int i = 0; i < e->args_size && args_counter < e->args_count; i++) { + char c = e->args[i]; + if (env.quote) { + if (c == '\0') { + args_counter++; + putchar('"'); + putchar(' '); + if (args_counter < e->args_count) { + putchar('"'); + } + } else { + quoted_symbol(c); + } + } else { + if (c == '\0') { + args_counter++; + putchar(' '); + } else { + putchar(c); + } + } + } + if (e->args_count == env.max_args + 1) { + fputs(" ...", stdout); + } +} + +void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) +{ + const struct event *e = data; + time_t t; + struct tm *tm; + char ts[32]; + + /* TODO: use pcre lib */ + if (env.name && strstr(e->comm, env.name) == NULL) + return; + + /* TODO: use pcre lib */ + if (env.line && strstr(e->comm, env.line) == NULL) + return; + + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + + if (env.time) { + printf("%-8s ", ts); + } + if (env.timestamp) { + time_since_start(); + } + + if (env.print_uid) + printf("%-6d", e->uid); + + printf("%-16s %-6d %-6d %3d ", e->comm, e->pid, e->ppid, e->retval); + print_args(e, env.quote); + putchar('\n'); +} + +void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt) +{ + fprintf(stderr, "Lost %llu events on CPU #%d!\n", lost_cnt, cpu); +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct perf_buffer_opts pb_opts; + struct perf_buffer *pb = NULL; + struct execsnoop_bpf *obj; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = execsnoop_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF object\n"); + return 1; + } + + /* initialize global data (filtering options) */ + obj->rodata->ignore_failed = !env.fails; + obj->rodata->targ_uid = env.uid; + obj->rodata->max_args = env.max_args; + + err = execsnoop_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + clock_gettime(CLOCK_MONOTONIC, &start_time); + err = execsnoop_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs\n"); + goto cleanup; + } + /* print headers */ + if (env.time) { + printf("%-9s", "TIME"); + } + if (env.timestamp) { + printf("%-8s ", "TIME(s)"); + } + if (env.print_uid) { + printf("%-6s ", "UID"); + } + + printf("%-16s %-6s %-6s %3s %s\n", "PCOMM", "PID", "PPID", "RET", "ARGS"); + + /* setup event callbacks */ + pb_opts.sample_cb = handle_event; + pb_opts.lost_cb = handle_lost_events; + pb = perf_buffer__new(bpf_map__fd(obj->maps.events), PERF_BUFFER_PAGES, &pb_opts); + err = libbpf_get_error(pb); + if (err) { + pb = NULL; + fprintf(stderr, "failed to open perf buffer: %d\n", err); + goto cleanup; + } + + /* main: poll */ + while ((err = perf_buffer__poll(pb, 100)) >= 0) + ; + printf("Error polling perf buffer: %d\n", err); + +cleanup: + perf_buffer__free(pb); + execsnoop_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/execsnoop.h b/libbpf-tools/execsnoop.h new file mode 100644 index 000000000..7f9d960f4 --- /dev/null +++ b/libbpf-tools/execsnoop.h @@ -0,0 +1,27 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __EXECSNOOP_H +#define __EXECSNOOP_H + +#define ARGSIZE 128 +#define TASK_COMM_LEN 16 +#define TOTAL_MAX_ARGS 60 +#define DEFAULT_MAXARGS 20 +#define FULL_MAX_ARGS_ARR (TOTAL_MAX_ARGS * ARGSIZE) +#define INVALID_UID ((uid_t)-1) +#define BASE_EVENT_SIZE (size_t)(&((struct event*)0)->args) +#define EVENT_SIZE(e) (BASE_EVENT_SIZE + e->args_size) +#define LAST_ARG (FULL_MAX_ARGS_ARR - ARGSIZE) + +struct event { + pid_t pid; + pid_t tgid; + pid_t ppid; + uid_t uid; + int retval; + int args_count; + unsigned int args_size; + char comm[TASK_COMM_LEN]; + char args[FULL_MAX_ARGS_ARR]; +}; + +#endif /* __EXECSNOOP_H */ From 74e66b4f6730e0708f97150ac23d5951c5684ff8 Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Thu, 21 May 2020 00:03:09 -0700 Subject: [PATCH 113/278] sync with latest libbpf Sync with latest libbpf repo. Update virtual_bpf.h, helpers.h, docs, etc. Signed-off-by: Yonghong Song --- docs/kernel-versions.md | 9 +- src/cc/compat/linux/virtual_bpf.h | 250 ++++++++++++++++++++++++------ src/cc/export/helpers.h | 13 ++ src/cc/libbpf | 2 +- src/cc/libbpf.c | 5 + 5 files changed, 229 insertions(+), 50 deletions(-) diff --git a/docs/kernel-versions.md b/docs/kernel-versions.md index 416f70076..ec1d6a50c 100644 --- a/docs/kernel-versions.md +++ b/docs/kernel-versions.md @@ -187,6 +187,7 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_get_stackid()` | 4.6 | GPL | [`d5a3b1f69186`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d5a3b1f691865be576c2bffa708549b8cdccda19) `BPF_FUNC_getsockopt()` | 4.15 | | [`cd86d1fd2102`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=cd86d1fd21025fdd6daf23d1288da405e7ad0ec6) `BPF_FUNC_jiffies64()` | 5.5 | | [`5576b991e9c1`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=5576b991e9c1a11d2cc21c4b94fc75ec27603896) +`BPF_FUNC_ktime_get_boot_ns()` | 5.7 | GPL | [`71d19214776e`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/71d19214776e61b33da48f7c1b46e522c7f78221) `BPF_FUNC_ktime_get_ns()` | 4.1 | GPL | [`d9847d310ab4`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d9847d310ab4003725e6ed1822682e24bd406908) `BPF_FUNC_l3_csum_replace()` | 4.1 | | [`91bc4822c3d6`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=91bc4822c3d61b9bb7ef66d3b77948a4f9177954) `BPF_FUNC_l4_csum_replace()` | 4.1 | | [`91bc4822c3d6`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=91bc4822c3d61b9bb7ef66d3b77948a4f9177954) @@ -226,10 +227,14 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_redirect_map()` | 4.14 | | [`97f91a7cf04f`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=97f91a7cf04ff605845c20948b8a80e54cbd3376) `BPF_FUNC_send_signal()` | 5.3 | | [`8b401f9ed244`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=8b401f9ed2441ad9e219953927a842d24ed051fc) `BPF_FUNC_send_signal_thread()` | 5.5 | | [`8482941f0906`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=8482941f09067da42f9c3362e15bfb3f3c19d610) +`BPF_FUNC_seq_printf()` | 5.7 | GPL | [`492e639f0c22`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/492e639f0c222784e2e0f121966375f641c61b15) +`BPF_FUNC_seq_write()` | 5.7 | GPL | [`492e639f0c22`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/492e639f0c222784e2e0f121966375f641c61b15) `BPF_FUNC_set_hash()` | 4.13 | | [`ded092cd73c2`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=ded092cd73c2c56a394b936f86897f29b2e131c0) `BPF_FUNC_set_hash_invalid()` | 4.9 | | [`7a4b28c6cc9f`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=7a4b28c6cc9ffac50f791b99cc7e46106436e5d8) `BPF_FUNC_setsockopt()` | 4.13 | | [`8c4b4c7e9ff0`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=8c4b4c7e9ff0447995750d9329949fa082520269) +`BPF_FUNC_sk_ancestor_cgroup_id()` | 5.7 | | [`f307fa2cb4c9`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/f307fa2cb4c935f7f1ff0aeb880c7b44fb9a642b) `BPF_FUNC_sk_assign()` | 5.6 | | [`cf7fbe660f2d`](https://github.com/torvalds/linux/commit/cf7fbe660f2dbd738ab58aea8e9b0ca6ad232449) +`BPF_FUNC_sk_cgroup_id()` | 5.7 | | [`f307fa2cb4c9`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/f307fa2cb4c935f7f1ff0aeb880c7b44fb9a642b) `BPF_FUNC_sk_fullsock()` | 5.1 | | [`46f8bc92758c`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=46f8bc92758c6259bcf945e9216098661c1587cd) `BPF_FUNC_sk_lookup_tcp()` | 4.20 | | [`6acc9b432e67`](https://github.com/torvalds/linux/commit/6acc9b432e6714d72d7d77ec7c27f6f8358d0c71) `BPF_FUNC_sk_lookup_udp()` | 4.20 | | [`6acc9b432e67`](https://github.com/torvalds/linux/commit/6acc9b432e6714d72d7d77ec7c27f6f8358d0c71) @@ -326,6 +331,6 @@ The list of program types and supported helper functions can be retrieved with: |Function Group| Functions| |------------------|-------| -|`Base functions`| `BPF_FUNC_map_lookup_elem()`
`BPF_FUNC_map_update_elem()`
`BPF_FUNC_map_delete_elem()`
`BPF_FUNC_map_peek_elem()`
`BPF_FUNC_map_pop_elem()`
`BPF_FUNC_map_push_elem()`
`BPF_FUNC_get_prandom_u32()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_get_numa_node_id()`
`BPF_FUNC_tail_call()`
`BPF_FUNC_ktime_get_ns()`
`BPF_FUNC_trace_printk()`
`BPF_FUNC_spin_lock()`
`BPF_FUNC_spin_unlock()` | -|`Tracing functions`|`BPF_FUNC_map_lookup_elem()`
`BPF_FUNC_map_update_elem()`
`BPF_FUNC_map_delete_elem()`
`BPF_FUNC_probe_read()`
`BPF_FUNC_ktime_get_ns()`
`BPF_FUNC_tail_call()`
`BPF_FUNC_get_current_pid_tgid()`
`BPF_FUNC_get_current_task()`
`BPF_FUNC_get_current_uid_gid()`
`BPF_FUNC_get_current_comm()`
`BPF_FUNC_trace_printk()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_get_numa_node_id()`
`BPF_FUNC_perf_event_read()`
`BPF_FUNC_probe_write_user()`
`BPF_FUNC_current_task_under_cgroup()`
`BPF_FUNC_get_prandom_u32()`
`BPF_FUNC_probe_read_str()`
`BPF_FUNC_get_current_cgroup_id()`
`BPF_FUNC_send_signal()`
`BPF_FUNC_probe_read_kernel()`
`BPF_FUNC_probe_read_kernel_str()`
`BPF_FUNC_probe_read_user()`
`BPF_FUNC_probe_read_user_str()`
`BPF_FUNC_send_signal_thread()`
`BPF_FUNC_get_ns_current_pid_tgid()`
`BPF_FUNC_xdp_output()`| +|`Base functions`| `BPF_FUNC_map_lookup_elem()`
`BPF_FUNC_map_update_elem()`
`BPF_FUNC_map_delete_elem()`
`BPF_FUNC_map_peek_elem()`
`BPF_FUNC_map_pop_elem()`
`BPF_FUNC_map_push_elem()`
`BPF_FUNC_get_prandom_u32()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_get_numa_node_id()`
`BPF_FUNC_tail_call()`
`BPF_FUNC_ktime_get_boot_ns()`
`BPF_FUNC_ktime_get_ns()`
`BPF_FUNC_trace_printk()`
`BPF_FUNC_spin_lock()`
`BPF_FUNC_spin_unlock()` | +|`Tracing functions`|`BPF_FUNC_map_lookup_elem()`
`BPF_FUNC_map_update_elem()`
`BPF_FUNC_map_delete_elem()`
`BPF_FUNC_probe_read()`
`BPF_FUNC_ktime_get_boot_ns()`
`BPF_FUNC_ktime_get_ns()`
`BPF_FUNC_tail_call()`
`BPF_FUNC_get_current_pid_tgid()`
`BPF_FUNC_get_current_task()`
`BPF_FUNC_get_current_uid_gid()`
`BPF_FUNC_get_current_comm()`
`BPF_FUNC_trace_printk()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_get_numa_node_id()`
`BPF_FUNC_perf_event_read()`
`BPF_FUNC_probe_write_user()`
`BPF_FUNC_current_task_under_cgroup()`
`BPF_FUNC_get_prandom_u32()`
`BPF_FUNC_probe_read_str()`
`BPF_FUNC_get_current_cgroup_id()`
`BPF_FUNC_send_signal()`
`BPF_FUNC_probe_read_kernel()`
`BPF_FUNC_probe_read_kernel_str()`
`BPF_FUNC_probe_read_user()`
`BPF_FUNC_probe_read_user_str()`
`BPF_FUNC_send_signal_thread()`
`BPF_FUNC_get_ns_current_pid_tgid()`
`BPF_FUNC_xdp_output()`| |`LWT functions`| `BPF_FUNC_skb_load_bytes()`
`BPF_FUNC_skb_pull_data()`
`BPF_FUNC_csum_diff()`
`BPF_FUNC_get_cgroup_classid()`
`BPF_FUNC_get_route_realm()`
`BPF_FUNC_get_hash_recalc()`
`BPF_FUNC_perf_event_output()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_skb_under_cgroup()`| diff --git a/src/cc/compat/linux/virtual_bpf.h b/src/cc/compat/linux/virtual_bpf.h index 17b07c366..8ce8bf593 100644 --- a/src/cc/compat/linux/virtual_bpf.h +++ b/src/cc/compat/linux/virtual_bpf.h @@ -74,7 +74,7 @@ struct bpf_insn { /* Key of an a BPF_MAP_TYPE_LPM_TRIE entry */ struct bpf_lpm_trie_key { __u32 prefixlen; /* up to 32 for AF_INET, 128 for AF_INET6 */ - __u8 data[]; /* Arbitrary size */ + __u8 data[0]; /* Arbitrary size */ }; struct bpf_cgroup_storage_key { @@ -114,6 +114,10 @@ enum bpf_cmd { BPF_MAP_DELETE_BATCH, BPF_LINK_CREATE, BPF_LINK_UPDATE, + BPF_LINK_GET_FD_BY_ID, + BPF_LINK_GET_NEXT_ID, + BPF_ENABLE_STATS, + BPF_ITER_CREATE, }; enum bpf_map_type { @@ -216,11 +220,26 @@ enum bpf_attach_type { BPF_TRACE_FEXIT, BPF_MODIFY_RETURN, BPF_LSM_MAC, + BPF_TRACE_ITER, + BPF_CGROUP_INET4_GETPEERNAME, + BPF_CGROUP_INET6_GETPEERNAME, + BPF_CGROUP_INET4_GETSOCKNAME, + BPF_CGROUP_INET6_GETSOCKNAME, __MAX_BPF_ATTACH_TYPE }; #define MAX_BPF_ATTACH_TYPE __MAX_BPF_ATTACH_TYPE +enum bpf_link_type { + BPF_LINK_TYPE_UNSPEC = 0, + BPF_LINK_TYPE_RAW_TRACEPOINT = 1, + BPF_LINK_TYPE_TRACING = 2, + BPF_LINK_TYPE_CGROUP = 3, + BPF_LINK_TYPE_ITER = 4, + + MAX_BPF_LINK_TYPE, +}; + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command * * NONE(default): No further bpf programs allowed in the subtree. @@ -380,6 +399,12 @@ enum { */ #define BPF_F_QUERY_EFFECTIVE (1U << 0) +/* type for BPF_ENABLE_STATS */ +enum bpf_stats_type { + /* enabled run_time_ns and run_cnt */ + BPF_STATS_RUN_TIME = 0, +}; + enum bpf_stack_build_id_status { /* user space need an empty entry to identify end of a trace */ BPF_STACK_BUILD_ID_EMPTY = 0, @@ -524,6 +549,7 @@ union bpf_attr { __u32 prog_id; __u32 map_id; __u32 btf_id; + __u32 link_id; }; __u32 next_id; __u32 open_flags; @@ -590,6 +616,15 @@ union bpf_attr { __u32 old_prog_fd; } link_update; + struct { /* struct used by BPF_ENABLE_STATS command */ + __u32 type; + } enable_stats; + + struct { /* struct used by BPF_ITER_CREATE command */ + __u32 link_fd; + __u32 flags; + } iter_create; + } __attribute__((aligned(8))); /* The description below is an attempt at providing documentation to eBPF @@ -645,14 +680,16 @@ union bpf_attr { * For tracing programs, safely attempt to read *size* bytes from * kernel space address *unsafe_ptr* and store the data in *dst*. * - * Generally, use bpf_probe_read_user() or bpf_probe_read_kernel() - * instead. + * Generally, use **bpf_probe_read_user**\ () or + * **bpf_probe_read_kernel**\ () instead. * Return * 0 on success, or a negative error in case of failure. * * u64 bpf_ktime_get_ns(void) * Description * Return the time elapsed since system boot, in nanoseconds. + * Does not include time the system was suspended. + * See: **clock_gettime**\ (**CLOCK_MONOTONIC**) * Return * Current *ktime*. * @@ -1511,11 +1548,11 @@ union bpf_attr { * int bpf_probe_read_str(void *dst, u32 size, const void *unsafe_ptr) * Description * Copy a NUL terminated string from an unsafe kernel address - * *unsafe_ptr* to *dst*. See bpf_probe_read_kernel_str() for + * *unsafe_ptr* to *dst*. See **bpf_probe_read_kernel_str**\ () for * more details. * - * Generally, use bpf_probe_read_user_str() or bpf_probe_read_kernel_str() - * instead. + * Generally, use **bpf_probe_read_user_str**\ () or + * **bpf_probe_read_kernel_str**\ () instead. * Return * On success, the strictly positive length of the string, * including the trailing NUL character. On error, a negative @@ -1543,7 +1580,7 @@ union bpf_attr { * * u64 bpf_get_socket_cookie(struct bpf_sock_ops *ctx) * Description - * Equivalent to bpf_get_socket_cookie() helper that accepts + * Equivalent to **bpf_get_socket_cookie**\ () helper that accepts * *skb*, but gets socket from **struct bpf_sock_ops** context. * Return * A 8-byte long non-decreasing number. @@ -1563,7 +1600,7 @@ union bpf_attr { * Return * 0 * - * int bpf_setsockopt(struct bpf_sock_ops *bpf_socket, int level, int optname, void *optval, int optlen) + * int bpf_setsockopt(void *bpf_socket, int level, int optname, void *optval, int optlen) * Description * Emulate a call to **setsockopt()** on the socket associated to * *bpf_socket*, which must be a full socket. The *level* at @@ -1571,6 +1608,12 @@ union bpf_attr { * must be specified, see **setsockopt(2)** for more information. * The option value of length *optlen* is pointed by *optval*. * + * *bpf_socket* should be one of the following: + * + * * **struct bpf_sock_ops** for **BPF_PROG_TYPE_SOCK_OPS**. + * * **struct bpf_sock_addr** for **BPF_CGROUP_INET4_CONNECT** + * and **BPF_CGROUP_INET6_CONNECT**. + * * This helper actually implements a subset of **setsockopt()**. * It supports the following *level*\ s: * @@ -1635,15 +1678,15 @@ union bpf_attr { * * The lower two bits of *flags* are used as the return code if * the map lookup fails. This is so that the return value can be - * one of the XDP program return codes up to XDP_TX, as chosen by - * the caller. Any higher bits in the *flags* argument must be + * one of the XDP program return codes up to **XDP_TX**, as chosen + * by the caller. Any higher bits in the *flags* argument must be * unset. * - * See also bpf_redirect(), which only supports redirecting to an - * ifindex, but doesn't require a map to do so. + * See also **bpf_redirect**\ (), which only supports redirecting + * to an ifindex, but doesn't require a map to do so. * Return * **XDP_REDIRECT** on success, or the value of the two lower bits - * of the **flags* argument on error. + * of the *flags* argument on error. * * int bpf_sk_redirect_map(struct sk_buff *skb, struct bpf_map *map, u32 key, u64 flags) * Description @@ -1748,7 +1791,7 @@ union bpf_attr { * the time running for event since last normalization. The * enabled and running times are accumulated since the perf event * open. To achieve scaling factor between two invocations of an - * eBPF program, users can can use CPU id as the key (which is + * eBPF program, users can use CPU id as the key (which is * typical for perf array usage model) to remember the previous * value and do the calculation inside the eBPF program. * Return @@ -1765,7 +1808,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_getsockopt(struct bpf_sock_ops *bpf_socket, int level, int optname, void *optval, int optlen) + * int bpf_getsockopt(void *bpf_socket, int level, int optname, void *optval, int optlen) * Description * Emulate a call to **getsockopt()** on the socket associated to * *bpf_socket*, which must be a full socket. The *level* at @@ -1774,6 +1817,12 @@ union bpf_attr { * The retrieved value is stored in the structure pointed by * *opval* and of length *optlen*. * + * *bpf_socket* should be one of the following: + * + * * **struct bpf_sock_ops** for **BPF_PROG_TYPE_SOCK_OPS**. + * * **struct bpf_sock_addr** for **BPF_CGROUP_INET4_CONNECT** + * and **BPF_CGROUP_INET6_CONNECT**. + * * This helper actually implements a subset of **getsockopt()**. * It supports the following *level*\ s: * @@ -1791,7 +1840,7 @@ union bpf_attr { * The first argument is the context *regs* on which the kprobe * works. * - * This helper works by setting setting the PC (program counter) + * This helper works by setting the PC (program counter) * to an override function which is run in place of the original * probed function. This means the probed function is not run at * all. The replacement function just returns with the required @@ -1960,18 +2009,19 @@ union bpf_attr { * * This helper works for IPv4 and IPv6, TCP and UDP sockets. The * domain (*addr*\ **->sa_family**) must be **AF_INET** (or - * **AF_INET6**). Looking for a free port to bind to can be - * expensive, therefore binding to port is not permitted by the - * helper: *addr*\ **->sin_port** (or **sin6_port**, respectively) - * must be set to zero. + * **AF_INET6**). It's advised to pass zero port (**sin_port** + * or **sin6_port**) which triggers IP_BIND_ADDRESS_NO_PORT-like + * behavior and lets the kernel efficiently pick up an unused + * port as long as 4-tuple is unique. Passing non-zero port might + * lead to degraded performance. * Return * 0 on success, or a negative error in case of failure. * * int bpf_xdp_adjust_tail(struct xdp_buff *xdp_md, int delta) * Description * Adjust (move) *xdp_md*\ **->data_end** by *delta* bytes. It is - * only possible to shrink the packet as of this writing, - * therefore *delta* must be a negative integer. + * possible to both shrink and grow the packet tail. + * Shrink done via *delta* being a negative integer. * * A call to this helper is susceptible to change the underlying * packet buffer. Therefore, at load time, all checks on pointers @@ -2257,7 +2307,7 @@ union bpf_attr { * **bpf_rc_keydown**\ () again with the same values, or calling * **bpf_rc_repeat**\ (). * - * Some protocols include a toggle bit, in case the button was + * Some protocols include a toggle bit, in case the button was * released and pressed again between consecutive scancodes. * * The *ctx* should point to the lirc sample as passed into @@ -2603,7 +2653,6 @@ union bpf_attr { * * *th* points to the start of the TCP header, while *th_len* * contains **sizeof**\ (**struct tcphdr**). - * * Return * 0 if *iph* and *th* are a valid SYN cookie ACK, or a negative * error otherwise. @@ -2786,7 +2835,6 @@ union bpf_attr { * * *th* points to the start of the TCP header, while *th_len* * contains the length of the TCP header. - * * Return * On success, lower 32 bits hold the generated SYN cookie in * followed by 16 bits which hold the MSS value for that cookie, @@ -2869,7 +2917,7 @@ union bpf_attr { * // size, after checking its boundaries. * } * - * In comparison, using **bpf_probe_read_user()** helper here + * In comparison, using **bpf_probe_read_user**\ () helper here * instead to read the string would require to estimate the length * at compile time, and would often result in copying more memory * than necessary. @@ -2887,14 +2935,14 @@ union bpf_attr { * int bpf_probe_read_kernel_str(void *dst, u32 size, const void *unsafe_ptr) * Description * Copy a NUL terminated string from an unsafe kernel address *unsafe_ptr* - * to *dst*. Same semantics as with bpf_probe_read_user_str() apply. + * to *dst*. Same semantics as with **bpf_probe_read_user_str**\ () apply. * Return - * On success, the strictly positive length of the string, including + * On success, the strictly positive length of the string, including * the trailing NUL character. On error, a negative value. * * int bpf_tcp_send_ack(void *tp, u32 rcv_nxt) * Description - * Send out a tcp-ack. *tp* is the in-kernel struct tcp_sock. + * Send out a tcp-ack. *tp* is the in-kernel struct **tcp_sock**. * *rcv_nxt* is the ack_seq to be sent out. * Return * 0 on success, or a negative error in case of failure. @@ -2922,19 +2970,19 @@ union bpf_attr { * int bpf_read_branch_records(struct bpf_perf_event_data *ctx, void *buf, u32 size, u64 flags) * Description * For an eBPF program attached to a perf event, retrieve the - * branch records (struct perf_branch_entry) associated to *ctx* - * and store it in the buffer pointed by *buf* up to size + * branch records (**struct perf_branch_entry**) associated to *ctx* + * and store it in the buffer pointed by *buf* up to size * *size* bytes. * Return * On success, number of bytes written to *buf*. On error, a * negative value. * * The *flags* can be set to **BPF_F_GET_BRANCH_RECORDS_SIZE** to - * instead return the number of bytes required to store all the + * instead return the number of bytes required to store all the * branch entries. If this flag is set, *buf* may be NULL. * * **-EINVAL** if arguments invalid or **size** not a multiple - * of sizeof(struct perf_branch_entry). + * of **sizeof**\ (**struct perf_branch_entry**\ ). * * **-ENOENT** if architecture does not support branch records. * @@ -2942,8 +2990,8 @@ union bpf_attr { * Description * Returns 0 on success, values for *pid* and *tgid* as seen from the current * *namespace* will be returned in *nsdata*. - * - * On failure, the returned value is one of the following: + * Return + * 0 on success, or one of the following in case of failure: * * **-EINVAL** if dev and inum supplied don't match dev_t and inode number * with nsfs of current task, or if dev conversion to dev_t lost high bits. @@ -2982,8 +3030,8 @@ union bpf_attr { * a global identifier that can be assumed unique. If *ctx* is * NULL, then the helper returns the cookie for the initial * network namespace. The cookie itself is very similar to that - * of bpf_get_socket_cookie() helper, but for network namespaces - * instead of sockets. + * of **bpf_get_socket_cookie**\ () helper, but for network + * namespaces instead of sockets. * Return * A 8-byte long opaque number. * @@ -3018,14 +3066,98 @@ union bpf_attr { * * The *flags* argument must be zero. * Return - * 0 on success, or a negative errno in case of failure. - * - * * **-EINVAL** Unsupported flags specified. - * * **-ENOENT** Socket is unavailable for assignment. - * * **-ENETUNREACH** Socket is unreachable (wrong netns). - * * **-EOPNOTSUPP** Unsupported operation, for example a - * call from outside of TC ingress. - * * **-ESOCKTNOSUPPORT** Socket type not supported (reuseport). + * 0 on success, or a negative error in case of failure: + * + * **-EINVAL** if specified *flags* are not supported. + * + * **-ENOENT** if the socket is unavailable for assignment. + * + * **-ENETUNREACH** if the socket is unreachable (wrong netns). + * + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * + * **-ESOCKTNOSUPPORT** if the socket type is not supported + * (reuseport). + * + * u64 bpf_ktime_get_boot_ns(void) + * Description + * Return the time elapsed since system boot, in nanoseconds. + * Does include the time the system was suspended. + * See: **clock_gettime**\ (**CLOCK_BOOTTIME**) + * Return + * Current *ktime*. + * + * int bpf_seq_printf(struct seq_file *m, const char *fmt, u32 fmt_size, const void *data, u32 data_len) + * Description + * **bpf_seq_printf**\ () uses seq_file **seq_printf**\ () to print + * out the format string. + * The *m* represents the seq_file. The *fmt* and *fmt_size* are for + * the format string itself. The *data* and *data_len* are format string + * arguments. The *data* are a **u64** array and corresponding format string + * values are stored in the array. For strings and pointers where pointees + * are accessed, only the pointer values are stored in the *data* array. + * The *data_len* is the size of *data* in bytes. + * + * Formats **%s**, **%p{i,I}{4,6}** requires to read kernel memory. + * Reading kernel memory may fail due to either invalid address or + * valid address but requiring a major memory fault. If reading kernel memory + * fails, the string for **%s** will be an empty string, and the ip + * address for **%p{i,I}{4,6}** will be 0. Not returning error to + * bpf program is consistent with what **bpf_trace_printk**\ () does for now. + * Return + * 0 on success, or a negative error in case of failure: + * + * **-EBUSY** if per-CPU memory copy buffer is busy, can try again + * by returning 1 from bpf program. + * + * **-EINVAL** if arguments are invalid, or if *fmt* is invalid/unsupported. + * + * **-E2BIG** if *fmt* contains too many format specifiers. + * + * **-EOVERFLOW** if an overflow happened: The same object will be tried again. + * + * int bpf_seq_write(struct seq_file *m, const void *data, u32 len) + * Description + * **bpf_seq_write**\ () uses seq_file **seq_write**\ () to write the data. + * The *m* represents the seq_file. The *data* and *len* represent the + * data to write in bytes. + * Return + * 0 on success, or a negative error in case of failure: + * + * **-EOVERFLOW** if an overflow happened: The same object will be tried again. + * + * u64 bpf_sk_cgroup_id(struct bpf_sock *sk) + * Description + * Return the cgroup v2 id of the socket *sk*. + * + * *sk* must be a non-**NULL** pointer to a full socket, e.g. one + * returned from **bpf_sk_lookup_xxx**\ (), + * **bpf_sk_fullsock**\ (), etc. The format of returned id is + * same as in **bpf_skb_cgroup_id**\ (). + * + * This helper is available only if the kernel was compiled with + * the **CONFIG_SOCK_CGROUP_DATA** configuration option. + * Return + * The id is returned or 0 in case the id could not be retrieved. + * + * u64 bpf_sk_ancestor_cgroup_id(struct bpf_sock *sk, int ancestor_level) + * Description + * Return id of cgroup v2 that is ancestor of cgroup associated + * with the *sk* at the *ancestor_level*. The root cgroup is at + * *ancestor_level* zero and each step down the hierarchy + * increments the level. If *ancestor_level* == level of cgroup + * associated with *sk*, then return value will be same as that + * of **bpf_sk_cgroup_id**\ (). + * + * The helper is useful to implement policies based on cgroups + * that are upper in hierarchy than immediate cgroup associated + * with *sk*. + * + * The format of returned id and helper limitations are same as in + * **bpf_sk_cgroup_id**\ (). + * Return + * The id is returned or 0 in case the id could not be retrieved. */ #define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ @@ -3152,7 +3284,12 @@ union bpf_attr { FN(xdp_output), \ FN(get_netns_cookie), \ FN(get_current_ancestor_cgroup_id), \ - FN(sk_assign), + FN(sk_assign), \ + FN(ktime_get_boot_ns), \ + FN(seq_printf), \ + FN(seq_write), \ + FN(sk_cgroup_id), \ + FN(sk_ancestor_cgroup_id), /* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call @@ -3599,6 +3736,25 @@ struct bpf_btf_info { __u32 id; } __attribute__((aligned(8))); +struct bpf_link_info { + __u32 type; + __u32 id; + __u32 prog_id; + union { + struct { + __aligned_u64 tp_name; /* in/out: tp_name buffer ptr */ + __u32 tp_name_len; /* in/out: tp_name buffer len */ + } raw_tracepoint; + struct { + __u32 attach_type; + } tracing; + struct { + __u64 cgroup_id; + __u32 attach_type; + } cgroup; + }; +} __attribute__((aligned(8))); + /* User bpf_sock_addr struct to access socket fields and sockaddr struct passed * by user and intended to be used by socket (e.g. to bind to, depends on * attach attach type). @@ -3611,7 +3767,7 @@ struct bpf_sock_addr { __u32 user_ip6[4]; /* Allows 1,2,4,8-byte read and 4,8-byte write. * Stored in network byte order. */ - __u32 user_port; /* Allows 4-byte read and write. + __u32 user_port; /* Allows 1,2,4-byte read and 4-byte write. * Stored in network byte order */ __u32 family; /* Allows 4-byte read, but no write */ diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index b0ffc4f27..79a3879ae 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -642,6 +642,19 @@ struct sk_buff; static int (*bpf_sk_assign)(struct sk_buff *skb, struct bpf_sock *sk, __u64 flags) = (void *)BPF_FUNC_sk_assign; +static __u64 (*bpf_ktime_get_boot_ns)(void) = (void *)BPF_FUNC_ktime_get_boot_ns; + +struct seq_file; +static int (*bpf_seq_printf)(struct seq_file *m, const char *fmt, __u32 fmt_size, + const void *data, __u32 data_len) = + (void *)BPF_FUNC_seq_printf; +static int (*bpf_seq_write)(struct seq_file *m, const void *data, __u32 len) = + (void *)BPF_FUNC_seq_write; + +static __u64 (*bpf_sk_cgroup_id)(struct bpf_sock *sk) = (void *)BPF_FUNC_sk_cgroup_id; +static __u64 (*bpf_sk_ancestor_cgroup_id)(struct bpf_sock *sk, int ancestor_level) = + (void *)BPF_FUNC_sk_ancestor_cgroup_id; + /* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions */ diff --git a/src/cc/libbpf b/src/cc/libbpf index 6a1615c26..3b2394254 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit 6a1615c263b679c17ecb292fa897f159e826dc10 +Subproject commit 3b239425426e4fa1c204ea3c708d36ec3f509702 diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index 008968c7c..fcb22014a 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -221,6 +221,11 @@ static struct bpf_helper helpers[] = { {"get_netns_cookie", "5.6"}, {"get_current_ancestor_cgroup_id", "5.6"}, {"sk_assign", "5.6"}, + {"ktime_get_boot_ns", "5.7"}, + {"seq_printf", "5.7"}, + {"seq_write", "5.7"}, + {"sk_cgroup_id", "5.7"}, + {"sk_ancestor_cgroup_id", "5.7"}, }; static uint64_t ptr_to_u64(void *ptr) From 44e0f43eeac53648adb4734862f9b36d80853420 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mauricio=20V=C3=A1squez?= Date: Thu, 21 May 2020 11:50:52 -0500 Subject: [PATCH 114/278] Fix KFUNC_PROBE return value MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The KFUNC_PROBE macro is using "void" as return type, this is causing problems in some tools that have a filtering enable that returns 0. Reproducer: (Notice that it requires BTF support) ``` $ python opensnoop.py --pid 5 /virtual/main.c:33:21: error: void function '____kretfunc__do_sys_open' should not return a value [-Wreturn-type] if (pid != 5) { return 0; } ^ ~ 1 error generated. ... ``` Signed-off-by: Mauricio Vásquez --- src/cc/export/helpers.h | 4 ++-- tools/klockstat.py | 6 +++--- tools/opensnoop.py | 2 ++ 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index 79a3879ae..2b73d1c7f 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -1012,7 +1012,7 @@ int raw_tracepoint__##event(struct bpf_raw_tracepoint_args *ctx) #define BPF_PROG(name, args...) \ int name(unsigned long long *ctx); \ __attribute__((always_inline)) \ -static void ____##name(unsigned long long *ctx, ##args); \ +static int ____##name(unsigned long long *ctx, ##args); \ int name(unsigned long long *ctx) \ { \ _Pragma("GCC diagnostic push") \ @@ -1021,7 +1021,7 @@ int name(unsigned long long *ctx) \ _Pragma("GCC diagnostic pop") \ return 0; \ } \ -static void ____##name(unsigned long long *ctx, ##args) +static int ____##name(unsigned long long *ctx, ##args) #define KFUNC_PROBE(event, args...) \ BPF_PROG(kfunc__ ## event, args) diff --git a/tools/klockstat.py b/tools/klockstat.py index 540dd4e7d..7cb15ad3b 100755 --- a/tools/klockstat.py +++ b/tools/klockstat.py @@ -352,17 +352,17 @@ def stack_id_err(stack_id): program_kfunc = """ KFUNC_PROBE(mutex_unlock, void *lock) { - do_mutex_unlock_enter(); + return do_mutex_unlock_enter(); } KRETFUNC_PROBE(mutex_lock, void *lock, int ret) { - do_mutex_lock_return(); + return do_mutex_lock_return(); } KFUNC_PROBE(mutex_lock, void *lock) { - do_mutex_lock_enter(ctx, 3); + return do_mutex_lock_enter(ctx, 3); } """ diff --git a/tools/opensnoop.py b/tools/opensnoop.py index 995443e3f..28fe7559b 100755 --- a/tools/opensnoop.py +++ b/tools/opensnoop.py @@ -197,6 +197,8 @@ data.ret = ret; events.perf_submit(ctx, &data, sizeof(data)); + + return 0: } """ From 7722fc55f6c8a5ec1c16ba76f10db3b709af5d36 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mauricio=20V=C3=A1squez?= Date: Thu, 21 May 2020 10:22:30 -0500 Subject: [PATCH 115/278] libbcc-py: Fix libbpf types MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 1ad2656a1d9c ("Add support_kfunc function to BPF object") added new functions to libbcc-py but didn't set the restype and argstypes for those. It's causing the `bpf_has_kernel_btf` function to return True in systems without support for BTF, making tools like opensnoop, klockstat and any other using kfuncs unusable in those systems. The following Python script reproduces the problem: ``` from bcc import BPF print(BPF.support_kfunc()) ``` Signed-off-by: Mauricio Vásquez --- src/python/bcc/libbcc.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/python/bcc/libbcc.py b/src/python/bcc/libbcc.py index d2c4d2e3e..f35b15c41 100644 --- a/src/python/bcc/libbcc.py +++ b/src/python/bcc/libbcc.py @@ -108,6 +108,10 @@ lib.bpf_detach_tracepoint.argtypes = [ct.c_char_p, ct.c_char_p] lib.bpf_attach_raw_tracepoint.restype = ct.c_int lib.bpf_attach_raw_tracepoint.argtypes = [ct.c_int, ct.c_char_p] +lib.bpf_attach_kfunc.restype = ct.c_int +lib.bpf_attach_kfunc.argtypes = [ct.c_int] +lib.bpf_has_kernel_btf.restype = ct.c_bool +lib.bpf_has_kernel_btf.argtypes = None lib.bpf_open_perf_buffer.restype = ct.c_void_p lib.bpf_open_perf_buffer.argtypes = [_RAW_CB_TYPE, _LOST_CB_TYPE, ct.py_object, ct.c_int, ct.c_int, ct.c_int] lib.bpf_open_perf_event.restype = ct.c_int From 104a5b8052a2c7743109b8d19351b66d218359d5 Mon Sep 17 00:00:00 2001 From: Kavinda Wewegama Date: Thu, 21 May 2020 12:33:26 -0500 Subject: [PATCH 116/278] bcc/tools: fix typo in help message --- tools/tcplife.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/tcplife.py b/tools/tcplife.py index d4e679dd7..980eebba0 100755 --- a/tools/tcplife.py +++ b/tools/tcplife.py @@ -32,7 +32,7 @@ # arguments examples = """examples: ./tcplife # trace all TCP connect()s - ./tcplife -t # include time column (HH:MM:SS) + ./tcplife -T # include time column (HH:MM:SS) ./tcplife -w # wider columns (fit IPv6) ./tcplife -stT # csv output, with times & timestamps ./tcplife -p 181 # only trace PID 181 From 32ab858309c84c23049715aaab936ce654ad5792 Mon Sep 17 00:00:00 2001 From: Alban Crequy Date: Sun, 22 Mar 2020 16:06:44 +0100 Subject: [PATCH 117/278] tools: add filtering by mount namespace MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit In previous patches, I added the option --cgroupmap to filter events belonging to a set of cgroup-v2. Although this approach works fine with systemd services and containers when cgroup-v2 is enabled, it does not work with containers when only cgroup-v1 is enabled because bpf_get_current_cgroup_id() only works with cgroup-v2. It also requires Linux 4.18 to get this bpf helper function. This patch adds an additional way to filter by containers, using mount namespaces. Note that this does not help with systemd services since they normally don't create a new mount namespace (unless you set some options like 'ReadOnlyPaths=', see "man 5 systemd.exec"). My goal with this patch is to filter Kubernetes pods, even on distributions with an older kernel (<4.18) or without cgroup-v2 enabled. - This is only implemented for tools that already support filtering by cgroup id (bindsnoop, capable, execsnoop, profile, tcpaccept, tcpconnect, tcptop and tcptracer). - I picked the mount namespace because the other namespaces could be disabled in Kubernetes (e.g. HostNetwork, HostPID, HostIPC). It can be tested by following the example in docs/special_filtering added in this commit, to avoid compiling locally the following command can be used ``` sudo bpftool map create /sys/fs/bpf/mnt_ns_set type hash key 8 value 4 \ entries 128 name mnt_ns_set flags 0 docker run -ti --rm --privileged \ -v /usr/src:/usr/src -v /lib/modules:/lib/modules \ -v /sys/fs/bpf:/sys/fs/bpf --pid=host kinvolk/bcc:alban-containers-filters \ /usr/share/bcc/tools/execsnoop --mntnsmap /sys/fs/bpf/mnt_ns_set ``` Co-authored-by: Alban Crequy Co-authored-by: Mauricio Vásquez --- ...ing_by_cgroups.md => special_filtering.md} | 59 +++++++++++++- man/man8/bindsnoop.8 | 7 +- man/man8/capable.8 | 7 +- man/man8/execsnoop.8 | 14 ++-- man/man8/opensnoop.8 | 7 +- man/man8/profile.8 | 4 +- man/man8/tcpaccept.8 | 7 +- man/man8/tcpconnect.8 | 8 +- man/man8/tcptop.8 | 7 +- man/man8/tcptracer.8 | 7 +- src/python/bcc/containers.py | 80 +++++++++++++++++++ tools/bindsnoop.py | 30 +++---- tools/bindsnoop_example.txt | 5 +- tools/capable.py | 24 +++--- tools/capable_example.txt | 10 ++- tools/execsnoop.py | 29 +++---- tools/execsnoop_example.txt | 6 +- tools/opensnoop.py | 31 +++---- tools/opensnoop_example.txt | 12 ++- tools/profile.py | 23 ++---- tools/profile_example.txt | 8 +- tools/tcpaccept.py | 32 +++----- tools/tcpaccept_example.txt | 5 +- tools/tcpconnect.py | 23 ++---- tools/tcpconnect_example.txt | 7 +- tools/tcptop.py | 42 +++++----- tools/tcptop_example.txt | 4 +- tools/tcptracer.py | 41 +++------- tools/tcptracer_example.txt | 2 +- 29 files changed, 322 insertions(+), 219 deletions(-) rename docs/{filtering_by_cgroups.md => special_filtering.md} (58%) create mode 100644 src/python/bcc/containers.py diff --git a/docs/filtering_by_cgroups.md b/docs/special_filtering.md similarity index 58% rename from docs/filtering_by_cgroups.md rename to docs/special_filtering.md index f2f08926d..9b15260ca 100644 --- a/docs/filtering_by_cgroups.md +++ b/docs/special_filtering.md @@ -1,4 +1,10 @@ -# Demonstrations of filtering by cgroups +# Special Filtering + +Some tools have special filtering capabitilies, the main use case is to trace +processes running in containers, but those mechanisms are generic and could +be used in other cases as well. + +## Filtering by cgroups Some tools have an option to filter by cgroup by referencing a pinned BPF hash map managed externally. @@ -66,3 +72,54 @@ map, bcc tools will display results from this shell. Cgroups can be added and removed from the BPF hash map without restarting the bcc tool. This feature is useful for integrating bcc tools in external projects. + +## Filtering by mount by namespace + +The BPF hash map can be created by: + +``` +# bpftool map create /sys/fs/bpf/mnt_ns_set type hash key 8 value 4 entries 128 \ + name mnt_ns_set flags 0 +``` + +Execute the `execsnoop` tool filtering only the mount namespaces +in `/sys/fs/bpf/mnt_ns_set`: + +``` +# tools/execsnoop.py --mntnsmap /sys/fs/bpf/mnt_ns_set +``` + +Start a terminal in a new mount namespace: + +``` +# unshare -m bash +``` + +Update the hash map with the mount namespace ID of the terminal above: + +``` +FILE=/sys/fs/bpf/mnt_ns_set +if [ $(printf '\1' | od -dAn) -eq 1 ]; then + HOST_ENDIAN_CMD=tac +else + HOST_ENDIAN_CMD=cat +fi + +NS_ID_HEX="$(printf '%016x' $(stat -Lc '%i' /proc/self/ns/mnt) | sed 's/.\{2\}/&\n/g' | $HOST_ENDIAN_CMD)" +bpftool map update pinned $FILE key hex $NS_ID_HEX value hex 00 00 00 00 any +``` + +Execute a command in this terminal: + +``` +# ping kinvolk.io +``` + +You'll see how on the `execsnoop` terminal you started above the call is logged: + +``` +# tools/execsnoop.py --mntnsmap /sys/fs/bpf/mnt_ns_set +[sudo] password for mvb: +PCOMM PID PPID RET ARGS +ping 8096 7970 0 /bin/ping kinvolk.io +``` diff --git a/man/man8/bindsnoop.8 b/man/man8/bindsnoop.8 index ec7ca1dae..f8fa18502 100644 --- a/man/man8/bindsnoop.8 +++ b/man/man8/bindsnoop.8 @@ -2,7 +2,7 @@ .SH NAME bindsnoop \- Trace bind() system calls. .SH SYNOPSIS -.B bindsnoop.py [\fB-h\fP] [\fB-w\fP] [\fB-t\fP] [\fB-p\fP PID] [\fB-P\fP PORT] [\fB-E\fP] [\fB-U\fP] [\fB-u\fP UID] [\fB--count\fP] [\fB--cgroupmap MAP\fP] +.B bindsnoop.py [\fB-h\fP] [\fB-w\fP] [\fB-t\fP] [\fB-p\fP PID] [\fB-P\fP PORT] [\fB-E\fP] [\fB-U\fP] [\fB-u\fP UID] [\fB--count\fP] [\fB--cgroupmap MAP\fP] [\fB--mntnsmap MNTNSMAP\fP] .SH DESCRIPTION bindsnoop reports socket options set before the bind call that would impact this system call behavior. .PP @@ -42,6 +42,11 @@ Trace cgroups in this BPF map: .B \fB--cgroupmap\fP MAP .TP +Trace mount namespaces in this BPF map: +.TP +.B +\fB--mntnsmap\fP MNTNSMAP +.TP Include errors in the output: .TP .B diff --git a/man/man8/capable.8 b/man/man8/capable.8 index dfb8a6aad..342946f83 100644 --- a/man/man8/capable.8 +++ b/man/man8/capable.8 @@ -3,7 +3,7 @@ capable \- Trace security capability checks (cap_capable()). .SH SYNOPSIS .B capable [\-h] [\-v] [\-p PID] [\-K] [\-U] [\-x] [\-\-cgroupmap MAPPATH] - [--unique] + [\-\-mntnsmap MAPPATH] [--unique] .SH DESCRIPTION This traces security capability checks in the kernel, and prints details for each call. This can be useful for general debugging, and also security @@ -33,6 +33,9 @@ Show extra fields in TID and INSETID columns. \-\-cgroupmap MAPPATH Trace cgroups in this BPF map only (filtered in-kernel). .TP +\-\-mntnsmap MAPPATH +Trace mount namespaces in this BPF map only (filtered in-kernel). +.TP \-\-unique Don't repeat stacks for the same PID or cgroup. .SH EXAMPLES @@ -45,7 +48,7 @@ Trace capability checks for PID 181: # .B capable \-p 181 .TP -Trace capability checks in a set of cgroups only (see filtering_by_cgroups.md +Trace capability checks in a set of cgroups only (see special_filtering.md from bcc sources for more details): # .B capable \-\-cgroupmap /sys/fs/bpf/test01 diff --git a/man/man8/execsnoop.8 b/man/man8/execsnoop.8 index 4a88e0074..e42ad38ab 100644 --- a/man/man8/execsnoop.8 +++ b/man/man8/execsnoop.8 @@ -2,8 +2,8 @@ .SH NAME execsnoop \- Trace new processes via exec() syscalls. Uses Linux eBPF/bcc. .SH SYNOPSIS -.B execsnoop [\-h] [\-T] [\-t] [\-x] [\-\-cgroupmap CGROUPMAP] [\-u USER] -.B [\-q] [\-n NAME] [\-l LINE] [\-U] [\-\-max-args MAX_ARGS] +.B execsnoop [\-h] [\-T] [\-t] [\-x] [\-\-cgroupmap CGROUPMAP] [\-\-mntnsmap MAPPATH] +.B [\-u USER] [\-q] [\-n NAME] [\-l LINE] [\-U] [\-\-max-args MAX_ARGS] .SH DESCRIPTION execsnoop traces new processes, showing the filename executed and argument list. @@ -42,7 +42,7 @@ Include failed exec()s .TP \-q Add "quotemarks" around arguments. Escape quotemarks in arguments with a -backslash. For tracing empty arguments or arguments that contain whitespace. +backslash. For tracing empty arguments or arguments that contain whitespace. .TP \-n NAME Only print command lines matching this name (regex) @@ -55,6 +55,10 @@ Maximum number of arguments parsed and displayed, defaults to 20 .TP \-\-cgroupmap MAPPATH Trace cgroups in this BPF map only (filtered in-kernel). +.TP +\-\-mntnsmap MAPPATH +Trace mount namespaces in this BPF map only (filtered in-kernel). +.TP .SH EXAMPLES .TP Trace all exec() syscalls: @@ -81,7 +85,7 @@ Include failed exec()s: # .B execsnoop \-x .TP -Put quotemarks around arguments. +Put quotemarks around arguments. # .B execsnoop \-q .TP @@ -93,7 +97,7 @@ Only trace exec()s where argument's line contains "testpkg": # .B execsnoop \-l testpkg .TP -Trace a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +Trace a set of cgroups only (see special_filtering.md from bcc sources for more details): # .B execsnoop \-\-cgroupmap /sys/fs/bpf/test01 .SH FIELDS diff --git a/man/man8/opensnoop.8 b/man/man8/opensnoop.8 index 54a7788a2..fee832634 100644 --- a/man/man8/opensnoop.8 +++ b/man/man8/opensnoop.8 @@ -4,7 +4,7 @@ opensnoop \- Trace open() syscalls. Uses Linux eBPF/bcc. .SH SYNOPSIS .B opensnoop.py [\-h] [\-T] [\-U] [\-x] [\-p PID] [\-t TID] [\-u UID] [\-d DURATION] [\-n NAME] [\-e] [\-f FLAG_FILTER] - [--cgroupmap MAPPATH] + [--cgroupmap MAPPATH] [--mntnsmap MAPPATH] .SH DESCRIPTION opensnoop traces the open() syscall, showing which processes are attempting to open which files. This can be useful for determining the location of config @@ -58,6 +58,9 @@ Filter on open() flags, e.g., O_WRONLY. .TP \--cgroupmap MAPPATH Trace cgroups in this BPF map only (filtered in-kernel). +.TP +\--mntnsmap MAPPATH +Trace mount namespaces in this BPF map only (filtered in-kernel). .SH EXAMPLES .TP Trace all open() syscalls: @@ -100,7 +103,7 @@ Only print calls for writing: # .B opensnoop \-f O_WRONLY \-f O_RDWR .TP -Trace a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +Trace a set of cgroups only (see special_filtering.md from bcc sources for more details): # .B opensnoop \-\-cgroupmap /sys/fs/bpf/test01 .SH FIELDS diff --git a/man/man8/profile.8 b/man/man8/profile.8 index 823ff6996..30871afeb 100644 --- a/man/man8/profile.8 +++ b/man/man8/profile.8 @@ -3,7 +3,7 @@ profile \- Profile CPU usage by sampling stack traces. Uses Linux eBPF/bcc. .SH SYNOPSIS .B profile [\-adfh] [\-p PID | \-L TID] [\-U | \-K] [\-F FREQUENCY | \-c COUNT] -.B [\-\-stack\-storage\-size COUNT] [\-\-cgroupmap CGROUPMAP] [duration] +.B [\-\-stack\-storage\-size COUNT] [\-\-cgroupmap CGROUPMAP] [\-\-mntnsmap MAPPATH] [duration] .SH DESCRIPTION This is a CPU profiler. It works by taking samples of stack traces at timed intervals. It will help you understand and quantify CPU usage: which code is @@ -101,7 +101,7 @@ Profile kernel stacks only: # .B profile -K .TP -Profile a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +Profile a set of cgroups only (see special_filtering.md from bcc sources for more details): # .B profile \-\-cgroupmap /sys/fs/bpf/test01 .SH DEBUGGING diff --git a/man/man8/tcpaccept.8 b/man/man8/tcpaccept.8 index 432192605..603a5ca43 100644 --- a/man/man8/tcpaccept.8 +++ b/man/man8/tcpaccept.8 @@ -2,7 +2,7 @@ .SH NAME tcpaccept \- Trace TCP passive connections (accept()). Uses Linux eBPF/bcc. .SH SYNOPSIS -.B tcpaccept [\-h] [\-T] [\-t] [\-p PID] [\-P PORTS] [\-\-cgroupmap MAPPATH] +.B tcpaccept [\-h] [\-T] [\-t] [\-p PID] [\-P PORTS] [\-\-cgroupmap MAPPATH] [\-\-mntnsmap MAPPATH] .SH DESCRIPTION This tool traces passive TCP connections (eg, via an accept() syscall; connect() are active connections). This can be useful for general @@ -36,6 +36,9 @@ Comma-separated list of local ports to trace (filtered in-kernel). .TP \-\-cgroupmap MAPPATH Trace cgroups in this BPF map only (filtered in-kernel). +.TP +\-\-mntnsmap MAPPATH +Trace mount namespaces in this BPF map only (filtered in-kernel). .SH EXAMPLES .TP Trace all passive TCP connections (accept()s): @@ -54,7 +57,7 @@ Trace PID 181 only: # .B tcpaccept \-p 181 .TP -Trace a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +Trace a set of cgroups only (see special_filtering.md from bcc sources for more details): # .B tcpaccept \-\-cgroupmap /sys/fs/bpf/test01 .SH FIELDS diff --git a/man/man8/tcpconnect.8 b/man/man8/tcpconnect.8 index 60aac1e21..bc2589ed6 100644 --- a/man/man8/tcpconnect.8 +++ b/man/man8/tcpconnect.8 @@ -2,7 +2,7 @@ .SH NAME tcpconnect \- Trace TCP active connections (connect()). Uses Linux eBPF/bcc. .SH SYNOPSIS -.B tcpconnect [\-h] [\-c] [\-t] [\-x] [\-p PID] [-P PORT] [\-\-cgroupmap MAPPATH] +.B tcpconnect [\-h] [\-c] [\-t] [\-x] [\-p PID] [-P PORT] [\-\-cgroupmap MAPPATH] [\-\-mntnsmap MAPPATH] .SH DESCRIPTION This tool traces active TCP connections (eg, via a connect() syscall; accept() are passive connections). This can be useful for general @@ -72,9 +72,13 @@ Count connects per src ip and dest ip/port: # .B tcpconnect \-c .TP -Trace a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +Trace a set of cgroups only (see special_filtering.md from bcc sources for more details): # .B tcpconnect \-\-cgroupmap /sys/fs/bpf/test01 +.TP +Trace a set of mount namespaces only (see special_filtering.md from bcc sources for more details): +# +.B tcpconnect \-\-mntnsmap /sys/fs/bpf/mnt_ns_set .SH FIELDS .TP TIME(s) diff --git a/man/man8/tcptop.8 b/man/man8/tcptop.8 index 631c00c32..e636f4569 100644 --- a/man/man8/tcptop.8 +++ b/man/man8/tcptop.8 @@ -3,7 +3,7 @@ tcptop \- Summarize TCP send/recv throughput by host. Top for TCP. .SH SYNOPSIS .B tcptop [\-h] [\-C] [\-S] [\-p PID] [\-\-cgroupmap MAPPATH] - [interval] [count] + [--mntnsmap MAPPATH] [interval] [count] .SH DESCRIPTION This is top for TCP sessions. @@ -39,6 +39,9 @@ Trace this PID only. \-\-cgroupmap MAPPATH Trace cgroups in this BPF map only (filtered in-kernel). .TP +\--mntnsmap MAPPATH +Trace mount namespaces in this BPF map only (filtered in-kernel). +.TP interval Interval between updates, seconds (default 1). .TP @@ -58,7 +61,7 @@ Trace PID 181 only, and don't clear the screen: # .B tcptop \-Cp 181 .TP -Trace a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +Trace a set of cgroups only (see special_filtering.md from bcc sources for more details): # .B tcptop \-\-cgroupmap /sys/fs/bpf/test01 .SH FIELDS diff --git a/man/man8/tcptracer.8 b/man/man8/tcptracer.8 index 728c80af5..d2346c776 100644 --- a/man/man8/tcptracer.8 +++ b/man/man8/tcptracer.8 @@ -2,7 +2,7 @@ .SH NAME tcptracer \- Trace TCP established connections. Uses Linux eBPF/bcc. .SH SYNOPSIS -.B tcptracer [\-h] [\-v] [\-p PID] [\-N NETNS] [\-\-cgroupmap MAPPATH] +.B tcptracer [\-h] [\-v] [\-p PID] [\-N NETNS] [\-\-cgroupmap MAPPATH] [--mntnsmap MAPPATH] .SH DESCRIPTION This tool traces established TCP connections that open and close while tracing, and prints a line of output per connect, accept and close events. This includes @@ -31,6 +31,9 @@ Trace this network namespace only (filtered in-kernel). .TP \-\-cgroupmap MAPPATH Trace cgroups in this BPF map only (filtered in-kernel). +.TP +\-\-mntnsmap MAPPATH +Trace mount namespaces in the map (filtered in-kernel). .SH EXAMPLES .TP Trace all TCP established connections: @@ -49,7 +52,7 @@ Trace connections in network namespace 4026531969 only: # .B tcptracer \-N 4026531969 .TP -Trace a set of cgroups only (see filtering_by_cgroups.md from bcc sources for more details): +Trace a set of cgroups only (see special_filtering.md from bcc sources for more details): # .B tcptracer \-\-cgroupmap /sys/fs/bpf/test01 .SH FIELDS diff --git a/src/python/bcc/containers.py b/src/python/bcc/containers.py new file mode 100644 index 000000000..b55e05002 --- /dev/null +++ b/src/python/bcc/containers.py @@ -0,0 +1,80 @@ +# Copyright 2020 Kinvolk GmbH +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +def _cgroup_filter_func_writer(cgroupmap): + if not cgroupmap: + return """ + static inline int _cgroup_filter() { + return 0; + } + """ + + text = """ + BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUP_PATH"); + + static inline int _cgroup_filter() { + u64 cgroupid = bpf_get_current_cgroup_id(); + return cgroupset.lookup(&cgroupid) == NULL; + } + """ + + return text.replace('CGROUP_PATH', cgroupmap) + +def _mntns_filter_func_writer(mntnsmap): + if not mntnsmap: + return """ + static inline int _mntns_filter() { + return 0; + } + """ + text = """ + #include + #include + #include + + /* see mountsnoop.py: + * XXX: struct mnt_namespace is defined in fs/mount.h, which is private + * to the VFS and not installed in any kernel-devel packages. So, let's + * duplicate the important part of the definition. There are actually + * more members in the real struct, but we don't need them, and they're + * more likely to change. + */ + struct mnt_namespace { + atomic_t count; + struct ns_common ns; + }; + + BPF_TABLE_PINNED("hash", u64, u32, mount_ns_set, 1024, "MOUNT_NS_PATH"); + + static inline int _mntns_filter() { + struct task_struct *current_task; + current_task = (struct task_struct *)bpf_get_current_task(); + u64 ns_id = current_task->nsproxy->mnt_ns->ns.inum; + return mount_ns_set.lookup(&ns_id) == NULL; + } + """ + + return text.replace('MOUNT_NS_PATH', mntnsmap) + +def filter_by_containers(args): + filter_by_containers_text = """ + static inline int container_should_be_filtered() { + return _cgroup_filter() || _mntns_filter(); + } + """ + + cgroupmap_text = _cgroup_filter_func_writer(args.cgroupmap) + mntnsmap_text = _mntns_filter_func_writer(args.mntnsmap) + + return cgroupmap_text + mntnsmap_text + filter_by_containers_text diff --git a/tools/bindsnoop.py b/tools/bindsnoop.py index 4d3133fcf..de569c251 100755 --- a/tools/bindsnoop.py +++ b/tools/bindsnoop.py @@ -6,7 +6,7 @@ # based on tcpconnect utility from Brendan Gregg's suite. # # USAGE: bindsnoop [-h] [-t] [-E] [-p PID] [-P PORT[,PORT ...]] [-w] -# [--count] [--cgroupmap mappath] +# [--count] [--cgroupmap mappath] [--mntnsmap mappath] # # bindsnoop reports socket options set before the bind call # that would impact this system call behavior: @@ -28,6 +28,7 @@ from __future__ import print_function, absolute_import, unicode_literals from bcc import BPF, DEBUG_SOURCE +from bcc.containers import filter_by_containers from bcc.utils import printb import argparse import re @@ -51,6 +52,7 @@ ./bindsnoop -E # report bind errors ./bindsnoop --count # count bind per src ip ./bindsnoop --cgroupmap mappath # only trace cgroups in this BPF map + ./bindsnoop --mntnsmap mappath # only trace mount namespaces in the map it is reporting socket options set before the bins call impacting system call behavior: @@ -84,6 +86,8 @@ help="count binds per src ip and port") parser.add_argument("--cgroupmap", help="trace cgroups in this BPF map only") +parser.add_argument("--mntnsmap", + help="trace mount namespaces in this BPF map only") parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) parser.add_argument("--debug-source", action="store_true", @@ -148,8 +152,6 @@ }; BPF_HASH(ipv6_count, struct ipv6_flow_key_t); -CGROUP_MAP - // bind options for event reporting union bind_options { u8 data; @@ -174,7 +176,9 @@ FILTER_UID - FILTER_CGROUP + if (container_should_be_filtered()) { + return 0; + } // stash the sock ptr for lookup on return currsock.update(&tid, &socket); @@ -323,11 +327,6 @@ bpf_get_current_comm(&data6.task, sizeof(data6.task)); ipv6_bind_events.perf_submit(ctx, &data6, sizeof(data6));""" }, - 'filter_cgroup': """ - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { - return 0; - }""", } # code substitutions @@ -351,22 +350,11 @@ 'if (uid != %s) { return 0; }' % args.uid) if args.errors: bpf_text = bpf_text.replace('FILTER_ERRORS', 'ignore_errors = 0;') -if args.cgroupmap: - bpf_text = bpf_text.replace('FILTER_CGROUP', struct_init['filter_cgroup']) - bpf_text = bpf_text.replace( - 'CGROUP_MAP', - ( - 'BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "%s");' % - args.cgroupmap - ) - ) - +bpf_text = filter_by_containers(args) + bpf_text bpf_text = bpf_text.replace('FILTER_PID', '') bpf_text = bpf_text.replace('FILTER_PORT', '') bpf_text = bpf_text.replace('FILTER_UID', '') bpf_text = bpf_text.replace('FILTER_ERRORS', '') -bpf_text = bpf_text.replace('FILTER_CGROUP', '') -bpf_text = bpf_text.replace('CGROUP_MAP', '') # selecting output format - 80 characters or wide, fitting IPv6 addresses header_fmt = "%8s %-12.12s %-4s %-15s %-5s %5s %2s" diff --git a/tools/bindsnoop_example.txt b/tools/bindsnoop_example.txt index 77e040ed7..c7c513539 100644 --- a/tools/bindsnoop_example.txt +++ b/tools/bindsnoop_example.txt @@ -59,7 +59,7 @@ It is meant to be used with an externally created map. # ./bindsnoop.py --cgroupmap /sys/fs/bpf/test01 -For more details, see docs/filtering_by_cgroups.md +For more details, see docs/special_filtering.md In order to track heavy bind usage one can use --count option @@ -74,7 +74,7 @@ LADDR LPORT BINDS Usage message: # ./bindsnoop.py -h usage: bindsnoop.py [-h] [-t] [-w] [-p PID] [-P PORT] [-E] [-U] [-u UID] - [--count] [--cgroupmap CGROUPMAP] + [--count] [--cgroupmap CGROUPMAP] [--mntnsmap MNTNSMAP] Trace TCP binds @@ -103,6 +103,7 @@ examples: ./bindsnoop -E # report bind errors ./bindsnoop --count # count bind per src ip ./bindsnoop --cgroupmap mappath # only trace cgroups in this BPF map + ./bindsnoop --mntnsmap mappath # only trace mount namespaces in the map it is reporting socket options set before the bins call impacting system call behavior: diff --git a/tools/capable.py b/tools/capable.py index 3852e2247..94d1c32a3 100755 --- a/tools/capable.py +++ b/tools/capable.py @@ -15,6 +15,7 @@ from os import getpid from functools import partial from bcc import BPF +from bcc.containers import filter_by_containers import errno import argparse from time import strftime @@ -28,7 +29,8 @@ ./capable -U # add user-space stacks to trace ./capable -x # extra fields: show TID and INSETID columns ./capable --unique # don't repeat stacks for the same pid or cgroup - ./capable --cgroupmap ./mappath # only trace cgroups in this BPF map + ./capable --cgroupmap mappath # only trace cgroups in this BPF map + ./capable --mntnsmap mappath # only trace mount namespaces in the map """ parser = argparse.ArgumentParser( description="Trace security capability checks", @@ -46,6 +48,8 @@ help="show extra fields in TID and INSETID columns") parser.add_argument("--cgroupmap", help="trace cgroups in this BPF map only") +parser.add_argument("--mntnsmap", + help="trace mount namespaces in this BPF map only") parser.add_argument("--unique", action="store_true", help="don't repeat stacks for the same pid or cgroup") args = parser.parse_args() @@ -145,10 +149,6 @@ def __getattr__(self, name): BPF_HASH(seen, struct repeat_t, u64); #endif -#if CGROUPSET -BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); -#endif - #if defined(USER_STACKS) || defined(KERNEL_STACKS) BPF_STACK_TRACE(stacks, 2048); #endif @@ -173,12 +173,10 @@ def __getattr__(self, name): FILTER1 FILTER2 FILTER3 -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { + + if (container_should_be_filtered()) { return 0; } -#endif u32 uid = bpf_get_current_uid_gid(); struct data_t data = {.tgid = tgid, .pid = pid, .uid = uid, .cap = cap, .audit = audit, .insetid = insetid}; @@ -192,7 +190,7 @@ def __getattr__(self, name): #if UNIQUESET struct repeat_t repeat = {0,}; repeat.cap = cap; -#if CGROUPSET +#if CGROUP_ID_SET repeat.cgroupid = bpf_get_current_cgroup_id(); #else repeat.tgid = tgid; @@ -229,11 +227,7 @@ def __getattr__(self, name): bpf_text = bpf_text.replace('FILTER2', '') bpf_text = bpf_text.replace('FILTER3', 'if (pid == %s) { return 0; }' % getpid()) -if args.cgroupmap: - bpf_text = bpf_text.replace('CGROUPSET', '1') - bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) -else: - bpf_text = bpf_text.replace('CGROUPSET', '0') +bpf_text = filter_by_containers(args) + bpf_text if args.unique: bpf_text = bpf_text.replace('UNIQUESET', '1') else: diff --git a/tools/capable_example.txt b/tools/capable_example.txt index bcd6d01ee..1701b6a2e 100644 --- a/tools/capable_example.txt +++ b/tools/capable_example.txt @@ -4,7 +4,7 @@ Demonstrations of capable, the Linux eBPF/bcc version. capable traces calls to the kernel cap_capable() function, which does security capability checks, and prints details for each call. For example: -# ./capable.py +# ./capable.py TIME UID PID COMM CAP NAME AUDIT 22:11:23 114 2676 snmpd 12 CAP_NET_ADMIN 1 22:11:23 0 6990 run 24 CAP_SYS_RESOURCE 1 @@ -100,14 +100,14 @@ with an externally created map. # ./capable.py --cgroupmap /sys/fs/bpf/test01 -For more details, see docs/filtering_by_cgroups.md +For more details, see docs/special_filtering.md USAGE: # ./capable.py -h usage: capable.py [-h] [-v] [-p PID] [-K] [-U] [-x] [--cgroupmap CGROUPMAP] - [--unique] + [--mntnsmap MNTNSMAP] [--unique] Trace security capability checks @@ -120,6 +120,7 @@ optional arguments: -x, --extra show extra fields in TID and INSETID columns --cgroupmap CGROUPMAP trace cgroups in this BPF map only + --mntnsmap MNTNSMAP trace mount namespaces in this BPF map only --unique don't repeat stacks for the same pid or cgroup examples: @@ -130,4 +131,5 @@ examples: ./capable -U # add user-space stacks to trace ./capable -x # extra fields: show TID and INSETID columns ./capable --unique # don't repeat stacks for the same pid or cgroup - ./capable --cgroupmap ./mappath # only trace cgroups in this BPF map + ./capable --cgroupmap mappath # only trace cgroups in this BPF map + ./capable --mntnsmap mappath # only trace mount namespaces in the map diff --git a/tools/execsnoop.py b/tools/execsnoop.py index 9879d2c2f..53052d390 100755 --- a/tools/execsnoop.py +++ b/tools/execsnoop.py @@ -19,6 +19,7 @@ from __future__ import print_function from bcc import BPF +from bcc.containers import filter_by_containers from bcc.utils import ArgString, printb import bcc.utils as utils import argparse @@ -57,7 +58,8 @@ def parse_uid(user): ./execsnoop -q # add "quotemarks" around arguments ./execsnoop -n main # only print command lines containing "main" ./execsnoop -l tpkg # only print command where arguments contains "tpkg" - ./execsnoop --cgroupmap ./mappath # only trace cgroups in this BPF map + ./execsnoop --cgroupmap mappath # only trace cgroups in this BPF map + ./execsnoop --mntnsmap mappath # only trace mount namespaces in the map """ parser = argparse.ArgumentParser( description="Trace exec() syscalls", @@ -71,6 +73,8 @@ def parse_uid(user): help="include failed exec()s") parser.add_argument("--cgroupmap", help="trace cgroups in this BPF map only") +parser.add_argument("--mntnsmap", + help="trace mount namespaces in this BPF map only") parser.add_argument("-u", "--uid", type=parse_uid, metavar='USER', help="trace this UID only") parser.add_argument("-q", "--quote", action="store_true", @@ -113,9 +117,6 @@ def parse_uid(user): int retval; }; -#if CGROUPSET -BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); -#endif BPF_PERF_OUTPUT(events); static int __submit_arg(struct pt_regs *ctx, void *ptr, struct data_t *data) @@ -145,12 +146,9 @@ def parse_uid(user): UID_FILTER -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { - return 0; + if (container_should_be_filtered()) { + return 0; } -#endif // create data here and pass to submit_arg to save stack space (#555) struct data_t data = {}; @@ -185,12 +183,9 @@ def parse_uid(user): int do_ret_sys_execve(struct pt_regs *ctx) { -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { - return 0; + if (container_should_be_filtered()) { + return 0; } -#endif struct data_t data = {}; struct task_struct *task; @@ -223,11 +218,7 @@ def parse_uid(user): 'if (uid != %s) { return 0; }' % args.uid) else: bpf_text = bpf_text.replace('UID_FILTER', '') -if args.cgroupmap: - bpf_text = bpf_text.replace('CGROUPSET', '1') - bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) -else: - bpf_text = bpf_text.replace('CGROUPSET', '0') +bpf_text = filter_by_containers(args) + bpf_text if args.ebpf: print(bpf_text) exit() diff --git a/tools/execsnoop_example.txt b/tools/execsnoop_example.txt index a90d00794..8cdfe0db7 100644 --- a/tools/execsnoop_example.txt +++ b/tools/execsnoop_example.txt @@ -83,7 +83,7 @@ with an externally created map. # ./execsnoop --cgroupmap /sys/fs/bpf/test01 -For more details, see docs/filtering_by_cgroups.md +For more details, see docs/special_filtering.md The -U option include UID on output: @@ -121,6 +121,7 @@ optional arguments: -x, --fails include failed exec()s --cgroupmap CGROUPMAP trace cgroups in this BPF map only + --mntnsmap MNTNSMAP trace mount namespaces in this BPF map only -u USER, --uid USER trace this UID only -q, --quote Add quotemarks (") around arguments. -n NAME, --name NAME only print commands matching this name (regex), any @@ -142,4 +143,5 @@ examples: ./execsnoop -q # add "quotemarks" around arguments ./execsnoop -n main # only print command lines containing "main" ./execsnoop -l tpkg # only print command where arguments contains "tpkg" - ./execsnoop --cgroupmap ./mappath # only trace cgroups in this BPF map + ./execsnoop --cgroupmap mappath # only trace cgroups in this BPF map + ./execsnoop --mntnsmap mappath # only trace mount namespaces in the map diff --git a/tools/opensnoop.py b/tools/opensnoop.py index 28fe7559b..a68b13f9a 100755 --- a/tools/opensnoop.py +++ b/tools/opensnoop.py @@ -17,6 +17,7 @@ from __future__ import print_function from bcc import ArgString, BPF +from bcc.containers import filter_by_containers from bcc.utils import printb import argparse from datetime import datetime, timedelta @@ -35,7 +36,8 @@ ./opensnoop -n main # only print process names containing "main" ./opensnoop -e # show extended fields ./opensnoop -f O_WRONLY -f O_RDWR # only print calls for writing - ./opensnoop --cgroupmap ./mappath # only trace cgroups in this BPF map + ./opensnoop --cgroupmap mappath # only trace cgroups in this BPF map + ./opensnoop --mntnsmap mappath # only trace mount namespaces in the map """ parser = argparse.ArgumentParser( description="Trace open() syscalls", @@ -53,6 +55,8 @@ help="trace this TID only") parser.add_argument("--cgroupmap", help="trace cgroups in this BPF map only") +parser.add_argument("--mntnsmap", + help="trace mount namespaces in this BPF map only") parser.add_argument("-u", "--uid", help="trace this UID only") parser.add_argument("-d", "--duration", @@ -102,9 +106,6 @@ int flags; // EXTENDED_STRUCT_MEMBER }; -#if CGROUPSET -BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); -#endif BPF_PERF_OUTPUT(events); """ @@ -122,12 +123,11 @@ PID_TID_FILTER UID_FILTER FLAGS_FILTER -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { - return 0; + + if (container_should_be_filtered()) { + return 0; } -#endif + if (bpf_get_current_comm(&val.comm, sizeof(val.comm)) == 0) { val.id = id; val.fname = filename; @@ -177,12 +177,9 @@ PID_TID_FILTER UID_FILTER FLAGS_FILTER -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { - return 0; + if (container_should_be_filtered()) { + return 0; } -#endif struct data_t data = {}; bpf_get_current_comm(&data.comm, sizeof(data.comm)); @@ -221,11 +218,7 @@ 'if (uid != %s) { return 0; }' % args.uid) else: bpf_text = bpf_text.replace('UID_FILTER', '') -if args.cgroupmap: - bpf_text = bpf_text.replace('CGROUPSET', '1') - bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) -else: - bpf_text = bpf_text.replace('CGROUPSET', '0') +bpf_text = filter_by_containers(args) + bpf_text if args.flag_filter: bpf_text = bpf_text.replace('FLAGS_FILTER', 'if (!(flags & %d)) { return 0; }' % flag_filter_mask) diff --git a/tools/opensnoop_example.txt b/tools/opensnoop_example.txt index 44f0e337d..f15e84f2b 100644 --- a/tools/opensnoop_example.txt +++ b/tools/opensnoop_example.txt @@ -187,14 +187,15 @@ with an externally created map. # ./opensnoop --cgroupmap /sys/fs/bpf/test01 -For more details, see docs/filtering_by_cgroups.md +For more details, see docs/special_filtering.md USAGE message: # ./opensnoop -h -usage: opensnoop [-h] [-T] [-x] [-p PID] [-t TID] [-d DURATION] [-n NAME] - [-e] [-f FLAG_FILTER] +usage: opensnoop.py [-h] [-T] [-U] [-x] [-p PID] [-t TID] + [--cgroupmap CGROUPMAP] [--mntnsmap MNTNSMAP] [-u UID] + [-d DURATION] [-n NAME] [-e] [-f FLAG_FILTER] Trace open() syscalls @@ -205,6 +206,9 @@ optional arguments: -x, --failed only show failed opens -p PID, --pid PID trace this PID only -t TID, --tid TID trace this TID only + --cgroupmap CGROUPMAP + trace cgroups in this BPF map only + --mntnsmap MNTNSMAP trace mount namespaces in this BPF map on -u UID, --uid UID trace this UID only -d DURATION, --duration DURATION total duration of trace in seconds @@ -226,3 +230,5 @@ examples: ./opensnoop -n main # only print process names containing "main" ./opensnoop -e # show extended fields ./opensnoop -f O_WRONLY -f O_RDWR # only print calls for writing + ./opensnoop --cgroupmap mappath # only trace cgroups in this BPF map + ./opensnoop --mntnsmap mappath # only trace mount namespaces in the map diff --git a/tools/profile.py b/tools/profile.py index 2067933af..dd6f65fa3 100755 --- a/tools/profile.py +++ b/tools/profile.py @@ -24,10 +24,11 @@ # # 15-Jul-2016 Brendan Gregg Created this. # 20-Oct-2016 " " Switched to use the new 4.9 support. -# 26-Jan-2019 " " Changed to exclude CPU idle by default. +# 26-Jan-2019 " " Changed to exclude CPU idle by default. from __future__ import print_function from bcc import BPF, PerfType, PerfSWConfig +from bcc.containers import filter_by_containers from sys import stderr from time import sleep import argparse @@ -72,7 +73,8 @@ def stack_id_err(stack_id): ./profile -L 185 # only profile thread with TID 185 ./profile -U # only show user space stacks (no kernel) ./profile -K # only show kernel space stacks (no user) - ./profile --cgroupmap ./mappath # only trace cgroups in this BPF map + ./profile --cgroupmap mappath # only trace cgroups in this BPF map + ./profile --mntnsmap mappath # only trace mount namespaces in the map """ parser = argparse.ArgumentParser( description="Profile CPU stack traces at a timed interval", @@ -115,6 +117,8 @@ def stack_id_err(stack_id): help=argparse.SUPPRESS) parser.add_argument("--cgroupmap", help="trace cgroups in this BPF map only") +parser.add_argument("--mntnsmap", + help="trace mount namespaces in this BPF map only") # option logic args = parser.parse_args() @@ -146,10 +150,6 @@ def stack_id_err(stack_id): BPF_HASH(counts, struct key_t); BPF_STACK_TRACE(stack_traces, STACK_STORAGE_SIZE); -#if CGROUPSET -BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); -#endif - // This code gets a bit complex. Probably not suitable for casual hacking. int do_perf_event(struct bpf_perf_event_data *ctx) { @@ -163,12 +163,9 @@ def stack_id_err(stack_id): if (!(THREAD_FILTER)) return 0; -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { + if (container_should_be_filtered()) { return 0; } -#endif // create map key struct key_t key = {.pid = tgid}; @@ -246,11 +243,7 @@ def stack_id_err(stack_id): stack_context = "user + kernel" bpf_text = bpf_text.replace('USER_STACK_GET', user_stack_get) bpf_text = bpf_text.replace('KERNEL_STACK_GET', kernel_stack_get) -if args.cgroupmap: - bpf_text = bpf_text.replace('CGROUPSET', '1') - bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) -else: - bpf_text = bpf_text.replace('CGROUPSET', '0') +bpf_text = filter_by_containers(args) + bpf_text sample_freq = 0 sample_period = 0 diff --git a/tools/profile_example.txt b/tools/profile_example.txt index bb3c5aec9..2c7e702a9 100644 --- a/tools/profile_example.txt +++ b/tools/profile_example.txt @@ -708,7 +708,7 @@ with an externally created map. # ./profile --cgroupmap /sys/fs/bpf/test01 -For more details, see docs/filtering_by_cgroups.md +For more details, see docs/special_filtering.md USAGE message: @@ -717,7 +717,7 @@ USAGE message: usage: profile.py [-h] [-p PID | -L TID] [-U | -K] [-F FREQUENCY | -c COUNT] [-d] [-a] [-I] [-f] [--stack-storage-size STACK_STORAGE_SIZE] [-C CPU] - [--cgroupmap CGROUPMAP] + [--cgroupmap CGROUPMAP] [--mntnsmap MNTNSMAP] [duration] Profile CPU stack traces at a timed interval @@ -750,6 +750,7 @@ optional arguments: -C CPU, --cpu CPU cpu number to run profile on --cgroupmap CGROUPMAP trace cgroups in this BPF map only + --mntnsmap MNTNSMAP trace mount namespaces in this BPF map only examples: ./profile # profile stack traces at 49 Hertz until Ctrl-C @@ -761,4 +762,5 @@ examples: ./profile -L 185 # only profile thread with TID 185 ./profile -U # only show user space stacks (no kernel) ./profile -K # only show kernel space stacks (no user) - ./profile --cgroupmap ./mappath # only trace cgroups in this BPF map + ./profile --cgroupmap mappath # only trace cgroups in this BPF map + ./profile --mntnsmap mappath # only trace mount namespaces in the map diff --git a/tools/tcpaccept.py b/tools/tcpaccept.py index 03b05e0ab..4aa7fd7a1 100755 --- a/tools/tcpaccept.py +++ b/tools/tcpaccept.py @@ -16,6 +16,7 @@ # 14-Feb-2016 " " Switch to bpf_perf_output. from __future__ import print_function +from bcc.containers import filter_by_containers from bcc import BPF from socket import inet_ntop, AF_INET, AF_INET6 from struct import pack @@ -29,7 +30,8 @@ ./tcpaccept -t # include timestamps ./tcpaccept -P 80,81 # only trace port 80 and 81 ./tcpaccept -p 181 # only trace PID 181 - ./tcpaccept --cgroupmap ./mappath # only trace cgroups in this BPF map + ./tcpaccept --cgroupmap mappath # only trace cgroups in this BPF map + ./tcpaccept --mntnsmap mappath # only trace mount namespaces in the map """ parser = argparse.ArgumentParser( description="Trace TCP accepts", @@ -45,6 +47,8 @@ help="comma-separated list of local ports to trace") parser.add_argument("--cgroupmap", help="trace cgroups in this BPF map only") +parser.add_argument("--mntnsmap", + help="trace mount namespaces in this BPF map only") parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) args = parser.parse_args() @@ -80,11 +84,6 @@ char task[TASK_COMM_LEN]; }; BPF_PERF_OUTPUT(ipv6_events); - -#if CGROUPSET -BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); -#endif - """ # @@ -97,12 +96,9 @@ bpf_text_kprobe = """ int kretprobe__inet_csk_accept(struct pt_regs *ctx) { -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { + if (container_should_be_filtered()) { return 0; } -#endif struct sock *newsk = (struct sock *)PT_REGS_RC(ctx); u32 pid = bpf_get_current_pid_tgid() >> 32; @@ -115,21 +111,21 @@ // check this is TCP u8 protocol = 0; // workaround for reading the sk_protocol bitfield: - + // Following comments add by Joe Yin: // Unfortunately,it can not work since Linux 4.10, // because the sk_wmem_queued is not following the bitfield of sk_protocol. // And the following member is sk_gso_max_segs. // So, we can use this: // bpf_probe_read(&protocol, 1, (void *)((u64)&newsk->sk_gso_max_segs) - 3); - // In order to diff the pre-4.10 and 4.10+ ,introduce the variables gso_max_segs_offset,sk_lingertime, - // sk_lingertime is closed to the gso_max_segs_offset,and - // the offset between the two members is 4 + // In order to diff the pre-4.10 and 4.10+ ,introduce the variables gso_max_segs_offset,sk_lingertime, + // sk_lingertime is closed to the gso_max_segs_offset,and + // the offset between the two members is 4 int gso_max_segs_offset = offsetof(struct sock, sk_gso_max_segs); int sk_lingertime_offset = offsetof(struct sock, sk_lingertime); - if (sk_lingertime_offset - gso_max_segs_offset == 4) + if (sk_lingertime_offset - gso_max_segs_offset == 4) // 4.10+ with little endian #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ protocol = *(u8 *)((u64)&newsk->sk_gso_max_segs - 3); @@ -199,11 +195,7 @@ lports_if = ' && '.join(['lport != %d' % lport for lport in lports]) bpf_text = bpf_text.replace('##FILTER_PORT##', 'if (%s) { return 0; }' % lports_if) -if args.cgroupmap: - bpf_text = bpf_text.replace('CGROUPSET', '1') - bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) -else: - bpf_text = bpf_text.replace('CGROUPSET', '0') +bpf_text = filter_by_containers(args) + bpf_text if debug or args.ebpf: print(bpf_text) if args.ebpf: diff --git a/tools/tcpaccept_example.txt b/tools/tcpaccept_example.txt index 5b6b1a6d8..938156556 100644 --- a/tools/tcpaccept_example.txt +++ b/tools/tcpaccept_example.txt @@ -38,7 +38,7 @@ with an externally created map. # ./tcpaccept --cgroupmap /sys/fs/bpf/test01 -For more details, see docs/filtering_by_cgroups.md +For more details, see docs/special_filtering.md USAGE message: @@ -62,4 +62,5 @@ examples: ./tcpaccept -t # include timestamps ./tcpaccept -P 80,81 # only trace port 80 and 81 ./tcpaccept -p 181 # only trace PID 181 - ./tcpaccept --cgroupmap ./mappath # only trace cgroups in this BPF map + ./tcpaccept --cgroupmap mappath # only trace cgroups in this BPF map + ./tcpaccept --mntnsmap mappath # only trace mount namespaces in the map \ No newline at end of file diff --git a/tools/tcpconnect.py b/tools/tcpconnect.py index 67f2cef19..40878eea0 100755 --- a/tools/tcpconnect.py +++ b/tools/tcpconnect.py @@ -21,6 +21,7 @@ from __future__ import print_function from bcc import BPF +from bcc.containers import filter_by_containers from bcc.utils import printb import argparse from socket import inet_ntop, ntohs, AF_INET, AF_INET6 @@ -37,7 +38,8 @@ ./tcpconnect -U # include UID ./tcpconnect -u 1000 # only trace UID 1000 ./tcpconnect -c # count connects per src ip and dest ip/port - ./tcpconnect --cgroupmap ./mappath # only trace cgroups in this BPF map + ./tcpconnect --cgroupmap mappath # only trace cgroups in this BPF map + ./tcpconnect --mntnsmap mappath # only trace mount namespaces in the map """ parser = argparse.ArgumentParser( description="Trace TCP connects", @@ -57,6 +59,8 @@ help="count connects per src ip and dest ip/port") parser.add_argument("--cgroupmap", help="trace cgroups in this BPF map only") +parser.add_argument("--mntnsmap", + help="trace mount namespaces in this BPF map only") parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) args = parser.parse_args() @@ -70,10 +74,6 @@ BPF_HASH(currsock, u32, struct sock *); -#if CGROUPSET -BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); -#endif - // separate data structs for ipv4 and ipv6 struct ipv4_data_t { u64 ts_us; @@ -116,12 +116,9 @@ int trace_connect_entry(struct pt_regs *ctx, struct sock *sk) { -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { - return 0; + if (container_should_be_filtered()) { + return 0; } -#endif u64 pid_tgid = bpf_get_current_pid_tgid(); u32 pid = pid_tgid >> 32; @@ -248,11 +245,7 @@ if args.uid: bpf_text = bpf_text.replace('FILTER_UID', 'if (uid != %s) { return 0; }' % args.uid) -if args.cgroupmap: - bpf_text = bpf_text.replace('CGROUPSET', '1') - bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) -else: - bpf_text = bpf_text.replace('CGROUPSET', '0') +bpf_text = filter_by_containers(args) + bpf_text bpf_text = bpf_text.replace('FILTER_PID', '') bpf_text = bpf_text.replace('FILTER_PORT', '') diff --git a/tools/tcpconnect_example.txt b/tools/tcpconnect_example.txt index cf9756272..7efac4a31 100644 --- a/tools/tcpconnect_example.txt +++ b/tools/tcpconnect_example.txt @@ -73,14 +73,14 @@ with an externally created map. # ./tcpconnect --cgroupmap /sys/fs/bpf/test01 -For more details, see docs/filtering_by_cgroups.md +For more details, see docs/special_filtering.md USAGE message: # ./tcpconnect -h usage: tcpconnect.py [-h] [-t] [-p PID] [-P PORT] [-U] [-u UID] [-c] - [--cgroupmap CGROUPMAP] + [--cgroupmap CGROUPMAP] [--mntnsmap MNTNSMAP] Trace TCP connects @@ -104,4 +104,5 @@ examples: ./tcpconnect -U # include UID ./tcpconnect -u 1000 # only trace UID 1000 ./tcpconnect -c # count connects per src ip and dest ip/port - ./tcpconnect --cgroupmap ./mappath # only trace cgroups in this BPF map + ./tcpconnect --cgroupmap mappath # only trace cgroups in this BPF map + ./tcpconnect --mntnsmap mappath # only trace mount namespaces in the map \ No newline at end of file diff --git a/tools/tcptop.py b/tools/tcptop.py index 9fb3ca2b3..510c4e86b 100755 --- a/tools/tcptop.py +++ b/tools/tcptop.py @@ -26,6 +26,7 @@ from __future__ import print_function from bcc import BPF +from bcc.containers import filter_by_containers import argparse from socket import inet_ntop, AF_INET, AF_INET6 from struct import pack @@ -45,7 +46,8 @@ def range_check(string): ./tcptop # trace TCP send/recv by host ./tcptop -C # don't clear the screen ./tcptop -p 181 # only trace PID 181 - ./tcptop --cgroupmap ./mappath # only trace cgroups in this BPF map + ./tcptop --cgroupmap mappath # only trace cgroups in this BPF map + ./tcptop --mntnsmap mappath # only trace mount namespaces in the map """ parser = argparse.ArgumentParser( description="Summarize TCP send/recv throughput by host", @@ -63,6 +65,8 @@ def range_check(string): help="number of outputs") parser.add_argument("--cgroupmap", help="trace cgroups in this BPF map only") +parser.add_argument("--mntnsmap", + help="trace mount namespaces in this BPF map only") parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) args = parser.parse_args() @@ -98,21 +102,16 @@ def range_check(string): BPF_HASH(ipv6_send_bytes, struct ipv6_key_t); BPF_HASH(ipv6_recv_bytes, struct ipv6_key_t); -#if CGROUPSET -BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); -#endif - int kprobe__tcp_sendmsg(struct pt_regs *ctx, struct sock *sk, struct msghdr *msg, size_t size) { - u32 pid = bpf_get_current_pid_tgid() >> 32; - FILTER -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { + if (container_should_be_filtered()) { return 0; } -#endif + + u32 pid = bpf_get_current_pid_tgid() >> 32; + FILTER_PID + u16 dport = 0, family = sk->__sk_common.skc_family; if (family == AF_INET) { @@ -148,14 +147,13 @@ def range_check(string): */ int kprobe__tcp_cleanup_rbuf(struct pt_regs *ctx, struct sock *sk, int copied) { - u32 pid = bpf_get_current_pid_tgid() >> 32; - FILTER -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { + if (container_should_be_filtered()) { return 0; } -#endif + + u32 pid = bpf_get_current_pid_tgid() >> 32; + FILTER_PID + u16 dport = 0, family = sk->__sk_common.skc_family; u64 *val, zero = 0; @@ -190,15 +188,11 @@ def range_check(string): # code substitutions if args.pid: - bpf_text = bpf_text.replace('FILTER', + bpf_text = bpf_text.replace('FILTER_PID', 'if (pid != %s) { return 0; }' % args.pid) else: - bpf_text = bpf_text.replace('FILTER', '') -if args.cgroupmap: - bpf_text = bpf_text.replace('CGROUPSET', '1') - bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) -else: - bpf_text = bpf_text.replace('CGROUPSET', '0') + bpf_text = bpf_text.replace('FILTER_PID', '') +bpf_text = filter_by_containers(args) + bpf_text if debug or args.ebpf: print(bpf_text) if args.ebpf: diff --git a/tools/tcptop_example.txt b/tools/tcptop_example.txt index 379aff208..e29e2fa2e 100644 --- a/tools/tcptop_example.txt +++ b/tools/tcptop_example.txt @@ -97,13 +97,14 @@ with an externally created map. # tcptop --cgroupmap /sys/fs/bpf/test01 -For more details, see docs/filtering_by_cgroups.md +For more details, see docs/special_filtering.md USAGE: # tcptop -h usage: tcptop.py [-h] [-C] [-S] [-p PID] [--cgroupmap CGROUPMAP] + [--mntnsmap MNTNSMAP] [interval] [count] Summarize TCP send/recv throughput by host @@ -125,3 +126,4 @@ examples: ./tcptop -C # don't clear the screen ./tcptop -p 181 # only trace PID 181 ./tcptop --cgroupmap ./mappath # only trace cgroups in this BPF map + ./tcptop --mntnsmap mappath # only trace mount namespaces in the map diff --git a/tools/tcptracer.py b/tools/tcptracer.py index 8e6e1ec2b..7f67d3381 100755 --- a/tools/tcptracer.py +++ b/tools/tcptracer.py @@ -16,6 +16,7 @@ # Licensed under the Apache License, Version 2.0 (the "License") from __future__ import print_function from bcc import BPF +from bcc.containers import filter_by_containers import argparse as ap from socket import inet_ntop, AF_INET, AF_INET6 @@ -31,6 +32,8 @@ help="trace this Network Namespace only") parser.add_argument("--cgroupmap", help="trace cgroups in this BPF map only") +parser.add_argument("--mntnsmap", + help="trace mount namespaces in this BPF map only") parser.add_argument("-v", "--verbose", action="store_true", help="include Network Namespace in the output") parser.add_argument("--ebpf", action="store_true", @@ -79,10 +82,6 @@ }; BPF_PERF_OUTPUT(tcp_ipv6_event); -#if CGROUPSET -BPF_TABLE_PINNED("hash", u64, u64, cgroupset, 1024, "CGROUPPATH"); -#endif - // tcp_set_state doesn't run in the context of the process that initiated the // connection so we need to store a map TUPLE -> PID to send the right PID on // the event @@ -179,12 +178,9 @@ int trace_connect_v4_entry(struct pt_regs *ctx, struct sock *sk) { -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { - return 0; + if (container_should_be_filtered()) { + return 0; } -#endif u64 pid = bpf_get_current_pid_tgid(); @@ -233,12 +229,9 @@ int trace_connect_v6_entry(struct pt_regs *ctx, struct sock *sk) { -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { - return 0; + if (container_should_be_filtered()) { + return 0; } -#endif u64 pid = bpf_get_current_pid_tgid(); ##FILTER_PID## @@ -371,12 +364,9 @@ int trace_close_entry(struct pt_regs *ctx, struct sock *skp) { -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { - return 0; + if (container_should_be_filtered()) { + return 0; } -#endif u64 pid = bpf_get_current_pid_tgid(); @@ -439,12 +429,9 @@ int trace_accept_return(struct pt_regs *ctx) { -#if CGROUPSET - u64 cgroupid = bpf_get_current_cgroup_id(); - if (cgroupset.lookup(&cgroupid) == NULL) { - return 0; + if (container_should_be_filtered()) { + return 0; } -#endif struct sock *newsk = (struct sock *)PT_REGS_RC(ctx); u64 pid = bpf_get_current_pid_tgid(); @@ -614,11 +601,7 @@ def print_ipv6_event(cpu, data, size): bpf_text = bpf_text.replace('##FILTER_PID##', pid_filter) bpf_text = bpf_text.replace('##FILTER_NETNS##', netns_filter) -if args.cgroupmap: - bpf_text = bpf_text.replace('CGROUPSET', '1') - bpf_text = bpf_text.replace('CGROUPPATH', args.cgroupmap) -else: - bpf_text = bpf_text.replace('CGROUPSET', '0') +bpf_text = filter_by_containers(args) + bpf_text if args.ebpf: print(bpf_text) diff --git a/tools/tcptracer_example.txt b/tools/tcptracer_example.txt index b6e52589d..0f61ecc7b 100644 --- a/tools/tcptracer_example.txt +++ b/tools/tcptracer_example.txt @@ -42,4 +42,4 @@ with an externally created map. # ./tcptracer --cgroupmap /sys/fs/bpf/test01 -For more details, see docs/filtering_by_cgroups.md +For more details, see docs/special_filtering.md From 683ed9e1baede201e1dfe74d3a661b8b1d6b97da Mon Sep 17 00:00:00 2001 From: Kunal Bhalla Date: Thu, 21 May 2020 23:37:54 -0400 Subject: [PATCH 118/278] Spelling (as title) --- docs/tutorial_bcc_python_developer.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorial_bcc_python_developer.md b/docs/tutorial_bcc_python_developer.md index 5de74dcdc..b8d3987d4 100644 --- a/docs/tutorial_bcc_python_developer.md +++ b/docs/tutorial_bcc_python_developer.md @@ -713,7 +713,7 @@ These programs can be found in the files [examples/tracing/task_switch.c](../exa For further study, see Sasha Goldshtein's [linux-tracing-workshop](https://github.com/goldshtn/linux-tracing-workshop), which contains additional labs. There are also many tools in bcc /tools to study. -Please read [CONTRIBUTING-SCRIPTS.md](../CONTRIBUTING-SCRIPTS.md) if you wish to contrubite tools to bcc. At the bottom of the main [README.md](../README.md), you'll also find methods for contacting us. Good luck, and happy tracing! +Please read [CONTRIBUTING-SCRIPTS.md](../CONTRIBUTING-SCRIPTS.md) if you wish to contribute tools to bcc. At the bottom of the main [README.md](../README.md), you'll also find methods for contacting us. Good luck, and happy tracing! ## Networking From a28337a7ebea6ce375fb2e976f0b3b61aa05e981 Mon Sep 17 00:00:00 2001 From: Shohei YOSHIDA Date: Fri, 22 May 2020 22:13:01 +0900 Subject: [PATCH 119/278] tool: trace process termination by default `sched_process_exit` tracepoint is called when thread terminates. So exitsnoop shows line per each thread termination if the process is multi-thread process. This is not useful when people wants to know why process terminates, not thread. So this changes exitsnoop default behavior which traces process termination instead of thread termination. And add `--per-thread` option which behaves as original exitsnoop implementation. --- man/man8/exitsnoop.8 | 9 ++++++++- tools/exitsnoop.py | 13 ++++++++++++- tools/exitsnoop_example.txt | 4 +++- 3 files changed, 23 insertions(+), 3 deletions(-) diff --git a/man/man8/exitsnoop.8 b/man/man8/exitsnoop.8 index fb1942b42..86a439214 100644 --- a/man/man8/exitsnoop.8 +++ b/man/man8/exitsnoop.8 @@ -2,7 +2,7 @@ .SH NAME exitsnoop \- Trace all process termination (exit, fatal signal). Uses Linux eBPF/bcc. .SH SYNOPSIS -.B exitsnoop [\-h] [\-t] [\-\-utc] [\-x] [\-p PID] [\-\-label LABEL] +.B exitsnoop [\-h] [\-t] [\-\-utc] [\-x] [\-p PID] [\-\-label LABEL] [\-\-per\-thread] .SH DESCRIPTION exitsnoop traces process termination, showing the command name and reason for termination, either an exit or a fatal signal. @@ -35,6 +35,9 @@ Trace this process ID only (filtered in-kernel). .TP \-\-label LABEL Label each line with LABEL (default 'exit') in first column (2nd if timestamp is present). +.TP +\-\-per\-thread +Trace per thread termination .SH EXAMPLES .TP Trace all process termination @@ -56,6 +59,10 @@ Trace PID 181 only: Label each output line with 'EXIT': # .B exitsnoop \-\-label EXIT +.TP +Trace per thread termination +# +.B exitsnoop \-\-per\-thread .SH FIELDS .TP TIME-TZ diff --git a/tools/exitsnoop.py b/tools/exitsnoop.py index 13a1444c5..db0d40087 100755 --- a/tools/exitsnoop.py +++ b/tools/exitsnoop.py @@ -27,6 +27,7 @@ exitsnoop --utc # include timestamps (UTC) exitsnoop -p 181 # only trace PID 181 exitsnoop --label=exit # label each output line with 'exit' + exitsnoop --per-thread # trace per thread termination """ """ Exit status (from ): @@ -62,6 +63,7 @@ def _getParser(): a("-p", "--pid", help="trace this PID only") a("--label", help="label each line") a("-x", "--failed", action="store_true", help="trace only fails, exclude exit(0)") + a("--per-thread", action="store_true", help="trace per thread termination") # print the embedded C program and exit, for debugging a("--ebpf", action="store_true", help=argparse.SUPPRESS) # RHEL 7.6 keeps task->start_time as struct timespec, convert to u64 nanoseconds @@ -140,11 +142,20 @@ def _embedded_c(args): extern int bpf_static_assert[(condition) ? 1 : -1] #endif """ + + if Global.args.pid: + if Global.args.per_thread: + filter_pid = "task->tgid != %s" % Global.args.pid + else: + filter_pid = "!(task->tgid == %s && task->pid == task->tgid)" % Global.args.pid + else: + filter_pid = '0' if Global.args.per_thread else 'task->pid != task->tgid' + code_substitutions = [ ('EBPF_COMMENT', '' if not Global.args.ebpf else _ebpf_comment()), ("BPF_STATIC_ASSERT_DEF", bpf_static_assert_def), ("CTYPES_SIZEOF_DATA", str(ct.sizeof(Data))), - ('FILTER_PID', '0' if not Global.args.pid else "task->tgid != %s" % Global.args.pid), + ('FILTER_PID', filter_pid), ('FILTER_EXIT_CODE', '0' if not Global.args.failed else 'task->exit_code == 0'), ('PROCESS_START_TIME_NS', 'task->start_time' if not Global.args.timespec else '(task->start_time.tv_sec * 1000000000L) + task->start_time.tv_nsec'), diff --git a/tools/exitsnoop_example.txt b/tools/exitsnoop_example.txt index 3a322dc15..31306e4f3 100644 --- a/tools/exitsnoop_example.txt +++ b/tools/exitsnoop_example.txt @@ -67,7 +67,7 @@ TIME-UTC LABEL PCOMM PID PPID TID AGE(s) EXIT_CODE USAGE message: # ./exitsnoop.py -h -usage: exitsnoop.py [-h] [-t] [--utc] [-p PID] [--label LABEL] [-x] +usage: exitsnoop.py [-h] [-t] [--utc] [-p PID] [--label LABEL] [-x] [--per-thread] Trace all process termination (exit, fatal signal) @@ -78,6 +78,7 @@ optional arguments: -p PID, --pid PID trace this PID only --label LABEL label each line -x, --failed trace only fails, exclude exit(0) + --per-thread trace per thread termination examples: exitsnoop # trace all process termination @@ -86,6 +87,7 @@ examples: exitsnoop --utc # include timestamps (UTC) exitsnoop -p 181 # only trace PID 181 exitsnoop --label=exit # label each output line with 'exit' + exitsnoop --per-thread # trace per thread termination Exit status: From 112f5291c63fe6160685160c552ae2b03deb3d1e Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Wed, 20 May 2020 10:46:33 -0500 Subject: [PATCH 120/278] bcc: Error out when bpf_probe_read_user is not present 1. For architecture with overlapping address space, error out when bpf_probe_read_user is not available. 2. For arch with non overlapping address space, if bpf_probe_read_user is not available bpf_probe_read_user is implicitly converted to bpf_probe_read. 3. Use bpf_probe_read_kernel instead of bpf_probe_read. When bpf_probe_read_kernel is not available, fallback to bpf_probe_read. If bpf_probe_read is not available, then bcc would fail anyways. 4. See kernel commit 0ebeea8ca8a4 ("bpf: Restrict bpf_probe_read{, str}() only to archs where they work") Signed-off-by: Sumanth Korikkar Acked-by: Ilya Leoshkevich --- src/cc/frontends/clang/b_frontend_action.cc | 72 +++++++++++++++++---- 1 file changed, 59 insertions(+), 13 deletions(-) diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc index 0deaac05d..3aff2ec4a 100644 --- a/src/cc/frontends/clang/b_frontend_action.cc +++ b/src/cc/frontends/clang/b_frontend_action.cc @@ -83,25 +83,55 @@ const char **get_call_conv(void) { return ret; } -static std::string check_bpf_probe_read_user(llvm::StringRef probe) { +/* Use resolver only once */ +static void *kresolver = NULL; +static void *get_symbol_resolver(void) { + if (!kresolver) + kresolver = bcc_symcache_new(-1, nullptr); + return kresolver; +} + +static std::string check_bpf_probe_read_kernel(void) { + bool is_probe_read_kernel; + void *resolver = get_symbol_resolver(); + uint64_t addr = 0; + is_probe_read_kernel = bcc_symcache_resolve_name(resolver, nullptr, + "bpf_probe_read_kernel", &addr) >= 0 ? true: false; + + /* If bpf_probe_read is not found (ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE) is + * not set in newer kernel, then bcc would anyway fail */ + if (is_probe_read_kernel) + return "bpf_probe_read_kernel"; + else + return "bpf_probe_read"; +} + +static std::string check_bpf_probe_read_user(llvm::StringRef probe, + bool& overlap_addr) { if (probe.str() == "bpf_probe_read_user" || probe.str() == "bpf_probe_read_user_str") { #if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 5, 0) return probe.str(); #else - // Check for probe_user symbols in backported kernels before fallback - void *resolver = bcc_symcache_new(-1, nullptr); + // Check for probe_user symbols in backported kernel before fallback + void *resolver = get_symbol_resolver(); uint64_t addr = 0; bool found = bcc_symcache_resolve_name(resolver, nullptr, "bpf_probe_read_user", &addr) >= 0 ? true: false; if (found) return probe.str(); - if (probe.str() == "bpf_probe_read_user") { + /* For arch with overlapping address space, dont use bpf_probe_read for + * user read. Just error out */ +#if defined(__s390x__) + overlap_addr = true; + return ""; +#endif + + if (probe.str() == "bpf_probe_read_user") return "bpf_probe_read"; - } else { + else return "bpf_probe_read_str"; - } #endif } return ""; @@ -462,7 +492,7 @@ bool ProbeVisitor::VisitUnaryOperator(UnaryOperator *E) { memb_visited_.insert(E); string pre, post; pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));"; - pre += " bpf_probe_read(&_val, sizeof(_val), (u64)"; + pre += " " + check_bpf_probe_read_kernel() + "(&_val, sizeof(_val), (u64)"; post = "); _val; })"; rewriter_.ReplaceText(expansionLoc(E->getOperatorLoc()), 1, pre); rewriter_.InsertTextAfterToken(expansionLoc(GET_ENDLOC(sub)), post); @@ -523,7 +553,7 @@ bool ProbeVisitor::VisitMemberExpr(MemberExpr *E) { string base_type = base->getType()->getPointeeType().getAsString(); string pre, post; pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));"; - pre += " bpf_probe_read(&_val, sizeof(_val), (u64)&"; + pre += " " + check_bpf_probe_read_kernel() + "(&_val, sizeof(_val), (u64)&"; post = rhs + "); _val; })"; rewriter_.InsertText(expansionLoc(GET_BEGINLOC(E)), pre); rewriter_.ReplaceText(expansionRange(SourceRange(member, GET_ENDLOC(E))), post); @@ -574,7 +604,7 @@ bool ProbeVisitor::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { return true; pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));"; - pre += " bpf_probe_read(&_val, sizeof(_val), (u64)(("; + pre += " " + check_bpf_probe_read_kernel() + "(&_val, sizeof(_val), (u64)(("; if (isMemberDereference(base)) { pre += "&"; // If the base of the array subscript is a member dereference, we'll rewrite @@ -707,7 +737,8 @@ void BTypeVisitor::genParamIndirectAssign(FunctionDecl *D, string& preamble, size_t d = idx - 1; const char *reg = calling_conv_regs[d]; preamble += "\n " + text + ";"; - preamble += " bpf_probe_read(&" + arg->getName().str() + ", sizeof(" + + preamble += " " + check_bpf_probe_read_kernel(); + preamble += "(&" + arg->getName().str() + ", sizeof(" + arg->getName().str() + "), &" + new_ctx + "->" + string(reg) + ");"; } @@ -974,8 +1005,14 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) { if (!Decl) return true; string text; - - std::string probe = check_bpf_probe_read_user(Decl->getName()); + + bool overlap_addr = false; + std::string probe = check_bpf_probe_read_user(Decl->getName(), + overlap_addr); + if (overlap_addr) { + error(GET_BEGINLOC(Call), "bpf_probe_read_user not found. Use latest kernel"); + return false; + } if (probe != "") { vector probe_args; @@ -1036,7 +1073,13 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) { text += "_bpf_readarg_" + current_fn_ + "_" + args[0] + "(" + args[1] + ", &__addr, sizeof(__addr));"; - text += check_bpf_probe_read_user(StringRef("bpf_probe_read_user")); + bool overlap_addr = false; + text += check_bpf_probe_read_user(StringRef("bpf_probe_read_user"), + overlap_addr); + if (overlap_addr) { + error(GET_BEGINLOC(Call), "bpf_probe_read_user not found. Use latest kernel"); + return false; + } text += "(" + args[2] + ", " + args[3] + ", (void *)__addr);"; text += "})"; @@ -1496,6 +1539,9 @@ void BTypeConsumer::HandleTranslationUnit(ASTContext &Context) { btype_visitor_.TraverseDecl(D); } + + if (kresolver) + bcc_free_symcache(kresolver, -1); } BFrontendAction::BFrontendAction(llvm::raw_ostream &os, unsigned flags, From 7f6066d250efa138419c16c150ad8711d6528d29 Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Wed, 20 May 2020 10:49:56 -0500 Subject: [PATCH 121/278] bcc/tools: Replace bpf_probe_read with bpf_probe_read_kernel It is recommended to use bpf_probe_read_kernel_{str} in the bpf tools. See kernel commit 0ebeea8ca8a4 ("bpf: Restrict bpf_probe_read{, str}() only to archs where they work") Signed-off-by: Sumanth Korikkar Acked-by: Ilya Leoshkevich --- src/cc/libbpf.c | 4 ++-- tests/python/test_clang.py | 10 +++++----- tools/argdist.py | 4 ++-- tools/bindsnoop.py | 8 ++++---- tools/biolatency.py | 2 +- tools/biosnoop.lua | 4 ++-- tools/biosnoop.py | 4 ++-- tools/bitesize.py | 2 +- tools/btrfsslower.py | 2 +- tools/compactsnoop.py | 10 +++++----- tools/dbslower.py | 4 ++-- tools/dcsnoop.py | 4 ++-- tools/deadlock.c | 2 +- tools/drsnoop.py | 6 +++--- tools/ext4slower.py | 2 +- tools/filelife.py | 2 +- tools/fileslower.py | 6 +++--- tools/filetop.py | 2 +- tools/funcslower.py | 2 +- tools/gethostlatency.py | 4 ++-- tools/hardirqs.py | 6 +++--- tools/killsnoop.py | 2 +- tools/mdflush.py | 2 +- tools/memleak.py | 2 +- tools/nfsslower.py | 8 ++++---- tools/oomkill.py | 2 +- tools/opensnoop.py | 2 +- tools/runqslower.py | 16 ++++++++-------- tools/slabratetop.py | 2 +- tools/sofdsnoop.py | 2 +- tools/solisten.py | 2 +- tools/tcpaccept.py | 6 +++--- tools/tcpconnect.py | 8 ++++---- tools/tcpconnlat.py | 4 ++-- tools/tcpdrop.py | 4 ++-- tools/tcplife.lua | 8 ++++---- tools/tcplife.py | 12 ++++++------ tools/tcpretrans.py | 8 ++++---- tools/tcpstates.py | 14 +++++++------- tools/tcptop.py | 8 ++++---- tools/tcptracer.py | 8 ++++---- tools/trace.py | 14 +++++++------- tools/ttysnoop.py | 2 +- tools/wakeuptime.py | 2 +- tools/xfsslower.py | 2 +- tools/zfsslower.py | 2 +- 46 files changed, 116 insertions(+), 116 deletions(-) diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index fcb22014a..5138d27f2 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -385,8 +385,8 @@ static void bpf_print_hints(int ret, char *log) if (strstr(log, "invalid mem access 'inv'") != NULL) { fprintf(stderr, "HINT: The invalid mem access 'inv' error can happen " "if you try to dereference memory without first using " - "bpf_probe_read() to copy it to the BPF stack. Sometimes the " - "bpf_probe_read is automatic by the bcc rewriter, other times " + "bpf_probe_read_kernel() to copy it to the BPF stack. Sometimes the " + "bpf_probe_read_kernel() is automatic by the bcc rewriter, other times " "you'll need to be explicit.\n\n"); } diff --git a/tests/python/test_clang.py b/tests/python/test_clang.py index 886eebedd..5ad0de176 100755 --- a/tests/python/test_clang.py +++ b/tests/python/test_clang.py @@ -80,7 +80,7 @@ def test_probe_read3(self): text = """ #define KBUILD_MODNAME "foo" #include -#define _(P) ({typeof(P) val = 0; bpf_probe_read(&val, sizeof(val), &P); val;}) +#define _(P) ({typeof(P) val = 0; bpf_probe_read_kernel(&val, sizeof(val), &P); val;}) int count_tcp(struct pt_regs *ctx, struct sk_buff *skb) { return _(TCP_SKB_CB(skb)->tcp_gso_size); } @@ -92,7 +92,7 @@ def test_probe_read4(self): text = """ #define KBUILD_MODNAME "foo" #include -#define _(P) ({typeof(P) val = 0; bpf_probe_read(&val, sizeof(val), &P); val;}) +#define _(P) ({typeof(P) val = 0; bpf_probe_read_kernel(&val, sizeof(val), &P); val;}) int test(struct pt_regs *ctx, struct sk_buff *skb) { return _(TCP_SKB_CB(skb)->tcp_gso_size) + skb->protocol; } @@ -111,7 +111,7 @@ def test_probe_read_whitelist1(self): // failing below statement // return TCP_SKB_CB(skb)->tcp_gso_size; u16 val = 0; - bpf_probe_read(&val, sizeof(val), &(TCP_SKB_CB(skb)->tcp_gso_size)); + bpf_probe_read_kernel(&val, sizeof(val), &(TCP_SKB_CB(skb)->tcp_gso_size)); return val; } """ @@ -129,7 +129,7 @@ def test_probe_read_whitelist2(self): // failing below statement // return TCP_SKB_CB(skb)->tcp_gso_size; u16 val = 0; - bpf_probe_read(&val, sizeof(val), &(TCP_SKB_CB(skb)->tcp_gso_size)); + bpf_probe_read_kernel(&val, sizeof(val), &(TCP_SKB_CB(skb)->tcp_gso_size)); return val + skb->protocol; } """ @@ -1144,7 +1144,7 @@ def test_no_probe_read_addrof(self): #include static inline int test_help(__be16 *addr) { __be16 val = 0; - bpf_probe_read(&val, sizeof(val), addr); + bpf_probe_read_kernel(&val, sizeof(val), addr); return val; } int test(struct pt_regs *ctx) { diff --git a/tools/argdist.py b/tools/argdist.py index 0bc1414e0..88da0d841 100755 --- a/tools/argdist.py +++ b/tools/argdist.py @@ -42,7 +42,7 @@ def _parse_signature(self): param_name = param[index + 1:].strip() self.param_types[param_name] = param_type # Maintain list of user params. Then later decide to - # switch to bpf_probe_read or bpf_probe_read_user. + # switch to bpf_probe_read_kernel or bpf_probe_read_user. if "__user" in param_type.split(): self.probe_user_list.add(param_name) @@ -299,7 +299,7 @@ def _generate_field_assignment(self, i): self.exprs[i] in self.probe_user_list: probe_readfunc = "bpf_probe_read_user" else: - probe_readfunc = "bpf_probe_read" + probe_readfunc = "bpf_probe_read_kernel" return (text + " %s(&__key.v%d.s," + " sizeof(__key.v%d.s), (void *)%s);\n") % \ (probe_readfunc, i, i, self.exprs[i]) diff --git a/tools/bindsnoop.py b/tools/bindsnoop.py index de569c251..e08ebf857 100755 --- a/tools/bindsnoop.py +++ b/tools/bindsnoop.py @@ -215,7 +215,7 @@ struct inet_sock *sockp = (struct inet_sock *)skp; u16 sport = 0; - bpf_probe_read(&sport, sizeof(sport), &sockp->inet_sport); + bpf_probe_read_kernel(&sport, sizeof(sport), &sockp->inet_sport); sport = ntohs(sport); FILTER_PORT @@ -296,7 +296,7 @@ struct ipv4_bind_data_t data4 = {.pid = pid, .ip = ipver}; data4.uid = bpf_get_current_uid_gid(); data4.ts_us = bpf_ktime_get_ns() / 1000; - bpf_probe_read( + bpf_probe_read_kernel( &data4.saddr, sizeof(data4.saddr), &sockp->inet_saddr); data4.return_code = ret; data4.sport = sport; @@ -309,7 +309,7 @@ 'ipv6': { 'count': """ struct ipv6_flow_key_t flow_key = {}; - bpf_probe_read(&flow_key.saddr, sizeof(flow_key.saddr), + bpf_probe_read_kernel(&flow_key.saddr, sizeof(flow_key.saddr), skp->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); flow_key.sport = sport; ipv6_count.increment(flow_key);""", @@ -317,7 +317,7 @@ struct ipv6_bind_data_t data6 = {.pid = pid, .ip = ipver}; data6.uid = bpf_get_current_uid_gid(); data6.ts_us = bpf_ktime_get_ns() / 1000; - bpf_probe_read(&data6.saddr, sizeof(data6.saddr), + bpf_probe_read_kernel(&data6.saddr, sizeof(data6.saddr), skp->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); data6.return_code = ret; data6.sport = sport; diff --git a/tools/biolatency.py b/tools/biolatency.py index 86d994370..c608dcb5d 100755 --- a/tools/biolatency.py +++ b/tools/biolatency.py @@ -112,7 +112,7 @@ bpf_text = bpf_text.replace('STORE', 'disk_key_t key = {.slot = bpf_log2l(delta)}; ' + 'void *__tmp = (void *)req->rq_disk->disk_name; ' + - 'bpf_probe_read(&key.disk, sizeof(key.disk), __tmp); ' + + 'bpf_probe_read_kernel(&key.disk, sizeof(key.disk), __tmp); ' + 'dist.increment(key);') elif args.flags: bpf_text = bpf_text.replace('STORAGE', diff --git a/tools/biosnoop.lua b/tools/biosnoop.lua index 21261d0b3..8d9b6a190 100755 --- a/tools/biosnoop.lua +++ b/tools/biosnoop.lua @@ -90,8 +90,8 @@ int trace_req_completion(struct pt_regs *ctx, struct request *req) data.pid = valp->pid; data.len = req->__data_len; data.sector = req->__sector; - bpf_probe_read(&data.name, sizeof(data.name), valp->name); - bpf_probe_read(&data.disk_name, sizeof(data.disk_name), + bpf_probe_read_kernel(&data.name, sizeof(data.name), valp->name); + bpf_probe_read_kernel(&data.disk_name, sizeof(data.disk_name), req->rq_disk->disk_name); } diff --git a/tools/biosnoop.py b/tools/biosnoop.py index b550281c8..ff9b842bc 100755 --- a/tools/biosnoop.py +++ b/tools/biosnoop.py @@ -117,9 +117,9 @@ data.pid = valp->pid; data.len = req->__data_len; data.sector = req->__sector; - bpf_probe_read(&data.name, sizeof(data.name), valp->name); + bpf_probe_read_kernel(&data.name, sizeof(data.name), valp->name); struct gendisk *rq_disk = req->rq_disk; - bpf_probe_read(&data.disk_name, sizeof(data.disk_name), + bpf_probe_read_kernel(&data.disk_name, sizeof(data.disk_name), rq_disk->disk_name); } diff --git a/tools/bitesize.py b/tools/bitesize.py index f4cea7cdd..6ae71dcf8 100755 --- a/tools/bitesize.py +++ b/tools/bitesize.py @@ -30,7 +30,7 @@ TRACEPOINT_PROBE(block, block_rq_issue) { struct proc_key_t key = {.slot = bpf_log2l(args->bytes / 1024)}; - bpf_probe_read(&key.name, sizeof(key.name), args->comm); + bpf_probe_read_kernel(&key.name, sizeof(key.name), args->comm); dist.increment(key); return 0; } diff --git a/tools/btrfsslower.py b/tools/btrfsslower.py index b30880a78..9e46243a4 100755 --- a/tools/btrfsslower.py +++ b/tools/btrfsslower.py @@ -233,7 +233,7 @@ qs = de->d_name; if (qs.len == 0) return 0; - bpf_probe_read(&data.file, sizeof(data.file), (void *)qs.name); + bpf_probe_read_kernel(&data.file, sizeof(data.file), (void *)qs.name); // output events.perf_submit(ctx, &data, sizeof(data)); diff --git a/tools/compactsnoop.py b/tools/compactsnoop.py index 7f9ce7ee3..71ef95b08 100755 --- a/tools/compactsnoop.py +++ b/tools/compactsnoop.py @@ -108,7 +108,7 @@ static inline int zone_to_nid_(struct zone *zone) { int node; - bpf_probe_read(&node, sizeof(node), &zone->node); + bpf_probe_read_kernel(&node, sizeof(node), &zone->node); return node; } #else @@ -122,7 +122,7 @@ static inline int zone_idx_(struct zone *zone) { struct pglist_data *zone_pgdat = NULL; - bpf_probe_read(&zone_pgdat, sizeof(zone_pgdat), &zone->zone_pgdat); + bpf_probe_read_kernel(&zone_pgdat, sizeof(zone_pgdat), &zone->zone_pgdat); return zone - zone_pgdat->node_zones; } @@ -132,13 +132,13 @@ u64 _watermark[NR_WMARK] = {}; u64 watermark_boost = 0; - bpf_probe_read(&_watermark, sizeof(_watermark), &zone->_watermark); - bpf_probe_read(&watermark_boost, sizeof(watermark_boost), + bpf_probe_read_kernel(&_watermark, sizeof(_watermark), &zone->_watermark); + bpf_probe_read_kernel(&watermark_boost, sizeof(watermark_boost), &zone->watermark_boost); valp->min = _watermark[WMARK_MIN] + watermark_boost; valp->low = _watermark[WMARK_LOW] + watermark_boost; valp->high = _watermark[WMARK_HIGH] + watermark_boost; - bpf_probe_read(&valp->free, sizeof(valp->free), + bpf_probe_read_kernel(&valp->free, sizeof(valp->free), &zone->vm_stat[NR_FREE_PAGES]); } #endif diff --git a/tools/dbslower.py b/tools/dbslower.py index ffbb5e1b6..9db225fde 100755 --- a/tools/dbslower.py +++ b/tools/dbslower.py @@ -158,8 +158,8 @@ data.timestamp = tempp->timestamp; data.duration = delta; #if defined(MYSQL56) || defined(MYSQL57) - // We already copied string to the bpf stack. Hence use bpf_probe_read() - bpf_probe_read(&data.query, sizeof(data.query), tempp->query); + // We already copied string to the bpf stack. Hence use bpf_probe_read_kernel() + bpf_probe_read_kernel(&data.query, sizeof(data.query), tempp->query); #else // USDT - we didnt copy string to the bpf stack before. bpf_probe_read_user(&data.query, sizeof(data.query), tempp->query); diff --git a/tools/dcsnoop.py b/tools/dcsnoop.py index 331ee30e1..7c50152f3 100755 --- a/tools/dcsnoop.py +++ b/tools/dcsnoop.py @@ -84,7 +84,7 @@ .type = type, }; bpf_get_current_comm(&data.comm, sizeof(data.comm)); - bpf_probe_read(&data.filename, sizeof(data.filename), name); + bpf_probe_read_kernel(&data.filename, sizeof(data.filename), name); events.perf_submit(ctx, &data, sizeof(data)); } @@ -102,7 +102,7 @@ struct entry_t entry = {}; const char *fname = name->name; if (fname) { - bpf_probe_read(&entry.name, sizeof(entry.name), (void *)fname); + bpf_probe_read_kernel(&entry.name, sizeof(entry.name), (void *)fname); } entrybypid.update(&pid, &entry); return 0; diff --git a/tools/deadlock.c b/tools/deadlock.c index a6a6d9155..b34a207dd 100644 --- a/tools/deadlock.c +++ b/tools/deadlock.c @@ -164,7 +164,7 @@ int trace_mutex_release(struct pt_regs *ctx, void *mutex_addr) { // invalid memory access on `leaf->held_mutexes[i]` below. On newer kernels, // we can avoid making this extra copy in `value` and use `leaf` directly. struct thread_to_held_mutex_leaf_t value = {}; - bpf_probe_read(&value, sizeof(struct thread_to_held_mutex_leaf_t), leaf); + bpf_probe_read_user(&value, sizeof(struct thread_to_held_mutex_leaf_t), leaf); #pragma unroll for (int i = 0; i < MAX_HELD_MUTEXES; ++i) { diff --git a/tools/drsnoop.py b/tools/drsnoop.py index 3dc8d7abe..e4ea92224 100755 --- a/tools/drsnoop.py +++ b/tools/drsnoop.py @@ -128,7 +128,7 @@ def K(x): if (bpf_get_current_comm(&val.name, sizeof(val.name)) == 0) { val.id = id; val.ts = bpf_ktime_get_ns(); - bpf_probe_read(&val.vm_stat, sizeof(val.vm_stat), (const void *)%s); + bpf_probe_read_kernel(&val.vm_stat, sizeof(val.vm_stat), (const void *)%s); start.update(&id, &val); } return 0; @@ -150,8 +150,8 @@ def K(x): data.ts = ts / 1000; data.id = valp->id; data.uid = bpf_get_current_uid_gid(); - bpf_probe_read(&data.name, sizeof(data.name), valp->name); - bpf_probe_read(&data.vm_stat, sizeof(data.vm_stat), valp->vm_stat); + bpf_probe_read_kernel(&data.name, sizeof(data.name), valp->name); + bpf_probe_read_kernel(&data.vm_stat, sizeof(data.vm_stat), valp->vm_stat); data.nr_reclaimed = args->nr_reclaimed; events.perf_submit(args, &data, sizeof(data)); diff --git a/tools/ext4slower.py b/tools/ext4slower.py index 0524f22e7..90663a585 100755 --- a/tools/ext4slower.py +++ b/tools/ext4slower.py @@ -226,7 +226,7 @@ qs = de->d_name; if (qs.len == 0) return 0; - bpf_probe_read(&data.file, sizeof(data.file), (void *)qs.name); + bpf_probe_read_kernel(&data.file, sizeof(data.file), (void *)qs.name); // output events.perf_submit(ctx, &data, sizeof(data)); diff --git a/tools/filelife.py b/tools/filelife.py index 38b6b12c4..9b7562f4c 100755 --- a/tools/filelife.py +++ b/tools/filelife.py @@ -90,7 +90,7 @@ if (bpf_get_current_comm(&data.comm, sizeof(data.comm)) == 0) { data.pid = pid; data.delta = delta; - bpf_probe_read(&data.fname, sizeof(data.fname), d_name.name); + bpf_probe_read_kernel(&data.fname, sizeof(data.fname), d_name.name); } events.perf_submit(ctx, &data, sizeof(data)); diff --git a/tools/fileslower.py b/tools/fileslower.py index 31e3adf9a..21b0e1c8f 100755 --- a/tools/fileslower.py +++ b/tools/fileslower.py @@ -112,7 +112,7 @@ struct qstr d_name = de->d_name; val.name_len = d_name.len; - bpf_probe_read(&val.name, sizeof(val.name), d_name.name); + bpf_probe_read_kernel(&val.name, sizeof(val.name), d_name.name); bpf_get_current_comm(&val.comm, sizeof(val.comm)); entryinfo.update(&pid, &val); @@ -159,8 +159,8 @@ data.sz = valp->sz; data.delta_us = delta_us; data.name_len = valp->name_len; - bpf_probe_read(&data.name, sizeof(data.name), valp->name); - bpf_probe_read(&data.comm, sizeof(data.comm), valp->comm); + bpf_probe_read_kernel(&data.name, sizeof(data.name), valp->name); + bpf_probe_read_kernel(&data.comm, sizeof(data.comm), valp->comm); events.perf_submit(ctx, &data, sizeof(data)); return 0; diff --git a/tools/filetop.py b/tools/filetop.py index dbe7a7da4..34cfebc84 100755 --- a/tools/filetop.py +++ b/tools/filetop.py @@ -108,7 +108,7 @@ def signal_ignore(signal_value, frame): struct info_t info = {.pid = pid}; bpf_get_current_comm(&info.comm, sizeof(info.comm)); info.name_len = d_name.len; - bpf_probe_read(&info.name, sizeof(info.name), d_name.name); + bpf_probe_read_kernel(&info.name, sizeof(info.name), d_name.name); if (S_ISREG(mode)) { info.type = 'R'; } else if (S_ISSOCK(mode)) { diff --git a/tools/funcslower.py b/tools/funcslower.py index 9acd35d12..ffa618d73 100755 --- a/tools/funcslower.py +++ b/tools/funcslower.py @@ -206,7 +206,7 @@ #endif #ifdef GRAB_ARGS - bpf_probe_read(&data.args[0], sizeof(data.args), entryp->args); + bpf_probe_read_kernel(&data.args[0], sizeof(data.args), entryp->args); #endif bpf_get_current_comm(&data.comm, sizeof(data.comm)); events.perf_submit(ctx, &data, sizeof(data)); diff --git a/tools/gethostlatency.py b/tools/gethostlatency.py index a6b80801a..0ba5a1eb2 100755 --- a/tools/gethostlatency.py +++ b/tools/gethostlatency.py @@ -86,8 +86,8 @@ if (valp == 0) return 0; // missed start - bpf_probe_read(&data.comm, sizeof(data.comm), valp->comm); - bpf_probe_read(&data.host, sizeof(data.host), (void *)valp->host); + bpf_probe_read_kernel(&data.comm, sizeof(data.comm), valp->comm); + bpf_probe_read_kernel(&data.host, sizeof(data.host), (void *)valp->host); data.pid = valp->pid; data.delta = tsp - valp->ts; events.perf_submit(ctx, &data, sizeof(data)); diff --git a/tools/hardirqs.py b/tools/hardirqs.py index 589a890dd..fda804d49 100755 --- a/tools/hardirqs.py +++ b/tools/hardirqs.py @@ -83,7 +83,7 @@ char *name = (char *)action->name; irq_key_t key = {.slot = 0 /* ignore */}; - bpf_probe_read(&key.name, sizeof(key.name), name); + bpf_probe_read_kernel(&key.name, sizeof(key.name), name); dist.increment(key); return 0; @@ -129,12 +129,12 @@ if args.dist: bpf_text = bpf_text.replace('STORE', 'irq_key_t key = {.slot = bpf_log2l(delta / %d)};' % factor + - 'bpf_probe_read(&key.name, sizeof(key.name), name);' + + 'bpf_probe_read_kernel(&key.name, sizeof(key.name), name);' + 'dist.increment(key);') else: bpf_text = bpf_text.replace('STORE', 'irq_key_t key = {.slot = 0 /* ignore */};' + - 'bpf_probe_read(&key.name, sizeof(key.name), name);' + + 'bpf_probe_read_kernel(&key.name, sizeof(key.name), name);' + 'dist.increment(key, delta);') if debug or args.ebpf: print(bpf_text) diff --git a/tools/killsnoop.py b/tools/killsnoop.py index 2fb1dcb5d..977c6bb1d 100755 --- a/tools/killsnoop.py +++ b/tools/killsnoop.py @@ -87,7 +87,7 @@ return 0; } - bpf_probe_read(&data.comm, sizeof(data.comm), valp->comm); + bpf_probe_read_kernel(&data.comm, sizeof(data.comm), valp->comm); data.pid = pid; data.tpid = valp->tpid; data.ret = PT_REGS_RC(ctx); diff --git a/tools/mdflush.py b/tools/mdflush.py index f1c68aee9..2abe15cfc 100755 --- a/tools/mdflush.py +++ b/tools/mdflush.py @@ -47,7 +47,7 @@ #else struct gendisk *bi_disk = bio->bi_bdev->bd_disk; #endif - bpf_probe_read(&data.disk, sizeof(data.disk), bi_disk->disk_name); + bpf_probe_read_kernel(&data.disk, sizeof(data.disk), bi_disk->disk_name); events.perf_submit(ctx, &data, sizeof(data)); return 0; } diff --git a/tools/memleak.py b/tools/memleak.py index 9fa6805c6..539901943 100755 --- a/tools/memleak.py +++ b/tools/memleak.py @@ -287,7 +287,7 @@ def run_command_get_pid(command): memptrs.delete(&pid); - if (bpf_probe_read(&addr, sizeof(void*), (void*)(size_t)*memptr64)) + if (bpf_probe_read_user(&addr, sizeof(void*), (void*)(size_t)*memptr64)) return 0; u64 addr64 = (u64)(size_t)addr; diff --git a/tools/nfsslower.py b/tools/nfsslower.py index 5e344b9b4..6b94f34f7 100755 --- a/tools/nfsslower.py +++ b/tools/nfsslower.py @@ -190,18 +190,18 @@ struct qstr qs = {}; if(type == TRACE_GETATTR) { - bpf_probe_read(&de,sizeof(de), &valp->d); + bpf_probe_read_kernel(&de,sizeof(de), &valp->d); } else { - bpf_probe_read(&de, sizeof(de), &valp->fp->f_path.dentry); + bpf_probe_read_kernel(&de, sizeof(de), &valp->fp->f_path.dentry); } - bpf_probe_read(&qs, sizeof(qs), (void *)&de->d_name); + bpf_probe_read_kernel(&qs, sizeof(qs), (void *)&de->d_name); if (qs.len == 0) return 0; - bpf_probe_read(&data.file, sizeof(data.file), (void *)qs.name); + bpf_probe_read_kernel(&data.file, sizeof(data.file), (void *)qs.name); // output events.perf_submit(ctx, &data, sizeof(data)); return 0; diff --git a/tools/oomkill.py b/tools/oomkill.py index 298e35363..3d6e927b7 100755 --- a/tools/oomkill.py +++ b/tools/oomkill.py @@ -45,7 +45,7 @@ data.tpid = p->pid; data.pages = oc->totalpages; bpf_get_current_comm(&data.fcomm, sizeof(data.fcomm)); - bpf_probe_read(&data.tcomm, sizeof(data.tcomm), p->comm); + bpf_probe_read_kernel(&data.tcomm, sizeof(data.tcomm), p->comm); events.perf_submit(ctx, &data, sizeof(data)); } """ diff --git a/tools/opensnoop.py b/tools/opensnoop.py index a68b13f9a..dffb0212d 100755 --- a/tools/opensnoop.py +++ b/tools/opensnoop.py @@ -151,7 +151,7 @@ // missed entry return 0; } - bpf_probe_read(&data.comm, sizeof(data.comm), valp->comm); + bpf_probe_read_kernel(&data.comm, sizeof(data.comm), valp->comm); bpf_probe_read_user(&data.fname, sizeof(data.fname), (void *)valp->fname); data.id = valp->id; data.ts = tsp / 1000; diff --git a/tools/runqslower.py b/tools/runqslower.py index 8f790602a..c8b832cf3 100755 --- a/tools/runqslower.py +++ b/tools/runqslower.py @@ -28,7 +28,7 @@ # Licensed under the Apache License, Version 2.0 (the "License") # # 02-May-2018 Ivan Babrou Created this. -# 18-Nov-2019 Gergely Bod BUG fix: Use bpf_probe_read_str() to extract the +# 18-Nov-2019 Gergely Bod BUG fix: Use bpf_probe_read_kernel_str() to extract the # process name from 'task_struct* next' in raw tp code. # bpf_get_current_comm() operates on the current task # which might already be different than 'next'. @@ -164,8 +164,8 @@ struct task_struct *p = (struct task_struct *)ctx->args[0]; u32 tgid, pid; - bpf_probe_read(&tgid, sizeof(tgid), &p->tgid); - bpf_probe_read(&pid, sizeof(pid), &p->pid); + bpf_probe_read_kernel(&tgid, sizeof(tgid), &p->tgid); + bpf_probe_read_kernel(&pid, sizeof(pid), &p->pid); return trace_enqueue(tgid, pid); } @@ -178,10 +178,10 @@ long state; // ivcsw: treat like an enqueue event and store timestamp - bpf_probe_read(&state, sizeof(long), (const void *)&prev->state); + bpf_probe_read_kernel(&state, sizeof(long), (const void *)&prev->state); if (state == TASK_RUNNING) { - bpf_probe_read(&tgid, sizeof(prev->tgid), &prev->tgid); - bpf_probe_read(&pid, sizeof(prev->pid), &prev->pid); + bpf_probe_read_kernel(&tgid, sizeof(prev->tgid), &prev->tgid); + bpf_probe_read_kernel(&pid, sizeof(prev->pid), &prev->pid); u64 ts = bpf_ktime_get_ns(); if (pid != 0) { if (!(FILTER_PID) && !(FILTER_TGID)) { @@ -191,7 +191,7 @@ } - bpf_probe_read(&pid, sizeof(next->pid), &next->pid); + bpf_probe_read_kernel(&pid, sizeof(next->pid), &next->pid); u64 *tsp, delta_us; @@ -208,7 +208,7 @@ struct data_t data = {}; data.pid = pid; data.delta_us = delta_us; - bpf_probe_read_str(&data.task, sizeof(data.task), next->comm); + bpf_probe_read_kernel_str(&data.task, sizeof(data.task), next->comm); // output events.perf_submit(ctx, &data, sizeof(data)); diff --git a/tools/slabratetop.py b/tools/slabratetop.py index b947e44e1..066f79d6b 100755 --- a/tools/slabratetop.py +++ b/tools/slabratetop.py @@ -88,7 +88,7 @@ def signal_ignore(signal, frame): { struct info_t info = {}; const char *name = cachep->name; - bpf_probe_read(&info.name, sizeof(info.name), name); + bpf_probe_read_kernel(&info.name, sizeof(info.name), name); struct val_t *valp, zero = {}; valp = counts.lookup_or_try_init(&info, &zero); diff --git a/tools/sofdsnoop.py b/tools/sofdsnoop.py index 6df7fcadc..9bd5bb312 100755 --- a/tools/sofdsnoop.py +++ b/tools/sofdsnoop.py @@ -105,7 +105,7 @@ { val->fd_cnt = min(num, MAX_FD); - if (bpf_probe_read(&val->fd[0], MAX_FD * sizeof(int), data)) + if (bpf_probe_read_kernel(&val->fd[0], MAX_FD * sizeof(int), data)) return -1; events.perf_submit(ctx, val, sizeof(*val)); diff --git a/tools/solisten.py b/tools/solisten.py index fc066d84b..71c0a296f 100755 --- a/tools/solisten.py +++ b/tools/solisten.py @@ -111,7 +111,7 @@ if (family == AF_INET) { evt.laddr[0] = inet->inet_rcv_saddr; } else if (family == AF_INET6) { - bpf_probe_read(evt.laddr, sizeof(evt.laddr), + bpf_probe_read_kernel(evt.laddr, sizeof(evt.laddr), sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); } diff --git a/tools/tcpaccept.py b/tools/tcpaccept.py index 4aa7fd7a1..1a5f1c7b5 100755 --- a/tools/tcpaccept.py +++ b/tools/tcpaccept.py @@ -117,7 +117,7 @@ // because the sk_wmem_queued is not following the bitfield of sk_protocol. // And the following member is sk_gso_max_segs. // So, we can use this: - // bpf_probe_read(&protocol, 1, (void *)((u64)&newsk->sk_gso_max_segs) - 3); + // bpf_probe_read_kernel(&protocol, 1, (void *)((u64)&newsk->sk_gso_max_segs) - 3); // In order to diff the pre-4.10 and 4.10+ ,introduce the variables gso_max_segs_offset,sk_lingertime, // sk_lingertime is closed to the gso_max_segs_offset,and // the offset between the two members is 4 @@ -167,9 +167,9 @@ } else if (family == AF_INET6) { struct ipv6_data_t data6 = {.pid = pid, .ip = 6}; data6.ts_us = bpf_ktime_get_ns() / 1000; - bpf_probe_read(&data6.saddr, sizeof(data6.saddr), + bpf_probe_read_kernel(&data6.saddr, sizeof(data6.saddr), &newsk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&data6.daddr, sizeof(data6.daddr), + bpf_probe_read_kernel(&data6.daddr, sizeof(data6.daddr), &newsk->__sk_common.skc_v6_daddr.in6_u.u6_addr32); data6.lport = lport; data6.dport = dport; diff --git a/tools/tcpconnect.py b/tools/tcpconnect.py index 40878eea0..8cb6e4d82 100755 --- a/tools/tcpconnect.py +++ b/tools/tcpconnect.py @@ -205,9 +205,9 @@ { 'count' : """ struct ipv6_flow_key_t flow_key = {}; - bpf_probe_read(&flow_key.saddr, sizeof(flow_key.saddr), + bpf_probe_read_kernel(&flow_key.saddr, sizeof(flow_key.saddr), skp->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&flow_key.daddr, sizeof(flow_key.daddr), + bpf_probe_read_kernel(&flow_key.daddr, sizeof(flow_key.daddr), skp->__sk_common.skc_v6_daddr.in6_u.u6_addr32); flow_key.dport = ntohs(dport); ipv6_count.increment(flow_key);""", @@ -216,9 +216,9 @@ struct ipv6_data_t data6 = {.pid = pid, .ip = ipver}; data6.uid = bpf_get_current_uid_gid(); data6.ts_us = bpf_ktime_get_ns() / 1000; - bpf_probe_read(&data6.saddr, sizeof(data6.saddr), + bpf_probe_read_kernel(&data6.saddr, sizeof(data6.saddr), skp->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&data6.daddr, sizeof(data6.daddr), + bpf_probe_read_kernel(&data6.daddr, sizeof(data6.daddr), skp->__sk_common.skc_v6_daddr.in6_u.u6_addr32); data6.dport = ntohs(dport); bpf_get_current_comm(&data6.task, sizeof(data6.task)); diff --git a/tools/tcpconnlat.py b/tools/tcpconnlat.py index be6bbbfa1..e28a43a71 100755 --- a/tools/tcpconnlat.py +++ b/tools/tcpconnlat.py @@ -160,9 +160,9 @@ def positive_float(val): } else /* AF_INET6 */ { struct ipv6_data_t data6 = {.pid = infop->pid, .ip = 6}; data6.ts_us = now / 1000; - bpf_probe_read(&data6.saddr, sizeof(data6.saddr), + bpf_probe_read_kernel(&data6.saddr, sizeof(data6.saddr), skp->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&data6.daddr, sizeof(data6.daddr), + bpf_probe_read_kernel(&data6.daddr, sizeof(data6.daddr), skp->__sk_common.skc_v6_daddr.in6_u.u6_addr32); data6.dport = ntohs(dport); data6.delta_us = delta_us; diff --git a/tools/tcpdrop.py b/tools/tcpdrop.py index 14515f75e..aceff8715 100755 --- a/tools/tcpdrop.py +++ b/tools/tcpdrop.py @@ -128,9 +128,9 @@ struct ipv6_data_t data6 = {}; data6.pid = pid; data6.ip = 6; - bpf_probe_read(&data6.saddr, sizeof(data6.saddr), + bpf_probe_read_kernel(&data6.saddr, sizeof(data6.saddr), sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&data6.daddr, sizeof(data6.daddr), + bpf_probe_read_kernel(&data6.daddr, sizeof(data6.daddr), sk->__sk_common.skc_v6_daddr.in6_u.u6_addr32); data6.dport = dport; data6.sport = sport; diff --git a/tools/tcplife.lua b/tools/tcplife.lua index 3f4f6afdd..3e18011e1 100755 --- a/tools/tcplife.lua +++ b/tools/tcplife.lua @@ -154,7 +154,7 @@ int trace_tcp_set_state(struct pt_regs *ctx, struct sock *sk, int state) if (mep == 0) { bpf_get_current_comm(&data4.task, sizeof(data4.task)); } else { - bpf_probe_read(&data4.task, sizeof(data4.task), (void *)mep->task); + bpf_probe_read_kernel(&data4.task, sizeof(data4.task), (void *)mep->task); } ipv4_events.perf_submit(ctx, &data4, sizeof(data4)); @@ -162,9 +162,9 @@ int trace_tcp_set_state(struct pt_regs *ctx, struct sock *sk, int state) struct ipv6_data_t data6 = {.span_us = delta_us, .rx_b = rx_b, .tx_b = tx_b}; data6.ts_us = bpf_ktime_get_ns() / 1000; - bpf_probe_read(&data6.saddr, sizeof(data6.saddr), + bpf_probe_read_kernel(&data6.saddr, sizeof(data6.saddr), sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&data6.daddr, sizeof(data6.daddr), + bpf_probe_read_kernel(&data6.daddr, sizeof(data6.daddr), sk->__sk_common.skc_v6_daddr.in6_u.u6_addr32); // a workaround until data6 compiles with separate lport/dport data6.ports = ntohs(dport) + ((0ULL + lport) << 32); @@ -172,7 +172,7 @@ int trace_tcp_set_state(struct pt_regs *ctx, struct sock *sk, int state) if (mep == 0) { bpf_get_current_comm(&data6.task, sizeof(data6.task)); } else { - bpf_probe_read(&data6.task, sizeof(data6.task), (void *)mep->task); + bpf_probe_read_kernel(&data6.task, sizeof(data6.task), (void *)mep->task); } ipv6_events.perf_submit(ctx, &data6, sizeof(data6)); } diff --git a/tools/tcplife.py b/tools/tcplife.py index 980eebba0..1600a3c7f 100755 --- a/tools/tcplife.py +++ b/tools/tcplife.py @@ -206,7 +206,7 @@ if (mep == 0) { bpf_get_current_comm(&data4.task, sizeof(data4.task)); } else { - bpf_probe_read(&data4.task, sizeof(data4.task), (void *)mep->task); + bpf_probe_read_kernel(&data4.task, sizeof(data4.task), (void *)mep->task); } ipv4_events.perf_submit(ctx, &data4, sizeof(data4)); @@ -216,9 +216,9 @@ data6.rx_b = rx_b; data6.tx_b = tx_b; data6.ts_us = bpf_ktime_get_ns() / 1000; - bpf_probe_read(&data6.saddr, sizeof(data6.saddr), + bpf_probe_read_kernel(&data6.saddr, sizeof(data6.saddr), sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&data6.daddr, sizeof(data6.daddr), + bpf_probe_read_kernel(&data6.daddr, sizeof(data6.daddr), sk->__sk_common.skc_v6_daddr.in6_u.u6_addr32); // a workaround until data6 compiles with separate lport/dport data6.ports = dport + ((0ULL + lport) << 32); @@ -226,7 +226,7 @@ if (mep == 0) { bpf_get_current_comm(&data6.task, sizeof(data6.task)); } else { - bpf_probe_read(&data6.task, sizeof(data6.task), (void *)mep->task); + bpf_probe_read_kernel(&data6.task, sizeof(data6.task), (void *)mep->task); } ipv6_events.perf_submit(ctx, &data6, sizeof(data6)); } @@ -332,7 +332,7 @@ if (mep == 0) { bpf_get_current_comm(&data4.task, sizeof(data4.task)); } else { - bpf_probe_read(&data4.task, sizeof(data4.task), (void *)mep->task); + bpf_probe_read_kernel(&data4.task, sizeof(data4.task), (void *)mep->task); } ipv4_events.perf_submit(args, &data4, sizeof(data4)); @@ -350,7 +350,7 @@ if (mep == 0) { bpf_get_current_comm(&data6.task, sizeof(data6.task)); } else { - bpf_probe_read(&data6.task, sizeof(data6.task), (void *)mep->task); + bpf_probe_read_kernel(&data6.task, sizeof(data6.task), (void *)mep->task); } ipv6_events.perf_submit(args, &data6, sizeof(data6)); } diff --git a/tools/tcpretrans.py b/tools/tcpretrans.py index 1b2636ae6..7785d9b34 100755 --- a/tools/tcpretrans.py +++ b/tools/tcpretrans.py @@ -180,9 +180,9 @@ { 'count' : """ struct ipv6_flow_key_t flow_key = {}; - bpf_probe_read(&flow_key.saddr, sizeof(flow_key.saddr), + bpf_probe_read_kernel(&flow_key.saddr, sizeof(flow_key.saddr), skp->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&flow_key.daddr, sizeof(flow_key.daddr), + bpf_probe_read_kernel(&flow_key.daddr, sizeof(flow_key.daddr), skp->__sk_common.skc_v6_daddr.in6_u.u6_addr32); // lport is host order flow_key.lport = lport; @@ -192,9 +192,9 @@ data6.pid = pid; data6.ip = 6; data6.type = type; - bpf_probe_read(&data6.saddr, sizeof(data6.saddr), + bpf_probe_read_kernel(&data6.saddr, sizeof(data6.saddr), skp->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&data6.daddr, sizeof(data6.daddr), + bpf_probe_read_kernel(&data6.daddr, sizeof(data6.daddr), skp->__sk_common.skc_v6_daddr.in6_u.u6_addr32); // lport is host order data6.lport = lport; diff --git a/tools/tcpstates.py b/tools/tcpstates.py index 48f878840..7681822e7 100755 --- a/tools/tcpstates.py +++ b/tools/tcpstates.py @@ -178,7 +178,7 @@ // because the sk_wmem_queued is not following the bitfield of sk_protocol. // And the following member is sk_gso_max_segs. // So, we can use this: - // bpf_probe_read(&protocol, 1, (void *)((u64)&newsk->sk_gso_max_segs) - 3); + // bpf_probe_read_kernel(&protocol, 1, (void *)((u64)&newsk->sk_gso_max_segs) - 3); // In order to diff the pre-4.10 and 4.10+ ,introduce the variables gso_max_segs_offset,sk_lingertime, // sk_lingertime is closed to the gso_max_segs_offset,and // the offset between the two members is 4 @@ -189,16 +189,16 @@ if (sk_lingertime_offset - gso_max_segs_offset == 4) // 4.10+ with little endian #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ - bpf_probe_read(&protocol, 1, (void *)((u64)&sk->sk_gso_max_segs) - 3); + bpf_probe_read_kernel(&protocol, 1, (void *)((u64)&sk->sk_gso_max_segs) - 3); else // pre-4.10 with little endian - bpf_probe_read(&protocol, 1, (void *)((u64)&sk->sk_wmem_queued) - 3); + bpf_probe_read_kernel(&protocol, 1, (void *)((u64)&sk->sk_wmem_queued) - 3); #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ // 4.10+ with big endian - bpf_probe_read(&protocol, 1, (void *)((u64)&sk->sk_gso_max_segs) - 1); + bpf_probe_read_kernel(&protocol, 1, (void *)((u64)&sk->sk_gso_max_segs) - 1); else // pre-4.10 with big endian - bpf_probe_read(&protocol, 1, (void *)((u64)&sk->sk_wmem_queued) - 1); + bpf_probe_read_kernel(&protocol, 1, (void *)((u64)&sk->sk_wmem_queued) - 1); #else # error "Fix your compiler's __BYTE_ORDER__?!" #endif @@ -250,9 +250,9 @@ .newstate = state }; data6.skaddr = (u64)sk; data6.ts_us = bpf_ktime_get_ns() / 1000; - bpf_probe_read(&data6.saddr, sizeof(data6.saddr), + bpf_probe_read_kernel(&data6.saddr, sizeof(data6.saddr), sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&data6.daddr, sizeof(data6.daddr), + bpf_probe_read_kernel(&data6.daddr, sizeof(data6.daddr), sk->__sk_common.skc_v6_daddr.in6_u.u6_addr32); // a workaround until data6 compiles with separate lport/dport data6.ports = dport + ((0ULL + lport) << 16); diff --git a/tools/tcptop.py b/tools/tcptop.py index 510c4e86b..e9d0d1a28 100755 --- a/tools/tcptop.py +++ b/tools/tcptop.py @@ -125,9 +125,9 @@ def range_check(string): } else if (family == AF_INET6) { struct ipv6_key_t ipv6_key = {.pid = pid}; - bpf_probe_read(&ipv6_key.saddr, sizeof(ipv6_key.saddr), + bpf_probe_read_kernel(&ipv6_key.saddr, sizeof(ipv6_key.saddr), &sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&ipv6_key.daddr, sizeof(ipv6_key.daddr), + bpf_probe_read_kernel(&ipv6_key.daddr, sizeof(ipv6_key.daddr), &sk->__sk_common.skc_v6_daddr.in6_u.u6_addr32); ipv6_key.lport = sk->__sk_common.skc_num; dport = sk->__sk_common.skc_dport; @@ -171,9 +171,9 @@ def range_check(string): } else if (family == AF_INET6) { struct ipv6_key_t ipv6_key = {.pid = pid}; - bpf_probe_read(&ipv6_key.saddr, sizeof(ipv6_key.saddr), + bpf_probe_read_kernel(&ipv6_key.saddr, sizeof(ipv6_key.saddr), &sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&ipv6_key.daddr, sizeof(ipv6_key.daddr), + bpf_probe_read_kernel(&ipv6_key.daddr, sizeof(ipv6_key.daddr), &sk->__sk_common.skc_v6_daddr.in6_u.u6_addr32); ipv6_key.lport = sk->__sk_common.skc_num; dport = sk->__sk_common.skc_dport; diff --git a/tools/tcptracer.py b/tools/tcptracer.py index 7f67d3381..2e486b152 100755 --- a/tools/tcptracer.py +++ b/tools/tcptracer.py @@ -149,9 +149,9 @@ #ifdef CONFIG_NET_NS net_ns_inum = skp->__sk_common.skc_net.net->ns.inum; #endif - bpf_probe_read(&saddr, sizeof(saddr), + bpf_probe_read_kernel(&saddr, sizeof(saddr), skp->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&daddr, sizeof(daddr), + bpf_probe_read_kernel(&daddr, sizeof(daddr), skp->__sk_common.skc_v6_daddr.in6_u.u6_addr32); ##FILTER_NETNS## @@ -491,9 +491,9 @@ evt6.pid = pid >> 32; evt6.ip = ipver; - bpf_probe_read(&evt6.saddr, sizeof(evt6.saddr), + bpf_probe_read_kernel(&evt6.saddr, sizeof(evt6.saddr), newsk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read(&evt6.daddr, sizeof(evt6.daddr), + bpf_probe_read_kernel(&evt6.daddr, sizeof(evt6.daddr), newsk->__sk_common.skc_v6_daddr.in6_u.u6_addr32); evt6.sport = lport; diff --git a/tools/trace.py b/tools/trace.py index add3f3e85..9c44a4abb 100755 --- a/tools/trace.py +++ b/tools/trace.py @@ -238,17 +238,17 @@ def _parse_action(self, action): aliases_indarg = { "arg1": "({u64 _val; struct pt_regs *_ctx = (struct pt_regs *)PT_REGS_PARM1(ctx);" - " bpf_probe_read(&_val, sizeof(_val), &(PT_REGS_PARM1(_ctx))); _val;})", + " bpf_probe_read_kernel(&_val, sizeof(_val), &(PT_REGS_PARM1(_ctx))); _val;})", "arg2": "({u64 _val; struct pt_regs *_ctx = (struct pt_regs *)PT_REGS_PARM1(ctx);" - " bpf_probe_read(&_val, sizeof(_val), &(PT_REGS_PARM2(_ctx))); _val;})", + " bpf_probe_read_kernel(&_val, sizeof(_val), &(PT_REGS_PARM2(_ctx))); _val;})", "arg3": "({u64 _val; struct pt_regs *_ctx = (struct pt_regs *)PT_REGS_PARM1(ctx);" - " bpf_probe_read(&_val, sizeof(_val), &(PT_REGS_PARM3(_ctx))); _val;})", + " bpf_probe_read_kernel(&_val, sizeof(_val), &(PT_REGS_PARM3(_ctx))); _val;})", "arg4": "({u64 _val; struct pt_regs *_ctx = (struct pt_regs *)PT_REGS_PARM1(ctx);" - " bpf_probe_read(&_val, sizeof(_val), &(PT_REGS_PARM4(_ctx))); _val;})", + " bpf_probe_read_kernel(&_val, sizeof(_val), &(PT_REGS_PARM4(_ctx))); _val;})", "arg5": "({u64 _val; struct pt_regs *_ctx = (struct pt_regs *)PT_REGS_PARM1(ctx);" - " bpf_probe_read(&_val, sizeof(_val), &(PT_REGS_PARM5(_ctx))); _val;})", + " bpf_probe_read_kernel(&_val, sizeof(_val), &(PT_REGS_PARM5(_ctx))); _val;})", "arg6": "({u64 _val; struct pt_regs *_ctx = (struct pt_regs *)PT_REGS_PARM1(ctx);" - " bpf_probe_read(&_val, sizeof(_val), &(PT_REGS_PARM6(_ctx))); _val;})", + " bpf_probe_read_kernel(&_val, sizeof(_val), &(PT_REGS_PARM6(_ctx))); _val;})", } aliases_common = { @@ -399,7 +399,7 @@ def _generate_field_assign(self, idx): text = (" %s %s = 0;\n" + " bpf_usdt_readarg(%s, ctx, &%s);\n") \ % (arg_ctype, expr, expr[3], expr) - probe_read_func = "bpf_probe_read" + probe_read_func = "bpf_probe_read_kernel" if field_type == "s": if self.library: probe_read_func = "bpf_probe_read_user" diff --git a/tools/ttysnoop.py b/tools/ttysnoop.py index 24c118054..b576b7ae5 100755 --- a/tools/ttysnoop.py +++ b/tools/ttysnoop.py @@ -77,7 +77,7 @@ def usage(): if (file->f_inode->i_ino != PTS) return 0; - // bpf_probe_read() can only use a fixed size, so truncate to count + // bpf_probe_read_user() can only use a fixed size, so truncate to count // in user space: struct data_t data = {}; bpf_probe_read_user(&data.buf, BUFSIZE, (void *)buf); diff --git a/tools/wakeuptime.py b/tools/wakeuptime.py index a22245a7b..e13bdf0f7 100755 --- a/tools/wakeuptime.py +++ b/tools/wakeuptime.py @@ -136,7 +136,7 @@ def signal_ignore(signal, frame): struct key_t key = {}; key.w_k_stack_id = stack_traces.get_stackid(ctx, 0); - bpf_probe_read(&key.target, sizeof(key.target), p->comm); + bpf_probe_read_kernel(&key.target, sizeof(key.target), p->comm); bpf_get_current_comm(&key.waker, sizeof(key.waker)); counts.increment(key, delta); diff --git a/tools/xfsslower.py b/tools/xfsslower.py index 9fa125662..f259e495c 100755 --- a/tools/xfsslower.py +++ b/tools/xfsslower.py @@ -196,7 +196,7 @@ struct qstr qs = valp->fp->f_path.dentry->d_name; if (qs.len == 0) return 0; - bpf_probe_read(&data.file, sizeof(data.file), (void *)qs.name); + bpf_probe_read_kernel(&data.file, sizeof(data.file), (void *)qs.name); // output events.perf_submit(ctx, &data, sizeof(data)); diff --git a/tools/zfsslower.py b/tools/zfsslower.py index 2f05b561e..3a61a36ca 100755 --- a/tools/zfsslower.py +++ b/tools/zfsslower.py @@ -192,7 +192,7 @@ struct qstr qs = valp->fp->f_path.dentry->d_name; if (qs.len == 0) return 0; - bpf_probe_read(&data.file, sizeof(data.file), (void *)qs.name); + bpf_probe_read_kernel(&data.file, sizeof(data.file), (void *)qs.name); // output events.perf_submit(ctx, &data, sizeof(data)); From 747e0dd9f0e40ef0fd55291a42f79d4691c344dd Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Wed, 20 May 2020 10:50:13 -0500 Subject: [PATCH 122/278] bcc: Fix user space probe reads with bpf_probe_read_user User space probe reads should be performed using bpf_probe_read_user. Fix this in remaining places. Signed-off-by: Sumanth Korikkar Acked-by: Ilya Leoshkevich --- examples/cpp/pyperf/PyPerfBPFProgram.cc | 42 +++++++++---------- .../usdt_sample/scripts/bpf_text_shared.c | 2 +- src/cc/usdt/usdt_args.cc | 4 +- 3 files changed, 24 insertions(+), 24 deletions(-) diff --git a/examples/cpp/pyperf/PyPerfBPFProgram.cc b/examples/cpp/pyperf/PyPerfBPFProgram.cc index e04f743ee..c2a2c862e 100644 --- a/examples/cpp/pyperf/PyPerfBPFProgram.cc +++ b/examples/cpp/pyperf/PyPerfBPFProgram.cc @@ -139,7 +139,7 @@ static inline __attribute__((__always_inline__)) void* get_thread_state( // p *(PyThreadState*)((struct pthread*)pthread_self())-> // specific_1stblock[autoTLSkey]->data int key; - bpf_probe_read(&key, sizeof(key), (void*)pid_data->tls_key_addr); + bpf_probe_read_user(&key, sizeof(key), (void*)pid_data->tls_key_addr); // This assumes autoTLSkey < 32, which means that the TLS is stored in // pthread->specific_1stblock[autoTLSkey] // 0x310 is offsetof(struct pthread, specific_1stblock), @@ -148,7 +148,7 @@ static inline __attribute__((__always_inline__)) void* get_thread_state( // 'struct pthread' is not in the public API so we have to hardcode // the offsets here void* thread_state; - bpf_probe_read( + bpf_probe_read_user( &thread_state, sizeof(thread_state), tls_base + 0x310 + key * 0x10 + 0x08); @@ -206,7 +206,7 @@ static inline __attribute__((__always_inline__)) int get_gil_state( int gil_locked = 0; void* gil_thread_state = 0; - if (bpf_probe_read( + if (bpf_probe_read_user( &gil_locked, sizeof(gil_locked), (void*)pid_data->gil_locked_addr)) { return GIL_STATE_ERROR; } @@ -218,7 +218,7 @@ static inline __attribute__((__always_inline__)) int get_gil_state( return GIL_STATE_NOT_LOCKED; case 1: // GIL is held by some Thread - bpf_probe_read( + bpf_probe_read_user( &gil_thread_state, sizeof(void*), (void*)pid_data->gil_last_holder_addr); @@ -244,7 +244,7 @@ get_pthread_id_match(void* thread_state, void* tls_base, PidData* pid_data) { uint64_t pthread_self, pthread_created; - bpf_probe_read( + bpf_probe_read_user( &pthread_created, sizeof(pthread_created), thread_state + pid_data->offsets.PyThreadState_thread); @@ -253,7 +253,7 @@ get_pthread_id_match(void* thread_state, void* tls_base, PidData* pid_data) { } // 0x10 = offsetof(struct pthread, header.self) - bpf_probe_read(&pthread_self, sizeof(pthread_self), tls_base + 0x10); + bpf_probe_read_user(&pthread_self, sizeof(pthread_self), tls_base + 0x10); if (pthread_self == 0) { return PTHREAD_ID_ERROR; } @@ -287,7 +287,7 @@ int on_event(struct pt_regs* ctx) { // Get pointer of global PyThreadState, which should belong to the Thread // currently holds the GIL void* global_current_thread = (void*)0; - bpf_probe_read( + bpf_probe_read_user( &global_current_thread, sizeof(global_current_thread), (void*)pid_data->current_state_addr); @@ -331,7 +331,7 @@ int on_event(struct pt_regs* ctx) { if (thread_state != 0) { // Get pointer to top frame from PyThreadState - bpf_probe_read( + bpf_probe_read_user( &state->frame_ptr, sizeof(void*), thread_state + pid_data->offsets.PyThreadState_frame); @@ -356,11 +356,11 @@ static inline __attribute__((__always_inline__)) void get_names( // the name. This is not perfect but there is no better way to figure this // out from the code object. void* args_ptr; - bpf_probe_read( + bpf_probe_read_user( &args_ptr, sizeof(void*), code_ptr + offsets->PyCodeObject_varnames); - bpf_probe_read( + bpf_probe_read_user( &args_ptr, sizeof(void*), args_ptr + offsets->PyTupleObject_item); - bpf_probe_read_str( + bpf_probe_read_user_str( &symbol->name, sizeof(symbol->name), args_ptr + offsets->String_data); // compare strings as ints to save instructions @@ -382,26 +382,26 @@ static inline __attribute__((__always_inline__)) void get_names( // Read class name from $frame->f_localsplus[0]->ob_type->tp_name. if (first_self || first_cls) { void* ptr; - bpf_probe_read( + bpf_probe_read_user( &ptr, sizeof(void*), cur_frame + offsets->PyFrameObject_localsplus); if (first_self) { // we are working with an instance, first we need to get type - bpf_probe_read(&ptr, sizeof(void*), ptr + offsets->PyObject_type); + bpf_probe_read_user(&ptr, sizeof(void*), ptr + offsets->PyObject_type); } - bpf_probe_read(&ptr, sizeof(void*), ptr + offsets->PyTypeObject_name); - bpf_probe_read_str(&symbol->classname, sizeof(symbol->classname), ptr); + bpf_probe_read_user(&ptr, sizeof(void*), ptr + offsets->PyTypeObject_name); + bpf_probe_read_user_str(&symbol->classname, sizeof(symbol->classname), ptr); } void* pystr_ptr; // read PyCodeObject's filename into symbol - bpf_probe_read( + bpf_probe_read_user( &pystr_ptr, sizeof(void*), code_ptr + offsets->PyCodeObject_filename); - bpf_probe_read_str( + bpf_probe_read_user_str( &symbol->file, sizeof(symbol->file), pystr_ptr + offsets->String_data); // read PyCodeObject's name into symbol - bpf_probe_read( + bpf_probe_read_user( &pystr_ptr, sizeof(void*), code_ptr + offsets->PyCodeObject_name); - bpf_probe_read_str( + bpf_probe_read_user_str( &symbol->name, sizeof(symbol->name), pystr_ptr + offsets->String_data); } @@ -419,7 +419,7 @@ static inline __attribute__((__always_inline__)) bool get_frame_data( } void* code_ptr; // read PyCodeObject first, if that fails, then no point reading next frame - bpf_probe_read( + bpf_probe_read_user( &code_ptr, sizeof(void*), cur_frame + offsets->PyFrameObject_code); if (!code_ptr) { return false; @@ -428,7 +428,7 @@ static inline __attribute__((__always_inline__)) bool get_frame_data( get_names(cur_frame, code_ptr, offsets, symbol, ctx); // read next PyFrameObject pointer, update in place - bpf_probe_read( + bpf_probe_read_user( frame_ptr, sizeof(void*), cur_frame + offsets->PyFrameObject_back); return true; diff --git a/examples/usdt_sample/scripts/bpf_text_shared.c b/examples/usdt_sample/scripts/bpf_text_shared.c index d8e7464cb..41d8c9871 100644 --- a/examples/usdt_sample/scripts/bpf_text_shared.c +++ b/examples/usdt_sample/scripts/bpf_text_shared.c @@ -10,7 +10,7 @@ static inline bool filter(char const* inputString) { char needle[] = "FILTER_STRING"; ///< The FILTER STRING is replaced by python code. char haystack[sizeof(needle)] = {}; - bpf_probe_read(&haystack, sizeof(haystack), (void*)inputString); + bpf_probe_read_user(&haystack, sizeof(haystack), (void*)inputString); for (int i = 0; i < sizeof(needle) - 1; ++i) { if (needle[i] != haystack[i]) { return false; diff --git a/src/cc/usdt/usdt_args.cc b/src/cc/usdt/usdt_args.cc index 3bf194635..1e239bd6e 100644 --- a/src/cc/usdt/usdt_args.cc +++ b/src/cc/usdt/usdt_args.cc @@ -92,7 +92,7 @@ bool Argument::assign_to_local(std::ostream &stream, tfm::format(stream, " %s ", COMPILER_BARRIER); tfm::format(stream, "%s __res = 0x0; " - "bpf_probe_read(&__res, sizeof(__res), (void *)__addr); " + "bpf_probe_read_user(&__res, sizeof(__res), (void *)__addr); " "%s = __res; }", ctype(), local_name); return true; @@ -105,7 +105,7 @@ bool Argument::assign_to_local(std::ostream &stream, tfm::format(stream, "{ u64 __addr = 0x%xull + %d; %s __res = 0x0; " - "bpf_probe_read(&__res, sizeof(__res), (void *)__addr); " + "bpf_probe_read_user(&__res, sizeof(__res), (void *)__addr); " "%s = __res; }", global_address, *deref_offset_, ctype(), local_name); return true; From d9583813c07897fbbe99d475ab6beb445ae9ffe8 Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Wed, 20 May 2020 10:50:26 -0500 Subject: [PATCH 123/278] bcc/libbpf-tools: Replace bpf_probe_read with bpf_probe_read_kernel. As kernel commit b8ebce86ffe6 ("libbpf: Provide CO-RE variants of PT_REGS macros") is introduced after bpf_probe_read_kernel changes, it is safe to use bpf_probe_read_kernel directly Signed-off-by: Sumanth Korikkar Acked-by: Ilya Leoshkevich --- libbpf-tools/drsnoop.bpf.c | 2 +- libbpf-tools/filelife.bpf.c | 2 +- libbpf-tools/runqslower.bpf.c | 2 +- libbpf-tools/xfsslower.bpf.c | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/libbpf-tools/drsnoop.bpf.c b/libbpf-tools/drsnoop.bpf.c index 491de15da..91072cbb3 100644 --- a/libbpf-tools/drsnoop.bpf.c +++ b/libbpf-tools/drsnoop.bpf.c @@ -42,7 +42,7 @@ int handle__mm_vmscan_direct_reclaim_begin(u64 *ctx) piddata.ts = bpf_ktime_get_ns(); if (vm_zone_stat_kaddrp) { - bpf_probe_read(&piddata.nr_free_pages, + bpf_probe_read_kernel(&piddata.nr_free_pages, sizeof(*vm_zone_stat_kaddrp), &vm_zone_stat_kaddrp[NR_FREE_PAGES]); } diff --git a/libbpf-tools/filelife.bpf.c b/libbpf-tools/filelife.bpf.c index 04217a697..657217200 100644 --- a/libbpf-tools/filelife.bpf.c +++ b/libbpf-tools/filelife.bpf.c @@ -68,7 +68,7 @@ int BPF_KPROBE(kprobe__vfs_unlink, struct inode *dir, struct dentry *dentry) qs_name_ptr = BPF_CORE_READ(dentry, d_name.name); qs_len = BPF_CORE_READ(dentry, d_name.len); - bpf_probe_read_str(&event.file, sizeof(event.file), qs_name_ptr); + bpf_probe_read_kernel_str(&event.file, sizeof(event.file), qs_name_ptr); bpf_get_current_comm(&event.task, sizeof(event.task)); event.delta_ns = delta_ns; event.tgid = tgid; diff --git a/libbpf-tools/runqslower.bpf.c b/libbpf-tools/runqslower.bpf.c index 65a9ca961..94b215b8a 100644 --- a/libbpf-tools/runqslower.bpf.c +++ b/libbpf-tools/runqslower.bpf.c @@ -89,7 +89,7 @@ int handle__sched_switch(u64 *ctx) event.pid = pid; event.delta_us = delta_us; - bpf_probe_read_str(&event.task, sizeof(event.task), next->comm); + bpf_probe_read_kernel_str(&event.task, sizeof(event.task), next->comm); /* output */ bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, diff --git a/libbpf-tools/xfsslower.bpf.c b/libbpf-tools/xfsslower.bpf.c index a73a2dc1d..9c0bc105e 100644 --- a/libbpf-tools/xfsslower.bpf.c +++ b/libbpf-tools/xfsslower.bpf.c @@ -115,7 +115,7 @@ probe_exit(struct pt_regs *ctx, char type, ssize_t size) dentry = BPF_CORE_READ(fp, f_path.dentry); qs_len = BPF_CORE_READ(dentry, d_name.len); qs_name_ptr = BPF_CORE_READ(dentry, d_name.name); - bpf_probe_read_str(&event.file, sizeof(event.file), qs_name_ptr); + bpf_probe_read_kernel_str(&event.file, sizeof(event.file), qs_name_ptr); bpf_get_current_comm(&event.task, sizeof(event.task)); event.delta_us = delta_us; event.end_ns = end_ns; From 4a1313d179e9701469e1e5650b05ec332b85751f Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Wed, 20 May 2020 10:50:39 -0500 Subject: [PATCH 124/278] bcc/libbpf-tools: Fix user probe read references Replace bpf_probe_read_str with bpf_probe_read_user_str. Signed-off-by: Sumanth Korikkar Acked-by: Ilya Leoshkevich --- libbpf-tools/opensnoop.bpf.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libbpf-tools/opensnoop.bpf.c b/libbpf-tools/opensnoop.bpf.c index 8082c3fde..4689d403a 100644 --- a/libbpf-tools/opensnoop.bpf.c +++ b/libbpf-tools/opensnoop.bpf.c @@ -104,7 +104,7 @@ int trace_exit(struct trace_event_raw_sys_exit* ctx) event.pid = bpf_get_current_pid_tgid() >> 32; event.uid = bpf_get_current_uid_gid(); bpf_get_current_comm(&event.comm, sizeof(event.comm)); - bpf_probe_read_str(&event.fname, sizeof(event.fname), ap->fname); + bpf_probe_read_user_str(&event.fname, sizeof(event.fname), ap->fname); event.flags = ap->flags; event.ret = ret; From 471d366bb001f6025ec610dd3a615fba8c1dcd26 Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Wed, 20 May 2020 10:51:04 -0500 Subject: [PATCH 125/278] bcc/docs: Replace bpf_probe_read with bpf_probe_read_kernel Signed-off-by: Sumanth Korikkar Acked-by: Ilya Leoshkevich --- docs/reference_guide.md | 28 +++++++++++++-------------- docs/tutorial_bcc_python_developer.md | 2 +- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 5ac228f4c..107ecff53 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -19,8 +19,8 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [9. kfuncs](#9-kfuncs) - [10. kretfuncs](#9-kretfuncs) - [Data](#data) - - [1. bpf_probe_read()](#1-bpf_probe_read) - - [2. bpf_probe_read_str()](#2-bpf_probe_read_str) + - [1. bpf_probe_read_kernel()](#1-bpf_probe_read_kernel) + - [2. bpf_probe_read_kernel_str()](#2-bpf_probe_read_kernel_str) - [3. bpf_ktime_get_ns()](#3-bpf_ktime_get_ns) - [4. bpf_get_current_pid_tgid()](#4-bpf_get_current_pid_tgid) - [5. bpf_get_current_uid_gid()](#5-bpf_get_current_uid_gid) @@ -277,8 +277,8 @@ RAW_TRACEPOINT_PROBE(sched_switch) struct task_struct *next= (struct task_struct *)ctx->args[2]; s32 prev_tgid, next_tgid; - bpf_probe_read(&prev_tgid, sizeof(prev->tgid), &prev->tgid); - bpf_probe_read(&next_tgid, sizeof(next->tgid), &next->tgid); + bpf_probe_read_kernel(&prev_tgid, sizeof(prev->tgid), &prev->tgid); + bpf_probe_read_kernel(&next_tgid, sizeof(next->tgid), &next->tgid); bpf_trace_printk("%d -> %d\\n", prev_tgid, next_tgid); } ``` @@ -368,21 +368,21 @@ Examples in situ: ## Data -### 1. bpf_probe_read() +### 1. bpf_probe_read_kernel() -Syntax: ```int bpf_probe_read(void *dst, int size, const void *src)``` +Syntax: ```int bpf_probe_read_kernel(void *dst, int size, const void *src)``` Return: 0 on success -This copies size bytes from kernel address space to the BPF stack, so that BPF can later operate on it. For safety, all kernel memory reads must pass through bpf_probe_read(). This happens automatically in some cases, such as dereferencing kernel variables, as bcc will rewrite the BPF program to include the necessary bpf_probe_read(). +This copies size bytes from kernel address space to the BPF stack, so that BPF can later operate on it. For safety, all kernel memory reads must pass through bpf_probe_read_kernel(). This happens automatically in some cases, such as dereferencing kernel variables, as bcc will rewrite the BPF program to include the necessary bpf_probe_read_kernel(). Examples in situ: -[search /examples](https://github.com/iovisor/bcc/search?q=bpf_probe_read+path%3Aexamples&type=Code), -[search /tools](https://github.com/iovisor/bcc/search?q=bpf_probe_read+path%3Atools&type=Code) +[search /examples](https://github.com/iovisor/bcc/search?q=bpf_probe_read_kernel+path%3Aexamples&type=Code), +[search /tools](https://github.com/iovisor/bcc/search?q=bpf_probe_read_kernel+path%3Atools&type=Code) -### 2. bpf_probe_read_str() +### 2. bpf_probe_read_kernel_str() -Syntax: ```int bpf_probe_read_str(void *dst, int size, const void *src)``` +Syntax: ```int bpf_probe_read_kernel_str(void *dst, int size, const void *src)``` Return: - \> 0 length of the string including the trailing NULL on success @@ -391,8 +391,8 @@ Return: This copies a `NULL` terminated string from kernel address space to the BPF stack, so that BPF can later operate on it. In case the string length is smaller than size, the target is not padded with further `NULL` bytes. In case the string length is larger than size, just `size - 1` bytes are copied and the last byte is set to `NULL`. Examples in situ: -[search /examples](https://github.com/iovisor/bcc/search?q=bpf_probe_read_str+path%3Aexamples&type=Code), -[search /tools](https://github.com/iovisor/bcc/search?q=bpf_probe_read_str+path%3Atools&type=Code) +[search /examples](https://github.com/iovisor/bcc/search?q=bpf_probe_read_kernel_str+path%3Aexamples&type=Code), +[search /tools](https://github.com/iovisor/bcc/search?q=bpf_probe_read_kernel_str+path%3Atools&type=Code) ### 3. bpf_ktime_get_ns() @@ -1749,7 +1749,7 @@ See the "Understanding eBPF verifier messages" section in the kernel source unde ## 1. Invalid mem access -This can be due to trying to read memory directly, instead of operating on memory on the BPF stack. All kernel memory reads must be passed via bpf_probe_read() to copy kernel memory into the BPF stack, which can be automatic by the bcc rewriter in some cases of simple dereferencing. bpf_probe_read() does all the required checks. +This can be due to trying to read memory directly, instead of operating on memory on the BPF stack. All kernel memory reads must be passed via bpf_probe_read_kernel() to copy kernel memory into the BPF stack, which can be automatic by the bcc rewriter in some cases of simple dereferencing. bpf_probe_read_kernel() does all the required checks. Example: diff --git a/docs/tutorial_bcc_python_developer.md b/docs/tutorial_bcc_python_developer.md index b8d3987d4..9c28a08f3 100644 --- a/docs/tutorial_bcc_python_developer.md +++ b/docs/tutorial_bcc_python_developer.md @@ -228,7 +228,7 @@ Things to learn: 1. ```REQ_WRITE```: We're defining a kernel constant in the Python program because we'll use it there later. If we were using REQ_WRITE in the BPF program, it should just work (without needing to be defined) with the appropriate #includes. 1. ```trace_start(struct pt_regs *ctx, struct request *req)```: This function will later be attached to kprobes. The arguments to kprobe functions are ```struct pt_regs *ctx```, for registers and BPF context, and then the actual arguments to the function. We'll attach this to blk_start_request(), where the first argument is ```struct request *```. 1. ```start.update(&req, &ts)```: We're using the pointer to the request struct as a key in our hash. What? This is commonplace in tracing. Pointers to structs turn out to be great keys, as they are unique: two structs can't have the same pointer address. (Just be careful about when it gets free'd and reused.) So what we're really doing is tagging the request struct, which describes the disk I/O, with our own timestamp, so that we can time it. There's two common keys used for storing timestamps: pointers to structs, and, thread IDs (for timing function entry to return). -1. ```req->__data_len```: We're dereferencing members of ```struct request```. See its definition in the kernel source for what members are there. bcc actually rewrites these expressions to be a series of ```bpf_probe_read()``` calls. Sometimes bcc can't handle a complex dereference, and you need to call ```bpf_probe_read()``` directly. +1. ```req->__data_len```: We're dereferencing members of ```struct request```. See its definition in the kernel source for what members are there. bcc actually rewrites these expressions to be a series of ```bpf_probe_read_kernel()``` calls. Sometimes bcc can't handle a complex dereference, and you need to call ```bpf_probe_read_kernel()``` directly. This is a pretty interesting program, and if you can understand all the code, you'll understand many important basics. We're still using the bpf_trace_printk() hack, so let's fix that next. From 275abc9f3b7fb22ad1ac6a4188c807793b9c38bd Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Wed, 20 May 2020 10:55:04 -0500 Subject: [PATCH 126/278] bcc: Check probe read availabilty and use macros When bpf_probe_read_kernel is not available, then macros are defined at the prologue to replace bpf_probe_read_kernel to bpf_prob_read. This resolves the problem of test_probe_read3 failure in test_clang.py for #2919 Signed-off-by: Sumanth Korikkar --- src/cc/frontends/clang/b_frontend_action.cc | 49 ++++++++++++--------- 1 file changed, 27 insertions(+), 22 deletions(-) diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc index 3aff2ec4a..151896e26 100644 --- a/src/cc/frontends/clang/b_frontend_action.cc +++ b/src/cc/frontends/clang/b_frontend_action.cc @@ -83,7 +83,7 @@ const char **get_call_conv(void) { return ret; } -/* Use resolver only once */ +/* Use resolver only once per translation */ static void *kresolver = NULL; static void *get_symbol_resolver(void) { if (!kresolver) @@ -492,7 +492,7 @@ bool ProbeVisitor::VisitUnaryOperator(UnaryOperator *E) { memb_visited_.insert(E); string pre, post; pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));"; - pre += " " + check_bpf_probe_read_kernel() + "(&_val, sizeof(_val), (u64)"; + pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (u64)"; post = "); _val; })"; rewriter_.ReplaceText(expansionLoc(E->getOperatorLoc()), 1, pre); rewriter_.InsertTextAfterToken(expansionLoc(GET_ENDLOC(sub)), post); @@ -553,7 +553,7 @@ bool ProbeVisitor::VisitMemberExpr(MemberExpr *E) { string base_type = base->getType()->getPointeeType().getAsString(); string pre, post; pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));"; - pre += " " + check_bpf_probe_read_kernel() + "(&_val, sizeof(_val), (u64)&"; + pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (u64)&"; post = rhs + "); _val; })"; rewriter_.InsertText(expansionLoc(GET_BEGINLOC(E)), pre); rewriter_.ReplaceText(expansionRange(SourceRange(member, GET_ENDLOC(E))), post); @@ -604,7 +604,7 @@ bool ProbeVisitor::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { return true; pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));"; - pre += " " + check_bpf_probe_read_kernel() + "(&_val, sizeof(_val), (u64)(("; + pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (u64)(("; if (isMemberDereference(base)) { pre += "&"; // If the base of the array subscript is a member dereference, we'll rewrite @@ -737,7 +737,7 @@ void BTypeVisitor::genParamIndirectAssign(FunctionDecl *D, string& preamble, size_t d = idx - 1; const char *reg = calling_conv_regs[d]; preamble += "\n " + text + ";"; - preamble += " " + check_bpf_probe_read_kernel(); + preamble += " bpf_probe_read_kernel"; preamble += "(&" + arg->getName().str() + ", sizeof(" + arg->getName().str() + "), &" + new_ctx + "->" + string(reg) + ");"; @@ -1005,7 +1005,9 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) { if (!Decl) return true; string text; - + + // Bail out when bpf_probe_read_user is unavailable for overlapping address + // space arch. bool overlap_addr = false; std::string probe = check_bpf_probe_read_user(Decl->getName(), overlap_addr); @@ -1013,17 +1015,6 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) { error(GET_BEGINLOC(Call), "bpf_probe_read_user not found. Use latest kernel"); return false; } - if (probe != "") { - vector probe_args; - - for (auto arg : Call->arguments()) - probe_args.push_back( - rewriter_.getRewrittenText(expansionRange(arg->getSourceRange()))); - - text = probe + "(" + probe_args[0] + ", " + probe_args[1] + ", " + - probe_args[2] + ")"; - rewriter_.ReplaceText(expansionRange(Call->getSourceRange()), text); - } if (AsmLabelAttr *A = Decl->getAttr()) { // Functions with the tag asm("llvm.bpf.extra") are implemented in the @@ -1540,8 +1531,6 @@ void BTypeConsumer::HandleTranslationUnit(ASTContext &Context) { btype_visitor_.TraverseDecl(D); } - if (kresolver) - bcc_free_symcache(kresolver, -1); } BFrontendAction::BFrontendAction(llvm::raw_ostream &os, unsigned flags, @@ -1577,8 +1566,21 @@ void BFrontendAction::DoMiscWorkAround() { // to guard certain fields. The workaround here intends to define // CONFIG_CC_STACKPROTECTOR properly based on other configs, so it relieved any bpf // program (using task_struct, etc.) of patching the below code. - rewriter_->getEditBuffer(rewriter_->getSourceMgr().getMainFileID()).InsertText(0, - "#if defined(BPF_LICENSE)\n" + std::string probefunc = check_bpf_probe_read_kernel(); + if (kresolver) { + bcc_free_symcache(kresolver, -1); + kresolver = NULL; + } + if (probefunc == "bpf_probe_read") { + probefunc = "#define bpf_probe_read_kernel bpf_probe_read\n" + "#define bpf_probe_read_kernel_str bpf_probe_read_str\n" + "#define bpf_probe_read_user bpf_probe_read\n" + "#define bpf_probe_read_user_str bpf_probe_read_str\n"; + } + else { + probefunc = ""; + } + std::string prologue = "#if defined(BPF_LICENSE)\n" "#error BPF_LICENSE cannot be specified through cflags\n" "#endif\n" "#if !defined(CONFIG_CC_STACKPROTECTOR)\n" @@ -1587,7 +1589,10 @@ void BFrontendAction::DoMiscWorkAround() { " || defined(CONFIG_CC_STACKPROTECTOR_STRONG)\n" "#define CONFIG_CC_STACKPROTECTOR\n" "#endif\n" - "#endif\n", + "#endif\n"; + prologue = prologue + probefunc; + rewriter_->getEditBuffer(rewriter_->getSourceMgr().getMainFileID()).InsertText(0, + prologue, false); rewriter_->getEditBuffer(rewriter_->getSourceMgr().getMainFileID()).InsertTextAfter( From 0b2f4d0b981803ea8d8393ad2eec93c699e59df1 Mon Sep 17 00:00:00 2001 From: Sumanth Korikkar Date: Thu, 21 May 2020 17:08:46 -0500 Subject: [PATCH 127/278] bcc: Remove bpf_probe_read_user availability checks on compile time If wrong kernel-headers are installed, then this can provide false result for probe read selection. Instead look for only kallsyms. Signed-off-by: Sumanth Korikkar --- src/cc/frontends/clang/b_frontend_action.cc | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc index 151896e26..f7e6cdbc1 100644 --- a/src/cc/frontends/clang/b_frontend_action.cc +++ b/src/cc/frontends/clang/b_frontend_action.cc @@ -110,9 +110,6 @@ static std::string check_bpf_probe_read_user(llvm::StringRef probe, bool& overlap_addr) { if (probe.str() == "bpf_probe_read_user" || probe.str() == "bpf_probe_read_user_str") { -#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 5, 0) - return probe.str(); -#else // Check for probe_user symbols in backported kernel before fallback void *resolver = get_symbol_resolver(); uint64_t addr = 0; @@ -132,7 +129,6 @@ static std::string check_bpf_probe_read_user(llvm::StringRef probe, return "bpf_probe_read"; else return "bpf_probe_read_str"; -#endif } return ""; } From ec64e6a774499aa54fdf6eb006a8c94eabec8866 Mon Sep 17 00:00:00 2001 From: Goro Fuji Date: Mon, 25 May 2020 01:47:26 +0000 Subject: [PATCH 128/278] fix: avoid -Wsign-compare warnings --- src/cc/frontends/b/lexer.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cc/frontends/b/lexer.h b/src/cc/frontends/b/lexer.h index 14f31102f..394daa33a 100644 --- a/src/cc/frontends/b/lexer.h +++ b/src/cc/frontends/b/lexer.h @@ -51,7 +51,7 @@ class Lexer : public yyFlexLexer { } std::string text(const position& begin, const position& end) const { std::string result; - for (size_t i = begin.line; i <= end.line; ++i) { + for (auto i = begin.line; i <= end.line; ++i) { if (i == begin.line && i == end.line) { result += lines_.at(i - 1).substr(begin.column - 1, end.column - begin.column); } else if (i == begin.line && i < end.line) { From 076a3545e4f365cdc517995d77329ea0c15c89f0 Mon Sep 17 00:00:00 2001 From: synical Date: Sat, 23 May 2020 12:40:09 -0400 Subject: [PATCH 129/278] Add arg for filtering on signal --- tools/killsnoop.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/tools/killsnoop.py b/tools/killsnoop.py index 977c6bb1d..63e8ee86a 100755 --- a/tools/killsnoop.py +++ b/tools/killsnoop.py @@ -23,6 +23,7 @@ ./killsnoop # trace all kill() signals ./killsnoop -x # only show failed kills ./killsnoop -p 181 # only trace PID 181 + ./killsnoop -s 13 # only trace signal 13 """ parser = argparse.ArgumentParser( description="Trace signals issued by the kill() syscall", @@ -32,6 +33,8 @@ help="only show failed kill syscalls") parser.add_argument("-p", "--pid", help="trace this PID only") +parser.add_argument("-s", "--signal", + help="trace this signal only") parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) args = parser.parse_args() @@ -63,7 +66,8 @@ int syscall__kill(struct pt_regs *ctx, int tpid, int sig) { u32 pid = bpf_get_current_pid_tgid(); - FILTER + PID_FILTER + SIGNAL_FILTER struct val_t val = {.pid = pid}; if (bpf_get_current_comm(&val.comm, sizeof(val.comm)) == 0) { @@ -100,10 +104,15 @@ } """ if args.pid: - bpf_text = bpf_text.replace('FILTER', + bpf_text = bpf_text.replace('PID_FILTER', 'if (pid != %s) { return 0; }' % args.pid) else: - bpf_text = bpf_text.replace('FILTER', '') + bpf_text = bpf_text.replace('PID_FILTER', '') +if args.signal: + bpf_text = bpf_text.replace('SIGNAL_FILTER', + 'if (sig != %s) { return 0; }' % args.signal) +else: + bpf_text = bpf_text.replace('SIGNAL_FILTER', '') if debug or args.ebpf: print(bpf_text) if args.ebpf: From 33c8b1aca84b4cdd955efb14d06cea6ce7db4169 Mon Sep 17 00:00:00 2001 From: synical Date: Tue, 26 May 2020 10:34:13 -0400 Subject: [PATCH 130/278] Update man page and example file --- man/man8/killsnoop.8 | 7 +++++++ tools/killsnoop_example.txt | 7 ++++--- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/man/man8/killsnoop.8 b/man/man8/killsnoop.8 index b90162f0d..acb376ea1 100644 --- a/man/man8/killsnoop.8 +++ b/man/man8/killsnoop.8 @@ -28,6 +28,9 @@ Only print failed kill() syscalls. .TP \-p PID Trace this process ID only (filtered in-kernel). +.TP +\-s SIGNAL +Trace this signal only (filtered in-kernel). .SH EXAMPLES .TP Trace all kill() syscalls: @@ -41,6 +44,10 @@ Trace only kill() syscalls that failed: Trace PID 181 only: # .B killsnoop \-p 181 +.TP +Trace signal 9 only: +# +.B killsnoop \-s 9 .SH FIELDS .TP TIME diff --git a/tools/killsnoop_example.txt b/tools/killsnoop_example.txt index 29d56b0a8..4803c35ef 100644 --- a/tools/killsnoop_example.txt +++ b/tools/killsnoop_example.txt @@ -29,6 +29,7 @@ optional arguments: -p PID, --pid PID trace this PID only examples: - ./killsnoop # trace all kill() signals - ./killsnoop -x # only show failed kills - ./killsnoop -p 181 # only trace PID 181 + ./killsnoop # trace all kill() signals + ./killsnoop -x # only show failed kills + ./killsnoop -p 181 # only trace PID 181 + ./killsnoop -s 9 # only trace signal 9 From d12dd2e9fb1ddeb4407dd66881f90d1faff22e54 Mon Sep 17 00:00:00 2001 From: synical Date: Tue, 26 May 2020 11:15:31 -0400 Subject: [PATCH 131/278] Fix example indent --- tools/killsnoop_example.txt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tools/killsnoop_example.txt b/tools/killsnoop_example.txt index 4803c35ef..7746f2a0c 100644 --- a/tools/killsnoop_example.txt +++ b/tools/killsnoop_example.txt @@ -29,7 +29,7 @@ optional arguments: -p PID, --pid PID trace this PID only examples: - ./killsnoop # trace all kill() signals - ./killsnoop -x # only show failed kills - ./killsnoop -p 181 # only trace PID 181 - ./killsnoop -s 9 # only trace signal 9 + ./killsnoop # trace all kill() signals + ./killsnoop -x # only show failed kills + ./killsnoop -p 181 # only trace PID 181 + ./killsnoop -s 9 # only trace signal 9 From 7cecd795440251ca53065caca185978bdc8a18d5 Mon Sep 17 00:00:00 2001 From: synical Date: Tue, 26 May 2020 11:16:52 -0400 Subject: [PATCH 132/278] Make examples consistent --- tools/killsnoop.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/killsnoop.py b/tools/killsnoop.py index 63e8ee86a..2dc5b8af9 100755 --- a/tools/killsnoop.py +++ b/tools/killsnoop.py @@ -23,7 +23,7 @@ ./killsnoop # trace all kill() signals ./killsnoop -x # only show failed kills ./killsnoop -p 181 # only trace PID 181 - ./killsnoop -s 13 # only trace signal 13 + ./killsnoop -s 9 # only trace signal 9 """ parser = argparse.ArgumentParser( description="Trace signals issued by the kill() syscall", From 30d897563bd116451f41230712aad2b952eda7d0 Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Tue, 26 May 2020 09:56:40 -0700 Subject: [PATCH 133/278] return failure if rewriter cannot rewrite properly Fix issue #537. The bcc rewriter does not have enough information to do proper rewriting from: #define PKT_LEN_ADD 1 ip->tlen += PKT_LEN_ADD; to bpf_dins_pkt(skb, (u64)ip+2, 0, 16, PKT_LEN_ADD); So instead of generate incorrect code which caused compilation error. Let return an error earlier with helper comments so users know what to do. With this patch, we will have /virtual/main.c:20:17: error: cannot have macro at the end of expresssion, workaround: put perentheses around macro "(MARCO)" ip->tlen += PKT_LEN_ADD; ^ --- src/cc/frontends/clang/b_frontend_action.cc | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc index f7e6cdbc1..63e19e1b4 100644 --- a/src/cc/frontends/clang/b_frontend_action.cc +++ b/src/cc/frontends/clang/b_frontend_action.cc @@ -1152,13 +1152,21 @@ bool BTypeVisitor::VisitBinaryOperator(BinaryOperator *E) { error(GET_BEGINLOC(E), "cannot use \"packet\" header type inside a macro"); return false; } + + auto EndLoc = GET_ENDLOC(E); + if (EndLoc.isMacroID()) { + error(EndLoc, "cannot have macro at the end of expresssion, " + "workaround: put perentheses around macro \"(MARCO)\""); + return false; + } + uint64_t ofs = C.getFieldOffset(F); uint64_t sz = F->isBitField() ? F->getBitWidthValue(C) : C.getTypeSize(F->getType()); string base = rewriter_.getRewrittenText(expansionRange(Base->getSourceRange())); string text = "bpf_dins_pkt(" + fn_args_[0]->getName().str() + ", (u64)" + base + "+" + to_string(ofs >> 3) + ", " + to_string(ofs & 0x7) + ", " + to_string(sz) + ","; rewriter_.ReplaceText(expansionRange(SourceRange(GET_BEGINLOC(E), E->getOperatorLoc())), text); - rewriter_.InsertTextAfterToken(GET_ENDLOC(E), ")"); + rewriter_.InsertTextAfterToken(EndLoc, ")"); } } } From 82abd2f2680e5c8c86c8cfcab02cc8c68915c599 Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Thu, 21 May 2020 16:51:30 +0200 Subject: [PATCH 134/278] Allow to specify kernel include dirs It's sometimes convenient to use other kernel headers, now it's possible possible with new KERNEL_INCLUDE_DIRS build variable, like: $ cd $ make INSTALL_HDR_PATH=/tmp/headers headers_install $ cd $ cmake -DKERNEL_INCLUDE_DIRS=/tmp/headers/include/ ... Signed-off-by: Jiri Olsa --- CMakeLists.txt | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 65e78ffef..74fe4f193 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -19,6 +19,14 @@ if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/src/cc/libbpf/src) WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) endif() +# It's possible to use other kernel headers with +# KERNEL_INCLUDE_DIRS build variable, like: +# $ cd +# $ make INSTALL_HDR_PATH=/tmp/headers headers_install +# $ cd +# $ cmake -DKERNEL_INCLUDE_DIRS=/tmp/headers/include/ ... +include_directories(${KERNEL_INCLUDE_DIRS}) + include(cmake/GetGitRevisionDescription.cmake) include(cmake/version.cmake) include(CMakeDependentOption) From d0074783b6f56ed195f378a581726098ab87fe98 Mon Sep 17 00:00:00 2001 From: Jiri Olsa Date: Fri, 22 May 2020 08:45:43 +0200 Subject: [PATCH 135/278] Adding support to load lsm programs Adding the 'lsm__' prefix check for loaded program and set BPF_LSM_MAC as expected_attach_type if the program name matches. This way we can load LSM programs via bcc interface. The program attach can be done by existing kfunc API: bpf_attach_kfunc bpf_detach_kfunc It will be used in upcomming bpftrace change that adds lsm probes. Signed-off-by: Jiri Olsa --- src/cc/export/helpers.h | 3 +++ src/cc/libbpf.c | 6 +++++- src/python/bcc/__init__.py | 1 + tests/python/test_clang.py | 12 ++++++++++++ 4 files changed, 21 insertions(+), 1 deletion(-) diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index 2b73d1c7f..64250aa8f 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -1029,6 +1029,9 @@ static int ____##name(unsigned long long *ctx, ##args) #define KRETFUNC_PROBE(event, args...) \ BPF_PROG(kretfunc__ ## event, args) +#define LSM_PROBE(event, args...) \ + BPF_PROG(lsm__ ## event, args) + #define TP_DATA_LOC_READ_CONST(dst, field, length) \ do { \ unsigned short __offset = args->data_loc_##field & 0xFFFF; \ diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index 5138d27f2..5bde5a544 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -564,9 +564,13 @@ int bcc_prog_load_xattr(struct bpf_load_program_attr *attr, int prog_len, } else if (strncmp(attr->name, "kretfunc__", 10) == 0) { name_offset = 10; expected_attach_type = BPF_TRACE_FEXIT; + } else if (strncmp(attr->name, "lsm__", 5) == 0) { + name_offset = 5; + expected_attach_type = BPF_LSM_MAC; } - if (attr->prog_type == BPF_PROG_TYPE_TRACING) { + if (attr->prog_type == BPF_PROG_TYPE_TRACING || + attr->prog_type == BPF_PROG_TYPE_LSM) { attr->attach_btf_id = libbpf_find_vmlinux_btf_id(attr->name + name_offset, expected_attach_type); attr->expected_attach_type = expected_attach_type; diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index 0aea60003..8496ee62f 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -157,6 +157,7 @@ class BPF(object): RAW_TRACEPOINT = 17 CGROUP_SOCK_ADDR = 18 TRACING = 26 + LSM = 29 # from xdp_action uapi/linux/bpf.h XDP_ABORTED = 0 diff --git a/tests/python/test_clang.py b/tests/python/test_clang.py index 5ad0de176..bbce641d2 100755 --- a/tests/python/test_clang.py +++ b/tests/python/test_clang.py @@ -323,6 +323,18 @@ def test_char_array_probe(self): return 0; }""") + @skipUnless(kernel_version_ge(5,7), "requires kernel >= 5.7") + def test_lsm_probe(self): + b = BPF(text=""" +LSM_PROBE(bpf, int cmd, union bpf_attr *uattr, unsigned int size) { + return 0; +}""") + # depending on CONFIG_BPF_LSM being compiled in + try: + b.load_func("lsm__bpf", BPF.LSM) + except: + pass + def test_probe_read_helper(self): b = BPF(text=""" #include From 5558e36bd97ace7bc3efe3a70d0c9d4fc0d34e2a Mon Sep 17 00:00:00 2001 From: Ivan Babrou Date: Fri, 29 May 2020 15:33:25 -0700 Subject: [PATCH 136/278] Make reading blacklist from debugfs optional With lockdown enabled one sees the following: ``` $ sudo /usr/share/bcc/tools/funccount -Ti 1 run_timer_softirq [Errno 1] Operation not permitted: '/sys/kernel/debug/tracing/../kprobes/blacklist' ``` Which is accompanied by the following in `dmesg`: ``` [Fri May 29 22:12:47 2020] Lockdown: funccount: debugfs access is restricted; see man kernel_lockdown.7 ``` Since blacklist is not a required feature, let's make reading from it optional, so that bcc can work out of the box. --- src/python/bcc/__init__.py | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index 8496ee62f..749ebfe51 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -546,8 +546,15 @@ def attach_raw_socket(fn, dev): @staticmethod def get_kprobe_functions(event_re): - with open("%s/../kprobes/blacklist" % TRACEFS, "rb") as blacklist_f: - blacklist = set([line.rstrip().split()[1] for line in blacklist_f]) + blacklist_file = "%s/../kprobes/blacklist" % TRACEFS + try: + with open(blacklist_file, "rb") as blacklist_f: + blacklist = set([line.rstrip().split()[1] for line in blacklist_f]) + except IOError as e: + if e.errno != errno.EPERM: + raise e + blacklist = set([]) + fns = [] in_init_section = 0 @@ -607,7 +614,7 @@ def _del_kprobe_fd(self, name): global _num_open_probes del self.kprobe_fds[name] _num_open_probes -= 1 - + def _add_uprobe_fd(self, name, fd): global _num_open_probes self.uprobe_fds[name] = fd @@ -643,7 +650,7 @@ def fix_syscall_fnname(self, name): if name.startswith(prefix): return self.get_syscall_fnname(name[len(prefix):]) return name - + def attach_kprobe(self, event=b"", event_off=0, fn_name=b"", event_re=b""): event = _assert_is_bytes(event) fn_name = _assert_is_bytes(fn_name) From b20f5e741f086bf37b19365566b01b5bf6fa251e Mon Sep 17 00:00:00 2001 From: lorddoskias Date: Sat, 30 May 2020 19:17:33 +0300 Subject: [PATCH 137/278] offwaketime: Add support for --state (#2940) Since offwaketime is really an amalgamation of offcputime and wakeuptime there is no reason why it shouldn't support the --state argument of the former. Co-authored-by: Nikolay Borisov --- man/man8/offwaketime.8 | 6 +++++- tools/offwaketime.py | 15 +++++++++++++-- tools/offwaketime_example.txt | 4 +++- 3 files changed, 21 insertions(+), 4 deletions(-) diff --git a/man/man8/offwaketime.8 b/man/man8/offwaketime.8 index cdc49a71b..5527478c4 100644 --- a/man/man8/offwaketime.8 +++ b/man/man8/offwaketime.8 @@ -2,7 +2,7 @@ .SH NAME offwaketime \- Summarize blocked time by off-CPU stack + waker stack. Uses Linux eBPF/bcc. .SH SYNOPSIS -.B offwaketime [\-h] [\-p PID | \-t TID | \-u | \-k] [\-U | \-K] [\-f] [\-\-stack-storage-size STACK_STORAGE_SIZE] [\-m MIN_BLOCK_TIME] [\-M MAX_BLOCK_TIME] [duration] +.B offwaketime [\-h] [\-p PID | \-t TID | \-u | \-k] [\-U | \-K] [\-f] [\-\-stack-storage-size STACK_STORAGE_SIZE] [\-m MIN_BLOCK_TIME] [\-M MAX_BLOCK_TIME] [\-\-state STATE] [duration] .SH DESCRIPTION This program shows kernel stack traces and task names that were blocked and "off-CPU", along with the stack traces and task names for the threads that woke @@ -64,6 +64,10 @@ The amount of time in microseconds over which we store traces (default 1) .TP \-M MAX_BLOCK_TIME The amount of time in microseconds under which we store traces (default U64_MAX) +.TP +\-\-state +Filter on this thread state bitmask (eg, 2 == TASK_UNINTERRUPTIBLE). +See include/linux/sched.h for states. .SH EXAMPLES .TP Trace all thread blocking events, and summarize (in-kernel) by user and kernel off-CPU stack trace, waker stack traces, task names, and total blocked time: diff --git a/tools/offwaketime.py b/tools/offwaketime.py index 665b66661..88dc68c15 100755 --- a/tools/offwaketime.py +++ b/tools/offwaketime.py @@ -93,6 +93,9 @@ def stack_id_err(stack_id): type=positive_nonzero_int, help="the amount of time in microseconds under which we " + "store traces (default U64_MAX)") +parser.add_argument("--state", type=positive_int, + help="filter on this thread state bitmask (eg, 2 == TASK_UNINTERRUPTIBLE" + + ") see include/linux/sched.h") parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) args = parser.parse_args() @@ -147,7 +150,7 @@ def signal_ignore(signal, frame): u32 pid = p->pid; u32 tgid = p->tgid; - if (!(THREAD_FILTER)) { + if (!((THREAD_FILTER) && (STATE_FILTER))) { return 0; } @@ -171,7 +174,7 @@ def signal_ignore(signal, frame): u64 ts = bpf_ktime_get_ns(); // Record timestamp for the previous Process (Process going into waiting) - if (THREAD_FILTER) { + if ((THREAD_FILTER) && (STATE_FILTER)) { start.update(&pid, &ts); } @@ -234,7 +237,15 @@ def signal_ignore(signal, frame): else: thread_context = "all threads" thread_filter = '1' +if args.state == 0: + state_filter = 'p->state == 0' +elif args.state: + # these states are sometimes bitmask checked + state_filter = 'p->state & %d' % args.state +else: + state_filter = '1' bpf_text = bpf_text.replace('THREAD_FILTER', thread_filter) +bpf_text = bpf_text.replace('STATE_FILTER', state_filter) # set stack storage size bpf_text = bpf_text.replace('STACK_STORAGE_SIZE', str(args.stack_storage_size)) diff --git a/tools/offwaketime_example.txt b/tools/offwaketime_example.txt index 8291e2f76..02c5a04c0 100644 --- a/tools/offwaketime_example.txt +++ b/tools/offwaketime_example.txt @@ -307,7 +307,7 @@ USAGE message: # ./offwaketime -h usage: offwaketime [-h] [-p PID | -t TID | -u | -k] [-U | -K] [-d] [-f] [--stack-storage-size STACK_STORAGE_SIZE] - [-m MIN_BLOCK_TIME] [-M MAX_BLOCK_TIME] + [-m MIN_BLOCK_TIME] [-M MAX_BLOCK_TIME] [--state STATE] [duration] Summarize blocked time by kernel stack trace + waker stack @@ -340,6 +340,8 @@ optional arguments: -M MAX_BLOCK_TIME, --max-block-time MAX_BLOCK_TIME the amount of time in microseconds under which we store traces (default U64_MAX) + --state STATE filter on this thread state bitmask (eg, 2 == + TASK_UNINTERRUPTIBLE) see include/linux/sched.h examples: ./offwaketime # trace off-CPU + waker stack time until Ctrl-C From f3fbeb46cb5264d324e60882bd97977ad3dc00d5 Mon Sep 17 00:00:00 2001 From: Anton Protopopov Date: Mon, 1 Jun 2020 21:22:02 -0400 Subject: [PATCH 138/278] libbpf-tools: convert BCC syscount to BPF CO-RE version Add a new libbpf-based tool, syscount, and add some helpers which may be used by other tools. Namely, * syscall_helpers.{c,h}: convert system call numbers to names * errno_helpers.{c,h}: convert errno names to numbers The helpers contain pre-generated tables for x86_64 (which will be outdated at some point, so require to be updated on demand), but for other architectures require additional tools: syscall helpers require the ausyscall(1) tool, and errno helpers require errno(1) utility from the moreutils package. So, if you run on non-x86_64, then either install these tools, or use numeric values. If possible, use bpf_map_lookup_and_delete_batch function to read and reset values in the data map. This is a raceless way to obtain all values. If the function is not available, e.g., for old kernels, then fall back to the old version which can loose some syscalls (happened between reading values and resetting them). Signed-off-by: Anton Protopopov --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 19 +- libbpf-tools/drsnoop.c | 2 +- libbpf-tools/errno_helpers.c | 232 +++++++++++++++ libbpf-tools/errno_helpers.h | 7 + libbpf-tools/filelife.c | 2 +- libbpf-tools/syscall_helpers.c | 526 +++++++++++++++++++++++++++++++++ libbpf-tools/syscall_helpers.h | 12 + libbpf-tools/syscount.bpf.c | 120 ++++++++ libbpf-tools/syscount.c | 482 ++++++++++++++++++++++++++++++ libbpf-tools/syscount.h | 16 + libbpf-tools/xfsslower.c | 2 +- 12 files changed, 1416 insertions(+), 5 deletions(-) create mode 100644 libbpf-tools/errno_helpers.c create mode 100644 libbpf-tools/errno_helpers.h create mode 100644 libbpf-tools/syscall_helpers.c create mode 100644 libbpf-tools/syscall_helpers.h create mode 100644 libbpf-tools/syscount.bpf.c create mode 100644 libbpf-tools/syscount.c create mode 100644 libbpf-tools/syscount.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 50bf5f8b1..859a5292d 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -4,5 +4,6 @@ /filelife /opensnoop /runqslower +/syscount /vfsstat /xfsslower diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 819dd2e12..73feb6598 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -9,7 +9,22 @@ INCLUDES := -I$(OUTPUT) CFLAGS := -g -O2 -Wall ARCH := $(shell uname -m | sed 's/x86_64/x86/') -APPS = drsnoop execsnoop filelife opensnoop runqslower vfsstat xfsslower +APPS = \ + drsnoop \ + execsnoop \ + filelife \ + opensnoop \ + runqslower \ + syscount \ + vfsstat \ + xfsslower \ + # + +COMMON_OBJ = \ + $(OUTPUT)/trace_helpers.o \ + $(OUTPUT)/syscall_helpers.o \ + $(OUTPUT)/errno_helpers.o \ + # .PHONY: all all: $(APPS) @@ -32,7 +47,7 @@ $(OUTPUT) $(OUTPUT)/libbpf: $(call msg,MKDIR,$@) $(Q)mkdir -p $@ -$(APPS): %: $(OUTPUT)/%.o $(LIBBPF_OBJ) $(OUTPUT)/trace_helpers.o | $(OUTPUT) +$(APPS): %: $(OUTPUT)/%.o $(LIBBPF_OBJ) $(COMMON_OBJ) | $(OUTPUT) $(call msg,BINARY,$@) $(Q)$(CC) $(CFLAGS) $^ -lelf -lz -o $@ diff --git a/libbpf-tools/drsnoop.c b/libbpf-tools/drsnoop.c index a31626f9c..6c0da7981 100644 --- a/libbpf-tools/drsnoop.c +++ b/libbpf-tools/drsnoop.c @@ -167,7 +167,7 @@ int main(int argc, char **argv) obj = drsnoop_bpf__open(); if (!obj) { - fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + fprintf(stderr, "failed to open and/or load BPF object\n"); return 1; } diff --git a/libbpf-tools/errno_helpers.c b/libbpf-tools/errno_helpers.c new file mode 100644 index 000000000..786d2e98f --- /dev/null +++ b/libbpf-tools/errno_helpers.c @@ -0,0 +1,232 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Anton Protopopov +#include +#include +#include +#include +#include + +#define warn(...) fprintf(stderr, __VA_ARGS__) + +#ifdef __x86_64__ +static int errno_by_name_x86_64(const char *errno_name) +{ + +#define strcase(X, N) if (!strcmp(errno_name, (X))) return N + + strcase("EPERM", 1); + strcase("ENOENT", 2); + strcase("ESRCH", 3); + strcase("EINTR", 4); + strcase("EIO", 5); + strcase("ENXIO", 6); + strcase("E2BIG", 7); + strcase("ENOEXEC", 8); + strcase("EBADF", 9); + strcase("ECHILD", 10); + strcase("EAGAIN", 11); + strcase("EWOULDBLOCK", 11); + strcase("ENOMEM", 12); + strcase("EACCES", 13); + strcase("EFAULT", 14); + strcase("ENOTBLK", 15); + strcase("EBUSY", 16); + strcase("EEXIST", 17); + strcase("EXDEV", 18); + strcase("ENODEV", 19); + strcase("ENOTDIR", 20); + strcase("EISDIR", 21); + strcase("EINVAL", 22); + strcase("ENFILE", 23); + strcase("EMFILE", 24); + strcase("ENOTTY", 25); + strcase("ETXTBSY", 26); + strcase("EFBIG", 27); + strcase("ENOSPC", 28); + strcase("ESPIPE", 29); + strcase("EROFS", 30); + strcase("EMLINK", 31); + strcase("EPIPE", 32); + strcase("EDOM", 33); + strcase("ERANGE", 34); + strcase("EDEADLK", 35); + strcase("EDEADLOCK", 35); + strcase("ENAMETOOLONG", 36); + strcase("ENOLCK", 37); + strcase("ENOSYS", 38); + strcase("ENOTEMPTY", 39); + strcase("ELOOP", 40); + strcase("ENOMSG", 42); + strcase("EIDRM", 43); + strcase("ECHRNG", 44); + strcase("EL2NSYNC", 45); + strcase("EL3HLT", 46); + strcase("EL3RST", 47); + strcase("ELNRNG", 48); + strcase("EUNATCH", 49); + strcase("ENOCSI", 50); + strcase("EL2HLT", 51); + strcase("EBADE", 52); + strcase("EBADR", 53); + strcase("EXFULL", 54); + strcase("ENOANO", 55); + strcase("EBADRQC", 56); + strcase("EBADSLT", 57); + strcase("EBFONT", 59); + strcase("ENOSTR", 60); + strcase("ENODATA", 61); + strcase("ETIME", 62); + strcase("ENOSR", 63); + strcase("ENONET", 64); + strcase("ENOPKG", 65); + strcase("EREMOTE", 66); + strcase("ENOLINK", 67); + strcase("EADV", 68); + strcase("ESRMNT", 69); + strcase("ECOMM", 70); + strcase("EPROTO", 71); + strcase("EMULTIHOP", 72); + strcase("EDOTDOT", 73); + strcase("EBADMSG", 74); + strcase("EOVERFLOW", 75); + strcase("ENOTUNIQ", 76); + strcase("EBADFD", 77); + strcase("EREMCHG", 78); + strcase("ELIBACC", 79); + strcase("ELIBBAD", 80); + strcase("ELIBSCN", 81); + strcase("ELIBMAX", 82); + strcase("ELIBEXEC", 83); + strcase("EILSEQ", 84); + strcase("ERESTART", 85); + strcase("ESTRPIPE", 86); + strcase("EUSERS", 87); + strcase("ENOTSOCK", 88); + strcase("EDESTADDRREQ", 89); + strcase("EMSGSIZE", 90); + strcase("EPROTOTYPE", 91); + strcase("ENOPROTOOPT", 92); + strcase("EPROTONOSUPPORT", 93); + strcase("ESOCKTNOSUPPORT", 94); + strcase("ENOTSUP", 95); + strcase("EOPNOTSUPP", 95); + strcase("EPFNOSUPPORT", 96); + strcase("EAFNOSUPPORT", 97); + strcase("EADDRINUSE", 98); + strcase("EADDRNOTAVAIL", 99); + strcase("ENETDOWN", 100); + strcase("ENETUNREACH", 101); + strcase("ENETRESET", 102); + strcase("ECONNABORTED", 103); + strcase("ECONNRESET", 104); + strcase("ENOBUFS", 105); + strcase("EISCONN", 106); + strcase("ENOTCONN", 107); + strcase("ESHUTDOWN", 108); + strcase("ETOOMANYREFS", 109); + strcase("ETIMEDOUT", 110); + strcase("ECONNREFUSED", 111); + strcase("EHOSTDOWN", 112); + strcase("EHOSTUNREACH", 113); + strcase("EALREADY", 114); + strcase("EINPROGRESS", 115); + strcase("ESTALE", 116); + strcase("EUCLEAN", 117); + strcase("ENOTNAM", 118); + strcase("ENAVAIL", 119); + strcase("EISNAM", 120); + strcase("EREMOTEIO", 121); + strcase("EDQUOT", 122); + strcase("ENOMEDIUM", 123); + strcase("EMEDIUMTYPE", 124); + strcase("ECANCELED", 125); + strcase("ENOKEY", 126); + strcase("EKEYEXPIRED", 127); + strcase("EKEYREVOKED", 128); + strcase("EKEYREJECTED", 129); + strcase("EOWNERDEAD", 130); + strcase("ENOTRECOVERABLE", 131); + strcase("ERFKILL", 132); + strcase("EHWPOISON", 133); + +#undef strcase + + return -1; + +} +#endif + +/* Try to find the errno number using the errno(1) program */ +static int errno_by_name_dynamic(const char *errno_name) +{ + int len = strlen(errno_name); + int err, number = -1; + char buf[128]; + char cmd[64]; + char *end; + long val; + FILE *f; + + /* sanity check to not call popen with random input */ + for (int i = 0; i < len; i++) { + if (errno_name[i] < 'A' || errno_name[i] > 'Z') { + warn("errno_name contains invalid char 0x%02x: %s\n", + errno_name[i], errno_name); + return -1; + } + } + + snprintf(cmd, sizeof(cmd), "errno %s", errno_name); + f = popen(cmd, "r"); + if (!f) { + warn("popen: %s: %s\n", cmd, strerror(errno)); + return -1; + } + + if (!fgets(buf, sizeof(buf), f)) { + goto close; + } else if (ferror(f)) { + warn("fgets: %s\n", strerror(errno)); + goto close; + } + + // expecting " " + if (strncmp(errno_name, buf, len) || strlen(buf) < len+2) { + warn("expected '%s': %s\n", errno_name, buf); + goto close; + } + errno = 0; + val = strtol(buf+len+2, &end, 10); + if (errno || end == (buf+len+2) || number < 0 || number > INT_MAX) { + warn("can't parse the second column, expected int: %s\n", buf); + goto close; + } + number = val; + +close: + err = pclose(f); + if (err < 0) + warn("pclose: %s\n", strerror(errno)); +#ifndef __x86_64__ + /* Ignore the error for x86_64 where we have a table compiled in */ + else if (err && WEXITSTATUS(err) == 127) { + warn("errno(1) required for errno name/number mapping\n"); + } else if (err) { + warn("errno(1) exit status (see wait(2)): 0x%x\n", err); + } +#endif + return number; +} + +int errno_by_name(const char *errno_name) +{ +#ifdef __x86_64__ + int err; + + err = errno_by_name_x86_64(errno_name); + if (err >= 0) + return err; +#endif + + return errno_by_name_dynamic(errno_name); +} diff --git a/libbpf-tools/errno_helpers.h b/libbpf-tools/errno_helpers.h new file mode 100644 index 000000000..4c154fb6a --- /dev/null +++ b/libbpf-tools/errno_helpers.h @@ -0,0 +1,7 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __ERRNO_HELPERS_H +#define __ERRNO_HELPERS_H + +int errno_by_name(const char *errno_name); + +#endif /* __ERRNO_HELPERS_H */ diff --git a/libbpf-tools/filelife.c b/libbpf-tools/filelife.c index f21a68455..020f04879 100644 --- a/libbpf-tools/filelife.c +++ b/libbpf-tools/filelife.c @@ -127,7 +127,7 @@ int main(int argc, char **argv) obj = filelife_bpf__open(); if (!obj) { - fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + fprintf(stderr, "failed to open and/or load BPF object\n"); return 1; } diff --git a/libbpf-tools/syscall_helpers.c b/libbpf-tools/syscall_helpers.c new file mode 100644 index 000000000..c72a17097 --- /dev/null +++ b/libbpf-tools/syscall_helpers.c @@ -0,0 +1,526 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Anton Protopopov +#include +#include +#include +#include +#include + +static const char **syscall_names; +static size_t syscall_names_size; + +#define warn(...) fprintf(stderr, __VA_ARGS__) +#define MAX(x, y) (((x) > (y)) ? (x) : (y)) + +static const char *parse_syscall(const char *buf, int *number) +{ + char *end; + long x; + + errno = 0; + x = strtol(buf, &end, 10); + if (errno) { + warn("strtol(%s): %s\n", buf, strerror(errno)); + return NULL; + } else if (end == buf) { + warn("strtol(%s): no digits found\n", buf); + return NULL; + } else if (x < 0 || x > INT_MAX) { + warn("strtol(%s): bad syscall number: %ld\n", buf, x); + return NULL; + } + if (*end != '\t') { + warn("bad input: %s (expected \t)\n", buf); + return NULL; + } + + *number = x; + return ++end; +} + +void init_syscall_names(void) +{ + size_t old_size, size = 1024; + const char *name; + char buf[64]; + int number; + int err; + FILE *f; + + f = popen("ausyscall --dump 2>/dev/null", "r"); + if (!f) { + warn("popen: ausyscall --dump: %s\n", strerror(errno)); + return; + } + + syscall_names = calloc(size, sizeof(char *)); + if (!syscall_names) { + warn("calloc: %s\n", strerror(errno)); + goto close; + } + + /* skip the header */ + fgets(buf, sizeof(buf), f); + + while (fgets(buf, sizeof(buf), f)) { + if (buf[strlen(buf) - 1] == '\n') + buf[strlen(buf) - 1] = '\0'; + + name = parse_syscall(buf, &number); + if (!name || !name[0]) + goto close; + + /* In a rare case when syscall number is > than initial 1024 */ + if (number >= size) { + old_size = size; + size = 1024 * (1 + number / 1024); + syscall_names = realloc(syscall_names, + size * sizeof(char *)); + if (!syscall_names) { + warn("realloc: %s\n", strerror(errno)); + goto close; + } + memset(syscall_names+old_size, 0, + (size - old_size) * sizeof(char *)); + } + + if (syscall_names[number]) { + warn("duplicate number: %d (stored: %s)", + number, syscall_names[number]); + goto close; + } + + syscall_names[number] = strdup(name); + if (!syscall_names[number]) { + warn("strdup: %s\n", strerror(errno)); + goto close; + } + syscall_names_size = MAX(number+1, syscall_names_size); + } + + if (ferror(f)) + warn("fgets: %s\n", strerror(errno)); +close: + err = pclose(f); + if (err < 0) + warn("pclose: %s\n", strerror(errno)); +#ifndef __x86_64__ + /* Ignore the error for x86_64 where we have a table compiled in */ + else if (err && WEXITSTATUS(err) == 127) { + warn("ausyscall required for syscalls number/name mapping\n"); + } else if (err) { + warn("ausyscall exit status (see wait(2)): 0x%x\n", err); + } +#endif +} + +void free_syscall_names(void) +{ + for (size_t i = 0; i < syscall_names_size; i++) + free((void *) syscall_names[i]); + free(syscall_names); +} + +/* + * Syscall table for Linux x86_64. + * + * Semi-automatically generated from strace/linux/x86_64/syscallent.h and + * linux/syscallent-common.h using the following commands: + * + * awk -F\" '/SEN/{printf("%d %s\n", substr($0,2,3), $(NF-1));}' syscallent.h + * awk '/SEN/ { printf("%d %s\n", $3, $9); }' syscallent-common.h + * + * (The idea is taken from src/python/bcc/syscall.py.) + */ +#ifdef __x86_64__ +static const char *syscall_names_x86_64[] = { + [0] = "read", + [1] = "write", + [2] = "open", + [3] = "close", + [4] = "stat", + [5] = "fstat", + [6] = "lstat", + [7] = "poll", + [8] = "lseek", + [9] = "mmap", + [10] = "mprotect", + [11] = "munmap", + [12] = "brk", + [13] = "rt_sigaction", + [14] = "rt_sigprocmask", + [15] = "rt_sigreturn", + [16] = "ioctl", + [17] = "pread64", + [18] = "pwrite64", + [19] = "readv", + [20] = "writev", + [21] = "access", + [22] = "pipe", + [23] = "select", + [24] = "sched_yield", + [25] = "mremap", + [26] = "msync", + [27] = "mincore", + [28] = "madvise", + [29] = "shmget", + [30] = "shmat", + [31] = "shmctl", + [32] = "dup", + [33] = "dup2", + [34] = "pause", + [35] = "nanosleep", + [36] = "getitimer", + [37] = "alarm", + [38] = "setitimer", + [39] = "getpid", + [40] = "sendfile", + [41] = "socket", + [42] = "connect", + [43] = "accept", + [44] = "sendto", + [45] = "recvfrom", + [46] = "sendmsg", + [47] = "recvmsg", + [48] = "shutdown", + [49] = "bind", + [50] = "listen", + [51] = "getsockname", + [52] = "getpeername", + [53] = "socketpair", + [54] = "setsockopt", + [55] = "getsockopt", + [56] = "clone", + [57] = "fork", + [58] = "vfork", + [59] = "execve", + [60] = "exit", + [61] = "wait4", + [62] = "kill", + [63] = "uname", + [64] = "semget", + [65] = "semop", + [66] = "semctl", + [67] = "shmdt", + [68] = "msgget", + [69] = "msgsnd", + [70] = "msgrcv", + [71] = "msgctl", + [72] = "fcntl", + [73] = "flock", + [74] = "fsync", + [75] = "fdatasync", + [76] = "truncate", + [77] = "ftruncate", + [78] = "getdents", + [79] = "getcwd", + [80] = "chdir", + [81] = "fchdir", + [82] = "rename", + [83] = "mkdir", + [84] = "rmdir", + [85] = "creat", + [86] = "link", + [87] = "unlink", + [88] = "symlink", + [89] = "readlink", + [90] = "chmod", + [91] = "fchmod", + [92] = "chown", + [93] = "fchown", + [94] = "lchown", + [95] = "umask", + [96] = "gettimeofday", + [97] = "getrlimit", + [98] = "getrusage", + [99] = "sysinfo", + [100] = "times", + [101] = "ptrace", + [102] = "getuid", + [103] = "syslog", + [104] = "getgid", + [105] = "setuid", + [106] = "setgid", + [107] = "geteuid", + [108] = "getegid", + [109] = "setpgid", + [110] = "getppid", + [111] = "getpgrp", + [112] = "setsid", + [113] = "setreuid", + [114] = "setregid", + [115] = "getgroups", + [116] = "setgroups", + [117] = "setresuid", + [118] = "getresuid", + [119] = "setresgid", + [120] = "getresgid", + [121] = "getpgid", + [122] = "setfsuid", + [123] = "setfsgid", + [124] = "getsid", + [125] = "capget", + [126] = "capset", + [127] = "rt_sigpending", + [128] = "rt_sigtimedwait", + [129] = "rt_sigqueueinfo", + [130] = "rt_sigsuspend", + [131] = "sigaltstack", + [132] = "utime", + [133] = "mknod", + [134] = "uselib", + [135] = "personality", + [136] = "ustat", + [137] = "statfs", + [138] = "fstatfs", + [139] = "sysfs", + [140] = "getpriority", + [141] = "setpriority", + [142] = "sched_setparam", + [143] = "sched_getparam", + [144] = "sched_setscheduler", + [145] = "sched_getscheduler", + [146] = "sched_get_priority_max", + [147] = "sched_get_priority_min", + [148] = "sched_rr_get_interval", + [149] = "mlock", + [150] = "munlock", + [151] = "mlockall", + [152] = "munlockall", + [153] = "vhangup", + [154] = "modify_ldt", + [155] = "pivot_root", + [156] = "_sysctl", + [157] = "prctl", + [158] = "arch_prctl", + [159] = "adjtimex", + [160] = "setrlimit", + [161] = "chroot", + [162] = "sync", + [163] = "acct", + [164] = "settimeofday", + [165] = "mount", + [166] = "umount2", + [167] = "swapon", + [168] = "swapoff", + [169] = "reboot", + [170] = "sethostname", + [171] = "setdomainname", + [172] = "iopl", + [173] = "ioperm", + [174] = "create_module", + [175] = "init_module", + [176] = "delete_module", + [177] = "get_kernel_syms", + [178] = "query_module", + [179] = "quotactl", + [180] = "nfsservctl", + [181] = "getpmsg", + [182] = "putpmsg", + [183] = "afs_syscall", + [184] = "tuxcall", + [185] = "security", + [186] = "gettid", + [187] = "readahead", + [188] = "setxattr", + [189] = "lsetxattr", + [190] = "fsetxattr", + [191] = "getxattr", + [192] = "lgetxattr", + [193] = "fgetxattr", + [194] = "listxattr", + [195] = "llistxattr", + [196] = "flistxattr", + [197] = "removexattr", + [198] = "lremovexattr", + [199] = "fremovexattr", + [200] = "tkill", + [201] = "time", + [202] = "futex", + [203] = "sched_setaffinity", + [204] = "sched_getaffinity", + [205] = "set_thread_area", + [206] = "io_setup", + [207] = "io_destroy", + [208] = "io_getevents", + [209] = "io_submit", + [210] = "io_cancel", + [211] = "get_thread_area", + [212] = "lookup_dcookie", + [213] = "epoll_create", + [214] = "epoll_ctl_old", + [215] = "epoll_wait_old", + [216] = "remap_file_pages", + [217] = "getdents64", + [218] = "set_tid_address", + [219] = "restart_syscall", + [220] = "semtimedop", + [221] = "fadvise64", + [222] = "timer_create", + [223] = "timer_settime", + [224] = "timer_gettime", + [225] = "timer_getoverrun", + [226] = "timer_delete", + [227] = "clock_settime", + [228] = "clock_gettime", + [229] = "clock_getres", + [230] = "clock_nanosleep", + [231] = "exit_group", + [232] = "epoll_wait", + [233] = "epoll_ctl", + [234] = "tgkill", + [235] = "utimes", + [236] = "vserver", + [237] = "mbind", + [238] = "set_mempolicy", + [239] = "get_mempolicy", + [240] = "mq_open", + [241] = "mq_unlink", + [242] = "mq_timedsend", + [243] = "mq_timedreceive", + [244] = "mq_notify", + [245] = "mq_getsetattr", + [246] = "kexec_load", + [247] = "waitid", + [248] = "add_key", + [249] = "request_key", + [250] = "keyctl", + [251] = "ioprio_set", + [252] = "ioprio_get", + [253] = "inotify_init", + [254] = "inotify_add_watch", + [255] = "inotify_rm_watch", + [256] = "migrate_pages", + [257] = "openat", + [258] = "mkdirat", + [259] = "mknodat", + [260] = "fchownat", + [261] = "futimesat", + [262] = "newfstatat", + [263] = "unlinkat", + [264] = "renameat", + [265] = "linkat", + [266] = "symlinkat", + [267] = "readlinkat", + [268] = "fchmodat", + [269] = "faccessat", + [270] = "pselect6", + [271] = "ppoll", + [272] = "unshare", + [273] = "set_robust_list", + [274] = "get_robust_list", + [275] = "splice", + [276] = "tee", + [277] = "sync_file_range", + [278] = "vmsplice", + [279] = "move_pages", + [280] = "utimensat", + [281] = "epoll_pwait", + [282] = "signalfd", + [283] = "timerfd_create", + [284] = "eventfd", + [285] = "fallocate", + [286] = "timerfd_settime", + [287] = "timerfd_gettime", + [288] = "accept4", + [289] = "signalfd4", + [290] = "eventfd2", + [291] = "epoll_create1", + [292] = "dup3", + [293] = "pipe2", + [294] = "inotify_init1", + [295] = "preadv", + [296] = "pwritev", + [297] = "rt_tgsigqueueinfo", + [298] = "perf_event_open", + [299] = "recvmmsg", + [300] = "fanotify_init", + [301] = "fanotify_mark", + [302] = "prlimit64", + [303] = "name_to_handle_at", + [304] = "open_by_handle_at", + [305] = "clock_adjtime", + [306] = "syncfs", + [307] = "sendmmsg", + [308] = "setns", + [309] = "getcpu", + [310] = "process_vm_readv", + [311] = "process_vm_writev", + [312] = "kcmp", + [313] = "finit_module", + [314] = "sched_setattr", + [315] = "sched_getattr", + [316] = "renameat2", + [317] = "seccomp", + [318] = "getrandom", + [319] = "memfd_create", + [320] = "kexec_file_load", + [321] = "bpf", + [322] = "execveat", + [323] = "userfaultfd", + [324] = "membarrier", + [325] = "mlock2", + [326] = "copy_file_range", + [327] = "preadv2", + [328] = "pwritev2", + [329] = "pkey_mprotect", + [330] = "pkey_alloc", + [331] = "pkey_free", + [332] = "statx", + [333] = "io_pgetevents", + [334] = "rseq", + [424] = "pidfd_send_signal", + [425] = "io_uring_setup", + [426] = "io_uring_enter", + [427] = "io_uring_register", + [428] = "open_tree", + [429] = "move_mount", + [430] = "fsopen", + [431] = "fsconfig", + [432] = "fsmount", + [433] = "fspick", + [434] = "pidfd_open", + [435] = "clone3", + [437] = "openat2", + [438] = "pidfd_getfd", +}; +size_t syscall_names_x86_64_size = sizeof(syscall_names_x86_64)/sizeof(char*); +#endif + +void syscall_name(unsigned n, char *buf, size_t size) +{ + const char *name = NULL; + + if (n < syscall_names_size) + name = syscall_names[n]; +#ifdef __x86_64__ + else if (n < syscall_names_x86_64_size) + name = syscall_names_x86_64[n]; +#endif + + if (name) + strncpy(buf, name, size-1); + else + snprintf(buf, size, "[unknown: %u]", n); +} + +int list_syscalls(void) +{ + const char **list = syscall_names; + size_t size = syscall_names_size; + +#ifdef __x86_64__ + if (!size) { + size = syscall_names_x86_64_size; + list = syscall_names_x86_64; + } +#endif + + for (size_t i = 0; i < size; i++) { + if (list[i]) + printf("%3zd: %s\n", i, list[i]); + } + + return (!list || !size); +} + diff --git a/libbpf-tools/syscall_helpers.h b/libbpf-tools/syscall_helpers.h new file mode 100644 index 000000000..06f296555 --- /dev/null +++ b/libbpf-tools/syscall_helpers.h @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __SYSCALL_HELPERS_H +#define __SYSCALL_HELPERS_H + +#include + +void init_syscall_names(void); +void free_syscall_names(void); +void list_syscalls(void); +void syscall_name(unsigned n, char *buf, size_t size); + +#endif /* __SYSCALL_HELPERS_H */ diff --git a/libbpf-tools/syscount.bpf.c b/libbpf-tools/syscount.bpf.c new file mode 100644 index 000000000..ffac0be2d --- /dev/null +++ b/libbpf-tools/syscount.bpf.c @@ -0,0 +1,120 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Anton Protopopov +// +// Based on syscount(8) from BCC by Sasha Goldshtein +#include "vmlinux.h" +#include +#include +#include +#include +#include "syscount.h" + +const volatile bool count_by_process = false; +const volatile bool measure_latency = false; +const volatile bool filter_failed = false; +const volatile int filter_errno = false; +const volatile pid_t filter_pid = 0; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, u32); + __type(value, u64); + __uint(map_flags, BPF_F_NO_PREALLOC); +} start SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, u32); + __type(value, struct data_t); + __uint(map_flags, BPF_F_NO_PREALLOC); +} data SEC(".maps"); + +static __always_inline +void *bpf_map_lookup_or_try_init(void *map, void *key, const void *init) +{ + void *val; + int err; + + val = bpf_map_lookup_elem(map, key); + if (val) + return val; + + err = bpf_map_update_elem(map, key, init, 0); + if (err) + return (void *) 0; + + return bpf_map_lookup_elem(map, key); +} + +static __always_inline +void save_proc_name(struct data_t *val) +{ + struct task_struct *current = (void *)bpf_get_current_task(); + + /* We should save the process name every time because it can be + * changed (e.g., by exec). This can be optimized later by managing + * this field with the help of tp/sched/sched_process_exec and + * raw_tp/task_rename. */ + BPF_CORE_READ_STR_INTO(&val->comm, current, group_leader, comm); +} + +SEC("tracepoint/raw_syscalls/sys_enter") +int sys_enter(struct trace_event_raw_sys_enter *args) +{ + u64 id = bpf_get_current_pid_tgid(); + pid_t pid = id >> 32; + u32 tid = id; + u64 ts; + + if (filter_pid && pid != filter_pid) + return 0; + + ts = bpf_ktime_get_ns(); + bpf_map_update_elem(&start, &tid, &ts, 0); + return 0; +} + +SEC("tracepoint/raw_syscalls/sys_exit") +int sys_exit(struct trace_event_raw_sys_exit *args) +{ + struct task_struct *current; + u64 id = bpf_get_current_pid_tgid(); + static const struct data_t zero; + pid_t pid = id >> 32; + struct data_t *val; + u64 *start_ts; + u32 tid = id; + u32 key; + + /* this happens when there is an interrupt */ + if (args->id == -1) + return 0; + + if (filter_pid && pid != filter_pid) + return 0; + if (filter_failed && args->ret >= 0) + return 0; + if (filter_errno && args->ret != -filter_errno) + return 0; + + if (measure_latency) { + start_ts = bpf_map_lookup_elem(&start, &tid); + if (!start_ts) + return 0; + } + + key = (count_by_process) ? pid : args->id; + val = bpf_map_lookup_or_try_init(&data, &key, &zero); + if (val) { + val->count++; + if (count_by_process) + save_proc_name(val); + if (measure_latency) + val->total_ns += bpf_ktime_get_ns() - *start_ts; + } + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/syscount.c b/libbpf-tools/syscount.c new file mode 100644 index 000000000..98cb5c6ad --- /dev/null +++ b/libbpf-tools/syscount.c @@ -0,0 +1,482 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Anton Protopopov +// +// Based on syscount(8) from BCC by Sasha Goldshtein +#include +#include +#include +#include +#include +#include +#include +#include "syscount.h" +#include "syscount.skel.h" +#include "errno_helpers.h" +#include "syscall_helpers.h" + +/* This structure extends data_t by adding a key item which should be sorted + * together with the count and total_ns fields */ +struct data_ext_t { + __u64 count; + __u64 total_ns; + char comm[TASK_COMM_LEN]; + __u32 key; +}; + + +#define warn(...) fprintf(stderr, __VA_ARGS__) + +const char *argp_program_version = "syscount 0.1"; +const char *argp_program_bug_address = ""; +static const char argp_program_doc[] = +"\nsyscount: summarize syscall counts and latencies\n" +"\n" +"EXAMPLES:\n" +" syscount # print top 10 syscalls by count every second\n" +" syscount -p $(pidof dd) # look only at a particular process\n" +" syscount -L # measure and sort output by latency\n" +" syscount -P # group statistics by pid, not by syscall\n" +" syscount -x -i 5 # count only failed syscalls\n" +" syscount -e ENOENT -i 5 # count only syscalls failed with a given errno" +; + +static const struct argp_option opts[] = { + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + { "pid", 'p', "PID", 0, "Process PID to trace" }, + { "interval", 'i', "INTERVAL", 0, "Print summary at this interval" + " (seconds), 0 for infinite wait (default)" }, + { "duration", 'd', "DURATION", 0, "Total tracing duration (seconds)" }, + { "top", 'T', "TOP", 0, "Print only the top syscalls (default 10)" }, + { "failures", 'x', NULL, 0, "Trace only failed syscalls" }, + { "latency", 'L', NULL, 0, "Collect syscall latency" }, + { "milliseconds", 'm', NULL, 0, "Display latency in milliseconds" + " (default: microseconds)" }, + { "process", 'P', NULL, 0, "Count by process and not by syscall" }, + { "errno", 'e', "ERRNO", 0, "Trace only syscalls that return this error" + "(numeric or EPERM, etc.)" }, + { "list", 'l', NULL, 0, "Print list of recognized syscalls and exit" }, + {}, +}; + +static struct env { + bool list_syscalls; + bool milliseconds; + bool failures; + bool verbose; + bool latency; + bool process; + int filter_errno; + int interval; + int duration; + int top; + pid_t pid; +} env = { + .top = 10, +}; + +static int get_int(const char *arg, int *ret, int min, int max) +{ + char *end; + long val; + + errno = 0; + val = strtol(arg, &end, 10); + if (errno) { + warn("strtol: %s: %s\n", arg, strerror(errno)); + return -1; + } else if (end == arg || val < min || val > max) { + return -1; + } + if (ret) + *ret = val; + return 0; +} + +static int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + + return vfprintf(stderr, format, args); +} + +static int bump_memlock_rlimit(void) +{ + struct rlimit rlim_new = { + .rlim_cur = RLIM_INFINITY, + .rlim_max = RLIM_INFINITY, + }; + + return setrlimit(RLIMIT_MEMLOCK, &rlim_new); +} + +static int compar_count(const void *dx, const void *dy) +{ + __u64 x = ((struct data_ext_t *) dx)->count; + __u64 y = ((struct data_ext_t *) dy)->count; + return x > y ? -1 : !(x == y); +} + +static int compar_latency(const void *dx, const void *dy) +{ + __u64 x = ((struct data_ext_t *) dx)->total_ns; + __u64 y = ((struct data_ext_t *) dy)->total_ns; + return x > y ? -1 : !(x == y); +} + +static const char *agg_col(struct data_ext_t *val, char *buf, size_t size) +{ + if (env.process) { + snprintf(buf, size, "%-6u %-15s", val->key, val->comm); + } else { + syscall_name(val->key, buf, size); + } + return buf; +} + +static const char *agg_colname(void) +{ + return (env.process) ? "PID COMM" : "SYSCALL"; +} + +static const char *time_colname(void) +{ + return (env.milliseconds) ? "TIME (ms)" : "TIME (us)"; +} + +static void print_latency_header(void) +{ + printf("%-22s %8s %16s\n", agg_colname(), "COUNT", time_colname()); +} + +static void print_count_header(void) +{ + printf("%-22s %8s\n", agg_colname(), "COUNT"); +} + +static void print_latency(struct data_ext_t *vals, size_t count) +{ + double div = env.milliseconds ? 1000000.0 : 1000.0; + char buf[2 * TASK_COMM_LEN]; + + print_latency_header(); + for (int i = 0; i < count && i < env.top; i++) + printf("%-22s %8llu %16.3lf\n", + agg_col(&vals[i], buf, sizeof(buf)), + vals[i].count, vals[i].total_ns / div); + printf("\n"); +} + +static void print_count(struct data_ext_t *vals, size_t count) +{ + char buf[2 * TASK_COMM_LEN]; + + print_count_header(); + for (int i = 0; i < count && i < env.top; i++) + printf("%-22s %8llu\n", + agg_col(&vals[i], buf, sizeof(buf)), vals[i].count); + printf("\n"); +} + +static void print_timestamp() +{ + time_t now = time(NULL); + struct tm tm; + + if (localtime_r(&now, &tm)) + printf("[%02d:%02d:%02d]\n", tm.tm_hour, tm.tm_min, tm.tm_sec); + else + warn("localtime_r: %s", strerror(errno)); +} + +static bool batch_map_ops = true; /* hope for the best */ + +static bool read_vals_batch(int fd, struct data_ext_t *vals, __u32 *count) +{ + struct data_t orig_vals[*count]; + void *in = NULL, *out; + __u32 n, n_read = 0; + __u32 keys[*count]; + int err = 0; + + while (n_read < *count && !err) { + n = *count - n_read; + err = bpf_map_lookup_and_delete_batch(fd, &in, &out, + keys + n_read, orig_vals + n_read, &n, NULL); + if (err && errno != ENOENT) { + /* we want to propagate EINVAL upper, so that + * the batch_map_ops flag is set to false */ + if (errno != EINVAL) + warn("bpf_map_lookup_and_delete_batch: %s\n", + strerror(-err)); + return false; + } + n_read += n; + in = out; + } + + for (__u32 i = 0; i < n_read; i++) { + vals[i].count = orig_vals[i].count; + vals[i].total_ns = orig_vals[i].total_ns; + vals[i].key = keys[i]; + strncpy(vals[i].comm, orig_vals[i].comm, TASK_COMM_LEN); + } + + *count = n_read; + return true; +} + +static bool read_vals(int fd, struct data_ext_t *vals, __u32 *count) +{ + __u32 keys[MAX_ENTRIES]; + struct data_t val; + __u32 key = -1; + __u32 next_key; + int i = 0; + int err; + + if (batch_map_ops) { + bool ok = read_vals_batch(fd, vals, count); + if (!ok && errno == EINVAL) { + /* fall back to a racy variant */ + batch_map_ops = false; + } else { + return ok; + } + } + + if (!vals || !count || !*count) + return true; + + for (key = -1; i < *count; ) { + err = bpf_map_get_next_key(fd, &key, &next_key); + if (err && errno != ENOENT) { + warn("failed to get next key: %s\n", strerror(errno)); + return false; + } else if (err) { + break; + } + key = keys[i++] = next_key; + } + + for (int j = 0; j < i; j++) { + err = bpf_map_lookup_elem(fd, &keys[j], &val); + if (err && errno != ENOENT) { + warn("failed to lookup element: %s\n", strerror(errno)); + return false; + } + vals[j].count = val.count; + vals[j].total_ns = val.total_ns; + vals[j].key = keys[j]; + memcpy(vals[j].comm, val.comm, TASK_COMM_LEN); + } + + /* There is a race here: system calls which are represented by keys + * above and happened between lookup and delete will be ignored. This + * will be fixed in future by using bpf_map_lookup_and_delete_batch, + * but this function is too fresh to use it in bcc. */ + + for (int j = 0; j < i; j++) { + err = bpf_map_delete_elem(fd, &keys[j]); + if (err) { + warn("failed to delete element: %s\n", strerror(errno)); + return false; + } + } + + *count = i; + return true; +} + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + int number; + int err; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'x': + env.failures = true; + break; + case 'L': + env.latency = true; + break; + case 'm': + env.milliseconds = true; + break; + case 'P': + env.process = true; + break; + case 'p': + err = get_int(arg, &env.pid, 1, INT_MAX); + if (err) { + warn("invalid PID: %s\n", arg); + argp_usage(state); + } + break; + case 'i': + err = get_int(arg, &env.interval, 0, INT_MAX); + if (err) { + warn("invalid INTERVAL: %s\n", arg); + argp_usage(state); + } + break; + case 'd': + err = get_int(arg, &env.duration, 1, INT_MAX); + if (err) { + warn("invalid DURATION: %s\n", arg); + argp_usage(state); + } + break; + case 'T': + err = get_int(arg, &env.top, 1, INT_MAX); + if (err) { + warn("invalid TOP: %s\n", arg); + argp_usage(state); + } + break; + case 'e': + err = get_int(arg, &number, 1, INT_MAX); + if (err) { + number = errno_by_name(arg); + if (number < 0) { + warn("invalid errno: %s (bad, or can't " + "parse dynamically; consider using " + "numeric value and/or installing the " + "errno program from moreutils)\n", arg); + argp_usage(state); + } + } + env.filter_errno = number; + break; + case 'l': + env.list_syscalls = true; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +static volatile sig_atomic_t hang_on = 1; + +void sig_int(int signo) +{ + hang_on = 0; +} + +int main(int argc, char **argv) +{ + void (*print)(struct data_ext_t *, size_t); + int (*compar)(const void *, const void *); + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct data_ext_t vals[MAX_ENTRIES]; + struct syscount_bpf *obj; + int seconds = 0; + __u32 count; + int err; + + init_syscall_names(); + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + goto free_names; + + if (env.list_syscalls) { + list_syscalls(); + goto free_names; + } + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + warn("failed to increase rlimit: %s\n", strerror(errno)); + goto free_names; + } + + obj = syscount_bpf__open(); + if (!obj) { + warn("failed to open and/or load BPF object\n"); + err = 1; + goto free_names; + } + + if (env.pid) + obj->rodata->filter_pid = env.pid; + if (env.failures) + obj->rodata->filter_failed = true; + if (env.latency) + obj->rodata->measure_latency = true; + if (env.process) + obj->rodata->count_by_process = true; + if (env.filter_errno) + obj->rodata->filter_errno = env.filter_errno; + + err = syscount_bpf__load(obj); + if (err) { + warn("failed to load BPF object: %s\n", strerror(-err)); + goto cleanup_obj; + } + + obj->links.sys_exit = bpf_program__attach(obj->progs.sys_exit); + err = libbpf_get_error(obj->links.sys_exit); + if (err) { + warn("failed to attach sys_exit program: %s\n", + strerror(-err)); + goto cleanup_obj; + } + if (env.latency) { + obj->links.sys_enter = bpf_program__attach(obj->progs.sys_enter); + err = libbpf_get_error(obj->links.sys_enter); + if (err) { + warn("failed to attach sys_enter programs: %s\n", + strerror(-err)); + goto cleanup_obj; + } + } + + if (signal(SIGINT, sig_int) == SIG_ERR) { + warn("can't set signal handler: %s\n", strerror(-errno)); + goto cleanup_obj; + } + + compar = env.latency ? compar_latency : compar_count; + print = env.latency ? print_latency : print_count; + + printf("Tracing syscalls, printing top %d... Ctrl+C to quit.\n", env.top); + while (hang_on) { + sleep(env.interval ?: 1); + if (env.duration) { + seconds += env.interval ?: 1; + if (seconds >= env.duration) + hang_on = 0; + } + if (hang_on && !env.interval) + continue; + + count = MAX_ENTRIES; + if (!read_vals(bpf_map__fd(obj->maps.data), vals, &count)) + break; + if (!count) + continue; + + qsort(vals, count, sizeof(vals[0]), compar); + print_timestamp(); + print(vals, count); + } + +cleanup_obj: + syscount_bpf__destroy(obj); +free_names: + free_syscall_names(); + + return err != 0; +} diff --git a/libbpf-tools/syscount.h b/libbpf-tools/syscount.h new file mode 100644 index 000000000..148305a94 --- /dev/null +++ b/libbpf-tools/syscount.h @@ -0,0 +1,16 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Anton Protopopov +#ifndef __SYSCOUNT_H +#define __SYSCOUNT_H + +#define MAX_ENTRIES 8192 + +#define TASK_COMM_LEN 16 + +struct data_t { + __u64 count; + __u64 total_ns; + char comm[TASK_COMM_LEN]; +}; + +#endif /* __SYSCOUNT_H */ diff --git a/libbpf-tools/xfsslower.c b/libbpf-tools/xfsslower.c index b525eff04..d381f3f9c 100644 --- a/libbpf-tools/xfsslower.c +++ b/libbpf-tools/xfsslower.c @@ -192,7 +192,7 @@ int main(int argc, char **argv) obj = xfsslower_bpf__open(); if (!obj) { - fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + fprintf(stderr, "failed to open and/or load BPF object\n"); return 1; } From 2188d233d69baf9b49ccf5856292f56285be6d41 Mon Sep 17 00:00:00 2001 From: Edward Wu Date: Thu, 28 May 2020 09:36:21 +0800 Subject: [PATCH 139/278] tools: Add funcinterval bcc tool. Time interval between the same function as a histogram. Referenced from funclatency. --- README.md | 1 + man/man8/funcinterval.8 | 115 +++++++++++++++++++++ tools/funcinterval.py | 180 +++++++++++++++++++++++++++++++++ tools/funcinterval_example.txt | 163 +++++++++++++++++++++++++++++ 4 files changed, 459 insertions(+) create mode 100755 man/man8/funcinterval.8 create mode 100755 tools/funcinterval.py create mode 100755 tools/funcinterval_example.txt diff --git a/README.md b/README.md index 03a50c4c1..58340622d 100644 --- a/README.md +++ b/README.md @@ -115,6 +115,7 @@ pair of .c and .py files, and some are directories of files. - tools/[fileslower](tools/fileslower.py): Trace slow synchronous file reads and writes. [Examples](tools/fileslower_example.txt). - tools/[filetop](tools/filetop.py): File reads and writes by filename and process. Top for files. [Examples](tools/filetop_example.txt). - tools/[funccount](tools/funccount.py): Count kernel function calls. [Examples](tools/funccount_example.txt). +- tools/[funcinterval](tools/funcinterval.py): Time interval between the same function as a histogram. [Examples](tools/funcinterval_example.txt). - tools/[funclatency](tools/funclatency.py): Time functions and show their latency distribution. [Examples](tools/funclatency_example.txt). - tools/[funcslower](tools/funcslower.py): Trace slow kernel or user function calls. [Examples](tools/funcslower_example.txt). - tools/[gethostlatency](tools/gethostlatency.py): Show latency for getaddrinfo/gethostbyname[2] calls. [Examples](tools/gethostlatency_example.txt). diff --git a/man/man8/funcinterval.8 b/man/man8/funcinterval.8 new file mode 100755 index 000000000..89a4a7b4f --- /dev/null +++ b/man/man8/funcinterval.8 @@ -0,0 +1,115 @@ +.TH funcinterval 8 "2020-05-27" "USER COMMANDS" +.SH NAME +funcinterval \- Time interval between the same function, tracepoint as a histogram. +.SH SYNOPSIS +.B funcinterval [\-h] [\-p PID] [\-i INTERVAL] [\-d DURATION] [\-T] [\-u] [\-m] [\-v] pattern +.SH DESCRIPTION +This tool times interval between the same function as a histogram. + +eBPF/bcc is very suitable for platform performance tuning. +By funclatency, we can profile specific functions to know how latency +this function costs. However, sometimes performance drop is not about the +latency of function but the interval between function calls. +funcinterval is born for this purpose. + +This tool uses in-kernel eBPF maps for storing timestamps and the histogram, +for efficiency. + +WARNING: This uses dynamic tracing of (what can be many) functions, an +activity that has had issues on some kernel versions (risk of panics or +freezes). Test, and know what you are doing, before use. + +Since this uses BPF, only the root user can use this tool. +.SH REQUIREMENTS +CONFIG_BPF and bcc. +.SH OPTIONS +pattern +Function name. +\-h +Print usage message. +.TP +\-p PID +Trace this process ID only. +.TP +\-i INTERVAL +Print output every interval seconds. +.TP +\-d DURATION +Total duration of trace, in seconds. +.TP +\-T +Include timestamps on output. +.TP +\-u +Output histogram in microseconds. +.TP +\-m +Output histogram in milliseconds. +.TP +\-v +Print the BPF program (for debugging purposes). +.SH EXAMPLES +.TP +Time the interval of do_sys_open() kernel function as a histogram: +# +.B funcinterval do_sys_open +.TP +Time the interval of xhci_ring_ep_doorbell(), in microseconds: +# +.B funcinterval -u xhci_ring_ep_doorbell +.TP +Time the interval of do_nanosleep(), in milliseconds +# +.B funcinterval -m do_nanosleep +.TP +Output every 5 seconds, with timestamps: +# +.B funcinterval -mTi 5 vfs_read +.TP +Time process 181 only: +# +.B funcinterval -p 181 vfs_read +.TP +Time the interval of mm_vmscan_direct_reclaim_begin tracepoint: +# +.B funcinterval t:vmscan:mm_vmscan_direct_reclaim_begin +.SH FIELDS +.TP +necs +Nanosecond range +.TP +usecs +Microsecond range +.TP +msecs +Millisecond range +.TP +count +How many calls fell into this range +.TP +distribution +An ASCII bar chart to visualize the distribution (count column) +.SH OVERHEAD +This traces kernel functions and maintains in-kernel timestamps and a histogram, +which are asynchronously copied to user-space. While this method is very +efficient, the rate of kernel functions can also be very high (>1M/sec), at +which point the overhead is expected to be measurable. Measure in a test +environment and understand overheads before use. You can also use funccount +to measure the rate of kernel functions over a short duration, to set some +expectations before use. +.SH SOURCE +This is from bcc. +.IP +https://github.com/iovisor/bcc +.PP +Also look in the bcc distribution for a companion _examples.txt file containing +example usage, output, and commentary for this tool. +.SH OS +Linux +.SH STABILITY +Unstable - in development. +.SH AUTHOR +Edward Wu +.SH SEE ALSO +funclatency(8) +funccount(8) diff --git a/tools/funcinterval.py b/tools/funcinterval.py new file mode 100755 index 000000000..baac73c9a --- /dev/null +++ b/tools/funcinterval.py @@ -0,0 +1,180 @@ +#!/usr/bin/python +# @lint-avoid-python-3-compatibility-imports +# +# funcinterval Time interval between the same function, tracepoint +# as a histogram. +# +# USAGE: funcinterval [-h] [-p PID] [-i INTERVAL] [-T] [-u] [-m] [-v] pattern +# +# Run "funcinterval -h" for full usage. +# +# Copyright (c) 2020 Realtek, Inc. +# Licensed under the Apache License, Version 2.0 (the "License") +# +# 03-Jun-2020 Edward Wu Referenced funclatency and created this. + +from __future__ import print_function +from bcc import BPF +from time import sleep, strftime +import argparse +import signal + +# arguments +examples = """examples: + # time the interval of do_sys_open() + ./funcinterval do_sys_open + # time the interval of xhci_ring_ep_doorbell(), in microseconds + ./funcinterval -u xhci_ring_ep_doorbell + # time the interval of do_nanosleep(), in milliseconds + ./funcinterval -m do_nanosleep + # output every 5 seconds, with timestamps + ./funcinterval -mTi 5 vfs_read + # time process 181 only + ./funcinterval -p 181 vfs_read + # time the interval of mm_vmscan_direct_reclaim_begin tracepoint + ./funcinterval t:vmscan:mm_vmscan_direct_reclaim_begin +""" +parser = argparse.ArgumentParser( + description="Time interval and print latency as a histogram", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=examples) +parser.add_argument("-p", "--pid", type=int, + help="trace this PID only") +parser.add_argument("-i", "--interval", type=int, + help="summary interval, in seconds") +parser.add_argument("-d", "--duration", type=int, + help="total duration of trace, in seconds") +parser.add_argument("-T", "--timestamp", action="store_true", + help="include timestamp on output") +parser.add_argument("-u", "--microseconds", action="store_true", + help="microsecond histogram") +parser.add_argument("-m", "--milliseconds", action="store_true", + help="millisecond histogram") +parser.add_argument("-v", "--verbose", action="store_true", + help="print the BPF program (for debugging purposes)") +parser.add_argument("pattern", + help="Function/Tracepoint name for tracing") +parser.add_argument("--ebpf", action="store_true", + help=argparse.SUPPRESS) +args = parser.parse_args() +if args.duration and not args.interval: + args.interval = args.duration +if not args.interval: + args.interval = 99999999 + +def bail(error): + print("Error: " + error) + exit(1) + + +parts = args.pattern.split(':') +if len(parts) == 1: + attach_type = "function" + pattern = args.pattern +elif len(parts) == 3: + attach_type = "tracepoint" + pattern = ':'.join(parts[1:]) +else: + bail("unrecognized pattern format '%s'" % pattern) + +# define BPF program +bpf_text = """ +#include + +BPF_HASH(start, u32, u64, 1); +BPF_HISTOGRAM(dist); + +int trace_func_entry(struct pt_regs *ctx) +{ + u64 pid_tgid = bpf_get_current_pid_tgid(); + u32 index = 0, tgid = pid_tgid >> 32; + u64 *tsp, ts = bpf_ktime_get_ns(), delta; + + FILTER + tsp = start.lookup(&index); + if (tsp == 0) + goto out; + + delta = ts - *tsp; + FACTOR + + // store as histogram + dist.increment(bpf_log2l(delta)); + +out: + start.update(&index, &ts); + + return 0; +} +""" + +# code substitutions +if args.pid: + bpf_text = bpf_text.replace('FILTER', + 'if (tgid != %d) { return 0; }' % args.pid) +else: + bpf_text = bpf_text.replace('FILTER', '') +if args.milliseconds: + bpf_text = bpf_text.replace('FACTOR', 'delta /= 1000000;') + label = "msecs" +elif args.microseconds: + bpf_text = bpf_text.replace('FACTOR', 'delta /= 1000;') + label = "usecs" +else: + bpf_text = bpf_text.replace('FACTOR', '') + label = "nsecs" + +if args.verbose or args.ebpf: + print(bpf_text) + if args.ebpf: + exit() + +# signal handler +def signal_ignore(signal, frame): + print() + + +# load BPF program +b = BPF(text=bpf_text) + +if len(parts) == 1: + b.attach_kprobe(event=pattern, fn_name="trace_func_entry") + matched = b.num_open_kprobes() +elif len(parts) == 3: + b.attach_tracepoint(tp=pattern, fn_name="trace_func_entry") + matched = b.num_open_tracepoints() + +if matched == 0: + print("0 %s matched by \"%s\". Exiting." % (attach_type, pattern)) + exit() + +# header +print("Tracing %s for \"%s\"... Hit Ctrl-C to end." % + (attach_type, pattern)) + +exiting = 0 if args.interval else 1 +seconds = 0 +dist = b.get_table("dist") +start = b.get_table("start") +while (1): + try: + sleep(args.interval) + seconds += args.interval + except KeyboardInterrupt: + exiting = 1 + # as cleanup can take many seconds, trap Ctrl-C: + signal.signal(signal.SIGINT, signal_ignore) + if args.duration and seconds >= args.duration: + exiting = 1 + + print() + if args.timestamp: + print("%-8s\n" % strftime("%H:%M:%S"), end="") + + dist.print_log2_hist(label) + dist.clear() + start.clear() + + if exiting: + print("Detaching...") + exit() diff --git a/tools/funcinterval_example.txt b/tools/funcinterval_example.txt new file mode 100755 index 000000000..8f3f8cbed --- /dev/null +++ b/tools/funcinterval_example.txt @@ -0,0 +1,163 @@ +Demonstrations of funcinterval, the Linux eBPF/bcc version. + +eBPF/bcc is very suitable for platform performance tuning. +By funclatency, we can profile specific functions to know how latency +this function costs. However, sometimes performance drop is not about the +latency of function but the interval between function calls. +funcinterval is born for this purpose. + +Another story, hardware performance tuning on the platform we will use +protocol analyzer to analyze performance, but most protocol analyzers lack +the distribution feature. Using a protocol analyzer you need a lot of time +to check every detail latency. By funcinterval, we can save a lot of time +by distribution feature. + +For example: + +# ./funcinterval xhci_ring_ep_doorbell -d 2 -u +Tracing 1 functions for "xhci_ring_ep_doorbell"... Hit Ctrl-C to end. + + usecs : count distribution + 0 -> 1 : 0 | | + 2 -> 3 : 0 | | + 4 -> 7 : 0 | | + 8 -> 15 : 0 | | + 16 -> 31 : 0 | | + 32 -> 63 : 134 | | + 64 -> 127 : 2862 |******************** | + 128 -> 255 : 5552 |****************************************| + 256 -> 511 : 216 |* | + 512 -> 1023 : 2 | | +Detaching... + +This example output shows that the interval latency of xhci_ring_ep_doorbell +took between 64 and 255 microseconds. USB MAC will start its job after USB +doorbell register ringing, above information that can help hardware engineer to +analyze, the performance drop is because software rings the doorbell too +late or just slowly hardware DMA. + +# ./funcinterval blk_start_request -i 2 -u +Tracing 1 functions for "blk_start_request"... Hit Ctrl-C to end. + + usecs : count distribution + 0 -> 1 : 0 | | + 2 -> 3 : 0 | | + 4 -> 7 : 0 | | + 8 -> 15 : 5 |* | + 16 -> 31 : 0 | | + 32 -> 63 : 1 | | + 64 -> 127 : 2 | | + 128 -> 255 : 1 | | + 256 -> 511 : 0 | | + 512 -> 1023 : 1 | | + 1024 -> 2047 : 1 | | + 2048 -> 4095 : 117 |****************************************| + 4096 -> 8191 : 13 |**** | + 8192 -> 16383 : 1 | | + +If using biolatency tool that has no difference between two platforms. +Maybe the problem is related to the interval time instead of block +device I/O latency. + +# ./funcinterval ion_ioctl -i 2 -m +Tracing 1 functions for "ion_ioctl"... Hit Ctrl-C to end. + + msecs : count distribution + 0 -> 1 : 215 |****************************************| + 2 -> 3 : 0 | | + 4 -> 7 : 4 | | + 8 -> 15 : 5 | | + 16 -> 31 : 29 |***** | + +You can also check the ion_ioctl. By the above output, we know the activity +frequency of ion_ioctl() is high mostly(less than 1 ms), but has 29 times low +frequency. + +# ./funcinterval t:block:block_bio_queue -d 30 -u +Tracing tracepoint for "block:block_bio_queue"... Hit Ctrl-C to end. + + usecs : count distribution + 0 -> 1 : 0 | | + 2 -> 3 : 0 | | + 4 -> 7 : 0 | | + 8 -> 15 : 2 | | + 16 -> 31 : 262 | | + 32 -> 63 : 9075 |******************* | + 64 -> 127 : 18668 |****************************************| + 128 -> 255 : 1492 |*** | + 256 -> 511 : 2616 |***** | + 512 -> 1023 : 7226 |*************** | + 1024 -> 2047 : 8982 |******************* | + 2048 -> 4095 : 2394 |***** | + 4096 -> 8191 : 163 | | + 8192 -> 16383 : 42 | | + 16384 -> 32767 : 2 | | + 32768 -> 65535 : 0 | | + 65536 -> 131071 : 0 | | + 131072 -> 262143 : 0 | | + 262144 -> 524287 : 0 | | + 524288 -> 1048575 : 1 | | +Detaching... + +# ./funcinterval t:block:block_rq_issue -d 30 -u +Tracing tracepoint for "block:block_rq_issue"... Hit Ctrl-C to end. + + usecs : count distribution + 0 -> 1 : 0 | | + 2 -> 3 : 0 | | + 4 -> 7 : 0 | | + 8 -> 15 : 0 | | + 16 -> 31 : 5 | | + 32 -> 63 : 18 | | + 64 -> 127 : 32 | | + 128 -> 255 : 95 | | + 256 -> 511 : 2194 |****** | + 512 -> 1023 : 13830 |****************************************| + 1024 -> 2047 : 9001 |************************** | + 2048 -> 4095 : 1569 |**** | + 4096 -> 8191 : 96 | | + 8192 -> 16383 : 17 | | +Detaching... + +funcinterval also supports tracepoint filter. The above two cases are under EMMC +throughput testing, by those results you know which layer has a slower interval +time. In our case, mmc-cmdqd is slower than block layer. + + +USAGE message: + +# ./funcinterval -h +usage: funcinterval [-h] [-p PID] [-i INTERVAL] [-d DURATION] [-T] [-u] [-m] + [-v] + pattern + +Time interval and print latency as a histogram + +positional arguments: + pattern Function name for tracing + +optional arguments: + -h, --help show this help message and exit + -p PID, --pid PID trace this PID only + -i INTERVAL, --interval INTERVAL + summary interval, in seconds + -d DURATION, --duration DURATION + total duration of trace, in seconds + -T, --timestamp include timestamp on output + -u, --microseconds microsecond histogram + -m, --milliseconds millisecond histogram + -v, --verbose print the BPF program (for debugging purposes) + +examples: + # time the interval of do_sys_open() + ./funcinterval do_sys_open + # time the interval of xhci_ring_ep_doorbell(), in microseconds + ./funcinterval -u xhci_ring_ep_doorbell + # time the interval of do_nanosleep(), in milliseconds + ./funcinterval -m do_nanosleep + # output every 5 seconds, with timestamps + ./funcinterval -mTi 5 vfs_read + # time process 181 only + ./funcinterval -p 181 vfs_read + # time the interval of mm_vmscan_direct_reclaim_begin tracepoint + ./funcinterval t:vmscan:mm_vmscan_direct_reclaim_begin From be5d68c7a4847113337e5f98711a3ff37ebd7c29 Mon Sep 17 00:00:00 2001 From: Wenbo Zhang Date: Tue, 2 Jun 2020 02:03:06 -0400 Subject: [PATCH 140/278] libbpf-tools: add CO-RE cpudist Signed-off-by: Wenbo Zhang --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/cpudist.bpf.c | 120 +++++++++++++++ libbpf-tools/cpudist.c | 286 +++++++++++++++++++++++++++++++++++ libbpf-tools/cpudist.h | 13 ++ libbpf-tools/trace_helpers.c | 62 ++++++++ libbpf-tools/trace_helpers.h | 2 + 7 files changed, 485 insertions(+) create mode 100644 libbpf-tools/cpudist.bpf.c create mode 100644 libbpf-tools/cpudist.c create mode 100644 libbpf-tools/cpudist.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 859a5292d..fa2a15f7a 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -1,4 +1,5 @@ /.output +/cpudist /drsnoop /execsnoop /filelife diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 73feb6598..7d8053ff7 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -10,6 +10,7 @@ CFLAGS := -g -O2 -Wall ARCH := $(shell uname -m | sed 's/x86_64/x86/') APPS = \ + cpudist \ drsnoop \ execsnoop \ filelife \ diff --git a/libbpf-tools/cpudist.bpf.c b/libbpf-tools/cpudist.bpf.c new file mode 100644 index 000000000..2bd76f97d --- /dev/null +++ b/libbpf-tools/cpudist.bpf.c @@ -0,0 +1,120 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include +#include +#include +#include "cpudist.h" + +#define TASK_RUNNING 0 + +const volatile bool targ_per_process = false; +const volatile bool targ_per_thread = false; +const volatile bool targ_offcpu = false; +const volatile bool targ_ms = false; +const volatile pid_t targ_tgid = -1; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __type(key, u32); + __type(value, u64); +} start SEC(".maps"); + +static struct hist initial_hist; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __type(key, u32); + __type(value, struct hist); +} hists SEC(".maps"); + +static __always_inline u64 log2(u32 v) +{ + u32 shift, r; + + r = (v > 0xFFFF) << 4; v >>= r; + shift = (v > 0xFF) << 3; v >>= shift; r |= shift; + shift = (v > 0xF) << 2; v >>= shift; r |= shift; + shift = (v > 0x3) << 1; v >>= shift; r |= shift; + r |= (v >> 1); + + return r; +} + +static __always_inline u64 log2l(u64 v) +{ + u32 hi = v >> 32; + + if (hi) + return log2(hi) + 32; + else + return log2(v); +} + +static __always_inline void store_start(u32 tgid, u32 pid, u64 ts) +{ + if (targ_tgid != -1 && targ_tgid != tgid) + return; + bpf_map_update_elem(&start, &pid, &ts, 0); +} + +static __always_inline void update_hist(struct task_struct *task, + u32 tgid, u32 pid, u64 ts) +{ + u64 delta, *tsp, slot; + struct hist *histp; + u32 id; + + if (targ_tgid != -1 && targ_tgid != tgid) + return; + + tsp = bpf_map_lookup_elem(&start, &pid); + if (!tsp || ts < *tsp) + return; + + if (targ_per_process) + id = tgid; + else if (targ_per_thread) + id = pid; + else + id = -1; + histp = bpf_map_lookup_elem(&hists, &id); + if (!histp) { + bpf_map_update_elem(&hists, &id, &initial_hist, 0); + histp = bpf_map_lookup_elem(&hists, &id); + if (!histp) + return; + BPF_CORE_READ_STR_INTO(&histp->comm, task, comm); + } + delta = ts - *tsp; + if (targ_ms) + delta /= 1000000; + else + delta /= 1000; + slot = log2l(delta); + if (slot >= MAX_SLOTS) + slot = MAX_SLOTS - 1; + __sync_fetch_and_add(&histp->slots[slot], 1); +} + +SEC("kprobe/finish_task_switch") +int BPF_KPROBE(kprobe__finish_task_switch, struct task_struct *prev) +{ + u32 prev_tgid = BPF_CORE_READ(prev, tgid); + u32 prev_pid = BPF_CORE_READ(prev, pid); + u64 id = bpf_get_current_pid_tgid(); + u32 tgid = id >> 32, pid = id; + u64 ts = bpf_ktime_get_ns(); + + if (targ_offcpu) { + store_start(prev_tgid, prev_pid, ts); + update_hist((void*)bpf_get_current_task(), tgid, pid, ts); + } else { + if (BPF_CORE_READ(prev, state) == TASK_RUNNING) + update_hist(prev, prev_tgid, prev_pid, ts); + store_start(tgid, pid, ts); + } + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/cpudist.c b/libbpf-tools/cpudist.c new file mode 100644 index 000000000..89419259e --- /dev/null +++ b/libbpf-tools/cpudist.c @@ -0,0 +1,286 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on cpudist(8) from BCC by Brendan Gregg & Dina Goldshtein. +// 8-May-2020 Wenbo Zhang Created this. +#include +#include +#include +#include +#include +#include +#include +#include +#include "cpudist.h" +#include "cpudist.skel.h" +#include "trace_helpers.h" + +static struct env { + time_t interval; + pid_t pid; + int times; + bool offcpu; + bool timestamp; + bool per_process; + bool per_thread; + bool milliseconds; + bool verbose; +} env = { + .interval = 99999999, + .pid = -1, + .times = 99999999, +}; + +static volatile bool exiting; + +const char *argp_program_version = "cpudist 0.1"; +const char *argp_program_bug_address = ""; +const char argp_program_doc[] = +"Summarize on-CPU time per task as a histogram.\n" +"\n" +"USAGE: cpudist [-h] [-O] [-T] [-m] [-P] [-L] [-p PID] [interval] [count]\n" +"\n" +"EXAMPLES:\n" +" cpudist # summarize on-CPU time as a histogram" +" cpudist -O # summarize off-CPU time as a histogram" +" cpudist 1 10 # print 1 second summaries, 10 times" +" cpudist -mT 1 # 1s summaries, milliseconds, and timestamps" +" cpudist -P # show each PID separately" +" cpudist -p 185 # trace PID 185 only"; + +static const struct argp_option opts[] = { + { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, + { "offcpu", 'O', NULL, 0, "Measure off-CPU time" }, + { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, + { "milliseconds", 'm', NULL, 0, "Millisecond histogram" }, + { "pids", 'P', NULL, 0, "Print a histogram per process ID" }, + { "tids", 'L', NULL, 0, "Print a histogram per thread ID" }, + { "pid", 'p', "PID", 0, "Trace this PID only" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static int pos_args; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'h': + argp_usage(state); + break; + case 'm': + env.milliseconds = true; + break; + case 'p': + errno = 0; + env.pid = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid PID: %s\n", arg); + argp_usage(state); + } + break; + case 'O': + env.offcpu = true; + break; + case 'P': + env.per_process = true; + break; + case 'L': + env.per_thread = true; + break; + case 'T': + env.timestamp = true; + break; + case ARGP_KEY_ARG: + errno = 0; + if (pos_args == 0) { + env.interval = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid internal\n"); + argp_usage(state); + } + } else if (pos_args == 1) { + env.times = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid times\n"); + argp_usage(state); + } + } else { + fprintf(stderr, + "unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + pos_args++; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static int bump_memlock_rlimit(void) +{ + struct rlimit rlim_new = { + .rlim_cur = RLIM_INFINITY, + .rlim_max = RLIM_INFINITY, + }; + + return setrlimit(RLIMIT_MEMLOCK, &rlim_new); +} + +static int get_pid_max(void) +{ + int pid_max; + FILE *f; + + f = fopen("/proc/sys/kernel/pid_max", "r"); + if (!f) + return -1; + if (fscanf(f, "%d\n", &pid_max) != 1) + pid_max = -1; + fclose(f); + return pid_max; +} + +static void sig_handler(int sig) +{ + exiting = true; +} + +static int print_log2_hists(int fd) +{ + char *units = env.milliseconds ? "msecs" : "usecs"; + __u32 lookup_key = -2, next_key; + struct hist hist; + int err; + + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_lookup_elem(fd, &next_key, &hist); + if (err < 0) { + fprintf(stderr, "failed to lookup hist: %d\n", err); + return -1; + } + if (env.per_process) + printf("\npid = %d %s\n", next_key, hist.comm); + if (env.per_thread) + printf("\ntid = %d %s\n", next_key, hist.comm); + print_log2_hist(hist.slots, MAX_SLOTS, units); + lookup_key = next_key; + } + + lookup_key = -2; + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_delete_elem(fd, &next_key); + if (err < 0) { + fprintf(stderr, "failed to cleanup hist : %d\n", err); + return -1; + } + lookup_key = next_key; + } + return 0; +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct cpudist_bpf *obj; + int pid_max, fd, err; + struct tm *tm; + char ts[32]; + time_t t; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = cpudist_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + return 1; + } + + /* initialize global data (filtering options) */ + obj->rodata->targ_per_process = env.per_process; + obj->rodata->targ_per_thread = env.per_thread; + obj->rodata->targ_ms = env.milliseconds; + obj->rodata->targ_offcpu = env.offcpu; + obj->rodata->targ_tgid = env.pid; + + pid_max = get_pid_max(); + if (pid_max < 0) { + fprintf(stderr, "failed to get pid_max\n"); + return 1; + } + + bpf_map__resize(obj->maps.start, pid_max); + if (!env.per_process && !env.per_thread) + bpf_map__resize(obj->maps.hists, 1); + else + bpf_map__resize(obj->maps.hists, pid_max); + + err = cpudist_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + err = cpudist_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs\n"); + goto cleanup; + } + + fd = bpf_map__fd(obj->maps.hists); + + signal(SIGINT, sig_handler); + + printf("Tracing %s-CPU time... Hit Ctrl-C to end.\n", env.offcpu ? "off" : "on"); + + /* main: poll */ + while (1) { + sleep(env.interval); + printf("\n"); + + if (env.timestamp) { + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + printf("%-8s\n", ts); + } + + err = print_log2_hists(fd); + if (err) + break; + + if (exiting || --env.times == 0) + break; + } + +cleanup: + cpudist_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/cpudist.h b/libbpf-tools/cpudist.h new file mode 100644 index 000000000..2da5a5767 --- /dev/null +++ b/libbpf-tools/cpudist.h @@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __CPUDIST_H +#define __CPUDIST_H + +#define TASK_COMM_LEN 16 +#define MAX_SLOTS 36 + +struct hist { + __u32 slots[MAX_SLOTS]; + char comm[TASK_COMM_LEN]; +}; + +#endif // __CPUDIST_H diff --git a/libbpf-tools/trace_helpers.c b/libbpf-tools/trace_helpers.c index 355fd2d6d..2664b794c 100644 --- a/libbpf-tools/trace_helpers.c +++ b/libbpf-tools/trace_helpers.c @@ -150,3 +150,65 @@ const struct ksym *ksyms__get_symbol(const struct ksyms *ksyms, return NULL; } + +#define min(x, y) ({ \ + typeof(x) _min1 = (x); \ + typeof(y) _min2 = (y); \ + (void) (&_min1 == &_min2); \ + _min1 < _min2 ? _min1 : _min2; }) + +static void print_stars(unsigned int val, unsigned int val_max, int width) +{ + int num_stars, num_spaces, i; + bool need_plus; + + num_stars = min(val, val_max) * width / val_max; + num_spaces = width - num_stars; + need_plus = val > val_max; + + for (i = 0; i < num_stars; i++) + printf("*"); + for (i = 0; i < num_spaces; i++) + printf(" "); + if (need_plus) + printf("+"); +} + +void print_log2_hist(unsigned int *vals, int vals_size, char *val_type) +{ + int stars_max = 40, idx_max = -1; + unsigned int val, val_max = 0; + unsigned long long low, high; + int stars, width, i; + + for (i = 0; i < vals_size; i++) { + val = vals[i]; + if (val > 0) + idx_max = i; + if (val > val_max) + val_max = val; + } + + if (idx_max < 0) + return; + + printf("%*s%-*s : count distribution\n", idx_max <= 32 ? 5 : 15, "", + idx_max <= 32 ? 19 : 29, val_type); + + if (idx_max <= 32) + stars = stars_max; + else + stars = stars_max / 2; + + for (i = 0; i <= idx_max; i++) { + low = (1ULL << (i + 1)) >> 1; + high = (1ULL << (i + 1)) - 1; + if (low == high) + low -= 1; + val = vals[i]; + width = idx_max <= 32 ? 10 : 20; + printf("%*lld -> %-*lld : %-8d |", width, low, width, high, val); + print_stars(val, val_max, stars); + printf("|\n"); + } +} diff --git a/libbpf-tools/trace_helpers.h b/libbpf-tools/trace_helpers.h index 9d7156e56..6524b8afd 100644 --- a/libbpf-tools/trace_helpers.h +++ b/libbpf-tools/trace_helpers.h @@ -16,4 +16,6 @@ const struct ksym *ksyms__map_addr(const struct ksyms *ksyms, const struct ksym *ksyms__get_symbol(const struct ksyms *ksyms, const char *name); +void print_log2_hist(unsigned int *vals, int vals_size, char *val_type); + #endif /* __TRACE_HELPERS_H */ From da0d82cc11d56d12a383f5c670281bfa61ca2ad7 Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Tue, 2 Jun 2020 22:55:32 -0700 Subject: [PATCH 141/278] silence a python travis-ci warning The travis-ci flags a python warning: $ flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics ./tools/biolatpcts.py:123:5: F821 undefined name 'die' die() ^ 1 F821 undefined name 'die' Let us fix it with proper error message and then exit(). Signed-off-by: Yonghong Song --- tools/biolatpcts.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/biolatpcts.py b/tools/biolatpcts.py index 9db210e8b..7776a6f5e 100755 --- a/tools/biolatpcts.py +++ b/tools/biolatpcts.py @@ -120,7 +120,8 @@ elif args.which == 'on-device': start_time_field = 'io_start_time_ns' else: - die() + print("Invalid latency measurement {}".format(args.which)) + exit() bpf_source = bpf_source.replace('__START_TIME_FIELD__', start_time_field) bpf_source = bpf_source.replace('__MAJOR__', str(major)) From 5fed2a94da19501c3088161db0c412b5623050ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mauricio=20V=C3=A1squez?= Date: Tue, 2 Jun 2020 11:03:55 -0500 Subject: [PATCH 142/278] Docker: add kmod dependency to docker container MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit modprobe and rmmod are used to load the kheaders module as a last option when kernel headers are not found. The modprobe command is missing in the docker image and scroipts are failing: $ /usr/share/bcc/tools/execsnoop --mntnsmap /sys/fs/bpf/mnt_ns_set sh: 1: modprobe: not found Unable to find kernel headers. Try rebuilding kernel with CONFIG_IKHEADERS=m (module) ... Signed-off-by: Mauricio Vásquez --- Dockerfile.ubuntu | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Dockerfile.ubuntu b/Dockerfile.ubuntu index 8ac79066a..a2582cd91 100644 --- a/Dockerfile.ubuntu +++ b/Dockerfile.ubuntu @@ -19,5 +19,5 @@ COPY --from=builder /root/bcc/*.deb /root/bcc/ RUN \ apt-get update -y && \ - DEBIAN_FRONTEND=noninteractive apt-get install -y python python3 binutils libelf1 && \ + DEBIAN_FRONTEND=noninteractive apt-get install -y python python3 binutils libelf1 kmod && \ dpkg -i /root/bcc/*.deb From 8319d52dc8834daa0766f61487f75ed3c3c731fe Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Tue, 2 Jun 2020 22:41:12 -0700 Subject: [PATCH 143/278] turn off x86 jump table optimization during jit compilation jump table optimization tries to optimize switch statements into an array access. But such optimization will place certain information, acted as the array, in the read-only section. Currently, bcc does not support read-only section, so jump table optimized code will fail during kernel verification. This is what happened to biolatpcts.py in my environment with latest llvm. -bash-4.4$ sudo ./biolatpcts.py console bpf: Failed to load program: Invalid argument unknown opcode 60 processed 0 insns (limit 1000000) max_states_per_insn 0 total_states 0 peak_states 0 mark_read 0 HINT: The 'unknown opcode' can happen if you reference a global or static variable, or data in read-only section. For example, 'char *p = "hello"' will result in p referencing a read-only section, and 'char p[] = "hello"' will have "hello" stored on the stack. This patch disabled jump table optimization on x64. The jump table optimization is guarded for llvm version 4 and above. We can disable jump table on other architectures if needed. A test case, developed based biolatpcts.py tool, is added to ensure it pass the verifier. Signed-off-by: Yonghong Song --- src/cc/frontends/clang/loader.cc | 5 ++++ tests/python/test_clang.py | 48 ++++++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+) diff --git a/src/cc/frontends/clang/loader.cc b/src/cc/frontends/clang/loader.cc index 9d768d305..50b24bcbb 100644 --- a/src/cc/frontends/clang/loader.cc +++ b/src/cc/frontends/clang/loader.cc @@ -316,6 +316,11 @@ int ClangLoader::do_compile(unique_ptr *mod, TableStorage &ts, string target_triple = get_clang_target(); driver::Driver drv("", target_triple, diags); +#if LLVM_MAJOR_VERSION >= 4 + if (target_triple == "x86_64-unknown-linux-gnu") + flags_cstr.push_back("-fno-jump-tables"); +#endif + drv.setTitle("bcc-clang-driver"); drv.setCheckInputsExist(false); diff --git a/tests/python/test_clang.py b/tests/python/test_clang.py index bbce641d2..f62152b44 100755 --- a/tests/python/test_clang.py +++ b/tests/python/test_clang.py @@ -1292,5 +1292,53 @@ def test_packed_structure(self): self.assertEqual(st.a, 10) self.assertEqual(st.b, 20) + @skipUnless(kernel_version_ge(4,14), "requires kernel >= 4.14") + def test_jump_table(self): + text = """ +#include +#include +#include + +BPF_PERCPU_ARRAY(rwdf_100ms, u64, 400); + +int do_request(struct pt_regs *ctx, struct request *rq) { + u32 cmd_flags; + u64 base, dur, slot, now = 100000; + + if (!rq->start_time_ns) + return 0; + + if (!rq->rq_disk || rq->rq_disk->major != 5 || + rq->rq_disk->first_minor != 6) + return 0; + + cmd_flags = rq->cmd_flags; + switch (cmd_flags & REQ_OP_MASK) { + case REQ_OP_READ: + base = 0; + break; + case REQ_OP_WRITE: + base = 100; + break; + case REQ_OP_DISCARD: + base = 200; + break; + case REQ_OP_FLUSH: + base = 300; + break; + default: + return 0; + } + + dur = now - rq->start_time_ns; + slot = min_t(size_t, div_u64(dur, 100 * NSEC_PER_MSEC), 99); + rwdf_100ms.increment(base + slot); + + return 0; +} +""" + b = BPF(text=text) + fns = b.load_funcs(BPF.KPROBE) + if __name__ == "__main__": main() From 78b0f07c55e179929e789c987cce47031495cad6 Mon Sep 17 00:00:00 2001 From: Aditya Mandaleeka Date: Thu, 4 Jun 2020 13:23:14 -0700 Subject: [PATCH 144/278] Fix runqslower to indicate that the latency param is in microseconds. --- tools/runqslower.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/runqslower.py b/tools/runqslower.py index c8b832cf3..e1583e54b 100755 --- a/tools/runqslower.py +++ b/tools/runqslower.py @@ -50,7 +50,7 @@ formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("min_us", nargs="?", default='10000', - help="minimum run queue latecy to trace, in ms (default 10000)") + help="minimum run queue latency to trace, in us (default 10000)") parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) From 126054e829e7c6ed342f8719818490bc093f851a Mon Sep 17 00:00:00 2001 From: Daniel Xu Date: Thu, 4 Jun 2020 18:50:37 -0700 Subject: [PATCH 145/278] usdt: Add helpers to set semaphore values While debugging a high memory consumption issue in bpftrace, I noticed that a USDT::Context object can take ~10M per instance [0]. Along with the new --usdt-file-activation feature in bpftrace ( https://github.com/iovisor/bpftrace/pull/1317 ), bpftrace can potentially hold onto many dozens of USDT:Context instances, causing memory issues. While reducing the amount of memory USDT::Context uses is one option, we can potentially side step it by allowing the usdt semaphore count to be set independently. Before, the only way to increment the count (by 1) is to call bcc_usdt_enable*(). bcc_usdt_enable*() has checks that limit it to a single increment per context. The only way to decrement the count is by calling bcc_usdt_close() which naturally only allows for one decrement. With independent semaphore helpers, we can avoid holding onto a USDT::Context instance for the lifetime of the tracing session. We can simply: 1. create a USDT::Context 2. increment the semaphore count for the probe we care about 3. destroy the USDT::Context 4. repeat 1-3 for all probes we want to attach to 5. do our tracing 6. create a USDT::Context for the probe we care about 7. decrement the semaphore count 8. destroy the USDT::Context 9. repeat 6-8 for all the probes we're attached to This approach also has the benefit of 1 USDT::Context instance being alive at a time which can help keep memory high watermark low. [0]: Through gdb single stepping and /proc/pid/status. Exact process is not described here b/c memory usage probably varies based on tracee binary. --- src/cc/bcc_usdt.h | 3 +++ src/cc/usdt.h | 5 +++++ src/cc/usdt/usdt.cc | 42 +++++++++++++++++++++++++++++++++++++----- 3 files changed, 45 insertions(+), 5 deletions(-) diff --git a/src/cc/bcc_usdt.h b/src/cc/bcc_usdt.h index 3efdfa462..b8b0e0c3c 100644 --- a/src/cc/bcc_usdt.h +++ b/src/cc/bcc_usdt.h @@ -70,9 +70,12 @@ int bcc_usdt_get_argument(void *usdt, const char *provider_name, struct bcc_usdt_argument *argument); int bcc_usdt_enable_probe(void *, const char *, const char *); +int bcc_usdt_addsem_probe(void *, const char *, const char *, int16_t); #define BCC_USDT_HAS_FULLY_SPECIFIED_PROBE int bcc_usdt_enable_fully_specified_probe(void *, const char *, const char *, const char *); +int bcc_usdt_addsem_fully_specified_probe(void *, const char *, const char *, + const char *, int16_t); const char *bcc_usdt_genargs(void **ctx_array, int len); const char *bcc_usdt_get_probe_argctype( void *ctx, const char* probe_name, const int arg_index diff --git a/src/cc/usdt.h b/src/cc/usdt.h index 800beeb72..aba0441b3 100644 --- a/src/cc/usdt.h +++ b/src/cc/usdt.h @@ -262,6 +262,8 @@ class Context { void add_probe(const char *binpath, const struct bcc_elf_usdt *probe); std::string resolve_bin_path(const std::string &bin_path); + Probe *get_checked(const std::string &provider_name, + const std::string &probe_name); private: uint8_t mod_match_inode_only_; @@ -285,6 +287,9 @@ class Context { bool enable_probe(const std::string &probe_name, const std::string &fn_name); bool enable_probe(const std::string &provider_name, const std::string &probe_name, const std::string &fn_name); + bool addsem_probe(const std::string &provider_name, + const std::string &probe_name, const std::string &fn_name, + int16_t val); typedef void (*each_cb)(struct bcc_usdt *); void each(each_cb callback); diff --git a/src/cc/usdt/usdt.cc b/src/cc/usdt/usdt.cc index b32ea1a12..5c487d738 100644 --- a/src/cc/usdt/usdt.cc +++ b/src/cc/usdt/usdt.cc @@ -308,11 +308,10 @@ bool Context::enable_probe(const std::string &probe_name, return enable_probe("", probe_name, fn_name); } -bool Context::enable_probe(const std::string &provider_name, - const std::string &probe_name, - const std::string &fn_name) { +Probe *Context::get_checked(const std::string &provider_name, + const std::string &probe_name) { if (pid_stat_ && pid_stat_->is_stale()) - return false; + return nullptr; Probe *found_probe = nullptr; for (auto &p : probes_) { @@ -321,12 +320,20 @@ bool Context::enable_probe(const std::string &provider_name, if (found_probe != nullptr) { fprintf(stderr, "Two same-name probes (%s) but different providers\n", probe_name.c_str()); - return false; + return nullptr; } found_probe = p.get(); } } + return found_probe; +} + +bool Context::enable_probe(const std::string &provider_name, + const std::string &probe_name, + const std::string &fn_name) { + Probe *found_probe = get_checked(provider_name, probe_name); + if (found_probe != nullptr) return found_probe->enable(fn_name); @@ -346,6 +353,18 @@ void Context::each(each_cb callback) { } } +bool Context::addsem_probe(const std::string &provider_name, + const std::string &probe_name, + const std::string &fn_name, + int16_t val) { + Probe *found_probe = get_checked(provider_name, probe_name); + + if (found_probe != nullptr) + return found_probe->add_to_semaphore(val); + + return false; +} + void Context::each_uprobe(each_uprobe_cb callback) { for (auto &p : probes_) { if (!p->enabled()) @@ -457,6 +476,12 @@ int bcc_usdt_enable_probe(void *usdt, const char *probe_name, return ctx->enable_probe(probe_name, fn_name) ? 0 : -1; } +int bcc_usdt_addsem_probe(void *usdt, const char *probe_name, + const char *fn_name, int16_t val) { + USDT::Context *ctx = static_cast(usdt); + return ctx->addsem_probe("", probe_name, fn_name, val) ? 0 : -1; +} + int bcc_usdt_enable_fully_specified_probe(void *usdt, const char *provider_name, const char *probe_name, const char *fn_name) { @@ -464,6 +489,13 @@ int bcc_usdt_enable_fully_specified_probe(void *usdt, const char *provider_name, return ctx->enable_probe(provider_name, probe_name, fn_name) ? 0 : -1; } +int bcc_usdt_addsem_fully_specified_probe(void *usdt, const char *provider_name, + const char *probe_name, + const char *fn_name, int16_t val) { + USDT::Context *ctx = static_cast(usdt); + return ctx->addsem_probe(provider_name, probe_name, fn_name, val) ? 0 : -1; +} + const char *bcc_usdt_genargs(void **usdt_array, int len) { static std::string storage_; std::ostringstream stream; From 0bcf2388ce19271c98512d04f719f9efb1c87d39 Mon Sep 17 00:00:00 2001 From: Daniel Xu Date: Fri, 5 Jun 2020 15:27:47 -0700 Subject: [PATCH 146/278] usdt: Have Context::addsem_probe() nop if pid not specified This makes bcc_usdt_addsem*() more consistent with the bcc_usdt_enable*() interface where if a USDT::Context was not constructed with a pid the semaphore enablement nops. --- src/cc/usdt/usdt.cc | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/cc/usdt/usdt.cc b/src/cc/usdt/usdt.cc index 5c487d738..0a18c2b14 100644 --- a/src/cc/usdt/usdt.cc +++ b/src/cc/usdt/usdt.cc @@ -359,8 +359,12 @@ bool Context::addsem_probe(const std::string &provider_name, int16_t val) { Probe *found_probe = get_checked(provider_name, probe_name); - if (found_probe != nullptr) - return found_probe->add_to_semaphore(val); + if (found_probe != nullptr) { + if (found_probe->need_enable()) + return found_probe->add_to_semaphore(val); + + return true; + } return false; } From 263411be9805502bc7e4daaf0ce6cea90884aa38 Mon Sep 17 00:00:00 2001 From: lorddoskias Date: Mon, 8 Jun 2020 09:33:46 +0300 Subject: [PATCH 147/278] Add support for multiple PID/TID for offwaketime (#2951) Instead of filtering on a single process allow up to 5 pid/tgid to be used for filtering. The limit of 5 is arbitrary and can be increased should the need arise. Also remove unnecessary thread_context variable. Co-authored-by: Nikolay Borisov --- man/man8/offwaketime.8 | 6 +++-- tools/offwaketime.py | 44 ++++++++++++++++++++++++----------- tools/offwaketime_example.txt | 6 +++-- 3 files changed, 38 insertions(+), 18 deletions(-) diff --git a/man/man8/offwaketime.8 b/man/man8/offwaketime.8 index 5527478c4..7334b6f83 100644 --- a/man/man8/offwaketime.8 +++ b/man/man8/offwaketime.8 @@ -36,10 +36,12 @@ Print usage message. Print output in folded stack format. .TP \-p PID -Trace this process ID only (filtered in-kernel). +Trace this process ID only (filtered in-kernel). Can be a comma separated list +of PIDS. .TP \-t TID -Trace this thread ID only (filtered in-kernel). +Trace this thread ID only (filtered in-kernel). Can be a comma separated list +of TIDS. .TP \-u Only trace user threads (no kernel threads). diff --git a/tools/offwaketime.py b/tools/offwaketime.py index 88dc68c15..117c6e794 100755 --- a/tools/offwaketime.py +++ b/tools/offwaketime.py @@ -20,6 +20,16 @@ # arg validation def positive_int(val): + dest = [] + # Filter up to 5 pids, arbitrary + args_list = val.split(",", 5) + pids_to_add = min(len(args_list), 5) + for i in range(pids_to_add): + dest.append(_positive_int(args_list[i])) + + return dest + +def _positive_int(val): try: ival = int(val) except ValueError: @@ -30,11 +40,21 @@ def positive_int(val): return ival def positive_nonzero_int(val): - ival = positive_int(val) + ival = _positive_int(val) if ival == 0: raise argparse.ArgumentTypeError("must be nonzero") return ival +def build_filter(filter_name, values): + filter_string = "((%s == %d)" % (filter_name, values[0]) + + for val in values[1:]: + filter_string += " || (%s == %d )" % (filter_name , val) + + filter_string += ")" + + return filter_string + def stack_id_err(stack_id): # -EFAULT in get_stackid normally means the stack-trace is not available, # Such as getting kernel stack trace in userspace code @@ -61,10 +81,12 @@ def stack_id_err(stack_id): thread_group = parser.add_mutually_exclusive_group() # Note: this script provides --pid and --tid flags but their arguments are # referred to internally using kernel nomenclature: TGID and PID. -thread_group.add_argument("-p", "--pid", metavar="PID", dest="tgid", - help="trace this PID only", type=positive_int) -thread_group.add_argument("-t", "--tid", metavar="TID", dest="pid", - help="trace this TID only", type=positive_int) +thread_group.add_argument("-p", "--pid", metavar="PIDS", dest="tgid", + type=positive_int, + help="trace these PIDS only. Can be a comma separated list of PIDS.") +thread_group.add_argument("-t", "--tid", metavar="TIDS", dest="pid", + type=positive_int, + help="trace these TIDS only. Can be a comma separated list of TIDS.") thread_group.add_argument("-u", "--user-threads-only", action="store_true", help="user threads only (no kernel threads)") thread_group.add_argument("-k", "--kernel-threads-only", action="store_true", @@ -93,7 +115,7 @@ def stack_id_err(stack_id): type=positive_nonzero_int, help="the amount of time in microseconds under which we " + "store traces (default U64_MAX)") -parser.add_argument("--state", type=positive_int, +parser.add_argument("--state", type=_positive_int, help="filter on this thread state bitmask (eg, 2 == TASK_UNINTERRUPTIBLE" + ") see include/linux/sched.h") parser.add_argument("--ebpf", action="store_true", @@ -221,21 +243,15 @@ def signal_ignore(signal, frame): """ # set thread filter -thread_context = "" if args.tgid is not None: - thread_context = "PID %d" % args.tgid - thread_filter = 'tgid == %d' % args.tgid + thread_filter = build_filter("tgid", args.tgid) elif args.pid is not None: - thread_context = "TID %d" % args.pid - thread_filter = 'pid == %d' % args.pid + thread_filter = build_filter("pid", args.pid) elif args.user_threads_only: - thread_context = "user threads" thread_filter = '!(p->flags & PF_KTHREAD)' elif args.kernel_threads_only: - thread_context = "kernel threads" thread_filter = 'p->flags & PF_KTHREAD' else: - thread_context = "all threads" thread_filter = '1' if args.state == 0: state_filter = 'p->state == 0' diff --git a/tools/offwaketime_example.txt b/tools/offwaketime_example.txt index 02c5a04c0..26bfb3924 100644 --- a/tools/offwaketime_example.txt +++ b/tools/offwaketime_example.txt @@ -317,8 +317,10 @@ positional arguments: optional arguments: -h, --help show this help message and exit - -p PID, --pid PID trace this PID only - -t TID, --tid TID trace this TID only + -p PID, --pid PID trace these PIDS only. Can be a comma separated list of + PID. + -t TID, --tid TID trace these TIDS only. Can be a comma separated list of + TIDS. -u, --user-threads-only user threads only (no kernel threads) -k, --kernel-threads-only From 005664bd2d252c51ef18f5286e049a389e298bd3 Mon Sep 17 00:00:00 2001 From: stwind Date: Sun, 7 Jun 2020 12:36:22 +0800 Subject: [PATCH 148/278] fix: encode path to bytes in python3 --- src/python/bcc/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index 749ebfe51..7bc79a0f1 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -278,7 +278,7 @@ def is_exe(fpath): else: for path in os.environ["PATH"].split(os.pathsep): path = path.strip('"') - exe_file = os.path.join(path, bin_path) + exe_file = os.path.join(path.encode(), bin_path) if is_exe(exe_file): return exe_file return None From 8cd2717de91983aeeadefd0886031bd4d8e920ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mauricio=20V=C3=A1squez?= Date: Mon, 8 Jun 2020 08:12:08 -0500 Subject: [PATCH 149/278] tools/opensnoop: Fix compilation problem MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fix stupid bug introduced by myself. Signed-off-by: Mauricio Vásquez --- tools/opensnoop.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/opensnoop.py b/tools/opensnoop.py index dffb0212d..51d3dc055 100755 --- a/tools/opensnoop.py +++ b/tools/opensnoop.py @@ -195,7 +195,7 @@ events.perf_submit(ctx, &data, sizeof(data)); - return 0: + return 0; } """ From e4de95efada2bdb2f5a1ae8647421a712d1c196a Mon Sep 17 00:00:00 2001 From: Wenbo Zhang Date: Tue, 9 Jun 2020 00:04:36 -0400 Subject: [PATCH 150/278] libbpf-tools: refactor, move public methods to trace_helpers.c Signed-off-by: Wenbo Zhang --- libbpf-tools/cpudist.c | 13 +------------ libbpf-tools/drsnoop.c | 32 +++++++++++++------------------- libbpf-tools/execsnoop.c | 15 ++------------- libbpf-tools/execsnoop.h | 2 +- libbpf-tools/filelife.c | 14 ++------------ libbpf-tools/filelife.h | 4 ++-- libbpf-tools/opensnoop.c | 28 ++++------------------------ libbpf-tools/runqslower.c | 12 +----------- libbpf-tools/syscount.c | 14 ++------------ libbpf-tools/trace_helpers.c | 32 ++++++++++++++++++++++++++------ libbpf-tools/trace_helpers.h | 5 +++++ libbpf-tools/vfsstat.c | 14 ++------------ libbpf-tools/xfsslower.c | 22 +--------------------- 13 files changed, 62 insertions(+), 145 deletions(-) diff --git a/libbpf-tools/cpudist.c b/libbpf-tools/cpudist.c index 89419259e..fc7d20a24 100644 --- a/libbpf-tools/cpudist.c +++ b/libbpf-tools/cpudist.c @@ -6,7 +6,6 @@ #include #include #include -#include #include #include #include @@ -122,23 +121,13 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) } int libbpf_print_fn(enum libbpf_print_level level, - const char *format, va_list args) + const char *format, va_list args) { if (level == LIBBPF_DEBUG && !env.verbose) return 0; return vfprintf(stderr, format, args); } -static int bump_memlock_rlimit(void) -{ - struct rlimit rlim_new = { - .rlim_cur = RLIM_INFINITY, - .rlim_max = RLIM_INFINITY, - }; - - return setrlimit(RLIMIT_MEMLOCK, &rlim_new); -} - static int get_pid_max(void) { int pid_max; diff --git a/libbpf-tools/drsnoop.c b/libbpf-tools/drsnoop.c index 6c0da7981..0275d02ab 100644 --- a/libbpf-tools/drsnoop.c +++ b/libbpf-tools/drsnoop.c @@ -7,7 +7,6 @@ #include #include #include -#include #include #include #include @@ -98,23 +97,13 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) } int libbpf_print_fn(enum libbpf_print_level level, - const char *format, va_list args) + const char *format, va_list args) { if (level == LIBBPF_DEBUG && !env.verbose) return 0; return vfprintf(stderr, format, args); } -static int bump_memlock_rlimit(void) -{ - struct rlimit rlim_new = { - .rlim_cur = RLIM_INFINITY, - .rlim_max = RLIM_INFINITY, - }; - - return setrlimit(RLIMIT_MEMLOCK, &rlim_new); -} - void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) { const struct event *e = data; @@ -150,7 +139,7 @@ int main(int argc, char **argv) struct ksyms *ksyms = NULL; const struct ksym *ksym; struct drsnoop_bpf *obj; - time_t start_time; + __u64 time_end = 0; int err; err = argp_parse(&argp, argc, argv, 0, NULL, NULL); @@ -207,7 +196,7 @@ int main(int argc, char **argv) else printf("... Hit Ctrl-C to end.\n"); printf("%-8s %-16s %-6s %8s %5s", - "TIME", "COMM", "TID", "LAT(ms)", "PAGES"); + "TIME", "COMM", "TID", "LAT(ms)", "PAGES"); if (env.extended) printf(" %8s", "FREE(KB)"); printf("\n"); @@ -223,13 +212,18 @@ int main(int argc, char **argv) goto cleanup; } - start_time = time(NULL); - while (!env.duration || time(NULL) - start_time < env.duration) { - if ((err = perf_buffer__poll(pb, PERF_POLL_TIMEOUT_MS)) < 0) { - printf("error polling perf buffer: %d\n", err); + /* setup duration */ + if (env.duration) + time_end = get_ktime_ns() + env.duration * NSEC_PER_SEC; + + /* main: poll */ + while (1) { + if ((err = perf_buffer__poll(pb, PERF_POLL_TIMEOUT_MS)) < 0) break; - } + if (env.duration && get_ktime_ns() > time_end) + goto cleanup; } + printf("error polling perf buffer: %d\n", err); cleanup: perf_buffer__free(pb); diff --git a/libbpf-tools/execsnoop.c b/libbpf-tools/execsnoop.c index 6cf936055..417e41040 100644 --- a/libbpf-tools/execsnoop.c +++ b/libbpf-tools/execsnoop.c @@ -4,7 +4,6 @@ #include #include #include -#include #include #include #include @@ -12,9 +11,9 @@ #include #include "execsnoop.h" #include "execsnoop.skel.h" +#include "trace_helpers.h" #define PERF_BUFFER_PAGES 64 -#define NSEC_PER_SEC 1000000000L #define NSEC_PRECISION (NSEC_PER_SEC / 1000) #define MAX_ARGS_KEY 259 @@ -128,18 +127,8 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) return 0; } -static int bump_memlock_rlimit(void) -{ - struct rlimit rlim_new = { - .rlim_cur = RLIM_INFINITY, - .rlim_max = RLIM_INFINITY, - }; - - return setrlimit(RLIMIT_MEMLOCK, &rlim_new); -} - int libbpf_print_fn(enum libbpf_print_level level, - const char *format, va_list args) + const char *format, va_list args) { if (level == LIBBPF_DEBUG && !env.verbose) return 0; diff --git a/libbpf-tools/execsnoop.h b/libbpf-tools/execsnoop.h index 7f9d960f4..b0b50dedd 100644 --- a/libbpf-tools/execsnoop.h +++ b/libbpf-tools/execsnoop.h @@ -13,6 +13,7 @@ #define LAST_ARG (FULL_MAX_ARGS_ARR - ARGSIZE) struct event { + char comm[TASK_COMM_LEN]; pid_t pid; pid_t tgid; pid_t ppid; @@ -20,7 +21,6 @@ struct event { int retval; int args_count; unsigned int args_size; - char comm[TASK_COMM_LEN]; char args[FULL_MAX_ARGS_ARR]; }; diff --git a/libbpf-tools/filelife.c b/libbpf-tools/filelife.c index 020f04879..2dc64c20b 100644 --- a/libbpf-tools/filelife.c +++ b/libbpf-tools/filelife.c @@ -7,13 +7,13 @@ #include #include #include -#include #include #include #include #include #include "filelife.h" #include "filelife.skel.h" +#include "trace_helpers.h" #define PERF_BUFFER_PAGES 16 #define PERF_POLL_TIMEOUT_MS 100 @@ -64,23 +64,13 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) } int libbpf_print_fn(enum libbpf_print_level level, - const char *format, va_list args) + const char *format, va_list args) { if (level == LIBBPF_DEBUG && !env.verbose) return 0; return vfprintf(stderr, format, args); } -static int bump_memlock_rlimit(void) -{ - struct rlimit rlim_new = { - .rlim_cur = RLIM_INFINITY, - .rlim_max = RLIM_INFINITY, - }; - - return setrlimit(RLIMIT_MEMLOCK, &rlim_new); -} - void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) { const struct event *e = data; diff --git a/libbpf-tools/filelife.h b/libbpf-tools/filelife.h index d9ea7fc94..13b11418d 100644 --- a/libbpf-tools/filelife.h +++ b/libbpf-tools/filelife.h @@ -6,10 +6,10 @@ #define TASK_COMM_LEN 16 struct event { - __u64 delta_ns; - pid_t tgid; char file[DNAME_INLINE_LEN]; char task[TASK_COMM_LEN]; + __u64 delta_ns; + pid_t tgid; }; #endif /* __FILELIFE_H */ diff --git a/libbpf-tools/opensnoop.c b/libbpf-tools/opensnoop.c index 0d7330f9c..37c3f50df 100644 --- a/libbpf-tools/opensnoop.c +++ b/libbpf-tools/opensnoop.c @@ -8,7 +8,6 @@ #include #include #include -#include #include #include #include @@ -16,6 +15,7 @@ #include #include "opensnoop.h" #include "opensnoop.skel.h" +#include "trace_helpers.h" /* Tune the buffer size and wakeup rate. These settings cope with roughly * 50k opens/sec. @@ -164,16 +164,6 @@ int libbpf_print_fn(enum libbpf_print_level level, return vfprintf(stderr, format, args); } -static int bump_memlock_rlimit(void) -{ - struct rlimit rlim_new = { - .rlim_cur = RLIM_INFINITY, - .rlim_max = RLIM_INFINITY, - }; - - return setrlimit(RLIMIT_MEMLOCK, &rlim_new); -} - void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) { const struct event *e = data; @@ -214,13 +204,6 @@ void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt) fprintf(stderr, "Lost %llu events on CPU #%d!\n", lost_cnt, cpu); } -__u64 gettimens() -{ - struct timespec ts = {}; - clock_gettime(CLOCK_MONOTONIC, &ts); - return (ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec); -} - int main(int argc, char **argv) { static const struct argp argp = { @@ -294,18 +277,15 @@ int main(int argc, char **argv) /* setup duration */ if (env.duration) - time_end = gettimens() + env.duration * NSEC_PER_SEC; + time_end = get_ktime_ns() + env.duration * NSEC_PER_SEC; /* main: poll */ while (1) { usleep(PERF_BUFFER_TIME_MS * 1000); if ((err = perf_buffer__poll(pb, PERF_POLL_TIMEOUT_MS)) < 0) break; - if (env.duration) { - if (gettimens() > time_end) { - goto cleanup; - } - } + if (env.duration && get_ktime_ns() > time_end) + goto cleanup; } printf("Error polling perf buffer: %d\n", err); diff --git a/libbpf-tools/runqslower.c b/libbpf-tools/runqslower.c index 5b1a97435..7c598a5a5 100644 --- a/libbpf-tools/runqslower.c +++ b/libbpf-tools/runqslower.c @@ -7,12 +7,12 @@ #include #include #include -#include #include #include #include #include "runqslower.h" #include "runqslower.skel.h" +#include "trace_helpers.h" struct env { pid_t pid; @@ -99,16 +99,6 @@ int libbpf_print_fn(enum libbpf_print_level level, return vfprintf(stderr, format, args); } -static int bump_memlock_rlimit(void) -{ - struct rlimit rlim_new = { - .rlim_cur = RLIM_INFINITY, - .rlim_max = RLIM_INFINITY, - }; - - return setrlimit(RLIMIT_MEMLOCK, &rlim_new); -} - void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) { const struct event *e = data; diff --git a/libbpf-tools/syscount.c b/libbpf-tools/syscount.c index 98cb5c6ad..b4ebf20d7 100644 --- a/libbpf-tools/syscount.c +++ b/libbpf-tools/syscount.c @@ -2,7 +2,6 @@ // Copyright (c) 2020 Anton Protopopov // // Based on syscount(8) from BCC by Sasha Goldshtein -#include #include #include #include @@ -13,6 +12,7 @@ #include "syscount.skel.h" #include "errno_helpers.h" #include "syscall_helpers.h" +#include "trace_helpers.h" /* This structure extends data_t by adding a key item which should be sorted * together with the count and total_ns fields */ @@ -93,7 +93,7 @@ static int get_int(const char *arg, int *ret, int min, int max) } static int libbpf_print_fn(enum libbpf_print_level level, - const char *format, va_list args) + const char *format, va_list args) { if (level == LIBBPF_DEBUG && !env.verbose) return 0; @@ -101,16 +101,6 @@ static int libbpf_print_fn(enum libbpf_print_level level, return vfprintf(stderr, format, args); } -static int bump_memlock_rlimit(void) -{ - struct rlimit rlim_new = { - .rlim_cur = RLIM_INFINITY, - .rlim_max = RLIM_INFINITY, - }; - - return setrlimit(RLIMIT_MEMLOCK, &rlim_new); -} - static int compar_count(const void *dx, const void *dy) { __u64 x = ((struct data_ext_t *) dx)->count; diff --git a/libbpf-tools/trace_helpers.c b/libbpf-tools/trace_helpers.c index 2664b794c..a1bbf81e0 100644 --- a/libbpf-tools/trace_helpers.c +++ b/libbpf-tools/trace_helpers.c @@ -3,8 +3,16 @@ #include #include #include +#include +#include #include "trace_helpers.h" +#define min(x, y) ({ \ + typeof(x) _min1 = (x); \ + typeof(y) _min2 = (y); \ + (void) (&_min1 == &_min2); \ + _min1 < _min2 ? _min1 : _min2; }) + struct ksyms { struct ksym *syms; int syms_sz; @@ -151,12 +159,6 @@ const struct ksym *ksyms__get_symbol(const struct ksyms *ksyms, return NULL; } -#define min(x, y) ({ \ - typeof(x) _min1 = (x); \ - typeof(y) _min2 = (y); \ - (void) (&_min1 == &_min2); \ - _min1 < _min2 ? _min1 : _min2; }) - static void print_stars(unsigned int val, unsigned int val_max, int width) { int num_stars, num_spaces, i; @@ -212,3 +214,21 @@ void print_log2_hist(unsigned int *vals, int vals_size, char *val_type) printf("|\n"); } } + +unsigned long long get_ktime_ns(void) +{ + struct timespec ts; + + clock_gettime(CLOCK_MONOTONIC, &ts); + return ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec; +} + +int bump_memlock_rlimit(void) +{ + struct rlimit rlim_new = { + .rlim_cur = RLIM_INFINITY, + .rlim_max = RLIM_INFINITY, + }; + + return setrlimit(RLIMIT_MEMLOCK, &rlim_new); +} diff --git a/libbpf-tools/trace_helpers.h b/libbpf-tools/trace_helpers.h index 6524b8afd..8d9510441 100644 --- a/libbpf-tools/trace_helpers.h +++ b/libbpf-tools/trace_helpers.h @@ -2,6 +2,8 @@ #ifndef __TRACE_HELPERS_H #define __TRACE_HELPERS_H +#define NSEC_PER_SEC 1000000000ULL + struct ksym { const char *name; unsigned long addr; @@ -18,4 +20,7 @@ const struct ksym *ksyms__get_symbol(const struct ksyms *ksyms, void print_log2_hist(unsigned int *vals, int vals_size, char *val_type); +unsigned long long get_ktime_ns(void); +int bump_memlock_rlimit(void); + #endif /* __TRACE_HELPERS_H */ diff --git a/libbpf-tools/vfsstat.c b/libbpf-tools/vfsstat.c index 887ec9ad1..7fd42bd24 100644 --- a/libbpf-tools/vfsstat.c +++ b/libbpf-tools/vfsstat.c @@ -2,13 +2,13 @@ // Copyright (c) 2020 Anton Protopopov // // Based on vfsstat(8) from BCC by Brendan Gregg -#include #include #include #include #include #include "vfsstat.h" #include "vfsstat.skel.h" +#include "trace_helpers.h" const char *argp_program_version = "vfsstat 0.1"; const char *argp_program_bug_address = ""; @@ -74,23 +74,13 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) } static int libbpf_print_fn(enum libbpf_print_level level, - const char *format, va_list args) + const char *format, va_list args) { if (level == LIBBPF_DEBUG && !env.verbose) return 0; return vfprintf(stderr, format, args); } -static int bump_memlock_rlimit(void) -{ - struct rlimit rlim_new = { - .rlim_cur = RLIM_INFINITY, - .rlim_max = RLIM_INFINITY, - }; - - return setrlimit(RLIMIT_MEMLOCK, &rlim_new); -} - static const char *strftime_now(char *s, size_t max, const char *format) { struct tm *tm; diff --git a/libbpf-tools/xfsslower.c b/libbpf-tools/xfsslower.c index d381f3f9c..2c8a2b375 100644 --- a/libbpf-tools/xfsslower.c +++ b/libbpf-tools/xfsslower.c @@ -9,7 +9,6 @@ #include #include #include -#include #include #include #include @@ -22,7 +21,6 @@ #define PERF_BUFFER_TIME_MS 10 #define PERF_POLL_TIMEOUT_MS 100 -#define NSEC_PER_SEC 1000000000ULL static struct env { pid_t pid; @@ -106,23 +104,13 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) } int libbpf_print_fn(enum libbpf_print_level level, - const char *format, va_list args) + const char *format, va_list args) { if (level == LIBBPF_DEBUG && !env.verbose) return 0; return vfprintf(stderr, format, args); } -static int bump_memlock_rlimit(void) -{ - struct rlimit rlim_new = { - .rlim_cur = RLIM_INFINITY, - .rlim_max = RLIM_INFINITY, - }; - - return setrlimit(RLIMIT_MEMLOCK, &rlim_new); -} - void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) { const struct event *e = data; @@ -157,14 +145,6 @@ void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt) fprintf(stderr, "lost %llu events on CPU #%d\n", lost_cnt, cpu); } -uint64_t get_ktime_ns(void) -{ - struct timespec ts; - - clock_gettime(CLOCK_MONOTONIC, &ts); - return ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec; -} - int main(int argc, char **argv) { static const struct argp argp = { From 4440a4db2e3fdb5277c2ad283504ea3504b43ecf Mon Sep 17 00:00:00 2001 From: Jerome Marchand Date: Wed, 10 Jun 2020 10:28:42 +0200 Subject: [PATCH 151/278] deadlock: print a more explicit message when pthread_mutex_unlock can't be attached Most likely, this happen because of a missing --binary argument. Let's be friendly to our user and print a more useful messsage. --- tools/deadlock.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/deadlock.py b/tools/deadlock.py index 178487200..81122adb7 100755 --- a/tools/deadlock.py +++ b/tools/deadlock.py @@ -483,7 +483,7 @@ def main(): pid=args.pid, ) except Exception as e: - print('%s. Failed to attach to symbol: %s' % (str(e), symbol)) + print('%s. Failed to attach to symbol: %s\nIs --binary argument missing?' % (str(e), symbol)) sys.exit(1) for symbol in args.lock_symbols: try: From eddf9dd07a4c1d94aad70894f98df24bc0e4cbc2 Mon Sep 17 00:00:00 2001 From: Jerome Marchand Date: Wed, 10 Jun 2020 11:30:35 +0200 Subject: [PATCH 152/278] man: remove non-existent -x argument from tcpconnect man page There's no -x option in tcpconnect. I don't know how it get into the man page sysnopsis, but it doesn't belong there. --- man/man8/tcpconnect.8 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/man/man8/tcpconnect.8 b/man/man8/tcpconnect.8 index bc2589ed6..36247241d 100644 --- a/man/man8/tcpconnect.8 +++ b/man/man8/tcpconnect.8 @@ -2,7 +2,7 @@ .SH NAME tcpconnect \- Trace TCP active connections (connect()). Uses Linux eBPF/bcc. .SH SYNOPSIS -.B tcpconnect [\-h] [\-c] [\-t] [\-x] [\-p PID] [-P PORT] [\-\-cgroupmap MAPPATH] [\-\-mntnsmap MAPPATH] +.B tcpconnect [\-h] [\-c] [\-t] [\-p PID] [-P PORT] [\-\-cgroupmap MAPPATH] [\-\-mntnsmap MAPPATH] .SH DESCRIPTION This tool traces active TCP connections (eg, via a connect() syscall; accept() are passive connections). This can be useful for general From 7830947fad1e0a9e2c723e7cb800af9d7e5b8e77 Mon Sep 17 00:00:00 2001 From: Jerome Marchand Date: Wed, 10 Jun 2020 11:41:59 +0200 Subject: [PATCH 153/278] loader: suggest to install the right kernel devel package Unfortunately, some package dependency system do not allow to make sure that the kernel development package installed is the same version as the running kernel. When this happen, the loader, unable to find the kernel header, will suggest to rebuild the kernel with CONFIG_IKHEADERS. For most users, this is probably not an option, but installing the kernel development package corresponding to the running kernel version is. --- src/cc/frontends/clang/loader.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/cc/frontends/clang/loader.cc b/src/cc/frontends/clang/loader.cc index 50b24bcbb..5ec778ceb 100644 --- a/src/cc/frontends/clang/loader.cc +++ b/src/cc/frontends/clang/loader.cc @@ -151,7 +151,8 @@ int ClangLoader::parse(unique_ptr *mod, TableStorage &ts, kpath = tmpdir; } else { std::cout << "Unable to find kernel headers. "; - std::cout << "Try rebuilding kernel with CONFIG_IKHEADERS=m (module)\n"; + std::cout << "Try rebuilding kernel with CONFIG_IKHEADERS=m (module) "; + std::cout << "or installing the kernel development package for your running kernel version.\n"; } } From c9805f44bfe491a6fbbc34a06d0432a5ae3e8c20 Mon Sep 17 00:00:00 2001 From: Jerome Marchand Date: Wed, 10 Jun 2020 18:29:11 +0200 Subject: [PATCH 154/278] tools: fix a python 3 map issue in dbstat and dbslower In python 3, map returns an iterator and not a list anymore. This patch cast the map into a list. It fixes the following error: $ /usr/share/bcc/tools/dbstat mysql Traceback (most recent call last): File "/usr/share/bcc/tools/dbstat", line 95, in bpf = BPF(text=program, usdt_contexts=usdts) File "/usr/lib/python3.6/site-packages/bcc/__init__.py", line 339, in __init__ ctx_array = (ct.c_void_p * len(usdt_contexts))() TypeError: object of type 'map' has no len() --- tools/dbslower.py | 2 +- tools/dbstat.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/dbslower.py b/tools/dbslower.py index 9db225fde..090d5218a 100755 --- a/tools/dbslower.py +++ b/tools/dbslower.py @@ -194,7 +194,7 @@ args.pids = map(int, subprocess.check_output( "pidof postgres".split()).split()) - usdts = map(lambda pid: USDT(pid=pid), args.pids) + usdts = list(map(lambda pid: USDT(pid=pid), args.pids)) for usdt in usdts: usdt.enable_probe("query__start", "query_start") usdt.enable_probe("query__done", "query_end") diff --git a/tools/dbstat.py b/tools/dbstat.py index a89b09711..a7d301b1f 100755 --- a/tools/dbstat.py +++ b/tools/dbstat.py @@ -83,7 +83,7 @@ program = program.replace("FILTER", "" if args.threshold == 0 else "if (delta / 1000000 < %d) { return 0; }" % args.threshold) -usdts = map(lambda pid: USDT(pid=pid), args.pids) +usdts = list(map(lambda pid: USDT(pid=pid), args.pids)) for usdt in usdts: usdt.enable_probe("query__start", "probe_start") usdt.enable_probe("query__done", "probe_end") From 6a9619418cd202b477ca0582bd9b3a30d14731d5 Mon Sep 17 00:00:00 2001 From: William Findlay Date: Fri, 12 Jun 2020 12:57:30 -0400 Subject: [PATCH 155/278] Fix typos in kretfunc documentation Fixes an incorrect link to kretfunc documentation section and fixes example to use proper macro --- docs/reference_guide.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 107ecff53..dbb0ac451 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -17,7 +17,7 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [7. Raw Tracepoints](#7-raw-tracepoints) - [8. system call tracepoints](#8-system-call-tracepoints) - [9. kfuncs](#9-kfuncs) - - [10. kretfuncs](#9-kretfuncs) + - [10. kretfuncs](#10-kretfuncs) - [Data](#data) - [1. bpf_probe_read_kernel()](#1-bpf_probe_read_kernel) - [2. bpf_probe_read_kernel_str()](#2-bpf_probe_read_kernel_str) @@ -354,7 +354,7 @@ The last argument of the probe is the return value of the instrumented function. For example: ```C -KFUNC_PROBE(do_sys_open, int dfd, const char *filename, int flags, int mode, int ret) +KRETFUNC_PROBE(do_sys_open, int dfd, const char *filename, int flags, int mode, int ret) { ... ``` From 59665497bf967e29a3d693e50081f62e3012edfe Mon Sep 17 00:00:00 2001 From: Dave Josephsen Date: Sat, 13 Jun 2020 01:23:08 -0500 Subject: [PATCH 156/278] Explicitly use NULL macro in pointer value check (#2965) Explicitly use NULL macro in pointer value check also updated the tutorial --- docs/tutorial_bcc_python_developer.md | 3 ++- examples/tracing/sync_timing.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/docs/tutorial_bcc_python_developer.md b/docs/tutorial_bcc_python_developer.md index 9c28a08f3..0cb0e7807 100644 --- a/docs/tutorial_bcc_python_developer.md +++ b/docs/tutorial_bcc_python_developer.md @@ -128,7 +128,7 @@ int do_trace(struct pt_regs *ctx) { // attempt to read stored timestamp tsp = last.lookup(&key); - if (tsp != 0) { + if (tsp != NULL) { delta = bpf_ktime_get_ns() - *tsp; if (delta < 1000000000) { // output if time is less than 1 second @@ -163,6 +163,7 @@ Things to learn: 1. ```BPF_HASH(last)```: Creates a BPF map object that is a hash (associative array), called "last". We didn't specify any further arguments, so it defaults to key and value types of u64. 1. ```key = 0```: We'll only store one key/value pair in this hash, where the key is hardwired to zero. 1. ```last.lookup(&key)```: Lookup the key in the hash, and return a pointer to its value if it exists, else NULL. We pass the key in as an address to a pointer. +1. ```if (tsp != NULL) {```: The verifier requires that pointer values derived from a map lookup must be checked for a null value before they can be dereferenced and used. 1. ```last.delete(&key)```: Delete the key from the hash. This is currently required because of [a kernel bug in `.update()`](https://git.kernel.org/cgit/linux/kernel/git/davem/net.git/commit/?id=a6ed3ea65d9868fdf9eff84e6fe4f666b8d14b02). 1. ```last.update(&key, &ts)```: Associate the value in the 2nd argument to the key, overwriting any previous value. This records the timestamp. diff --git a/examples/tracing/sync_timing.py b/examples/tracing/sync_timing.py index 1d89ce554..face2b46f 100755 --- a/examples/tracing/sync_timing.py +++ b/examples/tracing/sync_timing.py @@ -23,7 +23,7 @@ // attempt to read stored timestamp tsp = last.lookup(&key); - if (tsp != 0) { + if (tsp != NULL) { delta = bpf_ktime_get_ns() - *tsp; if (delta < 1000000000) { // output if time is less than 1 second From 10603c7123c4b2157190151b63ea846c04c76037 Mon Sep 17 00:00:00 2001 From: Jerome Marchand Date: Thu, 11 Jun 2020 10:08:26 +0200 Subject: [PATCH 157/278] dbstat: fix overflowing timestamp The current default value of interval (99999999999) in dbstat is too high to be used in the sleep() function in python 3. I couldn't find a authoritative source on the issue, but it seems the max value is 2^63/10^9 (9223372036). Anyway, 99999999 is the de facto standard for a very big number here, so just use that. It's over 3 years, that should be enough. For consistency, I also change a couple of value in klockstat even though they didn't overflow. It fixes the following error: $ dbstat mysql Tracing database queries for pids slower than 0 ms... Traceback (most recent call last): File "./dbstat", line 112, in sleep(args.interval) OverflowError: timestamp too large to convert to C _PyTime_t --- tools/dbstat.py | 2 +- tools/klockstat.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tools/dbstat.py b/tools/dbstat.py index a7d301b1f..72af9f8d1 100755 --- a/tools/dbstat.py +++ b/tools/dbstat.py @@ -39,7 +39,7 @@ help="trace queries slower than this threshold (ms)") parser.add_argument("-u", "--microseconds", action="store_true", help="display query latencies in microseconds (default: milliseconds)") -parser.add_argument("-i", "--interval", type=int, default=99999999999, +parser.add_argument("-i", "--interval", type=int, default=99999999, help="print summary at this interval (seconds)") args = parser.parse_args() diff --git a/tools/klockstat.py b/tools/klockstat.py index 7cb15ad3b..d157b7be1 100755 --- a/tools/klockstat.py +++ b/tools/klockstat.py @@ -61,7 +61,7 @@ def stack_id_err(stack_id): help="total duration of trace in seconds") time_group.add_argument("-i", "--interval", type=int, help="print summary at this interval (seconds)") -parser.add_argument("-n", "--locks", type=int, default=999999999, +parser.add_argument("-n", "--locks", type=int, default=99999999, help="print given number of locks") parser.add_argument("-s", "--stacks", type=int, default=1, help="print given number of stack entries") @@ -452,7 +452,7 @@ def display(sort, maxs, totals, counts): exiting = 0 if args.interval else 1 exiting = 1 if args.duration else 0 -seconds = 999999999 +seconds = 99999999 if args.interval: seconds = args.interval if args.duration: From 2c9395596e100697412225dc9e3856c2138a117b Mon Sep 17 00:00:00 2001 From: Adam Jensen Date: Sun, 14 Jun 2020 19:32:43 -0400 Subject: [PATCH 158/278] Add install steps for Alpine Linux --- INSTALL.md | 61 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) diff --git a/INSTALL.md b/INSTALL.md index c8254d758..764a43db9 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -10,6 +10,7 @@ - [RHEL](#rhel---binary) - [Amazon Linux 1](#Amazon-Linux-1---Binary) - [Amazon Linux 2](#Amazon-Linux-2---Binary) + - [Alpine](#alpine---binary) * [Source](#source) - [Debian](#debian---source) - [Ubuntu](#ubuntu---source) @@ -17,6 +18,7 @@ - [openSUSE](#opensuse---source) - [Centos](#centos---source) - [Amazon Linux](#amazon-linux---source) + - [Alpine](#alpine---source) * [Older Instructions](#older-instructions) ## Kernel Configuration @@ -233,6 +235,36 @@ sudo yum install kernel-devel-$(uname -r) sudo yum install bcc ``` +## Alpine - Binary + +As of Alpine 3.11, bcc binaries are available in the community repository: + +``` +sudo apk add bcc-tools bcc-doc +``` + +The tools are installed in `/usr/share/bcc/tools`. + +**Python Compatibility** + +The binary packages include bindings for Python 3 only. The Python-based tools assume that a `python` binary is available at `/usr/bin/python`, but that may not be true on recent versions of Alpine. If you encounter errors like `: not found`, you can try creating a symlink to the Python 3.x binary like so: + +``` +sudo ln -s $(which python3) /usr/bin/python +``` + +**Containers** + +Alpine Linux is often used as a base system for containers. `bcc` can be used in such an environment by launching the container in privileged mode with kernel modules available through bind mounts: + +``` +sudo docker run --rm -it --privileged \ + -v /lib/modules:/lib/modules:ro \ + -v /sys:/sys:ro \ + -v /usr/src:/usr/src:ro \ + alpine:3.12 +``` + # Source ## libbpf Submodule @@ -550,6 +582,35 @@ sudo mount -t debugfs debugfs /sys/kernel/debug sudo /usr/share/bcc/tools/execsnoop ``` +## Alpine - Source + +### Install packages required for building + +``` +sudo apk add tar git build-base iperf linux-headers llvm10-dev llvm10-static \ + clang-dev clang-static cmake python3 flex-dev bison luajit-dev elfutils-dev \ + zlib-dev +``` + +### Build bcc + +``` +git clone https://github.com/iovisor/bcc.git +mkdir bcc/build; cd bcc/build +# python2 can be substituted here, depending on your environment +cmake -DPYTHON_CMD=python3 .. +make && sudo make install + +# Optional, but needed if you don't have /usr/bin/python on your system +ln -s $(which python3) /usr/bin/python +``` + +### Test + +``` +sudo /usr/share/bcc/tools/execsnoop +``` + # Older Instructions ## Build LLVM and Clang development libs From 99fa312fefd90a760be9ba429f3267dfd78a76a8 Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Tue, 16 Jun 2020 00:03:11 -0700 Subject: [PATCH 159/278] sync with latest libbpf repo sync with latest libbpf repo, added newer ringbuf_* helper functions and new csum_level() helper. Signed-off-by: Yonghong Song --- docs/kernel-versions.md | 6 ++ introspection/bps.c | 1 + src/cc/compat/linux/virtual_bpf.h | 157 +++++++++++++++++++++++++++++- src/cc/export/helpers.h | 14 +++ src/cc/libbpf | 2 +- src/cc/libbpf.c | 6 ++ 6 files changed, 184 insertions(+), 2 deletions(-) diff --git a/docs/kernel-versions.md b/docs/kernel-versions.md index ec1d6a50c..3a3943caf 100644 --- a/docs/kernel-versions.md +++ b/docs/kernel-versions.md @@ -162,6 +162,7 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_bind()` | 4.17 | | [`d74bad4e74ee`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d74bad4e74ee373787a9ae24197c17b7cdc428d5) | `BPF_FUNC_clone_redirect()` | 4.2 | | [`3896d655f4d4`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=3896d655f4d491c67d669a15f275a39f713410f8) `BPF_FUNC_csum_diff()` | 4.6 | | [`7d672345ed29`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=7d672345ed295b1356a5d9f7111da1d1d7d65867) +`BPF_FUNC_csum_level()` | 5.7 | | [`7cdec54f9713`](https://github.com/torvalds/linux/commit/7cdec54f9713256bb170873a1fc5c75c9127c9d2) `BPF_FUNC_csum_update()` | 4.9 | | [`36bbef52c7eb`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=36bbef52c7eb646ed6247055a2acd3851e317857) `BPF_FUNC_current_task_under_cgroup()` | 4.9 | | [`60d20f9195b2`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=60d20f9195b260bdf0ac10c275ae9f6016f9c069) `BPF_FUNC_fib_lookup()` | 4.18 | GPL | [`87f5fc7e48dd`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=87f5fc7e48dd3175b30dd03b41564e1a8e136323) @@ -225,6 +226,11 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_read_branch_records()` | 5.6 | GPL | [`fff7b64355ea`](https://github.com/torvalds/linux/commit/fff7b64355eac6e29b50229ad1512315bc04b44e) `BPF_FUNC_redirect()` | 4.4 | | [`27b29f63058d`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=27b29f63058d26c6c1742f1993338280d5a41dc6) `BPF_FUNC_redirect_map()` | 4.14 | | [`97f91a7cf04f`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=97f91a7cf04ff605845c20948b8a80e54cbd3376) +`BPF_FUNC_ringbuf_discard()` | 5.7 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) +`BPF_FUNC_ringbuf_output()` | 5.7 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) +`BPF_FUNC_ringbuf_query()` | 5.7 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) +`BPF_FUNC_ringbuf_reserve()` | 5.7 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) +`BPF_FUNC_ringbuf_submit()` | 5.7 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) `BPF_FUNC_send_signal()` | 5.3 | | [`8b401f9ed244`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=8b401f9ed2441ad9e219953927a842d24ed051fc) `BPF_FUNC_send_signal_thread()` | 5.5 | | [`8482941f0906`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=8482941f09067da42f9c3362e15bfb3f3c19d610) `BPF_FUNC_seq_printf()` | 5.7 | GPL | [`492e639f0c22`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/492e639f0c222784e2e0f121966375f641c61b15) diff --git a/introspection/bps.c b/introspection/bps.c index 97868f7f0..7330d8117 100644 --- a/introspection/bps.c +++ b/introspection/bps.c @@ -75,6 +75,7 @@ static const char * const map_type_strings[] = { [BPF_MAP_TYPE_SK_STORAGE] = "sk_storage", [BPF_MAP_TYPE_DEVMAP_HASH] = "devmap_hash", [BPF_MAP_TYPE_STRUCT_OPS] = "struct_ops", + [BPF_MAP_TYPE_RINGBUF] = "ringbuf", }; #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x))) diff --git a/src/cc/compat/linux/virtual_bpf.h b/src/cc/compat/linux/virtual_bpf.h index 8ce8bf593..5041f22d6 100644 --- a/src/cc/compat/linux/virtual_bpf.h +++ b/src/cc/compat/linux/virtual_bpf.h @@ -148,6 +148,7 @@ enum bpf_map_type { BPF_MAP_TYPE_SK_STORAGE, BPF_MAP_TYPE_DEVMAP_HASH, BPF_MAP_TYPE_STRUCT_OPS, + BPF_MAP_TYPE_RINGBUF, }; /* Note that tracing related programs such as @@ -225,6 +226,7 @@ enum bpf_attach_type { BPF_CGROUP_INET6_GETPEERNAME, BPF_CGROUP_INET4_GETSOCKNAME, BPF_CGROUP_INET6_GETSOCKNAME, + BPF_XDP_DEVMAP, __MAX_BPF_ATTACH_TYPE }; @@ -236,6 +238,7 @@ enum bpf_link_type { BPF_LINK_TYPE_TRACING = 2, BPF_LINK_TYPE_CGROUP = 3, BPF_LINK_TYPE_ITER = 4, + BPF_LINK_TYPE_NETNS = 5, MAX_BPF_LINK_TYPE, }; @@ -1633,6 +1636,13 @@ union bpf_attr { * Grow or shrink the room for data in the packet associated to * *skb* by *len_diff*, and according to the selected *mode*. * + * By default, the helper will reset any offloaded checksum + * indicator of the skb to CHECKSUM_NONE. This can be avoided + * by the following flag: + * + * * **BPF_F_ADJ_ROOM_NO_CSUM_RESET**: Do not reset offloaded + * checksum data of the skb to CHECKSUM_NONE. + * * There are two supported modes at this time: * * * **BPF_ADJ_ROOM_MAC**: Adjust room at the mac layer @@ -3158,6 +3168,91 @@ union bpf_attr { * **bpf_sk_cgroup_id**\ (). * Return * The id is returned or 0 in case the id could not be retrieved. + * + * void *bpf_ringbuf_output(void *ringbuf, void *data, u64 size, u64 flags) + * Description + * Copy *size* bytes from *data* into a ring buffer *ringbuf*. + * If BPF_RB_NO_WAKEUP is specified in *flags*, no notification of + * new data availability is sent. + * IF BPF_RB_FORCE_WAKEUP is specified in *flags*, notification of + * new data availability is sent unconditionally. + * Return + * 0, on success; + * < 0, on error. + * + * void *bpf_ringbuf_reserve(void *ringbuf, u64 size, u64 flags) + * Description + * Reserve *size* bytes of payload in a ring buffer *ringbuf*. + * Return + * Valid pointer with *size* bytes of memory available; NULL, + * otherwise. + * + * void bpf_ringbuf_submit(void *data, u64 flags) + * Description + * Submit reserved ring buffer sample, pointed to by *data*. + * If BPF_RB_NO_WAKEUP is specified in *flags*, no notification of + * new data availability is sent. + * IF BPF_RB_FORCE_WAKEUP is specified in *flags*, notification of + * new data availability is sent unconditionally. + * Return + * Nothing. Always succeeds. + * + * void bpf_ringbuf_discard(void *data, u64 flags) + * Description + * Discard reserved ring buffer sample, pointed to by *data*. + * If BPF_RB_NO_WAKEUP is specified in *flags*, no notification of + * new data availability is sent. + * IF BPF_RB_FORCE_WAKEUP is specified in *flags*, notification of + * new data availability is sent unconditionally. + * Return + * Nothing. Always succeeds. + * + * u64 bpf_ringbuf_query(void *ringbuf, u64 flags) + * Description + * Query various characteristics of provided ring buffer. What + * exactly is queries is determined by *flags*: + * - BPF_RB_AVAIL_DATA - amount of data not yet consumed; + * - BPF_RB_RING_SIZE - the size of ring buffer; + * - BPF_RB_CONS_POS - consumer position (can wrap around); + * - BPF_RB_PROD_POS - producer(s) position (can wrap around); + * Data returned is just a momentary snapshots of actual values + * and could be inaccurate, so this facility should be used to + * power heuristics and for reporting, not to make 100% correct + * calculation. + * Return + * Requested value, or 0, if flags are not recognized. + * + * int bpf_csum_level(struct sk_buff *skb, u64 level) + * Description + * Change the skbs checksum level by one layer up or down, or + * reset it entirely to none in order to have the stack perform + * checksum validation. The level is applicable to the following + * protocols: TCP, UDP, GRE, SCTP, FCOE. For example, a decap of + * | ETH | IP | UDP | GUE | IP | TCP | into | ETH | IP | TCP | + * through **bpf_skb_adjust_room**\ () helper with passing in + * **BPF_F_ADJ_ROOM_NO_CSUM_RESET** flag would require one call + * to **bpf_csum_level**\ () with **BPF_CSUM_LEVEL_DEC** since + * the UDP header is removed. Similarly, an encap of the latter + * into the former could be accompanied by a helper call to + * **bpf_csum_level**\ () with **BPF_CSUM_LEVEL_INC** if the + * skb is still intended to be processed in higher layers of the + * stack instead of just egressing at tc. + * + * There are three supported level settings at this time: + * + * * **BPF_CSUM_LEVEL_INC**: Increases skb->csum_level for skbs + * with CHECKSUM_UNNECESSARY. + * * **BPF_CSUM_LEVEL_DEC**: Decreases skb->csum_level for skbs + * with CHECKSUM_UNNECESSARY. + * * **BPF_CSUM_LEVEL_RESET**: Resets skb->csum_level to 0 and + * sets CHECKSUM_NONE to force checksum validation by the stack. + * * **BPF_CSUM_LEVEL_QUERY**: No-op, returns the current + * skb->csum_level. + * Return + * 0 on success, or a negative error in case of failure. In the + * case of **BPF_CSUM_LEVEL_QUERY**, the current skb->csum_level + * is returned or the error code -EACCES in case the skb is not + * subject to CHECKSUM_UNNECESSARY. */ #define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ @@ -3289,7 +3384,13 @@ union bpf_attr { FN(seq_printf), \ FN(seq_write), \ FN(sk_cgroup_id), \ - FN(sk_ancestor_cgroup_id), + FN(sk_ancestor_cgroup_id), \ + FN(ringbuf_output), \ + FN(ringbuf_reserve), \ + FN(ringbuf_submit), \ + FN(ringbuf_discard), \ + FN(ringbuf_query), \ + FN(csum_level), /* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call @@ -3366,6 +3467,14 @@ enum { BPF_F_CURRENT_NETNS = (-1L), }; +/* BPF_FUNC_csum_level level values. */ +enum { + BPF_CSUM_LEVEL_QUERY, + BPF_CSUM_LEVEL_INC, + BPF_CSUM_LEVEL_DEC, + BPF_CSUM_LEVEL_RESET, +}; + /* BPF_FUNC_skb_adjust_room flags. */ enum { BPF_F_ADJ_ROOM_FIXED_GSO = (1ULL << 0), @@ -3373,6 +3482,7 @@ enum { BPF_F_ADJ_ROOM_ENCAP_L3_IPV6 = (1ULL << 2), BPF_F_ADJ_ROOM_ENCAP_L4_GRE = (1ULL << 3), BPF_F_ADJ_ROOM_ENCAP_L4_UDP = (1ULL << 4), + BPF_F_ADJ_ROOM_NO_CSUM_RESET = (1ULL << 5), }; enum { @@ -3399,6 +3509,29 @@ enum { BPF_F_GET_BRANCH_RECORDS_SIZE = (1ULL << 0), }; +/* BPF_FUNC_bpf_ringbuf_commit, BPF_FUNC_bpf_ringbuf_discard, and + * BPF_FUNC_bpf_ringbuf_output flags. + */ +enum { + BPF_RB_NO_WAKEUP = (1ULL << 0), + BPF_RB_FORCE_WAKEUP = (1ULL << 1), +}; + +/* BPF_FUNC_bpf_ringbuf_query flags */ +enum { + BPF_RB_AVAIL_DATA = 0, + BPF_RB_RING_SIZE = 1, + BPF_RB_CONS_POS = 2, + BPF_RB_PROD_POS = 3, +}; + +/* BPF ring buffer constants */ +enum { + BPF_RINGBUF_BUSY_BIT = (1U << 31), + BPF_RINGBUF_DISCARD_BIT = (1U << 30), + BPF_RINGBUF_HDR_SZ = 8, +}; + /* Mode for BPF_FUNC_skb_adjust_room helper. */ enum bpf_adj_room_mode { BPF_ADJ_ROOM_NET, @@ -3531,6 +3664,7 @@ struct bpf_sock { __u32 dst_ip4; __u32 dst_ip6[4]; __u32 state; + __s32 rx_queue_mapping; }; struct bpf_tcp_sock { @@ -3624,6 +3758,21 @@ struct xdp_md { /* Below access go through struct xdp_rxq_info */ __u32 ingress_ifindex; /* rxq->dev->ifindex */ __u32 rx_queue_index; /* rxq->queue_index */ + + __u32 egress_ifindex; /* txq->dev->ifindex */ +}; + +/* DEVMAP map-value layout + * + * The struct data-layout of map-value is a configuration interface. + * New members can only be added to the end of this structure. + */ +struct bpf_devmap_val { + __u32 ifindex; /* device index */ + union { + int fd; /* prog fd on map write */ + __u32 id; /* prog id on map read */ + } bpf_prog; }; enum sk_action { @@ -3646,6 +3795,8 @@ struct sk_msg_md { __u32 remote_port; /* Stored in network byte order */ __u32 local_port; /* stored in host byte order */ __u32 size; /* Total size of sk_msg */ + + __bpf_md_ptr(struct bpf_sock *, sk); /* current socket */ }; struct sk_reuseport_md { @@ -3752,6 +3903,10 @@ struct bpf_link_info { __u64 cgroup_id; __u32 attach_type; } cgroup; + struct { + __u32 netns_ino; + __u32 attach_type; + } netns; }; } __attribute__((aligned(8))); diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index 64250aa8f..18d79b317 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -655,6 +655,20 @@ static __u64 (*bpf_sk_cgroup_id)(struct bpf_sock *sk) = (void *)BPF_FUNC_sk_cgro static __u64 (*bpf_sk_ancestor_cgroup_id)(struct bpf_sock *sk, int ancestor_level) = (void *)BPF_FUNC_sk_ancestor_cgroup_id; +static int (*bpf_ringbuf_output)(void *ringbuf, void *data, __u64 size, __u64 flags) = + (void *)BPF_FUNC_ringbuf_output; +static void *(*bpf_ringbuf_reserve)(void *ringbuf, __u64 size, __u64 flags) = + (void *)BPF_FUNC_ringbuf_reserve; +static void (*bpf_ringbuf_submit)(void *data, __u64 flags) = + (void *)BPF_FUNC_ringbuf_submit; +static void (*bpf_ringbuf_discard)(void *data, __u64 flags) = + (void *)BPF_FUNC_ringbuf_discard; +static __u64 (*bpf_ringbuf_query)(void *ringbuf, __u64 flags) = + (void *)BPF_FUNC_ringbuf_query; + +static int (*bpf_csum_level)(struct __sk_buff *skb, __u64 level) = + (void *)BPF_FUNC_csum_level; + /* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions */ diff --git a/src/cc/libbpf b/src/cc/libbpf index 3b2394254..46c272f9b 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit 3b239425426e4fa1c204ea3c708d36ec3f509702 +Subproject commit 46c272f9b430fe46dc86caa631a3fb1b0e0f544c diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index 5bde5a544..209dbb6d6 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -226,6 +226,12 @@ static struct bpf_helper helpers[] = { {"seq_write", "5.7"}, {"sk_cgroup_id", "5.7"}, {"sk_ancestor_cgroup_id", "5.7"}, + {"ringbuf_output", "5.7"}, + {"ringbuf_reserve", "5.7"}, + {"ringbuf_submit", "5.7"}, + {"ringbuf_discard", "5.7"}, + {"ringbuf_query", "5.7"}, + {"csum_level", "5.7"}, }; static uint64_t ptr_to_u64(void *ptr) From 68abb51ed067c4317b991cec0bbc2ea4e7f6ddab Mon Sep 17 00:00:00 2001 From: William Findlay Date: Wed, 17 Jun 2020 12:07:48 -0400 Subject: [PATCH 160/278] Add KBUILD_MODNAME flag to default cflags --- src/cc/frontends/clang/kbuild_helper.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/cc/frontends/clang/kbuild_helper.cc b/src/cc/frontends/clang/kbuild_helper.cc index db5ca7f68..e3aade893 100644 --- a/src/cc/frontends/clang/kbuild_helper.cc +++ b/src/cc/frontends/clang/kbuild_helper.cc @@ -101,6 +101,7 @@ int KBuildHelper::get_flags(const char *uname_machine, vector *cflags) { cflags->push_back("-D__HAVE_BUILTIN_BSWAP16__"); cflags->push_back("-D__HAVE_BUILTIN_BSWAP32__"); cflags->push_back("-D__HAVE_BUILTIN_BSWAP64__"); + cflags->push_back("-DKBUILD_MODNAME=\"bcc\""); // If ARCH env variable is set, pass this along. if (archenv) From 1c843e2c0f7570844a2c955436455132936eae47 Mon Sep 17 00:00:00 2001 From: William Findlay Date: Wed, 17 Jun 2020 18:59:43 -0400 Subject: [PATCH 161/278] Delete existing kbuild_modname definitions --- examples/networking/xdp/xdp_drop_count.py | 1 - examples/networking/xdp/xdp_macswap_count.py | 1 - examples/networking/xdp/xdp_redirect_cpu.py | 1 - examples/networking/xdp/xdp_redirect_map.py | 1 - examples/tracing/nflatency.py | 1 - tests/python/test_clang.py | 8 -------- tools/tcplife.lua | 1 - tools/tcplife.py | 1 - tools/tcpstates.py | 1 - 9 files changed, 16 deletions(-) diff --git a/examples/networking/xdp/xdp_drop_count.py b/examples/networking/xdp/xdp_drop_count.py index f03273e90..512e0a20f 100755 --- a/examples/networking/xdp/xdp_drop_count.py +++ b/examples/networking/xdp/xdp_drop_count.py @@ -52,7 +52,6 @@ def usage(): # load BPF program b = BPF(text = """ -#define KBUILD_MODNAME "foo" #include #include #include diff --git a/examples/networking/xdp/xdp_macswap_count.py b/examples/networking/xdp/xdp_macswap_count.py index 0e2b21caa..770ce8ca0 100755 --- a/examples/networking/xdp/xdp_macswap_count.py +++ b/examples/networking/xdp/xdp_macswap_count.py @@ -50,7 +50,6 @@ def usage(): # load BPF program b = BPF(text = """ -#define KBUILD_MODNAME "foo" #include #include #include diff --git a/examples/networking/xdp/xdp_redirect_cpu.py b/examples/networking/xdp/xdp_redirect_cpu.py index 15b0d09b8..470079f43 100755 --- a/examples/networking/xdp/xdp_redirect_cpu.py +++ b/examples/networking/xdp/xdp_redirect_cpu.py @@ -30,7 +30,6 @@ def usage(): # load BPF program b = BPF(text = """ -#define KBUILD_MODNAME "foo" #include #include #include diff --git a/examples/networking/xdp/xdp_redirect_map.py b/examples/networking/xdp/xdp_redirect_map.py index 4a6227236..4936ac1eb 100755 --- a/examples/networking/xdp/xdp_redirect_map.py +++ b/examples/networking/xdp/xdp_redirect_map.py @@ -29,7 +29,6 @@ def usage(): # load BPF program b = BPF(text = """ -#define KBUILD_MODNAME "foo" #include #include #include diff --git a/examples/tracing/nflatency.py b/examples/tracing/nflatency.py index 767164909..c201930a0 100755 --- a/examples/tracing/nflatency.py +++ b/examples/tracing/nflatency.py @@ -12,7 +12,6 @@ from bcc import BPF BPF_SRC = """ -#define KBUILD_MODNAME "bpf_hook_nflatency" #include #include #include diff --git a/tests/python/test_clang.py b/tests/python/test_clang.py index f62152b44..f3f7d6299 100755 --- a/tests/python/test_clang.py +++ b/tests/python/test_clang.py @@ -78,7 +78,6 @@ def test_probe_read2(self): def test_probe_read3(self): text = """ -#define KBUILD_MODNAME "foo" #include #define _(P) ({typeof(P) val = 0; bpf_probe_read_kernel(&val, sizeof(val), &P); val;}) int count_tcp(struct pt_regs *ctx, struct sk_buff *skb) { @@ -90,7 +89,6 @@ def test_probe_read3(self): def test_probe_read4(self): text = """ -#define KBUILD_MODNAME "foo" #include #define _(P) ({typeof(P) val = 0; bpf_probe_read_kernel(&val, sizeof(val), &P); val;}) int test(struct pt_regs *ctx, struct sk_buff *skb) { @@ -102,7 +100,6 @@ def test_probe_read4(self): def test_probe_read_whitelist1(self): text = """ -#define KBUILD_MODNAME "foo" #include int count_tcp(struct pt_regs *ctx, struct sk_buff *skb) { // The below define is in net/tcp.h: @@ -120,7 +117,6 @@ def test_probe_read_whitelist1(self): def test_probe_read_whitelist2(self): text = """ -#define KBUILD_MODNAME "foo" #include int count_tcp(struct pt_regs *ctx, struct sk_buff *skb) { // The below define is in net/tcp.h: @@ -1084,7 +1080,6 @@ def test_probe_read_tc_ctx(self): def test_probe_read_return(self): text = """ -#define KBUILD_MODNAME "foo" #include #include static inline unsigned char *my_skb_transport_header(struct sk_buff *skb) { @@ -1100,7 +1095,6 @@ def test_probe_read_return(self): def test_probe_read_multiple_return(self): text = """ -#define KBUILD_MODNAME "foo" #include #include static inline u64 error_function() { @@ -1121,7 +1115,6 @@ def test_probe_read_multiple_return(self): def test_probe_read_return_expr(self): text = """ -#define KBUILD_MODNAME "foo" #include #include static inline unsigned char *my_skb_transport_header(struct sk_buff *skb) { @@ -1137,7 +1130,6 @@ def test_probe_read_return_expr(self): def test_probe_read_return_call(self): text = """ -#define KBUILD_MODNAME "foo" #include #include static inline struct tcphdr *my_skb_transport_header(struct sk_buff *skb) { diff --git a/tools/tcplife.lua b/tools/tcplife.lua index 3e18011e1..f2fe90695 100755 --- a/tools/tcplife.lua +++ b/tools/tcplife.lua @@ -25,7 +25,6 @@ uint16_t ntohs(uint16_t netshort); local program = [[ #include -#define KBUILD_MODNAME "foo" #include #include #include diff --git a/tools/tcplife.py b/tools/tcplife.py index 1600a3c7f..9fe9804b9 100755 --- a/tools/tcplife.py +++ b/tools/tcplife.py @@ -66,7 +66,6 @@ # define BPF program bpf_text = """ #include -#define KBUILD_MODNAME "foo" #include #include #include diff --git a/tools/tcpstates.py b/tools/tcpstates.py index 7681822e7..57fbb7658 100755 --- a/tools/tcpstates.py +++ b/tools/tcpstates.py @@ -61,7 +61,6 @@ # define BPF program bpf_header = """ #include -#define KBUILD_MODNAME "foo" #include #include #include From c3ed131d33426d2094fdd05f76f3a33bc3140ddf Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Thu, 18 Jun 2020 22:16:05 -0700 Subject: [PATCH 162/278] sync with libbpf v0.0.9 sync with libbpf version 0.0.9. Signed-off-by: Yonghong Song --- src/cc/compat/linux/virtual_bpf.h | 2 +- src/cc/libbpf | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cc/compat/linux/virtual_bpf.h b/src/cc/compat/linux/virtual_bpf.h index 5041f22d6..566706ba4 100644 --- a/src/cc/compat/linux/virtual_bpf.h +++ b/src/cc/compat/linux/virtual_bpf.h @@ -3169,7 +3169,7 @@ union bpf_attr { * Return * The id is returned or 0 in case the id could not be retrieved. * - * void *bpf_ringbuf_output(void *ringbuf, void *data, u64 size, u64 flags) + * int bpf_ringbuf_output(void *ringbuf, void *data, u64 size, u64 flags) * Description * Copy *size* bytes from *data* into a ring buffer *ringbuf*. * If BPF_RB_NO_WAKEUP is specified in *flags*, no notification of diff --git a/src/cc/libbpf b/src/cc/libbpf index 46c272f9b..fb27968bf 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit 46c272f9b430fe46dc86caa631a3fb1b0e0f544c +Subproject commit fb27968bf1052423584be76affe5abe5a0f7d570 From e3daec85c47c0695f1bf955782fddf8644d89742 Mon Sep 17 00:00:00 2001 From: Gaurav Singh Date: Thu, 18 Jun 2020 01:23:04 -0400 Subject: [PATCH 163/278] [BPFTable] clear_table_non_atomic: Remove duplicate macro Signed-off-by: Gaurav Singh --- src/cc/api/BPFTable.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cc/api/BPFTable.cc b/src/cc/api/BPFTable.cc index 2c819614a..1ea04e3e5 100644 --- a/src/cc/api/BPFTable.cc +++ b/src/cc/api/BPFTable.cc @@ -145,7 +145,7 @@ StatusTuple BPFTable::remove_value(const std::string& key_str) { } StatusTuple BPFTable::clear_table_non_atomic() { - if (desc.type == BPF_MAP_TYPE_HASH || desc.type == BPF_MAP_TYPE_PERCPU_HASH || + if (desc.type == BPF_MAP_TYPE_HASH || desc.type == BPF_MAP_TYPE_LRU_HASH || desc.type == BPF_MAP_TYPE_PERCPU_HASH || desc.type == BPF_MAP_TYPE_HASH_OF_MAPS) { From f438bffe0331d482fac57899fdd68411c4aca693 Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Thu, 18 Jun 2020 22:54:55 -0700 Subject: [PATCH 164/278] fix LSM_PROBE return value Fix issue #2976. The LSM_PROBE program return value is fixed with value 0. This is not correct. The return value is meaningful for LSM_PROBE programs. Return proper value provided by the bpf program itself. Signed-off-by: Yonghong Song --- src/cc/export/helpers.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index 18d79b317..b73d0041a 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -1029,11 +1029,13 @@ __attribute__((always_inline)) \ static int ____##name(unsigned long long *ctx, ##args); \ int name(unsigned long long *ctx) \ { \ + int __ret; \ + \ _Pragma("GCC diagnostic push") \ _Pragma("GCC diagnostic ignored \"-Wint-conversion\"") \ - ____##name(___bpf_ctx_cast(args)); \ + __ret = ____##name(___bpf_ctx_cast(args)); \ _Pragma("GCC diagnostic pop") \ - return 0; \ + return __ret; \ } \ static int ____##name(unsigned long long *ctx, ##args) From 9b82af3ef53bbae76d9f09f403b58975995aa900 Mon Sep 17 00:00:00 2001 From: William Findlay Date: Fri, 19 Jun 2020 14:41:29 -0400 Subject: [PATCH 165/278] API improvements for BPF LSM programs (#2979) * Enhanced support for LSM programs - added explicit libbcc support for LSM programs - added bcc helpers to attach LSM programs - added bcc helper to indicate kernel support for LSM programs - added LSM programs to __trace_autoload hook - removed (now) unnecessary load_func from LSM unit test - Remove detach_kfunc Signed-off-by: William Findlay --- src/cc/libbpf.c | 15 +++++++++------ src/cc/libbpf.h | 4 ++-- src/python/bcc/__init__.py | 35 +++++++++++++++++++++++++++++++++++ src/python/bcc/libbcc.py | 2 ++ tests/python/test_clang.py | 8 +++----- 5 files changed, 51 insertions(+), 13 deletions(-) diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index 209dbb6d6..010d12226 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -1186,20 +1186,23 @@ bool bpf_has_kernel_btf(void) return libbpf_find_vmlinux_btf_id("bpf_prog_put", 0) > 0; } -int bpf_detach_kfunc(int prog_fd, char *func) +int bpf_attach_kfunc(int prog_fd) { - UNUSED(prog_fd); - UNUSED(func); - return 0; + int ret; + + ret = bpf_raw_tracepoint_open(NULL, prog_fd); + if (ret < 0) + fprintf(stderr, "bpf_attach_raw_tracepoint (kfunc): %s\n", strerror(errno)); + return ret; } -int bpf_attach_kfunc(int prog_fd) +int bpf_attach_lsm(int prog_fd) { int ret; ret = bpf_raw_tracepoint_open(NULL, prog_fd); if (ret < 0) - fprintf(stderr, "bpf_attach_raw_tracepoint (kfunc): %s\n", strerror(errno)); + fprintf(stderr, "bpf_attach_raw_tracepoint (lsm): %s\n", strerror(errno)); return ret; } diff --git a/src/cc/libbpf.h b/src/cc/libbpf.h index b9bf11e51..61471b5b8 100644 --- a/src/cc/libbpf.h +++ b/src/cc/libbpf.h @@ -94,10 +94,10 @@ int bpf_detach_tracepoint(const char *tp_category, const char *tp_name); int bpf_attach_raw_tracepoint(int progfd, const char *tp_name); -int bpf_detach_kfunc(int prog_fd, char *func); - int bpf_attach_kfunc(int prog_fd); +int bpf_attach_lsm(int prog_fd); + bool bpf_has_kernel_btf(void); void * bpf_open_perf_buffer(perf_reader_raw_cb raw_cb, diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index 7bc79a0f1..88f8a607c 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -311,6 +311,7 @@ def __init__(self, src_file=b"", hdr_file=b"", text=None, debug=0, self.raw_tracepoint_fds = {} self.kfunc_entry_fds = {} self.kfunc_exit_fds = {} + self.lsm_fds = {} self.perf_buffers = {} self.open_perf_events = {} self.tracefile = None @@ -899,6 +900,15 @@ def support_kfunc(): return True return False + @staticmethod + def support_lsm(): + if not lib.bpf_has_kernel_btf(): + return False + # kernel symbol "bpf_lsm_bpf" indicates BPF LSM support + if BPF.ksymname(b"bpf_lsm_bpf") != -1: + return True + return False + def detach_kfunc(self, fn_name=b""): fn_name = _assert_is_bytes(fn_name) fn_name = BPF.add_prefix(b"kfunc__", fn_name) @@ -945,6 +955,29 @@ def attach_kretfunc(self, fn_name=b""): self.kfunc_exit_fds[fn_name] = fd; return self + def detach_lsm(self, fn_name=b""): + fn_name = _assert_is_bytes(fn_name) + fn_name = BPF.add_prefix(b"lsm__", fn_name) + + if fn_name not in self.lsm_fds: + raise Exception("LSM %s is not attached" % fn_name) + os.close(self.lsm_fds[fn_name]) + del self.lsm_fds[fn_name] + + def attach_lsm(self, fn_name=b""): + fn_name = _assert_is_bytes(fn_name) + fn_name = BPF.add_prefix(b"lsm__", fn_name) + + if fn_name in self.lsm_fds: + raise Exception("LSM %s has been attached" % fn_name) + + fn = self.load_func(fn_name, BPF.LSM) + fd = lib.bpf_attach_lsm(fn.fd) + if fd < 0: + raise Exception("Failed to attach LSM") + self.lsm_fds[fn_name] = fd; + return self + @staticmethod def support_raw_tracepoint(): # kernel symbol "bpf_find_raw_tracepoint" indicates raw_tracepoint support @@ -1204,6 +1237,8 @@ def _trace_autoload(self): self.attach_kfunc(fn_name=func_name) elif func_name.startswith(b"kretfunc__"): self.attach_kretfunc(fn_name=func_name) + elif func_name.startswith(b"lsm__"): + self.attach_lsm(fn_name=func_name) def trace_open(self, nonblocking=False): """trace_open(nonblocking=False) diff --git a/src/python/bcc/libbcc.py b/src/python/bcc/libbcc.py index f35b15c41..92f6c5e49 100644 --- a/src/python/bcc/libbcc.py +++ b/src/python/bcc/libbcc.py @@ -110,6 +110,8 @@ lib.bpf_attach_raw_tracepoint.argtypes = [ct.c_int, ct.c_char_p] lib.bpf_attach_kfunc.restype = ct.c_int lib.bpf_attach_kfunc.argtypes = [ct.c_int] +lib.bpf_attach_lsm.restype = ct.c_int +lib.bpf_attach_lsm.argtypes = [ct.c_int] lib.bpf_has_kernel_btf.restype = ct.c_bool lib.bpf_has_kernel_btf.argtypes = None lib.bpf_open_perf_buffer.restype = ct.c_void_p diff --git a/tests/python/test_clang.py b/tests/python/test_clang.py index f3f7d6299..1006bee4b 100755 --- a/tests/python/test_clang.py +++ b/tests/python/test_clang.py @@ -321,15 +321,13 @@ def test_char_array_probe(self): @skipUnless(kernel_version_ge(5,7), "requires kernel >= 5.7") def test_lsm_probe(self): + # Skip if the kernel is not compiled with CONFIG_BPF_LSM + if not BPF.support_lsm(): + return b = BPF(text=""" LSM_PROBE(bpf, int cmd, union bpf_attr *uattr, unsigned int size) { return 0; }""") - # depending on CONFIG_BPF_LSM being compiled in - try: - b.load_func("lsm__bpf", BPF.LSM) - except: - pass def test_probe_read_helper(self): b = BPF(text=""" From 5a8bf15a7e1bfdcd327126f02501630f8b79f4d1 Mon Sep 17 00:00:00 2001 From: William Findlay Date: Fri, 19 Jun 2020 16:00:22 -0400 Subject: [PATCH 166/278] Add LSM probe documentation (#2980) Add LSM documentation Add minimum kernel version requirements --- docs/reference_guide.md | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/docs/reference_guide.md b/docs/reference_guide.md index dbb0ac451..21649a788 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -18,6 +18,7 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [8. system call tracepoints](#8-system-call-tracepoints) - [9. kfuncs](#9-kfuncs) - [10. kretfuncs](#10-kretfuncs) + - [11. lsm probes](#11-lsm-probes) - [Data](#data) - [1. bpf_probe_read_kernel()](#1-bpf_probe_read_kernel) - [2. bpf_probe_read_kernel_str()](#2-bpf_probe_read_kernel_str) @@ -366,6 +367,45 @@ Examples in situ: [search /tools](https://github.com/iovisor/bcc/search?q=KRETFUNC_PROBE+path%3Atools&type=Code) +### 11. LSM Probes + +Syntax: LSM_PROBE(*hook*, typeof(arg1) arg1, typeof(arg2) arg2 ...) + +This is a macro that instruments an LSM hook as a BPF program. It can be +used to audit security events and implement MAC security policies in BPF. +It is defined by specifying the hook name followed by its arguments. + +Hook names can be found in +[include/linux/security.h](https://github.com/torvalds/linux/tree/master/include/linux/security.h#L254) +by taking functions like `security_hookname` and taking just the `hookname` part. +For example, `security_bpf` would simply become `bpf`. + +Unlike other BPF program types, the return value specified in an LSM probe +matters. A return value of 0 allows the hook to succeed, whereas +any non-zero return value will cause the hook to fail and deny the +security operation. + +The following example instruments a hook that denies all future BPF operations: +```C +LSM_PROBE(bpf, int cmd, union bpf_attr *attr, unsigned int size) +{ + return -EPERM; +} +``` + +This instruments the `security_bpf` hook and causes it to return `-EPERM`. +Changing `return -EPERM` to `return 0` would cause the BPF program +to allow the operation instead. + +LSM probes require at least a 5.7+ kernel with the following configuation options set: +- `CONFIG_BPF_LSM=y` +- `CONFIG_LSM` comma separated string must contain "bpf" (for example, + `CONFIG_LSM="lockdown,yama,bpf"`) + +Examples in situ: +[search /tests](https://github.com/iovisor/bcc/search?q=LSM_PROBE+path%3Atests&type=Code) + + ## Data ### 1. bpf_probe_read_kernel() From e41f7a3be5c8114ef6a0990e50c2fbabea0e928e Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Fri, 19 Jun 2020 13:17:54 -0700 Subject: [PATCH 167/278] prepare for release v0.15.0 added changelog for release v0.15.0 Signed-off-by: Yonghong Song --- debian/changelog | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/debian/changelog b/debian/changelog index 79351d17f..2b559f256 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,19 @@ +bcc (0.15.0-1) unstable; urgency=low + + * Support for kernel up to 5.7 + * new tools: funcinterval.py, dirtop.py + * support lsm bpf programs + * support multiple pid/tids for offwaketime + * usdt: add helpers to set semaphore values + * turn off x86 jump table optimization during jit compilation + * add support to use bpf_probe_read[_str_}{_user,kernel} in all bpf + * programs, fail back to old bpf_probe_read[_str] for old kernels + * tools: add filtering by mount namespace + * libbpf-tools: cpudist, syscount, execsnoop, vfsstat + * lots of bug fixes and a few additional arguments for tools + + -- Yonghong Song Mon, 19 Jun 2020 17:00:00 +0000 + bcc (0.14.0-1) unstable; urgency=low * Support for kernel up to 5.6 From 05f3f8668481cf975cbf89338e0db7d411ef1432 Mon Sep 17 00:00:00 2001 From: Andrii Nakryiko Date: Sat, 20 Jun 2020 20:01:52 -0700 Subject: [PATCH 168/278] libbpf-tools: remove unnecessary header include from syscount.bpf.c It causes build failure on my system due to trying to include GCC-specific header. It doesn't seem to be necessary, though, so remove it. Signed-off-by: Andrii Nakryiko --- libbpf-tools/syscount.bpf.c | 1 - 1 file changed, 1 deletion(-) diff --git a/libbpf-tools/syscount.bpf.c b/libbpf-tools/syscount.bpf.c index ffac0be2d..360e82854 100644 --- a/libbpf-tools/syscount.bpf.c +++ b/libbpf-tools/syscount.bpf.c @@ -6,7 +6,6 @@ #include #include #include -#include #include "syscount.h" const volatile bool count_by_process = false; From 4bf92d1110799393439cb6138bbcfa57670b42b9 Mon Sep 17 00:00:00 2001 From: William Findlay Date: Sat, 20 Jun 2020 15:38:13 -0400 Subject: [PATCH 169/278] Add missing LSM cleanup hook --- src/python/bcc/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index 88f8a607c..e12022109 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -1472,6 +1472,8 @@ def cleanup(self): self.detach_kfunc(k) for k, v in list(self.kfunc_exit_fds.items()): self.detach_kretfunc(k) + for k, v in list(self.lsm_fds.items()): + self.detach_lsm(k) # Clean up opened perf ring buffer and perf events table_keys = list(self.tables.keys()) From f579bf8d60c804084888c12ecb621d74a86815aa Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Sun, 21 Jun 2020 21:26:11 -0700 Subject: [PATCH 170/278] bpf: use bpf_probe_read in implicitly generated kernel mem read Currently, bcc rewriter uses bpf_probe_read_kernel() for implicitly specified kernel memory read. This is not totally correct. Some user memory in kernel data structure may be accessed. bpf_probe_read_kernel() may fail with later kernels. Let us revert back to old bpf_probe_read(). --- src/cc/frontends/clang/b_frontend_action.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc index 63e19e1b4..319689d3e 100644 --- a/src/cc/frontends/clang/b_frontend_action.cc +++ b/src/cc/frontends/clang/b_frontend_action.cc @@ -488,7 +488,7 @@ bool ProbeVisitor::VisitUnaryOperator(UnaryOperator *E) { memb_visited_.insert(E); string pre, post; pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));"; - pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (u64)"; + pre += " bpf_probe_read(&_val, sizeof(_val), (u64)"; post = "); _val; })"; rewriter_.ReplaceText(expansionLoc(E->getOperatorLoc()), 1, pre); rewriter_.InsertTextAfterToken(expansionLoc(GET_ENDLOC(sub)), post); @@ -549,7 +549,7 @@ bool ProbeVisitor::VisitMemberExpr(MemberExpr *E) { string base_type = base->getType()->getPointeeType().getAsString(); string pre, post; pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));"; - pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (u64)&"; + pre += " bpf_probe_read(&_val, sizeof(_val), (u64)&"; post = rhs + "); _val; })"; rewriter_.InsertText(expansionLoc(GET_BEGINLOC(E)), pre); rewriter_.ReplaceText(expansionRange(SourceRange(member, GET_ENDLOC(E))), post); @@ -600,7 +600,7 @@ bool ProbeVisitor::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { return true; pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));"; - pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (u64)(("; + pre += " bpf_probe_read(&_val, sizeof(_val), (u64)(("; if (isMemberDereference(base)) { pre += "&"; // If the base of the array subscript is a member dereference, we'll rewrite @@ -733,7 +733,7 @@ void BTypeVisitor::genParamIndirectAssign(FunctionDecl *D, string& preamble, size_t d = idx - 1; const char *reg = calling_conv_regs[d]; preamble += "\n " + text + ";"; - preamble += " bpf_probe_read_kernel"; + preamble += " bpf_probe_read"; preamble += "(&" + arg->getName().str() + ", sizeof(" + arg->getName().str() + "), &" + new_ctx + "->" + string(reg) + ");"; From 0d9e0911ddd9e6132fd2b05c7de6eaeafc540d67 Mon Sep 17 00:00:00 2001 From: William Findlay Date: Mon, 22 Jun 2020 20:12:57 -0400 Subject: [PATCH 171/278] Fix kernel version for ringbuf and add ringbuf to maps table --- docs/kernel-versions.md | 13 +++++++------ src/cc/libbpf.c | 10 +++++----- 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/docs/kernel-versions.md b/docs/kernel-versions.md index 3a3943caf..76a474199 100644 --- a/docs/kernel-versions.md +++ b/docs/kernel-versions.md @@ -113,6 +113,7 @@ precpu cgroup storage | 4.20 | [`b741f1630346`](https://github.com/torvalds/linu queue | 4.20 | [`f1a2e44a3aec`](https://github.com/torvalds/linux/commit/f1a2e44a3aeccb3ff18d3ccc0b0203e70b95bd92) stack | 4.20 | [`f1a2e44a3aec`](https://github.com/torvalds/linux/commit/f1a2e44a3aeccb3ff18d3ccc0b0203e70b95bd92) socket local storage | 5.2 | [`6ac99e8f23d4`](https://github.com/torvalds/linux/commit/6ac99e8f23d4b10258406ca0dd7bffca5f31da9d) +ringbuf | 5.8 | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) ## XDP @@ -159,7 +160,7 @@ Alphabetical order Helper | Kernel version | License | Commit | -------|----------------|---------|--------| -`BPF_FUNC_bind()` | 4.17 | | [`d74bad4e74ee`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d74bad4e74ee373787a9ae24197c17b7cdc428d5) | +`BPF_FUNC_bind()` | 4.17 | | [`d74bad4e74ee`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d74bad4e74ee373787a9ae24197c17b7cdc428d5) | `BPF_FUNC_clone_redirect()` | 4.2 | | [`3896d655f4d4`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=3896d655f4d491c67d669a15f275a39f713410f8) `BPF_FUNC_csum_diff()` | 4.6 | | [`7d672345ed29`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=7d672345ed295b1356a5d9f7111da1d1d7d65867) `BPF_FUNC_csum_level()` | 5.7 | | [`7cdec54f9713`](https://github.com/torvalds/linux/commit/7cdec54f9713256bb170873a1fc5c75c9127c9d2) @@ -226,11 +227,11 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_read_branch_records()` | 5.6 | GPL | [`fff7b64355ea`](https://github.com/torvalds/linux/commit/fff7b64355eac6e29b50229ad1512315bc04b44e) `BPF_FUNC_redirect()` | 4.4 | | [`27b29f63058d`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=27b29f63058d26c6c1742f1993338280d5a41dc6) `BPF_FUNC_redirect_map()` | 4.14 | | [`97f91a7cf04f`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=97f91a7cf04ff605845c20948b8a80e54cbd3376) -`BPF_FUNC_ringbuf_discard()` | 5.7 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) -`BPF_FUNC_ringbuf_output()` | 5.7 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) -`BPF_FUNC_ringbuf_query()` | 5.7 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) -`BPF_FUNC_ringbuf_reserve()` | 5.7 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) -`BPF_FUNC_ringbuf_submit()` | 5.7 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) +`BPF_FUNC_ringbuf_discard()` | 5.8 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) +`BPF_FUNC_ringbuf_output()` | 5.8 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) +`BPF_FUNC_ringbuf_query()` | 5.8 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) +`BPF_FUNC_ringbuf_reserve()` | 5.8 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) +`BPF_FUNC_ringbuf_submit()` | 5.8 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) `BPF_FUNC_send_signal()` | 5.3 | | [`8b401f9ed244`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=8b401f9ed2441ad9e219953927a842d24ed051fc) `BPF_FUNC_send_signal_thread()` | 5.5 | | [`8482941f0906`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=8482941f09067da42f9c3362e15bfb3f3c19d610) `BPF_FUNC_seq_printf()` | 5.7 | GPL | [`492e639f0c22`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/492e639f0c222784e2e0f121966375f641c61b15) diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index 010d12226..de27c3472 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -226,12 +226,12 @@ static struct bpf_helper helpers[] = { {"seq_write", "5.7"}, {"sk_cgroup_id", "5.7"}, {"sk_ancestor_cgroup_id", "5.7"}, - {"ringbuf_output", "5.7"}, - {"ringbuf_reserve", "5.7"}, - {"ringbuf_submit", "5.7"}, - {"ringbuf_discard", "5.7"}, - {"ringbuf_query", "5.7"}, {"csum_level", "5.7"}, + {"ringbuf_output", "5.8"}, + {"ringbuf_reserve", "5.8"}, + {"ringbuf_submit", "5.8"}, + {"ringbuf_discard", "5.8"}, + {"ringbuf_query", "5.8"}, }; static uint64_t ptr_to_u64(void *ptr) From 34f8985c29b0107b8526d5b0eedce2299db6570b Mon Sep 17 00:00:00 2001 From: Wenbo Zhang Date: Sun, 21 Jun 2020 20:30:13 -0400 Subject: [PATCH 172/278] libbpf-tools: add CO-RE bitesize Signed-off-by: Wenbo Zhang --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/bitesize.bpf.c | 59 ++++++++++ libbpf-tools/bitesize.c | 219 ++++++++++++++++++++++++++++++++++++ libbpf-tools/bitesize.h | 15 +++ libbpf-tools/bits.bpf.h | 28 +++++ libbpf-tools/cpudist.bpf.c | 24 +--- 7 files changed, 324 insertions(+), 23 deletions(-) create mode 100644 libbpf-tools/bitesize.bpf.c create mode 100644 libbpf-tools/bitesize.c create mode 100644 libbpf-tools/bitesize.h create mode 100644 libbpf-tools/bits.bpf.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index fa2a15f7a..59e5064e7 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -1,4 +1,5 @@ /.output +/bitesize /cpudist /drsnoop /execsnoop diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 7d8053ff7..cd73b6e3d 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -10,6 +10,7 @@ CFLAGS := -g -O2 -Wall ARCH := $(shell uname -m | sed 's/x86_64/x86/') APPS = \ + bitesize \ cpudist \ drsnoop \ execsnoop \ diff --git a/libbpf-tools/bitesize.bpf.c b/libbpf-tools/bitesize.bpf.c new file mode 100644 index 000000000..2c0c59dc0 --- /dev/null +++ b/libbpf-tools/bitesize.bpf.c @@ -0,0 +1,59 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include +#include +#include "bitesize.h" +#include "bits.bpf.h" + +const volatile char targ_comm[TASK_COMM_LEN] = {}; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, 10240); + __type(key, struct hist_key); + __type(value, struct hist); + __uint(map_flags, BPF_F_NO_PREALLOC); +} hists SEC(".maps"); + +static struct hist initial_hist; + +static __always_inline bool comm_filtered(const char *comm) +{ + int i; + + for (i = 0; targ_comm[i] != '\0' && i < TASK_COMM_LEN; i++) { + if (comm[i] != targ_comm[i]) + return false; + } + return true; +} + +SEC("tp_btf/block_rq_issue") +int BPF_PROG(tp_btf__block_rq_issue, struct request_queue *q, + struct request *rq) +{ + struct hist_key hkey; + struct hist *histp; + u64 slot; + + bpf_get_current_comm(&hkey.comm, sizeof(hkey.comm)); + if (!comm_filtered(hkey.comm)) + return 0; + + histp = bpf_map_lookup_elem(&hists, &hkey); + if (!histp) { + bpf_map_update_elem(&hists, &hkey, &initial_hist, 0); + histp = bpf_map_lookup_elem(&hists, &hkey); + if (!histp) + return 0; + } + slot = log2l(rq->__data_len / 1024); + if (slot >= MAX_SLOTS) + slot = MAX_SLOTS - 1; + __sync_fetch_and_add(&histp->slots[slot], 1); + + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/bitesize.c b/libbpf-tools/bitesize.c new file mode 100644 index 000000000..16657d62b --- /dev/null +++ b/libbpf-tools/bitesize.c @@ -0,0 +1,219 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on bitesize(8) from BCC by Brendan Gregg. +// 16-Jun-2020 Wenbo Zhang Created this. +#include +#include +#include +#include +#include +#include +#include +#include "bitesize.h" +#include "bitesize.skel.h" +#include "trace_helpers.h" + +static struct env { + char *comm; + int comm_len; + time_t interval; + bool timestamp; + bool verbose; + int times; +} env = { + .interval = 99999999, + .times = 99999999, +}; + +static volatile bool exiting; + +const char *argp_program_version = "bitesize 0.1"; +const char *argp_program_bug_address = ""; +const char argp_program_doc[] = +"Summarize block device I/O size as a histogram.\n" +"\n" +"USAGE: bitesize [-h] [-T] [-m] [interval] [count]\n" +"\n" +"EXAMPLES:\n" +" bitesize # summarize block I/O latency as a histogram\n" +" bitesize 1 10 # print 1 second summaries, 10 times\n" +" bitesize -T 1 # 1s summaries with timestamps\n" +" bitesize -c fio # trace fio only\n"; + +static const struct argp_option opts[] = { + { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, + { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, + { "comm", 'c', "COMM", 0, "Trace this comm only" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static int pos_args, len; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'h': + argp_usage(state); + break; + case 'c': + env.comm = arg; + len = strlen(arg) + 1; + env.comm_len = len > TASK_COMM_LEN ? TASK_COMM_LEN : len; + break; + case 'T': + env.timestamp = true; + break; + case ARGP_KEY_ARG: + errno = 0; + if (pos_args == 0) { + env.interval = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid internal\n"); + argp_usage(state); + } + } else if (pos_args == 1) { + env.times = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid times\n"); + argp_usage(state); + } + } else { + fprintf(stderr, + "unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + pos_args++; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void sig_handler(int sig) +{ + exiting = true; +} + +static int print_log2_hists(int fd) +{ + struct hist_key lookup_key, next_key; + struct hist hist; + int err; + + memset(lookup_key.comm, '?', sizeof(lookup_key.comm)); + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_lookup_elem(fd, &next_key, &hist); + if (err < 0) { + fprintf(stderr, "failed to lookup hist: %d\n", err); + return -1; + } + printf("\nProcess Name = %s\n", next_key.comm); + print_log2_hist(hist.slots, MAX_SLOTS, "Kbytes"); + lookup_key = next_key; + } + + memset(lookup_key.comm, '?', sizeof(lookup_key.comm)); + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_delete_elem(fd, &next_key); + if (err < 0) { + fprintf(stderr, "failed to cleanup hist : %d\n", err); + return -1; + } + lookup_key = next_key; + } + + return 0; +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct bitesize_bpf *obj; + struct tm *tm; + char ts[32]; + int fd, err; + time_t t; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = bitesize_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + return 1; + } + + /* initialize global data (filtering options) */ + if (env.comm) + strncpy((char*)obj->rodata->targ_comm, env.comm, env.comm_len); + + err = bitesize_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + err = bitesize_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs\n"); + goto cleanup; + } + + fd = bpf_map__fd(obj->maps.hists); + + signal(SIGINT, sig_handler); + + printf("Tracing block device I/O... Hit Ctrl-C to end.\n"); + + /* main: poll */ + while (1) { + sleep(env.interval); + printf("\n"); + + if (env.timestamp) { + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + printf("%-8s\n", ts); + } + + err = print_log2_hists(fd); + if (err) + break; + + if (exiting || --env.times == 0) + break; + } + +cleanup: + bitesize_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/bitesize.h b/libbpf-tools/bitesize.h new file mode 100644 index 000000000..9ebbb7009 --- /dev/null +++ b/libbpf-tools/bitesize.h @@ -0,0 +1,15 @@ +#ifndef __BITESIZE_H +#define __BITESIZE_H + +#define TASK_COMM_LEN 16 +#define MAX_SLOTS 20 + +struct hist_key { + char comm[TASK_COMM_LEN]; +}; + +struct hist { + __u32 slots[MAX_SLOTS]; +}; + +#endif /* __BITESIZE_H */ diff --git a/libbpf-tools/bits.bpf.h b/libbpf-tools/bits.bpf.h new file mode 100644 index 000000000..e1511c0b5 --- /dev/null +++ b/libbpf-tools/bits.bpf.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __BITS_BPF_H +#define __BITS_BPF_H + +static __always_inline u64 log2(u32 v) +{ + u32 shift, r; + + r = (v > 0xFFFF) << 4; v >>= r; + shift = (v > 0xFF) << 3; v >>= shift; r |= shift; + shift = (v > 0xF) << 2; v >>= shift; r |= shift; + shift = (v > 0x3) << 1; v >>= shift; r |= shift; + r |= (v >> 1); + + return r; +} + +static __always_inline u64 log2l(u64 v) +{ + u32 hi = v >> 32; + + if (hi) + return log2(hi) + 32; + else + return log2(v); +} + +#endif /* __BITS_BPF_H */ diff --git a/libbpf-tools/cpudist.bpf.c b/libbpf-tools/cpudist.bpf.c index 2bd76f97d..380c3461e 100644 --- a/libbpf-tools/cpudist.bpf.c +++ b/libbpf-tools/cpudist.bpf.c @@ -5,6 +5,7 @@ #include #include #include "cpudist.h" +#include "bits.bpf.h" #define TASK_RUNNING 0 @@ -28,29 +29,6 @@ struct { __type(value, struct hist); } hists SEC(".maps"); -static __always_inline u64 log2(u32 v) -{ - u32 shift, r; - - r = (v > 0xFFFF) << 4; v >>= r; - shift = (v > 0xFF) << 3; v >>= shift; r |= shift; - shift = (v > 0xF) << 2; v >>= shift; r |= shift; - shift = (v > 0x3) << 1; v >>= shift; r |= shift; - r |= (v >> 1); - - return r; -} - -static __always_inline u64 log2l(u64 v) -{ - u32 hi = v >> 32; - - if (hi) - return log2(hi) + 32; - else - return log2(v); -} - static __always_inline void store_start(u32 tgid, u32 pid, u64 ts) { if (targ_tgid != -1 && targ_tgid != tgid) From 1bddba6adefedc02fa5d6fda371a92c8fd4a3aea Mon Sep 17 00:00:00 2001 From: Xiaozhou Liu Date: Tue, 23 Jun 2020 19:07:07 +0000 Subject: [PATCH 173/278] tools/profile: fix suggestion about when to increase stack-storage-size When we do stack traces via stackmaps, hash collisions (-EEXIST) may indicate that the map size is too small. Not -ENOMEM. --- tools/profile.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/tools/profile.py b/tools/profile.py index dd6f65fa3..093d07c5f 100755 --- a/tools/profile.py +++ b/tools/profile.py @@ -305,17 +305,18 @@ def aksym(addr): # output stacks missing_stacks = 0 -has_enomem = False +has_collision = False counts = b.get_table("counts") stack_traces = b.get_table("stack_traces") for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): # handle get_stackid errors if not args.user_stacks_only and stack_id_err(k.kernel_stack_id): missing_stacks += 1 - has_enomem = has_enomem or k.kernel_stack_id == -errno.ENOMEM + # hash collision (-EEXIST) suggests that the map size may be too small + has_collision = has_collision or k.kernel_stack_id == -errno.EEXIST if not args.kernel_stacks_only and stack_id_err(k.user_stack_id): missing_stacks += 1 - has_enomem = has_enomem or k.user_stack_id == -errno.ENOMEM + has_collision = has_collision or k.user_stack_id == -errno.EEXIST user_stack = [] if k.user_stack_id < 0 else \ stack_traces.walk(k.user_stack_id) @@ -371,7 +372,7 @@ def aksym(addr): # check missing if missing_stacks > 0: - enomem_str = "" if not has_enomem else \ + enomem_str = "" if not has_collision else \ " Consider increasing --stack-storage-size." print("WARNING: %d stack traces could not be displayed.%s" % (missing_stacks, enomem_str), From 156a7d150a20f2ce7cce0fb7144952ab9fedf6e7 Mon Sep 17 00:00:00 2001 From: William Findlay Date: Wed, 24 Jun 2020 11:14:05 -0400 Subject: [PATCH 174/278] Fix KFUNC_PROBE calls in vfs_stat.py by adding a return value (#2990) Fix KFUNC_PROBE calls in vfs_stat.py by adding a return value of 0 --- tools/vfsstat.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tools/vfsstat.py b/tools/vfsstat.py index e044ce502..a3d22db82 100755 --- a/tools/vfsstat.py +++ b/tools/vfsstat.py @@ -66,11 +66,11 @@ def usage(): """ bpf_text_kfunc = """ -KFUNC_PROBE(vfs_read, int unused) { stats_increment(S_READ); } -KFUNC_PROBE(vfs_write, int unused) { stats_increment(S_WRITE); } -KFUNC_PROBE(vfs_fsync, int unused) { stats_increment(S_FSYNC); } -KFUNC_PROBE(vfs_open, int unused) { stats_increment(S_OPEN); } -KFUNC_PROBE(vfs_create, int unused) { stats_increment(S_CREATE); } +KFUNC_PROBE(vfs_read, int unused) { stats_increment(S_READ); return 0; } +KFUNC_PROBE(vfs_write, int unused) { stats_increment(S_WRITE); return 0; } +KFUNC_PROBE(vfs_fsync, int unused) { stats_increment(S_FSYNC); return 0; } +KFUNC_PROBE(vfs_open, int unused) { stats_increment(S_OPEN); return 0; } +KFUNC_PROBE(vfs_create, int unused) { stats_increment(S_CREATE); return 0; } """ is_support_kfunc = BPF.support_kfunc() From fe730f29f14bef8b5ffe1112c578df876c44d22d Mon Sep 17 00:00:00 2001 From: William Findlay Date: Thu, 25 Jun 2020 18:59:50 -0400 Subject: [PATCH 175/278] Ringbuf Support for Python API (#2989) This pull request contains an implementation for ringbuf support in bcc's Python API. Fixes #2985. More specifically, the following are added: - ringbuf helpers from libbpf API to libbcc - a new RingBuf class to represent the ringbuf map - BPF_RINGBUF_OUTPUT macro for BPF programs - tests - detailed documentation and examples --- docs/reference_guide.md | 244 ++++++++++++++++++++ examples/ringbuf/ringbuf_output.py | 53 +++++ examples/ringbuf/ringbuf_submit.py | 56 +++++ src/cc/export/helpers.h | 21 +- src/cc/frontends/clang/b_frontend_action.cc | 61 +++++ src/cc/libbpf.c | 32 +++ src/cc/libbpf.h | 11 + src/python/bcc/__init__.py | 40 +++- src/python/bcc/libbcc.py | 12 + src/python/bcc/table.py | 198 +++++++++++----- tests/python/CMakeLists.txt | 2 + tests/python/test_ringbuf.py | 169 ++++++++++++++ 12 files changed, 837 insertions(+), 62 deletions(-) create mode 100755 examples/ringbuf/ringbuf_output.py create mode 100755 examples/ringbuf/ringbuf_submit.py create mode 100755 tests/python/test_ringbuf.py diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 21649a788..924fa2031 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -37,6 +37,11 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [1. bpf_trace_printk()](#1-bpf_trace_printk) - [2. BPF_PERF_OUTPUT](#2-bpf_perf_output) - [3. perf_submit()](#3-perf_submit) + - [4. BPF_RINGBUF_OUTPUT](#4-bpf_ringbuf_output) + - [5. ringbuf_output()](#5-ringbuf_output) + - [6. ringbuf_reserve()](#6-ringbuf_reserve) + - [7. ringbuf_submit()](#7-ringbuf_submit) + - [8. ringbuf_discard()](#8-ringbuf_submit) - [Maps](#maps) - [1. BPF_TABLE](#1-bpf_table) - [2. BPF_HASH](#2-bpf_hash) @@ -81,6 +86,8 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [2. trace_fields()](#2-trace_fields) - [Output](#output) - [1. perf_buffer_poll()](#1-perf_buffer_poll) + - [2. ring_buffer_poll()](#2-ring_buffer_poll) + - [3. ring_buffer_consume()](#3-ring_buffer_consume) - [Maps](#maps) - [1. get_table()](#1-get_table) - [2. open_perf_buffer()](#2-open_perf_buffer) @@ -89,6 +96,7 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [5. clear()](#5-clear) - [6. print_log2_hist()](#6-print_log2_hist) - [7. print_linear_hist()](#6-print_linear_hist) + - [8. open_ring_buffer()](#8-open_ring_buffer) - [Helpers](#helpers) - [1. ksym()](#1-ksym) - [2. ksymname()](#2-ksymname) @@ -647,6 +655,131 @@ Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=perf_submit+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=perf_submit+path%3Atools&type=Code) +### 4. BPF_RINGBUF_OUTPUT + +Syntax: ```BPF_RINGBUF_OUTPUT(name, page_cnt)``` + +Creates a BPF table for pushing out custom event data to user space via a ringbuf ring buffer. +```BPF_RINGBUF_OUTPUT``` has several advantages over ```BPF_PERF_OUTPUT```, summarized as follows: + +- Buffer is shared across all CPUs, meaning no per-CPU allocation +- Supports two APIs for BPF programs + - ```map.ringbuf_output()``` works like ```map.perf_submit()``` (covered in [ringbuf_output](#5-ringbuf_output)) + - ```map.ringbuf_reserve()```/```map.ringbuf_submit()```/```map.ringbuf_discard()``` + split the process of reserving buffer space and submitting events into two steps + (covered in [ringbuf_reserve](#6-ringbuf_reserve), [ringbuf_submit](#7-ringbuf_submit), [ringbuf_discard](#8-ringbuf_submit)) +- BPF APIs do not require access to a CPU ctx argument +- Superior performance and latency in userspace thanks to a shared ring buffer manager +- Supports two ways of consuming data in userspace + +Starting in Linux 5.8, this should be the preferred method for pushing per-event data to user space. + +Example of both APIs: + +```C +struct data_t { + u32 pid; + u64 ts; + char comm[TASK_COMM_LEN]; +}; + +// Creates a ringbuf called events with 8 pages of space, shared across all CPUs +BPF_RINGBUF_OUTPUT(events, 8); + +int first_api_example(struct pt_regs *ctx) { + struct data_t data = {}; + + data.pid = bpf_get_current_pid_tgid(); + data.ts = bpf_ktime_get_ns(); + bpf_get_current_comm(&data.comm, sizeof(data.comm)); + + events.ringbuf_output(&data, sizeof(data), 0 /* flags */); + + return 0; +} + +int second_api_example(struct pt_regs *ctx) { + struct data_t *data = events.ringbuf_reserve(sizeof(struct data_t)); + if (!data) { // Failed to reserve space + return 1; + } + + data->pid = bpf_get_current_pid_tgid(); + data->ts = bpf_ktime_get_ns(); + bpf_get_current_comm(&data->comm, sizeof(data->comm)); + + events.ringbuf_submit(data, 0 /* flags */); + + return 0; +} +``` + +The output table is named ```events```. Data is allocated via ```events.ringbuf_reserve()``` and pushed to it via ```events.ringbuf_submit()```. + +Examples in situ: +[search /examples](https://github.com/iovisor/bcc/search?q=BPF_RINGBUF_OUTPUT+path%3Aexamples&type=Code), + +### 5. ringbuf_output() + +Syntax: ```int ringbuf_output((void *)data, u64 data_size, u64 flags)``` + +Return: 0 on success + +Flags: + - ```BPF_RB_NO_WAKEUP```: Do not sent notification of new data availability + - ```BPF_RB_FORCE_WAKEUP```: Send notification of new data availability unconditionally + +A method of the BPF_RINGBUF_OUTPUT table, for submitting custom event data to user space. This method works like ```perf_submit()```, +although it does not require a ctx argument. + +Examples in situ: +[search /examples](https://github.com/iovisor/bcc/search?q=ringbuf_output+path%3Aexamples&type=Code), + +### 6. ringbuf_reserve() + +Syntax: ```void* ringbuf_reserve(u64 data_size)``` + +Return: Pointer to data struct on success, NULL on failure + +A method of the BPF_RINGBUF_OUTPUT table, for reserving space in the ring buffer and simultaenously +allocating a data struct for output. Must be used with one of ```ringbuf_submit``` or ```ringbuf_discard```. + +Examples in situ: +[search /examples](https://github.com/iovisor/bcc/search?q=ringbuf_reserve+path%3Aexamples&type=Code), + +### 7. ringbuf_submit() + +Syntax: ```void ringbuf_submit((void *)data, u64 flags)``` + +Return: Nothing, always succeeds + +Flags: + - ```BPF_RB_NO_WAKEUP```: Do not sent notification of new data availability + - ```BPF_RB_FORCE_WAKEUP```: Send notification of new data availability unconditionally + +A method of the BPF_RINGBUF_OUTPUT table, for submitting custom event data to user space. Must be preceded by a call to +```ringbuf_reserve()``` to reserve space for the data. + +Examples in situ: +[search /examples](https://github.com/iovisor/bcc/search?q=ringbuf_submit+path%3Aexamples&type=Code), + +### 8. ringbuf_discard() + +Syntax: ```void ringbuf_discard((void *)data, u64 flags)``` + +Return: Nothing, always succeeds + +Flags: + - ```BPF_RB_NO_WAKEUP```: Do not sent notification of new data availability + - ```BPF_RB_FORCE_WAKEUP```: Send notification of new data availability unconditionally + +A method of the BPF_RINGBUF_OUTPUT table, for discarding custom event data; userspace +ignores the data associated with the discarded event. Must be preceded by a call to +```ringbuf_reserve()``` to reserve space for the data. + +Examples in situ: +[search /examples](https://github.com/iovisor/bcc/search?q=ringbuf_submit+path%3Aexamples&type=Code), + ## Maps Maps are BPF data stores, and are the basis for higher level object types including tables, hashes, and histograms. @@ -1451,6 +1584,55 @@ Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=perf_buffer_poll+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=perf_buffer_poll+path%3Atools+language%3Apython&type=Code) +### 2. ring_buffer_poll() + +Syntax: ```BPF.ring_buffer_poll(timeout=T)``` + +This polls from all open ringbuf ring buffers, calling the callback function that was provided when calling open_ring_buffer for each entry. + +The timeout parameter is optional and measured in milliseconds. In its absence, polling continues until +there is no more data or the callback returns a negative value. + +Example: + +```Python +# loop with callback to print_event +b["events"].open_ring_buffer(print_event) +while 1: + try: + b.ring_buffer_poll(30) + except KeyboardInterrupt: + exit(); +``` + +Examples in situ: +[search /examples](https://github.com/iovisor/bcc/search?q=ring_buffer_poll+path%3Aexamples+language%3Apython&type=Code), + +### 3. ring_buffer_consume() + +Syntax: ```BPF.ring_buffer_consume()``` + +This consumes from all open ringbuf ring buffers, calling the callback function that was provided when calling open_ring_buffer for each entry. + +Unlike ```ring_buffer_poll```, this method **does not poll for data** before attempting to consume. +This reduces latency at the expense of higher CPU consumption. If you are unsure which to use, +use ```ring_buffer_poll```. + +Example: + +```Python +# loop with callback to print_event +b["events"].open_ring_buffer(print_event) +while 1: + try: + b.ring_buffer_consume() + except KeyboardInterrupt: + exit(); +``` + +Examples in situ: +[search /examples](https://github.com/iovisor/bcc/search?q=ring_buffer_consume+path%3Aexamples+language%3Apython&type=Code), + ## Maps Maps are BPF data stores, and are used in bcc to implement a table, and then higher level objects on top of tables, including hashes and histograms. @@ -1694,6 +1876,68 @@ Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=print_linear_hist+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=print_linear_hist+path%3Atools+language%3Apython&type=Code) +### 8. open_ring_buffer() + +Syntax: ```table.open_ring_buffer(callback, ctx=None)``` + +This operates on a table as defined in BPF as BPF_RINGBUF_OUTPUT(), and associates the callback Python function ```callback``` to be called when data is available in the ringbuf ring buffer. This is part of the new (Linux 5.8+) recommended mechanism for transferring per-event data from kernel to user space. Unlike perf buffers, ringbuf sizes are specified within the BPF program, as part of the ```BPF_RINGBUF_OUTPUT``` macro. If the callback is not processing data fast enough, some submitted data may be lost. In this case, the events should be polled more frequently and/or the size of the ring buffer should be increased. + +Example: + +```Python +# process event +def print_event(ctx, data, size): + event = ct.cast(data, ct.POINTER(Data)).contents + [...] + +# loop with callback to print_event +b["events"].open_ring_buffer(print_event) +while 1: + try: + b.ring_buffer_poll() + except KeyboardInterrupt: + exit() +``` + +Note that the data structure transferred will need to be declared in C in the BPF program. For example: + +```C +// define output data structure in C +struct data_t { + u32 pid; + u64 ts; + char comm[TASK_COMM_LEN]; +}; +BPF_RINGBUF_OUTPUT(events, 8); +[...] +``` + +In Python, you can either let bcc generate the data structure from C declaration automatically (recommended): + +```Python +def print_event(ctx, data, size): + event = b["events"].event(data) +[...] +``` + +or define it manually: + +```Python +# define output data structure in Python +TASK_COMM_LEN = 16 # linux/sched.h +class Data(ct.Structure): + _fields_ = [("pid", ct.c_ulonglong), + ("ts", ct.c_ulonglong), + ("comm", ct.c_char * TASK_COMM_LEN)] + +def print_event(ctx, data, size): + event = ct.cast(data, ct.POINTER(Data)).contents +[...] +``` + +Examples in situ: +[search /examples](https://github.com/iovisor/bcc/search?q=open_ring_buffer+path%3Aexamples+language%3Apython&type=Code), + ## Helpers Some helper methods provided by bcc. Note that since we're in Python, we can import any Python library and their methods, including, for example, the libraries: argparse, collections, ctypes, datetime, re, socket, struct, subprocess, sys, and time. diff --git a/examples/ringbuf/ringbuf_output.py b/examples/ringbuf/ringbuf_output.py new file mode 100755 index 000000000..6e3cc0d5c --- /dev/null +++ b/examples/ringbuf/ringbuf_output.py @@ -0,0 +1,53 @@ +#!/usr/bin/python3 + +import sys +import time + +from bcc import BPF + +src = r""" +BPF_RINGBUF_OUTPUT(buffer, 1 << 4); + +struct event { + char filename[16]; + int dfd; + int flags; + int mode; +}; + +TRACEPOINT_PROBE(syscalls, sys_enter_openat) { + int zero = 0; + + struct event event = {}; + + bpf_probe_read_user_str(event.filename, sizeof(event.filename), args->filename); + + event.dfd = args->dfd; + event.flags = args->flags; + event.mode = args->mode; + + buffer.ringbuf_output(&event, sizeof(event), 0); + + return 0; +} +""" + +b = BPF(text=src) + +def callback(ctx, data, size): + event = b['buffer'].event(data) + print("%-16s %10d %10d %10d" % (event.filename.decode('utf-8'), event.dfd, event.flags, event.mode)) + +b['buffer'].open_ring_buffer(callback) + +print("Printing openat() calls, ctrl-c to exit.") + +print("%-16s %10s %10s %10s" % ("FILENAME", "DIR_FD", "FLAGS", "MODE")) + +try: + while 1: + b.ring_buffer_poll() + # or b.ring_buffer_consume() + time.sleep(0.5) +except KeyboardInterrupt: + sys.exit() diff --git a/examples/ringbuf/ringbuf_submit.py b/examples/ringbuf/ringbuf_submit.py new file mode 100755 index 000000000..53e28086d --- /dev/null +++ b/examples/ringbuf/ringbuf_submit.py @@ -0,0 +1,56 @@ +#!/usr/bin/python3 + +import sys +import time + +from bcc import BPF + +src = r""" +BPF_RINGBUF_OUTPUT(buffer, 1 << 4); + +struct event { + char filename[64]; + int dfd; + int flags; + int mode; +}; + +TRACEPOINT_PROBE(syscalls, sys_enter_openat) { + int zero = 0; + + struct event *event = buffer.ringbuf_reserve(sizeof(struct event)); + if (!event) { + return 1; + } + + bpf_probe_read_user_str(event->filename, sizeof(event->filename), args->filename); + + event->dfd = args->dfd; + event->flags = args->flags; + event->mode = args->mode; + + buffer.ringbuf_submit(event, 0); + // or, to discard: buffer.ringbuf_discard(event, 0); + + return 0; +} +""" + +b = BPF(text=src) + +def callback(ctx, data, size): + event = b['buffer'].event(data) + print("%-64s %10d %10d %10d" % (event.filename.decode('utf-8'), event.dfd, event.flags, event.mode)) + +b['buffer'].open_ring_buffer(callback) + +print("Printing openat() calls, ctrl-c to exit.") + +print("%-64s %10s %10s %10s" % ("FILENAME", "DIR_FD", "FLAGS", "MODE")) + +try: + while 1: + b.ring_buffer_consume() + time.sleep(0.5) +except KeyboardInterrupt: + sys.exit() diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index b73d0041a..cfe78699b 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -51,6 +51,7 @@ R"********( #include #include #include +#include #ifndef CONFIG_BPF_SYSCALL #error "CONFIG_BPF_SYSCALL is undefined, please check your .config or ask your Linux distro to enable this feature" @@ -128,7 +129,7 @@ struct _name##_table_t __##_name #endif #endif -// Table for pushing custom events to userspace via ring buffer +// Table for pushing custom events to userspace via perf ring buffer #define BPF_PERF_OUTPUT(_name) \ struct _name##_table_t { \ int key; \ @@ -141,6 +142,24 @@ struct _name##_table_t { \ __attribute__((section("maps/perf_output"))) \ struct _name##_table_t _name = { .max_entries = 0 } +// Table for pushing custom events to userspace via ring buffer +#define BPF_RINGBUF_OUTPUT(_name, _num_pages) \ +struct _name##_table_t { \ + int key; \ + u32 leaf; \ + /* map.ringbuf_output(data, data_size, flags) */ \ + int (*ringbuf_output) (void *, u64, u64); \ + /* map.ringbuf_reserve(data_size) */ \ + void* (*ringbuf_reserve) (u64); \ + /* map.ringbuf_discard(data, flags) */ \ + void (*ringbuf_discard) (void *, u64); \ + /* map.ringbuf_submit(data, flags) */ \ + void (*ringbuf_submit) (void *, u64); \ + u32 max_entries; \ +}; \ +__attribute__((section("maps/ringbuf"))) \ +struct _name##_table_t _name = { .max_entries = ((_num_pages) * PAGE_SIZE) } + // Table for reading hw perf cpu counters #define BPF_PERF_ARRAY(_name, _max_entries) \ struct _name##_table_t { \ diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc index 319689d3e..311697eea 100644 --- a/src/cc/frontends/clang/b_frontend_action.cc +++ b/src/cc/frontends/clang/b_frontend_action.cc @@ -940,6 +940,62 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) { string flag = rewriter_.getRewrittenText(expansionRange(Call->getArg(2)->getSourceRange())); txt = "bpf_" + string(memb_name) + "(" + ctx + ", " + "bpf_pseudo_fd(1, " + fd + "), " + keyp + ", " + flag + ");"; + } else if (memb_name == "ringbuf_output") { + string name = string(Ref->getDecl()->getName()); + string args = rewriter_.getRewrittenText(expansionRange(SourceRange(GET_BEGINLOC(Call->getArg(0)), + GET_ENDLOC(Call->getArg(2))))); + txt = "bpf_ringbuf_output(bpf_pseudo_fd(1, " + fd + ")"; + txt += ", " + args + ")"; + + // e.g. + // struct data_t { u32 pid; }; data_t data; + // events.ringbuf_output(&data, sizeof(data), 0); + // ... + // &data -> data -> typeof(data) -> data_t + auto type_arg0 = Call->getArg(0)->IgnoreCasts()->getType().getTypePtr()->getPointeeType().getTypePtr(); + if (type_arg0->isStructureType()) { + auto event_type = type_arg0->getAsTagDecl(); + const auto *r = dyn_cast(event_type); + std::vector perf_event; + + for (auto it = r->field_begin(); it != r->field_end(); ++it) { + perf_event.push_back(it->getNameAsString() + "#" + it->getType().getAsString()); //"pid#u32" + } + fe_.perf_events_[name] = perf_event; + } + } else if (memb_name == "ringbuf_reserve") { + string name = string(Ref->getDecl()->getName()); + string arg0 = rewriter_.getRewrittenText(expansionRange(Call->getArg(0)->getSourceRange())); + txt = "bpf_ringbuf_reserve(bpf_pseudo_fd(1, " + fd + ")"; + txt += ", " + arg0 + ", 0)"; // Flags in reserve are meaningless + } else if (memb_name == "ringbuf_discard") { + string name = string(Ref->getDecl()->getName()); + string args = rewriter_.getRewrittenText(expansionRange(SourceRange(GET_BEGINLOC(Call->getArg(0)), + GET_ENDLOC(Call->getArg(1))))); + txt = "bpf_ringbuf_discard(" + args + ")"; + } else if (memb_name == "ringbuf_submit") { + string name = string(Ref->getDecl()->getName()); + string args = rewriter_.getRewrittenText(expansionRange(SourceRange(GET_BEGINLOC(Call->getArg(0)), + GET_ENDLOC(Call->getArg(1))))); + txt = "bpf_ringbuf_submit(" + args + ")"; + + // e.g. + // struct data_t { u32 pid; }; + // data_t *data = events.ringbuf_reserve(sizeof(data_t)); + // events.ringbuf_submit(data, 0); + // ... + // &data -> data -> typeof(data) -> data_t + auto type_arg0 = Call->getArg(0)->IgnoreCasts()->getType().getTypePtr()->getPointeeType().getTypePtr(); + if (type_arg0->isStructureType()) { + auto event_type = type_arg0->getAsTagDecl(); + const auto *r = dyn_cast(event_type); + std::vector perf_event; + + for (auto it = r->field_begin(); it != r->field_end(); ++it) { + perf_event.push_back(it->getNameAsString() + "#" + it->getType().getAsString()); //"pid#u32" + } + fe_.perf_events_[name] = perf_event; + } } else { if (memb_name == "lookup") { prefix = "bpf_map_lookup_elem"; @@ -1356,6 +1412,11 @@ bool BTypeVisitor::VisitVarDecl(VarDecl *Decl) { if (numcpu <= 0) numcpu = 1; table.max_entries = numcpu; + } else if (section_attr == "maps/ringbuf") { + map_type = BPF_MAP_TYPE_RINGBUF; + // values from libbpf/src/libbpf_probes.c + table.key_size = 0; + table.leaf_size = 0; } else if (section_attr == "maps/perf_array") { map_type = BPF_MAP_TYPE_PERF_EVENT_ARRAY; } else if (section_attr == "maps/cgroup_array") { diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index de27c3472..e3d38cca0 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -1399,3 +1399,35 @@ int bpf_close_perf_event_fd(int fd) { } return error; } + +/* Create a new ringbuf manager to manage ringbuf associated with + * map_fd, associating it with callback sample_cb. */ +void * bpf_new_ringbuf(int map_fd, ring_buffer_sample_fn sample_cb, void *ctx) { + return ring_buffer__new(map_fd, sample_cb, ctx, NULL); +} + +/* Free the ringbuf manager rb and all ring buffers associated with it. */ +void bpf_free_ringbuf(struct ring_buffer *rb) { + ring_buffer__free(rb); +} + +/* Add a new ring buffer associated with map_fd to the ring buffer manager rb, + * associating it with callback sample_cb. */ +int bpf_add_ringbuf(struct ring_buffer *rb, int map_fd, + ring_buffer_sample_fn sample_cb, void *ctx) { + return ring_buffer__add(rb, map_fd, sample_cb, ctx); +} + +/* Poll for available data and consume, if data is available. Returns number + * of records consumed, or a negative number if any callbacks returned an + * error. */ +int bpf_poll_ringbuf(struct ring_buffer *rb, int timeout_ms) { + return ring_buffer__poll(rb, timeout_ms); +} + +/* Consume available data _without_ polling. Good for use cases where low + * latency is desired over performance impact. Returns number of records + * consumed, or a negative number if any callbacks returned an error. */ +int bpf_consume_ringbuf(struct ring_buffer *rb) { + return ring_buffer__consume(rb); +} diff --git a/src/cc/libbpf.h b/src/cc/libbpf.h index 61471b5b8..2e192381a 100644 --- a/src/cc/libbpf.h +++ b/src/cc/libbpf.h @@ -121,6 +121,17 @@ int bpf_open_perf_event(uint32_t type, uint64_t config, int pid, int cpu); int bpf_close_perf_event_fd(int fd); +typedef int (*ring_buffer_sample_fn)(void *ctx, void *data, size_t size); + +struct ring_buffer; + +void * bpf_new_ringbuf(int map_fd, ring_buffer_sample_fn sample_cb, void *ctx); +void bpf_free_ringbuf(struct ring_buffer *rb); +int bpf_add_ringbuf(struct ring_buffer *rb, int map_fd, + ring_buffer_sample_fn sample_cb, void *ctx); +int bpf_poll_ringbuf(struct ring_buffer *rb, int timeout_ms); +int bpf_consume_ringbuf(struct ring_buffer *rb); + int bpf_obj_pin(int fd, const char *pathname); int bpf_obj_get(const char *pathname); int bpf_obj_get_info(int prog_map_fd, void *info, uint32_t *info_len); diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index e12022109..df5b40f0f 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -24,7 +24,7 @@ import sys from .libbcc import lib, bcc_symbol, bcc_symbol_option, bcc_stacktrace_build_id, _SYM_CB_TYPE -from .table import Table, PerfEventArray +from .table import Table, PerfEventArray, RingBuf from .perf import Perf from .utils import get_online_cpus, printb, _assert_is_bytes, ArgString, StrcmpRewrite from .version import __version__ @@ -314,6 +314,7 @@ def __init__(self, src_file=b"", hdr_file=b"", text=None, debug=0, self.lsm_fds = {} self.perf_buffers = {} self.open_perf_events = {} + self._ringbuf_manager = None self.tracefile = None atexit.register(self.cleanup) @@ -1441,6 +1442,38 @@ def kprobe_poll(self, timeout = -1): """ self.perf_buffer_poll(timeout) + def _open_ring_buffer(self, map_fd, fn, ctx=None): + if not self._ringbuf_manager: + self._ringbuf_manager = lib.bpf_new_ringbuf(map_fd, fn, ctx) + if not self._ringbuf_manager: + raise Exception("Could not open ring buffer") + else: + ret = lib.bpf_add_ringbuf(self._ringbuf_manager, map_fd, fn, ctx) + if ret < 0: + raise Exception("Could not open ring buffer") + + def ring_buffer_poll(self, timeout = -1): + """ring_buffer_poll(self) + + Poll from all open ringbuf buffers, calling the callback that was + provided when calling open_ring_buffer for each entry. + """ + if not self._ringbuf_manager: + raise Exception("No ring buffers to poll") + lib.bpf_poll_ringbuf(self._ringbuf_manager, timeout) + + def ring_buffer_consume(self): + """ring_buffer_consume(self) + + Consume all open ringbuf buffers, regardless of whether or not + they currently contain events data. This is best for use cases + where low latency is desired, but it can impact performance. + If you are unsure, use ring_buffer_poll instead. + """ + if not self._ringbuf_manager: + raise Exception("No ring buffers to poll") + lib.bpf_consume_ringbuf(self._ringbuf_manager) + def free_bcc_memory(self): return lib.bcc_free_memory() @@ -1492,6 +1525,11 @@ def cleanup(self): lib.bpf_module_destroy(self.module) self.module = None + # Clean up ringbuf + if self._ringbuf_manager: + lib.bpf_free_ringbuf(self._ringbuf_manager) + self._ringbuf_manager = None + def __enter__(self): return self diff --git a/src/python/bcc/libbcc.py b/src/python/bcc/libbcc.py index 92f6c5e49..52affb613 100644 --- a/src/python/bcc/libbcc.py +++ b/src/python/bcc/libbcc.py @@ -135,6 +135,18 @@ lib.bpf_close_perf_event_fd.restype = ct.c_int lib.bpf_close_perf_event_fd.argtype = [ct.c_int] +_RINGBUF_CB_TYPE = ct.CFUNCTYPE(ct.c_int, ct.c_void_p, ct.c_void_p, ct.c_int) +lib.bpf_new_ringbuf.restype = ct.c_void_p +lib.bpf_new_ringbuf.argtypes = [ct.c_int, _RINGBUF_CB_TYPE, ct.c_void_p] +lib.bpf_free_ringbuf.restype = None +lib.bpf_free_ringbuf.argtypes = [ct.c_void_p] +lib.bpf_add_ringbuf.restype = ct.c_int +lib.bpf_add_ringbuf.argtypes = [ct.c_void_p, ct.c_int, _RINGBUF_CB_TYPE, ct.c_void_p] +lib.bpf_poll_ringbuf.restype = ct.c_int +lib.bpf_poll_ringbuf.argtypes = [ct.c_void_p, ct.c_int] +lib.bpf_consume_ringbuf.restype = ct.c_int +lib.bpf_consume_ringbuf.argtypes = [ct.c_void_p] + # bcc symbol helpers class bcc_symbol(ct.Structure): _fields_ = [ diff --git a/src/python/bcc/table.py b/src/python/bcc/table.py index 9f8842634..b8f108ffb 100644 --- a/src/python/bcc/table.py +++ b/src/python/bcc/table.py @@ -22,7 +22,7 @@ import re import sys -from .libbcc import lib, _RAW_CB_TYPE, _LOST_CB_TYPE +from .libbcc import lib, _RAW_CB_TYPE, _LOST_CB_TYPE, _RINGBUF_CB_TYPE from .perf import Perf from .utils import get_online_cpus from .utils import get_possible_cpus @@ -46,6 +46,15 @@ BPF_MAP_TYPE_CPUMAP = 16 BPF_MAP_TYPE_XSKMAP = 17 BPF_MAP_TYPE_SOCKHASH = 18 +BPF_MAP_TYPE_CGROUP_STORAGE = 19 +BPF_MAP_TYPE_REUSEPORT_SOCKARRAY = 20 +BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE = 21 +BPF_MAP_TYPE_QUEUE = 22 +BPF_MAP_TYPE_STACK = 23 +BPF_MAP_TYPE_SK_STORAGE = 24 +BPF_MAP_TYPE_DEVMAP_HASH = 25 +BPF_MAP_TYPE_STRUCT_OPS = 26 +BPF_MAP_TYPE_RINGBUF = 27 map_type_name = {BPF_MAP_TYPE_HASH: "HASH", BPF_MAP_TYPE_ARRAY: "ARRAY", @@ -64,7 +73,16 @@ BPF_MAP_TYPE_SOCKMAP: "SOCKMAP", BPF_MAP_TYPE_CPUMAP: "CPUMAP", BPF_MAP_TYPE_XSKMAP: "XSKMAP", - BPF_MAP_TYPE_SOCKHASH: "SOCKHASH",} + BPF_MAP_TYPE_SOCKHASH: "SOCKHASH", + BPF_MAP_TYPE_CGROUP_STORAGE: "CGROUP_STORAGE", + BPF_MAP_TYPE_REUSEPORT_SOCKARRAY: "REUSEPORT_SOCKARRAY", + BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE: "PERCPU_CGROUP_STORAGE", + BPF_MAP_TYPE_QUEUE: "QUEUE", + BPF_MAP_TYPE_STACK: "STACK", + BPF_MAP_TYPE_SK_STORAGE: "SK_STORAGE", + BPF_MAP_TYPE_DEVMAP_HASH: "DEVMAP_HASH", + BPF_MAP_TYPE_STRUCT_OPS: "STRUCT_OPS", + BPF_MAP_TYPE_RINGBUF: "RINGBUF",} stars_max = 40 log2_index_max = 65 @@ -151,6 +169,63 @@ def get_table_type_name(ttype): return "" +def _get_event_class(event_map): + ct_mapping = { 'char' : ct.c_char, + 's8' : ct.c_char, + 'unsigned char' : ct.c_ubyte, + 'u8' : ct.c_ubyte, + 'u8 *' : ct.c_char_p, + 'char *' : ct.c_char_p, + 'short' : ct.c_short, + 's16' : ct.c_short, + 'unsigned short' : ct.c_ushort, + 'u16' : ct.c_ushort, + 'int' : ct.c_int, + 's32' : ct.c_int, + 'enum' : ct.c_int, + 'unsigned int' : ct.c_uint, + 'u32' : ct.c_uint, + 'long' : ct.c_long, + 'unsigned long' : ct.c_ulong, + 'long long' : ct.c_longlong, + 's64' : ct.c_longlong, + 'unsigned long long': ct.c_ulonglong, + 'u64' : ct.c_ulonglong, + '__int128' : (ct.c_longlong * 2), + 'unsigned __int128' : (ct.c_ulonglong * 2), + 'void *' : ct.c_void_p } + + # handle array types e.g. "int [16] foo" + array_type = re.compile(r"(.+) \[([0-9]+)\]$") + + fields = [] + num_fields = lib.bpf_perf_event_fields(event_map.bpf.module, event_map._name) + i = 0 + while i < num_fields: + field = lib.bpf_perf_event_field(event_map.bpf.module, event_map._name, i).decode() + m = re.match(r"(.*)#(.*)", field) + field_name = m.group(1) + field_type = m.group(2) + + if re.match(r"enum .*", field_type): + field_type = "enum" + + m = array_type.match(field_type) + try: + if m: + fields.append((field_name, ct_mapping[m.group(1)] * int(m.group(2)))) + else: + fields.append((field_name, ct_mapping[field_type])) + except KeyError: + # Using print+sys.exit instead of raising exceptions, + # because exceptions are caught by the caller. + print("Type: '%s' not recognized. Please define the data with ctypes manually." + % field_type, file=sys.stderr) + sys.exit(1) + i += 1 + return type('', (ct.Structure,), {'_fields_': fields}) + + def Table(bpf, map_id, map_fd, keytype, leaftype, name, **kwargs): """Table(bpf, map_id, map_fd, keytype, leaftype, **kwargs) @@ -190,6 +265,8 @@ def Table(bpf, map_id, map_fd, keytype, leaftype, name, **kwargs): t = MapInMapArray(bpf, map_id, map_fd, keytype, leaftype) elif ttype == BPF_MAP_TYPE_HASH_OF_MAPS: t = MapInMapHash(bpf, map_id, map_fd, keytype, leaftype) + elif ttype == BPF_MAP_TYPE_RINGBUF: + t = RingBuf(bpf, map_id, map_fd, keytype, leaftype, name) if t == None: raise Exception("Unknown table type %d" % ttype) return t @@ -599,72 +676,16 @@ def __delitem__(self, key): lib.bpf_close_perf_event_fd(self._open_key_fds[key]) del self._open_key_fds[key] - def _get_event_class(self): - ct_mapping = { 'char' : ct.c_char, - 's8' : ct.c_char, - 'unsigned char' : ct.c_ubyte, - 'u8' : ct.c_ubyte, - 'u8 *' : ct.c_char_p, - 'char *' : ct.c_char_p, - 'short' : ct.c_short, - 's16' : ct.c_short, - 'unsigned short' : ct.c_ushort, - 'u16' : ct.c_ushort, - 'int' : ct.c_int, - 's32' : ct.c_int, - 'enum' : ct.c_int, - 'unsigned int' : ct.c_uint, - 'u32' : ct.c_uint, - 'long' : ct.c_long, - 'unsigned long' : ct.c_ulong, - 'long long' : ct.c_longlong, - 's64' : ct.c_longlong, - 'unsigned long long': ct.c_ulonglong, - 'u64' : ct.c_ulonglong, - '__int128' : (ct.c_longlong * 2), - 'unsigned __int128' : (ct.c_ulonglong * 2), - 'void *' : ct.c_void_p } - - # handle array types e.g. "int [16] foo" - array_type = re.compile(r"(.+) \[([0-9]+)\]$") - - fields = [] - num_fields = lib.bpf_perf_event_fields(self.bpf.module, self._name) - i = 0 - while i < num_fields: - field = lib.bpf_perf_event_field(self.bpf.module, self._name, i).decode() - m = re.match(r"(.*)#(.*)", field) - field_name = m.group(1) - field_type = m.group(2) - - if re.match(r"enum .*", field_type): - field_type = "enum" - - m = array_type.match(field_type) - try: - if m: - fields.append((field_name, ct_mapping[m.group(1)] * int(m.group(2)))) - else: - fields.append((field_name, ct_mapping[field_type])) - except KeyError: - # Using print+sys.exit instead of raising exceptions, - # because exceptions are caught by the caller. - print("Type: '%s' not recognized. Please define the data with ctypes manually." - % field_type, file=sys.stderr) - sys.exit(1) - i += 1 - return type('', (ct.Structure,), {'_fields_': fields}) - def event(self, data): """event(data) - When ring buffers are opened to receive custom perf event, + When perf buffers are opened to receive custom perf event, the underlying event data struct which is defined in C in the BPF program can be deduced via this function. This avoids redundant definitions in Python. """ if self._event_class == None: - self._event_class = self._get_event_class() + self._event_class = _get_event_class(self) return ct.cast(data, ct.POINTER(self._event_class)).contents def open_perf_buffer(self, callback, page_cnt=8, lost_cb=None): @@ -922,3 +943,60 @@ def __init__(self, *args, **kwargs): class MapInMapHash(HashTable): def __init__(self, *args, **kwargs): super(MapInMapHash, self).__init__(*args, **kwargs) + +class RingBuf(TableBase): + def __init__(self, *args, **kwargs): + super(RingBuf, self).__init__(*args, **kwargs) + self._ringbuf = None + self._event_class = None + + def __delitem(self, key): + pass + + def __del__(self): + pass + + def __len__(self): + return 0 + + def event(self, data): + """event(data) + + When ring buffers are opened to receive custom event, + the underlying event data struct which is defined in C in + the BPF program can be deduced via this function. This avoids + redundant definitions in Python. + """ + if self._event_class == None: + self._event_class = _get_event_class(self) + return ct.cast(data, ct.POINTER(self._event_class)).contents + + def open_ring_buffer(self, callback, ctx=None): + """open_ring_buffer(callback) + + Opens a ring buffer to receive custom event data from the bpf program. + The callback will be invoked for each event submitted from the kernel, + up to millions per second. + """ + + def ringbuf_cb_(ctx, data, size): + try: + ret = callback(ctx, data, size) + # Callback for ringbufs should _always_ return an integer. + # If the function the user registers does not, + # simply fall back to returning 0. + try: + ret = int(ret) + except: + ret = 0 + except IOError as e: + if e.errno == errno.EPIPE: + exit() + else: + raise e + return ret + + fn = _RINGBUF_CB_TYPE(ringbuf_cb_) + self.bpf._open_ring_buffer(self.map_fd, fn, ctx) + # keep a refcnt + self._cbs[0] = fn diff --git a/tests/python/CMakeLists.txt b/tests/python/CMakeLists.txt index 67b3303c9..df8d2d11c 100644 --- a/tests/python/CMakeLists.txt +++ b/tests/python/CMakeLists.txt @@ -89,3 +89,5 @@ add_test(NAME py_test_rlimit WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_test_rlimit sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_rlimit.py) add_test(NAME py_test_lpm_trie WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_test_lpm_trie sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_lpm_trie.py) +add_test(NAME py_ringbuf WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMAND ${TEST_WRAPPER} py_ringbuf sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_ringbuf.py) diff --git a/tests/python/test_ringbuf.py b/tests/python/test_ringbuf.py new file mode 100755 index 000000000..2c24eada1 --- /dev/null +++ b/tests/python/test_ringbuf.py @@ -0,0 +1,169 @@ +#!/usr/bin/env python +# Copyright (c) PLUMgrid, Inc. +# Licensed under the Apache License, Version 2.0 (the "License") + +from bcc import BPF +import os +import distutils.version +import ctypes as ct +import random +import time +import subprocess +from unittest import main, TestCase, skipUnless + +def kernel_version_ge(major, minor): + # True if running kernel is >= X.Y + version = distutils.version.LooseVersion(os.uname()[2]).version + if version[0] > major: + return True + if version[0] < major: + return False + if minor and version[1] < minor: + return False + return True + +class TestRingbuf(TestCase): + @skipUnless(kernel_version_ge(5,8), "requires kernel >= 5.8") + def test_ringbuf_output(self): + self.counter = 0 + + class Data(ct.Structure): + _fields_ = [("ts", ct.c_ulonglong)] + + def cb(ctx, data, size): + self.assertEqual(size, ct.sizeof(Data)) + event = ct.cast(data, ct.POINTER(Data)).contents + self.counter += 1 + + text = """ +BPF_RINGBUF_OUTPUT(events, 8); +struct data_t { + u64 ts; +}; +int do_sys_nanosleep(void *ctx) { + struct data_t data = {bpf_ktime_get_ns()}; + events.ringbuf_output(&data, sizeof(data), 0); + return 0; +} +""" + b = BPF(text=text) + b.attach_kprobe(event=b.get_syscall_fnname("nanosleep"), + fn_name="do_sys_nanosleep") + b.attach_kprobe(event=b.get_syscall_fnname("clock_nanosleep"), + fn_name="do_sys_nanosleep") + b["events"].open_ring_buffer(cb) + subprocess.call(['sleep', '0.1']) + b.ring_buffer_poll() + self.assertGreater(self.counter, 0) + b.cleanup() + + @skipUnless(kernel_version_ge(5,8), "requires kernel >= 5.8") + def test_ringbuf_consume(self): + self.counter = 0 + + class Data(ct.Structure): + _fields_ = [("ts", ct.c_ulonglong)] + + def cb(ctx, data, size): + self.assertEqual(size, ct.sizeof(Data)) + event = ct.cast(data, ct.POINTER(Data)).contents + self.counter += 1 + + text = """ +BPF_RINGBUF_OUTPUT(events, 8); +struct data_t { + u64 ts; +}; +int do_sys_nanosleep(void *ctx) { + struct data_t data = {bpf_ktime_get_ns()}; + events.ringbuf_output(&data, sizeof(data), 0); + return 0; +} +""" + b = BPF(text=text) + b.attach_kprobe(event=b.get_syscall_fnname("nanosleep"), + fn_name="do_sys_nanosleep") + b.attach_kprobe(event=b.get_syscall_fnname("clock_nanosleep"), + fn_name="do_sys_nanosleep") + b["events"].open_ring_buffer(cb) + subprocess.call(['sleep', '0.1']) + b.ring_buffer_consume() + self.assertGreater(self.counter, 0) + b.cleanup() + + @skipUnless(kernel_version_ge(5,8), "requires kernel >= 5.8") + def test_ringbuf_submit(self): + self.counter = 0 + + class Data(ct.Structure): + _fields_ = [("ts", ct.c_ulonglong)] + + def cb(ctx, data, size): + self.assertEqual(size, ct.sizeof(Data)) + event = ct.cast(data, ct.POINTER(Data)).contents + self.counter += 1 + + text = """ +BPF_RINGBUF_OUTPUT(events, 8); +struct data_t { + u64 ts; +}; +int do_sys_nanosleep(void *ctx) { + struct data_t *data = events.ringbuf_reserve(sizeof(struct data_t)); + if (!data) + return 1; + data->ts = bpf_ktime_get_ns(); + events.ringbuf_submit(data, 0); + return 0; +} +""" + b = BPF(text=text) + b.attach_kprobe(event=b.get_syscall_fnname("nanosleep"), + fn_name="do_sys_nanosleep") + b.attach_kprobe(event=b.get_syscall_fnname("clock_nanosleep"), + fn_name="do_sys_nanosleep") + b["events"].open_ring_buffer(cb) + subprocess.call(['sleep', '0.1']) + b.ring_buffer_poll() + self.assertGreater(self.counter, 0) + b.cleanup() + + @skipUnless(kernel_version_ge(5,8), "requires kernel >= 5.8") + def test_ringbuf_discard(self): + self.counter = 0 + + class Data(ct.Structure): + _fields_ = [("ts", ct.c_ulonglong)] + + def cb(ctx, data, size): + self.assertEqual(size, ct.sizeof(Data)) + event = ct.cast(data, ct.POINTER(Data)).contents + self.counter += 1 + + text = """ +BPF_RINGBUF_OUTPUT(events, 8); +struct data_t { + u64 ts; +}; +int do_sys_nanosleep(void *ctx) { + struct data_t *data = events.ringbuf_reserve(sizeof(struct data_t)); + if (!data) + return 1; + data->ts = bpf_ktime_get_ns(); + events.ringbuf_discard(data, 0); + return 0; +} +""" + b = BPF(text=text) + b.attach_kprobe(event=b.get_syscall_fnname("nanosleep"), + fn_name="do_sys_nanosleep") + b.attach_kprobe(event=b.get_syscall_fnname("clock_nanosleep"), + fn_name="do_sys_nanosleep") + b["events"].open_ring_buffer(cb) + subprocess.call(['sleep', '0.1']) + b.ring_buffer_poll() + self.assertEqual(self.counter, 0) + b.cleanup() + +if __name__ == "__main__": + main() From fbde62b089fd7bd7818fa4b4e36f89e9b49883f9 Mon Sep 17 00:00:00 2001 From: Simone Magnani Date: Fri, 26 Jun 2020 15:21:52 +0200 Subject: [PATCH 176/278] Introducing Queue/Stack helpers and clang frontend This commit aims to introduce helpers to declare Queue/Stack maps. I have supported also the creation of shared/public/pinned ones, as for the "traditional" tables. In clang frontend I have added both declaration of maps type/queue, type/stack and all the operations supported so far by these new maps (push/pop/peek). Possible declarations introduced: * BPF_QUEUESTACK(<"queue"/"stack">, , , , ) * BPF_QUEUESTACK_SHARED(...) * BPF_QUEUESTACK_PINNED(...) * BPF_QUEUESTACK_PUBLIC(...) * BPF_QUEUE(, , ) * BPF_QUEUE(, , , ) * BPF_STACK(, , ) * BPF_STACK(, , , ) Signed-off-by: Simone Magnani Co-authored-by: Sebastiano Miano --- src/cc/export/helpers.h | 54 +++++++++++++++++++++ src/cc/frontends/clang/b_frontend_action.cc | 17 ++++++- 2 files changed, 70 insertions(+), 1 deletion(-) diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index cfe78699b..ecf3fac6f 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -79,6 +79,15 @@ R"********( __attribute__ ((section(".maps." #name), used)) \ ____btf_map_##name = { } +// Associate map with its key/value types for QUEUE/STACK map types +#define BPF_ANNOTATE_KV_PAIR_QUEUESTACK(name, type_val) \ + struct ____btf_map_##name { \ + type_val value; \ + }; \ + struct ____btf_map_##name \ + __attribute__ ((section(".maps." #name), used)) \ + ____btf_map_##name = { } + // Changes to the macro require changes in BFrontendAction classes #define BPF_F_TABLE(_table_type, _key_type, _leaf_type, _name, _max_entries, _flags) \ struct _name##_table_t { \ @@ -100,6 +109,51 @@ __attribute__((section("maps/" _table_type))) \ struct _name##_table_t _name = { .flags = (_flags), .max_entries = (_max_entries) }; \ BPF_ANNOTATE_KV_PAIR(_name, _key_type, _leaf_type) + +// Changes to the macro require changes in BFrontendAction classes +#define BPF_QUEUESTACK(_table_type, _name, _leaf_type, _max_entries, _flags) \ +struct _name##_table_t { \ + _leaf_type leaf; \ + int * (*peek) (_leaf_type *); \ + int * (*pop) (_leaf_type *); \ + int * (*push) (_leaf_type *, u64); \ + u32 max_entries; \ + int flags; \ +}; \ +__attribute__((section("maps/" _table_type))) \ +struct _name##_table_t _name = { .flags = (_flags), .max_entries = (_max_entries) }; \ +BPF_ANNOTATE_KV_PAIR_QUEUESTACK(_name, _leaf_type) + +// define queue with 3 parameters (_type=queue/stack automatically) and default flags to 0 +#define BPF_QUEUE_STACK3(_type, _name, _leaf_type, _max_entries) \ + BPF_QUEUESTACK(_type, _name, _leaf_type, _max_entries, 0) + +// define queue with 4 parameters (_type=queue/stack automatically) +#define BPF_QUEUE_STACK4(_type, _name, _leaf_type, _max_entries, _flags) \ + BPF_QUEUESTACK(_type, _name, _leaf_type, _max_entries, _flags) + +// helper for default-variable macro function +#define BPF_QUEUE_STACKX(_1, _2, _3, _4, NAME, ...) NAME + +#define BPF_QUEUE(...) \ + BPF_QUEUE_STACKX(__VA_ARGS__, BPF_QUEUE_STACK4, BPF_QUEUE_STACK3)("queue", __VA_ARGS__) + +#define BPF_STACK(...) \ + BPF_QUEUE_STACKX(__VA_ARGS__, BPF_QUEUE_STACK4, BPF_QUEUE_STACK3)("stack", __VA_ARGS__) + +#define BPF_QUEUESTACK_PINNED(_table_type, _name, _leaf_type, _max_entries, _flags, _pinned) \ +BPF_QUEUESTACK(_table_type ":" _pinned, _name, _leaf_type, _max_entries, _flags) + +#define BPF_QUEUESTACK_PUBLIC(_table_type, _name, _leaf_type, _max_entries, _flags) \ +BPF_QUEUESTACK(_table_type, _name, _leaf_type, _max_entries, _flags); \ +__attribute__((section("maps/export"))) \ +struct _name##_table_t __##_name + +#define BPF_QUEUESTACK_SHARED(_table_type, _name, _leaf_type, _max_entries, _flags) \ +BPF_QUEUESTACK(_table_type, _name, _leaf_type, _max_entries, _flags); \ +__attribute__((section("maps/shared"))) \ +struct _name##_table_t __##_name + #define BPF_TABLE(_table_type, _key_type, _leaf_type, _name, _max_entries) \ BPF_F_TABLE(_table_type, _key_type, _leaf_type, _name, _max_entries, 0) diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc index 311697eea..39ba71e46 100644 --- a/src/cc/frontends/clang/b_frontend_action.cc +++ b/src/cc/frontends/clang/b_frontend_action.cc @@ -1036,7 +1036,16 @@ bool BTypeVisitor::VisitCallExpr(CallExpr *Call) { } else if (memb_name == "get_local_storage") { prefix = "bpf_get_local_storage"; suffix = ")"; - } else { + } else if (memb_name == "push") { + prefix = "bpf_map_push_elem"; + suffix = ")"; + } else if (memb_name == "pop") { + prefix = "bpf_map_pop_elem"; + suffix = ")"; + } else if (memb_name == "peek") { + prefix = "bpf_map_peek_elem"; + suffix = ")"; + } else { error(GET_BEGINLOC(Call), "invalid bpf_table operation %0") << memb_name; return false; } @@ -1419,6 +1428,12 @@ bool BTypeVisitor::VisitVarDecl(VarDecl *Decl) { table.leaf_size = 0; } else if (section_attr == "maps/perf_array") { map_type = BPF_MAP_TYPE_PERF_EVENT_ARRAY; + } else if (section_attr == "maps/queue") { + table.key_size = 0; + map_type = BPF_MAP_TYPE_QUEUE; + } else if (section_attr == "maps/stack") { + table.key_size = 0; + map_type = BPF_MAP_TYPE_STACK; } else if (section_attr == "maps/cgroup_array") { map_type = BPF_MAP_TYPE_CGROUP_ARRAY; } else if (section_attr == "maps/stacktrace") { From 30a420d70457555b92b8e5f555e58cf79d70ab23 Mon Sep 17 00:00:00 2001 From: Simone Magnani Date: Sun, 28 Jun 2020 19:00:36 +0200 Subject: [PATCH 177/278] add BPFQueueStackTable and tests This commit aims to introduce a new abstraction for these new map types: BPFQueueStackTableBase. As all the allowed operation on these map types are different from the "traditional" ones, I thought to introduce a new abstraction, following the already used programming style (template classes and utility func). Moreover, I had to update libbpf.h/c to insert the new bpf_map_lookup_and_delete_elem(), used when calling "pop()" Signed-off-by: Simone Magnani --- src/cc/api/BPF.h | 8 +++ src/cc/api/BPFTable.h | 67 ++++++++++++++++++++ src/cc/libbpf.c | 5 ++ src/cc/libbpf.h | 1 + tests/cc/CMakeLists.txt | 1 + tests/cc/test_queuestack_table.cc | 101 ++++++++++++++++++++++++++++++ 6 files changed, 183 insertions(+) create mode 100644 tests/cc/test_queuestack_table.cc diff --git a/src/cc/api/BPF.h b/src/cc/api/BPF.h index 9bf31c224..f3096d740 100644 --- a/src/cc/api/BPF.h +++ b/src/cc/api/BPF.h @@ -176,6 +176,14 @@ class BPF { return BPFPercpuCgStorageTable({}); } + template + BPFQueueStackTable get_queuestack_table(const std::string& name) { + TableStorage::iterator it; + if (bpf_module_->table_storage().Find(Path({bpf_module_->id(), name}), it)) + return BPFQueueStackTable(it->second); + return BPFQueueStackTable({}); + } + void* get_bsymcache(void) { if (bsymcache_ == NULL) { bsymcache_ = bcc_buildsymcache_new(); diff --git a/src/cc/api/BPFTable.h b/src/cc/api/BPFTable.h index c47c3dfe3..d75157591 100644 --- a/src/cc/api/BPFTable.h +++ b/src/cc/api/BPFTable.h @@ -36,6 +36,44 @@ namespace ebpf { +template +class BPFQueueStackTableBase { + public: + size_t capacity() const { return desc.max_entries; } + + StatusTuple string_to_leaf(const std::string& value_str, ValueType* value) { + return desc.leaf_sscanf(value_str.c_str(), value); + } + + StatusTuple leaf_to_string(const ValueType* value, std::string& value_str) { + char buf[8 * desc.leaf_size]; + StatusTuple rc = desc.leaf_snprintf(buf, sizeof(buf), value); + if (!rc.code()) + value_str.assign(buf); + return rc; + } + + int get_fd() { return desc.fd; } + + protected: + explicit BPFQueueStackTableBase(const TableDesc& desc) : desc(desc) {} + + bool pop(void *value) { + return bpf_lookup_and_delete(desc.fd, nullptr, value) >= 0; + } + // Flags are extremely useful, since they completely changes extraction behaviour + // (eg. if flag BPF_EXIST, then if the queue/stack is full remove the oldest one) + bool push(void *value, unsigned long long int flags) { + return bpf_update_elem(desc.fd, nullptr, value, flags) >= 0; + } + + bool peek(void *value) { + return bpf_lookup_elem(desc.fd, nullptr, value) >= 0; + } + + const TableDesc& desc; +}; + template class BPFTableBase { public: @@ -124,6 +162,35 @@ void* get_value_addr(std::vector& t) { return t.data(); } +template +class BPFQueueStackTable : public BPFQueueStackTableBase { + public: + explicit BPFQueueStackTable(const TableDesc& desc) : BPFQueueStackTableBase(desc) { + if (desc.type != BPF_MAP_TYPE_QUEUE && + desc.type != BPF_MAP_TYPE_STACK) + throw std::invalid_argument("Table '" + desc.name + + "' is not a queue/stack table"); + } + + virtual StatusTuple pop_value(ValueType& value) { + if (!this->pop(get_value_addr(value))) + return StatusTuple(-1, "Error getting value: %s", std::strerror(errno)); + return StatusTuple::OK(); + } + + virtual StatusTuple push_value(const ValueType& value, unsigned long long int flags = 0) { + if (!this->push(get_value_addr(const_cast(value)), flags)) + return StatusTuple(-1, "Error updating value: %s", std::strerror(errno)); + return StatusTuple::OK(); + } + + virtual StatusTuple get_head(const ValueType& value) { + if (!this->peek(get_value_addr(const_cast(value)))) + return StatusTuple(-1, "Error peeking value: %s", std::strerror(errno)); + return StatusTuple::OK(); + } +}; + template class BPFArrayTable : public BPFTableBase { public: diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index e3d38cca0..33c451856 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -322,6 +322,11 @@ int bpf_delete_elem(int fd, void *key) return bpf_map_delete_elem(fd, key); } +int bpf_lookup_and_delete(int fd, void *key, void *value) +{ + return bpf_map_lookup_and_delete_elem(fd, key, value); +} + int bpf_get_first_key(int fd, void *key, size_t key_size) { int i, res; diff --git a/src/cc/libbpf.h b/src/cc/libbpf.h index 2e192381a..5ff9d485d 100644 --- a/src/cc/libbpf.h +++ b/src/cc/libbpf.h @@ -44,6 +44,7 @@ int bpf_lookup_elem(int fd, void *key, void *value); int bpf_delete_elem(int fd, void *key); int bpf_get_first_key(int fd, void *key, size_t key_size); int bpf_get_next_key(int fd, void *key, void *next_key); +int bpf_lookup_and_delete(int fd, void *key, void *value); /* * Load a BPF program, and return the FD of the loaded program. diff --git a/tests/cc/CMakeLists.txt b/tests/cc/CMakeLists.txt index 79b2f16c1..1f1334431 100644 --- a/tests/cc/CMakeLists.txt +++ b/tests/cc/CMakeLists.txt @@ -26,6 +26,7 @@ set(TEST_LIBBCC_SOURCES test_perf_event.cc test_pinned_table.cc test_prog_table.cc + test_queuestack_table.cc test_shared_table.cc test_sk_storage.cc test_sock_table.cc diff --git a/tests/cc/test_queuestack_table.cc b/tests/cc/test_queuestack_table.cc new file mode 100644 index 000000000..e25717906 --- /dev/null +++ b/tests/cc/test_queuestack_table.cc @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2020 Politecnico di Torino + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "BPF.h" +#include "catch.hpp" +#include +#include + +//Queue/Stack types are available only from 5.0.0 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 0) +TEST_CASE("queue table", "[queue_table]") { + const std::string BPF_PROGRAM = R"( + BPF_QUEUE(myqueue, int, 30); + )"; + + ebpf::BPF bpf; + ebpf::StatusTuple res(0); + res = bpf.init(BPF_PROGRAM); + REQUIRE(res.code() == 0); + + ebpf::BPFQueueStackTable t = bpf.get_queuestack_table("myqueue"); + + SECTION("standard methods") { + int i, val; + std::string value; + + // insert elements + for (i=0; i<30; i++) { + res = t.push_value(i); + REQUIRE(res.code() == 0); + } + + // checking head (peek) + res = t.get_head(val); + REQUIRE(res.code() == 0); + REQUIRE(val == 0); + + // retrieve elements + for (i=0; i<30; i++) { + res = t.pop_value(val); + REQUIRE(res.code() == 0); + REQUIRE(val == i); + } + // get non existing element + res = t.pop_value(val); + REQUIRE(res.code() != 0); + } +} + +TEST_CASE("stack table", "[stack_table]") { + const std::string BPF_PROGRAM = R"( + BPF_STACK(mystack, int, 30); + )"; + + ebpf::BPF bpf; + ebpf::StatusTuple res(0); + res = bpf.init(BPF_PROGRAM); + REQUIRE(res.code() == 0); + + ebpf::BPFQueueStackTable t = bpf.get_queuestack_table("mystack"); + + SECTION("standard methods") { + int i, val; + std::string value; + + // insert elements + for (i=0; i<30; i++) { + res = t.push_value(i); + REQUIRE(res.code() == 0); + } + + // checking head (peek) + res = t.get_head(val); + REQUIRE(res.code() == 0); + REQUIRE(val == 29); + + // retrieve elements + for (i=0; i<30; i++) { + res = t.pop_value(val); + REQUIRE(res.code() == 0); + REQUIRE( val == (30 - 1 - i)); + } + // get non existing element + res = t.pop_value(val); + REQUIRE(res.code() != 0); + } +} +#endif From f0bbf327dc4dba3cfb4d48a27de6c690bee172ef Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Tue, 30 Jun 2020 22:48:41 -0700 Subject: [PATCH 178/278] sync with latest libbpf repo sync with latest libbpf repository --- docs/kernel-versions.md | 5 + src/cc/compat/linux/virtual_bpf.h | 279 +++++++++++++++++------------- src/cc/export/helpers.h | 16 ++ src/cc/libbpf | 2 +- src/cc/libbpf.c | 5 + 5 files changed, 186 insertions(+), 121 deletions(-) diff --git a/docs/kernel-versions.md b/docs/kernel-versions.md index 76a474199..07e6fef9a 100644 --- a/docs/kernel-versions.md +++ b/docs/kernel-versions.md @@ -273,6 +273,11 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_skb_vlan_pop()` | 4.3 | | [`4e10df9a60d9`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=4e10df9a60d96ced321dd2af71da558c6b750078) `BPF_FUNC_skb_vlan_push()` | 4.3 | | [`4e10df9a60d9`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=4e10df9a60d96ced321dd2af71da558c6b750078) `BPF_FUNC_skc_lookup_tcp()` | 5.2 | | [`edbf8c01de5a`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/davem/net-next/+/edbf8c01de5a104a71ed6df2bf6421ceb2836a8e) +`BPF_FUNC_skc_to_tcp_sock()` | 5.9 | | [`478cfbdf5f13`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/478cfbdf5f13dfe09cfd0b1cbac821f5e27f6108) +`BPF_FUNC_skc_to_tcp_request_sock()` | 5.9 | | [`478cfbdf5f13`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/478cfbdf5f13dfe09cfd0b1cbac821f5e27f6108) +`BPF_FUNC_skc_to_tcp_timewait_sock()` | 5.9 | | [`478cfbdf5f13`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/478cfbdf5f13dfe09cfd0b1cbac821f5e27f6108) +`BPF_FUNC_skc_to_tcp6_sock()` | 5.9 | | [`af7ec1383361`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/af7ec13833619e17f03aa73a785a2f871da6d66b) +`BPF_FUNC_skc_to_udp6_sock()` | 5.9 | | [`0d4fad3e57df`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/0d4fad3e57df2bf61e8ffc8d12a34b1caf9b8835) `BPF_FUNC_sock_hash_update()` | 4.18 | | [`81110384441a`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=81110384441a59cff47430f20f049e69b98c17f4) `BPF_FUNC_sock_map_update()` | 4.14 | | [`174a79ff9515`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=174a79ff9515f400b9a6115643dafd62a635b7e6) `BPF_FUNC_spin_lock()` | 5.1 | | [`d83525ca62cf`](https://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git/commit/?id=d83525ca62cf8ebe3271d14c36fb900c294274a2) diff --git a/src/cc/compat/linux/virtual_bpf.h b/src/cc/compat/linux/virtual_bpf.h index 566706ba4..59bf241f9 100644 --- a/src/cc/compat/linux/virtual_bpf.h +++ b/src/cc/compat/linux/virtual_bpf.h @@ -654,7 +654,7 @@ union bpf_attr { * Map value associated to *key*, or **NULL** if no entry was * found. * - * int bpf_map_update_elem(struct bpf_map *map, const void *key, const void *value, u64 flags) + * long bpf_map_update_elem(struct bpf_map *map, const void *key, const void *value, u64 flags) * Description * Add or update the value of the entry associated to *key* in * *map* with *value*. *flags* is one of: @@ -672,13 +672,13 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_map_delete_elem(struct bpf_map *map, const void *key) + * long bpf_map_delete_elem(struct bpf_map *map, const void *key) * Description * Delete entry with *key* from *map*. * Return * 0 on success, or a negative error in case of failure. * - * int bpf_probe_read(void *dst, u32 size, const void *unsafe_ptr) + * long bpf_probe_read(void *dst, u32 size, const void *unsafe_ptr) * Description * For tracing programs, safely attempt to read *size* bytes from * kernel space address *unsafe_ptr* and store the data in *dst*. @@ -696,7 +696,7 @@ union bpf_attr { * Return * Current *ktime*. * - * int bpf_trace_printk(const char *fmt, u32 fmt_size, ...) + * long bpf_trace_printk(const char *fmt, u32 fmt_size, ...) * Description * This helper is a "printk()-like" facility for debugging. It * prints a message defined by format *fmt* (of size *fmt_size*) @@ -776,7 +776,7 @@ union bpf_attr { * Return * The SMP id of the processor running the program. * - * int bpf_skb_store_bytes(struct sk_buff *skb, u32 offset, const void *from, u32 len, u64 flags) + * long bpf_skb_store_bytes(struct sk_buff *skb, u32 offset, const void *from, u32 len, u64 flags) * Description * Store *len* bytes from address *from* into the packet * associated to *skb*, at *offset*. *flags* are a combination of @@ -793,7 +793,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_l3_csum_replace(struct sk_buff *skb, u32 offset, u64 from, u64 to, u64 size) + * long bpf_l3_csum_replace(struct sk_buff *skb, u32 offset, u64 from, u64 to, u64 size) * Description * Recompute the layer 3 (e.g. IP) checksum for the packet * associated to *skb*. Computation is incremental, so the helper @@ -818,7 +818,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_l4_csum_replace(struct sk_buff *skb, u32 offset, u64 from, u64 to, u64 flags) + * long bpf_l4_csum_replace(struct sk_buff *skb, u32 offset, u64 from, u64 to, u64 flags) * Description * Recompute the layer 4 (e.g. TCP, UDP or ICMP) checksum for the * packet associated to *skb*. Computation is incremental, so the @@ -850,7 +850,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_tail_call(void *ctx, struct bpf_map *prog_array_map, u32 index) + * long bpf_tail_call(void *ctx, struct bpf_map *prog_array_map, u32 index) * Description * This special helper is used to trigger a "tail call", or in * other words, to jump into another eBPF program. The same stack @@ -881,7 +881,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_clone_redirect(struct sk_buff *skb, u32 ifindex, u64 flags) + * long bpf_clone_redirect(struct sk_buff *skb, u32 ifindex, u64 flags) * Description * Clone and redirect the packet associated to *skb* to another * net device of index *ifindex*. Both ingress and egress @@ -917,7 +917,7 @@ union bpf_attr { * A 64-bit integer containing the current GID and UID, and * created as such: *current_gid* **<< 32 \|** *current_uid*. * - * int bpf_get_current_comm(void *buf, u32 size_of_buf) + * long bpf_get_current_comm(void *buf, u32 size_of_buf) * Description * Copy the **comm** attribute of the current task into *buf* of * *size_of_buf*. The **comm** attribute contains the name of @@ -954,7 +954,7 @@ union bpf_attr { * Return * The classid, or 0 for the default unconfigured classid. * - * int bpf_skb_vlan_push(struct sk_buff *skb, __be16 vlan_proto, u16 vlan_tci) + * long bpf_skb_vlan_push(struct sk_buff *skb, __be16 vlan_proto, u16 vlan_tci) * Description * Push a *vlan_tci* (VLAN tag control information) of protocol * *vlan_proto* to the packet associated to *skb*, then update @@ -970,7 +970,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_skb_vlan_pop(struct sk_buff *skb) + * long bpf_skb_vlan_pop(struct sk_buff *skb) * Description * Pop a VLAN header from the packet associated to *skb*. * @@ -982,7 +982,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_skb_get_tunnel_key(struct sk_buff *skb, struct bpf_tunnel_key *key, u32 size, u64 flags) + * long bpf_skb_get_tunnel_key(struct sk_buff *skb, struct bpf_tunnel_key *key, u32 size, u64 flags) * Description * Get tunnel metadata. This helper takes a pointer *key* to an * empty **struct bpf_tunnel_key** of **size**, that will be @@ -1033,7 +1033,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_skb_set_tunnel_key(struct sk_buff *skb, struct bpf_tunnel_key *key, u32 size, u64 flags) + * long bpf_skb_set_tunnel_key(struct sk_buff *skb, struct bpf_tunnel_key *key, u32 size, u64 flags) * Description * Populate tunnel metadata for packet associated to *skb.* The * tunnel metadata is set to the contents of *key*, of *size*. The @@ -1099,7 +1099,7 @@ union bpf_attr { * The value of the perf event counter read from the map, or a * negative error code in case of failure. * - * int bpf_redirect(u32 ifindex, u64 flags) + * long bpf_redirect(u32 ifindex, u64 flags) * Description * Redirect the packet to another net device of index *ifindex*. * This helper is somewhat similar to **bpf_clone_redirect**\ @@ -1146,7 +1146,7 @@ union bpf_attr { * The realm of the route for the packet associated to *skb*, or 0 * if none was found. * - * int bpf_perf_event_output(void *ctx, struct bpf_map *map, u64 flags, void *data, u64 size) + * long bpf_perf_event_output(void *ctx, struct bpf_map *map, u64 flags, void *data, u64 size) * Description * Write raw *data* blob into a special BPF perf event held by * *map* of type **BPF_MAP_TYPE_PERF_EVENT_ARRAY**. This perf @@ -1191,7 +1191,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_skb_load_bytes(const void *skb, u32 offset, void *to, u32 len) + * long bpf_skb_load_bytes(const void *skb, u32 offset, void *to, u32 len) * Description * This helper was provided as an easy way to load data from a * packet. It can be used to load *len* bytes from *offset* from @@ -1208,7 +1208,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_get_stackid(void *ctx, struct bpf_map *map, u64 flags) + * long bpf_get_stackid(void *ctx, struct bpf_map *map, u64 flags) * Description * Walk a user or a kernel stack and return its id. To achieve * this, the helper needs *ctx*, which is a pointer to the context @@ -1277,7 +1277,7 @@ union bpf_attr { * The checksum result, or a negative error code in case of * failure. * - * int bpf_skb_get_tunnel_opt(struct sk_buff *skb, void *opt, u32 size) + * long bpf_skb_get_tunnel_opt(struct sk_buff *skb, void *opt, u32 size) * Description * Retrieve tunnel options metadata for the packet associated to * *skb*, and store the raw tunnel option data to the buffer *opt* @@ -1295,7 +1295,7 @@ union bpf_attr { * Return * The size of the option data retrieved. * - * int bpf_skb_set_tunnel_opt(struct sk_buff *skb, void *opt, u32 size) + * long bpf_skb_set_tunnel_opt(struct sk_buff *skb, void *opt, u32 size) * Description * Set tunnel options metadata for the packet associated to *skb* * to the option data contained in the raw buffer *opt* of *size*. @@ -1305,7 +1305,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_skb_change_proto(struct sk_buff *skb, __be16 proto, u64 flags) + * long bpf_skb_change_proto(struct sk_buff *skb, __be16 proto, u64 flags) * Description * Change the protocol of the *skb* to *proto*. Currently * supported are transition from IPv4 to IPv6, and from IPv6 to @@ -1332,7 +1332,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_skb_change_type(struct sk_buff *skb, u32 type) + * long bpf_skb_change_type(struct sk_buff *skb, u32 type) * Description * Change the packet type for the packet associated to *skb*. This * comes down to setting *skb*\ **->pkt_type** to *type*, except @@ -1359,7 +1359,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_skb_under_cgroup(struct sk_buff *skb, struct bpf_map *map, u32 index) + * long bpf_skb_under_cgroup(struct sk_buff *skb, struct bpf_map *map, u32 index) * Description * Check whether *skb* is a descendant of the cgroup2 held by * *map* of type **BPF_MAP_TYPE_CGROUP_ARRAY**, at *index*. @@ -1390,7 +1390,7 @@ union bpf_attr { * Return * A pointer to the current task struct. * - * int bpf_probe_write_user(void *dst, const void *src, u32 len) + * long bpf_probe_write_user(void *dst, const void *src, u32 len) * Description * Attempt in a safe way to write *len* bytes from the buffer * *src* to *dst* in memory. It only works for threads that are in @@ -1409,7 +1409,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_current_task_under_cgroup(struct bpf_map *map, u32 index) + * long bpf_current_task_under_cgroup(struct bpf_map *map, u32 index) * Description * Check whether the probe is being run is the context of a given * subset of the cgroup2 hierarchy. The cgroup2 to test is held by @@ -1421,7 +1421,7 @@ union bpf_attr { * * 1, if the *skb* task does not belong to the cgroup2. * * A negative error code, if an error occurred. * - * int bpf_skb_change_tail(struct sk_buff *skb, u32 len, u64 flags) + * long bpf_skb_change_tail(struct sk_buff *skb, u32 len, u64 flags) * Description * Resize (trim or grow) the packet associated to *skb* to the * new *len*. The *flags* are reserved for future usage, and must @@ -1445,7 +1445,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_skb_pull_data(struct sk_buff *skb, u32 len) + * long bpf_skb_pull_data(struct sk_buff *skb, u32 len) * Description * Pull in non-linear data in case the *skb* is non-linear and not * all of *len* are part of the linear section. Make *len* bytes @@ -1501,7 +1501,7 @@ union bpf_attr { * recalculation the next time the kernel tries to access this * hash or when the **bpf_get_hash_recalc**\ () helper is called. * - * int bpf_get_numa_node_id(void) + * long bpf_get_numa_node_id(void) * Description * Return the id of the current NUMA node. The primary use case * for this helper is the selection of sockets for the local NUMA @@ -1512,7 +1512,7 @@ union bpf_attr { * Return * The id of current NUMA node. * - * int bpf_skb_change_head(struct sk_buff *skb, u32 len, u64 flags) + * long bpf_skb_change_head(struct sk_buff *skb, u32 len, u64 flags) * Description * Grows headroom of packet associated to *skb* and adjusts the * offset of the MAC header accordingly, adding *len* bytes of @@ -1533,7 +1533,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_xdp_adjust_head(struct xdp_buff *xdp_md, int delta) + * long bpf_xdp_adjust_head(struct xdp_buff *xdp_md, int delta) * Description * Adjust (move) *xdp_md*\ **->data** by *delta* bytes. Note that * it is possible to use a negative value for *delta*. This helper @@ -1548,7 +1548,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_probe_read_str(void *dst, u32 size, const void *unsafe_ptr) + * long bpf_probe_read_str(void *dst, u32 size, const void *unsafe_ptr) * Description * Copy a NUL terminated string from an unsafe kernel address * *unsafe_ptr* to *dst*. See **bpf_probe_read_kernel_str**\ () for @@ -1596,14 +1596,14 @@ union bpf_attr { * is returned (note that **overflowuid** might also be the actual * UID value for the socket). * - * u32 bpf_set_hash(struct sk_buff *skb, u32 hash) + * long bpf_set_hash(struct sk_buff *skb, u32 hash) * Description * Set the full hash for *skb* (set the field *skb*\ **->hash**) * to value *hash*. * Return * 0 * - * int bpf_setsockopt(void *bpf_socket, int level, int optname, void *optval, int optlen) + * long bpf_setsockopt(void *bpf_socket, int level, int optname, void *optval, int optlen) * Description * Emulate a call to **setsockopt()** on the socket associated to * *bpf_socket*, which must be a full socket. The *level* at @@ -1622,16 +1622,19 @@ union bpf_attr { * * * **SOL_SOCKET**, which supports the following *optname*\ s: * **SO_RCVBUF**, **SO_SNDBUF**, **SO_MAX_PACING_RATE**, - * **SO_PRIORITY**, **SO_RCVLOWAT**, **SO_MARK**. + * **SO_PRIORITY**, **SO_RCVLOWAT**, **SO_MARK**, + * **SO_BINDTODEVICE**, **SO_KEEPALIVE**. * * **IPPROTO_TCP**, which supports the following *optname*\ s: * **TCP_CONGESTION**, **TCP_BPF_IW**, - * **TCP_BPF_SNDCWND_CLAMP**. + * **TCP_BPF_SNDCWND_CLAMP**, **TCP_SAVE_SYN**, + * **TCP_KEEPIDLE**, **TCP_KEEPINTVL**, **TCP_KEEPCNT**, + * **TCP_SYNCNT**, **TCP_USER_TIMEOUT**. * * **IPPROTO_IP**, which supports *optname* **IP_TOS**. * * **IPPROTO_IPV6**, which supports *optname* **IPV6_TCLASS**. * Return * 0 on success, or a negative error in case of failure. * - * int bpf_skb_adjust_room(struct sk_buff *skb, s32 len_diff, u32 mode, u64 flags) + * long bpf_skb_adjust_room(struct sk_buff *skb, s32 len_diff, u32 mode, u64 flags) * Description * Grow or shrink the room for data in the packet associated to * *skb* by *len_diff*, and according to the selected *mode*. @@ -1677,7 +1680,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_redirect_map(struct bpf_map *map, u32 key, u64 flags) + * long bpf_redirect_map(struct bpf_map *map, u32 key, u64 flags) * Description * Redirect the packet to the endpoint referenced by *map* at * index *key*. Depending on its type, this *map* can contain @@ -1698,7 +1701,7 @@ union bpf_attr { * **XDP_REDIRECT** on success, or the value of the two lower bits * of the *flags* argument on error. * - * int bpf_sk_redirect_map(struct sk_buff *skb, struct bpf_map *map, u32 key, u64 flags) + * long bpf_sk_redirect_map(struct sk_buff *skb, struct bpf_map *map, u32 key, u64 flags) * Description * Redirect the packet to the socket referenced by *map* (of type * **BPF_MAP_TYPE_SOCKMAP**) at index *key*. Both ingress and @@ -1709,7 +1712,7 @@ union bpf_attr { * Return * **SK_PASS** on success, or **SK_DROP** on error. * - * int bpf_sock_map_update(struct bpf_sock_ops *skops, struct bpf_map *map, void *key, u64 flags) + * long bpf_sock_map_update(struct bpf_sock_ops *skops, struct bpf_map *map, void *key, u64 flags) * Description * Add an entry to, or update a *map* referencing sockets. The * *skops* is used as a new value for the entry associated to @@ -1728,7 +1731,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_xdp_adjust_meta(struct xdp_buff *xdp_md, int delta) + * long bpf_xdp_adjust_meta(struct xdp_buff *xdp_md, int delta) * Description * Adjust the address pointed by *xdp_md*\ **->data_meta** by * *delta* (which can be positive or negative). Note that this @@ -1757,7 +1760,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_perf_event_read_value(struct bpf_map *map, u64 flags, struct bpf_perf_event_value *buf, u32 buf_size) + * long bpf_perf_event_read_value(struct bpf_map *map, u64 flags, struct bpf_perf_event_value *buf, u32 buf_size) * Description * Read the value of a perf event counter, and store it into *buf* * of size *buf_size*. This helper relies on a *map* of type @@ -1807,7 +1810,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_perf_prog_read_value(struct bpf_perf_event_data *ctx, struct bpf_perf_event_value *buf, u32 buf_size) + * long bpf_perf_prog_read_value(struct bpf_perf_event_data *ctx, struct bpf_perf_event_value *buf, u32 buf_size) * Description * For en eBPF program attached to a perf event, retrieve the * value of the event counter associated to *ctx* and store it in @@ -1818,7 +1821,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_getsockopt(void *bpf_socket, int level, int optname, void *optval, int optlen) + * long bpf_getsockopt(void *bpf_socket, int level, int optname, void *optval, int optlen) * Description * Emulate a call to **getsockopt()** on the socket associated to * *bpf_socket*, which must be a full socket. The *level* at @@ -1843,7 +1846,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_override_return(struct pt_regs *regs, u64 rc) + * long bpf_override_return(struct pt_regs *regs, u64 rc) * Description * Used for error injection, this helper uses kprobes to override * the return value of the probed function, and to set it to *rc*. @@ -1868,7 +1871,7 @@ union bpf_attr { * Return * 0 * - * int bpf_sock_ops_cb_flags_set(struct bpf_sock_ops *bpf_sock, int argval) + * long bpf_sock_ops_cb_flags_set(struct bpf_sock_ops *bpf_sock, int argval) * Description * Attempt to set the value of the **bpf_sock_ops_cb_flags** field * for the full TCP socket associated to *bpf_sock_ops* to @@ -1912,7 +1915,7 @@ union bpf_attr { * be set is returned (which comes down to 0 if all bits were set * as required). * - * int bpf_msg_redirect_map(struct sk_msg_buff *msg, struct bpf_map *map, u32 key, u64 flags) + * long bpf_msg_redirect_map(struct sk_msg_buff *msg, struct bpf_map *map, u32 key, u64 flags) * Description * This helper is used in programs implementing policies at the * socket level. If the message *msg* is allowed to pass (i.e. if @@ -1926,7 +1929,7 @@ union bpf_attr { * Return * **SK_PASS** on success, or **SK_DROP** on error. * - * int bpf_msg_apply_bytes(struct sk_msg_buff *msg, u32 bytes) + * long bpf_msg_apply_bytes(struct sk_msg_buff *msg, u32 bytes) * Description * For socket policies, apply the verdict of the eBPF program to * the next *bytes* (number of bytes) of message *msg*. @@ -1960,7 +1963,7 @@ union bpf_attr { * Return * 0 * - * int bpf_msg_cork_bytes(struct sk_msg_buff *msg, u32 bytes) + * long bpf_msg_cork_bytes(struct sk_msg_buff *msg, u32 bytes) * Description * For socket policies, prevent the execution of the verdict eBPF * program for message *msg* until *bytes* (byte number) have been @@ -1978,7 +1981,7 @@ union bpf_attr { * Return * 0 * - * int bpf_msg_pull_data(struct sk_msg_buff *msg, u32 start, u32 end, u64 flags) + * long bpf_msg_pull_data(struct sk_msg_buff *msg, u32 start, u32 end, u64 flags) * Description * For socket policies, pull in non-linear data from user space * for *msg* and set pointers *msg*\ **->data** and *msg*\ @@ -2009,7 +2012,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_bind(struct bpf_sock_addr *ctx, struct sockaddr *addr, int addr_len) + * long bpf_bind(struct bpf_sock_addr *ctx, struct sockaddr *addr, int addr_len) * Description * Bind the socket associated to *ctx* to the address pointed by * *addr*, of length *addr_len*. This allows for making outgoing @@ -2027,7 +2030,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_xdp_adjust_tail(struct xdp_buff *xdp_md, int delta) + * long bpf_xdp_adjust_tail(struct xdp_buff *xdp_md, int delta) * Description * Adjust (move) *xdp_md*\ **->data_end** by *delta* bytes. It is * possible to both shrink and grow the packet tail. @@ -2041,7 +2044,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_skb_get_xfrm_state(struct sk_buff *skb, u32 index, struct bpf_xfrm_state *xfrm_state, u32 size, u64 flags) + * long bpf_skb_get_xfrm_state(struct sk_buff *skb, u32 index, struct bpf_xfrm_state *xfrm_state, u32 size, u64 flags) * Description * Retrieve the XFRM state (IP transform framework, see also * **ip-xfrm(8)**) at *index* in XFRM "security path" for *skb*. @@ -2057,7 +2060,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_get_stack(void *ctx, void *buf, u32 size, u64 flags) + * long bpf_get_stack(void *ctx, void *buf, u32 size, u64 flags) * Description * Return a user or a kernel stack in bpf program provided buffer. * To achieve this, the helper needs *ctx*, which is a pointer @@ -2090,7 +2093,7 @@ union bpf_attr { * A non-negative value equal to or less than *size* on success, * or a negative error in case of failure. * - * int bpf_skb_load_bytes_relative(const void *skb, u32 offset, void *to, u32 len, u32 start_header) + * long bpf_skb_load_bytes_relative(const void *skb, u32 offset, void *to, u32 len, u32 start_header) * Description * This helper is similar to **bpf_skb_load_bytes**\ () in that * it provides an easy way to load *len* bytes from *offset* @@ -2112,7 +2115,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_fib_lookup(void *ctx, struct bpf_fib_lookup *params, int plen, u32 flags) + * long bpf_fib_lookup(void *ctx, struct bpf_fib_lookup *params, int plen, u32 flags) * Description * Do FIB lookup in kernel tables using parameters in *params*. * If lookup is successful and result shows packet is to be @@ -2143,7 +2146,7 @@ union bpf_attr { * * > 0 one of **BPF_FIB_LKUP_RET_** codes explaining why the * packet is not forwarded or needs assist from full stack * - * int bpf_sock_hash_update(struct bpf_sock_ops *skops, struct bpf_map *map, void *key, u64 flags) + * long bpf_sock_hash_update(struct bpf_sock_ops *skops, struct bpf_map *map, void *key, u64 flags) * Description * Add an entry to, or update a sockhash *map* referencing sockets. * The *skops* is used as a new value for the entry associated to @@ -2162,7 +2165,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_msg_redirect_hash(struct sk_msg_buff *msg, struct bpf_map *map, void *key, u64 flags) + * long bpf_msg_redirect_hash(struct sk_msg_buff *msg, struct bpf_map *map, void *key, u64 flags) * Description * This helper is used in programs implementing policies at the * socket level. If the message *msg* is allowed to pass (i.e. if @@ -2176,7 +2179,7 @@ union bpf_attr { * Return * **SK_PASS** on success, or **SK_DROP** on error. * - * int bpf_sk_redirect_hash(struct sk_buff *skb, struct bpf_map *map, void *key, u64 flags) + * long bpf_sk_redirect_hash(struct sk_buff *skb, struct bpf_map *map, void *key, u64 flags) * Description * This helper is used in programs implementing policies at the * skb socket level. If the sk_buff *skb* is allowed to pass (i.e. @@ -2190,7 +2193,7 @@ union bpf_attr { * Return * **SK_PASS** on success, or **SK_DROP** on error. * - * int bpf_lwt_push_encap(struct sk_buff *skb, u32 type, void *hdr, u32 len) + * long bpf_lwt_push_encap(struct sk_buff *skb, u32 type, void *hdr, u32 len) * Description * Encapsulate the packet associated to *skb* within a Layer 3 * protocol header. This header is provided in the buffer at @@ -2227,7 +2230,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_lwt_seg6_store_bytes(struct sk_buff *skb, u32 offset, const void *from, u32 len) + * long bpf_lwt_seg6_store_bytes(struct sk_buff *skb, u32 offset, const void *from, u32 len) * Description * Store *len* bytes from address *from* into the packet * associated to *skb*, at *offset*. Only the flags, tag and TLVs @@ -2242,7 +2245,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_lwt_seg6_adjust_srh(struct sk_buff *skb, u32 offset, s32 delta) + * long bpf_lwt_seg6_adjust_srh(struct sk_buff *skb, u32 offset, s32 delta) * Description * Adjust the size allocated to TLVs in the outermost IPv6 * Segment Routing Header contained in the packet associated to @@ -2258,7 +2261,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_lwt_seg6_action(struct sk_buff *skb, u32 action, void *param, u32 param_len) + * long bpf_lwt_seg6_action(struct sk_buff *skb, u32 action, void *param, u32 param_len) * Description * Apply an IPv6 Segment Routing action of type *action* to the * packet associated to *skb*. Each action takes a parameter @@ -2287,7 +2290,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_rc_repeat(void *ctx) + * long bpf_rc_repeat(void *ctx) * Description * This helper is used in programs implementing IR decoding, to * report a successfully decoded repeat key message. This delays @@ -2306,7 +2309,7 @@ union bpf_attr { * Return * 0 * - * int bpf_rc_keydown(void *ctx, u32 protocol, u64 scancode, u32 toggle) + * long bpf_rc_keydown(void *ctx, u32 protocol, u64 scancode, u32 toggle) * Description * This helper is used in programs implementing IR decoding, to * report a successfully decoded key press with *scancode*, @@ -2371,7 +2374,7 @@ union bpf_attr { * Return * A pointer to the local storage area. * - * int bpf_sk_select_reuseport(struct sk_reuseport_md *reuse, struct bpf_map *map, void *key, u64 flags) + * long bpf_sk_select_reuseport(struct sk_reuseport_md *reuse, struct bpf_map *map, void *key, u64 flags) * Description * Select a **SO_REUSEPORT** socket from a * **BPF_MAP_TYPE_REUSEPORT_ARRAY** *map*. @@ -2472,7 +2475,7 @@ union bpf_attr { * result is from *reuse*\ **->socks**\ [] using the hash of the * tuple. * - * int bpf_sk_release(struct bpf_sock *sock) + * long bpf_sk_release(struct bpf_sock *sock) * Description * Release the reference held by *sock*. *sock* must be a * non-**NULL** pointer that was returned from @@ -2480,7 +2483,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_map_push_elem(struct bpf_map *map, const void *value, u64 flags) + * long bpf_map_push_elem(struct bpf_map *map, const void *value, u64 flags) * Description * Push an element *value* in *map*. *flags* is one of: * @@ -2490,19 +2493,19 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_map_pop_elem(struct bpf_map *map, void *value) + * long bpf_map_pop_elem(struct bpf_map *map, void *value) * Description * Pop an element from *map*. * Return * 0 on success, or a negative error in case of failure. * - * int bpf_map_peek_elem(struct bpf_map *map, void *value) + * long bpf_map_peek_elem(struct bpf_map *map, void *value) * Description * Get an element from *map* without removing it. * Return * 0 on success, or a negative error in case of failure. * - * int bpf_msg_push_data(struct sk_msg_buff *msg, u32 start, u32 len, u64 flags) + * long bpf_msg_push_data(struct sk_msg_buff *msg, u32 start, u32 len, u64 flags) * Description * For socket policies, insert *len* bytes into *msg* at offset * *start*. @@ -2518,7 +2521,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_msg_pop_data(struct sk_msg_buff *msg, u32 start, u32 len, u64 flags) + * long bpf_msg_pop_data(struct sk_msg_buff *msg, u32 start, u32 len, u64 flags) * Description * Will remove *len* bytes from a *msg* starting at byte *start*. * This may result in **ENOMEM** errors under certain situations if @@ -2530,7 +2533,7 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_rc_pointer_rel(void *ctx, s32 rel_x, s32 rel_y) + * long bpf_rc_pointer_rel(void *ctx, s32 rel_x, s32 rel_y) * Description * This helper is used in programs implementing IR decoding, to * report a successfully decoded pointer movement. @@ -2544,7 +2547,7 @@ union bpf_attr { * Return * 0 * - * int bpf_spin_lock(struct bpf_spin_lock *lock) + * long bpf_spin_lock(struct bpf_spin_lock *lock) * Description * Acquire a spinlock represented by the pointer *lock*, which is * stored as part of a value of a map. Taking the lock allows to @@ -2592,7 +2595,7 @@ union bpf_attr { * Return * 0 * - * int bpf_spin_unlock(struct bpf_spin_lock *lock) + * long bpf_spin_unlock(struct bpf_spin_lock *lock) * Description * Release the *lock* previously locked by a call to * **bpf_spin_lock**\ (\ *lock*\ ). @@ -2615,7 +2618,7 @@ union bpf_attr { * A **struct bpf_tcp_sock** pointer on success, or **NULL** in * case of failure. * - * int bpf_skb_ecn_set_ce(struct sk_buff *skb) + * long bpf_skb_ecn_set_ce(struct sk_buff *skb) * Description * Set ECN (Explicit Congestion Notification) field of IP header * to **CE** (Congestion Encountered) if current value is **ECT** @@ -2652,7 +2655,7 @@ union bpf_attr { * result is from *reuse*\ **->socks**\ [] using the hash of the * tuple. * - * int bpf_tcp_check_syncookie(struct bpf_sock *sk, void *iph, u32 iph_len, struct tcphdr *th, u32 th_len) + * long bpf_tcp_check_syncookie(struct bpf_sock *sk, void *iph, u32 iph_len, struct tcphdr *th, u32 th_len) * Description * Check whether *iph* and *th* contain a valid SYN cookie ACK for * the listening socket in *sk*. @@ -2667,7 +2670,7 @@ union bpf_attr { * 0 if *iph* and *th* are a valid SYN cookie ACK, or a negative * error otherwise. * - * int bpf_sysctl_get_name(struct bpf_sysctl *ctx, char *buf, size_t buf_len, u64 flags) + * long bpf_sysctl_get_name(struct bpf_sysctl *ctx, char *buf, size_t buf_len, u64 flags) * Description * Get name of sysctl in /proc/sys/ and copy it into provided by * program buffer *buf* of size *buf_len*. @@ -2683,7 +2686,7 @@ union bpf_attr { * **-E2BIG** if the buffer wasn't big enough (*buf* will contain * truncated name in this case). * - * int bpf_sysctl_get_current_value(struct bpf_sysctl *ctx, char *buf, size_t buf_len) + * long bpf_sysctl_get_current_value(struct bpf_sysctl *ctx, char *buf, size_t buf_len) * Description * Get current value of sysctl as it is presented in /proc/sys * (incl. newline, etc), and copy it as a string into provided @@ -2702,7 +2705,7 @@ union bpf_attr { * **-EINVAL** if current value was unavailable, e.g. because * sysctl is uninitialized and read returns -EIO for it. * - * int bpf_sysctl_get_new_value(struct bpf_sysctl *ctx, char *buf, size_t buf_len) + * long bpf_sysctl_get_new_value(struct bpf_sysctl *ctx, char *buf, size_t buf_len) * Description * Get new value being written by user space to sysctl (before * the actual write happens) and copy it as a string into @@ -2719,7 +2722,7 @@ union bpf_attr { * * **-EINVAL** if sysctl is being read. * - * int bpf_sysctl_set_new_value(struct bpf_sysctl *ctx, const char *buf, size_t buf_len) + * long bpf_sysctl_set_new_value(struct bpf_sysctl *ctx, const char *buf, size_t buf_len) * Description * Override new value being written by user space to sysctl with * value provided by program in buffer *buf* of size *buf_len*. @@ -2736,7 +2739,7 @@ union bpf_attr { * * **-EINVAL** if sysctl is being read. * - * int bpf_strtol(const char *buf, size_t buf_len, u64 flags, long *res) + * long bpf_strtol(const char *buf, size_t buf_len, u64 flags, long *res) * Description * Convert the initial part of the string from buffer *buf* of * size *buf_len* to a long integer according to the given base @@ -2760,7 +2763,7 @@ union bpf_attr { * * **-ERANGE** if resulting value was out of range. * - * int bpf_strtoul(const char *buf, size_t buf_len, u64 flags, unsigned long *res) + * long bpf_strtoul(const char *buf, size_t buf_len, u64 flags, unsigned long *res) * Description * Convert the initial part of the string from buffer *buf* of * size *buf_len* to an unsigned long integer according to the @@ -2811,7 +2814,7 @@ union bpf_attr { * **NULL** if not found or there was an error in adding * a new bpf-local-storage. * - * int bpf_sk_storage_delete(struct bpf_map *map, struct bpf_sock *sk) + * long bpf_sk_storage_delete(struct bpf_map *map, struct bpf_sock *sk) * Description * Delete a bpf-local-storage from a *sk*. * Return @@ -2819,7 +2822,7 @@ union bpf_attr { * * **-ENOENT** if the bpf-local-storage cannot be found. * - * int bpf_send_signal(u32 sig) + * long bpf_send_signal(u32 sig) * Description * Send signal *sig* to the process of the current task. * The signal may be delivered to any of this process's threads. @@ -2860,7 +2863,7 @@ union bpf_attr { * * **-EPROTONOSUPPORT** IP packet version is not 4 or 6 * - * int bpf_skb_output(void *ctx, struct bpf_map *map, u64 flags, void *data, u64 size) + * long bpf_skb_output(void *ctx, struct bpf_map *map, u64 flags, void *data, u64 size) * Description * Write raw *data* blob into a special BPF perf event held by * *map* of type **BPF_MAP_TYPE_PERF_EVENT_ARRAY**. This perf @@ -2884,21 +2887,21 @@ union bpf_attr { * Return * 0 on success, or a negative error in case of failure. * - * int bpf_probe_read_user(void *dst, u32 size, const void *unsafe_ptr) + * long bpf_probe_read_user(void *dst, u32 size, const void *unsafe_ptr) * Description * Safely attempt to read *size* bytes from user space address * *unsafe_ptr* and store the data in *dst*. * Return * 0 on success, or a negative error in case of failure. * - * int bpf_probe_read_kernel(void *dst, u32 size, const void *unsafe_ptr) + * long bpf_probe_read_kernel(void *dst, u32 size, const void *unsafe_ptr) * Description * Safely attempt to read *size* bytes from kernel space address * *unsafe_ptr* and store the data in *dst*. * Return * 0 on success, or a negative error in case of failure. * - * int bpf_probe_read_user_str(void *dst, u32 size, const void *unsafe_ptr) + * long bpf_probe_read_user_str(void *dst, u32 size, const void *unsafe_ptr) * Description * Copy a NUL terminated string from an unsafe user address * *unsafe_ptr* to *dst*. The *size* should include the @@ -2942,7 +2945,7 @@ union bpf_attr { * including the trailing NUL character. On error, a negative * value. * - * int bpf_probe_read_kernel_str(void *dst, u32 size, const void *unsafe_ptr) + * long bpf_probe_read_kernel_str(void *dst, u32 size, const void *unsafe_ptr) * Description * Copy a NUL terminated string from an unsafe kernel address *unsafe_ptr* * to *dst*. Same semantics as with **bpf_probe_read_user_str**\ () apply. @@ -2950,14 +2953,14 @@ union bpf_attr { * On success, the strictly positive length of the string, including * the trailing NUL character. On error, a negative value. * - * int bpf_tcp_send_ack(void *tp, u32 rcv_nxt) + * long bpf_tcp_send_ack(void *tp, u32 rcv_nxt) * Description * Send out a tcp-ack. *tp* is the in-kernel struct **tcp_sock**. * *rcv_nxt* is the ack_seq to be sent out. * Return * 0 on success, or a negative error in case of failure. * - * int bpf_send_signal_thread(u32 sig) + * long bpf_send_signal_thread(u32 sig) * Description * Send signal *sig* to the thread corresponding to the current task. * Return @@ -2977,7 +2980,7 @@ union bpf_attr { * Return * The 64 bit jiffies * - * int bpf_read_branch_records(struct bpf_perf_event_data *ctx, void *buf, u32 size, u64 flags) + * long bpf_read_branch_records(struct bpf_perf_event_data *ctx, void *buf, u32 size, u64 flags) * Description * For an eBPF program attached to a perf event, retrieve the * branch records (**struct perf_branch_entry**) associated to *ctx* @@ -2996,7 +2999,7 @@ union bpf_attr { * * **-ENOENT** if architecture does not support branch records. * - * int bpf_get_ns_current_pid_tgid(u64 dev, u64 ino, struct bpf_pidns_info *nsdata, u32 size) + * long bpf_get_ns_current_pid_tgid(u64 dev, u64 ino, struct bpf_pidns_info *nsdata, u32 size) * Description * Returns 0 on success, values for *pid* and *tgid* as seen from the current * *namespace* will be returned in *nsdata*. @@ -3008,7 +3011,7 @@ union bpf_attr { * * **-ENOENT** if pidns does not exists for the current task. * - * int bpf_xdp_output(void *ctx, struct bpf_map *map, u64 flags, void *data, u64 size) + * long bpf_xdp_output(void *ctx, struct bpf_map *map, u64 flags, void *data, u64 size) * Description * Write raw *data* blob into a special BPF perf event held by * *map* of type **BPF_MAP_TYPE_PERF_EVENT_ARRAY**. This perf @@ -3063,7 +3066,7 @@ union bpf_attr { * Return * The id is returned or 0 in case the id could not be retrieved. * - * int bpf_sk_assign(struct sk_buff *skb, struct bpf_sock *sk, u64 flags) + * long bpf_sk_assign(struct sk_buff *skb, struct bpf_sock *sk, u64 flags) * Description * Assign the *sk* to the *skb*. When combined with appropriate * routing configuration to receive the packet towards the socket, @@ -3098,7 +3101,7 @@ union bpf_attr { * Return * Current *ktime*. * - * int bpf_seq_printf(struct seq_file *m, const char *fmt, u32 fmt_size, const void *data, u32 data_len) + * long bpf_seq_printf(struct seq_file *m, const char *fmt, u32 fmt_size, const void *data, u32 data_len) * Description * **bpf_seq_printf**\ () uses seq_file **seq_printf**\ () to print * out the format string. @@ -3127,7 +3130,7 @@ union bpf_attr { * * **-EOVERFLOW** if an overflow happened: The same object will be tried again. * - * int bpf_seq_write(struct seq_file *m, const void *data, u32 len) + * long bpf_seq_write(struct seq_file *m, const void *data, u32 len) * Description * **bpf_seq_write**\ () uses seq_file **seq_write**\ () to write the data. * The *m* represents the seq_file. The *data* and *len* represent the @@ -3169,16 +3172,15 @@ union bpf_attr { * Return * The id is returned or 0 in case the id could not be retrieved. * - * int bpf_ringbuf_output(void *ringbuf, void *data, u64 size, u64 flags) + * long bpf_ringbuf_output(void *ringbuf, void *data, u64 size, u64 flags) * Description * Copy *size* bytes from *data* into a ring buffer *ringbuf*. - * If BPF_RB_NO_WAKEUP is specified in *flags*, no notification of - * new data availability is sent. - * IF BPF_RB_FORCE_WAKEUP is specified in *flags*, notification of - * new data availability is sent unconditionally. + * If **BPF_RB_NO_WAKEUP** is specified in *flags*, no notification + * of new data availability is sent. + * If **BPF_RB_FORCE_WAKEUP** is specified in *flags*, notification + * of new data availability is sent unconditionally. * Return - * 0, on success; - * < 0, on error. + * 0 on success, or a negative error in case of failure. * * void *bpf_ringbuf_reserve(void *ringbuf, u64 size, u64 flags) * Description @@ -3190,20 +3192,20 @@ union bpf_attr { * void bpf_ringbuf_submit(void *data, u64 flags) * Description * Submit reserved ring buffer sample, pointed to by *data*. - * If BPF_RB_NO_WAKEUP is specified in *flags*, no notification of - * new data availability is sent. - * IF BPF_RB_FORCE_WAKEUP is specified in *flags*, notification of - * new data availability is sent unconditionally. + * If **BPF_RB_NO_WAKEUP** is specified in *flags*, no notification + * of new data availability is sent. + * If **BPF_RB_FORCE_WAKEUP** is specified in *flags*, notification + * of new data availability is sent unconditionally. * Return * Nothing. Always succeeds. * * void bpf_ringbuf_discard(void *data, u64 flags) * Description * Discard reserved ring buffer sample, pointed to by *data*. - * If BPF_RB_NO_WAKEUP is specified in *flags*, no notification of - * new data availability is sent. - * IF BPF_RB_FORCE_WAKEUP is specified in *flags*, notification of - * new data availability is sent unconditionally. + * If **BPF_RB_NO_WAKEUP** is specified in *flags*, no notification + * of new data availability is sent. + * If **BPF_RB_FORCE_WAKEUP** is specified in *flags*, notification + * of new data availability is sent unconditionally. * Return * Nothing. Always succeeds. * @@ -3211,18 +3213,20 @@ union bpf_attr { * Description * Query various characteristics of provided ring buffer. What * exactly is queries is determined by *flags*: - * - BPF_RB_AVAIL_DATA - amount of data not yet consumed; - * - BPF_RB_RING_SIZE - the size of ring buffer; - * - BPF_RB_CONS_POS - consumer position (can wrap around); - * - BPF_RB_PROD_POS - producer(s) position (can wrap around); - * Data returned is just a momentary snapshots of actual values + * + * * **BPF_RB_AVAIL_DATA**: Amount of data not yet consumed. + * * **BPF_RB_RING_SIZE**: The size of ring buffer. + * * **BPF_RB_CONS_POS**: Consumer position (can wrap around). + * * **BPF_RB_PROD_POS**: Producer(s) position (can wrap around). + * + * Data returned is just a momentary snapshot of actual values * and could be inaccurate, so this facility should be used to * power heuristics and for reporting, not to make 100% correct * calculation. * Return - * Requested value, or 0, if flags are not recognized. + * Requested value, or 0, if *flags* are not recognized. * - * int bpf_csum_level(struct sk_buff *skb, u64 level) + * long bpf_csum_level(struct sk_buff *skb, u64 level) * Description * Change the skbs checksum level by one layer up or down, or * reset it entirely to none in order to have the stack perform @@ -3253,6 +3257,36 @@ union bpf_attr { * case of **BPF_CSUM_LEVEL_QUERY**, the current skb->csum_level * is returned or the error code -EACCES in case the skb is not * subject to CHECKSUM_UNNECESSARY. + * + * struct tcp6_sock *bpf_skc_to_tcp6_sock(void *sk) + * Description + * Dynamically cast a *sk* pointer to a *tcp6_sock* pointer. + * Return + * *sk* if casting is valid, or NULL otherwise. + * + * struct tcp_sock *bpf_skc_to_tcp_sock(void *sk) + * Description + * Dynamically cast a *sk* pointer to a *tcp_sock* pointer. + * Return + * *sk* if casting is valid, or NULL otherwise. + * + * struct tcp_timewait_sock *bpf_skc_to_tcp_timewait_sock(void *sk) + * Description + * Dynamically cast a *sk* pointer to a *tcp_timewait_sock* pointer. + * Return + * *sk* if casting is valid, or NULL otherwise. + * + * struct tcp_request_sock *bpf_skc_to_tcp_request_sock(void *sk) + * Description + * Dynamically cast a *sk* pointer to a *tcp_request_sock* pointer. + * Return + * *sk* if casting is valid, or NULL otherwise. + * + * struct udp6_sock *bpf_skc_to_udp6_sock(void *sk) + * Description + * Dynamically cast a *sk* pointer to a *udp6_sock* pointer. + * Return + * *sk* if casting is valid, or NULL otherwise. */ #define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ @@ -3390,7 +3424,12 @@ union bpf_attr { FN(ringbuf_submit), \ FN(ringbuf_discard), \ FN(ringbuf_query), \ - FN(csum_level), + FN(csum_level), \ + FN(skc_to_tcp6_sock), \ + FN(skc_to_tcp_sock), \ + FN(skc_to_tcp_timewait_sock), \ + FN(skc_to_tcp_request_sock), \ + FN(skc_to_udp6_sock), /* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index ecf3fac6f..c3d0eea24 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -742,6 +742,22 @@ static __u64 (*bpf_ringbuf_query)(void *ringbuf, __u64 flags) = static int (*bpf_csum_level)(struct __sk_buff *skb, __u64 level) = (void *)BPF_FUNC_csum_level; +struct tcp6_sock; +struct tcp_sock; +struct tcp_timewait_sock; +struct tcp_request_sock; +struct udp6_sock; +static struct tcp6_sock *(*bpf_skc_to_tcp6_sock)(void *sk) = + (void *)BPF_FUNC_skc_to_tcp6_sock; +static struct tcp_sock *(*bpf_skc_to_tcp_sock)(void *sk) = + (void *)BPF_FUNC_skc_to_tcp_sock; +static struct tcp_timewait_sock *(*bpf_skc_to_tcp_timewait_sock)(void *sk) = + (void *)BPF_FUNC_skc_to_tcp_timewait_sock; +static struct tcp_request_sock *(*bpf_skc_to_tcp_request_sock)(void *sk) = + (void *)BPF_FUNC_skc_to_tcp_request_sock; +static struct udp6_sock *(*bpf_skc_to_udp6_sock)(void *sk) = + (void *)BPF_FUNC_skc_to_udp6_sock; + /* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions */ diff --git a/src/cc/libbpf b/src/cc/libbpf index fb27968bf..d08d57cd9 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit fb27968bf1052423584be76affe5abe5a0f7d570 +Subproject commit d08d57cd917e4cedb1ed777f8b0695c5b5bfb8ae diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index 33c451856..dd2e11ab1 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -232,6 +232,11 @@ static struct bpf_helper helpers[] = { {"ringbuf_submit", "5.8"}, {"ringbuf_discard", "5.8"}, {"ringbuf_query", "5.8"}, + {"skc_to_tcp6_sock", "5.9"}, + {"skc_to_tcp_sock", "5.9"}, + {"skc_to_tcp_timewait_sock", "5.9"}, + {"skc_to_tcp_request_sock", "5.9"}, + {"skc_to_udp6_sock", "5.9"}, }; static uint64_t ptr_to_u64(void *ptr) From 581b198cffb55a7dd6486e54007df25e57feb466 Mon Sep 17 00:00:00 2001 From: b-ripper Date: Thu, 2 Jul 2020 10:31:47 +0800 Subject: [PATCH 179/278] valloc and pvalloc is deprecated in bionic on Android memleak -p PID will failed on Android https://android.googlesource.com/platform/bionic/+/master/libc/bionic/malloc_common.cpp#196 --- tools/memleak.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/memleak.py b/tools/memleak.py index 539901943..ac34fd4d1 100755 --- a/tools/memleak.py +++ b/tools/memleak.py @@ -434,9 +434,9 @@ def attach_probes(sym, fn_prefix=None, can_fail=False): attach_probes("calloc") attach_probes("realloc") attach_probes("posix_memalign") - attach_probes("valloc") + attach_probes("valloc", can_fail=True) # failed on Android, is deprecated in libc.so from bionic directory attach_probes("memalign") - attach_probes("pvalloc") + attach_probes("pvalloc", can_fail=True) # failed on Android, is deprecated in libc.so from bionic directory attach_probes("aligned_alloc", can_fail=True) # added in C11 bpf.attach_uprobe(name=obj, sym="free", fn_name="free_enter", pid=pid) From fc20957bdf266ce3468a53e7d6b071d717c612d0 Mon Sep 17 00:00:00 2001 From: Michal Gregorczyk Date: Fri, 3 Jul 2020 00:39:18 -0400 Subject: [PATCH 180/278] Fix symfs symbol resolution Paths that are passed to find_debug_via_symfs often start with /proc/PID/root/ prefix which is followed by actual path. This breaks symfs symbol resoultion. Symfs directory usually does not contain proc subdirectory and subdirectories for each pid. Here are examples of stack traces I got when tracing dlopen on Android before: ``` 7acc558ef8 dlopen+0 (/system/lib64/libdl.so) 7a2222f988 EglThreadState::GetProcAddress(char const*)+64 (/vendor/lib64/egl/libGLESv2_adreno.so) 7ac8e3ecbc eglGetProcAddress+540 (/system/lib64/libEGL.so) 7acb824a58 GrGLMakeAssembledGLESInterface(void*, void (* ()(void, char const*))())+8136 (/system/lib64/libhwui.so) 7acb83a9b0 GrGLCreateNativeInterface()+48 (/system/lib64/libhwui.so) 7acb63443c 0x7acb63443c ([unknown]) 7acb9cd33c 0x7acb9cd33c ([unknown]) 7acb9cdd70 0x7acb9cdd70 ([unknown]) 7acb9c7f20 0x7acb9c7f20 ([unknown]) 7acb9cbcc8 0x7acb9cbcc8 ([unknown]) 7acb98348c 0x7acb98348c ([unknown]) 7acb65da30 0x7acb65da30 ([unknown]) 7aca096b84 android::Thread::_threadLoop(void*)+284 (/system/lib64/libutils.so) 7acc2c6288 __pthread_start(void*)+40 (/system/lib64/libc.so) 7acc266500 __start_thread+72 (/system/lib64/libc.so) ``` and after: ``` 7acc558ef8 dlopen+0 (/system/lib64/libdl.so) 7a23a2d988 EglThreadState::GetProcAddress(char const*)+64 (/vendor/lib64/egl/libGLESv2_adreno.so) 7ac8e3ecbc eglGetProcAddress+540 (/system/lib64/libEGL.so) 7acb824a58 0x7acb824a58 ([unknown]) 7acb83a9b0 GrGLCreateNativeInterface()+48 (/system/lib64/libhwui.so) 7acb63443c android::uirenderer::debug::GlesDriver::getSkiaInterface()+20 (/system/lib64/libhwui.so) 7acb9cd33c android::uirenderer::renderthread::EglManager::initialize()+700 (/system/lib64/libhwui.so) 7acb9cdd70 android::uirenderer::renderthread::EglManager::createSurface(ANativeWindow*, bool)+48 (/system/lib64/libhwui.so) 7acb9c7f20 android::uirenderer::skiapipeline::SkiaOpenGLPipeline::setSurface(android::Surface*, android::uirenderer::renderthread::SwapBehavior, android::uirenderer::renderthread::ColorMode)+88 (/system/lib64/libhwui.so) 7acb9cbcc8 android::uirenderer::renderthread::CanvasContext::setSurface(android::sp&&)+88 (/system/lib64/libhwui.so) 7acb98348c android::uirenderer::WorkQueue::process()+172 (/system/lib64/libhwui.so) 7acb65da30 0x7acb65da30 ([unknown]) 7aca096b84 android::Thread::_threadLoop(void*)+284 (/system/lib64/libutils.so) 7acc2c6288 __pthread_start(void*)+40 (/system/lib64/libc.so) 7acc266500 __start_thread+72 (/system/lib64/libc.so) ``` --- src/cc/bcc_elf.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/cc/bcc_elf.c b/src/cc/bcc_elf.c index 22b37397a..296b32265 100644 --- a/src/cc/bcc_elf.c +++ b/src/cc/bcc_elf.c @@ -562,6 +562,10 @@ static char *find_debug_via_symfs(Elf *e, const char* path) { check_build_id = find_buildid(e, buildid); + int ns_prefix_length = 0; + sscanf(path, "/proc/%*u/root/%n", &ns_prefix_length); + path += ns_prefix_length; + snprintf(fullpath, sizeof(fullpath), "%s/%s", symfs, path); if (access(fullpath, F_OK) == -1) goto out; From 1a348d4ae12ba6ec9831e89532504e27a815fa99 Mon Sep 17 00:00:00 2001 From: Gary Lin Date: Fri, 3 Jul 2020 15:06:16 +0800 Subject: [PATCH 181/278] docs: Add BPF LSM hook to kernel features Signed-off-by: Gary Lin --- docs/kernel-versions.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/kernel-versions.md b/docs/kernel-versions.md index 07e6fef9a..753f72463 100644 --- a/docs/kernel-versions.md +++ b/docs/kernel-versions.md @@ -78,6 +78,7 @@ BPF flow dissector | 4.20 | [`d58e468b1112`](https://github.com/torvalds/linux/c BPF cgroup sysctl | 5.2 | [`7b146cebe30c`](https://github.com/torvalds/linux/commit/7b146cebe30cb481b0f70d85779da938da818637) BPF raw tracepoint writable | 5.2 | [`9df1c28bb752`](https://github.com/torvalds/linux/commit/9df1c28bb75217b244257152ab7d788bb2a386d0) BPF trampoline | 5.5 | [`fec56f5890d9`](https://github.com/torvalds/linux/commit/fec56f5890d93fc2ed74166c397dc186b1c25951) +BPF LSM hook | 5.7 | [`fc611f47f218`](https://github.com/torvalds/linux/commit/fc611f47f2188ade2b48ff6902d5cce8baac0c58) [`641cd7b06c91`](https://github.com/torvalds/linux/commit/641cd7b06c911c5935c34f24850ea18690649917) ## Tables (_a.k.a._ Maps) From f0dd3496bd40b867cdf05d5f4565c8363f5fb906 Mon Sep 17 00:00:00 2001 From: Gary Lin Date: Fri, 3 Jul 2020 15:25:23 +0800 Subject: [PATCH 182/278] docs: Update XDP driver support list Signed-off-by: Gary Lin --- docs/kernel-versions.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/docs/kernel-versions.md b/docs/kernel-versions.md index 753f72463..a580d83e2 100644 --- a/docs/kernel-versions.md +++ b/docs/kernel-versions.md @@ -147,6 +147,11 @@ Intel `ixgbevf` driver | 4.17 | [`c7aec59657b6`](https://git.kernel.org/cgit/lin Freescale `dpaa2` driver | 5.0 | [`7e273a8ebdd3`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=7e273a8ebdd3b83f94eb8b49fc8ee61464f47cc2) Socionext `netsec` driver | 5.3 | [`ba2b232108d3`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=ba2b232108d3c2951bab02930a00f23b0cffd5af) TI `cpsw` driver | 5.3 | [`9ed4050c0d75`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=9ed4050c0d75768066a07cf66eef4f8dc9d79b52) +Intel `ice` driver |5.5| [`efc2214b6047`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=efc2214b6047b6f5b4ca53151eba62521b9452d6) +Solarflare `sfc` driver | 5.5 | [`eb9a36be7f3e`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=eb9a36be7f3ec414700af9a616f035eda1f1e63e) +Marvell `mvneta` driver | 5.5 | [`0db51da7a8e9`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=0db51da7a8e99f0803ec3a8e25c1a66234a219cb) +Microsoft `hv_netvsc` driver | 5.6 | [`351e1581395f`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=351e1581395fcc7fb952bbd7dda01238f69968fd) +Amazon `ena` driver | 5.6 | [`838c93dc5449`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=838c93dc5449e5d6378bae117b0a65a122cf7361) Intel `e1000` driver | | [Not upstream yet](https://git.kernel.org/pub/scm/linux/kernel/git/ast/bpf.git/commit/?h=xdp&id=0afee87cfc800bf3317f4dc8847e6f36539b820c) Intel `e1000e` driver | | [Not planned for upstream at this time](https://github.com/adjavon/e1000e_xdp) From be277421add33cb348ae1092d3ab926c1f609328 Mon Sep 17 00:00:00 2001 From: Gary Lin Date: Fri, 3 Jul 2020 15:33:30 +0800 Subject: [PATCH 183/278] docs: add RISC-V to the JIT support list Signed-off-by: Gary Lin --- docs/kernel-versions.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/kernel-versions.md b/docs/kernel-versions.md index a580d83e2..f806c2d01 100644 --- a/docs/kernel-versions.md +++ b/docs/kernel-versions.md @@ -24,6 +24,8 @@ Sparc64 | 4.12 | [`7a12b5031c6b`](https://git.kernel.org/cgit/linux/kernel/git/t MIPS | 4.13 | [`f381bf6d82f0`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=f381bf6d82f032b7410185b35d000ea370ac706b) ARM32 | 4.14 | [`39c13c204bb1`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=39c13c204bb1150d401e27d41a9d8b332be47c49) x86\_32 | 4.18 | [`03f5781be2c7`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=03f5781be2c7b7e728d724ac70ba10799cc710d7) +RISC-V RV64G | 5.1 | [`2353ecc6f91f`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=2353ecc6f91fd15b893fa01bf85a1c7a823ee4f2) +RISC-V RV32G | 5.7 | [`5f316b65e99f`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=5f316b65e99f109942c556dc8790abd4c75bcb34) ## Main features From 1b7aab1b12fbfd621ceec282df9fbffb7423c508 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20H=C3=B6rmann?= Date: Fri, 3 Jul 2020 13:54:24 +0200 Subject: [PATCH 184/278] add the option --hexdump to sslsniff to allow sniffing of binary protocols inside TLS/SSL connections --- tools/sslsniff.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tools/sslsniff.py b/tools/sslsniff.py index 8c027fe34..ef898f5ac 100755 --- a/tools/sslsniff.py +++ b/tools/sslsniff.py @@ -16,6 +16,8 @@ from __future__ import print_function from bcc import BPF import argparse +import binascii +import textwrap # arguments examples = """examples: @@ -25,6 +27,7 @@ ./sslsniff --no-openssl # don't show OpenSSL calls ./sslsniff --no-gnutls # don't show GnuTLS calls ./sslsniff --no-nss # don't show NSS calls + ./sslsniff --hex # show data as hex instead of trying to decode it as UTF-8 """ parser = argparse.ArgumentParser( description="Sniff SSL data", @@ -43,6 +46,7 @@ help='debug mode.') parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) +parser.add_argument("--hexdump", action="store_true", dest="hexdump", help="show data as hexdump instead of trying to decode it as UTF-8") args = parser.parse_args() @@ -211,7 +215,7 @@ def print_event(cpu, data, size, rw, evt): fmt = "%-12s %-18.9f %-16s %-6d %-6d\n%s\n%s\n%s\n\n" print(fmt % (rw, time_s, event.comm.decode('utf-8', 'replace'), event.pid, event.len, s_mark, - event.v0.decode('utf-8', 'replace'), e_mark)) + textwrap.fill(binascii.hexlify(event.v0).decode('utf-8', 'replace'),width=32) if args.hexdump else event.v0.decode('utf-8', 'replace'), e_mark)) b["perf_SSL_write"].open_perf_buffer(print_event_write) b["perf_SSL_read"].open_perf_buffer(print_event_read) From d40c3a7d801b3944a036a193366a99f96fbd570c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20H=C3=B6rmann?= Date: Fri, 3 Jul 2020 14:31:32 +0200 Subject: [PATCH 185/278] fix examples in sslsniff.py --- tools/sslsniff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/sslsniff.py b/tools/sslsniff.py index ef898f5ac..91874647e 100755 --- a/tools/sslsniff.py +++ b/tools/sslsniff.py @@ -27,7 +27,7 @@ ./sslsniff --no-openssl # don't show OpenSSL calls ./sslsniff --no-gnutls # don't show GnuTLS calls ./sslsniff --no-nss # don't show NSS calls - ./sslsniff --hex # show data as hex instead of trying to decode it as UTF-8 + ./sslsniff --hexdump # show data as hex instead of trying to decode it as UTF-8 """ parser = argparse.ArgumentParser( description="Sniff SSL data", From d91b31a59038c9c79ee1c9e6a45149239531b155 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20H=C3=B6rmann?= Date: Mon, 6 Jul 2020 09:38:39 +0200 Subject: [PATCH 186/278] reformat code, add new option to manpage and usage in sslsniff_example.txt --- man/man8/sslsniff.8 | 2 +- tools/sslsniff.py | 11 ++++++++--- tools/sslsniff_example.txt | 15 +++++++++------ 3 files changed, 18 insertions(+), 10 deletions(-) diff --git a/man/man8/sslsniff.8 b/man/man8/sslsniff.8 index 72836e27f..7b945b00e 100644 --- a/man/man8/sslsniff.8 +++ b/man/man8/sslsniff.8 @@ -2,7 +2,7 @@ .SH NAME sslsniff \- Print data passed to OpenSSL, GnuTLS or NSS. Uses Linux eBPF/bcc. .SH SYNOPSIS -.B sslsniff [-h] [-p PID] [-c COMM] [-o] [-g] [-n] [-d] +.B sslsniff [-h] [-p PID] [-c COMM] [-o] [-g] [-n] [-d] [--hexdump] .SH DESCRIPTION sslsniff prints data sent to write/send and read/recv functions of OpenSSL, GnuTLS and NSS, allowing us to read plain text content before diff --git a/tools/sslsniff.py b/tools/sslsniff.py index 91874647e..f5a2279e2 100755 --- a/tools/sslsniff.py +++ b/tools/sslsniff.py @@ -46,7 +46,8 @@ help='debug mode.') parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) -parser.add_argument("--hexdump", action="store_true", dest="hexdump", help="show data as hexdump instead of trying to decode it as UTF-8") +parser.add_argument("--hexdump", action="store_true", dest="hexdump", + help="show data as hexdump instead of trying to decode it as UTF-8") args = parser.parse_args() @@ -213,9 +214,13 @@ def print_event(cpu, data, size, rw, evt): " bytes lost) " + "-" * 5 fmt = "%-12s %-18.9f %-16s %-6d %-6d\n%s\n%s\n%s\n\n" + if args.hexdump: + unwrapped_data = binascii.hexlify(event.v0) + data = textwrap.fill(unwrapped_data.decode('utf-8', 'replace'),width=32) + else: + data = event.v0.decode('utf-8', 'replace') print(fmt % (rw, time_s, event.comm.decode('utf-8', 'replace'), - event.pid, event.len, s_mark, - textwrap.fill(binascii.hexlify(event.v0).decode('utf-8', 'replace'),width=32) if args.hexdump else event.v0.decode('utf-8', 'replace'), e_mark)) + event.pid, event.len, s_mark, data, e_mark)) b["perf_SSL_write"].open_perf_buffer(print_event_write) b["perf_SSL_read"].open_perf_buffer(print_event_read) diff --git a/tools/sslsniff_example.txt b/tools/sslsniff_example.txt index 8c5172265..66ee91655 100644 --- a/tools/sslsniff_example.txt +++ b/tools/sslsniff_example.txt @@ -9,8 +9,8 @@ text. Useful, for example, to sniff HTTP before encrypted with SSL. Output of tool executing in other shell "curl https://example.com" % sudo python sslsniff.py -FUNC TIME(s) COMM PID LEN -WRITE/SEND 0.000000000 curl 12915 75 +FUNC TIME(s) COMM PID LEN +WRITE/SEND 0.000000000 curl 12915 75 ----- DATA ----- GET / HTTP/1.1 Host: example.com @@ -20,7 +20,7 @@ Accept: */* ----- END DATA ----- -READ/RECV 0.127144585 curl 12915 333 +READ/RECV 0.127144585 curl 12915 333 ----- DATA ----- HTTP/1.1 200 OK Cache-Control: max-age=604800 @@ -38,7 +38,7 @@ Content-Length: 1270 ----- END DATA ----- -READ/RECV 0.129967972 curl 12915 1270 +READ/RECV 0.129967972 curl 12915 1270 ----- DATA ----- @@ -54,7 +54,7 @@ READ/RECV 0.129967972 curl 12915 1270 margin: 0; padding: 0; font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif; - + } div { w @@ -65,7 +65,7 @@ READ/RECV 0.129967972 curl 12915 1270 USAGE message: -usage: sslsniff.py [-h] [-p PID] [-c COMM] [-o] [-g] [-n] [-d] +usage: sslsniff.py [-h] [-p PID] [-c COMM] [-o] [-g] [-n] [-d] [--hexdump] Sniff SSL data @@ -77,6 +77,8 @@ optional arguments: -g, --no-gnutls do not show GnuTLS calls. -n, --no-nss do not show NSS calls. -d, --debug debug mode. + --hexdump show data as hexdump instead of trying to decode it as + UTF-8 examples: ./sslsniff # sniff OpenSSL and GnuTLS functions @@ -85,3 +87,4 @@ examples: ./sslsniff --no-openssl # don't show OpenSSL calls ./sslsniff --no-gnutls # don't show GnuTLS calls ./sslsniff --no-nss # don't show NSS calls + ./sslsniff --hexdump # show data as hex instead of trying to decode it as UTF-8 From 1ef6758b1ce5847d2699183d951c0e2bee00ee39 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20H=C3=B6rmann?= Date: Mon, 6 Jul 2020 09:50:29 +0200 Subject: [PATCH 187/278] example block of --hexdump in sslsniff_example.txt --- tools/sslsniff_example.txt | 40 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/tools/sslsniff_example.txt b/tools/sslsniff_example.txt index 66ee91655..360561f72 100644 --- a/tools/sslsniff_example.txt +++ b/tools/sslsniff_example.txt @@ -60,7 +60,47 @@ READ/RECV 0.129967972 curl 12915 1270 w ----- END DATA (TRUNCATED, 798 bytes lost) ----- +Using the --hexdump option you will get the exact same output, only the lines +between DATA and END DATA will differ. Those will be replaced with a 16 byte +(32 characters) wide hex-dump, an example of a block of output from sslsniff +called with that option is +READ/RECV 7.405609173 curl 201942 1256 +----- DATA ----- +3c21646f63747970652068746d6c3e0a +3c68746d6c3e0a3c686561643e0a2020 +20203c7469746c653e4578616d706c65 +20446f6d61696e3c2f7469746c653e0a +0a202020203c6d657461206368617273 +65743d227574662d3822202f3e0a2020 +20203c6d65746120687474702d657175 +69763d22436f6e74656e742d74797065 +2220636f6e74656e743d22746578742f +68746d6c3b20636861727365743d7574 +662d3822202f3e0a202020203c6d6574 +61206e616d653d2276696577706f7274 +2220636f6e74656e743d227769647468 +3d6465766963652d77696474682c2069 +6e697469616c2d7363616c653d312220 +2f3e0a202020203c7374796c65207479 +70653d22746578742f637373223e0a20 +202020626f6479207b0a202020202020 +20206261636b67726f756e642d636f6c +6f723a20236630663066323b0a202020 +20202020206d617267696e3a20303b0a +202020202020202070616464696e673a +20303b0a2020202020202020666f6e74 +2d66616d696c793a202d6170706c652d +73797374656d2c2073797374656d2d75 +692c20426c696e6b4d61635379737465 +6d466f6e742c20225365676f65205549 +222c20224f70656e2053616e73222c20 +2248656c766574696361204e65756522 +----- END DATA (TRUNCATED, 792 bytes lost) ----- + +This is useful to sniff binary protocols where the UTF-8 decode might insert a +lot of characters that are not printable or even Unicode replacement +characters. USAGE message: From d4f6a162363b759f00cecc9aa2293557519f615c Mon Sep 17 00:00:00 2001 From: Lorenzo Fontana Date: Mon, 6 Jul 2020 18:41:48 +0200 Subject: [PATCH 188/278] docs: fix Ubuntu Eoan spelling Signed-off-by: Lorenzo Fontana --- INSTALL.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/INSTALL.md b/INSTALL.md index 764a43db9..fa9831cef 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -68,7 +68,7 @@ packages use `bcc` in the name (e.g. `bcc-tools`), Ubuntu packages use `bpfcc` ( Currently, BCC packages for both the Ubuntu Universe, and the iovisor builds are outdated. This is a known and tracked in: - [Universe - Ubuntu Launchpad](https://bugs.launchpad.net/ubuntu/+source/bpfcc/+bug/1848137) - [iovisor - BCC GitHub Issues](https://github.com/iovisor/bcc/issues/2678) -Curently, [building from source](#ubuntu---source) is currently the only way to get up to date packaged version of bcc. +Currently, [building from source](#ubuntu---source) is currently the only way to get up to date packaged version of bcc. **Ubuntu Packages** Source packages and the binary packages produced from them can be @@ -383,7 +383,7 @@ sudo apt-get update sudo apt-get -y install bison build-essential cmake flex git libedit-dev \ libllvm6.0 llvm-6.0-dev libclang-6.0-dev python zlib1g-dev libelf-dev -# For Eon (19.10) +# For Eoan (19.10) sudo apt install -y bison build-essential cmake flex git libedit-dev \ libllvm7 llvm-7-dev libclang-7-dev python zlib1g-dev libelf-dev From 95c9229ea9f029a1b9e8dcbe86fc67f037c0dfa2 Mon Sep 17 00:00:00 2001 From: Chen HaoNing Date: Wed, 1 Jul 2020 15:49:17 -0500 Subject: [PATCH 189/278] Replace kprobe function "blk_account_io_completion" to "blk_account_io_done" for kernel version >= 5.8.0 The kernel function "blk_account_io_completion" is not available anymore as attach point of Kprobe as of kernel version 5.8.0. Therefore, after discussions, we decided to use function "blk_account_io_done" instead in every kprobe attachment to "blk_account_io_completion". --- docs/reference_guide.md | 4 ++-- docs/tutorial_bcc_python_developer.md | 6 +++--- examples/lua/kprobe-latency.lua | 2 +- examples/tracing/bitehist.py | 2 +- examples/tracing/disksnoop.py | 2 +- tools/biosnoop.lua | 2 +- tools/biosnoop.py | 2 +- tools/biotop.py | 2 +- tools/old/biosnoop.py | 2 +- 9 files changed, 12 insertions(+), 12 deletions(-) diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 924fa2031..9eaf27a59 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -1784,7 +1784,7 @@ Example: b = BPF(text=""" BPF_HISTOGRAM(dist); -int kprobe__blk_account_io_completion(struct pt_regs *ctx, struct request *req) +int kprobe__blk_account_io_done(struct pt_regs *ctx, struct request *req) { dist.increment(bpf_log2l(req->__data_len / 1024)); return 0; @@ -1835,7 +1835,7 @@ Example: b = BPF(text=""" BPF_HISTOGRAM(dist); -int kprobe__blk_account_io_completion(struct pt_regs *ctx, struct request *req) +int kprobe__blk_account_io_done(struct pt_regs *ctx, struct request *req) { dist.increment(req->__data_len / 1024); return 0; diff --git a/docs/tutorial_bcc_python_developer.md b/docs/tutorial_bcc_python_developer.md index 0cb0e7807..b3b8ed6ba 100644 --- a/docs/tutorial_bcc_python_developer.md +++ b/docs/tutorial_bcc_python_developer.md @@ -220,7 +220,7 @@ void trace_completion(struct pt_regs *ctx, struct request *req) { b.attach_kprobe(event="blk_start_request", fn_name="trace_start") b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_start") -b.attach_kprobe(event="blk_account_io_completion", fn_name="trace_completion") +b.attach_kprobe(event="blk_account_io_done", fn_name="trace_completion") [...] ``` @@ -351,7 +351,7 @@ b = BPF(text=""" BPF_HISTOGRAM(dist); -int kprobe__blk_account_io_completion(struct pt_regs *ctx, struct request *req) +int kprobe__blk_account_io_done(struct pt_regs *ctx, struct request *req) { dist.increment(bpf_log2l(req->__data_len / 1024)); return 0; @@ -374,7 +374,7 @@ b["dist"].print_log2_hist("kbytes") A recap from earlier lessons: - ```kprobe__```: This prefix means the rest will be treated as a kernel function name that will be instrumented using kprobe. -- ```struct pt_regs *ctx, struct request *req```: Arguments to kprobe. The ```ctx``` is registers and BPF context, the ```req``` is the first argument to the instrumented function: ```blk_account_io_completion()```. +- ```struct pt_regs *ctx, struct request *req```: Arguments to kprobe. The ```ctx``` is registers and BPF context, the ```req``` is the first argument to the instrumented function: ```blk_account_io_done()```. - ```req->__data_len```: Dereferencing that member. New things to learn: diff --git a/examples/lua/kprobe-latency.lua b/examples/lua/kprobe-latency.lua index 60ac2c1c7..98464e5c2 100644 --- a/examples/lua/kprobe-latency.lua +++ b/examples/lua/kprobe-latency.lua @@ -30,7 +30,7 @@ local lat_map = bpf.map('array', bins) local trace_start = bpf.kprobe('myprobe:blk_start_request', function (ptregs) map[ptregs.parm1] = time() end, false, -1, 0) -local trace_end = bpf.kprobe('myprobe2:blk_account_io_completion', function (ptregs) +local trace_end = bpf.kprobe('myprobe2:blk_account_io_done', function (ptregs) -- The lines below are computing index -- using log10(x)*10 = log2(x)*10/log2(10) = log2(x)*3 -- index = 29 ~ 1 usec diff --git a/examples/tracing/bitehist.py b/examples/tracing/bitehist.py index 4d7c7958b..89ceb307b 100755 --- a/examples/tracing/bitehist.py +++ b/examples/tracing/bitehist.py @@ -25,7 +25,7 @@ BPF_HISTOGRAM(dist); BPF_HISTOGRAM(dist_linear); -int kprobe__blk_account_io_completion(struct pt_regs *ctx, struct request *req) +int kprobe__blk_account_io_done(struct pt_regs *ctx, struct request *req) { dist.increment(bpf_log2l(req->__data_len / 1024)); dist_linear.increment(req->__data_len / 1024); diff --git a/examples/tracing/disksnoop.py b/examples/tracing/disksnoop.py index 1101e6f26..a35e1abd2 100755 --- a/examples/tracing/disksnoop.py +++ b/examples/tracing/disksnoop.py @@ -46,7 +46,7 @@ if BPF.get_kprobe_functions(b'blk_start_request'): b.attach_kprobe(event="blk_start_request", fn_name="trace_start") b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_start") -b.attach_kprobe(event="blk_account_io_completion", fn_name="trace_completion") +b.attach_kprobe(event="blk_account_io_done", fn_name="trace_completion") # header print("%-18s %-2s %-7s %8s" % ("TIME(s)", "T", "BYTES", "LAT(ms)")) diff --git a/tools/biosnoop.lua b/tools/biosnoop.lua index 8d9b6a190..3e0441e2a 100755 --- a/tools/biosnoop.lua +++ b/tools/biosnoop.lua @@ -126,7 +126,7 @@ return function(BPF, utils) bpf:attach_kprobe{event="blk_account_io_start", fn_name="trace_pid_start"} bpf:attach_kprobe{event="blk_start_request", fn_name="trace_req_start"} bpf:attach_kprobe{event="blk_mq_start_request", fn_name="trace_req_start"} - bpf:attach_kprobe{event="blk_account_io_completion", + bpf:attach_kprobe{event="blk_account_io_done", fn_name="trace_req_completion"} print("%-14s %-14s %-6s %-7s %-2s %-9s %-7s %7s" % {"TIME(s)", "COMM", "PID", diff --git a/tools/biosnoop.py b/tools/biosnoop.py index ff9b842bc..5bbc77cde 100755 --- a/tools/biosnoop.py +++ b/tools/biosnoop.py @@ -160,7 +160,7 @@ if BPF.get_kprobe_functions(b'blk_start_request'): b.attach_kprobe(event="blk_start_request", fn_name="trace_req_start") b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_req_start") -b.attach_kprobe(event="blk_account_io_completion", +b.attach_kprobe(event="blk_account_io_done", fn_name="trace_req_completion") # header diff --git a/tools/biotop.py b/tools/biotop.py index cad3759a9..d3a42ef78 100755 --- a/tools/biotop.py +++ b/tools/biotop.py @@ -178,7 +178,7 @@ def signal_ignore(signal_value, frame): if BPF.get_kprobe_functions(b'blk_start_request'): b.attach_kprobe(event="blk_start_request", fn_name="trace_req_start") b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_req_start") -b.attach_kprobe(event="blk_account_io_completion", +b.attach_kprobe(event="blk_account_io_done", fn_name="trace_req_completion") print('Tracing... Output every %d secs. Hit Ctrl-C to end' % interval) diff --git a/tools/old/biosnoop.py b/tools/old/biosnoop.py index 37ee3f9cb..847ab91bd 100755 --- a/tools/old/biosnoop.py +++ b/tools/old/biosnoop.py @@ -98,7 +98,7 @@ b.attach_kprobe(event="blk_account_io_start", fn_name="trace_pid_start") b.attach_kprobe(event="blk_start_request", fn_name="trace_req_start") b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_req_start") -b.attach_kprobe(event="blk_account_io_completion", +b.attach_kprobe(event="blk_account_io_done", fn_name="trace_req_completion") # header From cd81f13c1ff96927d6e4fffd6a5d9fb0cd354c08 Mon Sep 17 00:00:00 2001 From: Edward Wu Date: Mon, 6 Jul 2020 12:39:02 +0800 Subject: [PATCH 190/278] memleak: Add workaround to alleviate misjudgments when free is missing Profiling in memory part is hard to be accurate because of BPF infrastructure. memleak keeps misjudging memory leak on the complicated environment which has the action of free in hard/soft irq. For example, in my misjudged case: 640 bytes in 10 allocations from stack -- __kmalloc+0x178 [kernel] __kmalloc+0x178 [kernel] xhci_urb_enqueue+0x140 [kernel] usb_hcd_submit_urb+0x5e0 [kernel] This result looks like kernel doesn't free urb_priv. However, it's not true. The reason for this leak is because xhci hw irq interrupts during the BPF program. BPF program is not finished on that CPU, and xhci_irq() will call xhci_urb_free_priv() before the end. But the kernel doesn't permit this isr to go into BPF program again. Because BPF infrastructure(trace_call_bpf) denied this action. So we miss this free action and cause memory leak misjudgment. Side-effect: - Increase overhead for each memory allocation. - A higher chance to be interrupted at the allocation part causes ignore more allocations. This workaround doesn't solve all misjudgments, the improvement in BPF infrastructure is the only solution. --- man/man8/memleak.8 | 10 ++++++++-- tools/memleak.py | 18 ++++++++++++++++-- tools/memleak_example.txt | 26 ++++++++++++++++++++++++-- 3 files changed, 48 insertions(+), 6 deletions(-) diff --git a/man/man8/memleak.8 b/man/man8/memleak.8 index fa52c8cf6..2fd267643 100644 --- a/man/man8/memleak.8 +++ b/man/man8/memleak.8 @@ -3,8 +3,8 @@ memleak \- Print a summary of outstanding allocations and their call stacks to detect memory leaks. Uses Linux eBPF/bcc. .SH SYNOPSIS .B memleak [-h] [-p PID] [-t] [-a] [-o OLDER] [-c COMMAND] [--combined-only] -[-s SAMPLE_RATE] [-T TOP] [-z MIN_SIZE] [-Z MAX_SIZE] [-O OBJ] [INTERVAL] -[COUNT] +[--wa-missing-free] [-s SAMPLE_RATE] [-T TOP] [-z MIN_SIZE] [-Z MAX_SIZE] +[-O OBJ] [INTERVAL] [COUNT] .SH DESCRIPTION memleak traces and matches memory allocation and deallocation requests, and collects call stacks for each allocation. memleak can then print a summary @@ -53,6 +53,9 @@ Use statistics precalculated in kernel space. Amount of data to be pulled from kernel significantly decreases, at the cost of losing capabilities of time-based false positives filtering (\-o). .TP +\-\-wa-missing-free +Make up the action of free to alleviate misjudgments when free is missing. +.TP \-s SAMPLE_RATE Record roughly every SAMPLE_RATE-th allocation to reduce overhead. .TP @@ -109,6 +112,9 @@ Additionally, option \-\-combined-only saves processing time by reusing already calculated allocation statistics from kernel. It's faster, but lacks information about particular allocations. +Also, option \-\-wa-missing-free makes memleak more accuracy in the complicated +environment. + To determine the rate at which your application is calling malloc/free, or the rate at which your kernel is calling kmalloc/kfree, place a probe with perf and collect statistics. For example, to determine how many calls to __kmalloc are diff --git a/tools/memleak.py b/tools/memleak.py index ac34fd4d1..0800135e6 100755 --- a/tools/memleak.py +++ b/tools/memleak.py @@ -4,8 +4,8 @@ # memory leaks in user-mode processes and the kernel. # # USAGE: memleak [-h] [-p PID] [-t] [-a] [-o OLDER] [-c COMMAND] -# [--combined-only] [-s SAMPLE_RATE] [-T TOP] [-z MIN_SIZE] -# [-Z MAX_SIZE] [-O OBJ] +# [--combined-only] [--wa-missing-free] [-s SAMPLE_RATE] +# [-T TOP] [-z MIN_SIZE] [-Z MAX_SIZE] [-O OBJ] # [interval] [count] # # Licensed under the Apache License, Version 2.0 (the "License") @@ -88,6 +88,8 @@ def run_command_get_pid(command): help="execute and trace the specified command") parser.add_argument("--combined-only", default=False, action="store_true", help="show combined allocation statistics only") +parser.add_argument("--wa-missing-free", default=False, action="store_true", + help="Workaround to alleviate misjudgments when free is missing") parser.add_argument("-s", "--sample-rate", default=1, type=int, help="sample every N-th allocation to decrease the overhead") parser.add_argument("-T", "--top", type=int, default=10, @@ -330,11 +332,15 @@ def run_command_get_pid(command): bpf_source_kernel = """ TRACEPOINT_PROBE(kmem, kmalloc) { + if (WORKAROUND_MISSING_FREE) + gen_free_enter((struct pt_regs *)args, (void *)args->ptr); gen_alloc_enter((struct pt_regs *)args, args->bytes_alloc); return gen_alloc_exit2((struct pt_regs *)args, (size_t)args->ptr); } TRACEPOINT_PROBE(kmem, kmalloc_node) { + if (WORKAROUND_MISSING_FREE) + gen_free_enter((struct pt_regs *)args, (void *)args->ptr); gen_alloc_enter((struct pt_regs *)args, args->bytes_alloc); return gen_alloc_exit2((struct pt_regs *)args, (size_t)args->ptr); } @@ -344,11 +350,15 @@ def run_command_get_pid(command): } TRACEPOINT_PROBE(kmem, kmem_cache_alloc) { + if (WORKAROUND_MISSING_FREE) + gen_free_enter((struct pt_regs *)args, (void *)args->ptr); gen_alloc_enter((struct pt_regs *)args, args->bytes_alloc); return gen_alloc_exit2((struct pt_regs *)args, (size_t)args->ptr); } TRACEPOINT_PROBE(kmem, kmem_cache_alloc_node) { + if (WORKAROUND_MISSING_FREE) + gen_free_enter((struct pt_regs *)args, (void *)args->ptr); gen_alloc_enter((struct pt_regs *)args, args->bytes_alloc); return gen_alloc_exit2((struct pt_regs *)args, (size_t)args->ptr); } @@ -385,6 +395,10 @@ def run_command_get_pid(command): else: bpf_source += bpf_source_kernel +if kernel_trace: + bpf_source = bpf_source.replace("WORKAROUND_MISSING_FREE", "1" + if args.wa_missing_free else "0") + bpf_source = bpf_source.replace("SHOULD_PRINT", "1" if trace_all else "0") bpf_source = bpf_source.replace("SAMPLE_EVERY_N", str(sample_every_n)) bpf_source = bpf_source.replace("PAGE_SIZE", str(resource.getpagesize())) diff --git a/tools/memleak_example.txt b/tools/memleak_example.txt index 307a9fa51..421801702 100644 --- a/tools/memleak_example.txt +++ b/tools/memleak_example.txt @@ -146,13 +146,33 @@ Note that even though the application leaks 16 bytes of memory every second, the report (printed every 5 seconds) doesn't "see" all the allocations because of the sampling rate applied. +Profiling in memory part is hard to be accurate because of BPF infrastructure. +memleak keeps misjudging memory leak on the complicated environment which has +the action of free in hard/soft irq. +Add workaround to alleviate misjudgments when free is missing: + +# ./memleak --wa-missing-free +Attaching to kernel allocators, Ctrl+C to quit. +... + 248 bytes in 4 allocations from stack + bpf_prog_load [kernel] + sys_bpf [kernel] + + 328 bytes in 1 allocations from stack + perf_mmap [kernel] + mmap_region [kernel] + do_mmap [kernel] + vm_mmap_pgoff [kernel] + sys_mmap_pgoff [kernel] + sys_mmap [kernel] + USAGE message: # ./memleak -h usage: memleak.py [-h] [-p PID] [-t] [-a] [-o OLDER] [-c COMMAND] - [--combined-only] [-s SAMPLE_RATE] [-T TOP] [-z MIN_SIZE] - [-Z MAX_SIZE] [-O OBJ] + [--combined-only] [--wa-missing-free] [-s SAMPLE_RATE] + [-T TOP] [-z MIN_SIZE] [-Z MAX_SIZE] [-O OBJ] [interval] [count] Trace outstanding memory allocations that weren't freed. @@ -177,6 +197,8 @@ optional arguments: -c COMMAND, --command COMMAND execute and trace the specified command --combined-only show combined allocation statistics only + --wa-missing-free Workaround to alleviate misjudgments when free is + missing -s SAMPLE_RATE, --sample-rate SAMPLE_RATE sample every N-th allocation to decrease the overhead -T TOP, --top TOP display only this many top allocating stacks (by size) From fab26b4369aa020b412c2c1ba42bc1179b9c3337 Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Wed, 8 Jul 2020 08:18:52 -0700 Subject: [PATCH 191/278] sync with latest libbpf sync with latest libbpf repo Signed-off-by: Yonghong Song --- docs/kernel-versions.md | 3 ++- src/cc/compat/linux/virtual_bpf.h | 37 ++++++++++++++++++++++++++++++- src/cc/export/helpers.h | 5 +++++ src/cc/libbpf | 2 +- src/cc/libbpf.c | 1 + 5 files changed, 45 insertions(+), 3 deletions(-) diff --git a/docs/kernel-versions.md b/docs/kernel-versions.md index f806c2d01..44c961022 100644 --- a/docs/kernel-versions.md +++ b/docs/kernel-versions.md @@ -195,6 +195,7 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_get_socket_uid()` | 4.12 | | [`6acc5c291068`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6acc5c2910689fc6ee181bf63085c5efff6a42bd) `BPF_FUNC_get_stack()` | 4.18 | GPL | [`de2ff05f48af`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=de2ff05f48afcde816ff4edb217417f62f624ab5) `BPF_FUNC_get_stackid()` | 4.6 | GPL | [`d5a3b1f69186`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d5a3b1f691865be576c2bffa708549b8cdccda19) +`BPF_FUNC_get_task_stack()` | 5.9 | | [`fa28dcb82a38`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/fa28dcb82a38f8e3993b0fae9106b1a80b59e4f0) `BPF_FUNC_getsockopt()` | 4.15 | | [`cd86d1fd2102`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=cd86d1fd21025fdd6daf23d1288da405e7ad0ec6) `BPF_FUNC_jiffies64()` | 5.5 | | [`5576b991e9c1`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=5576b991e9c1a11d2cc21c4b94fc75ec27603896) `BPF_FUNC_ktime_get_boot_ns()` | 5.7 | GPL | [`71d19214776e`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/71d19214776e61b33da48f7c1b46e522c7f78221) @@ -352,5 +353,5 @@ The list of program types and supported helper functions can be retrieved with: |Function Group| Functions| |------------------|-------| |`Base functions`| `BPF_FUNC_map_lookup_elem()`
`BPF_FUNC_map_update_elem()`
`BPF_FUNC_map_delete_elem()`
`BPF_FUNC_map_peek_elem()`
`BPF_FUNC_map_pop_elem()`
`BPF_FUNC_map_push_elem()`
`BPF_FUNC_get_prandom_u32()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_get_numa_node_id()`
`BPF_FUNC_tail_call()`
`BPF_FUNC_ktime_get_boot_ns()`
`BPF_FUNC_ktime_get_ns()`
`BPF_FUNC_trace_printk()`
`BPF_FUNC_spin_lock()`
`BPF_FUNC_spin_unlock()` | -|`Tracing functions`|`BPF_FUNC_map_lookup_elem()`
`BPF_FUNC_map_update_elem()`
`BPF_FUNC_map_delete_elem()`
`BPF_FUNC_probe_read()`
`BPF_FUNC_ktime_get_boot_ns()`
`BPF_FUNC_ktime_get_ns()`
`BPF_FUNC_tail_call()`
`BPF_FUNC_get_current_pid_tgid()`
`BPF_FUNC_get_current_task()`
`BPF_FUNC_get_current_uid_gid()`
`BPF_FUNC_get_current_comm()`
`BPF_FUNC_trace_printk()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_get_numa_node_id()`
`BPF_FUNC_perf_event_read()`
`BPF_FUNC_probe_write_user()`
`BPF_FUNC_current_task_under_cgroup()`
`BPF_FUNC_get_prandom_u32()`
`BPF_FUNC_probe_read_str()`
`BPF_FUNC_get_current_cgroup_id()`
`BPF_FUNC_send_signal()`
`BPF_FUNC_probe_read_kernel()`
`BPF_FUNC_probe_read_kernel_str()`
`BPF_FUNC_probe_read_user()`
`BPF_FUNC_probe_read_user_str()`
`BPF_FUNC_send_signal_thread()`
`BPF_FUNC_get_ns_current_pid_tgid()`
`BPF_FUNC_xdp_output()`| +|`Tracing functions`|`BPF_FUNC_map_lookup_elem()`
`BPF_FUNC_map_update_elem()`
`BPF_FUNC_map_delete_elem()`
`BPF_FUNC_probe_read()`
`BPF_FUNC_ktime_get_boot_ns()`
`BPF_FUNC_ktime_get_ns()`
`BPF_FUNC_tail_call()`
`BPF_FUNC_get_current_pid_tgid()`
`BPF_FUNC_get_current_task()`
`BPF_FUNC_get_current_uid_gid()`
`BPF_FUNC_get_current_comm()`
`BPF_FUNC_trace_printk()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_get_numa_node_id()`
`BPF_FUNC_perf_event_read()`
`BPF_FUNC_probe_write_user()`
`BPF_FUNC_current_task_under_cgroup()`
`BPF_FUNC_get_prandom_u32()`
`BPF_FUNC_probe_read_str()`
`BPF_FUNC_get_current_cgroup_id()`
`BPF_FUNC_send_signal()`
`BPF_FUNC_probe_read_kernel()`
`BPF_FUNC_probe_read_kernel_str()`
`BPF_FUNC_probe_read_user()`
`BPF_FUNC_probe_read_user_str()`
`BPF_FUNC_send_signal_thread()`
`BPF_FUNC_get_ns_current_pid_tgid()`
`BPF_FUNC_xdp_output()`
`BPF_FUNC_get_task_stack()`| |`LWT functions`| `BPF_FUNC_skb_load_bytes()`
`BPF_FUNC_skb_pull_data()`
`BPF_FUNC_csum_diff()`
`BPF_FUNC_get_cgroup_classid()`
`BPF_FUNC_get_route_realm()`
`BPF_FUNC_get_hash_recalc()`
`BPF_FUNC_perf_event_output()`
`BPF_FUNC_get_smp_processor_id()`
`BPF_FUNC_skb_under_cgroup()`| diff --git a/src/cc/compat/linux/virtual_bpf.h b/src/cc/compat/linux/virtual_bpf.h index 59bf241f9..26c57a7eb 100644 --- a/src/cc/compat/linux/virtual_bpf.h +++ b/src/cc/compat/linux/virtual_bpf.h @@ -3287,6 +3287,39 @@ union bpf_attr { * Dynamically cast a *sk* pointer to a *udp6_sock* pointer. * Return * *sk* if casting is valid, or NULL otherwise. + * + * long bpf_get_task_stack(struct task_struct *task, void *buf, u32 size, u64 flags) + * Description + * Return a user or a kernel stack in bpf program provided buffer. + * To achieve this, the helper needs *task*, which is a valid + * pointer to struct task_struct. To store the stacktrace, the + * bpf program provides *buf* with a nonnegative *size*. + * + * The last argument, *flags*, holds the number of stack frames to + * skip (from 0 to 255), masked with + * **BPF_F_SKIP_FIELD_MASK**. The next bits can be used to set + * the following flags: + * + * **BPF_F_USER_STACK** + * Collect a user space stack instead of a kernel stack. + * **BPF_F_USER_BUILD_ID** + * Collect buildid+offset instead of ips for user stack, + * only valid if **BPF_F_USER_STACK** is also specified. + * + * **bpf_get_task_stack**\ () can collect up to + * **PERF_MAX_STACK_DEPTH** both kernel and user frames, subject + * to sufficient large buffer size. Note that + * this limit can be controlled with the **sysctl** program, and + * that it should be manually increased in order to profile long + * user stacks (such as stacks for Java programs). To do so, use: + * + * :: + * + * # sysctl kernel.perf_event_max_stack= + * Return + * A non-negative value equal to or less than *size* on success, + * or a negative error in case of failure. + * */ #define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ @@ -3429,7 +3462,9 @@ union bpf_attr { FN(skc_to_tcp_sock), \ FN(skc_to_tcp_timewait_sock), \ FN(skc_to_tcp_request_sock), \ - FN(skc_to_udp6_sock), + FN(skc_to_udp6_sock), \ + FN(get_task_stack), \ + /* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index c3d0eea24..bb6531bdc 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -758,6 +758,11 @@ static struct tcp_request_sock *(*bpf_skc_to_tcp_request_sock)(void *sk) = static struct udp6_sock *(*bpf_skc_to_udp6_sock)(void *sk) = (void *)BPF_FUNC_skc_to_udp6_sock; +struct task_struct; +static long (*bpf_get_task_stack)(struct task_struct *task, void *buf, + __u32 size, __u64 flags) = + (void *)BPF_FUNC_get_task_stack; + /* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions */ diff --git a/src/cc/libbpf b/src/cc/libbpf index d08d57cd9..5020fdf8f 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit d08d57cd917e4cedb1ed777f8b0695c5b5bfb8ae +Subproject commit 5020fdf8fc6cbc770ec7b2c4f686b97f134e3061 diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index dd2e11ab1..e912cbb4e 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -237,6 +237,7 @@ static struct bpf_helper helpers[] = { {"skc_to_tcp_timewait_sock", "5.9"}, {"skc_to_tcp_request_sock", "5.9"}, {"skc_to_udp6_sock", "5.9"}, + {"bpf_get_task_stack", "5.9"}, }; static uint64_t ptr_to_u64(void *ptr) From 57d10f5b4ed4c27b789cc72292e16daa1e1f9e7a Mon Sep 17 00:00:00 2001 From: Anton Protopopov Date: Sat, 20 Jun 2020 17:33:56 +0000 Subject: [PATCH 192/278] libbpf-tools: add header to store BPF-side map helpers Add a new header kern_map_helpers.h to store BPF-size map helpers which may be used from different programs. On the moment it contains the bpf_map_lookup_or_try_init helper. Signed-off-by: Anton Protopopov --- libbpf-tools/maps.bpf.h | 26 ++++++++++++++++++++++++++ libbpf-tools/syscount.bpf.c | 18 +----------------- 2 files changed, 27 insertions(+), 17 deletions(-) create mode 100644 libbpf-tools/maps.bpf.h diff --git a/libbpf-tools/maps.bpf.h b/libbpf-tools/maps.bpf.h new file mode 100644 index 000000000..5e43d27a9 --- /dev/null +++ b/libbpf-tools/maps.bpf.h @@ -0,0 +1,26 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Anton Protopopov +#ifndef __MAPS_BPF_H +#define __MAPS_BPF_H + +#include +#include + +static __always_inline void * +bpf_map_lookup_or_try_init(void *map, const void *key, const void *init) +{ + void *val; + long err; + + val = bpf_map_lookup_elem(map, key); + if (val) + return val; + + err = bpf_map_update_elem(map, key, init, BPF_NOEXIST); + if (err && err != -EEXIST) + return 0; + + return bpf_map_lookup_elem(map, key); +} + +#endif /* __MAPS_BPF_H */ diff --git a/libbpf-tools/syscount.bpf.c b/libbpf-tools/syscount.bpf.c index 360e82854..98b77efa2 100644 --- a/libbpf-tools/syscount.bpf.c +++ b/libbpf-tools/syscount.bpf.c @@ -7,6 +7,7 @@ #include #include #include "syscount.h" +#include "maps.bpf.h" const volatile bool count_by_process = false; const volatile bool measure_latency = false; @@ -30,23 +31,6 @@ struct { __uint(map_flags, BPF_F_NO_PREALLOC); } data SEC(".maps"); -static __always_inline -void *bpf_map_lookup_or_try_init(void *map, void *key, const void *init) -{ - void *val; - int err; - - val = bpf_map_lookup_elem(map, key); - if (val) - return val; - - err = bpf_map_update_elem(map, key, init, 0); - if (err) - return (void *) 0; - - return bpf_map_lookup_elem(map, key); -} - static __always_inline void save_proc_name(struct data_t *val) { From b8cdd214a0fcce7e2086e04f1a1f7a268e841271 Mon Sep 17 00:00:00 2001 From: Anton Protopopov Date: Sat, 20 Jun 2020 17:37:00 +0000 Subject: [PATCH 193/278] libbpf-tools: fix an error message A wrong argument (-errno) was passed to strerror, fix it. Signed-off-by: Anton Protopopov --- libbpf-tools/syscount.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libbpf-tools/syscount.c b/libbpf-tools/syscount.c index b4ebf20d7..3ccf7ab43 100644 --- a/libbpf-tools/syscount.c +++ b/libbpf-tools/syscount.c @@ -434,7 +434,7 @@ int main(int argc, char **argv) } if (signal(SIGINT, sig_int) == SIG_ERR) { - warn("can't set signal handler: %s\n", strerror(-errno)); + warn("can't set signal handler: %s\n", strerror(errno)); goto cleanup_obj; } From 3ef753186420e39e8b9c97d5eb2af7c991339dd7 Mon Sep 17 00:00:00 2001 From: Anton Protopopov Date: Sun, 21 Jun 2020 21:47:12 +0000 Subject: [PATCH 194/278] libbpf-tools: convert BCC tcpconnect to BPF CO-RE version Add a new libbpf-based tool, tcpconnect, and add some helpers which may be used by other tools. Namely, user_map_helpers.{c,h} files implement a function dump_hash() which uses map_batch_lookup (if possible) to read entire hash maps to user space. The tcpconnect acts as the original BCC tool except that --cgroupmap and --mntnsmap options are not implemented, yet. Signed-off-by: Anton Protopopov --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 2 + libbpf-tools/map_helpers.c | 106 +++++++++ libbpf-tools/map_helpers.h | 11 + libbpf-tools/tcpconnect.bpf.c | 218 ++++++++++++++++++ libbpf-tools/tcpconnect.c | 421 ++++++++++++++++++++++++++++++++++ libbpf-tools/tcpconnect.h | 43 ++++ 7 files changed, 802 insertions(+) create mode 100644 libbpf-tools/map_helpers.c create mode 100644 libbpf-tools/map_helpers.h create mode 100644 libbpf-tools/tcpconnect.bpf.c create mode 100644 libbpf-tools/tcpconnect.c create mode 100644 libbpf-tools/tcpconnect.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 59e5064e7..2b30730e3 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -7,5 +7,6 @@ /opensnoop /runqslower /syscount +/tcpconnect /vfsstat /xfsslower diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index cd73b6e3d..33bd0f64f 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -18,6 +18,7 @@ APPS = \ opensnoop \ runqslower \ syscount \ + tcpconnect \ vfsstat \ xfsslower \ # @@ -26,6 +27,7 @@ COMMON_OBJ = \ $(OUTPUT)/trace_helpers.o \ $(OUTPUT)/syscall_helpers.o \ $(OUTPUT)/errno_helpers.o \ + $(OUTPUT)/map_helpers.o \ # .PHONY: all diff --git a/libbpf-tools/map_helpers.c b/libbpf-tools/map_helpers.c new file mode 100644 index 000000000..5b562a295 --- /dev/null +++ b/libbpf-tools/map_helpers.c @@ -0,0 +1,106 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Anton Protopopov +#include +#include +#include + +#include "map_helpers.h" + +#define warn(...) fprintf(stderr, __VA_ARGS__) + +static bool batch_map_ops = true; /* hope for the best */ + +static int +dump_hash_iter(int map_fd, void *keys, __u32 key_size, + void *values, __u32 value_size, __u32 *count, + void *invalid_key) +{ + __u8 key[key_size], next_key[key_size]; + __u32 n = 0; + int err; + + /* First get keys */ + __builtin_memcpy(key, invalid_key, key_size); + while (n < *count) { + err = bpf_map_get_next_key(map_fd, key, next_key); + if (err && errno != ENOENT) { + return -1; + } else if (err) { + break; + } + __builtin_memcpy(key, next_key, key_size); + __builtin_memcpy(keys + key_size * n, next_key, key_size); + n++; + } + + /* Now read values */ + for (int i = 0; i < n; i++) { + err = bpf_map_lookup_elem(map_fd, keys + key_size * i, + values + value_size * i); + if (err) + return -1; + } + + *count = n; + return 0; +} + +static int +dump_hash_batch(int map_fd, void *keys, __u32 key_size, + void *values, __u32 value_size, __u32 *count) +{ + void *in = NULL, *out; + __u32 n, n_read = 0; + int err = 0; + + while (n_read < *count && !err) { + n = *count - n_read; + err = bpf_map_lookup_batch(map_fd, &in, &out, + keys + n_read * key_size, + values + n_read * value_size, + &n, NULL); + if (err && errno != ENOENT) { + return -1; + } + n_read += n; + in = out; + } + + *count = n_read; + return 0; +} + +int dump_hash(int map_fd, + void *keys, __u32 key_size, + void *values, __u32 value_size, + __u32 *count, void *invalid_key) +{ + int err; + + if (!keys || !values || !count || !key_size || !value_size) { + errno = EINVAL; + return -1; + } + + if (batch_map_ops) { + err = dump_hash_batch(map_fd, keys, key_size, + values, value_size, count); + if (err) { + if (errno != EINVAL) { + return -1; + + /* assume that batch operations are not + * supported and try non-batch mode */ + batch_map_ops = false; + } + } + } + + if (!invalid_key) { + errno = EINVAL; + return -1; + } + + return dump_hash_iter(map_fd, keys, key_size, + values, value_size, count, invalid_key); +} diff --git a/libbpf-tools/map_helpers.h b/libbpf-tools/map_helpers.h new file mode 100644 index 000000000..2d5cb0227 --- /dev/null +++ b/libbpf-tools/map_helpers.h @@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +/* Copyright (c) 2020 Anton Protopopov */ +#ifndef __MAP_HELPERS_H +#define __MAP_HELPERS_H + +#include + +int dump_hash(int map_fd, void *keys, __u32 key_size, + void *values, __u32 value_size, __u32 *count, void *invalid_key); + +#endif /* __MAP_HELPERS_H */ diff --git a/libbpf-tools/tcpconnect.bpf.c b/libbpf-tools/tcpconnect.bpf.c new file mode 100644 index 000000000..734f529f5 --- /dev/null +++ b/libbpf-tools/tcpconnect.bpf.c @@ -0,0 +1,218 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Anton Protopopov +// +// Based on tcpconnect(8) from BCC by Brendan Gregg +#include "vmlinux.h" + +#include +#include +#include + +#include "maps.bpf.h" +#include "tcpconnect.h" + +const volatile bool do_count; +const volatile int filter_ports_len; +SEC(".rodata") int filter_ports[MAX_PORTS]; +const volatile pid_t filter_pid; +const volatile uid_t filter_uid = -1; + +/* Define here, because there are conflicts with include files */ +#define AF_INET 2 +#define AF_INET6 10 + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, u32); + __type(value, struct sock *); + __uint(map_flags, BPF_F_NO_PREALLOC); +} sockets SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, struct ipv4_flow_key); + __type(value, u64); + __uint(map_flags, BPF_F_NO_PREALLOC); +} ipv4_count SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, struct ipv6_flow_key); + __type(value, u64); + __uint(map_flags, BPF_F_NO_PREALLOC); +} ipv6_count SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY); + __uint(key_size, sizeof(u32)); + __uint(value_size, sizeof(u32)); +} events SEC(".maps"); + +static __always_inline bool filter_port(__u16 port) +{ + if (filter_ports_len == 0) + return false; + + for (int i = 0; i < filter_ports_len; i++) { + if (port == filter_ports[i]) + return false; + } + return true; +} + +static __always_inline int +enter_tcp_connect(struct pt_regs *ctx, struct sock *sk) +{ + __u64 pid_tgid = bpf_get_current_pid_tgid(); + __u32 pid = pid_tgid >> 32; + __u32 tid = pid_tgid; + __u32 uid; + + if (filter_pid && pid != filter_pid) + return 0; + + uid = bpf_get_current_uid_gid(); + if (filter_uid != (uid_t) -1 && uid != filter_uid) + return 0; + + bpf_map_update_elem(&sockets, &tid, &sk, 0); + return 0; +} + +static __always_inline void count_v4(struct sock *sk, __u16 dport) +{ + struct ipv4_flow_key key = {}; + static __u64 zero; + __u64 *val; + + BPF_CORE_READ_INTO(&key.saddr, sk, __sk_common.skc_rcv_saddr); + BPF_CORE_READ_INTO(&key.daddr, sk, __sk_common.skc_daddr); + key.dport = dport; + val = bpf_map_lookup_or_try_init(&ipv4_count, &key, &zero); + if (val) + __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); +} + +static __always_inline void count_v6(struct sock *sk, __u16 dport) +{ + struct ipv6_flow_key key = {}; + static const __u64 zero; + __u64 *val; + + BPF_CORE_READ_INTO(&key.saddr, sk, + __sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); + BPF_CORE_READ_INTO(&key.daddr, sk, + __sk_common.skc_v6_daddr.in6_u.u6_addr32); + key.dport = dport; + + val = bpf_map_lookup_or_try_init(&ipv6_count, &key, &zero); + if (val) + __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); +} + +static __always_inline void +trace_v4(struct pt_regs *ctx, pid_t pid, struct sock *sk, __u16 dport) +{ + struct event event = {}; + + event.af = AF_INET; + event.pid = pid; + event.uid = bpf_get_current_uid_gid(); + event.ts_us = bpf_ktime_get_ns() / 1000; + BPF_CORE_READ_INTO(&event.saddr_v4, sk, __sk_common.skc_rcv_saddr); + BPF_CORE_READ_INTO(&event.daddr_v4, sk, __sk_common.skc_daddr); + event.dport = dport; + bpf_get_current_comm(event.task, sizeof(event.task)); + + bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, + &event, sizeof(event)); +} + +static __always_inline void +trace_v6(struct pt_regs *ctx, pid_t pid, struct sock *sk, __u16 dport) +{ + struct event event = {}; + + event.af = AF_INET6; + event.pid = pid; + event.uid = bpf_get_current_uid_gid(); + event.ts_us = bpf_ktime_get_ns() / 1000; + BPF_CORE_READ_INTO(&event.saddr_v6, sk, + __sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); + BPF_CORE_READ_INTO(&event.daddr_v6, sk, + __sk_common.skc_v6_daddr.in6_u.u6_addr32); + event.dport = dport; + bpf_get_current_comm(event.task, sizeof(event.task)); + + bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, + &event, sizeof(event)); +} + +static __always_inline int +exit_tcp_connect(struct pt_regs *ctx, int ret, int ip_ver) +{ + __u64 pid_tgid = bpf_get_current_pid_tgid(); + __u32 pid = pid_tgid >> 32; + __u32 tid = pid_tgid; + struct sock **skpp; + struct sock *sk; + __u16 dport; + + skpp = bpf_map_lookup_elem(&sockets, &tid); + if (!skpp) + return 0; + + if (ret) + goto end; + + sk = *skpp; + + BPF_CORE_READ_INTO(&dport, sk, __sk_common.skc_dport); + if (filter_port(dport)) + goto end; + + if (do_count) { + if (ip_ver == 4) + count_v4(sk, dport); + else + count_v6(sk, dport); + } else { + if (ip_ver == 4) + trace_v4(ctx, pid, sk, dport); + else + trace_v6(ctx, pid, sk, dport); + } + +end: + bpf_map_delete_elem(&sockets, &tid); + return 0; +} + +SEC("kprobe/tcp_v4_connect") +int BPF_KPROBE(kprobe__tcp_v4_connect, struct sock *sk) +{ + return enter_tcp_connect(ctx, sk); +} + +SEC("kretprobe/tcp_v4_connect") +int BPF_KRETPROBE(kretprobe__tcp_v4_connect, int ret) +{ + return exit_tcp_connect(ctx, ret, 4); +} + +SEC("kprobe/tcp_v6_connect") +int BPF_KPROBE(kprobe__tcp_v6_connect, struct sock *sk) +{ + return enter_tcp_connect(ctx, sk); +} + +SEC("kretprobe/tcp_v6_connect") +int BPF_KRETPROBE(kretprobe__tcp_v6_connect, int ret) +{ + return exit_tcp_connect(ctx, ret, 6); +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/tcpconnect.c b/libbpf-tools/tcpconnect.c new file mode 100644 index 000000000..fde6440dc --- /dev/null +++ b/libbpf-tools/tcpconnect.c @@ -0,0 +1,421 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Anton Protopopov +// +// Based on tcpconnect(8) from BCC by Brendan Gregg +#include +#include +#include +#include +#include +#include +#include +#include +#include "tcpconnect.h" +#include "tcpconnect.skel.h" +#include "trace_helpers.h" +#include "map_helpers.h" + +#define warn(...) fprintf(stderr, __VA_ARGS__) + +const char *argp_program_version = "tcpconnect 0.1"; +const char *argp_program_bug_address = ""; +static const char argp_program_doc[] = + "\ntcpconnect: Count/Trace active tcp connections\n" + "\n" + "EXAMPLES:\n" + " tcpconnect # trace all TCP connect()s\n" + " tcpconnect -t # include timestamps\n" + " tcpconnect -p 181 # only trace PID 181\n" + " tcpconnect -P 80 # only trace port 80\n" + " tcpconnect -P 80,81 # only trace port 80 and 81\n" + " tcpconnect -U # include UID\n" + " tcpconnect -u 1000 # only trace UID 1000\n" + " tcpconnect -c # count connects per src, dest, port\n" + " tcpconnect --C mappath # only trace cgroups in the map\n" + " tcpconnect --M mappath # only trace mount namespaces in the map\n" + ; + +static int get_int(const char *arg, int *ret, int min, int max) +{ + char *end; + long val; + + errno = 0; + val = strtol(arg, &end, 10); + if (errno) { + warn("strtol: %s: %s\n", arg, strerror(errno)); + return -1; + } else if (end == arg || val < min || val > max) { + return -1; + } + if (ret) + *ret = val; + return 0; +} + +static int get_ints(const char *arg, int *size, int *ret, int min, int max) +{ + const char *argp = arg; + int max_size = *size; + int sz = 0; + char *end; + long val; + + while (sz < max_size) { + errno = 0; + val = strtol(argp, &end, 10); + if (errno) { + warn("strtol: %s: %s\n", arg, strerror(errno)); + return -1; + } else if (end == arg || val < min || val > max) { + return -1; + } + ret[sz++] = val; + if (*end == 0) + break; + argp = end + 1; + } + + *size = sz; + return 0; +} + +static int get_uint(const char *arg, unsigned int *ret, + unsigned int min, unsigned int max) +{ + char *end; + long val; + + errno = 0; + val = strtoul(arg, &end, 10); + if (errno) { + warn("strtoul: %s: %s\n", arg, strerror(errno)); + return -1; + } else if (end == arg || val < min || val > max) { + return -1; + } + if (ret) + *ret = val; + return 0; +} + +static const struct argp_option opts[] = { + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + { "timestamp", 't', NULL, 0, "Include timestamp on output" }, + { "count", 'c', NULL, 0, "Count connects per src ip and dst ip/port" }, + { "print-uid", 'U', NULL, 0, "Include UID on output" }, + { "pid", 'p', "PID", 0, "Process PID to trace" }, + { "uid", 'u', "UID", 0, "Process UID to trace" }, + { "port", 'P', "PORTS", 0, + "Comma-separated list of destination ports to trace" }, + { "cgroupmap", 'C', "PATH", 0, "trace cgroups in this map" }, + { "mntnsmap", 'M', "PATH", 0, "trace mount namespaces in this map" }, + {}, +}; + +static struct env { + bool verbose; + bool count; + bool print_timestamp; + bool print_uid; + pid_t pid; + uid_t uid; + int nports; + int ports[MAX_PORTS]; +} env = { + .uid = (uid_t) -1, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + int err; + int nports; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'c': + env.count = true; + break; + case 't': + env.print_timestamp = true; + break; + case 'U': + env.print_uid = true; + break; + case 'p': + err = get_int(arg, &env.pid, 1, INT_MAX); + if (err) { + warn("invalid PID: %s\n", arg); + argp_usage(state); + } + break; + case 'u': + err = get_uint(arg, &env.uid, 0, (uid_t) -2); + if (err) { + warn("invalid UID: %s\n", arg); + argp_usage(state); + } + break; + case 'P': + nports = MAX_PORTS; + err = get_ints(arg, &nports, env.ports, 1, 65535); + if (err) { + warn("invalid PORT_LIST: %s\n", arg); + argp_usage(state); + } + env.nports = nports; + break; + case 'C': + warn("not implemented: --cgroupmap"); + break; + case 'M': + warn("not implemented: --mntnsmap"); + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +static int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static volatile sig_atomic_t hang_on = 1; + +static void sig_int(int signo) +{ + hang_on = 0; +} + +static void print_count_ipv4(int map_fd) +{ + static struct ipv4_flow_key keys[MAX_ENTRIES]; + __u32 value_size = sizeof(__u64); + __u32 key_size = sizeof(keys[0]); + static struct ipv4_flow_key zero; + static __u64 counts[MAX_ENTRIES]; + char s[INET_ADDRSTRLEN]; + char d[INET_ADDRSTRLEN]; + __u32 n = MAX_ENTRIES; + struct in_addr src; + struct in_addr dst; + + if (dump_hash(map_fd, keys, key_size, counts, value_size, &n, &zero)) { + warn("dump_hash: %s", strerror(errno)); + return; + } + + for (__u32 i = 0; i < n; i++) { + src.s_addr = keys[i].saddr; + dst.s_addr = keys[i].daddr; + + printf("%-25s %-25s %-20d %-10llu\n", + inet_ntop(AF_INET, &src, s, sizeof(s)), + inet_ntop(AF_INET, &dst, d, sizeof(d)), + ntohs(keys[i].dport), counts[i]); + } +} + +static void print_count_ipv6(int map_fd) +{ + static struct ipv6_flow_key keys[MAX_ENTRIES]; + __u32 value_size = sizeof(__u64); + __u32 key_size = sizeof(keys[0]); + static struct ipv6_flow_key zero; + static __u64 counts[MAX_ENTRIES]; + char s[INET6_ADDRSTRLEN]; + char d[INET6_ADDRSTRLEN]; + __u32 n = MAX_ENTRIES; + struct in6_addr src; + struct in6_addr dst; + + if (dump_hash(map_fd, keys, key_size, counts, value_size, &n, &zero)) { + warn("dump_hash: %s", strerror(errno)); + return; + } + + for (__u32 i = 0; i < n; i++) { + memcpy(src.s6_addr, &keys[i].saddr, sizeof(src.s6_addr)); + memcpy(dst.s6_addr, &keys[i].daddr, sizeof(src.s6_addr)); + + printf("%-25s %-25s %-20d %-10llu\n", + inet_ntop(AF_INET6, &src, s, sizeof(s)), + inet_ntop(AF_INET6, &dst, d, sizeof(d)), + ntohs(keys[i].dport), counts[i]); + } +} + +static void print_count(int map_fd_ipv4, int map_fd_ipv6) +{ + static const char *header_fmt = "\n%-25s %-25s %-20s %-10s\n"; + + while (hang_on) + pause(); + + printf(header_fmt, "LADDR", "RADDR", "RPORT", "CONNECTS"); + print_count_ipv4(map_fd_ipv4); + print_count_ipv6(map_fd_ipv6); +} + +static void print_events_header() +{ + if (env.print_timestamp) + printf("%-9s", "TIME(s)"); + if (env.print_uid) + printf("%-6s", "UID"); + printf("%-6s %-12s %-2s %-16s %-16s %-4s\n", + "PID", "COMM", "IP", "SADDR", "DADDR", "DPORT"); +} + +static void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) +{ + const struct event *event = data; + char src[INET6_ADDRSTRLEN]; + char dst[INET6_ADDRSTRLEN]; + union { + struct in_addr x4; + struct in6_addr x6; + } s, d; + static __u64 start_ts; + + if (event->af == AF_INET) { + s.x4.s_addr = event->saddr_v4; + d.x4.s_addr = event->daddr_v4; + } else if (event->af == AF_INET6) { + memcpy(&s.x6.s6_addr, &event->saddr_v6, sizeof(s.x6.s6_addr)); + memcpy(&d.x6.s6_addr, &event->daddr_v6, sizeof(d.x6.s6_addr)); + } else { + warn("broken event: event->af=%d", event->af); + return; + } + + if (env.print_timestamp) { + if (start_ts == 0) + start_ts = event->ts_us; + printf("%-9.3f", (event->ts_us - start_ts) / 1000000.0); + } + + if (env.print_uid) + printf("%-6d", event->uid); + + printf("%-6d %-12.12s %-2d %-16s %-16s %-4d\n", + event->pid, event->task, + event->af == AF_INET ? 4 : 6, + inet_ntop(event->af, &s, src, sizeof(src)), + inet_ntop(event->af, &d, dst, sizeof(dst)), + ntohs(event->dport)); +} + +static void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt) +{ + warn("Lost %llu events on CPU #%d!\n", lost_cnt, cpu); +} + +static void print_events(int perf_map_fd) +{ + struct perf_buffer_opts pb_opts = { + .sample_cb = handle_event, + .lost_cb = handle_lost_events, + }; + struct perf_buffer *pb = NULL; + int err; + + pb = perf_buffer__new(perf_map_fd, 128, &pb_opts); + err = libbpf_get_error(pb); + if (err) { + pb = NULL; + warn("failed to open perf buffer: %d\n", err); + goto cleanup; + } + + print_events_header(); + while (hang_on) { + err = perf_buffer__poll(pb, 100); + if (err < 0) { + warn("Error polling perf buffer: %d\n", err); + goto cleanup; + } + } + +cleanup: + perf_buffer__free(pb); +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + .args_doc = NULL, + }; + struct tcpconnect_bpf *obj; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + warn("failed to increase rlimit: %s\n", strerror(errno)); + return 1; + } + + obj = tcpconnect_bpf__open(); + if (!obj) { + warn("failed to open BPF object\n"); + return 1; + } + + if (env.count) + obj->rodata->do_count = true; + if (env.pid) + obj->rodata->filter_pid = env.pid; + if (env.uid != (uid_t) -1) + obj->rodata->filter_uid = env.uid; + if (env.nports > 0) { + obj->rodata->filter_ports_len = env.nports; + for (int i = 0; i < env.nports; i++) { + obj->rodata->filter_ports[i] = htons(env.ports[i]); + } + } + + err = tcpconnect_bpf__load(obj); + if (err) { + warn("failed to load BPF object: %d\n", err); + goto cleanup; + } + + err = tcpconnect_bpf__attach(obj); + if (err) { + warn("failed to attach BPF programs: %s\n", strerror(-err)); + goto cleanup; + } + + if (signal(SIGINT, sig_int) == SIG_ERR) { + warn("can't set signal handler: %s\n", strerror(-errno)); + goto cleanup; + } + + if (env.count) { + print_count(bpf_map__fd(obj->maps.ipv4_count), + bpf_map__fd(obj->maps.ipv6_count)); + } else { + print_events(bpf_map__fd(obj->maps.events)); + } + +cleanup: + tcpconnect_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/tcpconnect.h b/libbpf-tools/tcpconnect.h new file mode 100644 index 000000000..86cc194f8 --- /dev/null +++ b/libbpf-tools/tcpconnect.h @@ -0,0 +1,43 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Anton Protopopov +#ifndef __TCPCONNECT_H +#define __TCPCONNECT_H + +/* The maximum number of items in maps */ +#define MAX_ENTRIES 8192 + +/* The maximum number of ports to filter */ +#define MAX_PORTS 64 + +#define TASK_COMM_LEN 16 + +struct ipv4_flow_key { + __u32 saddr; + __u32 daddr; + __u16 dport; +}; + +struct ipv6_flow_key { + unsigned __int128 saddr; + unsigned __int128 daddr; + __u16 dport; +}; + +struct event { + union { + __u32 saddr_v4; + unsigned __int128 saddr_v6; + }; + union { + __u32 daddr_v4; + unsigned __int128 daddr_v6; + }; + char task[TASK_COMM_LEN]; + __u64 ts_us; + int af; // AF_INET or AF_INET6 + __u32 pid; + __u32 uid; + __u16 dport; +}; + +#endif /* __TCPCONNECT_H */ From 104d2b3eb6ed1f1bdbc03cb322c6ae917c1b4425 Mon Sep 17 00:00:00 2001 From: Junyeong Jeong Date: Thu, 9 Jul 2020 18:08:08 +0900 Subject: [PATCH 195/278] Add .lazy_symbolize field to bcc_symbol_option and add ignored fields to perf_event_attr --- src/python/bcc/libbcc.py | 1 + src/python/bcc/perf.py | 22 +++++++++++++--------- 2 files changed, 14 insertions(+), 9 deletions(-) diff --git a/src/python/bcc/libbcc.py b/src/python/bcc/libbcc.py index 52affb613..86ba5f2db 100644 --- a/src/python/bcc/libbcc.py +++ b/src/python/bcc/libbcc.py @@ -173,6 +173,7 @@ class bcc_symbol_option(ct.Structure): _fields_ = [ ('use_debug_file', ct.c_int), ('check_debug_file_crc', ct.c_int), + ('lazy_symbolize', ct.c_int), ('use_symbol_type', ct.c_uint), ] diff --git a/src/python/bcc/perf.py b/src/python/bcc/perf.py index 44b0128df..b1c13f72d 100644 --- a/src/python/bcc/perf.py +++ b/src/python/bcc/perf.py @@ -27,15 +27,19 @@ class perf_event_attr(ct.Structure): ('read_format', ct.c_ulong), ('flags', ct.c_ulong), ('wakeup_events', ct.c_uint), - ('IGNORE3', ct.c_uint), - ('IGNORE4', ct.c_ulong), - ('IGNORE5', ct.c_ulong), - ('IGNORE6', ct.c_ulong), - ('IGNORE7', ct.c_uint), - ('IGNORE8', ct.c_int), - ('IGNORE9', ct.c_ulong), - ('IGNORE10', ct.c_uint), - ('IGNORE11', ct.c_uint) + ('IGNORE3', ct.c_uint), # bp_type + ('IGNORE4', ct.c_ulong), # bp_addr + ('IGNORE5', ct.c_ulong), # bp_len + ('IGNORE6', ct.c_ulong), # branch_sample_type + ('IGNORE7', ct.c_ulong), # sample_regs_user + ('IGNORE8', ct.c_uint), # sample_stack_user + ('IGNORE9', ct.c_int), # clockid + ('IGNORE10', ct.c_ulong), # sample_regs_intr + ('IGNORE11', ct.c_uint), # aux_watermark + ('IGNORE12', ct.c_uint16), # sample_max_stack + ('IGNORE13', ct.c_uint16), # __reserved_2 + ('IGNORE14', ct.c_uint), # aux_sample_size + ('IGNORE15', ct.c_uint), # __reserved_3 ] # x86 specific, from arch/x86/include/generated/uapi/asm/unistd_64.h From e70bbdcbcbcd01e5570ba7b9d79e282d16a53d40 Mon Sep 17 00:00:00 2001 From: William Findlay Date: Sat, 11 Jul 2020 12:49:30 -0400 Subject: [PATCH 196/278] Add Python API and documentation for Queue/Stack Tables (#3013) * Add QueueStack Python API * Add tests for QueueStack Python API * Add documentation for QueueStack --- docs/reference_guide.md | 154 +++++++++++++++++++++++++++----- src/python/bcc/__init__.py | 5 +- src/python/bcc/table.py | 50 +++++++++++ tests/python/CMakeLists.txt | 2 + tests/python/test_queuestack.py | 81 +++++++++++++++++ 5 files changed, 269 insertions(+), 23 deletions(-) create mode 100755 tests/python/test_queuestack.py diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 9eaf27a59..426ed25d6 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -57,16 +57,21 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [12. BPF_XSKMAP](#12-bpf_xskmap) - [13. BPF_ARRAY_OF_MAPS](#13-bpf_array_of_maps) - [14. BPF_HASH_OF_MAPS](#14-bpf_hash_of_maps) - - [15. map.lookup()](#15-maplookup) - - [16. map.lookup_or_try_init()](#16-maplookup_or_try_init) - - [17. map.delete()](#17-mapdelete) - - [18. map.update()](#18-mapupdate) - - [19. map.insert()](#19-mapinsert) - - [20. map.increment()](#20-mapincrement) - - [21. map.get_stackid()](#21-mapget_stackid) - - [22. map.perf_read()](#22-mapperf_read) - - [23. map.call()](#23-mapcall) - - [24. map.redirect_map()](#24-mapredirect_map) + - [15. BPF_STACK](#15-bpf_stack) + - [16. BPF_QUEUE](#16-bpf_queue) + - [17. map.lookup()](#17-maplookup) + - [18. map.lookup_or_try_init()](#18-maplookup_or_try_init) + - [19. map.delete()](#19-mapdelete) + - [20. map.update()](#20-mapupdate) + - [21. map.insert()](#21-mapinsert) + - [22. map.increment()](#22-mapincrement) + - [23. map.get_stackid()](#23-mapget_stackid) + - [24. map.perf_read()](#24-mapperf_read) + - [25. map.call()](#25-mapcall) + - [26. map.redirect_map()](#26-mapredirect_map) + - [27. map.push()](#27-mappush) + - [28. map.pop()](#27-mappop) + - [29. map.peek()](#27-mappeek) - [Licensing](#licensing) - [bcc Python](#bcc-python) @@ -95,8 +100,11 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [4. values()](#4-values) - [5. clear()](#5-clear) - [6. print_log2_hist()](#6-print_log2_hist) - - [7. print_linear_hist()](#6-print_linear_hist) + - [7. print_linear_hist()](#7-print_linear_hist) - [8. open_ring_buffer()](#8-open_ring_buffer) + - [9. push()](#9-push) + - [10. pop()](#10-pop) + - [11. peek()](#11-peek) - [Helpers](#helpers) - [1. ksym()](#1-ksym) - [2. ksymname()](#2-ksymname) @@ -1051,7 +1059,47 @@ BPF_ARRAY(ex2, int, 1024); BPF_HASH_OF_MAPS(maps_hash, "ex1", 10); ``` -### 15. map.lookup() +### 15. BPF_STACK + +Syntax: ```BPF_STACK(name, leaf_type, max_entries[, flags])``` + +Creates a stack named ```name``` with value type ```leaf_type``` and max entries ```max_entries```. +Stack and Queue maps are only available from Linux 4.20+. + +For example: + +```C +BPF_STACK(stack, struct event, 10240); +``` + +This creates a stack named ```stack``` where the value type is ```struct event```, that holds up to 10240 entries. + +Methods (covered later): map.push(), map.pop(), map.peek(). + +Examples in situ: +[search /tests](https://github.com/iovisor/bcc/search?q=BPF_STACK+path%3Atests&type=Code), + +### 16. BPF_QUEUE + +Syntax: ```BPF_QUEUE(name, leaf_type, max_entries[, flags])``` + +Creates a queue named ```name``` with value type ```leaf_type``` and max entries ```max_entries```. +Stack and Queue maps are only available from Linux 4.20+. + +For example: + +```C +BPF_QUEUE(queue, struct event, 10240); +``` + +This creates a queue named ```queue``` where the value type is ```struct event```, that holds up to 10240 entries. + +Methods (covered later): map.push(), map.pop(), map.peek(). + +Examples in situ: +[search /tests](https://github.com/iovisor/bcc/search?q=BPF_QUEUE+path%3Atests&type=Code), + +### 17. map.lookup() Syntax: ```*val map.lookup(&key)``` @@ -1061,7 +1109,7 @@ Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=lookup+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=lookup+path%3Atools&type=Code) -### 16. map.lookup_or_try_init() +### 18. map.lookup_or_try_init() Syntax: ```*val map.lookup_or_try_init(&key, &zero)``` @@ -1074,7 +1122,7 @@ Examples in situ: Note: The old map.lookup_or_init() may cause return from the function, so lookup_or_try_init() is recommended as it does not have this side effect. -### 17. map.delete() +### 19. map.delete() Syntax: ```map.delete(&key)``` @@ -1084,7 +1132,7 @@ Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=delete+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=delete+path%3Atools&type=Code) -### 18. map.update() +### 20. map.update() Syntax: ```map.update(&key, &val)``` @@ -1094,7 +1142,7 @@ Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=update+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=update+path%3Atools&type=Code) -### 19. map.insert() +### 21. map.insert() Syntax: ```map.insert(&key, &val)``` @@ -1104,7 +1152,7 @@ Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=insert+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=insert+path%3Atools&type=Code) -### 20. map.increment() +### 22. map.increment() Syntax: ```map.increment(key[, increment_amount])``` @@ -1114,7 +1162,7 @@ Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=increment+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=increment+path%3Atools&type=Code) -### 21. map.get_stackid() +### 23. map.get_stackid() Syntax: ```int map.get_stackid(void *ctx, u64 flags)``` @@ -1124,7 +1172,7 @@ Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=get_stackid+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=get_stackid+path%3Atools&type=Code) -### 22. map.perf_read() +### 24. map.perf_read() Syntax: ```u64 map.perf_read(u32 cpu)``` @@ -1133,7 +1181,7 @@ This returns the hardware performance counter as configured in [5. BPF_PERF_ARRA Examples in situ: [search /tests](https://github.com/iovisor/bcc/search?q=perf_read+path%3Atests&type=Code) -### 23. map.call() +### 25. map.call() Syntax: ```void map.call(void *ctx, int index)``` @@ -1172,7 +1220,7 @@ Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?l=C&q=call+path%3Aexamples&type=Code), [search /tests](https://github.com/iovisor/bcc/search?l=C&q=call+path%3Atests&type=Code) -### 24. map.redirect_map() +### 26. map.redirect_map() Syntax: ```int map.redirect_map(int index, int flags)``` @@ -1210,6 +1258,39 @@ b.attach_xdp("eth1", out_fn, 0) Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?l=C&q=redirect_map+path%3Aexamples&type=Code), +### 27. map.push() + +Syntax: ```int map.push(&val, int flags)``` + +Push an element onto a Stack or Queue table. +Passing BPF_EXIST as a flag causes the Queue or Stack to discard the oldest element if it is full. +Returns 0 on success, negative error on failure. + +Examples in situ: +[search /tests](https://github.com/iovisor/bcc/search?q=push+path%3Atests&type=Code), + +### 28. map.pop() + +Syntax: ```int map.pop(&val)``` + +Pop an element from a Stack or Queue table. ```*val``` is populated with the result. +Unlike peeking, popping removes the element. +Returns 0 on success, negative error on failure. + +Examples in situ: +[search /tests](https://github.com/iovisor/bcc/search?q=pop+path%3Atests&type=Code), + +### 29. map.peek() + +Syntax: ```int map.peek(&val)``` + +Peek an element at the head of a Stack or Queue table. ```*val``` is populated with the result. +Unlike popping, peeking does not remove the element. +Returns 0 on success, negative error on failure. + +Examples in situ: +[search /tests](https://github.com/iovisor/bcc/search?q=peek+path%3Atests&type=Code), + ## Licensing Depending on which [BPF helpers](kernel-versions.md#helpers) are used, a GPL-compatible license is required. @@ -1938,6 +2019,37 @@ def print_event(ctx, data, size): Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=open_ring_buffer+path%3Aexamples+language%3Apython&type=Code), +### 9. push() + +Syntax: ```table.push(leaf, flags=0)``` + +Push an element onto a Stack or Queue table. Raises an exception if the operation does not succeed. +Passing QueueStack.BPF_EXIST as a flag causes the Queue or Stack to discard the oldest element if it is full. + +Examples in situ: +[search /tests](https://github.com/iovisor/bcc/search?q=push+path%3Atests+language%3Apython&type=Code), + +### 10. pop() + +Syntax: ```leaf = table.pop()``` + +Pop an element from a Stack or Queue table. Unlike ```peek()```, ```pop()``` +removes the element from the table before returning it. +Raises a KeyError exception if the operation does not succeed. + +Examples in situ: +[search /tests](https://github.com/iovisor/bcc/search?q=pop+path%3Atests+language%3Apython&type=Code), + +### 11. peek() + +Syntax: ```leaf = table.peek()``` + +Peek the element at the head of a Stack or Queue table. Unlike ```pop()```, ```peek()``` +does not remove the element from the table. Raises an exception if the operation does not succeed. + +Examples in situ: +[search /tests](https://github.com/iovisor/bcc/search?q=peek+path%3Atests+language%3Apython&type=Code), + ## Helpers Some helper methods provided by bcc. Note that since we're in Python, we can import any Python library and their methods, including, for example, the libraries: argparse, collections, ctypes, datetime, re, socket, struct, subprocess, sys, and time. diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index df5b40f0f..253230bfa 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -24,7 +24,7 @@ import sys from .libbcc import lib, bcc_symbol, bcc_symbol_option, bcc_stacktrace_build_id, _SYM_CB_TYPE -from .table import Table, PerfEventArray, RingBuf +from .table import Table, PerfEventArray, RingBuf, BPF_MAP_TYPE_QUEUE, BPF_MAP_TYPE_STACK from .perf import Perf from .utils import get_online_cpus, printb, _assert_is_bytes, ArgString, StrcmpRewrite from .version import __version__ @@ -499,9 +499,10 @@ def get_table(self, name, keytype=None, leaftype=None, reducer=None): name = _assert_is_bytes(name) map_id = lib.bpf_table_id(self.module, name) map_fd = lib.bpf_table_fd(self.module, name) + is_queuestack = lib.bpf_table_type_id(self.module, map_id) in [BPF_MAP_TYPE_QUEUE, BPF_MAP_TYPE_STACK] if map_fd < 0: raise KeyError - if not keytype: + if not keytype and not is_queuestack: key_desc = lib.bpf_table_key_desc(self.module, name).decode("utf-8") if not key_desc: raise Exception("Failed to load BPF Table %s key desc" % name) diff --git a/src/python/bcc/table.py b/src/python/bcc/table.py index b8f108ffb..1a283e8a4 100644 --- a/src/python/bcc/table.py +++ b/src/python/bcc/table.py @@ -265,6 +265,8 @@ def Table(bpf, map_id, map_fd, keytype, leaftype, name, **kwargs): t = MapInMapArray(bpf, map_id, map_fd, keytype, leaftype) elif ttype == BPF_MAP_TYPE_HASH_OF_MAPS: t = MapInMapHash(bpf, map_id, map_fd, keytype, leaftype) + elif ttype == BPF_MAP_TYPE_QUEUE or ttype == BPF_MAP_TYPE_STACK: + t = QueueStack(bpf, map_id, map_fd, leaftype) elif ttype == BPF_MAP_TYPE_RINGBUF: t = RingBuf(bpf, map_id, map_fd, keytype, leaftype, name) if t == None: @@ -1000,3 +1002,51 @@ def ringbuf_cb_(ctx, data, size): self.bpf._open_ring_buffer(self.map_fd, fn, ctx) # keep a refcnt self._cbs[0] = fn + +class QueueStack: + # Flag for map.push + BPF_EXIST = 2 + + def __init__(self, bpf, map_id, map_fd, leaftype): + self.bpf = bpf + self.map_id = map_id + self.map_fd = map_fd + self.Leaf = leaftype + self.ttype = lib.bpf_table_type_id(self.bpf.module, self.map_id) + self.flags = lib.bpf_table_flags_id(self.bpf.module, self.map_id) + + def leaf_sprintf(self, leaf): + buf = ct.create_string_buffer(ct.sizeof(self.Leaf) * 8) + res = lib.bpf_table_leaf_snprintf(self.bpf.module, self.map_id, buf, + len(buf), ct.byref(leaf)) + if res < 0: + raise Exception("Could not printf leaf") + return buf.value + + def leaf_scanf(self, leaf_str): + leaf = self.Leaf() + res = lib.bpf_table_leaf_sscanf(self.bpf.module, self.map_id, leaf_str, + ct.byref(leaf)) + if res < 0: + raise Exception("Could not scanf leaf") + return leaf + + def push(self, leaf, flags=0): + res = lib.bpf_update_elem(self.map_fd, None, ct.byref(leaf), flags) + if res < 0: + errstr = os.strerror(ct.get_errno()) + raise Exception("Could not push to table: %s" % errstr) + + def pop(self): + leaf = self.Leaf() + res = lib.bpf_lookup_and_delete(self.map_fd, None, ct.byref(leaf)) + if res < 0: + raise KeyError("Could not pop from table") + return leaf + + def peek(self): + leaf = self.Leaf() + res = lib.bpf_lookup_elem(self.map_fd, None, ct.byref(leaf)) + if res < 0: + raise KeyError("Could not peek table") + return leaf diff --git a/tests/python/CMakeLists.txt b/tests/python/CMakeLists.txt index df8d2d11c..e7ce5c632 100644 --- a/tests/python/CMakeLists.txt +++ b/tests/python/CMakeLists.txt @@ -91,3 +91,5 @@ add_test(NAME py_test_lpm_trie WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_test_lpm_trie sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_lpm_trie.py) add_test(NAME py_ringbuf WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_ringbuf sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_ringbuf.py) +add_test(NAME py_queuestack WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMAND ${TEST_WRAPPER} py_queuestack sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_queuestack.py) diff --git a/tests/python/test_queuestack.py b/tests/python/test_queuestack.py new file mode 100755 index 000000000..f103cb35c --- /dev/null +++ b/tests/python/test_queuestack.py @@ -0,0 +1,81 @@ +#!/usr/bin/env python +# Copyright (c) PLUMgrid, Inc. +# Licensed under the Apache License, Version 2.0 (the "License") + +from bcc import BPF +import os +import distutils.version +import ctypes as ct +import random +import time +import subprocess +from unittest import main, TestCase, skipUnless + +def kernel_version_ge(major, minor): + # True if running kernel is >= X.Y + version = distutils.version.LooseVersion(os.uname()[2]).version + if version[0] > major: + return True + if version[0] < major: + return False + if minor and version[1] < minor: + return False + return True + +class TestQueueStack(TestCase): + @skipUnless(kernel_version_ge(4,20), "requires kernel >= 4.20") + def test_stack(self): + text = """ + BPF_STACK(stack, u64, 10); + """ + b = BPF(text=text) + stack = b['stack'] + + for i in range(10): + stack.push(ct.c_uint64(i)) + + with self.assertRaises(Exception): + stack.push(ct.c_uint(10)) + + assert stack.peek().value == 9 + + for i in reversed(range(10)): + assert stack.pop().value == i + + with self.assertRaises(KeyError): + stack.peek() + + with self.assertRaises(KeyError): + stack.pop() + + b.cleanup() + + @skipUnless(kernel_version_ge(4,20), "requires kernel >= 4.20") + def test_queue(self): + text = """ + BPF_QUEUE(queue, u64, 10); + """ + b = BPF(text=text) + queue = b['queue'] + + for i in range(10): + queue.push(ct.c_uint64(i)) + + with self.assertRaises(Exception): + queue.push(ct.c_uint(10)) + + assert queue.peek().value == 0 + + for i in range(10): + assert queue.pop().value == i + + with self.assertRaises(KeyError): + queue.peek() + + with self.assertRaises(KeyError): + queue.pop() + + b.cleanup() + +if __name__ == "__main__": + main() From 1abab9bd2b68a389db704848c3b9fbb03f8e0c02 Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Sat, 11 Jul 2020 23:29:17 -0700 Subject: [PATCH 197/278] use bpf_probe_read_kernel for implicit kernel mem read on s390 Commit f579bf8d60c8 ("bpf: use bpf_probe_read in implicitly generated kernel mem read") unconditionally use bpf_probe_read() for implicit kernel memory read in bpf programs. This won't work for s390 with recent kernels since s390 has overlap user/kernel addresses and bpf_probe_read() is not available any more. This patch partially reverted Commit f579bf8d60c8 such that for s390, bpf_probe_read_kernel() will be used while other architectures bpf_probe_read() is used. Signed-off-by: Yonghong Song --- src/cc/frontends/clang/b_frontend_action.cc | 30 ++++++++++++++++----- src/cc/frontends/clang/b_frontend_action.h | 2 ++ 2 files changed, 26 insertions(+), 6 deletions(-) diff --git a/src/cc/frontends/clang/b_frontend_action.cc b/src/cc/frontends/clang/b_frontend_action.cc index 39ba71e46..154a3794d 100644 --- a/src/cc/frontends/clang/b_frontend_action.cc +++ b/src/cc/frontends/clang/b_frontend_action.cc @@ -316,7 +316,10 @@ bool MapVisitor::VisitCallExpr(CallExpr *Call) { ProbeVisitor::ProbeVisitor(ASTContext &C, Rewriter &rewriter, set &m, bool track_helpers) : C(C), rewriter_(rewriter), m_(m), track_helpers_(track_helpers), - addrof_stmt_(nullptr), is_addrof_(false) {} + addrof_stmt_(nullptr), is_addrof_(false) { + const char **calling_conv_regs = get_call_conv(); + has_overlap_kuaddr_ = calling_conv_regs == calling_conv_regs_s390x; +} bool ProbeVisitor::assignsExtPtr(Expr *E, int *nbDerefs) { if (IsContextMemberExpr(E)) { @@ -488,7 +491,10 @@ bool ProbeVisitor::VisitUnaryOperator(UnaryOperator *E) { memb_visited_.insert(E); string pre, post; pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));"; - pre += " bpf_probe_read(&_val, sizeof(_val), (u64)"; + if (has_overlap_kuaddr_) + pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (u64)"; + else + pre += " bpf_probe_read(&_val, sizeof(_val), (u64)"; post = "); _val; })"; rewriter_.ReplaceText(expansionLoc(E->getOperatorLoc()), 1, pre); rewriter_.InsertTextAfterToken(expansionLoc(GET_ENDLOC(sub)), post); @@ -549,7 +555,10 @@ bool ProbeVisitor::VisitMemberExpr(MemberExpr *E) { string base_type = base->getType()->getPointeeType().getAsString(); string pre, post; pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));"; - pre += " bpf_probe_read(&_val, sizeof(_val), (u64)&"; + if (has_overlap_kuaddr_) + pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (u64)&"; + else + pre += " bpf_probe_read(&_val, sizeof(_val), (u64)&"; post = rhs + "); _val; })"; rewriter_.InsertText(expansionLoc(GET_BEGINLOC(E)), pre); rewriter_.ReplaceText(expansionRange(SourceRange(member, GET_ENDLOC(E))), post); @@ -600,7 +609,10 @@ bool ProbeVisitor::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { return true; pre = "({ typeof(" + E->getType().getAsString() + ") _val; __builtin_memset(&_val, 0, sizeof(_val));"; - pre += " bpf_probe_read(&_val, sizeof(_val), (u64)(("; + if (has_overlap_kuaddr_) + pre += " bpf_probe_read_kernel(&_val, sizeof(_val), (u64)(("; + else + pre += " bpf_probe_read(&_val, sizeof(_val), (u64)(("; if (isMemberDereference(base)) { pre += "&"; // If the base of the array subscript is a member dereference, we'll rewrite @@ -692,7 +704,10 @@ DiagnosticBuilder ProbeVisitor::error(SourceLocation loc, const char (&fmt)[N]) } BTypeVisitor::BTypeVisitor(ASTContext &C, BFrontendAction &fe) - : C(C), diag_(C.getDiagnostics()), fe_(fe), rewriter_(fe.rewriter()), out_(llvm::errs()) {} + : C(C), diag_(C.getDiagnostics()), fe_(fe), rewriter_(fe.rewriter()), out_(llvm::errs()) { + const char **calling_conv_regs = get_call_conv(); + has_overlap_kuaddr_ = calling_conv_regs == calling_conv_regs_s390x; +} void BTypeVisitor::genParamDirectAssign(FunctionDecl *D, string& preamble, const char **calling_conv_regs) { @@ -733,7 +748,10 @@ void BTypeVisitor::genParamIndirectAssign(FunctionDecl *D, string& preamble, size_t d = idx - 1; const char *reg = calling_conv_regs[d]; preamble += "\n " + text + ";"; - preamble += " bpf_probe_read"; + if (has_overlap_kuaddr_) + preamble += " bpf_probe_read_kernel"; + else + preamble += " bpf_probe_read"; preamble += "(&" + arg->getName().str() + ", sizeof(" + arg->getName().str() + "), &" + new_ctx + "->" + string(reg) + ");"; diff --git a/src/cc/frontends/clang/b_frontend_action.h b/src/cc/frontends/clang/b_frontend_action.h index cea13cc08..bdbbc365a 100644 --- a/src/cc/frontends/clang/b_frontend_action.h +++ b/src/cc/frontends/clang/b_frontend_action.h @@ -90,6 +90,7 @@ class BTypeVisitor : public clang::RecursiveASTVisitor { std::vector fn_args_; std::set visited_; std::string current_fn_; + bool has_overlap_kuaddr_; }; // Do a depth-first search to rewrite all pointers that need to be probed @@ -129,6 +130,7 @@ class ProbeVisitor : public clang::RecursiveASTVisitor { std::list ptregs_returned_; const clang::Stmt *addrof_stmt_; bool is_addrof_; + bool has_overlap_kuaddr_; }; // A helper class to the frontend action, walks the decls From d3a102d5d1029438ec7a1a5450095362f3b56fc1 Mon Sep 17 00:00:00 2001 From: Simone Magnani Date: Sun, 12 Jul 2020 21:51:38 +0200 Subject: [PATCH 198/278] fix cc queue/stack test kernel version This commit fixes the Kernel version check in test_queuestack_table.cc . The correct one, as discussed in #3013, is 4.20 (not 5.0). Signed-off-by: Simone Magnani --- tests/cc/test_queuestack_table.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/cc/test_queuestack_table.cc b/tests/cc/test_queuestack_table.cc index e25717906..a502d6124 100644 --- a/tests/cc/test_queuestack_table.cc +++ b/tests/cc/test_queuestack_table.cc @@ -19,8 +19,8 @@ #include #include -//Queue/Stack types are available only from 5.0.0 -#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 0) +//Queue/Stack types are available only from 4.20 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0) TEST_CASE("queue table", "[queue_table]") { const std::string BPF_PROGRAM = R"( BPF_QUEUE(myqueue, int, 30); From 4efe7fe3e81a65ca4d2cf6eec8055125ca3018f9 Mon Sep 17 00:00:00 2001 From: Michal Gregorczyk Date: Thu, 9 Jul 2020 02:48:09 -0400 Subject: [PATCH 199/278] fix debug file lookup in bcc_elf_symbol_str Logic for looking up debug file in bcc_elf_symbol_str and foreach_sym_core differ. This commit factors out relevant code from foreach_sym_core and reuses it in bcc_elf_symbol_str. --- src/cc/bcc_elf.c | 38 ++++++++++++++++++++++---------------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/src/cc/bcc_elf.c b/src/cc/bcc_elf.c index 296b32265..c3b24046c 100644 --- a/src/cc/bcc_elf.c +++ b/src/cc/bcc_elf.c @@ -598,6 +598,25 @@ static char *find_debug_via_symfs(Elf *e, const char* path) { return result; } +static char *find_debug_file(Elf* e, const char* path, int check_crc) { + char *debug_file = NULL; + + // If there is a separate debuginfo file, try to locate and read it, first + // using symfs, then using the build-id section, finally using the debuglink + // section. These rules are what perf and gdb follow. + // See: + // - https://github.com/torvalds/linux/blob/v5.2/tools/perf/Documentation/perf-report.txt#L325 + // - https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html + debug_file = find_debug_via_symfs(e, path); + if (!debug_file) + debug_file = find_debug_via_buildid(e); + if (!debug_file) + debug_file = find_debug_via_debuglink(e, path, check_crc); + + return debug_file; +} + + static int foreach_sym_core(const char *path, bcc_elf_symcb callback, bcc_elf_symcb_lazy callback_lazy, struct bcc_symbol_option *option, void *payload, @@ -612,21 +631,11 @@ static int foreach_sym_core(const char *path, bcc_elf_symcb callback, if (openelf(path, &e, &fd) < 0) return -1; - // If there is a separate debuginfo file, try to locate and read it, first - // using symfs, then using the build-id section, finally using the debuglink - // section. These rules are what perf and gdb follow. - // See: - // - https://github.com/torvalds/linux/blob/v5.2/tools/perf/Documentation/perf-report.txt#L325 - // - https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html if (option->use_debug_file && !is_debug_file) { // The is_debug_file argument helps avoid infinitely resolving debuginfo // files for debuginfo files and so on. - debug_file = find_debug_via_symfs(e, path); - if (!debug_file) - debug_file = find_debug_via_buildid(e); - if (!debug_file) - debug_file = find_debug_via_debuglink(e, path, - option->check_debug_file_crc); + debug_file = find_debug_file(e, path, + option->check_debug_file_crc); if (debug_file) { foreach_sym_core(debug_file, callback, callback_lazy, option, payload, 1); free(debug_file); @@ -1002,10 +1011,7 @@ int bcc_elf_symbol_str(const char *path, size_t section_idx, return -1; if (debugfile) { - debug_file = find_debug_via_buildid(e); - if (!debug_file) - debug_file = find_debug_via_debuglink(e, path, 0); // No crc for speed - + debug_file = find_debug_file(e, path, 0); if (!debug_file) { err = -1; goto exit; From 316b404c28744fd106b3b37cc216693d143a7a2d Mon Sep 17 00:00:00 2001 From: Yonghong Song Date: Wed, 15 Jul 2020 10:04:06 -0700 Subject: [PATCH 200/278] update reference_guide for implicit kmem access rewriting Update the reference_guide to spell out for implicit kernel memory access, when rewriter uses bpf_probe_read() (for non-s390) and when using bpf_probe_read_kernel() (for s390). Signed-off-by: Yonghong Song --- docs/reference_guide.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 426ed25d6..6abb66c0b 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -73,6 +73,7 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [28. map.pop()](#27-mappop) - [29. map.peek()](#27-mappeek) - [Licensing](#licensing) + - [Rewriter](#rewriter) - [bcc Python](#bcc-python) - [Initialization](#initialization) @@ -1313,6 +1314,10 @@ Check the [BPF helpers reference](kernel-versions.md#helpers) to see which helpe **If the macro is not specified, BCC will automatically define the license of the program as GPL.** +## Rewriter + +One of jobs for rewriter is to turn implicit memory accesses to explicit ones using kernel helpers. Recent kernel introduced a config option ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE which will be set for architectures who user address space and kernel address are disjoint. x86 and arm has this config option set while s390 does not. If ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE is not set, the bpf old helper `bpf_probe_read()` will not be available. Some existing users may have implicit memory accesses to access user memory, so using `bpf_probe_read_kernel()` will cause their application to fail. Therefore, for non-s390, the rewriter will use `bpf_probe_read()` for these implicit memory accesses. For s390, `bpf_probe_read_kernel()` is used as default and users should use `bpf_probe_read_user()` explicitly when accessing user memories. + # bcc Python ## Initialization From 222821c8be2c3aa862ddd7e4bf2a10965ae0639f Mon Sep 17 00:00:00 2001 From: Wenbo Zhang Date: Thu, 9 Jul 2020 00:37:07 -0400 Subject: [PATCH 201/278] libbpf-tools: add CO-RE biolatency Signed-off-by: Wenbo Zhang --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/biolatency.bpf.c | 121 +++++++++++++ libbpf-tools/biolatency.c | 319 ++++++++++++++++++++++++++++++++++ libbpf-tools/biolatency.h | 17 ++ libbpf-tools/blk_types.h | 126 ++++++++++++++ 6 files changed, 585 insertions(+) create mode 100644 libbpf-tools/biolatency.bpf.c create mode 100644 libbpf-tools/biolatency.c create mode 100644 libbpf-tools/biolatency.h create mode 100644 libbpf-tools/blk_types.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 2b30730e3..ccbbd42b2 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -1,4 +1,5 @@ /.output +/biolatency /bitesize /cpudist /drsnoop diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 33bd0f64f..299f7089d 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -10,6 +10,7 @@ CFLAGS := -g -O2 -Wall ARCH := $(shell uname -m | sed 's/x86_64/x86/') APPS = \ + biolatency \ bitesize \ cpudist \ drsnoop \ diff --git a/libbpf-tools/biolatency.bpf.c b/libbpf-tools/biolatency.bpf.c new file mode 100644 index 000000000..57055b58d --- /dev/null +++ b/libbpf-tools/biolatency.bpf.c @@ -0,0 +1,121 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include +#include +#include +#include "biolatency.h" +#include "bits.bpf.h" + +#define MAX_ENTRIES 10240 + +const volatile char targ_disk[DISK_NAME_LEN] = {}; +const volatile bool targ_per_disk = false; +const volatile bool targ_per_flag = false; +const volatile bool targ_queued = false; +const volatile bool targ_ms = false; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, struct request *); + __type(value, u64); + __uint(map_flags, BPF_F_NO_PREALLOC); +} start SEC(".maps"); + +static struct hist initial_hist; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, struct hist_key); + __type(value, struct hist); + __uint(map_flags, BPF_F_NO_PREALLOC); +} hists SEC(".maps"); + +static __always_inline bool disk_filtered(const char *disk) +{ + int i; + + for (i = 0; targ_disk[i] != '\0' && i < DISK_NAME_LEN; i++) { + if (disk[i] != targ_disk[i]) + return false; + } + return true; +} + +static __always_inline +int trace_rq_start(struct request *rq) +{ + u64 ts = bpf_ktime_get_ns(); + char disk[DISK_NAME_LEN]; + + bpf_probe_read_kernel_str(&disk, sizeof(disk), rq->rq_disk->disk_name); + if (!disk_filtered(disk)) + return 0; + + bpf_map_update_elem(&start, &rq, &ts, 0); + return 0; +} + +SEC("tp_btf/block_rq_insert") +int BPF_PROG(tp_btf__block_rq_insert, struct request_queue *q, + struct request *rq) +{ + return trace_rq_start(rq); +} + +SEC("tp_btf/block_rq_issue") +int BPF_PROG(tp_btf__block_rq_issue, struct request_queue *q, + struct request *rq) +{ + if (targ_queued && BPF_CORE_READ(q, elevator)) + return 0; + return trace_rq_start(rq); +} + +SEC("tp_btf/block_rq_complete") +int BPF_PROG(tp_btf__block_rq_complete, struct request *rq, int error, + unsigned int nr_bytes) +{ + u64 slot, *tsp, ts = bpf_ktime_get_ns(); + struct hist_key hkey = {}; + struct hist *histp; + s64 delta; + + tsp = bpf_map_lookup_elem(&start, &rq); + if (!tsp) + return 0; + delta = (s64)(ts - *tsp); + if (delta < 0) + goto cleanup; + + if (targ_per_disk) + bpf_probe_read_kernel_str(&hkey.disk, sizeof(hkey.disk), + rq->rq_disk->disk_name); + if (targ_per_flag) + hkey.cmd_flags = rq->cmd_flags; + + histp = bpf_map_lookup_elem(&hists, &hkey); + if (!histp) { + bpf_map_update_elem(&hists, &hkey, &initial_hist, 0); + histp = bpf_map_lookup_elem(&hists, &hkey); + if (!histp) + goto cleanup; + } + + if (targ_ms) + delta /= 1000000; + else + delta /= 1000; + slot = log2l(delta); + if (slot >= MAX_SLOTS) + slot = MAX_SLOTS - 1; + __sync_fetch_and_add(&histp->slots[slot], 1); + +cleanup: + bpf_map_delete_elem(&start, &rq); + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/biolatency.c b/libbpf-tools/biolatency.c new file mode 100644 index 000000000..25e78b921 --- /dev/null +++ b/libbpf-tools/biolatency.c @@ -0,0 +1,319 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on biolatency(8) from BCC by Brendan Gregg. +// 15-Jun-2020 Wenbo Zhang Created this. +#include +#include +#include +#include +#include +#include +#include +#include +#include "blk_types.h" +#include "biolatency.h" +#include "biolatency.skel.h" +#include "trace_helpers.h" + +#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x))) + +static struct env { + char *disk; + int disk_len; + time_t interval; + int times; + bool timestamp; + bool queued; + bool per_disk; + bool per_flag; + bool milliseconds; + bool verbose; +} env = { + .interval = 99999999, + .times = 99999999, +}; + +static volatile bool exiting; + +const char *argp_program_version = "biolatency 0.1"; +const char *argp_program_bug_address = ""; +const char argp_program_doc[] = + "Summarize block device I/O latency as a histogram.\n" + "\n" + "USAGE: biolatency [-h] [-T] [-m] [-Q] [-D] [-F] [-d] [interval] [count]\n" + "\n" + "EXAMPLES:\n" + " biolatency # summarize block I/O latency as a histogram\n" + " biolatency 1 10 # print 1 second summaries, 10 times\n" + " biolatency -mT 1 # 1s summaries, milliseconds, and timestamps\n" + " biolatency -Q # include OS queued time in I/O time\n" + " biolatency -D # show each disk device separately\n" + " biolatency -F # show I/O flags separately\n" + " biolatency -d sdc # Trace sdc only\n"; + +static const struct argp_option opts[] = { + { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, + { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, + { "milliseconds", 'm', NULL, 0, "Millisecond histogram" }, + { "queued", 'Q', NULL, 0, "Include OS queued time in I/O time" }, + { "disk", 'D', NULL, 0, "Print a histogram per disk device" }, + { "flag", 'F', NULL, 0, "Print a histogram per set of I/O flags" }, + { "disk", 'd', "DISK", 0, "Trace this disk only" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static int pos_args; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'h': + argp_usage(state); + break; + case 'm': + env.milliseconds = true; + break; + case 'Q': + env.queued = true; + break; + case 'D': + env.per_disk = true; + break; + case 'F': + env.per_flag = true; + break; + case 'd': + env.disk = arg; + env.disk_len = strlen(arg) + 1; + if (env.disk_len > DISK_NAME_LEN) { + fprintf(stderr, "invaild disk name: too long\n"); + argp_usage(state); + } + break; + case ARGP_KEY_ARG: + errno = 0; + if (pos_args == 0) { + env.interval = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid internal\n"); + argp_usage(state); + } + } else if (pos_args == 1) { + env.times = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid times\n"); + argp_usage(state); + } + } else { + fprintf(stderr, + "unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + pos_args++; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void sig_handler(int sig) +{ + exiting = true; +} + +static void print_cmd_flags(int cmd_flags) +{ + static struct { int bit; const char *str; } flags[] = { + { REQ_NOWAIT, "NoWait-" }, + { REQ_BACKGROUND, "Background-" }, + { REQ_RAHEAD, "ReadAhead-" }, + { REQ_PREFLUSH, "PreFlush-" }, + { REQ_FUA, "FUA-" }, + { REQ_INTEGRITY, "Integrity-" }, + { REQ_IDLE, "Idle-" }, + { REQ_NOMERGE, "NoMerge-" }, + { REQ_PRIO, "Priority-" }, + { REQ_META, "Metadata-" }, + { REQ_SYNC, "Sync-" }, + }; + static const char *ops[] = { + [REQ_OP_READ] = "Read", + [REQ_OP_WRITE] = "Write", + [REQ_OP_FLUSH] = "Flush", + [REQ_OP_DISCARD] = "Discard", + [REQ_OP_SECURE_ERASE] = "SecureErase", + [REQ_OP_ZONE_RESET] = "ZoneReset", + [REQ_OP_WRITE_SAME] = "WriteSame", + [REQ_OP_ZONE_RESET_ALL] = "ZoneResetAll", + [REQ_OP_WRITE_ZEROES] = "WriteZeroes", + [REQ_OP_ZONE_OPEN] = "ZoneOpen", + [REQ_OP_ZONE_CLOSE] = "ZoneClose", + [REQ_OP_ZONE_FINISH] = "ZoneFinish", + [REQ_OP_SCSI_IN] = "SCSIIn", + [REQ_OP_SCSI_OUT] = "SCSIOut", + [REQ_OP_DRV_IN] = "DrvIn", + [REQ_OP_DRV_OUT] = "DrvOut", + }; + int i; + + printf("flags = "); + + for (i = 0; i < ARRAY_SIZE(flags); i++) { + if (cmd_flags & flags[i].bit) + printf("%s", flags[i].str); + } + + if ((cmd_flags & REQ_OP_MASK) < ARRAY_SIZE(ops)) + printf("%s", ops[cmd_flags & REQ_OP_MASK]); + else + printf("Unknown"); +} + +static int print_log2_hists(int fd) +{ + struct hist_key lookup_key = { .cmd_flags = -1 }, next_key; + char *units = env.milliseconds ? "msecs" : "usecs"; + struct hist hist; + int err; + + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_lookup_elem(fd, &next_key, &hist); + if (err < 0) { + fprintf(stderr, "failed to lookup hist: %d\n", err); + return -1; + } + if (env.per_disk) + printf("\ndisk = %s\t", next_key.disk[0] != '\0' ? + next_key.disk : "unnamed"); + if (env.per_flag) + print_cmd_flags(next_key.cmd_flags); + printf("\n"); + print_log2_hist(hist.slots, MAX_SLOTS, units); + lookup_key = next_key; + } + + lookup_key.cmd_flags = -1; + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_delete_elem(fd, &next_key); + if (err < 0) { + fprintf(stderr, "failed to cleanup hist : %d\n", err); + return -1; + } + lookup_key = next_key; + } + + return 0; +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct biolatency_bpf *obj; + struct tm *tm; + char ts[32]; + time_t t; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = biolatency_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + return 1; + } + + /* initialize global data (filtering options) */ + if (env.disk) + strncpy((char*)obj->rodata->targ_disk, env.disk, env.disk_len); + obj->rodata->targ_per_disk = env.per_disk; + obj->rodata->targ_per_flag = env.per_flag; + obj->rodata->targ_ms = env.milliseconds; + obj->rodata->targ_queued = env.queued; + + err = biolatency_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + if (env.queued) { + obj->links.tp_btf__block_rq_insert = + bpf_program__attach(obj->progs.tp_btf__block_rq_insert); + err = libbpf_get_error(obj->links.tp_btf__block_rq_insert); + if (err) { + fprintf(stderr, "failed to attach: %s\n", strerror(-err)); + goto cleanup; + } + } + obj->links.tp_btf__block_rq_issue = + bpf_program__attach(obj->progs.tp_btf__block_rq_issue); + err = libbpf_get_error(obj->links.tp_btf__block_rq_issue); + if (err) { + fprintf(stderr, "failed to attach: %s\n", strerror(-err)); + goto cleanup; + } + obj->links.tp_btf__block_rq_complete = + bpf_program__attach(obj->progs.tp_btf__block_rq_complete); + err = libbpf_get_error(obj->links.tp_btf__block_rq_complete); + if (err) { + fprintf(stderr, "failed to attach: %s\n", strerror(-err)); + goto cleanup; + } + + signal(SIGINT, sig_handler); + + printf("Tracing block device I/O... Hit Ctrl-C to end.\n"); + + /* main: poll */ + while (1) { + sleep(env.interval); + printf("\n"); + + if (env.timestamp) { + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + printf("%-8s\n", ts); + } + + err = print_log2_hists(bpf_map__fd(obj->maps.hists)); + if (err) + break; + + if (exiting || --env.times == 0) + break; + } + +cleanup: + biolatency_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/biolatency.h b/libbpf-tools/biolatency.h new file mode 100644 index 000000000..83d4386ff --- /dev/null +++ b/libbpf-tools/biolatency.h @@ -0,0 +1,17 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __BIOLATENCY_H +#define __BIOLATENCY_H + +#define DISK_NAME_LEN 32 +#define MAX_SLOTS 27 + +struct hist_key { + char disk[DISK_NAME_LEN]; + __u32 cmd_flags; +}; + +struct hist { + __u32 slots[MAX_SLOTS]; +}; + +#endif /* __BIOLATENCY_H */ diff --git a/libbpf-tools/blk_types.h b/libbpf-tools/blk_types.h new file mode 100644 index 000000000..3fc8a4945 --- /dev/null +++ b/libbpf-tools/blk_types.h @@ -0,0 +1,126 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __BLK_TYPES_H +#define __BLK_TYPES_H + +/* From include/linux/blk_types.h */ + +/* + * Operations and flags common to the bio and request structures. + * We use 8 bits for encoding the operation, and the remaining 24 for flags. + * + * The least significant bit of the operation number indicates the data + * transfer direction: + * + * - if the least significant bit is set transfers are TO the device + * - if the least significant bit is not set transfers are FROM the device + * + * If a operation does not transfer data the least significant bit has no + * meaning. + */ +#define REQ_OP_BITS 8 +#define REQ_OP_MASK ((1 << REQ_OP_BITS) - 1) +#define REQ_FLAG_BITS 24 + +enum req_opf { + /* read sectors from the device */ + REQ_OP_READ = 0, + /* write sectors to the device */ + REQ_OP_WRITE = 1, + /* flush the volatile write cache */ + REQ_OP_FLUSH = 2, + /* discard sectors */ + REQ_OP_DISCARD = 3, + /* securely erase sectors */ + REQ_OP_SECURE_ERASE = 5, + /* reset a zone write pointer */ + REQ_OP_ZONE_RESET = 6, + /* write the same sector many times */ + REQ_OP_WRITE_SAME = 7, + /* reset all the zone present on the device */ + REQ_OP_ZONE_RESET_ALL = 8, + /* write the zero filled sector many times */ + REQ_OP_WRITE_ZEROES = 9, + /* Open a zone */ + REQ_OP_ZONE_OPEN = 10, + /* Close a zone */ + REQ_OP_ZONE_CLOSE = 11, + /* Transition a zone to full */ + REQ_OP_ZONE_FINISH = 12, + + /* SCSI passthrough using struct scsi_request */ + REQ_OP_SCSI_IN = 32, + REQ_OP_SCSI_OUT = 33, + /* Driver private requests */ + REQ_OP_DRV_IN = 34, + REQ_OP_DRV_OUT = 35, + + REQ_OP_LAST, +}; + +enum req_flag_bits { + __REQ_FAILFAST_DEV = /* no driver retries of device errors */ + REQ_OP_BITS, + __REQ_FAILFAST_TRANSPORT, /* no driver retries of transport errors */ + __REQ_FAILFAST_DRIVER, /* no driver retries of driver errors */ + __REQ_SYNC, /* request is sync (sync write or read) */ + __REQ_META, /* metadata io request */ + __REQ_PRIO, /* boost priority in cfq */ + __REQ_NOMERGE, /* don't touch this for merging */ + __REQ_IDLE, /* anticipate more IO after this one */ + __REQ_INTEGRITY, /* I/O includes block integrity payload */ + __REQ_FUA, /* forced unit access */ + __REQ_PREFLUSH, /* request for cache flush */ + __REQ_RAHEAD, /* read ahead, can fail anytime */ + __REQ_BACKGROUND, /* background IO */ + __REQ_NOWAIT, /* Don't wait if request will block */ + __REQ_NOWAIT_INLINE, /* Return would-block error inline */ + /* + * When a shared kthread needs to issue a bio for a cgroup, doing + * so synchronously can lead to priority inversions as the kthread + * can be trapped waiting for that cgroup. CGROUP_PUNT flag makes + * submit_bio() punt the actual issuing to a dedicated per-blkcg + * work item to avoid such priority inversions. + */ + __REQ_CGROUP_PUNT, + + /* command specific flags for REQ_OP_WRITE_ZEROES: */ + __REQ_NOUNMAP, /* do not free blocks when zeroing */ + + __REQ_HIPRI, + + /* for driver use */ + __REQ_DRV, + __REQ_SWAP, /* swapping request. */ + __REQ_NR_BITS, /* stops here */ +}; + +#define REQ_FAILFAST_DEV (1ULL << __REQ_FAILFAST_DEV) +#define REQ_FAILFAST_TRANSPORT (1ULL << __REQ_FAILFAST_TRANSPORT) +#define REQ_FAILFAST_DRIVER (1ULL << __REQ_FAILFAST_DRIVER) +#define REQ_SYNC (1ULL << __REQ_SYNC) +#define REQ_META (1ULL << __REQ_META) +#define REQ_PRIO (1ULL << __REQ_PRIO) +#define REQ_NOMERGE (1ULL << __REQ_NOMERGE) +#define REQ_IDLE (1ULL << __REQ_IDLE) +#define REQ_INTEGRITY (1ULL << __REQ_INTEGRITY) +#define REQ_FUA (1ULL << __REQ_FUA) +#define REQ_PREFLUSH (1ULL << __REQ_PREFLUSH) +#define REQ_RAHEAD (1ULL << __REQ_RAHEAD) +#define REQ_BACKGROUND (1ULL << __REQ_BACKGROUND) +#define REQ_NOWAIT (1ULL << __REQ_NOWAIT) +#define REQ_NOWAIT_INLINE (1ULL << __REQ_NOWAIT_INLINE) +#define REQ_CGROUP_PUNT (1ULL << __REQ_CGROUP_PUNT) + +#define REQ_NOUNMAP (1ULL << __REQ_NOUNMAP) +#define REQ_HIPRI (1ULL << __REQ_HIPRI) + +#define REQ_DRV (1ULL << __REQ_DRV) +#define REQ_SWAP (1ULL << __REQ_SWAP) + +#define REQ_FAILFAST_MASK \ + (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER) + +#define REQ_NOMERGE_FLAGS \ + (REQ_NOMERGE | REQ_PREFLUSH | REQ_FUA) + +#endif /* __BLK_TYPES_H */ From c31e9d6c80f70ff39dff14a7ab3ebec07bec0c7f Mon Sep 17 00:00:00 2001 From: Gary Lin Date: Thu, 2 Jul 2020 17:28:58 +0800 Subject: [PATCH 202/278] Adjust the order of linux kernel header include paths The current order of include paths could cause the following error: In file included from /virtual/main.c:3: In file included from include/linux/sched.h:13: In file included from include/linux/pid.h:4: In file included from include/linux/rculist.h:10: In file included from include/linux/rcupdate.h:38: In file included from include/linux/spinlock.h:50: In file included from include/linux/preempt.h:80: In file included from /lib/modules/4.12.14-197.45-default/build/arch/s390/include/generated/asm/preempt.h:1: include/asm-generic/preempt.h:10:42: error: no member named 'preempt_count' in 'struct thread_info' return READ_ONCE(current_thread_info()->preempt_count); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~ include/linux/compiler.h:349:34: note: expanded from macro 'READ_ONCE' ~~~~~~~~~~~~^~~~~ include/linux/compiler.h:342:17: note: expanded from macro '__READ_ONCE' union { typeof(x) __val; char __c[1]; } __u; \ ... 7 errors generated. It's supposed to load "asm/preempt.h" from "source/"(*) but accidentally loaded the one from "build/", so the error showed. (x86_64 didn't suffer this error because it didn't install the extra "asm/preempt.h" to "build/".) For the distros, e.g. SUSE/openSUSE and debian, with separate "build/" and "source/", all those "generated/" paths only exist in "build/". To avoid the potential compilation issue, this commit adjusts the include order for those with split headers to align the include order from kernel top Makefile. (*) /lib/modules/4.12.14-197.45-default/source/arch/s390/include/ Signed-off-by: Gary Lin --- src/cc/frontends/clang/kbuild_helper.cc | 48 +++++++++++++++++-------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/src/cc/frontends/clang/kbuild_helper.cc b/src/cc/frontends/clang/kbuild_helper.cc index e3aade893..c4e0f074a 100644 --- a/src/cc/frontends/clang/kbuild_helper.cc +++ b/src/cc/frontends/clang/kbuild_helper.cc @@ -74,27 +74,47 @@ int KBuildHelper::get_flags(const char *uname_machine, vector *cflags) { cflags->push_back("-isystem"); cflags->push_back("/virtual/lib/clang/include"); - // some module build directories split headers between source/ and build/ + // The include order from kernel top Makefile: + // + // # Use USERINCLUDE when you must reference the UAPI directories only. + // USERINCLUDE := \ + // -I$(srctree)/arch/$(SRCARCH)/include/uapi \ + // -I$(objtree)/arch/$(SRCARCH)/include/generated/uapi \ + // -I$(srctree)/include/uapi \ + // -I$(objtree)/include/generated/uapi \ + // -include $(srctree)/include/linux/kconfig.h + // + // # Use LINUXINCLUDE when you must reference the include/ directory. + // # Needed to be compatible with the O= option + // LINUXINCLUDE := \ + // -I$(srctree)/arch/$(SRCARCH)/include \ + // -I$(objtree)/arch/$(SRCARCH)/include/generated \ + // $(if $(building_out_of_srctree),-I$(srctree)/include) \ + // -I$(objtree)/include \ + // $(USERINCLUDE) + // + // Some distros such as openSUSE/SUSE and Debian splits the headers between + // source/ and build/. In this case, just $(srctree) is source/ and + // $(objtree) is build/. if (has_source_dir_) { - cflags->push_back("-I" + kdir_ + "/build/arch/"+arch+"/include"); - cflags->push_back("-I" + kdir_ + "/build/arch/"+arch+"/include/generated/uapi"); + cflags->push_back("-Iarch/"+arch+"/include/"); cflags->push_back("-I" + kdir_ + "/build/arch/"+arch+"/include/generated"); + cflags->push_back("-Iinclude"); cflags->push_back("-I" + kdir_ + "/build/include"); - cflags->push_back("-I" + kdir_ + "/build/./arch/"+arch+"/include/uapi"); + cflags->push_back("-Iarch/"+arch+"/include/uapi"); cflags->push_back("-I" + kdir_ + "/build/arch/"+arch+"/include/generated/uapi"); - cflags->push_back("-I" + kdir_ + "/build/include/uapi"); - cflags->push_back("-I" + kdir_ + "/build/include/generated"); + cflags->push_back("-Iinclude/uapi"); cflags->push_back("-I" + kdir_ + "/build/include/generated/uapi"); + } else { + cflags->push_back("-Iarch/"+arch+"/include/"); + cflags->push_back("-Iarch/"+arch+"/include/generated"); + cflags->push_back("-Iinclude"); + cflags->push_back("-Iarch/"+arch+"/include/uapi"); + cflags->push_back("-Iarch/"+arch+"/include/generated/uapi"); + cflags->push_back("-Iinclude/uapi"); + cflags->push_back("-Iinclude/generated/uapi"); } - cflags->push_back("-I./arch/"+arch+"/include"); - cflags->push_back("-Iarch/"+arch+"/include/generated/uapi"); - cflags->push_back("-Iarch/"+arch+"/include/generated"); - cflags->push_back("-Iinclude"); - cflags->push_back("-I./arch/"+arch+"/include/uapi"); - cflags->push_back("-Iarch/"+arch+"/include/generated/uapi"); - cflags->push_back("-I./include/uapi"); - cflags->push_back("-Iinclude/generated/uapi"); cflags->push_back("-include"); cflags->push_back("./include/linux/kconfig.h"); cflags->push_back("-D__KERNEL__"); From a02663be278012a4d0aea357023ea145c1b1c0d9 Mon Sep 17 00:00:00 2001 From: Andrii Nakryiko Date: Tue, 21 Jul 2020 20:58:32 -0700 Subject: [PATCH 203/278] libbpf-tools: update bpftool and fix .rodata hack Update bpftool to the latest version, handing const volatile arrays properly when generating BPF skeletons. Fix tcpconnect tool hack to work around that issue. Signed-off-by: Andrii Nakryiko --- libbpf-tools/bin/bpftool | Bin 2376176 -> 2472968 bytes libbpf-tools/tcpconnect.bpf.c | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/libbpf-tools/bin/bpftool b/libbpf-tools/bin/bpftool index 51d90694310a71b9fe0bba21172e1e616f2e15dc..eed0c1d9056adf3c6a88c01dba3d7b42174b98c8 100755 GIT binary patch delta 766287 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

{tbemjwq1*tNs&xI~Gc){mAav1cHI+`A+3N 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±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

mbN9Zc0->lZ{$VMDCqVFex*$ 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 r0-qAIdA%Y?0Kc{s*`dxF6 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

o6{bnF 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 delta 674979 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%0A%PI+7CblKV1X5&G@*zMwwgx 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 diff --git a/libbpf-tools/tcpconnect.bpf.c b/libbpf-tools/tcpconnect.bpf.c index 734f529f5..f941f13dc 100644 --- a/libbpf-tools/tcpconnect.bpf.c +++ b/libbpf-tools/tcpconnect.bpf.c @@ -13,7 +13,7 @@ const volatile bool do_count; const volatile int filter_ports_len; -SEC(".rodata") int filter_ports[MAX_PORTS]; +const volatile int filter_ports[MAX_PORTS]; const volatile pid_t filter_pid; const volatile uid_t filter_uid = -1; From ba0bacf1714c37e4e99dbdef5559039c28aa7aef Mon Sep 17 00:00:00 2001 From: He Zhe <zhe.he@windriver.com> Date: Thu, 9 Jul 2020 18:25:00 +0800 Subject: [PATCH 204/278] Add return value check and handling for xattr loading libbpf_find_vmlinux_btf_id may return error code for different reasons. We should check and report the error we have just got, rather than let it slip down the path and give an ambiguous error later. Signed-off-by: He Zhe <zhe.he@windriver.com> --- src/cc/libbpf.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index e912cbb4e..165c08869 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -588,8 +588,18 @@ int bcc_prog_load_xattr(struct bpf_load_program_attr *attr, int prog_len, if (attr->prog_type == BPF_PROG_TYPE_TRACING || attr->prog_type == BPF_PROG_TYPE_LSM) { - attr->attach_btf_id = libbpf_find_vmlinux_btf_id(attr->name + name_offset, - expected_attach_type); + ret = libbpf_find_vmlinux_btf_id(attr->name + name_offset, + expected_attach_type); + if (ret == -EINVAL) { + fprintf(stderr, "bpf: vmlinux BTF is not found\n"); + return ret; + } else if (ret < 0) { + fprintf(stderr, "bpf: %s is not found in vmlinux BTF\n", + attr->name + name_offset); + return ret; + } + + attr->attach_btf_id = ret; attr->expected_attach_type = expected_attach_type; } From 6889afe0858b38b93f2a2da3ca538343d05f5930 Mon Sep 17 00:00:00 2001 From: He Zhe <zhe.he@windriver.com> Date: Mon, 20 Jul 2020 18:31:56 +0800 Subject: [PATCH 205/278] tools/opensnoop: Snoop all open related syscall stubs kernel v5.6 introduces fddb5d430ad9 ("open: introduce openat2(2) syscall"). Even though do_sys_open still exists, it might be optimized off final binary depending on compilers. So we can't catch do_sys_open in some cases. This patch uses ksymname to try to get entries of open, openat and openat2, and changes the definitions of the trace functions to snoop them all. This works for both kprobe and kfunc. Credit to Yonghong Song for better code organization. Signed-off-by: He Zhe <zhe.he@windriver.com> --- tools/opensnoop.py | 149 ++++++++++++++++++++++++++++++++++++--------- 1 file changed, 119 insertions(+), 30 deletions(-) diff --git a/tools/opensnoop.py b/tools/opensnoop.py index 51d3dc055..3b508875f 100755 --- a/tools/opensnoop.py +++ b/tools/opensnoop.py @@ -112,8 +112,52 @@ bpf_text_kprobe = """ BPF_HASH(infotmp, u64, struct val_t); -int trace_entry(struct pt_regs *ctx, int dfd, const char __user *filename, int flags) +int trace_return(struct pt_regs *ctx) +{ + u64 id = bpf_get_current_pid_tgid(); + struct val_t *valp; + struct data_t data = {}; + + u64 tsp = bpf_ktime_get_ns(); + + valp = infotmp.lookup(&id); + if (valp == 0) { + // missed entry + return 0; + } + bpf_probe_read_kernel(&data.comm, sizeof(data.comm), valp->comm); + bpf_probe_read_user(&data.fname, sizeof(data.fname), (void *)valp->fname); + data.id = valp->id; + data.ts = tsp / 1000; + data.uid = bpf_get_current_uid_gid(); + data.flags = valp->flags; // EXTENDED_STRUCT_MEMBER + data.ret = PT_REGS_RC(ctx); + + events.perf_submit(ctx, &data, sizeof(data)); + infotmp.delete(&id); + + return 0; +} +""" + +bpf_text_kprobe_header_open = """ +int syscall__trace_entry_open(struct pt_regs *ctx, const char __user *filename, int flags) { +""" + +bpf_text_kprobe_header_openat = """ +int syscall__trace_entry_openat(struct pt_regs *ctx, int dfd, const char __user *filename, int flags) +{ +""" + +bpf_text_kprobe_header_openat2 = """ +#include <uapi/linux/openat2.h> +int syscall__trace_entry_openat2(struct pt_regs *ctx, int dfd, const char __user *filename, struct open_how *how) +{ + int flags = how->flags; +""" + +bpf_text_kprobe_body = """ struct val_t val = {}; u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part @@ -137,38 +181,50 @@ return 0; }; +""" -int trace_return(struct pt_regs *ctx) +bpf_text_kfunc_header_open = """ +#if defined(CONFIG_ARCH_HAS_SYSCALL_WRAPPER) && !defined(__s390x__) +KRETFUNC_PROBE(FNNAME, struct pt_regs *regs, int ret) { - u64 id = bpf_get_current_pid_tgid(); - struct val_t *valp; - struct data_t data = {}; - - u64 tsp = bpf_ktime_get_ns(); - - valp = infotmp.lookup(&id); - if (valp == 0) { - // missed entry - return 0; - } - bpf_probe_read_kernel(&data.comm, sizeof(data.comm), valp->comm); - bpf_probe_read_user(&data.fname, sizeof(data.fname), (void *)valp->fname); - data.id = valp->id; - data.ts = tsp / 1000; - data.uid = bpf_get_current_uid_gid(); - data.flags = valp->flags; // EXTENDED_STRUCT_MEMBER - data.ret = PT_REGS_RC(ctx); - - events.perf_submit(ctx, &data, sizeof(data)); - infotmp.delete(&id); + const char __user *filename = (char *)PT_REGS_PARM1(regs); + int flags = PT_REGS_PARM2(regs); +#else +KRETFUNC_PROBE(FNNAME, const char __user *filename, int flags, int ret) +{ +#endif +""" - return 0; -} +bpf_text_kfunc_header_openat = """ +#if defined(CONFIG_ARCH_HAS_SYSCALL_WRAPPER) && !defined(__s390x__) +KRETFUNC_PROBE(FNNAME, struct pt_regs *regs, int ret) +{ + int dfd = PT_REGS_PARM1(regs); + const char __user *filename = (char *)PT_REGS_PARM2(regs); + int flags = PT_REGS_PARM3(regs); +#else +KRETFUNC_PROBE(FNNAME, int dfd, const char __user *filename, int flags, int ret) +{ +#endif """ -bpf_text_kfunc= """ -KRETFUNC_PROBE(do_sys_open, int dfd, const char __user *filename, int flags, int mode, int ret) +bpf_text_kfunc_header_openat2 = """ +#include <uapi/linux/openat2.h> +#if defined(CONFIG_ARCH_HAS_SYSCALL_WRAPPER) && !defined(__s390x__) +KRETFUNC_PROBE(FNNAME, struct pt_regs *regs, int ret) { + int dfd = PT_REGS_PARM1(regs); + const char __user *filename = (char *)PT_REGS_PARM2(regs); + struct open_how __user *how = (struct open_how *)PT_REGS_PARM3(regs); + int flags = how->flags; +#else +KRETFUNC_PROBE(FNNAME, int dfd, const char __user *filename, struct open_how __user *how, int ret) +{ + int flags = how->flags; +#endif +""" + +bpf_text_kfunc_body = """ u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part u32 tid = id; // Cast and get the lower part @@ -199,12 +255,38 @@ } """ +b = BPF(text='') +# open and openat are always in place since 2.6.16 +fnname_open = b.get_syscall_prefix().decode() + 'open' +fnname_openat = b.get_syscall_prefix().decode() + 'openat' +fnname_openat2 = b.get_syscall_prefix().decode() + 'openat2' +if b.ksymname(fnname_openat2) == -1: + fnname_openat2 = None + is_support_kfunc = BPF.support_kfunc() if is_support_kfunc: - bpf_text += bpf_text_kfunc + bpf_text += bpf_text_kfunc_header_open.replace('FNNAME', fnname_open) + bpf_text += bpf_text_kfunc_body + + bpf_text += bpf_text_kfunc_header_openat.replace('FNNAME', fnname_openat) + bpf_text += bpf_text_kfunc_body + + if fnname_openat2: + bpf_text += bpf_text_kfunc_header_openat2.replace('FNNAME', fnname_openat2) + bpf_text += bpf_text_kfunc_body else: bpf_text += bpf_text_kprobe + bpf_text += bpf_text_kprobe_header_open + bpf_text += bpf_text_kprobe_body + + bpf_text += bpf_text_kprobe_header_openat + bpf_text += bpf_text_kprobe_body + + if fnname_openat2: + bpf_text += bpf_text_kprobe_header_openat2 + bpf_text += bpf_text_kprobe_body + if args.tid: # TID trumps PID bpf_text = bpf_text.replace('PID_TID_FILTER', 'if (tid != %s) { return 0; }' % args.tid) @@ -235,8 +317,15 @@ # initialize BPF b = BPF(text=bpf_text) if not is_support_kfunc: - b.attach_kprobe(event="do_sys_open", fn_name="trace_entry") - b.attach_kretprobe(event="do_sys_open", fn_name="trace_return") + b.attach_kprobe(event=fnname_open, fn_name="syscall__trace_entry_open") + b.attach_kretprobe(event=fnname_open, fn_name="trace_return") + + b.attach_kprobe(event=fnname_openat, fn_name="syscall__trace_entry_openat") + b.attach_kretprobe(event=fnname_openat, fn_name="trace_return") + + if fnname_openat2: + b.attach_kprobe(event=fnname_openat2, fn_name="syscall__trace_entry_openat2") + b.attach_kretprobe(event=fnname_openat2, fn_name="trace_return") initial_ts = 0 From 7ce6f646ec6002c0f9a2f2742dc63ed2613b13c3 Mon Sep 17 00:00:00 2001 From: Jerome Marchand <jmarchan@redhat.com> Date: Mon, 27 Jul 2020 15:36:28 +0200 Subject: [PATCH 206/278] man: fix tcpconnect man page Add -u and -U options to the synopsis. Move their description frome the example to the description section. Add a description to --mntnsmap option. --- man/man8/tcpconnect.8 | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/man/man8/tcpconnect.8 b/man/man8/tcpconnect.8 index 36247241d..c96058b0a 100644 --- a/man/man8/tcpconnect.8 +++ b/man/man8/tcpconnect.8 @@ -2,7 +2,7 @@ .SH NAME tcpconnect \- Trace TCP active connections (connect()). Uses Linux eBPF/bcc. .SH SYNOPSIS -.B tcpconnect [\-h] [\-c] [\-t] [\-p PID] [-P PORT] [\-\-cgroupmap MAPPATH] [\-\-mntnsmap MAPPATH] +.B tcpconnect [\-h] [\-c] [\-t] [\-p PID] [-P PORT] [-u UID] [-U] [\-\-cgroupmap MAPPATH] [\-\-mntnsmap MAPPATH] .SH DESCRIPTION This tool traces active TCP connections (eg, via a connect() syscall; accept() are passive connections). This can be useful for general @@ -34,16 +34,19 @@ Trace this process ID only (filtered in-kernel). \-P PORT Comma-separated list of destination ports to trace (filtered in-kernel). .TP -\-\-cgroupmap MAPPATH -Trace cgroups in this BPF map only (filtered in-kernel). -.SH EXAMPLES -.TP \-U Include a UID column. .TP \-u UID Trace this UID only (filtered in-kernel). .TP +\-\-cgroupmap MAPPATH +Trace cgroups in this BPF map only (filtered in-kernel). +.TP +\--mntnsmap MAPPATH +Trace mount namespaces in this BPF map only (filtered in-kernel). +.SH EXAMPLES +.TP Trace all active TCP connections: # .B tcpconnect From 7928ea0cd71aa8e794ed5ffdf0a6ff1004ab2849 Mon Sep 17 00:00:00 2001 From: cneira <cneirabustos@gmail.com> Date: Fri, 24 Jul 2020 13:22:25 -0400 Subject: [PATCH 207/278] Add example for new helper to documentation. --- docs/reference_guide.md | 19 +++++ .../tracing/hello_perf_output_using_ns.py | 75 +++++++++++++++++++ 2 files changed, 94 insertions(+) create mode 100755 examples/tracing/hello_perf_output_using_ns.py diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 6abb66c0b..561e8e7db 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -31,6 +31,7 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [9. bpf_get_prandom_u32()](#9-bpf_get_prandom_u32) - [10. bpf_probe_read_user()](#10-bpf_probe_read_user) - [11. bpf_probe_read_user_str()](#11-bpf_probe_read_user_str) + - [12. bpf_get_ns_current_pid_tgid()](#4-bpf_get_ns_current_pid_tgid) - [Debugging](#debugging) - [1. bpf_override_return()](#1-bpf_override_return) - [Output](#output) @@ -574,6 +575,24 @@ This copies a `NULL` terminated string from user address space to the BPF stack, Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=bpf_probe_read_user_str+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=bpf_probe_read_user_str+path%3Atools&type=Code) + + +### 12. bpf_get_ns_current_pid_tgid() + +Syntax: ```u32 bpf_get_ns_current_pid_tgid(u64 dev, u64 ino, struct bpf_pidns_info* nsdata, u32 size)``` + +Values for *pid* and *tgid* as seen from the current *namespace* will be returned in *nsdata*. + +Return 0 on success, or one of the following in case of failure: + +- **-EINVAL** if dev and inum supplied don't match dev_t and inode number with nsfs of current task, or if dev conversion to dev_t lost high bits. + +- **-ENOENT** if pidns does not exists for the current task. + +Examples in situ: +[search /examples](https://github.com/iovisor/bcc/search?q=bpf_get_ns_current_pid_tgid+path%3Aexamples&type=Code), +[search /tools](https://github.com/iovisor/bcc/search?q=bpf_get_ns_current_pid_tgid+path%3Atools&type=Code) + ## Debugging diff --git a/examples/tracing/hello_perf_output_using_ns.py b/examples/tracing/hello_perf_output_using_ns.py new file mode 100755 index 000000000..cc7eb9df9 --- /dev/null +++ b/examples/tracing/hello_perf_output_using_ns.py @@ -0,0 +1,75 @@ +#!/usr/bin/python +# Carlos Neira <cneirabustos@gmail.com> +# This is a Hello World example that uses BPF_PERF_OUTPUT. +# in this example bpf_get_ns_current_pid_tgid(), this helper +# works inside pid namespaces. +# bpf_get_current_pid_tgid() only returns the host pid outside any +# namespace and this will not work when the script is run inside a pid namespace. + +from bcc import BPF +from bcc.utils import printb +import sys, os +from stat import * + +# define BPF program +prog = """ +#include <linux/sched.h> + +// define output data structure in C +struct data_t { + u32 pid; + u64 ts; + char comm[TASK_COMM_LEN]; +}; +BPF_PERF_OUTPUT(events); + +int hello(struct pt_regs *ctx) { + struct data_t data = {}; + struct bpf_pidns_info ns = {}; + + if(bpf_get_ns_current_pid_tgid(DEV, INO, &ns, sizeof(struct bpf_pidns_info))) + return 0; + data.pid = ns.pid; + data.ts = bpf_ktime_get_ns(); + bpf_get_current_comm(&data.comm, sizeof(data.comm)); + + events.perf_submit(ctx, &data, sizeof(data)); + + return 0; +} +""" + +devinfo = os.stat("/proc/self/ns/pid") +for r in (("DEV", str(devinfo.st_dev)), ("INO", str(devinfo.st_ino))): + prog = prog.replace(*r) + +# load BPF program +b = BPF(text=prog) +b.attach_kprobe(event=b.get_syscall_fnname("clone"), fn_name="hello") + +# header +print("%-18s %-16s %-6s %s" % ("TIME(s)", "COMM", "PID", "MESSAGE")) + +# process event +start = 0 + + +def print_event(cpu, data, size): + global start + event = b["events"].event(data) + if start == 0: + start = event.ts + time_s = (float(event.ts - start)) / 1000000000 + printb( + b"%-18.9f %-16s %-6d %s" + % (time_s, event.comm, event.pid, b"Hello, perf_output!") + ) + + +# loop with callback to print_event +b["events"].open_perf_buffer(print_event) +while 1: + try: + b.perf_buffer_poll() + except KeyboardInterrupt: + exit() From ca5bcd21468709f0fb0e6c8122a48f859d80769b Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Mon, 27 Jul 2020 06:12:13 -0400 Subject: [PATCH 208/278] libbpf-tools: add CO-RE biopattern Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/biopattern.bpf.c | 44 +++++++ libbpf-tools/biopattern.c | 230 ++++++++++++++++++++++++++++++++++ libbpf-tools/biopattern.h | 11 ++ 5 files changed, 287 insertions(+) create mode 100644 libbpf-tools/biopattern.bpf.c create mode 100644 libbpf-tools/biopattern.c create mode 100644 libbpf-tools/biopattern.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index ccbbd42b2..73db7c56d 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -1,5 +1,6 @@ /.output /biolatency +/biopattern /bitesize /cpudist /drsnoop diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 299f7089d..1c4c81e64 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -11,6 +11,7 @@ ARCH := $(shell uname -m | sed 's/x86_64/x86/') APPS = \ biolatency \ + biopattern \ bitesize \ cpudist \ drsnoop \ diff --git a/libbpf-tools/biopattern.bpf.c b/libbpf-tools/biopattern.bpf.c new file mode 100644 index 000000000..673d23578 --- /dev/null +++ b/libbpf-tools/biopattern.bpf.c @@ -0,0 +1,44 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> +#include "biopattern.h" +#include "maps.bpf.h" + +const volatile dev_t targ_dev = -1; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, 64); + __type(key, dev_t); + __type(value, struct counter); + __uint(map_flags, BPF_F_NO_PREALLOC); +} counters SEC(".maps"); + +SEC("tracepoint/block/block_rq_complete") +int tp__block__block_rq_complete(struct trace_event_raw_block_rq_complete *ctx) +{ + sector_t *last_sectorp, sector = ctx->sector; + struct counter *counterp, zero = {}; + u32 nr_sector = ctx->nr_sector; + dev_t dev = ctx->dev; + + if (targ_dev != -1 && targ_dev != dev) + return 0; + + counterp = bpf_map_lookup_or_try_init(&counters, &dev, &zero); + if (!counterp) + return 0; + if (counterp->last_sector) { + if (counterp->last_sector == sector) + __sync_fetch_and_add(&counterp->sequential, 1); + else + __sync_fetch_and_add(&counterp->random, 1); + __sync_fetch_and_add(&counterp->bytes, nr_sector * 512); + } + counterp->last_sector = sector + nr_sector; + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/biopattern.c b/libbpf-tools/biopattern.c new file mode 100644 index 000000000..851412a07 --- /dev/null +++ b/libbpf-tools/biopattern.c @@ -0,0 +1,230 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on biopattern(8) from BPF-Perf-Tools-Book by Brendan Gregg. +// 17-Jun-2020 Wenbo Zhang Created this. +#include <argp.h> +#include <signal.h> +#include <stdio.h> +#include <unistd.h> +#include <time.h> +#include <bpf/libbpf.h> +#include <bpf/bpf.h> +#include "biopattern.h" +#include "biopattern.skel.h" +#include "trace_helpers.h" + +#define MINORBITS 20 +#define MINORMASK ((1U << MINORBITS) - 1) + +#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS)) +#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK)) +#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi)) + +static struct env { + time_t interval; + bool timestamp; + bool verbose; + int times; + __u32 dev; +} env = { + .interval = 99999999, + .times = 99999999, + .dev = -1, +}; + +static volatile bool exiting; + +const char *argp_program_version = "biopattern 0.1"; +const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char argp_program_doc[] = +"Show block device I/O pattern.\n" +"\n" +"USAGE: biopattern [-h] [-T] [-m] [interval] [count]\n" +"\n" +"EXAMPLES:\n" +" biopattern # show block I/O pattern\n" +" biopattern 1 10 # print 1 second summaries, 10 times\n" +" biopattern -T 1 # 1s summaries with timestamps\n" +" biopattern -d 8:0 # trace 8:0 only\n"; + +static const struct argp_option opts[] = { + { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, + { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, + { "dev", 'd', "DEV", 0, "Trace this dev only" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static __u32 major, minor; + static int pos_args; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'h': + argp_usage(state); + break; + case 'd': + sscanf(arg,"%d:%d", &major, &minor); + env.dev = MKDEV(major, minor); + break; + case 'T': + env.timestamp = true; + break; + case ARGP_KEY_ARG: + errno = 0; + if (pos_args == 0) { + env.interval = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid internal\n"); + argp_usage(state); + } + } else if (pos_args == 1) { + env.times = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid times\n"); + argp_usage(state); + } + } else { + fprintf(stderr, + "unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + pos_args++; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void sig_handler(int sig) +{ + exiting = true; +} + +static int print_map(int fd) +{ + __u32 total, lookup_key = -1, next_key; + struct counter counter; + struct tm *tm; + char ts[32]; + time_t t; + int err; + + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_lookup_elem(fd, &next_key, &counter); + if (err < 0) { + fprintf(stderr, "failed to lookup counters: %d\n", err); + return -1; + } + lookup_key = next_key; + total = counter.sequential + counter.random; + if (!total) + continue; + if (env.timestamp) { + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + printf("%-9s ", ts); + } + printf("%3d:%-2d %5ld %5ld %8d %10lld\n", MAJOR(next_key), + MINOR(next_key), counter.random * 100L / total, + counter.sequential * 100L / total, total, + counter.bytes / 1024); + } + + lookup_key = -1; + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_delete_elem(fd, &next_key); + if (err < 0) { + fprintf(stderr, "failed to cleanup counters: %d\n", err); + return -1; + } + lookup_key = next_key; + } + + return 0; +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct biopattern_bpf *obj; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = biopattern_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + return 1; + } + + if (env.dev != -1) + obj->rodata->targ_dev = env.dev; + + err = biopattern_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + err = biopattern_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs\n"); + goto cleanup; + } + + signal(SIGINT, sig_handler); + + printf("Tracing block device I/O requested seeks... Hit Ctrl-C to " + "end.\n"); + if (env.timestamp) + printf("%-9s ", "TIME"); + printf("%-6s %5s %5s %8s %10s\n", " DEV", "%RND", "%SEQ", + "COUNT", "KBYTES"); + + /* main: poll */ + while (1) { + sleep(env.interval); + + err = print_map(bpf_map__fd(obj->maps.counters)); + if (err) + break; + + if (exiting || --env.times == 0) + break; + } + +cleanup: + biopattern_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/biopattern.h b/libbpf-tools/biopattern.h new file mode 100644 index 000000000..e23982e25 --- /dev/null +++ b/libbpf-tools/biopattern.h @@ -0,0 +1,11 @@ +#ifndef __BIOPATTERN_H +#define __BIOPATTERN_H + +struct counter { + __u64 last_sector; + __u64 bytes; + __u32 sequential; + __u32 random; +}; + +#endif /* __BIOPATTERN_H */ From b6ffa245cc4cd1ba41600f10062f820b6452a69d Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Wed, 22 Jul 2020 04:18:30 -0400 Subject: [PATCH 209/278] libbpf-tools: add CO-RE tcpconnlat Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/tcpconnlat.bpf.c | 107 +++++++++++++++++ libbpf-tools/tcpconnlat.c | 209 ++++++++++++++++++++++++++++++++++ libbpf-tools/tcpconnlat.h | 24 ++++ 5 files changed, 342 insertions(+) create mode 100644 libbpf-tools/tcpconnlat.bpf.c create mode 100644 libbpf-tools/tcpconnlat.c create mode 100644 libbpf-tools/tcpconnlat.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 73db7c56d..a42f9057f 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -10,5 +10,6 @@ /runqslower /syscount /tcpconnect +/tcpconnlat /vfsstat /xfsslower diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 1c4c81e64..c0f742afb 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -21,6 +21,7 @@ APPS = \ runqslower \ syscount \ tcpconnect \ + tcpconnlat \ vfsstat \ xfsslower \ # diff --git a/libbpf-tools/tcpconnlat.bpf.c b/libbpf-tools/tcpconnlat.bpf.c new file mode 100644 index 000000000..b6c36112f --- /dev/null +++ b/libbpf-tools/tcpconnlat.bpf.c @@ -0,0 +1,107 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_core_read.h> +#include <bpf/bpf_tracing.h> +#include "tcpconnlat.h" + +#define AF_INET 2 +#define AF_INET6 10 + +const volatile __u64 targ_min_us = 0; +const volatile pid_t targ_tgid = 0; + +struct piddata { + char comm[TASK_COMM_LEN]; + u64 ts; + u32 tgid; +}; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, 4096); + __type(key, struct sock *); + __type(value, struct piddata); +} start SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY); + __uint(key_size, sizeof(u32)); + __uint(value_size, sizeof(u32)); +} events SEC(".maps"); + +static __always_inline int trace_connect(struct sock *sk) +{ + u32 tgid = bpf_get_current_pid_tgid() >> 32; + struct piddata piddata = {}; + + if (targ_tgid && targ_tgid != tgid) + return 0; + + bpf_get_current_comm(&piddata.comm, sizeof(piddata.comm)); + piddata.ts = bpf_ktime_get_ns(); + piddata.tgid = tgid; + bpf_map_update_elem(&start, &sk, &piddata, 0); + return 0; +} + +SEC("fentry/tcp_v4_connect") +int BPF_PROG(fentry__tcp_v4_connect, struct sock *sk) +{ + return trace_connect(sk); +} + +SEC("kprobe/tcp_v6_connect") +int BPF_KPROBE(kprobe__tcp_v6_connect, struct sock *sk) +{ + return trace_connect(sk); +} + +SEC("fentry/tcp_rcv_state_process") +int BPF_PROG(fentry__tcp_rcv_state_process, struct sock *sk) +{ + struct piddata *piddatap; + struct event event = {}; + s64 delta; + u64 ts; + + if (sk->__sk_common.skc_state != TCP_SYN_SENT) + return 0; + + piddatap = bpf_map_lookup_elem(&start, &sk); + if (!piddatap) + return 0; + + ts = bpf_ktime_get_ns(); + delta = (s64)(ts - piddatap->ts); + if (delta < 0) + goto cleanup; + + event.delta_us = delta / 1000; + if (targ_min_us && event.delta_us < targ_min_us) + goto cleanup; + __builtin_memcpy(&event.comm, piddatap->comm, + sizeof(event.comm)); + event.ts_us = ts / 1000; + event.tgid = piddatap->tgid; + event.dport = sk->__sk_common.skc_dport; + event.af = sk->__sk_common.skc_family; + if (event.af == AF_INET) { + event.saddr_v4 = sk->__sk_common.skc_rcv_saddr; + event.daddr_v4 = sk->__sk_common.skc_daddr; + } else { + BPF_CORE_READ_INTO(&event.saddr_v6, sk, + __sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); + BPF_CORE_READ_INTO(&event.daddr_v6, sk, + __sk_common.skc_v6_daddr.in6_u.u6_addr32); + } + bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, + &event, sizeof(event)); + +cleanup: + bpf_map_delete_elem(&start, &sk); + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/tcpconnlat.c b/libbpf-tools/tcpconnlat.c new file mode 100644 index 000000000..18dba628a --- /dev/null +++ b/libbpf-tools/tcpconnlat.c @@ -0,0 +1,209 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on tcpconnlat(8) from BCC by Brendan Gregg. +// 11-Jul-2020 Wenbo Zhang Created this. +#include <argp.h> +#include <arpa/inet.h> +#include <stdio.h> +#include <unistd.h> +#include <time.h> +#include <bpf/libbpf.h> +#include <bpf/bpf.h> +#include "tcpconnlat.h" +#include "tcpconnlat.skel.h" +#include "trace_helpers.h" + +#define PERF_BUFFER_PAGES 16 +#define PERF_POLL_TIMEOUT_MS 100 + +static struct env { + __u64 min_us; + pid_t pid; + bool timestamp; + bool verbose; +} env; + +const char *argp_program_version = "tcpconnlat 0.1"; +const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char argp_program_doc[] = +"\nTrace TCP connects and show connection latency.\n" +"\n" +"USAGE: tcpconnlat [-h] [-t] [-p PID]\n" +"\n" +"EXAMPLES:\n" +" tcpconnlat # summarize on-CPU time as a histogram" +" tcpconnlat 1 # trace connection latency slower than 1 ms" +" tcpconnlat 0.1 # trace connection latency slower than 100 us" +" tcpconnlat -t # 1s summaries, milliseconds, and timestamps" +" tcpconnlat -p 185 # trace PID 185 only"; + +static const struct argp_option opts[] = { + { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, + { "timestamp", 't', NULL, 0, "Include timestamp on output" }, + { "pid", 'p', "PID", 0, "Trace this PID only" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static int pos_args; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'h': + argp_usage(state); + break; + case 'p': + errno = 0; + env.pid = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid PID: %s\n", arg); + argp_usage(state); + } + break; + case 't': + env.timestamp = true; + break; + case ARGP_KEY_ARG: + if (pos_args++) { + fprintf(stderr, + "Unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + errno = 0; + env.min_us = strtod(arg, NULL) * 1000; + if (errno || env.min_us <= 0) { + fprintf(stderr, "Invalid delay (in us): %s\n", arg); + argp_usage(state); + } + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) +{ + const struct event *e = data; + char src[INET6_ADDRSTRLEN]; + char dst[INET6_ADDRSTRLEN]; + union { + struct in_addr x4; + struct in6_addr x6; + } s, d; + static __u64 start_ts; + + if (env.timestamp) { + if (start_ts == 0) + start_ts = e->ts_us; + printf("%-9.3f ", (e->ts_us - start_ts) / 1000000.0); + } + if (e->af == AF_INET) { + s.x4.s_addr = e->saddr_v4; + d.x4.s_addr = e->daddr_v4; + } else if (e->af == AF_INET6) { + memcpy(&s.x6.s6_addr, &e->saddr_v6, sizeof(s.x6.s6_addr)); + memcpy(&d.x6.s6_addr, &e->daddr_v6, sizeof(d.x6.s6_addr)); + } else { + fprintf(stderr, "broken event: event->af=%d", e->af); + return; + } + + printf("%-6d %-12.12s %-2d %-16s %-16s %-5d %.2f\n", e->tgid, e->comm, + e->af == AF_INET ? 4 : 6, inet_ntop(e->af, &s, src, sizeof(src)), + inet_ntop(e->af, &d, dst, sizeof(dst)), ntohs(e->dport), + e->delta_us / 1000.0); +} + +void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt) +{ + fprintf(stderr, "lost %llu events on CPU #%d\n", lost_cnt, cpu); +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct perf_buffer_opts pb_opts; + struct perf_buffer *pb = NULL; + struct tcpconnlat_bpf *obj; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = tcpconnlat_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + return 1; + } + + /* initialize global data (filtering options) */ + obj->rodata->targ_min_us = env.min_us; + obj->rodata->targ_tgid = env.pid; + + err = tcpconnlat_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + err = tcpconnlat_bpf__attach(obj); + if (err) { + goto cleanup; + } + + pb_opts.sample_cb = handle_event; + + pb_opts.lost_cb = handle_lost_events; + pb = perf_buffer__new(bpf_map__fd(obj->maps.events), PERF_BUFFER_PAGES, + &pb_opts); + err = libbpf_get_error(pb); + if (err) { + pb = NULL; + fprintf(stderr, "failed to open perf buffer: %d\n", err); + goto cleanup; + } + + if (env.timestamp) + printf("%-9s ", ("TIME(s)")); + printf("%-6s %-12s %-2s %-16s %-16s %-5s %s\n", + "PID", "COMM", "IP", "SADDR", "DADDR", "DPORT", "LAT(ms)"); + + /* main: poll */ + while (1) { + if ((err = perf_buffer__poll(pb, PERF_POLL_TIMEOUT_MS)) < 0) + break; + } + printf("error polling perf buffer: %d\n", err); + +cleanup: + tcpconnlat_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/tcpconnlat.h b/libbpf-tools/tcpconnlat.h new file mode 100644 index 000000000..11524a756 --- /dev/null +++ b/libbpf-tools/tcpconnlat.h @@ -0,0 +1,24 @@ +#ifndef __TCPCONNLAT_H +#define __TCPCONNLAT_H + +#define TASK_COMM_LEN 16 + +struct event { + union { + __u32 saddr_v4; + unsigned __int128 saddr_v6; + }; + union { + __u32 daddr_v4; + unsigned __int128 daddr_v6; + }; + char comm[TASK_COMM_LEN]; + __u64 delta_us; + __u64 ts_us; + __u32 tgid; + int af; + __u16 dport; +}; + + +#endif /* __TCPCONNLAT_H_ */ From 8a164f95ee708495a89a43a243fdb5c8b7eee290 Mon Sep 17 00:00:00 2001 From: Yonghong Song <yhs@fb.com> Date: Thu, 30 Jul 2020 11:32:49 -0700 Subject: [PATCH 210/278] sync with latest libbpf repo sync with latest libbpf repo Signed-off-by: Yonghong Song <yhs@fb.com> --- introspection/bps.c | 1 + src/cc/compat/linux/virtual_bpf.h | 115 ++++++++++++++++++++++++++++-- src/cc/export/helpers.h | 2 +- src/cc/libbpf | 2 +- 4 files changed, 114 insertions(+), 6 deletions(-) diff --git a/introspection/bps.c b/introspection/bps.c index 7330d8117..9d7659e3e 100644 --- a/introspection/bps.c +++ b/introspection/bps.c @@ -46,6 +46,7 @@ static const char * const prog_type_strings[] = { [BPF_PROG_TYPE_STRUCT_OPS] = "struct_ops", [BPF_PROG_TYPE_EXT] = "ext", [BPF_PROG_TYPE_LSM] = "lsm", + [BPF_PROG_TYPE_SK_LOOKUP] = "sk_lookup", }; static const char * const map_type_strings[] = { diff --git a/src/cc/compat/linux/virtual_bpf.h b/src/cc/compat/linux/virtual_bpf.h index 26c57a7eb..c1eef179c 100644 --- a/src/cc/compat/linux/virtual_bpf.h +++ b/src/cc/compat/linux/virtual_bpf.h @@ -190,6 +190,7 @@ enum bpf_prog_type { BPF_PROG_TYPE_STRUCT_OPS, BPF_PROG_TYPE_EXT, BPF_PROG_TYPE_LSM, + BPF_PROG_TYPE_SK_LOOKUP, }; enum bpf_attach_type { @@ -227,6 +228,10 @@ enum bpf_attach_type { BPF_CGROUP_INET4_GETSOCKNAME, BPF_CGROUP_INET6_GETSOCKNAME, BPF_XDP_DEVMAP, + BPF_CGROUP_INET_SOCK_RELEASE, + BPF_XDP_CPUMAP, + BPF_SK_LOOKUP, + BPF_XDP, __MAX_BPF_ATTACH_TYPE }; @@ -239,10 +244,18 @@ enum bpf_link_type { BPF_LINK_TYPE_CGROUP = 3, BPF_LINK_TYPE_ITER = 4, BPF_LINK_TYPE_NETNS = 5, + BPF_LINK_TYPE_XDP = 6, MAX_BPF_LINK_TYPE, }; +enum bpf_iter_link_info { + BPF_ITER_LINK_UNSPEC = 0, + BPF_ITER_LINK_MAP_FD = 1, + + MAX_BPF_ITER_LINK_INFO, +}; + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command * * NONE(default): No further bpf programs allowed in the subtree. @@ -604,7 +617,10 @@ union bpf_attr { struct { /* struct used by BPF_LINK_CREATE command */ __u32 prog_fd; /* eBPF program to attach */ - __u32 target_fd; /* object to attach to */ + union { + __u32 target_fd; /* object to attach to */ + __u32 target_ifindex; /* target ifindex */ + }; __u32 attach_type; /* attach type */ __u32 flags; /* extra flags */ } link_create; @@ -2419,7 +2435,7 @@ union bpf_attr { * Look for an IPv6 socket. * * If the *netns* is a negative signed 32-bit integer, then the - * socket lookup table in the netns associated with the *ctx* will + * socket lookup table in the netns associated with the *ctx* * will be used. For the TC hooks, this is the netns of the device * in the skb. For socket hooks, this is the netns of the socket. * If *netns* is any other signed 32-bit value greater than or @@ -2456,7 +2472,7 @@ union bpf_attr { * Look for an IPv6 socket. * * If the *netns* is a negative signed 32-bit integer, then the - * socket lookup table in the netns associated with the *ctx* will + * socket lookup table in the netns associated with the *ctx* * will be used. For the TC hooks, this is the netns of the device * in the skb. For socket hooks, this is the netns of the socket. * If *netns* is any other signed 32-bit value greater than or @@ -3068,6 +3084,10 @@ union bpf_attr { * * long bpf_sk_assign(struct sk_buff *skb, struct bpf_sock *sk, u64 flags) * Description + * Helper is overloaded depending on BPF program type. This + * description applies to **BPF_PROG_TYPE_SCHED_CLS** and + * **BPF_PROG_TYPE_SCHED_ACT** programs. + * * Assign the *sk* to the *skb*. When combined with appropriate * routing configuration to receive the packet towards the socket, * will cause *skb* to be delivered to the specified socket. @@ -3093,6 +3113,56 @@ union bpf_attr { * **-ESOCKTNOSUPPORT** if the socket type is not supported * (reuseport). * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This + * description applies to **BPF_PROG_TYPE_SK_LOOKUP** programs. + * + * Select the *sk* as a result of a socket lookup. + * + * For the operation to succeed passed socket must be compatible + * with the packet description provided by the *ctx* object. + * + * L4 protocol (**IPPROTO_TCP** or **IPPROTO_UDP**) must + * be an exact match. While IP family (**AF_INET** or + * **AF_INET6**) must be compatible, that is IPv6 sockets + * that are not v6-only can be selected for IPv4 packets. + * + * Only TCP listeners and UDP unconnected sockets can be + * selected. *sk* can also be NULL to reset any previous + * selection. + * + * *flags* argument can combination of following values: + * + * * **BPF_SK_LOOKUP_F_REPLACE** to override the previous + * socket selection, potentially done by a BPF program + * that ran before us. + * + * * **BPF_SK_LOOKUP_F_NO_REUSEPORT** to skip + * load-balancing within reuseport group for the socket + * being selected. + * + * On success *ctx->sk* will point to the selected socket. + * + * Return + * 0 on success, or a negative errno in case of failure. + * + * * **-EAFNOSUPPORT** if socket family (*sk->family*) is + * not compatible with packet family (*ctx->family*). + * + * * **-EEXIST** if socket has been already selected, + * potentially by another program, and + * **BPF_SK_LOOKUP_F_REPLACE** flag was not specified. + * + * * **-EINVAL** if unsupported flags were specified. + * + * * **-EPROTOTYPE** if socket L4 protocol + * (*sk->protocol*) doesn't match packet protocol + * (*ctx->protocol*). + * + * * **-ESOCKTNOSUPPORT** if socket is not in allowed + * state (TCP listening or UDP unconnected). + * * u64 bpf_ktime_get_boot_ns(void) * Description * Return the time elapsed since system boot, in nanoseconds. @@ -3606,6 +3676,12 @@ enum { BPF_RINGBUF_HDR_SZ = 8, }; +/* BPF_FUNC_sk_assign flags in bpf_sk_lookup context. */ +enum { + BPF_SK_LOOKUP_F_REPLACE = (1ULL << 0), + BPF_SK_LOOKUP_F_NO_REUSEPORT = (1ULL << 1), +}; + /* Mode for BPF_FUNC_skb_adjust_room helper. */ enum bpf_adj_room_mode { BPF_ADJ_ROOM_NET, @@ -3849,6 +3925,19 @@ struct bpf_devmap_val { } bpf_prog; }; +/* CPUMAP map-value layout + * + * The struct data-layout of map-value is a configuration interface. + * New members can only be added to the end of this structure. + */ +struct bpf_cpumap_val { + __u32 qsize; /* queue size to remote target CPU */ + union { + int fd; /* prog fd on map write */ + __u32 id; /* prog id on map read */ + } bpf_prog; +}; + enum sk_action { SK_DROP = 0, SK_PASS, @@ -3981,12 +4070,15 @@ struct bpf_link_info { __u32 netns_ino; __u32 attach_type; } netns; + struct { + __u32 ifindex; + } xdp; }; } __attribute__((aligned(8))); /* User bpf_sock_addr struct to access socket fields and sockaddr struct passed * by user and intended to be used by socket (e.g. to bind to, depends on - * attach attach type). + * attach type). */ struct bpf_sock_addr { __u32 user_family; /* Allows 4-byte read, but no write. */ @@ -4335,5 +4427,20 @@ struct bpf_pidns_info { __u32 pid; __u32 tgid; }; + +/* User accessible data for SK_LOOKUP programs. Add new fields at the end. */ +struct bpf_sk_lookup { + __bpf_md_ptr(struct bpf_sock *, sk); /* Selected socket */ + + __u32 family; /* Protocol family (AF_INET, AF_INET6) */ + __u32 protocol; /* IP protocol (IPPROTO_TCP, IPPROTO_UDP) */ + __u32 remote_ip4; /* Network byte order */ + __u32 remote_ip6[4]; /* Network byte order */ + __u32 remote_port; /* Network byte order */ + __u32 local_ip4; /* Network byte order */ + __u32 local_ip6[4]; /* Network byte order */ + __u32 local_port; /* Host byte order */ +}; + #endif /* _UAPI__LINUX_BPF_H__ */ )********" diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index bb6531bdc..d1807a7c2 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -712,7 +712,7 @@ static __u64 (*bpf_get_current_ancestor_cgroup_id)(int ancestor_level) = (void *)BPF_FUNC_get_current_ancestor_cgroup_id; struct sk_buff; -static int (*bpf_sk_assign)(struct sk_buff *skb, struct bpf_sock *sk, __u64 flags) = +static int (*bpf_sk_assign)(void *skb, struct bpf_sock *sk, __u64 flags) = (void *)BPF_FUNC_sk_assign; static __u64 (*bpf_ktime_get_boot_ns)(void) = (void *)BPF_FUNC_ktime_get_boot_ns; diff --git a/src/cc/libbpf b/src/cc/libbpf index 5020fdf8f..734b3f0af 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit 5020fdf8fc6cbc770ec7b2c4f686b97f134e3061 +Subproject commit 734b3f0afe96354cc1a3932c02adcca42ee11bda From e0e2215833999998b9d654a0a5056d889457b005 Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Tue, 28 Jul 2020 21:31:46 -0400 Subject: [PATCH 211/278] libbpf-tools: add CO-RE biosnoop Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/biosnoop.bpf.c | 166 ++++++++++++++++++++ libbpf-tools/biosnoop.c | 295 ++++++++++++++++++++++++++++++++++++ libbpf-tools/biosnoop.h | 20 +++ 5 files changed, 483 insertions(+) create mode 100644 libbpf-tools/biosnoop.bpf.c create mode 100644 libbpf-tools/biosnoop.c create mode 100644 libbpf-tools/biosnoop.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index a42f9057f..b9f1784eb 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -1,6 +1,7 @@ /.output /biolatency /biopattern +/biosnoop /bitesize /cpudist /drsnoop diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index c0f742afb..be1c689da 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -12,6 +12,7 @@ ARCH := $(shell uname -m | sed 's/x86_64/x86/') APPS = \ biolatency \ biopattern \ + biosnoop \ bitesize \ cpudist \ drsnoop \ diff --git a/libbpf-tools/biosnoop.bpf.c b/libbpf-tools/biosnoop.bpf.c new file mode 100644 index 000000000..31545608c --- /dev/null +++ b/libbpf-tools/biosnoop.bpf.c @@ -0,0 +1,166 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_core_read.h> +#include <bpf/bpf_tracing.h> +#include "biosnoop.h" + +#define MAX_ENTRIES 10240 + +const volatile char targ_disk[DISK_NAME_LEN] = {}; +const volatile bool targ_queued = false; + +struct piddata { + char comm[TASK_COMM_LEN]; + u32 pid; +}; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, struct request *); + __type(value, struct piddata); + __uint(map_flags, BPF_F_NO_PREALLOC); +} infobyreq SEC(".maps"); + +struct stage { + u64 insert; + u64 issue; +}; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, struct request *); + __type(value, struct stage); +} start SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY); + __uint(key_size, sizeof(u32)); + __uint(value_size, sizeof(u32)); +} events SEC(".maps"); + +static __always_inline +int trace_pid(struct request *rq) +{ + u64 id = bpf_get_current_pid_tgid(); + struct piddata piddata = {}; + + piddata.pid = id; + bpf_get_current_comm(&piddata.comm, sizeof(&piddata.comm)); + bpf_map_update_elem(&infobyreq, &rq, &piddata, 0); + return 0; +} + +SEC("fentry/blk_account_io_start") +int BPF_PROG(fentry__blk_account_io_start, struct request *rq) +{ + return trace_pid(rq); +} + +SEC("kprobe/blk_account_io_merge_bio") +int BPF_KPROBE(kprobe__blk_account_io_merge_bio, struct request *rq) +{ + return trace_pid(rq); +} + +static __always_inline bool disk_filtered(const char *disk) +{ + int i; + + for (i = 0; targ_disk[i] != '\0' && i < DISK_NAME_LEN; i++) { + if (disk[i] != targ_disk[i]) + return false; + } + return true; +} + +static __always_inline +int trace_rq_start(struct request *rq, bool insert) +{ + struct stage *stagep, stage = {}; + u64 ts = bpf_ktime_get_ns(); + char disk[DISK_NAME_LEN]; + + stagep = bpf_map_lookup_elem(&start, &rq); + if (!stagep) { + bpf_probe_read_kernel_str(&disk, sizeof(disk), + rq->rq_disk->disk_name); + if (!disk_filtered(disk)) { + bpf_map_delete_elem(&infobyreq, &rq); + return 0; + } + stagep = &stage; + } + if (insert) + stagep->insert = ts; + else + stagep->issue = ts; + if (stagep == &stage) + bpf_map_update_elem(&start, &rq, stagep, 0); + return 0; +} + +SEC("tp_btf/block_rq_insert") +int BPF_PROG(tp_btf__block_rq_insert, struct request_queue *q, + struct request *rq) +{ + return trace_rq_start(rq, true); +} + +SEC("tp_btf/block_rq_issue") +int BPF_PROG(tp_btf__block_rq_issue, struct request_queue *q, + struct request *rq) +{ + return trace_rq_start(rq, false); +} + +SEC("tp_btf/block_rq_complete") +int BPF_PROG(tp_btf__block_rq_complete, struct request *rq, int error, + unsigned int nr_bytes) +{ + u64 slot, ts = bpf_ktime_get_ns(); + struct piddata *piddatap; + struct event event = {}; + struct stage *stagep; + s64 delta; + + stagep = bpf_map_lookup_elem(&start, &rq); + if (!stagep) + return 0; + delta = (s64)(ts - stagep->issue); + if (delta < 0) + goto cleanup; + piddatap = bpf_map_lookup_elem(&infobyreq, &rq); + if (!piddatap) { + event.comm[0] = '?'; + } else { + __builtin_memcpy(&event.comm, piddatap->comm, + sizeof(event.comm)); + event.pid = piddatap->pid; + } + event.delta = delta; + if (targ_queued && BPF_CORE_READ(rq, q, elevator)) { + if (!stagep->insert) + event.qdelta = -1; /* missed or don't insert entry */ + else + event.qdelta = stagep->issue - stagep->insert; + } + event.ts = ts; + event.sector = rq->__sector; + event.len = rq->__data_len; + event.cmd_flags = rq->cmd_flags; + bpf_probe_read_kernel_str(&event.disk, sizeof(event.disk), + rq->rq_disk->disk_name); + bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, &event, + sizeof(event)); + +cleanup: + bpf_map_delete_elem(&start, &rq); + bpf_map_delete_elem(&infobyreq, &rq); + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/biosnoop.c b/libbpf-tools/biosnoop.c new file mode 100644 index 000000000..2811c6d4a --- /dev/null +++ b/libbpf-tools/biosnoop.c @@ -0,0 +1,295 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on biosnoop(8) from BCC by Brendan Gregg. +// 29-Jun-2020 Wenbo Zhang Created this. +#include <argp.h> +#include <stdio.h> +#include <unistd.h> +#include <time.h> +#include <bpf/libbpf.h> +#include <sys/resource.h> +#include <bpf/bpf.h> +#include "blk_types.h" +#include "biosnoop.h" +#include "biosnoop.skel.h" +#include "trace_helpers.h" + +#define PERF_BUFFER_PAGES 16 +#define PERF_POLL_TIMEOUT_MS 100 + +static struct env { + char *disk; + int disk_len; + int duration; + bool timestamp; + bool queued; + bool verbose; +} env = {}; + +static volatile __u64 start_ts; + +const char *argp_program_version = "biosnoop 0.1"; +const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char argp_program_doc[] = +"Summarize block device I/O latency as a histogram.\n" +"\n" +"USAGE: biosnoop [-h] [-T] [-Q]\n" +"\n" +"EXAMPLES:\n" +" biosnoop # summarize block I/O latency as a histogram\n" +" biosnoop -Q # include OS queued time in I/O time\n" +" biosnoop 10 # trace for 10 seconds only\n" +" biosnoop -d sdc # trace sdc only\n"; + +static const struct argp_option opts[] = { + { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, + { "queued", 'Q', NULL, 0, "Include OS queued time in I/O time" }, + { "disk", 'd', "DISK", 0, "Trace this disk only" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static int pos_args; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'h': + argp_usage(state); + break; + case 'Q': + env.queued = true; + break; + case 'd': + env.disk = arg; + env.disk_len = strlen(arg) + 1; + if (env.disk_len > DISK_NAME_LEN) { + fprintf(stderr, "invaild disk name: too long\n"); + argp_usage(state); + } + break; + case ARGP_KEY_ARG: + if (pos_args++) { + fprintf(stderr, + "unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + errno = 0; + env.duration = strtoll(arg, NULL, 10); + if (errno || env.duration <= 0) { + fprintf(stderr, "invalid delay (in us): %s\n", arg); + argp_usage(state); + } + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void blk_fill_rwbs(char *rwbs, unsigned int op) +{ + int i = 0; + + if (op & REQ_PREFLUSH) + rwbs[i++] = 'F'; + + switch (op & REQ_OP_MASK) { + case REQ_OP_WRITE: + case REQ_OP_WRITE_SAME: + rwbs[i++] = 'W'; + break; + case REQ_OP_DISCARD: + rwbs[i++] = 'D'; + break; + case REQ_OP_SECURE_ERASE: + rwbs[i++] = 'D'; + rwbs[i++] = 'E'; + break; + case REQ_OP_FLUSH: + rwbs[i++] = 'F'; + break; + case REQ_OP_READ: + rwbs[i++] = 'R'; + break; + default: + rwbs[i++] = 'N'; + } + + if (op & REQ_FUA) + rwbs[i++] = 'F'; + if (op & REQ_RAHEAD) + rwbs[i++] = 'A'; + if (op & REQ_SYNC) + rwbs[i++] = 'S'; + if (op & REQ_META) + rwbs[i++] = 'M'; + + rwbs[i] = '\0'; +} + +void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) +{ + const struct event *e = data; + char rwbs[RWBS_LEN]; + + if (!start_ts) + start_ts = e->ts; + blk_fill_rwbs(rwbs, e->cmd_flags); + printf("%-11.6f %-14.14s %-6d %-7s %-4s %-10lld %-7d ", + (e->ts - start_ts) / 1000000000.0, + e->comm, e->pid, e->disk, rwbs, e->sector, e->len); + if (env.queued) + printf("%7.3f ", e->qdelta != -1 ? + e->qdelta / 1000000.0 : -1); + printf("%7.3f\n", e->delta / 1000000.0); +} + +void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt) +{ + fprintf(stderr, "lost %llu events on CPU #%d\n", lost_cnt, cpu); +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct perf_buffer_opts pb_opts; + struct perf_buffer *pb = NULL; + struct ksyms *ksyms = NULL; + struct biosnoop_bpf *obj; + __u64 time_end = 0; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = biosnoop_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + return 1; + } + + /* initialize global data (filtering options) */ + if (env.disk) + strncpy((char*)obj->rodata->targ_disk, env.disk, env.disk_len); + obj->rodata->targ_queued = env.queued; + + err = biosnoop_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + obj->links.fentry__blk_account_io_start = + bpf_program__attach(obj->progs.fentry__blk_account_io_start); + err = libbpf_get_error(obj->links.fentry__blk_account_io_start); + if (err) { + fprintf(stderr, "failed to attach blk_account_io_start: %s\n", + strerror(err)); + goto cleanup; + } + ksyms = ksyms__load(); + if (!ksyms) { + fprintf(stderr, "failed to load kallsyms\n"); + goto cleanup; + } + if (ksyms__get_symbol(ksyms, "blk_account_io_merge_bio")) { + obj->links.kprobe__blk_account_io_merge_bio = + bpf_program__attach(obj-> + progs.kprobe__blk_account_io_merge_bio); + err = libbpf_get_error(obj-> + links.kprobe__blk_account_io_merge_bio); + if (err) { + fprintf(stderr, "failed to attach " + "blk_account_io_merge_bio: %s\n", + strerror(err)); + goto cleanup; + } + } + if (env.queued) { + obj->links.tp_btf__block_rq_insert = + bpf_program__attach(obj->progs.tp_btf__block_rq_insert); + err = libbpf_get_error(obj->links.tp_btf__block_rq_insert); + if (err) { + fprintf(stderr, "failed to attach block_rq_insert: %s\n", + strerror(err)); + goto cleanup; + } + } + obj->links.tp_btf__block_rq_issue = + bpf_program__attach(obj->progs.tp_btf__block_rq_issue); + err = libbpf_get_error(obj->links.tp_btf__block_rq_issue); + if (err) { + fprintf(stderr, "failed to attach block_rq_issue: %s\n", + strerror(err)); + goto cleanup; + } + obj->links.tp_btf__block_rq_complete = + bpf_program__attach(obj->progs.tp_btf__block_rq_complete); + err = libbpf_get_error(obj->links.tp_btf__block_rq_complete); + if (err) { + fprintf(stderr, "failed to attach block_rq_complete: %s\n", + strerror(err)); + goto cleanup; + } + + pb_opts.sample_cb = handle_event; + pb_opts.lost_cb = handle_lost_events; + pb = perf_buffer__new(bpf_map__fd(obj->maps.events), PERF_BUFFER_PAGES, + &pb_opts); + err = libbpf_get_error(pb); + if (err) { + pb = NULL; + fprintf(stderr, "failed to open perf buffer: %d\n", err); + goto cleanup; + } + + printf("%-11s %-14s %-6s %-7s %-4s %-10s %-7s ", + "TIME(s)", "COMM", "PID", "DISK", "T", "SECTOR", "BYTES"); + if (env.queued) + printf("%7s ", "QUE(ms)"); + printf("%7s\n", "LAT(ms)"); + + /* setup duration */ + if (env.duration) + time_end = get_ktime_ns() + env.duration * NSEC_PER_SEC; + + /* main: poll */ + while (1) { + if ((err = perf_buffer__poll(pb, PERF_POLL_TIMEOUT_MS)) < 0) + break; + if (env.duration && get_ktime_ns() > time_end) + goto cleanup; + } + printf("error polling perf buffer: %d\n", err); + +cleanup: + biosnoop_bpf__destroy(obj); + ksyms__free(ksyms); + + return err != 0; +} diff --git a/libbpf-tools/biosnoop.h b/libbpf-tools/biosnoop.h new file mode 100644 index 000000000..b7e5d21f4 --- /dev/null +++ b/libbpf-tools/biosnoop.h @@ -0,0 +1,20 @@ +#ifndef __BIOSNOOP_H +#define __BIOSNOOP_H + +#define DISK_NAME_LEN 32 +#define TASK_COMM_LEN 16 +#define RWBS_LEN 8 + +struct event { + char comm[TASK_COMM_LEN]; + __u64 delta; + __u64 qdelta; + __u64 ts; + __u64 sector; + __u32 len; + __u32 pid; + __u32 cmd_flags; + char disk[DISK_NAME_LEN]; +}; + +#endif /* __BIOSNOOP_H */ From f8ac3c6c14519d9d35c88260473585861060d058 Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Mon, 20 Jul 2020 00:42:19 -0400 Subject: [PATCH 212/278] libbpf-tools: fix tcpconnect compile errors Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/maps.bpf.h | 2 +- libbpf-tools/tcpconnect.bpf.c | 8 ++++---- libbpf-tools/tcpconnect.c | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/libbpf-tools/maps.bpf.h b/libbpf-tools/maps.bpf.h index 5e43d27a9..51d1012b5 100644 --- a/libbpf-tools/maps.bpf.h +++ b/libbpf-tools/maps.bpf.h @@ -4,7 +4,7 @@ #define __MAPS_BPF_H #include <bpf/bpf_helpers.h> -#include <errno.h> +#include <asm-generic/errno.h> static __always_inline void * bpf_map_lookup_or_try_init(void *map, const void *key, const void *init) diff --git a/libbpf-tools/tcpconnect.bpf.c b/libbpf-tools/tcpconnect.bpf.c index f941f13dc..525d62c0d 100644 --- a/libbpf-tools/tcpconnect.bpf.c +++ b/libbpf-tools/tcpconnect.bpf.c @@ -11,11 +11,11 @@ #include "maps.bpf.h" #include "tcpconnect.h" -const volatile bool do_count; -const volatile int filter_ports_len; -const volatile int filter_ports[MAX_PORTS]; -const volatile pid_t filter_pid; +SEC(".rodata") int filter_ports[MAX_PORTS]; +const volatile int filter_ports_len = 0; const volatile uid_t filter_uid = -1; +const volatile pid_t filter_pid = 0; +const volatile bool do_count = 0; /* Define here, because there are conflicts with include files */ #define AF_INET 2 diff --git a/libbpf-tools/tcpconnect.c b/libbpf-tools/tcpconnect.c index fde6440dc..cc2ea4ad6 100644 --- a/libbpf-tools/tcpconnect.c +++ b/libbpf-tools/tcpconnect.c @@ -338,7 +338,7 @@ static void print_events(int perf_map_fd) print_events_header(); while (hang_on) { err = perf_buffer__poll(pb, 100); - if (err < 0) { + if (err < 0 && errno != EINTR) { warn("Error polling perf buffer: %d\n", err); goto cleanup; } From d7b427ebc35b4b3e77c7f8dae6a83fcdf7d32e6d Mon Sep 17 00:00:00 2001 From: Ferenc Fejes <fejes@inf.elte.hu> Date: Sat, 1 Aug 2020 21:18:57 +0200 Subject: [PATCH 213/278] Offset support for uprobe and kprobe --- tools/trace.py | 25 +++++++++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) diff --git a/tools/trace.py b/tools/trace.py index 9c44a4abb..7a61594f1 100755 --- a/tools/trace.py +++ b/tools/trace.py @@ -138,6 +138,19 @@ def _parse_probe(self): # The remainder of the text is the printf action self._parse_action(text.lstrip()) + def _parse_offset(self, func_and_offset): + func, offset_str = func_and_offset.split("+") + try: + if "x" in offset_str or "X" in offset_str: + offset = int(offset_str, 16) + else: + offset = int(offset_str) + except ValueError: + self._bail("invalid offset format " + + " '%s', must be decimal or hexadecimal" % offset_str) + + return func, offset + def _parse_spec(self, spec): parts = spec.split(":") # Two special cases: 'func' means 'p::func', 'lib:func' means @@ -155,6 +168,10 @@ def _parse_spec(self, spec): else: self._bail("probe type must be '', 'p', 't', 'r', " + "or 'u', but got '%s'" % parts[0]) + self.offset = 0 + if "+" in parts[-1]: + parts[-1], self.offset = self._parse_offset(parts[-1]) + if self.probe_type == "t": self.tp_category = parts[1] self.tp_event = parts[2] @@ -629,7 +646,8 @@ def _attach_k(self, bpf): fn_name=self.probe_name) elif self.probe_type == "p": bpf.attach_kprobe(event=self.function, - fn_name=self.probe_name) + fn_name=self.probe_name, + event_off=self.offset) # Note that tracepoints don't need an explicit attach def _attach_u(self, bpf): @@ -651,7 +669,8 @@ def _attach_u(self, bpf): bpf.attach_uprobe(name=libpath, sym=self.function, fn_name=self.probe_name, - pid=Probe.tgid) + pid=Probe.tgid, + sym_off=self.offset) class Tool(object): DEFAULT_PERF_BUFFER_PAGES = 64 @@ -660,6 +679,8 @@ class Tool(object): trace do_sys_open Trace the open syscall and print a default trace message when entered +trace kfree_skb+0x12 + Trace the kfree_skb kernel function after the instruction on the 0x12 offset trace 'do_sys_open "%s", arg2' Trace the open syscall and print the filename being opened trace 'do_sys_open "%s", arg2' -n main From 8105317c3bbe531801eb03324371462d627cf0ad Mon Sep 17 00:00:00 2001 From: Ferenc Fejes <fejes@inf.elte.hu> Date: Sun, 2 Aug 2020 21:45:45 +0200 Subject: [PATCH 214/278] Update the documentation of the k/uprobe offset support --- man/man8/trace.8 | 6 ++++- tools/trace_example.txt | 49 ++++++++++++++++++++++++++++++++++++++++- 2 files changed, 53 insertions(+), 2 deletions(-) diff --git a/man/man8/trace.8 b/man/man8/trace.8 index 0b27dbd60..e4f06fc7c 100644 --- a/man/man8/trace.8 +++ b/man/man8/trace.8 @@ -86,7 +86,7 @@ information. See PROBE SYNTAX below. .SH PROBE SYNTAX The general probe syntax is as follows: -.B [{p,r}]:[library]:function[(signature)] [(predicate)] ["format string"[, arguments]] +.B [{p,r}]:[library]:function[+offset][(signature)] [(predicate)] ["format string"[, arguments]] .B {t:category:event,u:library:probe} [(predicate)] ["format string"[, arguments]] .TP @@ -107,6 +107,10 @@ The tracepoint category. For example, "sched" or "irq". .TP .B function The function to probe. +.B offset +The offset after the address of the function where the probe should injected. +For example "kfree_skb+56" in decimal or hexadecimal "kfree_skb+0x38" format. +Only works with kprobes and uprobes. Zero if omitted. .TP .B signature The optional signature of the function to probe. This can make it easier to diff --git a/tools/trace_example.txt b/tools/trace_example.txt index a16b03959..33ca6cc4a 100644 --- a/tools/trace_example.txt +++ b/tools/trace_example.txt @@ -287,7 +287,52 @@ STRCMP helper in binary mode (--bin_cmp flag) to compare optval array against int value of 108 (parametr of setsockopt call) in hex representation (little endian format) - +For advanced users there is a possibility to insert the kprobes or uprobes +after a certain offset, rather than the start of the function call +This is useful for tracing register values at different places of the +execution of a function. Lets consider the following example: + +int main() +{ + int val = 0xdead; + printf("%d\n", val); + val = 0xbeef; + printf("%d\n", val); +} + +After compiling the code with -O3 optimization the object code looks +like the following (with GCC 10 and x86_64 architecture): + +objdump --disassemble=main --prefix-addresses a.out + +0000000000001060 <main> endbr64 +0000000000001064 <main+0x4> sub $0x8,%rsp +0000000000001068 <main+0x8> mov $0xdead,%edx +000000000000106d <main+0xd> mov $0x1,%edi +0000000000001072 <main+0x12> xor %eax,%eax +0000000000001074 <main+0x14> lea 0xf89(%rip),%rsi +000000000000107b <main+0x1b> callq 0000000000001050 <__printf_chk@plt> +0000000000001080 <main+0x20> mov $0xbeef,%edx +0000000000001085 <main+0x25> lea 0xf78(%rip),%rsi +000000000000108c <main+0x2c> xor %eax,%eax +000000000000108e <main+0x2e> mov $0x1,%edi +0000000000001093 <main+0x33> callq 0000000000001050 <__printf_chk@plt> +0000000000001098 <main+0x38> xor %eax,%eax +000000000000109a <main+0x3a> add $0x8,%rsp +000000000000109e <main+0x3e> retq + +The 0xdead and later the 0xbeef values are moved into the edx register. +As the dissassembly shows the edx register contains the 0xdead value +after the 0xd offset and 0xbeef after the 0x25 offset. To verify this +with trace lets insert probes to those offsets. The following +command insert two uprobe one after the 0xd offset and another one +after the 0x25 offset of the main function. The probe print the +value of the edx register which will show us the correct values. + +trace 'p:/tmp/a.out:main+0xd "%x", ctx->dx' 'p:/tmp/a.out:main+0x25 "%x", ctx->dx' +PID TID COMM FUNC - +25754 25754 a.out main dead +25754 25754 a.out main beef USAGE message: @@ -335,6 +380,8 @@ EXAMPLES: trace do_sys_open Trace the open syscall and print a default trace message when entered +trace kfree_skb+0x12 + Trace the kfree_skb kernel function after the instruction on the 0x12 offset trace 'do_sys_open "%s", arg2@user' Trace the open syscall and print the filename being opened. @user is added to arg2 in kprobes to ensure that char * should be copied from From 6432324310b4e46057ca5f55e1d7f16b3b032497 Mon Sep 17 00:00:00 2001 From: Fejes Ferenc <primalgamer@gmail.com> Date: Sun, 2 Aug 2020 22:07:20 +0200 Subject: [PATCH 215/278] typos --- tools/trace_example.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/trace_example.txt b/tools/trace_example.txt index 33ca6cc4a..40c5189a7 100644 --- a/tools/trace_example.txt +++ b/tools/trace_example.txt @@ -322,10 +322,10 @@ objdump --disassemble=main --prefix-addresses a.out 000000000000109e <main+0x3e> retq The 0xdead and later the 0xbeef values are moved into the edx register. -As the dissassembly shows the edx register contains the 0xdead value +As the disassembly shows the edx register contains the 0xdead value after the 0xd offset and 0xbeef after the 0x25 offset. To verify this with trace lets insert probes to those offsets. The following -command insert two uprobe one after the 0xd offset and another one +command inserts two uprobe one after the 0xd offset and another one after the 0x25 offset of the main function. The probe print the value of the edx register which will show us the correct values. From 9ef20e7aa61f6a4d7576f906fdaf32329bec34bc Mon Sep 17 00:00:00 2001 From: Yonghong Song <yhs@fb.com> Date: Sun, 9 Aug 2020 23:57:30 -0700 Subject: [PATCH 216/278] sync with latest libbpf repo Signed-off-by: Yonghong Song <yhs@fb.com> --- src/cc/compat/linux/virtual_bpf.h | 20 +++++++++++++------- src/cc/libbpf | 2 +- 2 files changed, 14 insertions(+), 8 deletions(-) diff --git a/src/cc/compat/linux/virtual_bpf.h b/src/cc/compat/linux/virtual_bpf.h index c1eef179c..382626303 100644 --- a/src/cc/compat/linux/virtual_bpf.h +++ b/src/cc/compat/linux/virtual_bpf.h @@ -82,6 +82,12 @@ struct bpf_cgroup_storage_key { __u32 attach_type; /* program attach type */ }; +union bpf_iter_link_info { + struct { + __u32 map_fd; + } map; +}; + /* BPF syscall commands, see bpf(2) man-page for details. */ enum bpf_cmd { BPF_MAP_CREATE, @@ -118,6 +124,7 @@ enum bpf_cmd { BPF_LINK_GET_NEXT_ID, BPF_ENABLE_STATS, BPF_ITER_CREATE, + BPF_LINK_DETACH, }; enum bpf_map_type { @@ -249,13 +256,6 @@ enum bpf_link_type { MAX_BPF_LINK_TYPE, }; -enum bpf_iter_link_info { - BPF_ITER_LINK_UNSPEC = 0, - BPF_ITER_LINK_MAP_FD = 1, - - MAX_BPF_ITER_LINK_INFO, -}; - /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command * * NONE(default): No further bpf programs allowed in the subtree. @@ -623,6 +623,8 @@ union bpf_attr { }; __u32 attach_type; /* attach type */ __u32 flags; /* extra flags */ + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ } link_create; struct { /* struct used by BPF_LINK_UPDATE command */ @@ -635,6 +637,10 @@ union bpf_attr { __u32 old_prog_fd; } link_update; + struct { + __u32 link_fd; + } link_detach; + struct { /* struct used by BPF_ENABLE_STATS command */ __u32 type; } enable_stats; diff --git a/src/cc/libbpf b/src/cc/libbpf index 734b3f0af..bf3ab4b0d 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit 734b3f0afe96354cc1a3932c02adcca42ee11bda +Subproject commit bf3ab4b0d8f9256f11d3e048be3f9124f7ed4d18 From 3fbb6648e9d843c5e835f0b26713b0656cb684a7 Mon Sep 17 00:00:00 2001 From: vmware <vmware@centos8.localdomain> Date: Tue, 11 Aug 2020 14:33:00 -0400 Subject: [PATCH 217/278] Fixes a problem when LLVM_DEFINITIONS contains a definition with an `=` in it. add_definitions doesn't seem to parse this type of argument correctly. --- src/cc/CMakeLists.txt | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/cc/CMakeLists.txt b/src/cc/CMakeLists.txt index 0f02ad625..4021c6621 100644 --- a/src/cc/CMakeLists.txt +++ b/src/cc/CMakeLists.txt @@ -12,7 +12,11 @@ include_directories(${LIBELF_INCLUDE_DIRS}) # todo: if check for kernel version include_directories(${CMAKE_CURRENT_SOURCE_DIR}/libbpf/include) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/libbpf/include/uapi) -add_definitions(${LLVM_DEFINITIONS}) + +# add_definitions has a problem parsing "-D_GLIBCXX_USE_CXX11_ABI=0", this is safer +separate_arguments(LLVM_DEFINITIONS) +add_compile_options(${LLVM_DEFINITIONS}) + configure_file(libbcc.pc.in libbcc.pc @ONLY) configure_file(bcc_version.h.in bcc_version.h @ONLY) From b61e65ffe1cd41fb9fe01118540158f98737996e Mon Sep 17 00:00:00 2001 From: He Zhe <zhe.he@windriver.com> Date: Wed, 12 Aug 2020 13:04:35 +0800 Subject: [PATCH 218/278] bcc/tools/fileslower: Attach to vfs_read after failing to attach __vfs_read __vfs_read has been removed since kernel v5.8-rc5 775802c0571f ("fs: remove __vfs_read"). Then try vfs_read instead. Signed-off-by: He Zhe <zhe.he@windriver.com> --- tools/fileslower.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/tools/fileslower.py b/tools/fileslower.py index 21b0e1c8f..07484e031 100755 --- a/tools/fileslower.py +++ b/tools/fileslower.py @@ -199,13 +199,18 @@ # do_sync_read/do_sync_write), but those became static. So trace these from # the parent functions, at the cost of more overhead, instead. # Ultimately, we should be using [V]FS tracepoints. -b.attach_kprobe(event="__vfs_read", fn_name="trace_read_entry") -b.attach_kretprobe(event="__vfs_read", fn_name="trace_read_return") +try: + b.attach_kprobe(event="__vfs_read", fn_name="trace_read_entry") + b.attach_kretprobe(event="__vfs_read", fn_name="trace_read_return") +except Exception: + print('Current kernel does not have __vfs_read, try vfs_read instead') + b.attach_kprobe(event="vfs_read", fn_name="trace_read_entry") + b.attach_kretprobe(event="vfs_read", fn_name="trace_read_return") try: b.attach_kprobe(event="__vfs_write", fn_name="trace_write_entry") b.attach_kretprobe(event="__vfs_write", fn_name="trace_write_return") except Exception: - # older kernels don't have __vfs_write so try vfs_write instead + print('Current kernel does not have __vfs_write, try vfs_write instead') b.attach_kprobe(event="vfs_write", fn_name="trace_write_entry") b.attach_kretprobe(event="vfs_write", fn_name="trace_write_return") From 5c272220f1cf8a3bb8fd6814c963b3f9b271fe3a Mon Sep 17 00:00:00 2001 From: Anton Protopopov <a.s.protopopov@gmail.com> Date: Wed, 12 Aug 2020 13:06:57 +0000 Subject: [PATCH 219/278] libbpibbpf-tools: fix tcpconnect types usage The __int128 is not defined for 32-bit platforms, see [1], so replace it by a portable array of __u8. The usage of this type came from the original tcpconnect.py, and __int128 is still used in most (if not all) original BCC tools to store IPv6 addresses. [1] https://github.com/iovisor/bcc/issues/3044 Signed-off-by: Anton Protopopov <a.s.protopopov@gmail.com> --- libbpf-tools/tcpconnect.c | 8 ++++---- libbpf-tools/tcpconnect.h | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/libbpf-tools/tcpconnect.c b/libbpf-tools/tcpconnect.c index cc2ea4ad6..ccee3e554 100644 --- a/libbpf-tools/tcpconnect.c +++ b/libbpf-tools/tcpconnect.c @@ -242,8 +242,8 @@ static void print_count_ipv6(int map_fd) } for (__u32 i = 0; i < n; i++) { - memcpy(src.s6_addr, &keys[i].saddr, sizeof(src.s6_addr)); - memcpy(dst.s6_addr, &keys[i].daddr, sizeof(src.s6_addr)); + memcpy(src.s6_addr, keys[i].saddr, sizeof(src.s6_addr)); + memcpy(dst.s6_addr, keys[i].daddr, sizeof(src.s6_addr)); printf("%-25s %-25s %-20d %-10llu\n", inet_ntop(AF_INET6, &src, s, sizeof(s)), @@ -289,8 +289,8 @@ static void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) s.x4.s_addr = event->saddr_v4; d.x4.s_addr = event->daddr_v4; } else if (event->af == AF_INET6) { - memcpy(&s.x6.s6_addr, &event->saddr_v6, sizeof(s.x6.s6_addr)); - memcpy(&d.x6.s6_addr, &event->daddr_v6, sizeof(d.x6.s6_addr)); + memcpy(&s.x6.s6_addr, event->saddr_v6, sizeof(s.x6.s6_addr)); + memcpy(&d.x6.s6_addr, event->daddr_v6, sizeof(d.x6.s6_addr)); } else { warn("broken event: event->af=%d", event->af); return; diff --git a/libbpf-tools/tcpconnect.h b/libbpf-tools/tcpconnect.h index 86cc194f8..65b768fd8 100644 --- a/libbpf-tools/tcpconnect.h +++ b/libbpf-tools/tcpconnect.h @@ -18,19 +18,19 @@ struct ipv4_flow_key { }; struct ipv6_flow_key { - unsigned __int128 saddr; - unsigned __int128 daddr; + __u8 saddr[16]; + __u8 daddr[16]; __u16 dport; }; struct event { union { __u32 saddr_v4; - unsigned __int128 saddr_v6; + __u8 saddr_v6[16]; }; union { __u32 daddr_v4; - unsigned __int128 daddr_v6; + __u8 daddr_v6[16]; }; char task[TASK_COMM_LEN]; __u64 ts_us; From fb54a822d54ab80e6e36755e7de5285e6f06f410 Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Fri, 7 Aug 2020 00:39:15 -0400 Subject: [PATCH 220/278] libbpf-tools: add CO-RE readahead Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/readahead.bpf.c | 89 ++++++++++++++++++++++++ libbpf-tools/readahead.c | 130 +++++++++++++++++++++++++++++++++++ libbpf-tools/readahead.h | 12 ++++ 5 files changed, 233 insertions(+) create mode 100644 libbpf-tools/readahead.bpf.c create mode 100644 libbpf-tools/readahead.c create mode 100644 libbpf-tools/readahead.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index b9f1784eb..9b681d4cd 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -8,6 +8,7 @@ /execsnoop /filelife /opensnoop +/readahead /runqslower /syscount /tcpconnect diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index be1c689da..232450e41 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -19,6 +19,7 @@ APPS = \ execsnoop \ filelife \ opensnoop \ + readahead \ runqslower \ syscount \ tcpconnect \ diff --git a/libbpf-tools/readahead.bpf.c b/libbpf-tools/readahead.bpf.c new file mode 100644 index 000000000..5cd27a01d --- /dev/null +++ b/libbpf-tools/readahead.bpf.c @@ -0,0 +1,89 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> +#include "readahead.h" +#include "bits.bpf.h" + +#define MAX_ENTRIES 10240 + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, u32); + __type(value, u64); + __uint(map_flags, BPF_F_NO_PREALLOC); +} in_readahead SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, struct page *); + __type(value, u64); + __uint(map_flags, BPF_F_NO_PREALLOC); +} birth SEC(".maps"); + +static struct hist hist; + +SEC("fentry/__do_page_cache_readahead") +int BPF_PROG(fentry__do_page_cache_readahead) +{ + u32 pid = bpf_get_current_pid_tgid(); + u64 one = 1; + + bpf_map_update_elem(&in_readahead, &pid, &one, 0); + return 0; +} + +SEC("fexit/__page_cache_alloc") +int BPF_PROG(fexit__page_cache_alloc, gfp_t gfp, struct page *ret) +{ + u32 pid = bpf_get_current_pid_tgid(); + u64 ts; + + if (!bpf_map_lookup_elem(&in_readahead, &pid)) + return 0; + + ts = bpf_ktime_get_ns(); + bpf_map_update_elem(&birth, &ret, &ts, 0); + __sync_fetch_and_add(&hist.unused, 1); + __sync_fetch_and_add(&hist.total, 1); + + return 0; +} + +SEC("fexit/__do_page_cache_readahead") +int BPF_PROG(fexit__do_page_cache_readahead) +{ + u32 pid = bpf_get_current_pid_tgid(); + + bpf_map_delete_elem(&in_readahead, &pid); + return 0; +} + +SEC("fentry/mark_page_accessed") +int BPF_PROG(fentry__mark_page_accessed, struct page *page) +{ + u64 *tsp, slot, ts = bpf_ktime_get_ns(); + s64 delta; + + tsp = bpf_map_lookup_elem(&birth, &page); + if (!tsp) + return 0; + delta = (s64)(ts - *tsp); + if (delta < 0) + goto update_and_cleanup; + slot = log2l(delta / 1000000); + if (slot >= MAX_SLOTS) + slot = MAX_SLOTS - 1; + __sync_fetch_and_add(&hist.slots[slot], 1); + +update_and_cleanup: + __sync_fetch_and_add(&hist.unused, -1); + bpf_map_delete_elem(&birth, &page); + + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/readahead.c b/libbpf-tools/readahead.c new file mode 100644 index 000000000..547f2bd0e --- /dev/null +++ b/libbpf-tools/readahead.c @@ -0,0 +1,130 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on readahead(8) from from BPF-Perf-Tools-Book by Brendan Gregg. +// 8-Jun-2020 Wenbo Zhang Created this. +#include <argp.h> +#include <signal.h> +#include <stdio.h> +#include <unistd.h> +#include <bpf/libbpf.h> +#include <bpf/bpf.h> +#include "readahead.h" +#include "readahead.skel.h" +#include "trace_helpers.h" + +static struct env { + int duration; + bool verbose; +} env = { + .duration = -1 +}; + +static volatile bool exiting; + +const char *argp_program_version = "readahead 0.1"; +const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char argp_program_doc[] = +"Show fs automatic read-ahead usage.\n" +"\n" +"USAGE: readahead [-d DURATION]\n" +"\n" +"EXAMPLES:\n" +" readahead # summarize on-CPU time as a histogram" +" readahead -d 10 # trace for 10 seconds only\n"; + +static const struct argp_option opts[] = { + { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, + { "duration", 'd', "DURATION", 0, "Duration to trace"}, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + switch (key) { + case 'v': + env.verbose = true; + break; + case 'd': + errno = 0; + env.duration = strtol(arg, NULL, 10); + if (errno || env.duration <= 0) { + fprintf(stderr, "Invalid duration: %s\n", arg); + argp_usage(state); + } + break; + case 'h': + argp_usage(state); + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void sig_handler(int sig) +{ + exiting = true; +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct readahead_bpf *obj; + struct hist *histp; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = readahead_bpf__open_and_load(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + return 1; + } + + err = readahead_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs\n"); + goto cleanup; + } + + signal(SIGINT, sig_handler); + + printf("Tracing fs read-ahead ... Hit Ctrl-C to end.\n"); + + sleep(env.duration); + printf("\n"); + + histp = &obj->bss->hist; + + printf("Readahead unused/total pages: %d/%d\n", + histp->unused, histp->total); + print_log2_hist(histp->slots, MAX_SLOTS, "msecs"); + +cleanup: + readahead_bpf__destroy(obj); + return err != 0; +} diff --git a/libbpf-tools/readahead.h b/libbpf-tools/readahead.h new file mode 100644 index 000000000..a41188abb --- /dev/null +++ b/libbpf-tools/readahead.h @@ -0,0 +1,12 @@ +#ifndef __READAHEAD_H +#define __READAHEAD_H + +#define MAX_SLOTS 20 + +struct hist { + __u32 unused; + __u32 total; + __u32 slots[MAX_SLOTS]; +}; + +#endif /* __READAHEAD_H */ From 7d081eb03d8a3412cfcdcf2a5cfc99047eb08bc1 Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Wed, 12 Aug 2020 20:47:57 -0400 Subject: [PATCH 221/278] libbpf-tools: fix tcpconnlat types usage Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/tcpconnlat.c | 4 ++-- libbpf-tools/tcpconnlat.h | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/libbpf-tools/tcpconnlat.c b/libbpf-tools/tcpconnlat.c index 18dba628a..46b6a60cd 100644 --- a/libbpf-tools/tcpconnlat.c +++ b/libbpf-tools/tcpconnlat.c @@ -115,8 +115,8 @@ void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) s.x4.s_addr = e->saddr_v4; d.x4.s_addr = e->daddr_v4; } else if (e->af == AF_INET6) { - memcpy(&s.x6.s6_addr, &e->saddr_v6, sizeof(s.x6.s6_addr)); - memcpy(&d.x6.s6_addr, &e->daddr_v6, sizeof(d.x6.s6_addr)); + memcpy(&s.x6.s6_addr, e->saddr_v6, sizeof(s.x6.s6_addr)); + memcpy(&d.x6.s6_addr, e->daddr_v6, sizeof(d.x6.s6_addr)); } else { fprintf(stderr, "broken event: event->af=%d", e->af); return; diff --git a/libbpf-tools/tcpconnlat.h b/libbpf-tools/tcpconnlat.h index 11524a756..63d09476b 100644 --- a/libbpf-tools/tcpconnlat.h +++ b/libbpf-tools/tcpconnlat.h @@ -6,11 +6,11 @@ struct event { union { __u32 saddr_v4; - unsigned __int128 saddr_v6; + __u8 saddr_v6[16]; }; union { __u32 daddr_v4; - unsigned __int128 daddr_v6; + __u8 daddr_v6[16]; }; char comm[TASK_COMM_LEN]; __u64 delta_us; From 639e83ff2a57eacac315f0389f79ae331eaf3e5c Mon Sep 17 00:00:00 2001 From: bas smit <bas@baslab.org> Date: Sun, 16 Aug 2020 22:27:05 +0200 Subject: [PATCH 222/278] docs: fix broken links --- docs/reference_guide.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 561e8e7db..82d510530 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -31,7 +31,7 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [9. bpf_get_prandom_u32()](#9-bpf_get_prandom_u32) - [10. bpf_probe_read_user()](#10-bpf_probe_read_user) - [11. bpf_probe_read_user_str()](#11-bpf_probe_read_user_str) - - [12. bpf_get_ns_current_pid_tgid()](#4-bpf_get_ns_current_pid_tgid) + - [12. bpf_get_ns_current_pid_tgid()](#12-bpf_get_ns_current_pid_tgid) - [Debugging](#debugging) - [1. bpf_override_return()](#1-bpf_override_return) - [Output](#output) @@ -71,8 +71,8 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [25. map.call()](#25-mapcall) - [26. map.redirect_map()](#26-mapredirect_map) - [27. map.push()](#27-mappush) - - [28. map.pop()](#27-mappop) - - [29. map.peek()](#27-mappeek) + - [28. map.pop()](#28-mappop) + - [29. map.peek()](#29-mappeek) - [Licensing](#licensing) - [Rewriter](#rewriter) From 49beed88ee27c8f86e50ac29064664671757d930 Mon Sep 17 00:00:00 2001 From: Jiri Olsa <jolsa@kernel.org> Date: Wed, 19 Aug 2020 12:47:48 +0200 Subject: [PATCH 223/278] Forbid trampolines for archs other than x86_64 The trampoline support check in bcc does not work properly, so the feature is detected even on architectures that do not support it - all archs other than x86_64. We are checking for bpf_trampoline_link_prog to exist in kernel, which works fine on x86_64 to check if the feature is supported, but it's global function, so it exists also in other archs even when the feature is not supported so it returns True also on other archs. Adding explicit x86_64 check to support_kfunc function. Signed-off-by: Jiri Olsa <jolsa@kernel.org> --- src/python/bcc/__init__.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index 253230bfa..53ef65196 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -22,6 +22,7 @@ import struct import errno import sys +import platform from .libbcc import lib, bcc_symbol, bcc_symbol_option, bcc_stacktrace_build_id, _SYM_CB_TYPE from .table import Table, PerfEventArray, RingBuf, BPF_MAP_TYPE_QUEUE, BPF_MAP_TYPE_STACK @@ -895,6 +896,9 @@ def add_prefix(prefix, name): @staticmethod def support_kfunc(): + # there's no trampoline support for other than x86_64 arch + if platform.machine() != 'x86_64': + return False; if not lib.bpf_has_kernel_btf(): return False; # kernel symbol "bpf_trampoline_link_prog" indicates kfunc support From e73e1f67b0167edbbe2e261997e3ae9e72e23757 Mon Sep 17 00:00:00 2001 From: Alba Mendez <me@alba.sh> Date: Thu, 20 Aug 2020 02:30:58 +0200 Subject: [PATCH 224/278] kernel-versions.md: document map UAPI features (#3058) Document kernel versions for userspace API features regarding map manipulation. --- docs/kernel-versions.md | 36 +++++++++++++++++++++++++++++++++--- 1 file changed, 33 insertions(+), 3 deletions(-) diff --git a/docs/kernel-versions.md b/docs/kernel-versions.md index 44c961022..ed95b7e46 100644 --- a/docs/kernel-versions.md +++ b/docs/kernel-versions.md @@ -84,6 +84,8 @@ BPF LSM hook | 5.7 | [`fc611f47f218`](https://github.com/torvalds/linux/commit/f ## Tables (_a.k.a._ Maps) +### Table types + The list of map types supported in your kernel can be found in file [`include/uapi/linux/bpf.h`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/bpf.h): @@ -98,14 +100,13 @@ Perf events | 4.3 | [`ea317b267e9d`](https://git.kernel.org/cgit/linux/kernel/gi Per-CPU hash | 4.6 | [`824bd0ce6c7c`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=824bd0ce6c7c43a9e1e210abf124958e54d88342) Per-CPU array | 4.6 | [`a10423b87a7e`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=a10423b87a7eae75da79ce80a8d9475047a674ee) Stack trace | 4.6 | [`d5a3b1f69186`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d5a3b1f691865be576c2bffa708549b8cdccda19) -Pre-alloc maps memory | 4.6 | [`6c9059817432`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6c90598174322b8888029e40dd84a4eb01f56afe) cgroup array | 4.8 | [`4ed8ec521ed5`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=4ed8ec521ed57c4e207ad464ca0388776de74d4b) LRU hash | 4.10 | [`29ba732acbee`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=29ba732acbeece1e34c68483d1ec1f3720fa1bb3) [`3a08c2fd7634`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=3a08c2fd763450a927d1130de078d6f9e74944fb) LRU per-CPU hash | 4.10 | [`8f8449384ec3`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=8f8449384ec364ba2a654f11f94e754e4ff719e0) [`961578b63474`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=961578b63474d13ad0e2f615fcc2901c5197dda6) LPM trie (longest-prefix match) | 4.11 | [`b95a5c4db09b`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=b95a5c4db09bc7c253636cb84dc9b12c577fd5a0) Array of maps | 4.12 | [`56f668dfe00d`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=56f668dfe00dcf086734f1c42ea999398fad6572) Hash of maps | 4.12 | [`bcc6b1b7ebf8`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=bcc6b1b7ebf857a9fe56202e2be3361131588c15) -Netdevice references | 4.14 | [`546ac1ffb70d`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=546ac1ffb70d25b56c1126940e5ec639c4dd7413) +Netdevice references (array) | 4.14 | [`546ac1ffb70d`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=546ac1ffb70d25b56c1126940e5ec639c4dd7413) Socket references (array) | 4.14 | [`174a79ff9515`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=174a79ff9515f400b9a6115643dafd62a635b7e6) CPU references | 4.15 | [`6710e1126934`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6710e1126934d8b4372b4d2f9ae1646cd3f151bf) AF_XDP socket (XSK) references | 4.18 | [`fbfc504a24f5`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=fbfc504a24f53f7ebe128ab55cb5dba634f4ece8) @@ -116,7 +117,36 @@ precpu cgroup storage | 4.20 | [`b741f1630346`](https://github.com/torvalds/linu queue | 4.20 | [`f1a2e44a3aec`](https://github.com/torvalds/linux/commit/f1a2e44a3aeccb3ff18d3ccc0b0203e70b95bd92) stack | 4.20 | [`f1a2e44a3aec`](https://github.com/torvalds/linux/commit/f1a2e44a3aeccb3ff18d3ccc0b0203e70b95bd92) socket local storage | 5.2 | [`6ac99e8f23d4`](https://github.com/torvalds/linux/commit/6ac99e8f23d4b10258406ca0dd7bffca5f31da9d) -ringbuf | 5.8 | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) +Netdevice references (hashmap) | 5.4 | [`6f9d451ab1a3`](https://github.com/torvalds/linux/commit/6f9d451ab1a33728adb72d7ff66a7b374d665176) +struct ops | 5.6 | [`85d33df357b6`](https://github.com/torvalds/linux/commit/85d33df357b634649ddbe0a20fd2d0fc5732c3cb) +ring buffer | 5.8 | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) + +### Table userspace API + +Some (but not all) of these *API features* translate to a subcommand beginning with `BPF_MAP_`. +The list of subcommands supported in your kernel can be found in file +[`include/uapi/linux/bpf.h`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/bpf.h): + + git grep -W 'bpf_cmd {' include/uapi/linux/bpf.h + +Feature | Kernel version | Commit +--------|----------------|------- +Basic operations (lookup, update, delete, `GET_NEXT_KEY`) | 3.18 | [`db20fd2b0108`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=db20fd2b01087bdfbe30bce314a198eefedcc42e) +Pass flags to `UPDATE_ELEM` | 3.19 | [`3274f52073d8`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3274f52073d88b62f3c5ace82ae9d48546232e72) +Pre-alloc map memory by default | 4.6 | [`6c9059817432`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6c90598174322b8888029e40dd84a4eb01f56afe) +Pass `NULL` to `GET_NEXT_KEY` | 4.12 | [`8fe45924387b`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=8fe45924387be6b5c1be59a7eb330790c61d5d10) +Creation: select NUMA node | 4.14 | [`96eabe7a40aa`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=96eabe7a40aa17e613cf3db2c742ee8b1fc764d0) +Restrict access from syscall side | 4.15 | [`6e71b04a8224`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6e71b04a82248ccf13a94b85cbc674a9fefe53f5) +Creation: specify map name | 4.15 | [`ad5b177bd73f`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ad5b177bd73f5107d97c36f56395c4281fb6f089) +`LOOKUP_AND_DELETE_ELEM` | 4.20 | [`bd513cd08f10`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=bd513cd08f10cbe28856f99ae951e86e86803861) +Creation: `BPF_F_ZERO_SEED` | 5.0 | [`96b3b6c9091d`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=96b3b6c9091d23289721350e32c63cc8749686be) +`BPF_F_LOCK` flag for lookup / update | 5.1 | [`96049f3afd50`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=96049f3afd50fe8db69fa0068cdca822e747b1e4) +Restrict access from BPF side | 5.2 | [`591fe9888d78`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=591fe9888d7809d9ee5c828020b6c6ae27c37229) +`FREEZE` | 5.2 | [`87df15de441b`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=87df15de441bd4add7876ef584da8cabdd9a042a) +mmap() support for array maps | 5.5 | [`fc9702273e2e`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=fc9702273e2edb90400a34b3be76f7b08fa3344b) +`LOOKUP_BATCH` | 5.6 | [`cb4d03ab499d`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cb4d03ab499d4c040f4ab6fd4389d2b49f42b5a5) +`UPDATE_BATCH`, `DELETE_BATCH` | 5.6 | [`aa2e93b8e58e`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=aa2e93b8e58e18442edfb2427446732415bc215e) +`LOOKUP_AND_DELETE_BATCH` | 5.6 | [`057996380a42`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=057996380a42bb64ccc04383cfa9c0ace4ea11f0) ## XDP From f4e65ac41bec1613c7cb54270f09d16411aaf89c Mon Sep 17 00:00:00 2001 From: zhenwei pi <p_ace@126.com> Date: Fri, 21 Aug 2020 12:59:33 +0800 Subject: [PATCH 225/278] tools/funccount: support funccount on specified CPU (#3059) A typical case of this feature: count timer setting on a x86 server for each CPU: for i in `seq 0 39`; do ./funccount.py -i 1 lapic_next_deadline -d 5 -c $i; done Then we can know the timer setting is balanced of not and do some futher work. Signed-off-by: zhenwei pi <pizhenwei@bytedance.com> --- man/man8/funccount.8 | 7 +++++++ tools/funccount.py | 26 +++++++++++++++++++------ tools/funccount_example.txt | 38 ++++++++++++++++++++++++++++++++++++- 3 files changed, 64 insertions(+), 7 deletions(-) diff --git a/man/man8/funccount.8 b/man/man8/funccount.8 index 9039ab33a..16ce4fc08 100644 --- a/man/man8/funccount.8 +++ b/man/man8/funccount.8 @@ -38,6 +38,9 @@ Use regular expressions for the search pattern. .TP \-D Print the BPF program before starting (for debugging purposes). +.TP +\-c CPU +Trace on this CPU only. .SH EXAMPLES .TP Count kernel functions beginning with "vfs_", until Ctrl-C is hit: @@ -75,6 +78,10 @@ Count all GC USDT probes in the Node process: Count all malloc() calls in libc: # .B funccount c:malloc +.TP +Count kernel functions beginning with "vfs_" on CPU 1 only: +# +.B funccount \-c 1 'vfs_*' .SH FIELDS .TP FUNC diff --git a/tools/funccount.py b/tools/funccount.py index 69dd01c8c..ef7d9cefd 100755 --- a/tools/funccount.py +++ b/tools/funccount.py @@ -4,7 +4,8 @@ # funccount Count functions, tracepoints, and USDT probes. # For Linux, uses BCC, eBPF. # -# USAGE: funccount [-h] [-p PID] [-i INTERVAL] [-d DURATION] [-T] [-r] pattern +# USAGE: funccount [-h] [-p PID] [-i INTERVAL] [-d DURATION] [-T] [-r] +# [-c CPU] pattern # # The pattern is a string with optional '*' wildcards, similar to file # globbing. If you'd prefer to use regular expressions, use the -r option. @@ -34,7 +35,7 @@ def verify_limit(num): (probe_limit, num)) class Probe(object): - def __init__(self, pattern, use_regex=False, pid=None): + def __init__(self, pattern, use_regex=False, pid=None, cpu=None): """Init a new probe. Init the probe from the pattern provided by the user. The supported @@ -79,6 +80,7 @@ def __init__(self, pattern, use_regex=False, pid=None): self.library = libpath self.pid = pid + self.cpu = cpu self.matched = 0 self.trace_functions = {} # map location number to function name @@ -164,7 +166,8 @@ def _generate_functions(self, template): def load(self): trace_count_text = b""" int PROBE_FUNCTION(void *ctx) { - FILTER + FILTERPID + FILTERCPU int loc = LOCATION; u64 *val = counts.lookup(&loc); if (!val) { @@ -182,11 +185,18 @@ def load(self): # We really mean the tgid from the kernel's perspective, which is in # the top 32 bits of bpf_get_current_pid_tgid(). if self.pid: - trace_count_text = trace_count_text.replace(b'FILTER', + trace_count_text = trace_count_text.replace(b'FILTERPID', b"""u32 pid = bpf_get_current_pid_tgid() >> 32; if (pid != %d) { return 0; }""" % self.pid) else: - trace_count_text = trace_count_text.replace(b'FILTER', b'') + trace_count_text = trace_count_text.replace(b'FILTERPID', b'') + + if self.cpu: + trace_count_text = trace_count_text.replace(b'FILTERCPU', + b"""u32 cpu = bpf_get_smp_processor_id(); + if (cpu != %d) { return 0; }""" % int(self.cpu)) + else: + trace_count_text = trace_count_text.replace(b'FILTERCPU', b'') bpf_text += self._generate_functions(trace_count_text) bpf_text = bpf_text.replace(b"NUMLOCATIONS", @@ -224,6 +234,7 @@ def __init__(self): ./funccount go:os.* # count all "os.*" calls in libgo ./funccount -p 185 go:os.* # count all "os.*" calls in libgo, PID 185 ./funccount ./test:read* # count "read*" calls in the ./test binary + ./funccount -c 1 'vfs_*' # count vfs calls on CPU 1 only """ parser = argparse.ArgumentParser( description="Count functions, tracepoints, and USDT probes", @@ -241,13 +252,16 @@ def __init__(self): help="use regular expressions. Default is \"*\" wildcards only.") parser.add_argument("-D", "--debug", action="store_true", help="print BPF program before starting (for debugging purposes)") + parser.add_argument("-c", "--cpu", + help="trace this CPU only") parser.add_argument("pattern", type=ArgString, help="search expression for events") self.args = parser.parse_args() global debug debug = self.args.debug - self.probe = Probe(self.args.pattern, self.args.regexp, self.args.pid) + self.probe = Probe(self.args.pattern, self.args.regexp, self.args.pid, + self.args.cpu) if self.args.duration and not self.args.interval: self.args.interval = self.args.duration if not self.args.interval: diff --git a/tools/funccount_example.txt b/tools/funccount_example.txt index d06cfd98e..e942b9cb3 100644 --- a/tools/funccount_example.txt +++ b/tools/funccount_example.txt @@ -325,11 +325,45 @@ tcp_v4_send_check 30 __tcp_v4_send_check 30 Detaching... +A cpu is specified by "-c CPU", this will only trace the specified CPU. Eg, +trace how many timers setting per sencond of CPU 1 on a x86(Intel) server: + +# funccount.py -i 1 -c 1 lapic_next_deadline +Tracing 1 functions for "lapic_next_deadline"... Hit Ctrl-C to end. + +FUNC COUNT +lapic_next_deadline 3840 + +FUNC COUNT +lapic_next_deadline 3930 + +FUNC COUNT +lapic_next_deadline 4701 + +FUNC COUNT +lapic_next_deadline 5895 + +FUNC COUNT +lapic_next_deadline 5591 + +FUNC COUNT +lapic_next_deadline 4727 + +FUNC COUNT +lapic_next_deadline 5560 + +FUNC COUNT +lapic_next_deadline 5416 +^C +FUNC COUNT +lapic_next_deadline 372 +Detaching... Full USAGE: # ./funccount -h -usage: funccount [-h] [-p PID] [-i INTERVAL] [-d DURATION] [-T] [-r] [-D] +usage: funccount.py [-h] [-p PID] [-i INTERVAL] [-d DURATION] [-T] [-r] [-D] + [-c CPU] pattern Count functions, tracepoints, and USDT probes @@ -349,6 +383,7 @@ optional arguments: only. -D, --debug print BPF program before starting (for debugging purposes) + -c CPU, --cpu CPU trace this CPU only examples: ./funccount 'vfs_*' # count kernel fns starting with "vfs" @@ -362,3 +397,4 @@ examples: ./funccount go:os.* # count all "os.*" calls in libgo ./funccount -p 185 go:os.* # count all "os.*" calls in libgo, PID 185 ./funccount ./test:read* # count "read*" calls in the ./test binary + ./funccount -c 1 'vfs_*' # count vfs calls on CPU 1 only From 785924b337f27c6e09b5a83ae4afac3d3c3fec7a Mon Sep 17 00:00:00 2001 From: Edward Wu <edwardwu@realtek.com> Date: Thu, 20 Aug 2020 10:55:40 +0800 Subject: [PATCH 226/278] Extend PerfType members You can use b.attach_perf_event(ev_type=PerfType.RAW, ...) to attach perf raw event for profiling. Signed-off-by: Edward Wu <edwardwu@realtek.com> --- src/python/bcc/__init__.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index 53ef65196..46f738bce 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -109,6 +109,10 @@ class PerfType: # From perf_type_id in uapi/linux/perf_event.h HARDWARE = 0 SOFTWARE = 1 + TRACEPOINT = 2 + HW_CACHE = 3 + RAW = 4 + BREAKPOINT = 5 class PerfHWConfig: # From perf_hw_id in uapi/linux/perf_event.h From 71c22fcaa688a1aea92a9588b1a60a7e2329f38b Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Thu, 20 Aug 2020 03:08:14 -0400 Subject: [PATCH 227/278] libbpf-tools: add CO-RE biostacks Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/biostacks.bpf.c | 115 +++++++++++++++++ libbpf-tools/biostacks.c | 232 +++++++++++++++++++++++++++++++++++ libbpf-tools/biostacks.h | 27 ++++ libbpf-tools/trace_helpers.c | 108 ++++++++++++++++ libbpf-tools/trace_helpers.h | 14 +++ 7 files changed, 498 insertions(+) create mode 100644 libbpf-tools/biostacks.bpf.c create mode 100644 libbpf-tools/biostacks.c create mode 100644 libbpf-tools/biostacks.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 9b681d4cd..65d47f923 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -2,6 +2,7 @@ /biolatency /biopattern /biosnoop +/biostacks /bitesize /cpudist /drsnoop diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 232450e41..b4a444786 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -13,6 +13,7 @@ APPS = \ biolatency \ biopattern \ biosnoop \ + biostacks \ bitesize \ cpudist \ drsnoop \ diff --git a/libbpf-tools/biostacks.bpf.c b/libbpf-tools/biostacks.bpf.c new file mode 100644 index 000000000..30e5c9d43 --- /dev/null +++ b/libbpf-tools/biostacks.bpf.c @@ -0,0 +1,115 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_core_read.h> +#include <bpf/bpf_tracing.h> +#include "biostacks.h" +#include "bits.bpf.h" +#include "maps.bpf.h" + +#define MAX_ENTRIES 10240 +#define NULL 0 + +const volatile bool targ_ms = false; +const volatile dev_t targ_dev = -1; + +struct internal_rqinfo { + u64 start_ts; + struct rqinfo rqinfo; +}; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, struct request *); + __type(value, struct internal_rqinfo); + __uint(map_flags, BPF_F_NO_PREALLOC); +} rqinfos SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, struct rqinfo); + __type(value, struct hist); + __uint(map_flags, BPF_F_NO_PREALLOC); +} hists SEC(".maps"); + +static struct hist zero; + +static __always_inline +int trace_start(void *ctx, struct request *rq, bool merge_bio) +{ + struct internal_rqinfo *i_rqinfop = NULL, i_rqinfo = {}; + struct gendisk *disk = BPF_CORE_READ(rq, rq_disk); + dev_t dev; + + dev = disk ? MKDEV(BPF_CORE_READ(disk, major), + BPF_CORE_READ(disk, first_minor)) : 0; + if (targ_dev != -1 && targ_dev != dev) + return 0; + + if (merge_bio) + i_rqinfop = bpf_map_lookup_elem(&rqinfos, &rq); + if (!i_rqinfop) + i_rqinfop = &i_rqinfo; + + i_rqinfop->start_ts = bpf_ktime_get_ns(); + i_rqinfop->rqinfo.pid = bpf_get_current_pid_tgid(); + i_rqinfop->rqinfo.kern_stack_size = + bpf_get_stack(ctx, i_rqinfop->rqinfo.kern_stack, + sizeof(i_rqinfop->rqinfo.kern_stack), 0); + bpf_get_current_comm(&i_rqinfop->rqinfo.comm, + sizeof(&i_rqinfop->rqinfo.comm)); + i_rqinfop->rqinfo.dev = dev; + + if (i_rqinfop == &i_rqinfo) + bpf_map_update_elem(&rqinfos, &rq, i_rqinfop, 0); + return 0; +} + +SEC("fentry/blk_account_io_start") +int BPF_PROG(blk_account_io_start, struct request *rq) +{ + return trace_start(ctx, rq, false); +} + +SEC("kprobe/blk_account_io_merge_bio") +int BPF_KPROBE(blk_account_io_merge_bio, struct request *rq) +{ + return trace_start(ctx, rq, true); +} + +SEC("fentry/blk_account_io_done") +int BPF_PROG(blk_account_io_done, struct request *rq) +{ + u64 slot, ts = bpf_ktime_get_ns(); + struct internal_rqinfo *i_rqinfop; + struct rqinfo *rqinfop; + struct hist *histp; + s64 delta; + + i_rqinfop = bpf_map_lookup_elem(&rqinfos, &rq); + if (!i_rqinfop) + return 0; + delta = (s64)(ts - i_rqinfop->start_ts); + if (delta < 0) + goto cleanup; + histp = bpf_map_lookup_or_try_init(&hists, &i_rqinfop->rqinfo, &zero); + if (!histp) + goto cleanup; + if (targ_ms) + delta /= 1000000; + else + delta /= 1000; + slot = log2l(delta); + if (slot >= MAX_SLOTS) + slot = MAX_SLOTS - 1; + __sync_fetch_and_add(&histp->slots[slot], 1); + +cleanup: + bpf_map_delete_elem(&rqinfos, &rq); + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/biostacks.c b/libbpf-tools/biostacks.c new file mode 100644 index 000000000..ed788944c --- /dev/null +++ b/libbpf-tools/biostacks.c @@ -0,0 +1,232 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on biostacks(8) from BPF-Perf-Tools-Book by Brendan Gregg. +// 10-Aug-2020 Wenbo Zhang Created this. +#include <argp.h> +#include <signal.h> +#include <stdio.h> +#include <unistd.h> +#include <bpf/libbpf.h> +#include <bpf/bpf.h> +#include "biostacks.h" +#include "biostacks.skel.h" +#include "trace_helpers.h" + +static struct env { + char *disk; + int duration; + bool milliseconds; + bool verbose; +} env = { + .duration = -1, +}; + +const char *argp_program_version = "biostacks 0.1"; +const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char argp_program_doc[] = +"Tracing block I/O with init stacks.\n" +"\n" +"USAGE: biostacks [--help] [-d disk] [duration]\n" +"\n" +"EXAMPLES:\n" +" biostacks # trace block I/O with init stacks.\n" +" biostacks 1 # trace for 1 seconds only\n" +" biostacks -d sdc # trace sdc only\n"; + +static const struct argp_option opts[] = { + { "disk", 'd', "DISK", 0, "Trace this disk only" }, + { "milliseconds", 'm', NULL, 0, "Millisecond histogram" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static int pos_args; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'h': + argp_usage(state); + break; + case 'd': + env.disk = arg; + if (strlen(arg) + 1 > DISK_NAME_LEN) { + fprintf(stderr, "invaild disk name: too long\n"); + argp_usage(state); + } + break; + case 'm': + env.milliseconds = true; + break; + case ARGP_KEY_ARG: + if (pos_args++) { + fprintf(stderr, + "unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + errno = 0; + env.duration = strtoll(arg, NULL, 10); + if (errno || env.duration <= 0) { + fprintf(stderr, "invalid delay (in us): %s\n", arg); + argp_usage(state); + } + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void sig_handler(int sig) +{ +} + +static +void print_map(struct ksyms *ksyms, struct partitions *partitions, int fd) +{ + char *units = env.milliseconds ? "msecs" : "usecs"; + struct rqinfo lookup_key = {}, next_key; + const struct partition *partition; + const struct ksym *ksym; + int num_stack, i, err; + struct hist hist; + + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_lookup_elem(fd, &next_key, &hist); + if (err < 0) { + fprintf(stderr, "failed to lookup hist: %d\n", err); + return; + } + partition = partitions__get_by_dev(partitions, next_key.dev); + printf("%-14.14s %-6d %-7s\n", + next_key.comm, next_key.pid, + partition ? partition->name : "Unknown"); + num_stack = next_key.kern_stack_size / + sizeof(next_key.kern_stack[0]); + for (i = 0; i < num_stack; i++) { + ksym = ksyms__map_addr(ksyms, next_key.kern_stack[i]); + printf("%s\n", ksym ? ksym->name : "Unknown"); + } + print_log2_hist(hist.slots, MAX_SLOTS, units); + printf("\n"); + lookup_key = next_key; + } + + return; +} + +int main(int argc, char **argv) +{ + struct partitions *partitions = NULL; + const struct partition *partition; + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct ksyms *ksyms = NULL; + struct biostacks_bpf *obj; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = biostacks_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF ojbect\n"); + return 1; + } + + partitions = partitions__load(); + if (!partitions) { + fprintf(stderr, "failed to load partitions info\n"); + goto cleanup; + } + + /* initialize global data (filtering options) */ + if (env.disk) { + partition = partitions__get_by_name(partitions, env.disk); + if (!partition) { + fprintf(stderr, "invaild partition name: not exit\n"); + goto cleanup; + } + obj->rodata->targ_dev = partition->dev; + } + + obj->rodata->targ_ms = env.milliseconds; + + err = biostacks_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + obj->links.blk_account_io_start = + bpf_program__attach(obj->progs.blk_account_io_start); + err = libbpf_get_error(obj->links.blk_account_io_start); + if (err) { + fprintf(stderr, "failed to attach blk_account_io_start: %s\n", + strerror(err)); + goto cleanup; + } + ksyms = ksyms__load(); + if (!ksyms) { + fprintf(stderr, "failed to load kallsyms\n"); + goto cleanup; + } + if (ksyms__get_symbol(ksyms, "blk_account_io_merge_bio")) { + obj->links.blk_account_io_merge_bio = + bpf_program__attach(obj-> + progs.blk_account_io_merge_bio); + err = libbpf_get_error(obj-> + links.blk_account_io_merge_bio); + if (err) { + fprintf(stderr, "failed to attach " + "blk_account_io_merge_bio: %s\n", + strerror(err)); + goto cleanup; + } + } + obj->links.blk_account_io_done = + bpf_program__attach(obj->progs.blk_account_io_done); + err = libbpf_get_error(obj->links.blk_account_io_done); + if (err) { + fprintf(stderr, "failed to attach blk_account_io_done: %s\n", + strerror(err)); + goto cleanup; + } + + signal(SIGINT, sig_handler); + + printf("Tracing block I/O with init stacks. Hit Ctrl-C to end.\n"); + sleep(env.duration); + print_map(ksyms, partitions, bpf_map__fd(obj->maps.hists)); + +cleanup: + biostacks_bpf__destroy(obj); + ksyms__free(ksyms); + partitions__free(partitions); + + return err != 0; +} diff --git a/libbpf-tools/biostacks.h b/libbpf-tools/biostacks.h new file mode 100644 index 000000000..fdb5999ef --- /dev/null +++ b/libbpf-tools/biostacks.h @@ -0,0 +1,27 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __BIOSTACKS_H +#define __BIOSTACKS_H + +#define DISK_NAME_LEN 32 +#define TASK_COMM_LEN 16 +#define MAX_SLOTS 20 +#define MAX_STACK 20 + +#define MINORBITS 20 +#define MINORMASK ((1U << MINORBITS) - 1) + +#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi)) + +struct rqinfo { + __u32 pid; + int kern_stack_size; + __u64 kern_stack[MAX_STACK]; + char comm[TASK_COMM_LEN]; + __u32 dev; +}; + +struct hist { + __u32 slots[MAX_SLOTS]; +}; + +#endif /* __BIOSTACKS_H */ diff --git a/libbpf-tools/trace_helpers.c b/libbpf-tools/trace_helpers.c index a1bbf81e0..9452d208b 100644 --- a/libbpf-tools/trace_helpers.c +++ b/libbpf-tools/trace_helpers.c @@ -13,6 +13,13 @@ (void) (&_min1 == &_min2); \ _min1 < _min2 ? _min1 : _min2; }) +#define DISK_NAME_LEN 32 + +#define MINORBITS 20 +#define MINORMASK ((1U << MINORBITS) - 1) + +#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi)) + struct ksyms { struct ksym *syms; int syms_sz; @@ -159,6 +166,107 @@ const struct ksym *ksyms__get_symbol(const struct ksyms *ksyms, return NULL; } +struct partitions { + struct partition *items; + int sz; +}; + +static int partitions__add_partition(struct partitions *partitions, + const char *name, unsigned int dev) +{ + struct partition *partition; + void *tmp; + + tmp = realloc(partitions->items, (partitions->sz + 1) * + sizeof(*partitions->items)); + if (!tmp) + return -1; + partitions->items = tmp; + partition = &partitions->items[partitions->sz]; + partition->name = strdup(name); + partition->dev = dev; + partitions->sz++; + + return 0; +} + +struct partitions *partitions__load(void) +{ + char part_name[DISK_NAME_LEN]; + unsigned int devmaj, devmin; + unsigned long long nop; + struct partitions *partitions; + char buf[64]; + FILE *f; + + f = fopen("/proc/partitions", "r"); + if (!f) + return NULL; + + partitions = calloc(1, sizeof(*partitions)); + if (!partitions) + goto err_out; + + while (fgets(buf, sizeof(buf), f) != NULL) { + /* skip heading */ + if (buf[0] != ' ' || buf[0] == '\n') + continue; + if (sscanf(buf, "%u %u %llu %s", &devmaj, &devmin, &nop, + part_name) != 4) + goto err_out; + if (partitions__add_partition(partitions, part_name, + MKDEV(devmaj, devmin))) + goto err_out; + } + + fclose(f); + return partitions; + +err_out: + partitions__free(partitions); + fclose(f); + return NULL; +} + +void partitions__free(struct partitions *partitions) +{ + int i; + + if (!partitions) + return; + + for (i = 0; i < partitions->sz; i++) + free(partitions->items[i].name); + free(partitions->items); + free(partitions); +} + +const struct partition * +partitions__get_by_dev(const struct partitions *partitions, unsigned int dev) +{ + int i; + + for (i = 0; i < partitions->sz; i++) { + if (partitions->items[i].dev == dev) + return &partitions->items[i]; + } + + return NULL; +} + +const struct partition * +partitions__get_by_name(const struct partitions *partitions, const char *name) +{ + int i; + + for (i = 0; i < partitions->sz; i++) { + if (strcmp(partitions->items[i].name, name) == 0) + return &partitions->items[i]; + } + + return NULL; +} + static void print_stars(unsigned int val, unsigned int val_max, int width) { int num_stars, num_spaces, i; diff --git a/libbpf-tools/trace_helpers.h b/libbpf-tools/trace_helpers.h index 8d9510441..eba6bc1c5 100644 --- a/libbpf-tools/trace_helpers.h +++ b/libbpf-tools/trace_helpers.h @@ -18,6 +18,20 @@ const struct ksym *ksyms__map_addr(const struct ksyms *ksyms, const struct ksym *ksyms__get_symbol(const struct ksyms *ksyms, const char *name); +struct partition { + char *name; + unsigned int dev; +}; + +struct partitions; + +struct partitions *partitions__load(void); +void partitions__free(struct partitions *partitions); +const struct partition * +partitions__get_by_dev(const struct partitions *partitions, unsigned int dev); +const struct partition * +partitions__get_by_name(const struct partitions *partitions, const char *name); + void print_log2_hist(unsigned int *vals, int vals_size, char *val_type); unsigned long long get_ktime_ns(void); From a79ec23adac0b267f1547b938392121da7403eea Mon Sep 17 00:00:00 2001 From: Yonghong Song <yhs@fb.com> Date: Sat, 22 Aug 2020 10:07:57 -0700 Subject: [PATCH 228/278] sync libbpf repo release 0.1.0 Signed-off-by: Yonghong Song <yhs@fb.com> --- src/cc/libbpf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cc/libbpf b/src/cc/libbpf index bf3ab4b0d..e8547bd4f 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit bf3ab4b0d8f9256f11d3e048be3f9124f7ed4d18 +Subproject commit e8547bd4f7d5ebbf35c2e37e943a0ca2d5af8b4c From fecd934a9c0ff581890d218ff6c5101694e9b326 Mon Sep 17 00:00:00 2001 From: Yonghong Song <yhs@fb.com> Date: Sat, 22 Aug 2020 12:09:44 -0700 Subject: [PATCH 229/278] prepare for release v0.16.0 add changelog for release v0.16.0 Signed-off-by: Yonghong Song <yhs@fb.com> --- debian/changelog | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/debian/changelog b/debian/changelog index 2b559f256..ce63b7f93 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,15 @@ +bcc (0.16.0-1) unstable; urgency=low + + * Support for kernel up to 5.8 + * trace.py: support kprobe/uprobe func offset + * support raw perf config for perf_event_open in python + * add BPFQueueStackTable support + * added Ringbuf support support + * libbpf-tools: readahead, biosnoop, bitesize, tcpconnlat, biopattern, biostacks + * bug fixes and some additional arguments for tools + + -- Yonghong Song <ys114321@gmail.com> Sat, 22 Aug 2020 17:00:00 +0000 + bcc (0.15.0-1) unstable; urgency=low * Support for kernel up to 5.7 From 43910c44121999592833cf20e8334997f2b6c470 Mon Sep 17 00:00:00 2001 From: Yonghong Song <yhs@fb.com> Date: Sat, 22 Aug 2020 15:19:46 -0700 Subject: [PATCH 230/278] sync with libbpf repo sync with latest libbpf repo. Strut definition for btf_ext_header is defined in libbpf/src/btf.h previously and used by bcc. Now, the struct is moved to libbpf/src/libbpf_internal.h and not available to bcc. We do not want to include libbpf/src/libbpf_internal.h as it is really libbpf internal. Let us define bcc version of btf_ext_header with struct name bcc_btf_ext_header. The new name is to avoid conflict when compiling with old libbpf package. Signed-off-by: Yonghong Song <yhs@fb.com> --- src/cc/bcc_btf.cc | 2 +- src/cc/bcc_btf.h | 17 +++++++++++++++++ src/cc/compat/linux/virtual_bpf.h | 17 ++++++++++++----- src/cc/libbpf | 2 +- 4 files changed, 31 insertions(+), 7 deletions(-) diff --git a/src/cc/bcc_btf.cc b/src/cc/bcc_btf.cc index e220f117c..1056950c1 100644 --- a/src/cc/bcc_btf.cc +++ b/src/cc/bcc_btf.cc @@ -185,7 +185,7 @@ void BTF::adjust(uint8_t *btf_sec, uintptr_t btf_sec_size, } struct btf_header *hdr = (struct btf_header *)btf_sec; - struct btf_ext_header *ehdr = (struct btf_ext_header *)btf_ext_sec; + struct bcc_btf_ext_header *ehdr = (struct bcc_btf_ext_header *)btf_ext_sec; // Fixup btf for old kernels or kernel requirements. fixup_btf(btf_sec + hdr->hdr_len + hdr->type_off, hdr->type_len, diff --git a/src/cc/bcc_btf.h b/src/cc/bcc_btf.h index 438c1f73f..75b47cc36 100644 --- a/src/cc/bcc_btf.h +++ b/src/cc/bcc_btf.h @@ -45,6 +45,23 @@ class BTFStringTable { }; class BTF { + struct bcc_btf_ext_header { + uint16_t magic; + uint8_t version; + uint8_t flags; + uint32_t hdr_len; + + /* All offsets are in bytes relative to the end of this header */ + uint32_t func_info_off; + uint32_t func_info_len; + uint32_t line_info_off; + uint32_t line_info_len; + + /* optional part of .BTF.ext header */ + uint32_t core_relo_off; + uint32_t core_relo_len; +}; + public: BTF(bool debug, sec_map_def &sections); ~BTF(); diff --git a/src/cc/compat/linux/virtual_bpf.h b/src/cc/compat/linux/virtual_bpf.h index 382626303..0387b9707 100644 --- a/src/cc/compat/linux/virtual_bpf.h +++ b/src/cc/compat/linux/virtual_bpf.h @@ -768,7 +768,7 @@ union bpf_attr { * * Also, note that **bpf_trace_printk**\ () is slow, and should * only be used for debugging purposes. For this reason, a notice - * bloc (spanning several lines) is printed to kernel logs and + * block (spanning several lines) is printed to kernel logs and * states that the helper should not be used "for production use" * the first time this helper is used (or more precisely, when * **trace_printk**\ () buffers are allocated). For passing values @@ -1034,14 +1034,14 @@ union bpf_attr { * * int ret; * struct bpf_tunnel_key key = {}; - * + * * ret = bpf_skb_get_tunnel_key(skb, &key, sizeof(key), 0); * if (ret < 0) * return TC_ACT_SHOT; // drop packet - * + * * if (key.remote_ipv4 != 0x0a000001) * return TC_ACT_SHOT; // drop packet - * + * * return TC_ACT_OK; // accept packet * * This interface can also be used with all encapsulation devices @@ -1148,7 +1148,7 @@ union bpf_attr { * Description * Retrieve the realm or the route, that is to say the * **tclassid** field of the destination for the *skb*. The - * indentifier retrieved is a user-provided tag, similar to the + * identifier retrieved is a user-provided tag, similar to the * one used with the net_cls cgroup (see description for * **bpf_get_cgroup_classid**\ () helper), but here this tag is * held by a route (a destination entry), not by a task. @@ -4072,6 +4072,13 @@ struct bpf_link_info { __u64 cgroup_id; __u32 attach_type; } cgroup; + struct { + __aligned_u64 target_name; /* in/out: target_name buffer ptr */ + __u32 target_name_len; /* in/out: target_name buffer len */ + union { + __u32 map_id; + } map; + } iter; struct { __u32 netns_ino; __u32 attach_type; diff --git a/src/cc/libbpf b/src/cc/libbpf index e8547bd4f..4001a658e 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit e8547bd4f7d5ebbf35c2e37e943a0ca2d5af8b4c +Subproject commit 4001a658e05f4385cc7764bbe0e6a110be26a468 From 60de17161fe7f44b534a8da343edbad2427220e3 Mon Sep 17 00:00:00 2001 From: Chen Guanqiao <chen.chenchacha@foxmail.com> Date: Wed, 26 Aug 2020 20:35:12 +0800 Subject: [PATCH 231/278] fix the exits abnormal due to trace buffer Some data may be left in the trace buffer, and the format cannot be parsed by trace_fields(), which whill cause an abnormality in the system. Re-running the program cannot solved, only restart kernel. Call trace: File "/usr/lib/python2.7/site-packages/kwaibcc/__init__.py", line 1273, in trace_fields pid, cpu, flags, ts = line[:ts_end].split() ValueError: need more than 2 values to unpack Prevent problems with exception handling. Signed-off-by: Chen Guanqiao <chen.chenchacha@foxmail.com> --- src/python/bcc/__init__.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/python/bcc/__init__.py b/src/python/bcc/__init__.py index 46f738bce..8d87945c7 100644 --- a/src/python/bcc/__init__.py +++ b/src/python/bcc/__init__.py @@ -1278,7 +1278,10 @@ def trace_fields(self, nonblocking=False): task = line[:16].lstrip() line = line[17:] ts_end = line.find(b":") - pid, cpu, flags, ts = line[:ts_end].split() + try: + pid, cpu, flags, ts = line[:ts_end].split() + except Exception as e: + continue cpu = cpu[1:-1] # line[ts_end:] will have ": [sym_or_addr]: msgs" # For trace_pipe debug output, the addr typically @@ -1290,7 +1293,10 @@ def trace_fields(self, nonblocking=False): line = line[ts_end + 1:] sym_end = line.find(b":") msg = line[sym_end + 2:] - return (task, int(pid), int(cpu), flags, float(ts), msg) + try: + return (task, int(pid), int(cpu), flags, float(ts), msg) + except Exception as e: + return ("Unknown", 0, 0, "Unknown", 0.0, "Unknown") def trace_readline(self, nonblocking=False): """trace_readline(nonblocking=False) From fc92caa08f52533dd18cff6bf9e3438c75ca5cb3 Mon Sep 17 00:00:00 2001 From: zhuangqh <zhuangqhc@gmail.com> Date: Thu, 27 Aug 2020 16:11:44 +0800 Subject: [PATCH 232/278] doc: fix mismatched link Signed-off-by: zhuangqh <zhuangqhc@gmail.com> --- docs/tutorial_bcc_python_developer.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorial_bcc_python_developer.md b/docs/tutorial_bcc_python_developer.md index b3b8ed6ba..bf068e29b 100644 --- a/docs/tutorial_bcc_python_developer.md +++ b/docs/tutorial_bcc_python_developer.md @@ -48,7 +48,7 @@ Improve it by printing "Tracing sys_sync()... Ctrl-C to end." when the program f ### Lesson 3. hello_fields.py -This program is in [examples/tracing/hello_fields.py](../examples/tracing/trace_fields.py). Sample output (run commands in another session): +This program is in [examples/tracing/hello_fields.py](../examples/tracing/hello_fields.py). Sample output (run commands in another session): ``` # ./examples/tracing/hello_fields.py From 0e7304eab277320bf0b0014a3940541aadea03e0 Mon Sep 17 00:00:00 2001 From: Kenta Tada <Kenta.Tada@sony.com> Date: Tue, 1 Sep 2020 18:15:41 +0900 Subject: [PATCH 233/278] tools/capable: support new capabilities This commit adds the support of below capabilities. * CAP_PERFMON * CAP_BPF * CAP_CHECKPOINT_RESTORE Signed-off-by: Kenta Tada <Kenta.Tada@sony.com> --- tools/capable.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tools/capable.py b/tools/capable.py index 94d1c32a3..b89f2af9c 100755 --- a/tools/capable.py +++ b/tools/capable.py @@ -97,6 +97,9 @@ 35: "CAP_WAKE_ALARM", 36: "CAP_BLOCK_SUSPEND", 37: "CAP_AUDIT_READ", + 38: "CAP_PERFMON", + 39: "CAP_BPF", + 40: "CAP_CHECKPOINT_RESTORE", } class Enum(set): From 892475f3c9a98fba4188a5077623e44e2fca9c5e Mon Sep 17 00:00:00 2001 From: Ubuntu <ubuntu@instance-ebpf-1.asia-east2-a.c.formal-outpost-272803.internal> Date: Mon, 31 Aug 2020 09:43:19 +0000 Subject: [PATCH 234/278] fix retruning typo --- examples/networking/http_filter/http-parse-complete.c | 2 +- examples/networking/http_filter/http-parse-simple.c | 2 +- examples/networking/vlan_filter/data-plane-tracing.c | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/examples/networking/http_filter/http-parse-complete.c b/examples/networking/http_filter/http-parse-complete.c index 01a234ea2..61cee0fba 100644 --- a/examples/networking/http_filter/http-parse-complete.c +++ b/examples/networking/http_filter/http-parse-complete.c @@ -138,7 +138,7 @@ int http_filter(struct __sk_buff *skb) { } goto DROP; - //keep the packet and send it to userspace retruning -1 + //keep the packet and send it to userspace returning -1 HTTP_MATCH: //if not already present, insert into map <Key, Leaf> sessions.lookup_or_try_init(&key,&zero); diff --git a/examples/networking/http_filter/http-parse-simple.c b/examples/networking/http_filter/http-parse-simple.c index 6ec53023e..292cb7b44 100644 --- a/examples/networking/http_filter/http-parse-simple.c +++ b/examples/networking/http_filter/http-parse-simple.c @@ -103,7 +103,7 @@ int http_filter(struct __sk_buff *skb) { //no HTTP match goto DROP; - //keep the packet and send it to userspace retruning -1 + //keep the packet and send it to userspace returning -1 KEEP: return -1; diff --git a/examples/networking/vlan_filter/data-plane-tracing.c b/examples/networking/vlan_filter/data-plane-tracing.c index 8b725a517..59c292d0e 100644 --- a/examples/networking/vlan_filter/data-plane-tracing.c +++ b/examples/networking/vlan_filter/data-plane-tracing.c @@ -44,11 +44,11 @@ int vlan_filter(struct __sk_buff *skb) { default: goto DROP; } - //keep the packet and send it to userspace retruning -1 + //keep the packet and send it to userspace returning -1 KEEP: return -1; //drop the packet returning 0 DROP: return 0; -} \ No newline at end of file +} From 43440348edc4e4687e370427f66a16fca0f34e91 Mon Sep 17 00:00:00 2001 From: Rafael Fonseca <r4f4rfs@gmail.com> Date: Wed, 2 Sep 2020 09:59:11 +0200 Subject: [PATCH 235/278] tests: only run arg parser test on supported arches Fixes #3077 Signed-off-by: Rafael Fonseca <r4f4rfs@gmail.com> --- tests/cc/test_usdt_args.cc | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/cc/test_usdt_args.cc b/tests/cc/test_usdt_args.cc index c2c5fff36..b8db58d25 100644 --- a/tests/cc/test_usdt_args.cc +++ b/tests/cc/test_usdt_args.cc @@ -52,6 +52,10 @@ static void verify_register(USDT::ArgumentParser &parser, int arg_size, REQUIRE(arg.scale() == scale); } +/* supported arches only */ +#if defined(__aarch64__) || defined(__powerpc64__) || \ + defined(__s390x__) || defined(__x86_64__) + TEST_CASE("test usdt argument parsing", "[usdt]") { SECTION("parse failure") { #ifdef __aarch64__ @@ -205,3 +209,5 @@ TEST_CASE("test usdt argument parsing", "[usdt]") { REQUIRE(parser.done()); } } + +#endif /* supported arches only */ From 7ac370b97bc9284105598460160875b2e5235018 Mon Sep 17 00:00:00 2001 From: Patrick Robinson <patrick.robinson@envato.com> Date: Fri, 4 Sep 2020 11:58:45 +1000 Subject: [PATCH 236/278] Add instructions on how to install amazon linux 2 from source --- INSTALL.md | 42 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 41 insertions(+), 1 deletion(-) diff --git a/INSTALL.md b/INSTALL.md index fa9831cef..a2c3d107a 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -537,7 +537,7 @@ make sudo make install ``` -## Amazon Linux - Source +## Amazon Linux 1 - Source Tested on Amazon Linux AMI release 2018.03 (kernel 4.14.47-56.37.amzn1.x86_64) @@ -582,6 +582,46 @@ sudo mount -t debugfs debugfs /sys/kernel/debug sudo /usr/share/bcc/tools/execsnoop ``` +## Amazon Linux 2 - Source + +``` +# enable epel to get iperf, luajit, luajit-devel, cmake3 (cmake3 is required to support c++11) +sudo yum-config-manager --enable epel + +sudo yum install -y bison cmake3 ethtool flex git iperf libstdc++-static python-netaddr gcc gcc-c++ make zlib-devel elfutils-libelf-devel +sudo yum install -y luajit luajit-devel +sudo yum install -y http://repo.iovisor.org/yum/extra/mageia/cauldron/x86_64/netperf-2.7.0-1.mga6.x86_64.rpm +sudo pip install pyroute2 +sudo yum install -y ncurses-devel +``` + +### Install clang +``` +yum install -y clang llvm llvm-devel llvm-static clang-devel clang-libs +``` + +### Build bcc +``` +git clone https://github.com/iovisor/bcc.git +pushd . +mkdir bcc/build; cd bcc/build +cmake3 .. +time make +sudo make install +popd +``` + +### Setup required to run the tools +``` +sudo yum -y install kernel-devel-$(uname -r) +sudo mount -t debugfs debugfs /sys/kernel/debug +``` + +### Test +``` +sudo /usr/share/bcc/tools/execsnoop +``` + ## Alpine - Source ### Install packages required for building From b8e661fb8238cdf3b2cfa6575e843dc3a2f7f3ec Mon Sep 17 00:00:00 2001 From: Amir Goldstein <amir73il@gmail.com> Date: Thu, 3 Sep 2020 09:48:31 +0300 Subject: [PATCH 237/278] memleak: fix false positive on failed allocations memleak tool reports a failed allocation as a leak, because the NULL address is never freed. Signed-off-by: Amir Goldstein <amir73il@gmail.com> --- tools/memleak.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/tools/memleak.py b/tools/memleak.py index 0800135e6..6cda15066 100755 --- a/tools/memleak.py +++ b/tools/memleak.py @@ -209,10 +209,12 @@ def run_command_get_pid(command): info.size = *size64; sizes.delete(&pid); - info.timestamp_ns = bpf_ktime_get_ns(); - info.stack_id = stack_traces.get_stackid(ctx, STACK_FLAGS); - allocs.update(&address, &info); - update_statistics_add(info.stack_id, info.size); + if (address != 0) { + info.timestamp_ns = bpf_ktime_get_ns(); + info.stack_id = stack_traces.get_stackid(ctx, STACK_FLAGS); + allocs.update(&address, &info); + update_statistics_add(info.stack_id, info.size); + } if (SHOULD_PRINT) { bpf_trace_printk("alloc exited, size = %lu, result = %lx\\n", From e42ac4176998a6dcf0dbf3b6befeaad0a69cb98a Mon Sep 17 00:00:00 2001 From: zhenwei pi <pizhenwei@bytedance.com> Date: Sun, 23 Aug 2020 19:17:52 +0800 Subject: [PATCH 238/278] tools/tcprtt: add tcprtt to trace the RTT of TCP This program traces TCP RTT(round-trip time) to analyze the quality of network, then help us to distinguish the network latency trouble is from user process or physical network. Currently, support source address/port and destination address/port as tcp filter. Suggested-by: Edward Wu <edwardwu@realtek.com> Suggested-by: Martin KaFai Lau <kafai@fb.com> Signed-off-by: zhenwei pi <pizhenwei@bytedance.com> --- man/man8/tcprtt.8 | 76 ++++++++++++++++++ tools/tcprtt.py | 169 +++++++++++++++++++++++++++++++++++++++ tools/tcprtt_example.txt | 83 +++++++++++++++++++ 3 files changed, 328 insertions(+) create mode 100644 man/man8/tcprtt.8 create mode 100755 tools/tcprtt.py create mode 100644 tools/tcprtt_example.txt diff --git a/man/man8/tcprtt.8 b/man/man8/tcprtt.8 new file mode 100644 index 000000000..5c3bb89b9 --- /dev/null +++ b/man/man8/tcprtt.8 @@ -0,0 +1,76 @@ +.TH tcprtt 8 "2020-08-23" "USER COMMANDS" +.SH NAME +tcprtt \- Trace TCP RTT of established connections. Uses Linux eBPF/bcc. +.SH SYNOPSIS +.B tcprtt [\-h] [\-T] [\-D] [\-m] [\-i INTERVAL] [\-d DURATION] +.SH DESCRIPTION +This tool traces established connections RTT(round-trip time) to analyze the +quality of network. This can be useful for general troubleshooting to +distinguish the network latency is from user process or physical network. + +Since this uses BPF, only the root user can use this tool. +.SH REQUIREMENTS +CONFIG_BPF and bcc. +.SH OPTIONS +.TP +\-h +Print usage message. +.TP +\-T +Include a time column on output (HH:MM:SS). +.TP +\-D +Show debug infomation of bpf text. +.TP +\-m +Output histogram in milliseconds. +.TP +\-i INTERVAL +Print output every interval seconds. +.TP +\-d DURATION +Total duration of trace in seconds. +.TP +\-p SPORT +Filter for source port. +.TP +\-P DPORT +Filter for destination port. +.TP +\-a SADDR +Filter for source address. +.TP +\-A DADDR +Filter for destination address. +.SH EXAMPLES +.TP +Trace TCP RTT and print 1 second summaries, 10 times: +# +.B tcprtt \-i 1 \-d 10 +.TP +Summarize in millisecond, and timestamps: +# +.B tcprtt \-m \-T +.TP +Only trace TCP RTT for destination address 192.168.1.100 and destination port 80: +# +.B tcprtt \-i 1 \-d 10 -A 192.168.1.100 -P 80 +.SH OVERHEAD +This traces the kernel tcp_rcv_established function and collects TCP RTT. The +rate of this depends on your server application. If it is a web or proxy server +accepting many tens of thousands of connections per second. +.SH SOURCE +This is from bcc. +.IP +https://github.com/iovisor/bcc +.PP +Also look in the bcc distribution for a companion _examples.txt file containing +example usage, output, and commentary for this tool. +.SH OS +Linux +.SH STABILITY +Unstable - in development. +.SH AUTHOR +zhenwei pi +.SH SEE ALSO +tcptracer(8), tcpconnect(8), funccount(8), tcpdump(8) diff --git a/tools/tcprtt.py b/tools/tcprtt.py new file mode 100755 index 000000000..81832cf0f --- /dev/null +++ b/tools/tcprtt.py @@ -0,0 +1,169 @@ +#!/usr/bin/python +# @lint-avoid-python-3-compatibility-imports +# +# tcprtt Summarize TCP RTT as a histogram. For Linux, uses BCC, eBPF. +# +# USAGE: tcprtt [-h] [-T] [-D] [-m] [-i INTERVAL] [-d DURATION] +# [-p SPORT] [-P DPORT] [-a SADDR] [-A DADDR] +# +# Copyright (c) 2020 zhenwei pi +# Licensed under the Apache License, Version 2.0 (the "License") +# +# 23-AUG-2020 zhenwei pi Created this. + +from __future__ import print_function +from bcc import BPF +from time import sleep, strftime +import socket, struct +import argparse + +# arguments +examples = """examples: + ./tcprtt # summarize TCP RTT + ./tcprtt -i 1 -d 10 # print 1 second summaries, 10 times + ./tcprtt -m -T # summarize in millisecond, and timestamps + ./tcprtt -p # filter for source port + ./tcprtt -P # filter for destination port + ./tcprtt -a # filter for source address + ./tcprtt -A # filter for destination address + ./tcprtt -D # show debug bpf text +""" +parser = argparse.ArgumentParser( + description="Summarize TCP RTT as a histogram", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=examples) +parser.add_argument("-i", "--interval", + help="summary interval, seconds") +parser.add_argument("-d", "--duration", type=int, default=99999, + help="total duration of trace, seconds") +parser.add_argument("-T", "--timestamp", action="store_true", + help="include timestamp on output") +parser.add_argument("-m", "--milliseconds", action="store_true", + help="millisecond histogram") +parser.add_argument("-p", "--sport", + help="source port") +parser.add_argument("-P", "--dport", + help="destination port") +parser.add_argument("-a", "--saddr", + help="source address") +parser.add_argument("-A", "--daddr", + help="destination address") +parser.add_argument("-D", "--debug", action="store_true", + help="print BPF program before starting (for debugging purposes)") +parser.add_argument("--ebpf", action="store_true", + help=argparse.SUPPRESS) +args = parser.parse_args() +if not args.interval: + args.interval = args.duration + +# define BPF program +bpf_text = """ +#ifndef KBUILD_MODNAME +#define KBUILD_MODNAME "bcc" +#endif +#include <uapi/linux/ptrace.h> +#include <linux/tcp.h> +#include <net/sock.h> +#include <net/inet_sock.h> +#include <bcc/proto.h> + +BPF_HISTOGRAM(hist_srtt); + +int trace_tcp_rcv(struct pt_regs *ctx, struct sock *sk, struct sk_buff *skb) +{ + struct tcp_sock *ts = tcp_sk(sk); + u32 srtt = ts->srtt_us >> 3; + const struct inet_sock *inet = inet_sk(sk); + + SPORTFILTER + DPORTFILTER + SADDRFILTER + DADDRFILTER + FACTOR + + hist_srtt.increment(bpf_log2l(srtt)); + + return 0; +} +""" + +# filter for source port +if args.sport: + bpf_text = bpf_text.replace(b'SPORTFILTER', + b"""u16 sport = 0; + bpf_probe_read_kernel(&sport, sizeof(sport), (void *)&inet->inet_sport); + if (ntohs(sport) != %d) + return 0;""" % int(args.sport)) +else: + bpf_text = bpf_text.replace(b'SPORTFILTER', b'') + +# filter for dest port +if args.dport: + bpf_text = bpf_text.replace(b'DPORTFILTER', + b"""u16 dport = 0; + bpf_probe_read_kernel(&dport, sizeof(dport), (void *)&inet->inet_dport); + if (ntohs(dport) != %d) + return 0;""" % int(args.dport)) +else: + bpf_text = bpf_text.replace(b'DPORTFILTER', b'') + +# filter for source address +if args.saddr: + bpf_text = bpf_text.replace(b'SADDRFILTER', + b"""u32 saddr = 0; + bpf_probe_read_kernel(&saddr, sizeof(saddr), (void *)&inet->inet_saddr); + if (saddr != %d) + return 0;""" % struct.unpack("=I", socket.inet_aton(args.saddr))[0]) +else: + bpf_text = bpf_text.replace(b'SADDRFILTER', b'') + +# filter for source address +if args.daddr: + bpf_text = bpf_text.replace(b'DADDRFILTER', + b"""u32 daddr = 0; + bpf_probe_read_kernel(&daddr, sizeof(daddr), (void *)&inet->inet_daddr); + if (daddr != %d) + return 0;""" % struct.unpack("=I", socket.inet_aton(args.daddr))[0]) +else: + bpf_text = bpf_text.replace(b'DADDRFILTER', b'') + +# show msecs or usecs[default] +if args.milliseconds: + bpf_text = bpf_text.replace('FACTOR', 'srtt /= 1000;') + label = "msecs" +else: + bpf_text = bpf_text.replace('FACTOR', '') + label = "usecs" + +# debug/dump ebpf enable or not +if args.debug or args.ebpf: + print(bpf_text) + if args.ebpf: + exit() + +# load BPF program +b = BPF(text=bpf_text) +b.attach_kprobe(event="tcp_rcv_established", fn_name="trace_tcp_rcv") + +print("Tracing TCP RTT... Hit Ctrl-C to end.") + +# output +exiting = 0 if args.interval else 1 +dist = b.get_table("hist_srtt") +seconds = 0 +while (1): + try: + sleep(int(args.interval)) + seconds = seconds + int(args.interval) + except KeyboardInterrupt: + exiting = 1 + + print() + if args.timestamp: + print("%-8s\n" % strftime("%H:%M:%S"), end="") + + dist.print_log2_hist(label, "srtt") + dist.clear() + + if exiting or seconds >= args.duration: + exit() diff --git a/tools/tcprtt_example.txt b/tools/tcprtt_example.txt new file mode 100644 index 000000000..9a3d2356b --- /dev/null +++ b/tools/tcprtt_example.txt @@ -0,0 +1,83 @@ +Demonstrations of tcprtt, the Linux eBPF/bcc version. + + +This program traces TCP RTT(round-trip time) to analyze the quality of +network, then help us to distinguish the network latency trouble is from +user process or physical network. + +For example, wrk show the http request latency distribution: +# wrk -d 30 -c 10 --latency http://192.168.122.100/index.html +Running 30s test @ http://192.168.122.100/index.html + 2 threads and 10 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 86.75ms 153.76ms 1.54s 90.85% + Req/Sec 160.91 76.07 424.00 67.06% + Latency Distribution + 50% 14.55ms + 75% 119.21ms + 90% 230.22ms + 99% 726.90ms + 9523 requests in 30.02s, 69.62MB read + Socket errors: connect 0, read 0, write 0, timeout 1 + +During wrk testing, run tcprtt: +# ./tcprtt -i 1 -d 10 -m +Tracing TCP RTT... Hit Ctrl-C to end. + msecs : count distribution + 0 -> 1 : 4 | | + 2 -> 3 : 0 | | + 4 -> 7 : 1055 |****************************************| + 8 -> 15 : 26 | | + 16 -> 31 : 0 | | + 32 -> 63 : 0 | | + 64 -> 127 : 18 | | + 128 -> 255 : 14 | | + 256 -> 511 : 14 | | + 512 -> 1023 : 12 | | + +The wrk output shows that the latency of web service is not stable, and tcprtt +also shows unstable TCP RTT. So in this situation, we need to make sure the +quality of network is good or not firstly. + + +Use filter for address and(or) port. Ex, only collect source address 192.168.122.200 +and destination address 192.168.122.100 and destination port 80. +# ./tcprtt -i 1 -d 10 -m -a 192.168.122.200 -A 192.168.122.100 -P 80 + + +Full USAGE: + +# ./tcprtt -h +usage: tcprtt [-h] [-i INTERVAL] [-d DURATION] [-T] [-m] [-p SPORT] + [-P DPORT] [-a SADDR] [-A DADDR] [-D] + +Summarize TCP RTT as a histogram + +optional arguments: + -h, --help show this help message and exit + -i INTERVAL, --interval INTERVAL + summary interval, seconds + -d DURATION, --duration DURATION + total duration of trace, seconds + -T, --timestamp include timestamp on output + -m, --milliseconds millisecond histogram + -p SPORT, --sport SPORT + source port + -P DPORT, --dport DPORT + destination port + -a SADDR, --saddr SADDR + source address + -A DADDR, --daddr DADDR + destination address + -D, --debug print BPF program before starting (for debugging + purposes) + +examples: + ./tcprtt # summarize TCP RTT + ./tcprtt -i 1 -d 10 # print 1 second summaries, 10 times + ./tcprtt -m -T # summarize in millisecond, and timestamps + ./tcprtt -p # filter for source port + ./tcprtt -P # filter for destination port + ./tcprtt -a # filter for source address + ./tcprtt -A # filter for destination address + ./tcprtt -D # show debug bpf text From ba73657cb8c4dab83dfb89eed4a8b3866255569a Mon Sep 17 00:00:00 2001 From: Hao <1075808668@qq.com> Date: Sat, 12 Sep 2020 02:05:29 +0800 Subject: [PATCH 239/278] Netqtop 3037 (#3048) The tool netqtop uses tracepoints NET_DEV_START_XMIT and NETIF_RECEIVE_SKB to intercept every transmitted and received packet, as a result, considerable performance descent is expected. Details for some performance evaluation can be found at https://github.com/iovisor/bcc/pull/3048 --- README.md | 1 + man/man8/netqtop.8 | 56 ++++++++++ tools/netqtop.c | 113 ++++++++++++++++++++ tools/netqtop.py | 218 ++++++++++++++++++++++++++++++++++++++ tools/netqtop_example.txt | 190 +++++++++++++++++++++++++++++++++ 5 files changed, 578 insertions(+) create mode 100644 man/man8/netqtop.8 create mode 100644 tools/netqtop.c create mode 100755 tools/netqtop.py create mode 100644 tools/netqtop_example.txt diff --git a/README.md b/README.md index 58340622d..d54e3848f 100644 --- a/README.md +++ b/README.md @@ -128,6 +128,7 @@ pair of .c and .py files, and some are directories of files. - tools/[memleak](tools/memleak.py): Display outstanding memory allocations to find memory leaks. [Examples](tools/memleak_example.txt). - tools/[mountsnoop](tools/mountsnoop.py): Trace mount and umount syscalls system-wide. [Examples](tools/mountsnoop_example.txt). - tools/[mysqld_qslower](tools/mysqld_qslower.py): Trace MySQL server queries slower than a threshold. [Examples](tools/mysqld_qslower_example.txt). +- tools/[netqtop](tools/netqtop.py) tools/[netqtop.c](tools/netqtop.c): Trace and display packets distribution on NIC queues. [Examples](tools/netqtop_example.txt). - tools/[nfsslower](tools/nfsslower.py): Trace slow NFS operations. [Examples](tools/nfsslower_example.txt). - tools/[nfsdist](tools/nfsdist.py): Summarize NFS operation latency distribution as a histogram. [Examples](tools/nfsdist_example.txt). - tools/[offcputime](tools/offcputime.py): Summarize off-CPU time by kernel stack trace. [Examples](tools/offcputime_example.txt). diff --git a/man/man8/netqtop.8 b/man/man8/netqtop.8 new file mode 100644 index 000000000..bfa34d11f --- /dev/null +++ b/man/man8/netqtop.8 @@ -0,0 +1,56 @@ +.TH netqtop 8 "2020-07-30" "USER COMMANDS" +.SH NAME +netqtop \- Summarize PPS, BPS, average size of packets and packet counts ordered by packet sizes +on each queue of a network interface. +.SH SYNOPSIS +.B netqtop [\-n nic] [\-i interval] [\-t throughput] +.SH DESCRIPTION +netqtop accounts statistics of both transmitted and received packets on each queue of +a specified network interface to help developers check if its traffic load is balanced. +The result is displayed as a table with columns of PPS, BPS, average size and +packet counts in range [0,64), [64, 5120), [512, 2048), [2048, 16K), [16K, 64K). +This is printed every given interval (default 1) in seconds. + +The tool uses the net:net_dev_start_xmit and net:netif_receive_skb kernel tracepoints. +Since it uses tracepoint, the tool only works on Linux 4.7+. + +netqtop introduces significant overhead while network traffic is large. See OVERHEAD +section below. + +.SH REQUIREMENTS +CONFIG_bpf and bcc +.SH OPTIONS +.TP +\-n NIC +Specify the network interface card +.TP +\-i INTERVAL +Print results every INTERVAL seconds. +The default value is 1. +.TP +\-t THROUGHPUT +Print BPS and PPS of each queue. +.SH EXAMPLES +.TP +Account statistics of eth0 and output every 2 seconds: +# +.B netqtop -n eth0 -i 1 +.SH OVERHEAD +In performance test, netqtop introduces a overhead up to 30% PPS drop +while printing interval is set to 1 second. So be mindful of potential packet drop +when using this tool. + +It also increases ping-pong latency by about 1 usec. +.SH SOURCE +This is from bcc +.IP +https://github.com/iovisor/bcc +.PP +Also look in the bcc distribution for a netqtop_example.txt file containing +example usage, output and commentary for this tool. +.SH OS +Linux +.SH STABILITY +Unstable - in development +.SH AUTHOR +Yolandajn diff --git a/tools/netqtop.c b/tools/netqtop.c new file mode 100644 index 000000000..52605ddab --- /dev/null +++ b/tools/netqtop.c @@ -0,0 +1,113 @@ + +#include <linux/netdevice.h> +#include <linux/ethtool.h> +#if IFNAMSIZ != 16 +#error "IFNAMSIZ != 16 is not supported" +#endif +#define MAX_QUEUE_NUM 1024 + +/** +* This union is use to store name of the specified interface +* and read it as two different data types +*/ +union name_buf{ + char name[IFNAMSIZ]; + struct { + u64 hi; + u64 lo; + }name_int; +}; + +/* data retrieved in tracepoints */ +struct queue_data{ + u64 total_pkt_len; + u32 num_pkt; + u32 size_64B; + u32 size_512B; + u32 size_2K; + u32 size_16K; + u32 size_64K; +}; + +/* array of length 1 for device name */ +BPF_ARRAY(name_map, union name_buf, 1); +/* table for transmit & receive packets */ +BPF_HASH(tx_q, u16, struct queue_data, MAX_QUEUE_NUM); +BPF_HASH(rx_q, u16, struct queue_data, MAX_QUEUE_NUM); + +static inline int name_filter(struct sk_buff* skb){ + /* get device name from skb */ + union name_buf real_devname; + struct net_device *dev; + bpf_probe_read(&dev, sizeof(skb->dev), ((char *)skb + offsetof(struct sk_buff, dev))); + bpf_probe_read(&real_devname, IFNAMSIZ, dev->name); + + int key=0; + union name_buf *leaf = name_map.lookup(&key); + if(!leaf){ + return 0; + } + if((leaf->name_int).hi != real_devname.name_int.hi || (leaf->name_int).lo != real_devname.name_int.lo){ + return 0; + } + + return 1; +} + +static void updata_data(struct queue_data *data, u64 len){ + data->total_pkt_len += len; + data->num_pkt ++; + if(len / 64 == 0){ + data->size_64B ++; + } + else if(len / 512 == 0){ + data->size_512B ++; + } + else if(len / 2048 == 0){ + data->size_2K ++; + } + else if(len / 16384 == 0){ + data->size_16K ++; + } + else if(len / 65536 == 0){ + data->size_64K ++; + } +} + +TRACEPOINT_PROBE(net, net_dev_start_xmit){ + /* read device name */ + struct sk_buff* skb = (struct sk_buff*)args->skbaddr; + if(!name_filter(skb)){ + return 0; + } + + /* update table */ + u16 qid = skb->queue_mapping; + struct queue_data newdata; + __builtin_memset(&newdata, 0, sizeof(newdata)); + struct queue_data *data = tx_q.lookup_or_try_init(&qid, &newdata); + if(!data){ + return 0; + } + updata_data(data, skb->len); + + return 0; +} + +TRACEPOINT_PROBE(net, netif_receive_skb){ + struct sk_buff* skb = (struct sk_buff*)args->skbaddr; + if(!name_filter(skb)){ + return 0; + } + + u16 qid = skb->queue_mapping; + struct queue_data newdata; + __builtin_memset(&newdata, 0, sizeof(newdata)); + struct queue_data *data = rx_q.lookup_or_try_init(&qid, &newdata); + if(!data){ + return 0; + } + updata_data(data, skb->len); + + return 0; +} diff --git a/tools/netqtop.py b/tools/netqtop.py new file mode 100755 index 000000000..e2823ac6e --- /dev/null +++ b/tools/netqtop.py @@ -0,0 +1,218 @@ +#!/usr/bin/python + +from bcc import BPF +from ctypes import * +import argparse +import os +from time import sleep,time,localtime,asctime +import types + +# pre defines ------------------------------- +ROOT_PATH = "/sys/class/net" +IFNAMSIZ = 16 +COL_WIDTH = 10 +MAX_QUEUE_NUM = 1024 +EBPF_FILE = "netqtop.c" + +# structure for network interface name array +class Devname(Structure): + _fields_=[ + ('name', c_char*IFNAMSIZ) + ] + +################## printer for results ################### +def to_str(num): + s = "" + if num > 1000000: + return str(round(num/(1024*1024.0), 2)) + 'M' + elif num > 1000: + return str(round(num/1024.0, 2)) + 'K' + else: + if type(num) == types.FloatType: + return str(round(num, 2)) + else: + return str(num) + +def print_table(table, qnum): + global print_interval + + # ---- print headers ---------------- + headers = [ + "QueueID", + "avg_size", + "[0, 64)", + "[64, 512)", + "[512, 2K)", + "[2K, 16K)", + "[16K, 64K)" + ] + if args.throughput: + headers.append("BPS") + headers.append("PPS") + + for hd in headers: + print(hd.center(COL_WIDTH)), + print + + # ------- calculates -------------- + qids=[] + tBPS = 0 + tPPS = 0 + tAVG = 0 + tGroup = [0,0,0,0,0] + tpkt = 0 + tlen = 0 + for k, v in table.items(): + qids += [k.value] + tlen += v.total_pkt_len + tpkt += v.num_pkt + tGroup[0] += v.size_64B + tGroup[1] += v.size_512B + tGroup[2] += v.size_2K + tGroup[3] += v.size_16K + tGroup[4] += v.size_64K + tBPS = tlen / print_interval + tPPS = tpkt / print_interval + if tpkt != 0: + tAVG = tlen / tpkt + + # -------- print table -------------- + for k in range(qnum): + if k in qids: + item = table[c_ushort(k)] + data = [ + k, + item.total_pkt_len, + item.num_pkt, + item.size_64B, + item.size_512B, + item.size_2K, + item.size_16K, + item.size_64K + ] + else: + data = [k,0,0,0,0,0,0,0] + + # print a line per queue + avg = 0 + if data[2] != 0: + avg = data[1] / data[2] + print("%5d %11s %10s %10s %10s %10s %10s" % ( + data[0], + to_str(avg), + to_str(data[3]), + to_str(data[4]), + to_str(data[5]), + to_str(data[6]), + to_str(data[7]) + )), + if args.throughput: + BPS = data[1] / print_interval + PPS = data[2] / print_interval + print("%10s %10s" % ( + to_str(BPS), + to_str(PPS) + )) + else: + print + + # ------- print total -------------- + print(" Total %10s %10s %10s %10s %10s %10s" % ( + to_str(tAVG), + to_str(tGroup[0]), + to_str(tGroup[1]), + to_str(tGroup[2]), + to_str(tGroup[3]), + to_str(tGroup[4]) + )), + + if args.throughput: + print("%10s %10s" % ( + to_str(tBPS), + to_str(tPPS) + )) + else: + print + + +def print_result(b): + # --------- print tx queues --------------- + print(asctime(localtime(time()))) + print("TX") + table = b['tx_q'] + print_table(table, tx_num) + b['tx_q'].clear() + + # --------- print rx queues --------------- + print("") + print("RX") + table = b['rx_q'] + print_table(table, rx_num) + b['rx_q'].clear() + if args.throughput: + print("-"*95) + else: + print("-"*76) + +############## specify network interface ################# +parser = argparse.ArgumentParser(description="") +parser.add_argument("--name", "-n", type=str, default="") +parser.add_argument("--interval", "-i", type=float, default=1) +parser.add_argument("--throughput", "-t", action="store_true") +parser.add_argument("--ebpf", action="store_true", help=argparse.SUPPRESS) +args = parser.parse_args() + +if args.ebpf: + with open(EBPF_FILE) as fileobj: + progtxt = fileobj.read() + print(progtxt) + exit() + +if args.name == "": + print ("Please specify a network interface.") + exit() +else: + dev_name = args.name + +if len(dev_name) > IFNAMSIZ-1: + print ("NIC name too long") + exit() + +print_interval = args.interval + 0.0 +if print_interval == 0: + print "print interval must be non-zero" + exit() + +################ get number of queues ##################### +tx_num = 0 +rx_num = 0 +path = ROOT_PATH + "/" + dev_name + "/queues" +if not os.path.exists(path): + print "Net interface", dev_name, "does not exits." + exit() + +list = os.listdir(path) +for s in list: + if s[0] == 'r': + rx_num += 1 + if s[0] == 't': + tx_num += 1 + +if tx_num > MAX_QUEUE_NUM or rx_num > MAX_QUEUE_NUM: + print "number of queues over 1024 is not supported." + exit() + +################## start tracing ################## +b = BPF(src_file = EBPF_FILE) +# --------- set hash array -------- +devname_map = b['name_map'] +_name = Devname() +_name.name = dev_name +devname_map[0] = _name + +while 1: + try: + sleep(print_interval) + print_result(b) + except KeyboardInterrupt: + exit() diff --git a/tools/netqtop_example.txt b/tools/netqtop_example.txt new file mode 100644 index 000000000..443cfb715 --- /dev/null +++ b/tools/netqtop_example.txt @@ -0,0 +1,190 @@ +Demonstrations of netqtop. + + +netqtop traces the kernel functions performing packet transmit (xmit_one) +and packet receive (__netif_receive_skb_core) on data link layer. The tool +not only traces every packet via a specified network interface, but also accounts +the PPS, BPS and average size of packets as well as packet amounts (categorized by +size range) on sending and receiving direction respectively. Results are printed +as tables, which can be used to understand traffic load allocation on each queue +of interested network interface to see if it is balanced. And the overall performance +is provided in the buttom. + +For example, suppose you want to know current traffic on lo, and print result +every second: +# ./netqtop.py -n lo -i 1 +Thu Sep 10 11:28:39 2020 +TX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) + 0 88 0 9 0 0 0 + Total 88 0 9 0 0 0 + +RX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) + 0 74 4 5 0 0 0 + Total 74 4 5 0 0 0 +---------------------------------------------------------------------------- +Thu Sep 10 11:28:40 2020 +TX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) + 0 233 0 3 1 0 0 + Total 233 0 3 1 0 0 + +RX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) + 0 219 2 1 1 0 0 + Total 219 2 1 1 0 0 +---------------------------------------------------------------------------- + +or you can just use the default mode +# ./netqtop.py -n lo +Thu Sep 10 11:27:45 2020 +TX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) + 0 92 0 7 0 0 0 + Total 92 0 7 0 0 0 + +RX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) + 0 78 3 4 0 0 0 + Total 78 3 4 0 0 0 +---------------------------------------------------------------------------- +Thu Sep 10 11:27:46 2020 +TX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) + 0 179 0 5 1 0 0 + Total 179 0 5 1 0 0 + +RX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) + 0 165 3 2 1 0 0 + Total 165 3 2 1 0 0 +---------------------------------------------------------------------------- + +This NIC only has 1 queue. +If you want the tool to print results after a longer interval, specify seconds with -i: +# ./netqtop.py -n lo -i 3 +Thu Sep 10 11:31:26 2020 +TX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) + 0 85 0 11 0 0 0 + Total 85 0 11 0 0 0 + +RX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) + 0 71 5 6 0 0 0 + Total 71 5 6 0 0 0 +---------------------------------------------------------------------------- +Thu Sep 10 11:31:29 2020 +TX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) + 0 153 0 7 1 0 0 + Total 153 0 7 1 0 0 + +RX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) + 0 139 4 3 1 0 0 + Total 139 4 3 1 0 0 +---------------------------------------------------------------------------- + +To see PPS and BPS of each queue, use -t: +# ./netqtop.py -n lo -i 1 -t +Thu Sep 10 11:37:02 2020 +TX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) BPS PPS + 0 114 0 10 0 0 0 1.11K 10.0 + Total 114 0 10 0 0 0 1.11K 10.0 + +RX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) BPS PPS + 0 100 4 6 0 0 0 1000.0 10.0 + Total 100 4 6 0 0 0 1000.0 10.0 +----------------------------------------------------------------------------------------------- +Thu Sep 10 11:37:03 2020 +TX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) BPS PPS + 0 271 0 3 1 0 0 1.06K 4.0 + Total 271 0 3 1 0 0 1.06K 4.0 + +RX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) BPS PPS + 0 257 2 1 1 0 0 1.0K 4.0 + Total 257 2 1 1 0 0 1.0K 4.0 +----------------------------------------------------------------------------------------------- + +When filtering multi-queue NICs, you do not need to specify the number of queues, +the tool calculates it for you: +# ./netqtop.py -n eth0 -t +Thu Sep 10 11:39:21 2020 +TX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) BPS PPS + 0 0 0 0 0 0 0 0.0 0.0 + 1 0 0 0 0 0 0 0.0 0.0 + 2 0 0 0 0 0 0 0.0 0.0 + 3 0 0 0 0 0 0 0.0 0.0 + 4 0 0 0 0 0 0 0.0 0.0 + 5 0 0 0 0 0 0 0.0 0.0 + 6 0 0 0 0 0 0 0.0 0.0 + 7 0 0 0 0 0 0 0.0 0.0 + 8 54 2 0 0 0 0 108.0 2.0 + 9 161 0 9 0 0 0 1.42K 9.0 + 10 0 0 0 0 0 0 0.0 0.0 + 11 0 0 0 0 0 0 0.0 0.0 + 12 0 0 0 0 0 0 0.0 0.0 + 13 0 0 0 0 0 0 0.0 0.0 + 14 0 0 0 0 0 0 0.0 0.0 + 15 0 0 0 0 0 0 0.0 0.0 + 16 0 0 0 0 0 0 0.0 0.0 + 17 0 0 0 0 0 0 0.0 0.0 + 18 0 0 0 0 0 0 0.0 0.0 + 19 0 0 0 0 0 0 0.0 0.0 + 20 0 0 0 0 0 0 0.0 0.0 + 21 0 0 0 0 0 0 0.0 0.0 + 22 0 0 0 0 0 0 0.0 0.0 + 23 0 0 0 0 0 0 0.0 0.0 + 24 0 0 0 0 0 0 0.0 0.0 + 25 0 0 0 0 0 0 0.0 0.0 + 26 0 0 0 0 0 0 0.0 0.0 + 27 0 0 0 0 0 0 0.0 0.0 + 28 0 0 0 0 0 0 0.0 0.0 + 29 0 0 0 0 0 0 0.0 0.0 + 30 0 0 0 0 0 0 0.0 0.0 + 31 0 0 0 0 0 0 0.0 0.0 + Total 141 2 9 0 0 0 1.52K 11.0 + +RX + QueueID avg_size [0, 64) [64, 512) [512, 2K) [2K, 16K) [16K, 64K) BPS PPS + 0 127 3 9 0 0 0 1.5K 12.0 + 1 0 0 0 0 0 0 0.0 0.0 + 2 0 0 0 0 0 0 0.0 0.0 + 3 0 0 0 0 0 0 0.0 0.0 + 4 0 0 0 0 0 0 0.0 0.0 + 5 0 0 0 0 0 0 0.0 0.0 + 6 0 0 0 0 0 0 0.0 0.0 + 7 0 0 0 0 0 0 0.0 0.0 + 8 0 0 0 0 0 0 0.0 0.0 + 9 0 0 0 0 0 0 0.0 0.0 + 10 0 0 0 0 0 0 0.0 0.0 + 11 0 0 0 0 0 0 0.0 0.0 + 12 0 0 0 0 0 0 0.0 0.0 + 13 0 0 0 0 0 0 0.0 0.0 + 14 0 0 0 0 0 0 0.0 0.0 + 15 0 0 0 0 0 0 0.0 0.0 + 16 0 0 0 0 0 0 0.0 0.0 + 17 0 0 0 0 0 0 0.0 0.0 + 18 0 0 0 0 0 0 0.0 0.0 + 19 0 0 0 0 0 0 0.0 0.0 + 20 0 0 0 0 0 0 0.0 0.0 + 21 0 0 0 0 0 0 0.0 0.0 + 22 0 0 0 0 0 0 0.0 0.0 + 23 0 0 0 0 0 0 0.0 0.0 + 24 0 0 0 0 0 0 0.0 0.0 + 25 0 0 0 0 0 0 0.0 0.0 + 26 0 0 0 0 0 0 0.0 0.0 + 27 0 0 0 0 0 0 0.0 0.0 + 28 0 0 0 0 0 0 0.0 0.0 + 29 0 0 0 0 0 0 0.0 0.0 + 30 0 0 0 0 0 0 0.0 0.0 + 31 0 0 0 0 0 0 0.0 0.0 + Total 127 3 9 0 0 0 1.5K 12.0 +----------------------------------------------------------------------------------------------- \ No newline at end of file From 3f95637a304d09921b880b6ba6d2fd04a19514fb Mon Sep 17 00:00:00 2001 From: Brendan Gregg <brendan.d.gregg@gmail.com> Date: Wed, 16 Sep 2020 14:32:16 -0700 Subject: [PATCH 240/278] add threadsnoop --- README.md | 1 + man/man8/threadsnoop.8 | 60 ++++++++++++++++++++++++++++++++ tools/threadsnoop.py | 64 +++++++++++++++++++++++++++++++++++ tools/threadsnoop_example.txt | 27 +++++++++++++++ 4 files changed, 152 insertions(+) create mode 100644 man/man8/threadsnoop.8 create mode 100755 tools/threadsnoop.py create mode 100644 tools/threadsnoop_example.txt diff --git a/README.md b/README.md index d54e3848f..66bac4e72 100644 --- a/README.md +++ b/README.md @@ -160,6 +160,7 @@ pair of .c and .py files, and some are directories of files. - tools/[tcpsubnet](tools/tcpsubnet.py): Summarize and aggregate TCP send by subnet. [Examples](tools/tcpsubnet_example.txt). - tools/[tcptop](tools/tcptop.py): Summarize TCP send/recv throughput by host. Top for TCP. [Examples](tools/tcptop_example.txt). - tools/[tcptracer](tools/tcptracer.py): Trace TCP established connections (connect(), accept(), close()). [Examples](tools/tcptracer_example.txt). +- tools/[threadsnoop](tools/threadsnoop.py): List new thread creation. [Examples](tools/threadsnoop_example.txt). - tools/[tplist](tools/tplist.py): Display kernel tracepoints or USDT probes and their formats. [Examples](tools/tplist_example.txt). - tools/[trace](tools/trace.py): Trace arbitrary functions, with filters. [Examples](tools/trace_example.txt). - tools/[ttysnoop](tools/ttysnoop.py): Watch live output from a tty or pts device. [Examples](tools/ttysnoop_example.txt). diff --git a/man/man8/threadsnoop.8 b/man/man8/threadsnoop.8 new file mode 100644 index 000000000..3c655f247 --- /dev/null +++ b/man/man8/threadsnoop.8 @@ -0,0 +1,60 @@ +.TH threadsnoop 8 "2019-07-02" "USER COMMANDS" +.SH NAME +threadsnoop \- Trace thread creation via pthread_create(). Uses BCC/eBPF. +.SH SYNOPSIS +.B threadsnoop +.SH DESCRIPTION +threadsnoop traces calls to pthread_create(), showing this path of thread +creation. This can be used for workload characterization and discovery, and is +a companion to execsnoop(8) which traces execve(2). + +This works by tracing the pthread_create() from libpthread.so.0. The path +to this library may need adjusting in the tool source to match your system. + +Since this uses BPF, only the root user can use this tool. +.SH REQUIREMENTS +CONFIG_BPF and BCC. +.SH EXAMPLES +.TP +Trace calls pthread_create(): +# +.B threadsnoop +.SH FIELDS +.TP +TIME(ms) +Elapsed time since the tool began tracing (in milliseconds). +.TP +PID +The process ID. +.TP +COMM +The process (thread) name. +.TP +FUNC +The name of the start routine, if the symbol is available, else a hex address +for the start routine address. +.SH OVERHEAD +Thread creation is expected to be low (<< 1000/s), so the overhead of this +tool is expected to be negligible. +.SH SOURCE +This originated as a bpftrace tool from the book "BPF Performance Tools", +published by Addison Wesley (2019): +.IP +http://www.brendangregg.com/bpf-performance-tools-book.html +.PP +See the book for more documentation on this tool. +.PP +This version is in the BCC repository: +.IP +https://github.com/iovisor/bcc +.PP +Also look in the bcc distribution for a companion _examples.txt file +containing example usage, output, and commentary for this tool. +.SH OS +Linux +.SH STABILITY +Unstable - in development. +.SH AUTHOR +Brendan Gregg +.SH SEE ALSO +execsnoop(8) diff --git a/tools/threadsnoop.py b/tools/threadsnoop.py new file mode 100755 index 000000000..04c5e680d --- /dev/null +++ b/tools/threadsnoop.py @@ -0,0 +1,64 @@ +#!/usr/bin/python +# @lint-avoid-python-3-compatibility-imports +# +# threadsnoop List new thread creation. +# For Linux, uses BCC, eBPF. Embedded C. +# +# Copyright (c) 2019 Brendan Gregg. +# Licensed under the Apache License, Version 2.0 (the "License"). +# This was originally created for the BPF Performance Tools book +# published by Addison Wesley. ISBN-13: 9780136554820 +# When copying or porting, include this comment. +# +# 02-Jul-2019 Brendan Gregg Ported from bpftrace to BCC. + +from __future__ import print_function +from bcc import BPF + +# load BPF program +b = BPF(text=""" +#include <linux/sched.h> + +struct data_t { + u64 ts; + u32 pid; + u64 start; + char comm[TASK_COMM_LEN]; +}; + +BPF_PERF_OUTPUT(events); + +void do_entry(struct pt_regs *ctx) { + struct data_t data = {}; + data.ts = bpf_ktime_get_ns(); + data.pid = bpf_get_current_pid_tgid() >> 32; + data.start = PT_REGS_PARM3(ctx); + bpf_get_current_comm(&data.comm, sizeof(data.comm)); + + events.perf_submit(ctx, &data, sizeof(data)); +}; +""") +b.attach_uprobe(name="pthread", sym="pthread_create", fn_name="do_entry") + +print("%-10s %-6s %-16s %s" % ("TIME(ms)", "PID", "COMM", "FUNC")) + +start_ts = 0 + +# process event +def print_event(cpu, data, size): + global start_ts + event = b["events"].event(data) + if start_ts == 0: + start_ts = event.ts + func = b.sym(event.start, event.pid) + if (func == "[unknown]"): + func = hex(event.start) + print("%-10d %-6d %-16s %s" % ((event.ts - start_ts) / 1000000, + event.pid, event.comm, func)) + +b["events"].open_perf_buffer(print_event) +while 1: + try: + b.perf_buffer_poll() + except KeyboardInterrupt: + exit() diff --git a/tools/threadsnoop_example.txt b/tools/threadsnoop_example.txt new file mode 100644 index 000000000..e65b503fa --- /dev/null +++ b/tools/threadsnoop_example.txt @@ -0,0 +1,27 @@ +Demonstrations of threadsnoop, the Linux BCC/eBPF version. + + +Tracing new threads via phtread_create(): + +# ./threadsnoop +Attaching 2 probes... +TIME(ms) PID COMM FUNC +1938 28549 dockerd threadentry +1939 28549 dockerd threadentry +1939 28549 dockerd threadentry +1940 28549 dockerd threadentry +1949 28549 dockerd threadentry +1958 28549 dockerd threadentry +1939 28549 dockerd threadentry +1950 28549 dockerd threadentry +2013 28579 docker-containe 0x562f30f2e710L +2036 28549 dockerd threadentry +2083 28579 docker-containe 0x562f30f2e710L +2116 629 systemd-journal 0x7fb7114955c0L +2116 629 systemd-journal 0x7fb7114955c0L +[...] + +The output shows a dockerd process creating several threads with the start +routine threadentry(), and docker-containe (truncated) and systemd-journal +also starting threads: in their cases, the function had no symbol information +available, so their addresses are printed in hex. From 12c234f9f68149ab3225a057d011d362416a42f8 Mon Sep 17 00:00:00 2001 From: Brendan Gregg <brendan.d.gregg@gmail.com> Date: Wed, 16 Sep 2020 14:34:29 -0700 Subject: [PATCH 241/278] add tcpsynbl --- README.md | 1 + man/man8/tcpsynbl.8 | 59 ++++++++++++++++++++++++++++++++++++++ tools/tcpsynbl.py | 52 +++++++++++++++++++++++++++++++++ tools/tcpsynbl_example.txt | 20 +++++++++++++ 4 files changed, 132 insertions(+) create mode 100644 man/man8/tcpsynbl.8 create mode 100755 tools/tcpsynbl.py create mode 100644 tools/tcpsynbl_example.txt diff --git a/README.md b/README.md index 66bac4e72..f92622444 100644 --- a/README.md +++ b/README.md @@ -158,6 +158,7 @@ pair of .c and .py files, and some are directories of files. - tools/[tcpretrans](tools/tcpretrans.py): Trace TCP retransmits and TLPs. [Examples](tools/tcpretrans_example.txt). - tools/[tcpstates](tools/tcpstates.py): Trace TCP session state changes with durations. [Examples](tools/tcpstates_example.txt). - tools/[tcpsubnet](tools/tcpsubnet.py): Summarize and aggregate TCP send by subnet. [Examples](tools/tcpsubnet_example.txt). +- tools/[tcpsynbl](tools/tcpsynbl.py): Show TCP SYN backlog. [Examples](tools/tcpsynbl_example.txt). - tools/[tcptop](tools/tcptop.py): Summarize TCP send/recv throughput by host. Top for TCP. [Examples](tools/tcptop_example.txt). - tools/[tcptracer](tools/tcptracer.py): Trace TCP established connections (connect(), accept(), close()). [Examples](tools/tcptracer_example.txt). - tools/[threadsnoop](tools/threadsnoop.py): List new thread creation. [Examples](tools/threadsnoop_example.txt). diff --git a/man/man8/tcpsynbl.8 b/man/man8/tcpsynbl.8 new file mode 100644 index 000000000..4dd38c8a0 --- /dev/null +++ b/man/man8/tcpsynbl.8 @@ -0,0 +1,59 @@ +.TH tcpsynbl 8 "2019-07-03" "USER COMMANDS" +.SH NAME +tcpsynbl \- Show the TCP SYN backlog as a histogram. Uses BCC/eBPF. +.SH SYNOPSIS +.B tcpsynbl +.SH DESCRIPTION +This tool shows the TCP SYN backlog size during SYN arrival as a histogram. +This lets you see how close your applications are to hitting the backlog limit +and dropping SYNs (causing performance issues with SYN retransmits), and is a +measure of workload saturation. The histogram shown is measured at the time of +SYN received, and a separate histogram is shown for each backlog limit. + +This works by tracing the tcp_v4_syn_recv_sock() and tcp_v6_syn_recv_sock() +kernel functions using dynamic instrumentation. Since these functions may +change in future kernels, this tool may need maintenance to keep working. + +Since this uses BPF, only the root user can use this tool. +.SH REQUIREMENTS +CONFIG_BPF and BCC. +.SH EXAMPLES +.TP +Show the TCP SYN backlog as a histogram. +# +.B tcpsynbl +.SH FIELDS +.TP +backlog +The backlog size when a SYN was received. +.TP +count +The number of times this backlog size was encountered. +.TP +distribution +An ASCII visualization of the count column. +.SH OVERHEAD +Inbound SYNs should be relatively low compared to packets and other events, +so the overhead of this tool is expected to be negligible. +.SH SOURCE +This originated as a bpftrace tool from the book "BPF Performance Tools", +published by Addison Wesley (2019): +.IP +http://www.brendangregg.com/bpf-performance-tools-book.html +.PP +See the book for more documentation on this tool. +.PP +This version is in the BCC repository: +.IP +https://github.com/iovisor/bcc +.PP +Also look in the bcc distribution for a companion _examples.txt file +containing example usage, output, and commentary for this tool. +.SH OS +Linux +.SH STABILITY +Unstable - in development. +.SH AUTHOR +Brendan Gregg +.SH SEE ALSO +tcptop(8) diff --git a/tools/tcpsynbl.py b/tools/tcpsynbl.py new file mode 100755 index 000000000..c24eb9607 --- /dev/null +++ b/tools/tcpsynbl.py @@ -0,0 +1,52 @@ +#!/usr/bin/python +# @lint-avoid-python-3-compatibility-imports +# +# tcpsynbl Show TCP SYN backlog. +# For Linux, uses BCC, eBPF. Embedded C. +# +# Copyright (c) 2019 Brendan Gregg. +# Licensed under the Apache License, Version 2.0 (the "License"). +# This was originally created for the BPF Performance Tools book +# published by Addison Wesley. ISBN-13: 9780136554820 +# When copying or porting, include this comment. +# +# 03-Jul-2019 Brendan Gregg Ported from bpftrace to BCC. + +from __future__ import print_function +from bcc import BPF +from time import sleep + +# load BPF program +b = BPF(text=""" +#include <net/sock.h> + +typedef struct backlog_key { + u32 backlog; + u64 slot; +} backlog_key_t; + +BPF_HISTOGRAM(dist, backlog_key_t); + +int do_entry(struct pt_regs *ctx) { + struct sock *sk = (struct sock *)PT_REGS_PARM1(ctx); + + backlog_key_t key = {}; + key.backlog = sk->sk_max_ack_backlog; + key.slot = bpf_log2l(sk->sk_ack_backlog); + dist.increment(key); + + return 0; +}; +""") +b.attach_kprobe(event="tcp_v4_syn_recv_sock", fn_name="do_entry") +b.attach_kprobe(event="tcp_v6_syn_recv_sock", fn_name="do_entry") + +print("Tracing SYN backlog size. Ctrl-C to end."); + +try: + sleep(99999999) +except KeyboardInterrupt: + print() + +dist = b.get_table("dist") +dist.print_log2_hist("backlog", "backlog_max") diff --git a/tools/tcpsynbl_example.txt b/tools/tcpsynbl_example.txt new file mode 100644 index 000000000..1ac167df3 --- /dev/null +++ b/tools/tcpsynbl_example.txt @@ -0,0 +1,20 @@ +Demonstrations of tcpsynbl, the Linux BCC/eBPF version. + + +This tool shows the TCP SYN backlog size during SYN arrival as a histogram. +This lets you see how close your applications are to hitting the backlog limit +and dropping SYNs (causing performance issues with SYN retransmits). For +example: + +# ./tcpsynbl.py +Tracing SYN backlog size. Ctrl-C to end. +^C + +backlog_max = 500L + backlog : count distribution + 0 -> 1 : 961 |****************************************| + 2 -> 3 : 1 | | + +This output shows that for the backlog limit of 500, there were 961 SYN +arrival where the backlog was zero or one, and one accept where the backlog was +two or three. This indicates that we are nowhere near this limit. From da8c6a9a3278545842557cb50671a9e051de173c Mon Sep 17 00:00:00 2001 From: Brendan Gregg <brendan.d.gregg@gmail.com> Date: Wed, 16 Sep 2020 14:39:53 -0700 Subject: [PATCH 242/278] add swapin --- README.md | 1 + man/man8/swapin.8 | 58 +++++++++++++++++++++++++++ tools/swapin.py | 88 +++++++++++++++++++++++++++++++++++++++++ tools/swapin_example.py | 48 ++++++++++++++++++++++ 4 files changed, 195 insertions(+) create mode 100644 man/man8/swapin.8 create mode 100755 tools/swapin.py create mode 100644 tools/swapin_example.py diff --git a/README.md b/README.md index f92622444..cbecf857c 100644 --- a/README.md +++ b/README.md @@ -148,6 +148,7 @@ pair of .c and .py files, and some are directories of files. - tools/[solisten](tools/solisten.py): Trace TCP socket listen. [Examples](tools/solisten_example.txt). - tools/[sslsniff](tools/sslsniff.py): Sniff OpenSSL written and readed data. [Examples](tools/sslsniff_example.txt). - tools/[stackcount](tools/stackcount.py): Count kernel function calls and their stack traces. [Examples](tools/stackcount_example.txt). +- tools/[swapin](tools/swapin.py): Count swapins by process. [Examples](tools/swapin_example.txt). - tools/[syncsnoop](tools/syncsnoop.py): Trace sync() syscall. [Examples](tools/syncsnoop_example.txt). - tools/[syscount](tools/syscount.py): Summarize syscall counts and latencies. [Examples](tools/syscount_example.txt). - tools/[tcpaccept](tools/tcpaccept.py): Trace TCP passive connections (accept()). [Examples](tools/tcpaccept_example.txt). diff --git a/man/man8/swapin.8 b/man/man8/swapin.8 new file mode 100644 index 000000000..c5ef1ffc0 --- /dev/null +++ b/man/man8/swapin.8 @@ -0,0 +1,58 @@ +.TH swapin 8 "2019-07-05" "USER COMMANDS" +.SH NAME +swapin \- Count swapins by process. Uses BCC/eBPF. +.SH SYNOPSIS +.B swapin +.SH DESCRIPTION +This tool counts swapins by process, to show which process is affected by +swapping (if swap devices are in use). This can explain a significant source +of application latency, if it has began swapping due to memory pressure on +the system. + +This works by tracing the swap_readpage() kernel funciton +using dynamic instrumentation. This tool may need maintenance to keep working +if that function changes in later kernels. + +Since this uses BPF, only the root user can use this tool. +.SH REQUIREMENTS +CONFIG_BPF and BCC. +.SH EXAMPLES +.TP +Count swapins by process, showing per-second summaries. +# +.B swapin +.SH FIELDS +.TP +1st +The process name. +.TP +2nd +The process ID. +.TP +3rd +The count of swapins during that interval. +.SH OVERHEAD +The rate of swapins should be low (bounded by swapin device IOPS), such that +the overhead of this tool is expected to be negligible. +.SH SOURCE +This originated as a bpftrace tool from the book "BPF Performance Tools", +published by Addison Wesley (2019): +.IP +http://www.brendangregg.com/bpf-performance-tools-book.html +.PP +See the book for more documentation on this tool. +.PP +This version is in the BCC repository: +.IP +https://github.com/iovisor/bcc +.PP +Also look in the bcc distribution for a companion _examples.txt file +containing example usage, output, and commentary for this tool. +.SH OS +Linux +.SH STABILITY +Unstable - in development. +.SH AUTHOR +Brendan Gregg +.SH SEE ALSO +swapon(8) diff --git a/tools/swapin.py b/tools/swapin.py new file mode 100755 index 000000000..e94000af6 --- /dev/null +++ b/tools/swapin.py @@ -0,0 +1,88 @@ +#!/usr/bin/python +# @lint-avoid-python-3-compatibility-imports +# +# swapin Count swapins by process. +# For Linux, uses BCC, eBPF. Embedded C. +# +# TODO: add -s for total swapin time column (sum) +# +# Copyright (c) 2019 Brendan Gregg. +# Licensed under the Apache License, Version 2.0 (the "License"). +# This was originally created for the BPF Performance Tools book +# published by Addison Wesley. ISBN-13: 9780136554820 +# When copying or porting, include this comment. +# +# 03-Jul-2019 Brendan Gregg Ported from bpftrace to BCC. + +from __future__ import print_function +from bcc import BPF +from time import sleep, strftime +import argparse + +# arguments +parser = argparse.ArgumentParser( + description="Count swapin events by process.") +parser.add_argument("-T", "--notime", action="store_true", + help="do not show the timestamp (HH:MM:SS)") +parser.add_argument("interval", nargs="?", default=1, + help="output interval, in seconds") +parser.add_argument("count", nargs="?", default=99999999, + help="number of outputs") +parser.add_argument("--ebpf", action="store_true", + help=argparse.SUPPRESS) +args = parser.parse_args() +interval = int(args.interval) +countdown = int(args.count) +debug = 0 + +# load BPF program +b = BPF(text=""" +#include <linux/sched.h> + +struct key_t { + u32 pid; + char comm[TASK_COMM_LEN]; +}; + +BPF_HASH(counts, struct key_t, u64); + +int kprobe__swap_readpage(struct pt_regs *ctx) +{ + u64 *val, zero = 0; + u32 tgid = bpf_get_current_pid_tgid() >> 32; + struct key_t key = {.pid = tgid}; + bpf_get_current_comm(&key.comm, sizeof(key.comm)); + val = counts.lookup_or_init(&key, &zero); + ++(*val); + return 0; +} +""") +if debug or args.ebpf: + print(bpf_text) + if args.ebpf: + exit() + +print("Counting swap ins. Ctrl-C to end."); + +# output +exiting = 0 +while 1: + try: + sleep(interval) + except KeyboardInterrupt: + exiting = 1 + + if not args.notime: + print(strftime("%H:%M:%S")) + print("%-16s %-6s %s" % ("COMM", "PID", "COUNT")) + counts = b.get_table("counts") + for k, v in sorted(counts.items(), + key=lambda counts: counts[1].value): + print("%-16s %-6d %d" % (k.comm, k.pid, v.value)) + counts.clear() + print() + + countdown -= 1 + if exiting or countdown == 0: + print("Detaching...") + exit() diff --git a/tools/swapin_example.py b/tools/swapin_example.py new file mode 100644 index 000000000..39ceb470c --- /dev/null +++ b/tools/swapin_example.py @@ -0,0 +1,48 @@ +Demonstrations of swapin, the Linux BCC/eBPF version. + + +This tool counts swapins by process, to show which process is affected by +swapping. For example: + +# swapin.py +Counting swap ins. Ctrl-C to end. +13:36:58 +COMM PID COUNT + +13:36:59 +COMM PID COUNT +gnome-shell 2239 12410 + +13:37:00 +COMM PID COUNT +chrome 4536 14635 + +13:37:01 +COMM PID COUNT +gnome-shell 2239 14 +cron 1180 23 + +13:37:02 +COMM PID COUNT +gnome-shell 2239 2496 +[...] + +While tracing, this showed that PID 2239 (gnome-shell) and PID 4536 (chrome) +suffered over ten thousand swapins. + + + +USAGE: + +# swapin.py -h +usage: swapin.py [-h] [-T] [interval] [count] + +Count swapin events by process. + +positional arguments: + interval output interval, in seconds + count number of outputs + +optional arguments: + -h, --help show this help message and exit + -T, --notime do not show the timestamp (HH:MM:SS) From 3953c6001e8ee67b9c01abeb0405ffd973f38642 Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Wed, 9 Sep 2020 11:38:54 +0800 Subject: [PATCH 243/278] libbpf-tools: add hardirqs Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/hardirqs.bpf.c | 93 +++++++++++++ libbpf-tools/hardirqs.c | 269 ++++++++++++++++++++++++++++++++++++ libbpf-tools/hardirqs.h | 16 +++ 5 files changed, 380 insertions(+) create mode 100644 libbpf-tools/hardirqs.bpf.c create mode 100644 libbpf-tools/hardirqs.c create mode 100644 libbpf-tools/hardirqs.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 65d47f923..c964564df 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -8,6 +8,7 @@ /drsnoop /execsnoop /filelife +/hardirqs /opensnoop /readahead /runqslower diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index b4a444786..77d853e39 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -19,6 +19,7 @@ APPS = \ drsnoop \ execsnoop \ filelife \ + hardirqs \ opensnoop \ readahead \ runqslower \ diff --git a/libbpf-tools/hardirqs.bpf.c b/libbpf-tools/hardirqs.bpf.c new file mode 100644 index 000000000..ce3f97d33 --- /dev/null +++ b/libbpf-tools/hardirqs.bpf.c @@ -0,0 +1,93 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> +#include "hardirqs.h" +#include "bits.bpf.h" +#include "maps.bpf.h" + +#define MAX_ENTRIES 256 + +const volatile bool targ_dist = false; +const volatile bool targ_ns = false; + +struct { + __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY); + __uint(max_entries, 1); + __type(key, u32); + __type(value, u64); +} start SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, struct irq_key); + __type(value, struct info); +} infos SEC(".maps"); + +static struct info zero; + +SEC("tracepoint/irq/irq_handler_entry") +int handle__irq_handler(struct trace_event_raw_irq_handler_entry *ctx) +{ + struct irq_key key = {}; + struct info *info; + + bpf_probe_read_kernel_str(&key.name, sizeof(key.name), ctx->__data); + info = bpf_map_lookup_or_try_init(&infos, &key, &zero); + if (!info) + return 0; + info->count += 1; + return 0; +} + +SEC("tp_btf/irq_handler_entry") +int BPF_PROG(irq_handler_entry) +{ + u64 ts = bpf_ktime_get_ns(); + u32 key = 0; + + bpf_map_update_elem(&start, &key, &ts, 0); + return 0; +} + +SEC("tp_btf/irq_handler_exit") +int BPF_PROG(irq_handler_exit_exit, int irq, struct irqaction *action) +{ + struct irq_key ikey = {}; + struct info *info; + u32 key = 0; + s64 delta; + u64 *tsp; + + tsp = bpf_map_lookup_elem(&start, &key); + if (!tsp || !*tsp) + return 0; + + delta = bpf_ktime_get_ns() - *tsp; + if (delta < 0) + return 0; + if (!targ_ns) + delta /= 1000U; + + bpf_probe_read_kernel_str(&ikey.name, sizeof(ikey.name), action->name); + info = bpf_map_lookup_or_try_init(&infos, &ikey, &zero); + if (!info) + return 0; + + if (!targ_dist) { + info->count += delta; + } else { + u64 slot; + + slot = log2(delta); + if (slot >= MAX_SLOTS) + slot = MAX_SLOTS - 1; + info->slots[slot]++; + } + + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/hardirqs.c b/libbpf-tools/hardirqs.c new file mode 100644 index 000000000..8366e2088 --- /dev/null +++ b/libbpf-tools/hardirqs.c @@ -0,0 +1,269 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on hardirq(8) from BCC by Brendan Gregg. +// 31-Aug-2020 Wenbo Zhang Created this. +#include <argp.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> +#include <bpf/libbpf.h> +#include <bpf/bpf.h> +#include "hardirqs.h" +#include "hardirqs.skel.h" +#include "trace_helpers.h" + +struct env { + bool count; + bool distributed; + bool nanoseconds; + time_t interval; + int times; + bool timestamp; + bool verbose; +} env = { + .interval = 99999999, + .times = 99999999, +}; + +static volatile bool exiting; + +const char *argp_program_version = "hardirqs 0.1"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; +const char argp_program_doc[] = +"Summarize hard irq event time as histograms.\n" +"\n" +"USAGE: hardirqs [--help] [-T] [-N] [-d] [interval] [count]\n" +"\n" +"EXAMPLES:\n" +" hardirqs # sum hard irq event time\n" +" hardirqs -d # show hard irq event time as histograms\n" +" hardirqs 1 10 # print 1 second summaries, 10 times\n" +" hardirqs -NT 1 # 1s summaries, nanoseconds, and timestamps\n"; + +static const struct argp_option opts[] = { + { "count", 'C', NULL, 0, "Show event counts instead of timing" }, + { "distributed", 'd', NULL, 0, "Show distributions as histograms" }, + { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, + { "nanoseconds", 'N', NULL, 0, "Output in nanoseconds" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static int pos_args; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'd': + env.distributed = true; + break; + case 'C': + env.count = true; + break; + case 'N': + env.nanoseconds = true; + break; + case 'T': + env.timestamp = true; + break; + case ARGP_KEY_ARG: + errno = 0; + if (pos_args == 0) { + env.interval = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid internal\n"); + argp_usage(state); + } + } else if (pos_args == 1) { + env.times = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid times\n"); + argp_usage(state); + } + } else { + fprintf(stderr, + "unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + pos_args++; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void sig_handler(int sig) +{ + exiting = true; +} + +static int print_map(struct bpf_map *map) +{ + struct irq_key lookup_key = {}, next_key; + struct info info; + int fd, err; + + if (env.count) { + printf("%-26s %11s\n", "HARDIRQ", "TOTAL_count"); + } else if (!env.distributed) { + const char *units = env.nanoseconds ? "nsecs" : "usecs"; + + printf("%-26s %6s%5s\n", "HARDIRQ", "TOTAL_", units); + } + + fd = bpf_map__fd(map); + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_lookup_elem(fd, &next_key, &info); + if (err < 0) { + fprintf(stderr, "failed to lookup infos: %d\n", err); + return -1; + } + if (!env.distributed) + printf("%-26s %11llu\n", next_key.name, info.count); + else { + const char *units = env.nanoseconds ? "nsecs" : "usecs"; + + printf("hardirq = %s\n", next_key.name); + print_log2_hist(info.slots, MAX_SLOTS, units); + } + lookup_key = next_key; + } + + memset(&lookup_key, 0, sizeof(lookup_key)); + + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_delete_elem(fd, &next_key); + if (err < 0) { + fprintf(stderr, "failed to cleanup infos: %d\n", err); + return -1; + } + lookup_key = next_key; + } + + return 0; +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct hardirqs_bpf *obj; + struct tm *tm; + char ts[32]; + time_t t; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + if (env.count && env.distributed) { + fprintf(stderr, "count, distributed cann't be used together.\n"); + return 1; + } + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = hardirqs_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF object\n"); + return 1; + } + + /* initialize global data (filtering options) */ + if (!env.count) { + obj->rodata->targ_dist = env.distributed; + obj->rodata->targ_ns = env.nanoseconds; + } + + err = hardirqs_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + if (env.count) { + obj->links.handle__irq_handler = + bpf_program__attach(obj->progs.handle__irq_handler); + err = libbpf_get_error(obj->links.handle__irq_handler); + if (err) { + fprintf(stderr, + "failed to attach irq/irq_handler_entry: %s\n", + strerror(err)); + } + } else { + obj->links.irq_handler_entry = + bpf_program__attach(obj->progs.irq_handler_entry); + err = libbpf_get_error(obj->links.irq_handler_entry); + if (err) { + fprintf(stderr, + "failed to attach irq_handler_entry: %s\n", + strerror(err)); + } + obj->links.irq_handler_exit_exit = + bpf_program__attach(obj->progs.irq_handler_exit_exit); + err = libbpf_get_error(obj->links.irq_handler_exit_exit); + if (err) { + fprintf(stderr, + "failed to attach irq_handler_exit: %s\n", + strerror(err)); + } + } + + signal(SIGINT, sig_handler); + + if (env.count) + printf("Tracing hard irq events... Hit Ctrl-C to end.\n"); + else + printf("Tracing hard irq event time... Hit Ctrl-C to end.\n"); + + /* main: poll */ + while (1) { + sleep(env.interval); + printf("\n"); + + if (env.timestamp) { + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + printf("%-8s\n", ts); + } + + err = print_map(obj->maps.infos); + if (err) + break; + + if (exiting || --env.times == 0) + break; + } + +cleanup: + hardirqs_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/hardirqs.h b/libbpf-tools/hardirqs.h new file mode 100644 index 000000000..97fec1809 --- /dev/null +++ b/libbpf-tools/hardirqs.h @@ -0,0 +1,16 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __HARDIRQS_H +#define __HARDIRQS_H + +#define MAX_SLOTS 20 + +struct irq_key { + char name[32]; +}; + +struct info { + __u64 count; + __u32 slots[MAX_SLOTS]; +}; + +#endif /* __HARDIRQS_H */ From bf4668d4a0c0144f1b5e3ed89696e5493daf3af4 Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Wed, 9 Sep 2020 14:08:32 +0800 Subject: [PATCH 244/278] libbpf-tools: add softirqs Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/softirqs.bpf.c | 67 ++++++++++ libbpf-tools/softirqs.c | 255 ++++++++++++++++++++++++++++++++++++ libbpf-tools/softirqs.h | 11 ++ 5 files changed, 335 insertions(+) create mode 100644 libbpf-tools/softirqs.bpf.c create mode 100644 libbpf-tools/softirqs.c create mode 100644 libbpf-tools/softirqs.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index c964564df..d684d4e98 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -12,6 +12,7 @@ /opensnoop /readahead /runqslower +/softirqs /syscount /tcpconnect /tcpconnlat diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index 77d853e39..a87df5337 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -23,6 +23,7 @@ APPS = \ opensnoop \ readahead \ runqslower \ + softirqs \ syscount \ tcpconnect \ tcpconnlat \ diff --git a/libbpf-tools/softirqs.bpf.c b/libbpf-tools/softirqs.bpf.c new file mode 100644 index 000000000..f3fa79599 --- /dev/null +++ b/libbpf-tools/softirqs.bpf.c @@ -0,0 +1,67 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> +#include "softirqs.h" +#include "bits.bpf.h" +#include "maps.bpf.h" + +const volatile bool targ_dist = false; +const volatile bool targ_ns = false; + +struct { + __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY); + __uint(max_entries, 1); + __type(key, u32); + __type(value, u64); +} start SEC(".maps"); + +__u64 counts[NR_SOFTIRQS]; +struct hist hists[NR_SOFTIRQS]; + +SEC("tp_btf/softirq_entry") +int BPF_PROG(softirq_entry, unsigned int vec_nr) +{ + u64 ts = bpf_ktime_get_ns(); + u32 key = 0; + + bpf_map_update_elem(&start, &key, &ts, 0); + return 0; +} + +SEC("tp_btf/softirq_exit") +int BPF_PROG(softirq_exit, unsigned int vec_nr) +{ + u32 key = 0; + s64 delta; + u64 *tsp; + + if (vec_nr >= NR_SOFTIRQS) + return 0; + tsp = bpf_map_lookup_elem(&start, &key); + if (!tsp || !*tsp) + return 0; + delta = bpf_ktime_get_ns() - *tsp; + if (delta < 0) + return 0; + if (!targ_ns) + delta /= 1000U; + + if (!targ_dist) { + __sync_fetch_and_add(&counts[vec_nr], delta); + } else { + struct hist *hist; + u64 slot; + + hist = &hists[vec_nr]; + slot = log2(delta); + if (slot >= MAX_SLOTS) + slot = MAX_SLOTS - 1; + __sync_fetch_and_add(&hist->slots[slot], 1); + } + + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/softirqs.c b/libbpf-tools/softirqs.c new file mode 100644 index 000000000..b23bfa163 --- /dev/null +++ b/libbpf-tools/softirqs.c @@ -0,0 +1,255 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on softirq(8) from BCC by Brendan Gregg & Sasha Goldshtein. +// 15-Aug-2020 Wenbo Zhang Created this. +#include <argp.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> +#include <bpf/libbpf.h> +#include <bpf/bpf.h> +#include "softirqs.h" +#include "softirqs.skel.h" +#include "trace_helpers.h" + +struct env { + bool distributed; + bool nanoseconds; + time_t interval; + int times; + bool timestamp; + bool verbose; +} env = { + .interval = 99999999, + .times = 99999999, +}; + +static volatile bool exiting; + +const char *argp_program_version = "softirqs 0.1"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; +const char argp_program_doc[] = +"Summarize soft irq event time as histograms.\n" +"\n" +"USAGE: softirqs [--help] [-T] [-N] [-d] [interval] [count]\n" +"\n" +"EXAMPLES:\n" +" softirqss # sum soft irq event time\n" +" softirqss -d # show soft irq event time as histograms\n" +" softirqss 1 10 # print 1 second summaries, 10 times\n" +" softirqss -NT 1 # 1s summaries, nanoseconds, and timestamps\n"; + +static const struct argp_option opts[] = { + { "distributed", 'd', NULL, 0, "Show distributions as histograms" }, + { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, + { "nanoseconds", 'N', NULL, 0, "Output in nanoseconds" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static int pos_args; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'd': + env.distributed = true; + break; + case 'N': + env.nanoseconds = true; + break; + case 'T': + env.timestamp = true; + break; + case ARGP_KEY_ARG: + errno = 0; + if (pos_args == 0) { + env.interval = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid internal\n"); + argp_usage(state); + } + } else if (pos_args == 1) { + env.times = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid times\n"); + argp_usage(state); + } + } else { + fprintf(stderr, + "unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + pos_args++; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void sig_handler(int sig) +{ + exiting = true; +} + +enum { + HI_SOFTIRQ = 0, + TIMER_SOFTIRQ = 1, + NET_TX_SOFTIRQ = 2, + NET_RX_SOFTIRQ = 3, + BLOCK_SOFTIRQ = 4, + IRQ_POLL_SOFTIRQ = 5, + TASKLET_SOFTIRQ = 6, + SCHED_SOFTIRQ = 7, + HRTIMER_SOFTIRQ = 8, + RCU_SOFTIRQ = 9, + NR_SOFTIRQS = 10, +}; + +static char *vec_names[] = { + [HI_SOFTIRQ] = "hi", + [TIMER_SOFTIRQ] = "timer", + [NET_TX_SOFTIRQ] = "net_tx", + [NET_RX_SOFTIRQ] = "net_rx", + [BLOCK_SOFTIRQ] = "block", + [IRQ_POLL_SOFTIRQ] = "irq_poll", + [TASKLET_SOFTIRQ] = "tasklet", + [SCHED_SOFTIRQ] = "sched", + [HRTIMER_SOFTIRQ] = "hrtimer", + [RCU_SOFTIRQ] = "rcu", +}; + +static int print_count(struct softirqs_bpf__bss *bss) +{ + const char *units = env.nanoseconds ? "nsecs" : "usecs"; + __u64 count; + __u32 vec; + + printf("%-16s %6s%5s\n", "SOFTIRQ", "TOTAL_", units); + + for (vec = 0; vec < NR_SOFTIRQS; vec++) { + count = __atomic_exchange_n(&bss->counts[vec], 0, + __ATOMIC_RELAXED); + if (count > 0) + printf("%-16s %11llu\n", vec_names[vec], count); + } + + return 0; +} + +static struct hist zero; + +static int print_hist(struct softirqs_bpf__bss *bss) +{ + const char *units = env.nanoseconds ? "nsecs" : "usecs"; + __u32 vec; + + for (vec = 0; vec < NR_SOFTIRQS; vec++) { + struct hist hist = bss->hists[vec]; + + bss->hists[vec] = zero; + if (!memcmp(&zero, &hist, sizeof(hist))) + continue; + printf("softirq = %s\n", vec_names[vec]); + print_log2_hist(hist.slots, MAX_SLOTS, units); + printf("\n"); + } + + return 0; +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct softirqs_bpf *obj; + struct tm *tm; + char ts[32]; + time_t t; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = softirqs_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF object\n"); + return 1; + } + + /* initialize global data (filtering options) */ + obj->rodata->targ_dist = env.distributed; + obj->rodata->targ_ns = env.nanoseconds; + + err = softirqs_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + err = softirqs_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs\n"); + goto cleanup; + } + + signal(SIGINT, sig_handler); + + printf("Tracing soft irq event time... Hit Ctrl-C to end.\n"); + + /* main: poll */ + while (1) { + sleep(env.interval); + printf("\n"); + + if (env.timestamp) { + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + printf("%-8s\n", ts); + } + + if (!env.distributed) + err = print_count(obj->bss); + else + err = print_hist(obj->bss); + if (err) + break; + + if (exiting || --env.times == 0) + break; + } + +cleanup: + softirqs_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/softirqs.h b/libbpf-tools/softirqs.h new file mode 100644 index 000000000..efc02a425 --- /dev/null +++ b/libbpf-tools/softirqs.h @@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __SOFTIRQS_H +#define __SOFTIRQS_H + +#define MAX_SLOTS 20 + +struct hist { + __u32 slots[MAX_SLOTS]; +}; + +#endif /* __SOFTIRQS_H */ From 48b7d61681ac6d4a32050d696d2eb9b2dd837c5f Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Thu, 3 Sep 2020 21:24:02 +0800 Subject: [PATCH 245/278] libbpf-tools: add runqlat Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/runqlat.bpf.c | 112 ++++++++++++++++ libbpf-tools/runqlat.c | 253 +++++++++++++++++++++++++++++++++++ libbpf-tools/runqlat.h | 13 ++ libbpf-tools/trace_helpers.c | 2 +- libbpf-tools/trace_helpers.h | 2 +- 7 files changed, 382 insertions(+), 2 deletions(-) create mode 100644 libbpf-tools/runqlat.bpf.c create mode 100644 libbpf-tools/runqlat.c create mode 100644 libbpf-tools/runqlat.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index d684d4e98..9c2a116ba 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -11,6 +11,7 @@ /hardirqs /opensnoop /readahead +/runqlat /runqslower /softirqs /syscount diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index a87df5337..c335e381a 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -22,6 +22,7 @@ APPS = \ hardirqs \ opensnoop \ readahead \ + runqlat \ runqslower \ softirqs \ syscount \ diff --git a/libbpf-tools/runqlat.bpf.c b/libbpf-tools/runqlat.bpf.c new file mode 100644 index 000000000..258407cbc --- /dev/null +++ b/libbpf-tools/runqlat.bpf.c @@ -0,0 +1,112 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_core_read.h> +#include <bpf/bpf_tracing.h> +#include "runqlat.h" +#include "bits.bpf.h" +#include "maps.bpf.h" + +#define MAX_ENTRIES 10240 +#define TASK_RUNNING 0 + +const volatile bool targ_per_process = false; +const volatile bool targ_per_thread = false; +const volatile bool targ_per_pidns = false; +const volatile bool targ_ms = false; +const volatile pid_t targ_tgid = 0; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, u32); + __type(value, u64); +} start SEC(".maps"); + +static struct hist zero; + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, u32); + __type(value, struct hist); +} hists SEC(".maps"); + +static __always_inline +int trace_enqueue(u32 tgid, u32 pid) +{ + u64 ts; + + if (!pid) + return 0; + if (targ_tgid && targ_tgid != tgid) + return 0; + + ts = bpf_ktime_get_ns(); + bpf_map_update_elem(&start, &pid, &ts, 0); + return 0; +} + +SEC("tp_btf/sched_wakeup") +int BPF_PROG(sched_wakeup, struct task_struct *p) +{ + return trace_enqueue(p->tgid, p->pid); +} + +SEC("tp_btf/sched_wakeup_new") +int BPF_PROG(sched_wakeup_new, struct task_struct *p) +{ + return trace_enqueue(p->tgid, p->pid); +} + +SEC("tp_btf/sched_switch") +int BPF_PROG(sched_swith, bool preempt, struct task_struct *prev, + struct task_struct *next) +{ + struct hist *histp; + u64 *tsp, slot; + u32 pid, hkey; + s64 delta; + + if (prev->state == TASK_RUNNING) + trace_enqueue(prev->tgid, prev->pid); + + pid = next->pid; + + tsp = bpf_map_lookup_elem(&start, &pid); + if (!tsp) + return 0; + delta = bpf_ktime_get_ns() - *tsp; + if (delta < 0) + goto cleanup; + + if (targ_per_process) + hkey = next->tgid; + else if (targ_per_thread) + hkey = pid; + else if (targ_per_pidns) + hkey = next->nsproxy->pid_ns_for_children->ns.inum; + else + hkey = -1; + histp = bpf_map_lookup_or_try_init(&hists, &hkey, &zero); + if (!histp) + goto cleanup; + if (!histp->comm[0]) + bpf_probe_read_kernel_str(&histp->comm, sizeof(histp->comm), + next->comm); + if (targ_ms) + delta /= 1000000U; + else + delta /= 1000U; + slot = log2l(delta); + if (slot >= MAX_SLOTS) + slot = MAX_SLOTS - 1; + __sync_fetch_and_add(&histp->slots[slot], 1); + +cleanup: + bpf_map_delete_elem(&start, &pid); + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/runqlat.c b/libbpf-tools/runqlat.c new file mode 100644 index 000000000..12cc40081 --- /dev/null +++ b/libbpf-tools/runqlat.c @@ -0,0 +1,253 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on runqlat(8) from BCC by Bredan Gregg. +// 10-Aug-2020 Wenbo Zhang Created this. +#include <argp.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> +#include <bpf/libbpf.h> +#include <bpf/bpf.h> +#include "runqlat.h" +#include "runqlat.skel.h" +#include "trace_helpers.h" + +struct env { + time_t interval; + pid_t pid; + int times; + bool milliseconds; + bool per_process; + bool per_thread; + bool per_pidns; + bool timestamp; + bool verbose; +} env = { + .interval = 99999999, + .times = 99999999, +}; + +static volatile bool exiting; + +const char *argp_program_version = "runqlat 0.1"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; +const char argp_program_doc[] = +"Summarize run queue (scheduler) latency as a histogram.\n" +"\n" +"USAGE: runqlat [--help] [-T] [-m] [--pidnss] [-L] [-P] [-p PID] [interval] [count]\n" +"\n" +"EXAMPLES:\n" +" runqlat # summarize run queue latency as a histogram\n" +" runqlat 1 10 # print 1 second summaries, 10 times\n" +" runqlat -mT 1 # 1s summaries, milliseconds, and timestamps\n" +" runqlat -P # show each PID separately\n" +" runqlat -p 185 # trace PID 185 only\n"; + +#define OPT_PIDNSS 1 /* --pidnss */ + +static const struct argp_option opts[] = { + { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, + { "milliseconds", 'm', NULL, 0, "Millisecond histogram" }, + { "pidnss", OPT_PIDNSS, NULL, 0, "Print a histogram per PID namespace" }, + { "pids", 'P', NULL, 0, "Print a histogram per process ID" }, + { "tids", 'L', NULL, 0, "Print a histogram per thread ID" }, + { "pid", 'p', "PID", 0, "Trace this PID only" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static int pos_args; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'm': + env.milliseconds = true; + break; + case 'p': + errno = 0; + env.pid = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid PID: %s\n", arg); + argp_usage(state); + } + break; + case 'L': + env.per_thread = true; + break; + case 'P': + env.per_process = true; + break; + case OPT_PIDNSS: + env.per_pidns = true; + break; + case 'T': + env.timestamp = true; + break; + case ARGP_KEY_ARG: + errno = 0; + if (pos_args == 0) { + env.interval = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid internal\n"); + argp_usage(state); + } + } else if (pos_args == 1) { + env.times = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid times\n"); + argp_usage(state); + } + } else { + fprintf(stderr, + "unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + pos_args++; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void sig_handler(int sig) +{ + exiting = true; +} + +static int print_log2_hists(struct bpf_map *hists) +{ + const char *units = env.milliseconds ? "msecs" : "usecs"; + int err, fd = bpf_map__fd(hists); + __u32 lookup_key = -2, next_key; + struct hist hist; + + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_lookup_elem(fd, &next_key, &hist); + if (err < 0) { + fprintf(stderr, "failed to lookup hist: %d\n", err); + return -1; + } + if (env.per_process) + printf("\npid = %d %s\n", next_key, hist.comm); + else if (env.per_thread) + printf("\ntid = %d %s\n", next_key, hist.comm); + else if (env.per_pidns) + printf("\npidns = %u %s\n", next_key, hist.comm); + print_log2_hist(hist.slots, MAX_SLOTS, units); + lookup_key = next_key; + } + + lookup_key = -2; + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_delete_elem(fd, &next_key); + if (err < 0) { + fprintf(stderr, "failed to cleanup hist : %d\n", err); + return -1; + } + lookup_key = next_key; + } + return 0; +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct runqlat_bpf *obj; + struct tm *tm; + char ts[32]; + time_t t; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + if ((env.per_thread && (env.per_process || env.per_pidns)) || + (env.per_process && env.per_pidns)) { + fprintf(stderr, "pidnss, pids, tids cann't be used together.\n"); + return 1; + } + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = runqlat_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF object\n"); + return 1; + } + + /* initialize global data (filtering options) */ + obj->rodata->targ_per_process = env.per_process; + obj->rodata->targ_per_thread = env.per_thread; + obj->rodata->targ_per_pidns = env.per_pidns; + obj->rodata->targ_ms = env.milliseconds; + obj->rodata->targ_tgid = env.pid; + + err = runqlat_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + err = runqlat_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs\n"); + goto cleanup; + } + + printf("Tracing run queue latency... Hit Ctrl-C to end.\n"); + + signal(SIGINT, sig_handler); + + /* main: poll */ + while (1) { + sleep(env.interval); + printf("\n"); + + if (env.timestamp) { + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + printf("%-8s\n", ts); + } + + err = print_log2_hists(obj->maps.hists); + if (err) + break; + + if (exiting || --env.times == 0) + break; + } + +cleanup: + runqlat_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/runqlat.h b/libbpf-tools/runqlat.h new file mode 100644 index 000000000..6a7ac9f3f --- /dev/null +++ b/libbpf-tools/runqlat.h @@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __RUNQLAT_H +#define __RUNQLAT_H + +#define TASK_COMM_LEN 16 +#define MAX_SLOTS 26 + +struct hist { + __u32 slots[MAX_SLOTS]; + char comm[TASK_COMM_LEN]; +}; + +#endif /* __RUNQLAT_H */ diff --git a/libbpf-tools/trace_helpers.c b/libbpf-tools/trace_helpers.c index 9452d208b..987a4513b 100644 --- a/libbpf-tools/trace_helpers.c +++ b/libbpf-tools/trace_helpers.c @@ -284,7 +284,7 @@ static void print_stars(unsigned int val, unsigned int val_max, int width) printf("+"); } -void print_log2_hist(unsigned int *vals, int vals_size, char *val_type) +void print_log2_hist(unsigned int *vals, int vals_size, const char *val_type) { int stars_max = 40, idx_max = -1; unsigned int val, val_max = 0; diff --git a/libbpf-tools/trace_helpers.h b/libbpf-tools/trace_helpers.h index eba6bc1c5..1978ab24c 100644 --- a/libbpf-tools/trace_helpers.h +++ b/libbpf-tools/trace_helpers.h @@ -32,7 +32,7 @@ partitions__get_by_dev(const struct partitions *partitions, unsigned int dev); const struct partition * partitions__get_by_name(const struct partitions *partitions, const char *name); -void print_log2_hist(unsigned int *vals, int vals_size, char *val_type); +void print_log2_hist(unsigned int *vals, int vals_size, const char *val_type); unsigned long long get_ktime_ns(void); int bump_memlock_rlimit(void); From 911ce07ddf156d23e8aabd30040e94f99ce4e518 Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Tue, 15 Sep 2020 20:46:57 -0400 Subject: [PATCH 246/278] libbpf-tools: add runqlen Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/runqlen.bpf.c | 48 ++++++ libbpf-tools/runqlen.c | 286 +++++++++++++++++++++++++++++++++++ libbpf-tools/runqlen.h | 12 ++ libbpf-tools/trace_helpers.c | 25 +++ libbpf-tools/trace_helpers.h | 1 + 7 files changed, 374 insertions(+) create mode 100644 libbpf-tools/runqlen.bpf.c create mode 100644 libbpf-tools/runqlen.c create mode 100644 libbpf-tools/runqlen.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 9c2a116ba..2bb225487 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -12,6 +12,7 @@ /opensnoop /readahead /runqlat +/runqlen /runqslower /softirqs /syscount diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index c335e381a..eb6a730f3 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -23,6 +23,7 @@ APPS = \ opensnoop \ readahead \ runqlat \ + runqlen \ runqslower \ softirqs \ syscount \ diff --git a/libbpf-tools/runqlen.bpf.c b/libbpf-tools/runqlen.bpf.c new file mode 100644 index 000000000..ecb834bd5 --- /dev/null +++ b/libbpf-tools/runqlen.bpf.c @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_core_read.h> +#include <bpf/bpf_tracing.h> +#include "runqlen.h" + +const volatile bool targ_per_cpu = false; + +struct hist hists[MAX_CPU_NR]; + +SEC("perf_event") +int do_sample(struct bpf_perf_event_data *ctx) +{ + struct task_struct *task; + struct hist *hist; + u64 slot, cpu = 0; + + task = (void*)bpf_get_current_task(); + slot = BPF_CORE_READ(task, se.cfs_rq, nr_running); + /* + * Calculate run queue length by subtracting the currently running task, + * if present. len 0 == idle, len 1 == one running task. + */ + if (slot > 0) + slot--; + if (targ_per_cpu) { + cpu = bpf_get_smp_processor_id(); + /* + * When the program is started, the user space will immediately + * exit when it detects this situation, here just to pass the + * verifier's check. + */ + if (cpu >= MAX_CPU_NR) + return 0; + } + hist = &hists[cpu]; + if (slot >= MAX_SLOTS) + slot = MAX_SLOTS - 1; + if (targ_per_cpu) + hist->slots[slot]++; + else + __sync_fetch_and_add(&hist->slots[slot], 1); + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/runqlen.c b/libbpf-tools/runqlen.c new file mode 100644 index 000000000..e1a2445fc --- /dev/null +++ b/libbpf-tools/runqlen.c @@ -0,0 +1,286 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on runqlen(8) from BCC by Brendan Gregg. +// 11-Sep-2020 Wenbo Zhang Created this. +#include <argp.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <time.h> +#include <linux/perf_event.h> +#include <asm/unistd.h> +#include <bpf/libbpf.h> +#include <bpf/bpf.h> +#include "runqlen.h" +#include "runqlen.skel.h" +#include "trace_helpers.h" + +#define FREQ 99 + +#define max(x, y) ({ \ + typeof(x) _max1 = (x); \ + typeof(y) _max2 = (y); \ + (void) (&_max1 == &_max2); \ + _max1 > _max2 ? _max1 : _max2; }) + +struct env { + bool per_cpu; + bool runqocc; + bool timestamp; + time_t interval; + int times; + bool verbose; +} env = { + .interval = 99999999, + .times = 99999999, +}; + +static volatile bool exiting; + +const char *argp_program_version = "runqlen 0.1"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; +const char argp_program_doc[] = +"Summarize scheduler run queue length as a histogram.\n" +"\n" +"USAGE: runqlen [--help] [-C] [-O] [-T] [interval] [count]\n" +"\n" +"EXAMPLES:\n" +" runqlen # summarize run queue length as a histogram\n" +" runqlen 1 10 # print 1 second summaries, 10 times\n" +" runqlen -T 1 # 1s summaries and timestamps\n" +" runqlen -O # report run queue occupancy\n" +" runqlen -C # show each CPU separately\n"; + +static const struct argp_option opts[] = { + { "cpus", 'C', NULL, 0, "Print output for each CPU separately" }, + { "runqocc", 'O', NULL, 0, "Report run queue occupancy" }, + { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static int pos_args; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'C': + env.per_cpu = true; + break; + case 'O': + env.runqocc = true; + break; + case 'T': + env.timestamp = true; + break; + case ARGP_KEY_ARG: + errno = 0; + if (pos_args == 0) { + env.interval = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid internal\n"); + argp_usage(state); + } + } else if (pos_args == 1) { + env.times = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid times\n"); + argp_usage(state); + } + } else { + fprintf(stderr, + "unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + pos_args++; + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +static int nr_cpus; + +static int open_and_attach_perf_event(int freq, struct bpf_program *prog, + struct bpf_link *links[]) +{ + struct perf_event_attr attr = { + .type = PERF_TYPE_SOFTWARE, + .freq = 1, + .sample_period = freq, + .config = PERF_COUNT_SW_CPU_CLOCK, + }; + int i, fd; + + for (i = 0; i < nr_cpus; i++) { + fd = syscall(__NR_perf_event_open, &attr, -1, i, -1, 0); + if (fd < 0) { + fprintf(stderr, "failed to init perf sampling: %s\n", + strerror(errno)); + return -1; + } + links[i] = bpf_program__attach_perf_event(prog, fd); + if (libbpf_get_error(links[i])) { + fprintf(stderr, "failed to attach perf event on cpu: " + "%d\n", i); + links[i] = NULL; + close(fd); + return -1; + } + } + + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void sig_handler(int sig) +{ + exiting = true; +} + +static struct hist zero; + +static void print_runq_occupancy(struct runqlen_bpf__bss *bss) +{ + __u64 samples, idle = 0, queued = 0; + struct hist hist; + int slot, i = 0; + float runqocc; + + do { + hist = bss->hists[i]; + bss->hists[i] = zero; + for (slot = 0; slot < MAX_SLOTS; slot++) { + __u64 val = hist.slots[slot]; + + if (slot == 0) + idle += val; + else + queued += val; + } + samples = idle + queued; + runqocc = queued * 1.0 / max(1ULL, samples); + if (env.per_cpu) + printf("runqocc, CPU %-3d %6.2f%%\n", i, + 100 * runqocc); + else + printf("runqocc: %0.2f%%\n", 100 * runqocc); + } while (env.per_cpu && ++i < nr_cpus); +} + +static void print_linear_hists(struct runqlen_bpf__bss *bss) +{ + struct hist hist; + int i = 0; + + do { + hist = bss->hists[i]; + bss->hists[i] = zero; + if (env.per_cpu) + printf("cpu = %d\n", i); + print_linear_hist(hist.slots, MAX_SLOTS, "runqlen"); + } while (env.per_cpu && ++i < nr_cpus); +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct bpf_link **links = NULL; + struct runqlen_bpf *obj; + struct tm *tm; + char ts[32]; + int err, i; + time_t t; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = runqlen_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF object\n"); + return 1; + } + + nr_cpus = libbpf_num_possible_cpus(); + if (nr_cpus > MAX_CPU_NR) { + fprintf(stderr, "The number of cpu cores is too much, please " + "increase MAX_CPU_NR's value and recompile"); + return 1; + } + links = calloc(nr_cpus, sizeof(*links)); + if (!links) { + fprintf(stderr, "failed to alloc links\n"); + goto cleanup; + } + + /* initialize global data (filtering options) */ + obj->rodata->targ_per_cpu = env.per_cpu; + + err = runqlen_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + if (open_and_attach_perf_event(FREQ, obj->progs.do_sample, links)) + goto cleanup; + + printf("Sampling run queue length... Hit Ctrl-C to end.\n"); + + signal(SIGINT, sig_handler); + + while (1) { + sleep(env.interval); + printf("\n"); + + if (env.timestamp) { + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + printf("%-8s\n", ts); + } + + if (env.runqocc) + print_runq_occupancy(obj->bss); + else + print_linear_hists(obj->bss); + + if (exiting || --env.times == 0) + break; + } + +cleanup: + for (i = 0; i < nr_cpus; i++) + bpf_link__destroy(links[i]); + free(links); + runqlen_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/runqlen.h b/libbpf-tools/runqlen.h new file mode 100644 index 000000000..605272898 --- /dev/null +++ b/libbpf-tools/runqlen.h @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __RUNQLEN_H +#define __RUNQLEN_H + +#define MAX_CPU_NR 128 +#define MAX_SLOTS 32 + +struct hist { + __u32 slots[MAX_SLOTS]; +}; + +#endif /* __RUNQLEN_H */ diff --git a/libbpf-tools/trace_helpers.c b/libbpf-tools/trace_helpers.c index 987a4513b..d4ae3aede 100644 --- a/libbpf-tools/trace_helpers.c +++ b/libbpf-tools/trace_helpers.c @@ -323,6 +323,31 @@ void print_log2_hist(unsigned int *vals, int vals_size, const char *val_type) } } +void print_linear_hist(unsigned int *vals, int vals_size, const char *val_type) +{ + int i, stars_max = 40, idx_max = -1; + unsigned int val, val_max = 0; + + for (i = 0; i < vals_size; i++) { + val = vals[i]; + if (val > 0) + idx_max = i; + if (val > val_max) + val_max = val; + } + + if (idx_max < 0) + return; + + printf(" %-13s : count distribution\n", val_type); + for (i = 0; i <= idx_max; i++) { + val = vals[i]; + printf(" %-10d : %-8d |", i, val); + print_stars(val, val_max, stars_max); + printf("|\n"); + } +} + unsigned long long get_ktime_ns(void) { struct timespec ts; diff --git a/libbpf-tools/trace_helpers.h b/libbpf-tools/trace_helpers.h index 1978ab24c..486db5d1b 100644 --- a/libbpf-tools/trace_helpers.h +++ b/libbpf-tools/trace_helpers.h @@ -33,6 +33,7 @@ const struct partition * partitions__get_by_name(const struct partitions *partitions, const char *name); void print_log2_hist(unsigned int *vals, int vals_size, const char *val_type); +void print_linear_hist(unsigned int *vals, int vals_size, const char *val_type); unsigned long long get_ktime_ns(void); int bump_memlock_rlimit(void); From caaeb0a87c95f0dd1ac1f1b0c260ec2f6c8a3c94 Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Thu, 3 Sep 2020 15:20:55 +0800 Subject: [PATCH 247/278] libbpf-tools: add numamove Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/numamove.bpf.c | 49 +++++++++++++++ libbpf-tools/numamove.c | 121 ++++++++++++++++++++++++++++++++++++ 4 files changed, 172 insertions(+) create mode 100644 libbpf-tools/numamove.bpf.c create mode 100644 libbpf-tools/numamove.c diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index 2bb225487..b9d1f8823 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -9,6 +9,7 @@ /execsnoop /filelife /hardirqs +/numamove /opensnoop /readahead /runqlat diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index eb6a730f3..e0f308ccc 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -20,6 +20,7 @@ APPS = \ execsnoop \ filelife \ hardirqs \ + numamove \ opensnoop \ readahead \ runqlat \ diff --git a/libbpf-tools/numamove.bpf.c b/libbpf-tools/numamove.bpf.c new file mode 100644 index 000000000..f4f0d5461 --- /dev/null +++ b/libbpf-tools/numamove.bpf.c @@ -0,0 +1,49 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, 10240); + __type(key, u32); + __type(value, u64); + __uint(map_flags, BPF_F_NO_PREALLOC); +} start SEC(".maps"); + +__u64 latency = 0; +__u64 num = 0; + +SEC("fentry/migrate_misplaced_page") +int BPF_PROG(migrate_misplaced_page) +{ + u32 pid = bpf_get_current_pid_tgid(); + u64 ts = bpf_ktime_get_ns(); + + bpf_map_update_elem(&start, &pid, &ts, 0); + return 0; +} + +SEC("fexit/migrate_misplaced_page") +int BPF_PROG(migrate_misplaced_page_exit) +{ + u32 pid = bpf_get_current_pid_tgid(); + u64 *tsp, ts = bpf_ktime_get_ns(); + s64 delta; + + tsp = bpf_map_lookup_elem(&start, &pid); + if (!tsp) + return 0; + delta = (s64)(ts - *tsp); + if (delta < 0) + goto cleanup; + __sync_fetch_and_add(&latency, delta / 1000000U); + __sync_fetch_and_add(&num, 1); + +cleanup: + bpf_map_delete_elem(&start, &pid); + return 0; +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/numamove.c b/libbpf-tools/numamove.c new file mode 100644 index 000000000..e03f91c92 --- /dev/null +++ b/libbpf-tools/numamove.c @@ -0,0 +1,121 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on numamove(8) from from BPF-Perf-Tools-Book by Brendan Gregg. +// 8-Jun-2020 Wenbo Zhang Created this. +#include <argp.h> +#include <signal.h> +#include <stdio.h> +#include <unistd.h> +#include <time.h> +#include <bpf/libbpf.h> +#include <bpf/bpf.h> +#include "numamove.skel.h" +#include "trace_helpers.h" + +static struct env { + bool verbose; +} env; + +static volatile bool exiting; + +const char *argp_program_version = "numamove 0.1"; +const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char argp_program_doc[] = +"Show page migrations of type NUMA misplaced per second.\n" +"\n" +"USAGE: numamove [--help]\n" +"\n" +"EXAMPLES:\n" +" numamove # Show page migrations' count and latency"; + +static const struct argp_option opts[] = { + { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + switch (key) { + case 'v': + env.verbose = true; + break; + case 'h': + argp_usage(state); + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void sig_handler(int sig) +{ + exiting = true; +} + +int main(int argc, char **argv) +{ + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct numamove_bpf *obj; + struct tm *tm; + char ts[32]; + time_t t; + int err; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = numamove_bpf__open_and_load(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF object\n"); + return 1; + } + + err = numamove_bpf__attach(obj); + if (err) { + fprintf(stderr, "failed to attach BPF programs\n"); + goto cleanup; + } + + signal(SIGINT, sig_handler); + + printf("%-10s %18s %18s\n", "TIME", "NUMA_migrations", + "NUMA_migrations_ms"); + while (!exiting) { + sleep(1); + time(&t); + tm = localtime(&t); + strftime(ts, sizeof(ts), "%H:%M:%S", tm); + printf("%-10s %18lld %18lld\n", ts, + __atomic_exchange_n(&obj->bss->num, 0, + __ATOMIC_RELAXED), + __atomic_exchange_n(&obj->bss->latency, 0, + __ATOMIC_RELAXED)); + } + +cleanup: + numamove_bpf__destroy(obj); + return err != 0; +} From 39a2a8f02cc3871ab375b005a00e296aa668d9ec Mon Sep 17 00:00:00 2001 From: Junyeong Jeong <rhdxmr@gmail.com> Date: Sat, 19 Sep 2020 18:59:15 +0900 Subject: [PATCH 248/278] Add uretprobe example for indirect function Already there is strlen_hist.py as a nice example of uretprobe. But it can not work correctly if strlen is indirect function(IFUNC). So strlen_hist_ifunc.py is introduced to show how to use uprobe/uretprobe for indirect functions. --- examples/tracing/strlen_hist_ifunc.py | 132 ++++++++++++++++++++++++++ 1 file changed, 132 insertions(+) create mode 100755 examples/tracing/strlen_hist_ifunc.py diff --git a/examples/tracing/strlen_hist_ifunc.py b/examples/tracing/strlen_hist_ifunc.py new file mode 100755 index 000000000..605907c67 --- /dev/null +++ b/examples/tracing/strlen_hist_ifunc.py @@ -0,0 +1,132 @@ +#!/usr/bin/python +# +# strlen_hist_ifunc.py Histogram of system-wide strlen return values. +# This can be used instead of strlen_hist.py if strlen is indirect function. + +from __future__ import print_function +from bcc import BPF +from bcc.libbcc import lib, bcc_symbol, bcc_symbol_option + +import ctypes as ct +import sys +import time + +NAME = 'c' +SYMBOL = 'strlen' +STT_GNU_IFUNC = 1 << 10 + +HIST_BPF_TEXT = """ +#include <uapi/linux/ptrace.h> +BPF_HISTOGRAM(dist); +int count(struct pt_regs *ctx) { + dist.increment(bpf_log2l(PT_REGS_RC(ctx))); + return 0; +} +""" + +SUBMIT_FUNC_ADDR_BPF_TEXT = """ +#include <uapi/linux/ptrace.h> + +BPF_PERF_OUTPUT(impl_func_addr); +void submit_impl_func_addr(struct pt_regs *ctx) { + u64 addr = PT_REGS_RC(ctx); + impl_func_addr.perf_submit(ctx, &addr, sizeof(addr)); +} + + +BPF_PERF_OUTPUT(resolv_func_addr); +int submit_resolv_func_addr(struct pt_regs *ctx) { + u64 rip = PT_REGS_IP(ctx); + resolv_func_addr.perf_submit(ctx, &rip, sizeof(rip)); + return 0; +} +""" + + +def get_indirect_function_sym(module, symname): + sym = bcc_symbol() + sym_op = bcc_symbol_option() + sym_op.use_debug_file = 1 + sym_op.check_debug_file_crc = 1 + sym_op.lazy_symbolize = 1 + sym_op.use_symbol_type = STT_GNU_IFUNC + if lib.bcc_resolve_symname( + module.encode(), + symname.encode(), + 0x0, + 0, + ct.byref(sym_op), + ct.byref(sym), + ) < 0: + return None + else: + return sym + + +def set_impl_func_addr(cpu, data, size): + addr = ct.cast(data, ct.POINTER(ct.c_uint64)).contents.value + global impl_func_addr + impl_func_addr = addr + + +def set_resolv_func_addr(cpu, data, size): + addr = ct.cast(data, ct.POINTER(ct.c_uint64)).contents.value + global resolv_func_addr + resolv_func_addr = addr + + +def find_impl_func_offset(ifunc_symbol): + b = BPF(text=SUBMIT_FUNC_ADDR_BPF_TEXT) + b.attach_uprobe(name=NAME, sym=SYMBOL, fn_name=b'submit_resolv_func_addr') + b['resolv_func_addr'].open_perf_buffer(set_resolv_func_addr) + b.attach_uretprobe(name=NAME, sym=SYMBOL, fn_name=b"submit_impl_func_addr") + b['impl_func_addr'].open_perf_buffer(set_impl_func_addr) + + print('wait for the first {} call'.format(SYMBOL)) + while True: + try: + if resolv_func_addr and impl_func_addr: + b.detach_uprobe(name=NAME, sym=SYMBOL) + b.detach_uretprobe(name=NAME, sym=SYMBOL) + b.cleanup() + break + b.perf_buffer_poll() + except KeyboardInterrupt: + exit() + print('IFUNC resolution of {} is performed'.format(SYMBOL)) + print('resolver function address: {:#x}'.format(resolv_func_addr)) + print('resolver function offset: {:#x}'.format(ifunc_symbol.offset)) + print('function implementation address: {:#x}'.format(impl_func_addr)) + impl_func_offset = impl_func_addr - resolv_func_addr + ifunc_symbol.offset + print('function implementation offset: {:#x}'.format(impl_func_offset)) + return impl_func_offset + + +def main(): + ifunc_symbol = get_indirect_function_sym(NAME, SYMBOL) + if not ifunc_symbol: + sys.stderr.write('{} is not an indirect function. abort!\n'.format(SYMBOL)) + exit(1) + + impl_func_offset = find_impl_func_offset(ifunc_symbol) + + b = BPF(text=HIST_BPF_TEXT) + b.attach_uretprobe(name=ct.cast(ifunc_symbol.module, ct.c_char_p).value, + addr=impl_func_offset, + fn_name=b'count') + dist = b['dist'] + try: + while True: + time.sleep(1) + print('%-8s\n' % time.strftime('%H:%M:%S'), end='') + dist.print_log2_hist(SYMBOL + ' return:') + dist.clear() + + except KeyboardInterrupt: + pass + + +resolv_func_addr = 0 +impl_func_addr = 0 + +main() From e548dd5728332da4bee048cc1b6775af8183f040 Mon Sep 17 00:00:00 2001 From: liuxiaozhou <liuxiaozhou@bytedance.com> Date: Thu, 24 Sep 2020 16:05:55 +0800 Subject: [PATCH 249/278] tools/tcpstates: remove unnecessary checking of TCP --- tools/tcpstates.py | 36 ------------------------------------ 1 file changed, 36 deletions(-) diff --git a/tools/tcpstates.py b/tools/tcpstates.py index 57fbb7658..616c2b743 100755 --- a/tools/tcpstates.py +++ b/tools/tcpstates.py @@ -169,42 +169,6 @@ bpf_text_kprobe = """ int kprobe__tcp_set_state(struct pt_regs *ctx, struct sock *sk, int state) { - // check this is TCP - u8 protocol = 0; - - // Following comments add by Joe Yin: - // Unfortunately,it can not work since Linux 4.10, - // because the sk_wmem_queued is not following the bitfield of sk_protocol. - // And the following member is sk_gso_max_segs. - // So, we can use this: - // bpf_probe_read_kernel(&protocol, 1, (void *)((u64)&newsk->sk_gso_max_segs) - 3); - // In order to diff the pre-4.10 and 4.10+ ,introduce the variables gso_max_segs_offset,sk_lingertime, - // sk_lingertime is closed to the gso_max_segs_offset,and - // the offset between the two members is 4 - - int gso_max_segs_offset = offsetof(struct sock, sk_gso_max_segs); - int sk_lingertime_offset = offsetof(struct sock, sk_lingertime); - - if (sk_lingertime_offset - gso_max_segs_offset == 4) - // 4.10+ with little endian -#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ - bpf_probe_read_kernel(&protocol, 1, (void *)((u64)&sk->sk_gso_max_segs) - 3); -else - // pre-4.10 with little endian - bpf_probe_read_kernel(&protocol, 1, (void *)((u64)&sk->sk_wmem_queued) - 3); -#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ - // 4.10+ with big endian - bpf_probe_read_kernel(&protocol, 1, (void *)((u64)&sk->sk_gso_max_segs) - 1); -else - // pre-4.10 with big endian - bpf_probe_read_kernel(&protocol, 1, (void *)((u64)&sk->sk_wmem_queued) - 1); -#else -# error "Fix your compiler's __BYTE_ORDER__?!" -#endif - - if (protocol != IPPROTO_TCP) - return 0; - u32 pid = bpf_get_current_pid_tgid() >> 32; // sk is used as a UUID From 561a71e105985ad04f5eb070b3487f5317f063b3 Mon Sep 17 00:00:00 2001 From: Suchakra Sharma <suchakra@gmail.com> Date: Thu, 24 Sep 2020 08:27:15 -0700 Subject: [PATCH 250/278] tool: port readahead tool to bcc --- README.md | 1 + man/man8/readahead.8 | 59 +++++++++++++++++ tools/readahead.py | 122 ++++++++++++++++++++++++++++++++++++ tools/readahead_example.txt | 60 ++++++++++++++++++ 4 files changed, 242 insertions(+) create mode 100644 man/man8/readahead.8 create mode 100755 tools/readahead.py create mode 100644 tools/readahead_example.txt diff --git a/README.md b/README.md index cbecf857c..59d8e090c 100644 --- a/README.md +++ b/README.md @@ -137,6 +137,7 @@ pair of .c and .py files, and some are directories of files. - tools/[opensnoop](tools/opensnoop.py): Trace open() syscalls. [Examples](tools/opensnoop_example.txt). - tools/[pidpersec](tools/pidpersec.py): Count new processes (via fork). [Examples](tools/pidpersec_example.txt). - tools/[profile](tools/profile.py): Profile CPU usage by sampling stack traces at a timed interval. [Examples](tools/profile_example.txt). +- tools/[readahead](tools/readahead.py): Show performance of read-ahead cache [Examples](tools/readahead_example.txt). - tools/[reset-trace](tools/reset-trace.sh): Reset the state of tracing. Maintenance tool only. [Examples](tools/reset-trace_example.txt). - tools/[runqlat](tools/runqlat.py): Run queue (scheduler) latency as a histogram. [Examples](tools/runqlat_example.txt). - tools/[runqlen](tools/runqlen.py): Run queue length as a histogram. [Examples](tools/runqlen_example.txt). diff --git a/man/man8/readahead.8 b/man/man8/readahead.8 new file mode 100644 index 000000000..a2a109149 --- /dev/null +++ b/man/man8/readahead.8 @@ -0,0 +1,59 @@ +.TH readahead 8 "2020-08-20" "USER COMMANDS" +.SH NAME +readahead \- Show performance of read-ahead cache +.SH SYNOPSIS +.B readahead [-d DURATION] +.SH DESCRIPTION +The tool shows the performance of read-ahead caching on the system under a given load to investigate any +caching issues. It shows a count of unused pages in the cache and also prints a histogram showing how +long they have remained there. + +This tool traces the \fB__do_page_cache_readahead()\fR kernel function to track entry and exit in the +readahead mechanism in the kernel and then uses \fB__page_cache_alloc()\fR and \fBmark_page_accessed()\fR +functions to calculate the age of the page in the cache as well as see how many are left unaccessed. + +Since this uses BPF, only the root user can use this tool. +.SS NOTE ON KPROBES USAGE +Since the tool uses Kprobes, depending on your linux kernel's compilation, these functions may be inlined +and hence not available for Kprobes. To see whether you have the functions available, check \fBvmlinux\fR +source and binary to confirm whether inlining is happening or not. You can also check \fB/proc/kallsyms\fR +on the host and verify if the target functions are present there before using this. +.SH REQUIREMENTS +CONFIG_BPF, bcc +.SH OPTIONS +\-h +Print usage message +.TP +\-d DURATION +Trace the read-ahead caching system for DURATION seconds +.SH EXAMPLES +.TP +Trace for 30 seconds and show histogram of page age (ms) in read-ahead cache along with unused page count: +# +.B readahead -d 30 +.SH OVERHEAD +The kernel functions instrumented by this program could be high-frequency depending on the profile of the +application (for example sequential IO). We advise the users to measure and monitor the overhead before leaving +this turned on in production environments. +.SH SOURCE +This originated as a bpftrace tool from the book "BPF Performance Tools", +published by Addison Wesley (2019): +.IP +http://www.brendangregg.com/bpf-performance-tools-book.html +.PP +See the book for more documentation on this tool. +.PP +This version is in the BCC repository: +.IP +https://github.com/iovisor/bcc +.PP +Also look in the bcc distribution for a companion _examples.txt file containing +example usage, output, and commentary for this tool. +.SH OS +Linux +.SH STABILITY +Unstable - in development. +.SH AUTHOR +Suchakra Sharma +.SH SEE ALSO +readahead(2), madvise(2) diff --git a/tools/readahead.py b/tools/readahead.py new file mode 100755 index 000000000..14182d5ac --- /dev/null +++ b/tools/readahead.py @@ -0,0 +1,122 @@ +#!/usr/bin/python +# @lint-avoid-python-3-compatibility-imports +# +# readahead Show performance of read-ahead cache +# For Linux, uses BCC, eBPF +# +# Copyright (c) 2020 Suchakra Sharma <mail@suchakra.in> +# Licensed under the Apache License, Version 2.0 (the "License") +# This was originally created for the BPF Performance Tools book +# published by Addison Wesley. ISBN-13: 9780136554820 +# When copying or porting, include this comment. +# +# 20-Aug-2020 Suchakra Sharma Ported from bpftrace to BCC + +from __future__ import print_function +from bcc import BPF +from time import sleep +import ctypes as ct +import argparse + +# arguments +examples = """examples: + ./readahead -d 20 # monitor for 10 seconds and generate stats +""" + +parser = argparse.ArgumentParser( + description="Monitor performance of read ahead cache", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=examples) +parser.add_argument("-d", "--duration", type=int, + help="total duration to monitor for, in seconds") +args = parser.parse_args() +if not args.duration: + args.duration = 99999999 + +# BPF program +program = """ +#include <uapi/linux/ptrace.h> +#include <linux/mm_types.h> + +BPF_HASH(flag, u32, u8); // used to track if we are in do_page_cache_readahead() +BPF_HASH(birth, struct page*, u64); // used to track timestamps of cache alloc'ed page +BPF_ARRAY(pages); // increment/decrement readahead pages +BPF_HISTOGRAM(dist); + +int entry__do_page_cache_readahead(struct pt_regs *ctx) { + u32 pid; + u8 one = 1; + pid = bpf_get_current_pid_tgid(); + flag.update(&pid, &one); + return 0; +} + +int exit__do_page_cache_readahead(struct pt_regs *ctx) { + u32 pid; + u8 zero = 0; + pid = bpf_get_current_pid_tgid(); + flag.update(&pid, &zero); + return 0; +} + +int exit__page_cache_alloc(struct pt_regs *ctx) { + u32 pid; + u64 ts; + struct page *retval = (struct page*) PT_REGS_RC(ctx); + u32 zero = 0; // static key for accessing pages[0] + pid = bpf_get_current_pid_tgid(); + u8 *f = flag.lookup(&pid); + if (f != NULL && *f == 1) { + ts = bpf_ktime_get_ns(); + birth.update(&retval, &ts); + + u64 *count = pages.lookup(&zero); + if (count) (*count)++; // increment read ahead pages count + } + return 0; +} + +int entry_mark_page_accessed(struct pt_regs *ctx) { + u64 ts, delta; + struct page *arg0 = (struct page *) PT_REGS_PARM1(ctx); + u32 zero = 0; // static key for accessing pages[0] + u64 *bts = birth.lookup(&arg0); + if (bts != NULL) { + delta = bpf_ktime_get_ns() - *bts; + dist.increment(bpf_log2l(delta/1000000)); + + u64 *count = pages.lookup(&zero); + if (count) (*count)--; // decrement read ahead pages count + + birth.delete(&arg0); // remove the entry from hashmap + } + return 0; +} +""" + +b = BPF(text=program) +b.attach_kprobe(event="__do_page_cache_readahead", fn_name="entry__do_page_cache_readahead") +b.attach_kretprobe(event="__do_page_cache_readahead", fn_name="exit__do_page_cache_readahead") +b.attach_kretprobe(event="__page_cache_alloc", fn_name="exit__page_cache_alloc") +b.attach_kprobe(event="mark_page_accessed", fn_name="entry_mark_page_accessed") + +# header +print("Tracing... Hit Ctrl-C to end.") + +# print +def print_stats(): + print() + print("Read-ahead unused pages: %d" % (b["pages"][ct.c_ulong(0)].value)) + print("Histogram of read-ahead used page age (ms):") + print("") + b["dist"].print_log2_hist("age (ms)") + b["dist"].clear() + b["pages"].clear() + +while True: + try: + sleep(args.duration) + print_stats() + except KeyboardInterrupt: + print_stats() + break diff --git a/tools/readahead_example.txt b/tools/readahead_example.txt new file mode 100644 index 000000000..079dbaae7 --- /dev/null +++ b/tools/readahead_example.txt @@ -0,0 +1,60 @@ +Demonstration of readahead, the Linux eBPF/bcc version + +Read-ahead mechanism is used by operation sytems to optimize sequential operations +by reading ahead some pages to avoid more expensive filesystem operations. This tool +shows the performance of the read-ahead caching on the system under a given load to +investigate any caching issues. It shows a count for unused pages in the cache and +also prints a histogram showing how long they have remianed there. + +Usage Scenario +============== + +Consider that you are developing a React Native application which performs aggressive +reads while re-encoding a video in local-storage. Usually such an app would be multi- +layered and have transitional library dependencies. The actual read may be performed +by some unknown native library which may or may not be using hints to the OS, such as +madvise(p, LEN, MADV_SEQUENTIAL). If high IOPS is observed in such an app, running +readahead may pin the issue much faster in this case as the developer digs deeper +into what may be causing this. + +An example where such an issue can surface is: https://github.com/boltdb/bolt/issues/691 + +# readahead -d 30 +Tracing... Hit Ctrl-C to end. +^C +Read-ahead unused pages: 6765 +Histogram of read-ahead used page age (ms): + + age (ms) : count distribution + 0 -> 1 : 4236 |****************************************| + 2 -> 3 : 394 |*** | + 4 -> 7 : 1670 |*************** | + 8 -> 15 : 2132 |******************** | + 16 -> 31 : 401 |*** | + 32 -> 63 : 1256 |*********** | + 64 -> 127 : 2352 |********************** | + 128 -> 255 : 357 |*** | + 256 -> 511 : 369 |*** | + 512 -> 1023 : 366 |*** | + 1024 -> 2047 : 181 |* | + 2048 -> 4095 : 439 |**** | + 4096 -> 8191 : 188 |* | + +In the example above, we recorded system-wide stats for 30 seconds. We can observe that +while most of the pages stayed in the readahead cache for quite less time, after 30 +seconds 6765 pages still remained in the cache, yet unaccessed. + +Note on Kprobes Usage +===================== + +This tool uses Kprobes on the following kernel functions: + +__do_page_cache_readahead() +__page_cache_alloc() +mark_page_accessed() + +Since the tool uses Kprobes, depending on your linux kernel's compilation, these +functions may be inlined and hence not available for Kprobes. To see whether you have +the functions available, check vmlinux source and binary to confirm whether inlining is +happening or not. You can also check /proc/kallsyms on the host and verify if the target +functions are present there before using this tool. From 4cbcd9afa83226405abd773212ed423c5d06fd26 Mon Sep 17 00:00:00 2001 From: zhenwei pi <pizhenwei@bytedance.com> Date: Tue, 29 Sep 2020 00:07:38 +0800 Subject: [PATCH 251/278] tcprtt: add --byladdr/--byraddr (#3106) On a server side, a server listens a local port and accepts lots of connections. To seperate histogram into views by each remote address, so add --byraddr to support this. Suggested-by: Brendan Gregg <brendan.d.gregg@gmail.com> Signed-off-by: zhenwei pi <pizhenwei@bytedance.com> --- README.md | 1 + man/man8/tcprtt.8 | 32 ++++++--- tools/tcprtt.py | 148 +++++++++++++++++++++++++-------------- tools/tcprtt_example.txt | 77 +++++++++++++++----- 4 files changed, 179 insertions(+), 79 deletions(-) diff --git a/README.md b/README.md index 59d8e090c..e5af60e3f 100644 --- a/README.md +++ b/README.md @@ -158,6 +158,7 @@ pair of .c and .py files, and some are directories of files. - tools/[tcpdrop](tools/tcpdrop.py): Trace kernel-based TCP packet drops with details. [Examples](tools/tcpdrop_example.txt). - tools/[tcplife](tools/tcplife.py): Trace TCP sessions and summarize lifespan. [Examples](tools/tcplife_example.txt). - tools/[tcpretrans](tools/tcpretrans.py): Trace TCP retransmits and TLPs. [Examples](tools/tcpretrans_example.txt). +- tools/[tcprtt](tools/tcprtt.py): Trace TCP round trip time. [Examples](tools/tcprtt_example.txt). - tools/[tcpstates](tools/tcpstates.py): Trace TCP session state changes with durations. [Examples](tools/tcpstates_example.txt). - tools/[tcpsubnet](tools/tcpsubnet.py): Summarize and aggregate TCP send by subnet. [Examples](tools/tcpsubnet_example.txt). - tools/[tcpsynbl](tools/tcpsynbl.py): Show TCP SYN backlog. [Examples](tools/tcpsynbl_example.txt). diff --git a/man/man8/tcprtt.8 b/man/man8/tcprtt.8 index 5c3bb89b9..729a1abb1 100644 --- a/man/man8/tcprtt.8 +++ b/man/man8/tcprtt.8 @@ -2,7 +2,7 @@ .SH NAME tcprtt \- Trace TCP RTT of established connections. Uses Linux eBPF/bcc. .SH SYNOPSIS -.B tcprtt [\-h] [\-T] [\-D] [\-m] [\-i INTERVAL] [\-d DURATION] +.B tcprtt [\-h] [\-T] [\-D] [\-m] [\-i INTERVAL] [\-d DURATION] [\-b] [\-B] .SH DESCRIPTION This tool traces established connections RTT(round-trip time) to analyze the quality of network. This can be useful for general troubleshooting to @@ -31,17 +31,23 @@ Print output every interval seconds. \-d DURATION Total duration of trace in seconds. .TP -\-p SPORT -Filter for source port. +\-p LPORT +Filter for local port. .TP -\-P DPORT -Filter for destination port. +\-P RPORT +Filter for remote port. .TP -\-a SADDR -Filter for source address. +\-a LADDR +Filter for local address. .TP -\-A DADDR -Filter for destination address. +\-A RADDR +Filter for remote address. +.TP +\-b +Show sockets histogram by local address. +.TP +\-B +Show sockets histogram by remote address. .SH EXAMPLES .TP Trace TCP RTT and print 1 second summaries, 10 times: @@ -52,9 +58,13 @@ Summarize in millisecond, and timestamps: # .B tcprtt \-m \-T .TP -Only trace TCP RTT for destination address 192.168.1.100 and destination port 80: +Only trace TCP RTT for remote address 192.168.1.100 and remote port 80: +# +.B tcprtt \-i 1 \-d 10 \-A 192.168.1.100 \-P 80 +.TP +Trace local port and show a breakdown of remote hosts RTT: # -.B tcprtt \-i 1 \-d 10 -A 192.168.1.100 -P 80 +.B tcprtt \-i 3 --lport 80 --byraddr .SH OVERHEAD This traces the kernel tcp_rcv_established function and collects TCP RTT. The rate of this depends on your server application. If it is a web or proxy server diff --git a/tools/tcprtt.py b/tools/tcprtt.py index 81832cf0f..155ccffb2 100755 --- a/tools/tcprtt.py +++ b/tools/tcprtt.py @@ -4,7 +4,7 @@ # tcprtt Summarize TCP RTT as a histogram. For Linux, uses BCC, eBPF. # # USAGE: tcprtt [-h] [-T] [-D] [-m] [-i INTERVAL] [-d DURATION] -# [-p SPORT] [-P DPORT] [-a SADDR] [-A DADDR] +# [-p LPORT] [-P RPORT] [-a LADDR] [-A RADDR] [-b] [-B] # # Copyright (c) 2020 zhenwei pi # Licensed under the Apache License, Version 2.0 (the "License") @@ -14,6 +14,7 @@ from __future__ import print_function from bcc import BPF from time import sleep, strftime +from socket import inet_ntop, AF_INET import socket, struct import argparse @@ -22,10 +23,12 @@ ./tcprtt # summarize TCP RTT ./tcprtt -i 1 -d 10 # print 1 second summaries, 10 times ./tcprtt -m -T # summarize in millisecond, and timestamps - ./tcprtt -p # filter for source port - ./tcprtt -P # filter for destination port - ./tcprtt -a # filter for source address - ./tcprtt -A # filter for destination address + ./tcprtt -p # filter for local port + ./tcprtt -P # filter for remote port + ./tcprtt -a # filter for local address + ./tcprtt -A # filter for remote address + ./tcprtt -b # show sockets histogram by local address + ./tcprtt -B # show sockets histogram by remote address ./tcprtt -D # show debug bpf text """ parser = argparse.ArgumentParser( @@ -40,14 +43,18 @@ help="include timestamp on output") parser.add_argument("-m", "--milliseconds", action="store_true", help="millisecond histogram") -parser.add_argument("-p", "--sport", - help="source port") -parser.add_argument("-P", "--dport", - help="destination port") -parser.add_argument("-a", "--saddr", - help="source address") -parser.add_argument("-A", "--daddr", - help="destination address") +parser.add_argument("-p", "--lport", + help="filter for local port") +parser.add_argument("-P", "--rport", + help="filter for remote port") +parser.add_argument("-a", "--laddr", + help="filter for local address") +parser.add_argument("-A", "--raddr", + help="filter for remote address") +parser.add_argument("-b", "--byladdr", action="store_true", + help="show sockets histogram by local address") +parser.add_argument("-B", "--byraddr", action="store_true", + help="show sockets histogram by remote address") parser.add_argument("-D", "--debug", action="store_true", help="print BPF program before starting (for debugging purposes)") parser.add_argument("--ebpf", action="store_true", @@ -67,65 +74,72 @@ #include <net/inet_sock.h> #include <bcc/proto.h> -BPF_HISTOGRAM(hist_srtt); +typedef struct sock_key { + u64 addr; + u64 slot; +} sock_key_t; + +STORAGE int trace_tcp_rcv(struct pt_regs *ctx, struct sock *sk, struct sk_buff *skb) { struct tcp_sock *ts = tcp_sk(sk); u32 srtt = ts->srtt_us >> 3; const struct inet_sock *inet = inet_sk(sk); + u16 sport = 0; + u16 dport = 0; + u32 saddr = 0; + u32 daddr = 0; + + bpf_probe_read_kernel(&sport, sizeof(sport), (void *)&inet->inet_sport); + bpf_probe_read_kernel(&dport, sizeof(dport), (void *)&inet->inet_dport); + bpf_probe_read_kernel(&saddr, sizeof(saddr), (void *)&inet->inet_saddr); + bpf_probe_read_kernel(&daddr, sizeof(daddr), (void *)&inet->inet_daddr); + + LPORTFILTER + RPORTFILTER + LADDRFILTER + RADDRFILTER - SPORTFILTER - DPORTFILTER - SADDRFILTER - DADDRFILTER FACTOR - hist_srtt.increment(bpf_log2l(srtt)); + STORE return 0; } """ -# filter for source port -if args.sport: - bpf_text = bpf_text.replace(b'SPORTFILTER', - b"""u16 sport = 0; - bpf_probe_read_kernel(&sport, sizeof(sport), (void *)&inet->inet_sport); - if (ntohs(sport) != %d) - return 0;""" % int(args.sport)) +# filter for local port +if args.lport: + bpf_text = bpf_text.replace(b'LPORTFILTER', + b"""if (ntohs(sport) != %d) + return 0;""" % int(args.lport)) else: - bpf_text = bpf_text.replace(b'SPORTFILTER', b'') + bpf_text = bpf_text.replace(b'LPORTFILTER', b'') -# filter for dest port -if args.dport: - bpf_text = bpf_text.replace(b'DPORTFILTER', - b"""u16 dport = 0; - bpf_probe_read_kernel(&dport, sizeof(dport), (void *)&inet->inet_dport); - if (ntohs(dport) != %d) - return 0;""" % int(args.dport)) +# filter for remote port +if args.rport: + bpf_text = bpf_text.replace(b'RPORTFILTER', + b"""if (ntohs(dport) != %d) + return 0;""" % int(args.rport)) else: - bpf_text = bpf_text.replace(b'DPORTFILTER', b'') + bpf_text = bpf_text.replace(b'RPORTFILTER', b'') -# filter for source address -if args.saddr: - bpf_text = bpf_text.replace(b'SADDRFILTER', - b"""u32 saddr = 0; - bpf_probe_read_kernel(&saddr, sizeof(saddr), (void *)&inet->inet_saddr); - if (saddr != %d) - return 0;""" % struct.unpack("=I", socket.inet_aton(args.saddr))[0]) +# filter for local address +if args.laddr: + bpf_text = bpf_text.replace(b'LADDRFILTER', + b"""if (saddr != %d) + return 0;""" % struct.unpack("=I", socket.inet_aton(args.laddr))[0]) else: - bpf_text = bpf_text.replace(b'SADDRFILTER', b'') + bpf_text = bpf_text.replace(b'LADDRFILTER', b'') -# filter for source address -if args.daddr: - bpf_text = bpf_text.replace(b'DADDRFILTER', - b"""u32 daddr = 0; - bpf_probe_read_kernel(&daddr, sizeof(daddr), (void *)&inet->inet_daddr); - if (daddr != %d) - return 0;""" % struct.unpack("=I", socket.inet_aton(args.daddr))[0]) +# filter for remote address +if args.raddr: + bpf_text = bpf_text.replace(b'RADDRFILTER', + b"""if (daddr != %d) + return 0;""" % struct.unpack("=I", socket.inet_aton(args.raddr))[0]) else: - bpf_text = bpf_text.replace(b'DADDRFILTER', b'') + bpf_text = bpf_text.replace(b'RADDRFILTER', b'') # show msecs or usecs[default] if args.milliseconds: @@ -135,6 +149,30 @@ bpf_text = bpf_text.replace('FACTOR', '') label = "usecs" +print_header = "srtt" +# show byladdr/byraddr histogram +if args.byladdr: + bpf_text = bpf_text.replace('STORAGE', + 'BPF_HISTOGRAM(hist_srtt, sock_key_t);') + bpf_text = bpf_text.replace('STORE', + b"""sock_key_t key; + key.addr = saddr; + key.slot = bpf_log2l(srtt); + hist_srtt.increment(key);""") + print_header = "Local Address: " +elif args.byraddr: + bpf_text = bpf_text.replace('STORAGE', + 'BPF_HISTOGRAM(hist_srtt, sock_key_t);') + bpf_text = bpf_text.replace('STORE', + b"""sock_key_t key; + key.addr = daddr; + key.slot = bpf_log2l(srtt); + hist_srtt.increment(key);""") + print_header = "Remote Address: " +else: + bpf_text = bpf_text.replace('STORAGE', 'BPF_HISTOGRAM(hist_srtt);') + bpf_text = bpf_text.replace('STORE', 'hist_srtt.increment(bpf_log2l(srtt));') + # debug/dump ebpf enable or not if args.debug or args.ebpf: print(bpf_text) @@ -147,6 +185,12 @@ print("Tracing TCP RTT... Hit Ctrl-C to end.") +def print_section(addr): + if args.byladdr: + return inet_ntop(AF_INET, struct.pack("I", addr)).encode() + elif args.byraddr: + return inet_ntop(AF_INET, struct.pack("I", addr)).encode() + # output exiting = 0 if args.interval else 1 dist = b.get_table("hist_srtt") @@ -162,7 +206,7 @@ if args.timestamp: print("%-8s\n" % strftime("%H:%M:%S"), end="") - dist.print_log2_hist(label, "srtt") + dist.print_log2_hist(label, section_header=print_header, section_print_fn=print_section) dist.clear() if exiting or seconds >= args.duration: diff --git a/tools/tcprtt_example.txt b/tools/tcprtt_example.txt index 9a3d2356b..a5e6ed5c8 100644 --- a/tools/tcprtt_example.txt +++ b/tools/tcprtt_example.txt @@ -40,16 +40,57 @@ also shows unstable TCP RTT. So in this situation, we need to make sure the quality of network is good or not firstly. -Use filter for address and(or) port. Ex, only collect source address 192.168.122.200 -and destination address 192.168.122.100 and destination port 80. +Use filter for address and(or) port. Ex, only collect local address 192.168.122.200 +and remote address 192.168.122.100 and remote port 80. # ./tcprtt -i 1 -d 10 -m -a 192.168.122.200 -A 192.168.122.100 -P 80 +Tracing at server side, show each clients with its own histogram. +For example, run tcprtt on a storage node to show initiators' rtt histogram: +# ./tcprtt -i 1 -m --lport 3260 --byraddr +Tracing TCP RTT... Hit Ctrl-C to end. + +Remote Address: = 10.131.90.16 + msecs : count distribution + 0 -> 1 : 0 | | + 2 -> 3 : 0 | | + 4 -> 7 : 0 | | + 8 -> 15 : 2 |****************************************| + +Remote Address: = 10.131.90.13 + msecs : count distribution + 0 -> 1 : 0 | | + 2 -> 3 : 0 | | + 4 -> 7 : 4 |************************** | + 8 -> 15 : 6 |****************************************| + +Remote Address: = 10.131.89.153 + msecs : count distribution + 0 -> 1 : 120 |****************************************| + 2 -> 3 : 31 |********** | + 4 -> 7 : 32 |********** | + +Remote Address: = 10.131.89.150 + msecs : count distribution + 0 -> 1 : 12 |****************************************| + 2 -> 3 : 12 |****************************************| + 4 -> 7 : 9 |****************************** | + 8 -> 15 : 3 |********** | + +Remote Address: = 10.131.89.148 + msecs : count distribution + 0 -> 1 : 0 | | + 2 -> 3 : 0 | | + 4 -> 7 : 4 |****************************************| + +.... + + Full USAGE: # ./tcprtt -h -usage: tcprtt [-h] [-i INTERVAL] [-d DURATION] [-T] [-m] [-p SPORT] - [-P DPORT] [-a SADDR] [-A DADDR] [-D] +usage: tcprtt.py [-h] [-i INTERVAL] [-d DURATION] [-T] [-m] [-p LPORT] + [-P RPORT] [-a LADDR] [-A RADDR] [-b] [-B] [-D] Summarize TCP RTT as a histogram @@ -61,14 +102,16 @@ optional arguments: total duration of trace, seconds -T, --timestamp include timestamp on output -m, --milliseconds millisecond histogram - -p SPORT, --sport SPORT - source port - -P DPORT, --dport DPORT - destination port - -a SADDR, --saddr SADDR - source address - -A DADDR, --daddr DADDR - destination address + -p LPORT, --lport LPORT + filter for local port + -P RPORT, --rport RPORT + filter for remote port + -a LADDR, --laddr LADDR + filter for local address + -A RADDR, --raddr RADDR + filter for remote address + -b, --byladdr show sockets histogram by local address + -B, --byraddr show sockets histogram by remote address -D, --debug print BPF program before starting (for debugging purposes) @@ -76,8 +119,10 @@ examples: ./tcprtt # summarize TCP RTT ./tcprtt -i 1 -d 10 # print 1 second summaries, 10 times ./tcprtt -m -T # summarize in millisecond, and timestamps - ./tcprtt -p # filter for source port - ./tcprtt -P # filter for destination port - ./tcprtt -a # filter for source address - ./tcprtt -A # filter for destination address + ./tcprtt -p # filter for local port + ./tcprtt -P # filter for remote port + ./tcprtt -a # filter for local address + ./tcprtt -A # filter for remote address + ./tcprtt -b # show sockets histogram by local address + ./tcprtt -B # show sockets histogram by remote address ./tcprtt -D # show debug bpf text From af90bd470a649e1276a7626edb1e5484f0ece8b3 Mon Sep 17 00:00:00 2001 From: Hao <1075808668@qq.com> Date: Tue, 29 Sep 2020 02:01:36 +0800 Subject: [PATCH 252/278] add average function latency (#3061) * add average function latency * update example.txt --- tools/funclatency.py | 19 +++++++++++++++++++ tools/funclatency_example.txt | 31 +++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+) diff --git a/tools/funclatency.py b/tools/funclatency.py index 3f08a7e0d..e77f634b8 100755 --- a/tools/funclatency.py +++ b/tools/funclatency.py @@ -111,6 +111,7 @@ def bail(error): } hist_key_t; BPF_HASH(start, u32); +BPF_ARRAY(avg, u64, 2); STORAGE int trace_func_entry(struct pt_regs *ctx) @@ -141,6 +142,14 @@ def bail(error): } delta = bpf_ktime_get_ns() - *tsp; start.delete(&pid); + + u32 lat = 0; + u32 cnt = 1; + u64 *sum = avg.lookup(&lat); + if (sum) lock_xadd(sum, delta); + u64 *cnts = avg.lookup(&cnt); + if (cnts) lock_xadd(cnts, 1); + FACTOR // store as histogram @@ -257,6 +266,16 @@ def print_section(key): dist.print_log2_hist(label) dist.clear() + total = b['avg'][0].value + counts = b['avg'][1].value + if counts > 0: + if label == 'msecs': + total /= 1000000 + elif label == 'usecs': + total /= 1000 + avg = total/counts + print("\navg = %ld %s, total: %ld %s, count: %ld\n" %(total/counts, label, total, label, counts)) + if exiting: print("Detaching...") exit() diff --git a/tools/funclatency_example.txt b/tools/funclatency_example.txt index d8217a236..e2effbecb 100644 --- a/tools/funclatency_example.txt +++ b/tools/funclatency_example.txt @@ -29,6 +29,9 @@ Tracing do_sys_open... Hit Ctrl-C to end. 524288 -> 1048575 : 0 | | 1048576 -> 2097151 : 0 | | 2097152 -> 4194303 : 1 | | + +avg = 13746 nsecs, total: 6543360 nsecs, count: 476 + Detaching... The output shows a histogram of function latency (call time), measured from when @@ -74,6 +77,9 @@ Tracing 1 function for "pthread:pthread_mutex_lock"... Hit Ctrl-C to end. 262144 -> 524287 : 5 | | 524288 -> 1048575 : 1 | | 1048576 -> 2097151 : 9 | | + +avg = 4317 nsecs, total: 2654426112 nsecs, count: 614752 + Detaching... It seems that most calls to pthread_mutex_lock completed rather quickly (in @@ -130,6 +136,9 @@ Function = insert_result [6556] 32768 -> 65535 : 106 | | 65536 -> 131071 : 5 | | 131072 -> 262143 : 4 | | + +avg = 3404 nsecs, total: 5862276096 nsecs, count: 1721727 + Detaching... From the results, we can see that the is_prime function has something resembling @@ -165,6 +174,9 @@ Tracing vfs_read... Hit Ctrl-C to end. 131072 -> 262143 : 7 | | 262144 -> 524287 : 3 | | 524288 -> 1048575 : 7 | | + +avg = 4229 nsecs, total: 8789145 nsecs, count: 2078 + Detaching... This shows a bimodal distribution. Many vfs_read() calls were faster than 15 @@ -195,6 +207,9 @@ Tracing do_nanosleep... Hit Ctrl-C to end. 8192 -> 16383 : 0 | | 16384 -> 32767 : 0 | | 32768 -> 65535 : 2 | | + +avg = 1510 nsecs, total: 546816 nsecs, count: 326 + Detaching... This looks like it has found threads that are sleeping every 1, 5, and 60 @@ -221,6 +236,8 @@ Tracing vfs_read... Hit Ctrl-C to end. 256 -> 511 : 1 | | 512 -> 1023 : 7 | | +avg = 5 nsecs, total: 8259 nsecs, count: 1521 + 20:10:13 msecs : count distribution 0 -> 1 : 1251 |*************************************+| @@ -235,6 +252,8 @@ Tracing vfs_read... Hit Ctrl-C to end. 512 -> 1023 : 6 | | 1024 -> 2047 : 2 | | +avg = 9 nsecs, total: 11736 nsecs, count: 1282 + 20:10:18 msecs : count distribution 0 -> 1 : 1265 |*************************************+| @@ -249,6 +268,9 @@ Tracing vfs_read... Hit Ctrl-C to end. 512 -> 1023 : 5 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 1 | | + +avg = 8 nsecs, total: 11219 nsecs, count: 1303 + ^C 20:10:20 msecs : count distribution @@ -262,6 +284,9 @@ Tracing vfs_read... Hit Ctrl-C to end. 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 1 | | + +avg = 4 nsecs, total: 1029 nsecs, count: 251 + Detaching... @@ -282,6 +307,9 @@ Tracing vfs_read... Hit Ctrl-C to end. 64 -> 127 : 13 |**************************************| 128 -> 255 : 10 |***************************** | 256 -> 511 : 4 |*********** | + +avg = 153 nsecs, total: 4765 nsecs, count: 31 + Detaching... The distribution between 64 and 511 milliseconds shows keystroke latency. @@ -324,6 +352,9 @@ Function = vfs_rename 8 -> 15 : 0 | | 16 -> 31 : 6 |************* | 32 -> 63 : 18 |****************************************| + +avg = 5087 nsecs, total: 8287001 nsecs, count: 1629 + Detaching... From 788303ead582d5fc70066443b2a94f5c482b53d9 Mon Sep 17 00:00:00 2001 From: Daniel Rank <dwrank@gmail.com> Date: Sun, 27 Sep 2020 16:55:22 -0700 Subject: [PATCH 253/278] slabratetop: Add memcg_cache_params struct def struct memcg_cache_params moved from include/linux/slab.h to mm/slab.h in kernel v5.4, causing a compiler error when including slub_def.h or slab_def.h in slabratetop's bpf program. It has been removed completely from kernel version 5.9. Add an empty memcg_cache_params struct in slabratetop's bpf program so it will compile with kernel versions 5.4 to 5.8. --- tools/slabratetop.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/tools/slabratetop.py b/tools/slabratetop.py index 066f79d6b..182dbd1d5 100755 --- a/tools/slabratetop.py +++ b/tools/slabratetop.py @@ -62,7 +62,13 @@ def signal_ignore(signal, frame): bpf_text = """ #include <uapi/linux/ptrace.h> #include <linux/mm.h> -#include <linux/slab.h> + +// memcg_cache_params is a part of kmem_cache, but is not publicly exposed in +// kernel versions 5.4 to 5.8. Define an empty struct for it here to allow the +// bpf program to compile. It has been completely removed in kernel version +// 5.9, but it does not hurt to have it here for versions 5.4 to 5.8. +struct memcg_cache_params {}; + #ifdef CONFIG_SLUB #include <linux/slub_def.h> #else From 7e3f0c08c7c28757711c0a173b5bd7d9a31cf7ee Mon Sep 17 00:00:00 2001 From: Neil Spring <nspring@gmail.com> Date: Mon, 28 Sep 2020 14:29:24 -0700 Subject: [PATCH 254/278] Fix v6 source (remote) and dest (local) address For v6, tcpdrop.py would report the source and destination addresses incorrectly - tcp_drop() covers the input path, where the source of the received packet is the daddr stored in the socket, while the destination of the received packet is the local address. This commit swaps them to be correct and leaves a comment since it is not obvious. --- tools/tcpdrop.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tools/tcpdrop.py b/tools/tcpdrop.py index aceff8715..f138f131c 100755 --- a/tools/tcpdrop.py +++ b/tools/tcpdrop.py @@ -128,10 +128,12 @@ struct ipv6_data_t data6 = {}; data6.pid = pid; data6.ip = 6; + // The remote address (skc_v6_daddr) was the source bpf_probe_read_kernel(&data6.saddr, sizeof(data6.saddr), - sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); - bpf_probe_read_kernel(&data6.daddr, sizeof(data6.daddr), sk->__sk_common.skc_v6_daddr.in6_u.u6_addr32); + // The local address (skc_v6_rcv_saddr) was the destination + bpf_probe_read_kernel(&data6.daddr, sizeof(data6.daddr), + sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); data6.dport = dport; data6.sport = sport; data6.state = state; From 21b810a3b297411452a41336d239002687e5607f Mon Sep 17 00:00:00 2001 From: Jerome Marchand <jmarchan@redhat.com> Date: Thu, 17 Sep 2020 10:37:02 +0200 Subject: [PATCH 255/278] tools: tcptracer: fix alignement in tcp_ipv6_event_t On IPv6, tcptracer ports always appears as zeros: Tracing TCP established connections. Ctrl-C to end. T PID COMM IP SADDR DADDR SPORT DPORT X 7055 nc 4 127.0.0.1 127.0.0.1 49476 9999 C 7074 nc 4 127.0.0.1 127.0.0.1 49478 9999 X 7074 nc 4 127.0.0.1 127.0.0.1 49478 9999 C 7085 nc 6 [::] [0:0:0:1::] 0 0 X 7085 nc 6 [::] [0:0:0:1::] 0 0 C 7086 nc 6 [::] [0:0:0:1::] 0 0 This seems related to alignment issue wrt to the __int128 type in tcp_ipv6_event_t structure. Moving the u8 field ip to the end of the structure fixes the issue. Fixes #2781 --- tools/tcptracer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/tcptracer.py b/tools/tcptracer.py index 2e486b152..3220105eb 100755 --- a/tools/tcptracer.py +++ b/tools/tcptracer.py @@ -73,12 +73,12 @@ u32 type; u32 pid; char comm[TASK_COMM_LEN]; - u8 ip; unsigned __int128 saddr; unsigned __int128 daddr; u16 sport; u16 dport; u32 netns; + u8 ip; }; BPF_PERF_OUTPUT(tcp_ipv6_event); From 87792ce6b783941ea1d8bcd29812a55520930c95 Mon Sep 17 00:00:00 2001 From: Calvin Kim <calvin@kcalvinalvin.info> Date: Tue, 29 Sep 2020 16:46:53 +0900 Subject: [PATCH 256/278] tools/biolatency: Handle signals from user --- tools/biolatency.py | 35 +++++++++++++++++++++++++---------- 1 file changed, 25 insertions(+), 10 deletions(-) diff --git a/tools/biolatency.py b/tools/biolatency.py index c608dcb5d..532b7ae21 100755 --- a/tools/biolatency.py +++ b/tools/biolatency.py @@ -15,6 +15,7 @@ from bcc import BPF from time import sleep, strftime import argparse +import signal # arguments examples = """examples: @@ -193,15 +194,7 @@ def flags_print(flags): desc = "NoWait-" + desc return desc -# output -exiting = 0 if args.interval else 1 -dist = b.get_table("dist") -while (1): - try: - sleep(int(args.interval)) - except KeyboardInterrupt: - exiting = 1 - +def print_hist(): print() if args.timestamp: print("%-8s\n" % strftime("%H:%M:%S"), end="") @@ -212,6 +205,28 @@ def flags_print(flags): dist.print_log2_hist(label, "disk") dist.clear() +def exit_handler(): + print_hist() + exit() + +def signal_handler(sig, frame): + exit_handler() + +signal.signal(signal.SIGTERM, signal_handler) +signal.signal(signal.SIGINT, signal_handler) +signal.signal(signal.SIGQUIT, signal_handler) + +exiting = 0 if args.interval else 1 +dist = b.get_table("dist") + +while (1): + try: + sleep(int(args.interval)) + except KeyboardInterrupt: + exiting = 1 + + print_hist() + countdown -= 1 if exiting or countdown == 0: - exit() + exit_handler() From 73cf23b84d47d437dbd3a9fc7d1f170a1f082a15 Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Thu, 24 Sep 2020 08:48:15 +0800 Subject: [PATCH 257/278] libbpf-tools: make some minor refactoring Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/biolatency.bpf.c | 50 ++++++++--------- libbpf-tools/biolatency.c | 93 +++++++++++++++++++------------- libbpf-tools/biolatency.h | 7 ++- libbpf-tools/biopattern.bpf.c | 2 +- libbpf-tools/biopattern.c | 65 ++++++++++++---------- libbpf-tools/biopattern.h | 3 ++ libbpf-tools/biosnoop.bpf.c | 42 +++++---------- libbpf-tools/biosnoop.c | 73 ++++++++++++++----------- libbpf-tools/biosnoop.h | 8 ++- libbpf-tools/biostacks.bpf.c | 4 +- libbpf-tools/biostacks.c | 11 ++-- libbpf-tools/biostacks.h | 2 +- libbpf-tools/bitesize.bpf.c | 18 +++++-- libbpf-tools/bitesize.c | 34 +++++++++--- libbpf-tools/bitesize.h | 7 +++ libbpf-tools/cpudist.bpf.c | 4 +- libbpf-tools/cpudist.c | 8 +-- libbpf-tools/drsnoop.bpf.c | 12 +++-- libbpf-tools/drsnoop.c | 4 +- libbpf-tools/drsnoop.h | 2 +- libbpf-tools/drsnoop_example.txt | 2 +- libbpf-tools/execsnoop.bpf.c | 1 + libbpf-tools/filelife.bpf.c | 6 +-- libbpf-tools/filelife.c | 4 +- libbpf-tools/filelife.h | 4 +- libbpf-tools/numamove.c | 7 +-- libbpf-tools/opensnoop.bpf.c | 16 +++--- libbpf-tools/readahead.bpf.c | 12 ++--- libbpf-tools/readahead.c | 8 +-- libbpf-tools/readahead.h | 1 + libbpf-tools/runqslower.bpf.c | 2 +- libbpf-tools/tcpconnect.bpf.c | 8 +-- libbpf-tools/tcpconnlat.bpf.c | 8 +-- libbpf-tools/tcpconnlat.c | 8 +-- libbpf-tools/tcpconnlat.h | 1 + libbpf-tools/trace_helpers.c | 6 ++- libbpf-tools/vfsstat.bpf.c | 10 ++-- libbpf-tools/xfsslower.bpf.c | 18 +++---- libbpf-tools/xfsslower.c | 6 +-- libbpf-tools/xfsslower.h | 4 +- 40 files changed, 319 insertions(+), 262 deletions(-) diff --git a/libbpf-tools/biolatency.bpf.c b/libbpf-tools/biolatency.bpf.c index 57055b58d..808c40800 100644 --- a/libbpf-tools/biolatency.bpf.c +++ b/libbpf-tools/biolatency.bpf.c @@ -7,13 +7,13 @@ #include "biolatency.h" #include "bits.bpf.h" -#define MAX_ENTRIES 10240 +#define MAX_ENTRIES 10240 -const volatile char targ_disk[DISK_NAME_LEN] = {}; const volatile bool targ_per_disk = false; const volatile bool targ_per_flag = false; const volatile bool targ_queued = false; const volatile bool targ_ms = false; +const volatile dev_t targ_dev = -1; struct { __uint(type, BPF_MAP_TYPE_HASH); @@ -33,41 +33,32 @@ struct { __uint(map_flags, BPF_F_NO_PREALLOC); } hists SEC(".maps"); -static __always_inline bool disk_filtered(const char *disk) -{ - int i; - - for (i = 0; targ_disk[i] != '\0' && i < DISK_NAME_LEN; i++) { - if (disk[i] != targ_disk[i]) - return false; - } - return true; -} - static __always_inline int trace_rq_start(struct request *rq) { u64 ts = bpf_ktime_get_ns(); - char disk[DISK_NAME_LEN]; - bpf_probe_read_kernel_str(&disk, sizeof(disk), rq->rq_disk->disk_name); - if (!disk_filtered(disk)) - return 0; + if (targ_dev != -1) { + struct gendisk *disk = BPF_CORE_READ(rq, rq_disk); + dev_t dev; + dev = disk ? MKDEV(BPF_CORE_READ(disk, major), + BPF_CORE_READ(disk, first_minor)) : 0; + if (targ_dev != dev) + return 0; + } bpf_map_update_elem(&start, &rq, &ts, 0); return 0; } SEC("tp_btf/block_rq_insert") -int BPF_PROG(tp_btf__block_rq_insert, struct request_queue *q, - struct request *rq) +int BPF_PROG(block_rq_insert, struct request_queue *q, struct request *rq) { return trace_rq_start(rq); } SEC("tp_btf/block_rq_issue") -int BPF_PROG(tp_btf__block_rq_issue, struct request_queue *q, - struct request *rq) +int BPF_PROG(block_rq_issue, struct request_queue *q, struct request *rq) { if (targ_queued && BPF_CORE_READ(q, elevator)) return 0; @@ -75,8 +66,8 @@ int BPF_PROG(tp_btf__block_rq_issue, struct request_queue *q, } SEC("tp_btf/block_rq_complete") -int BPF_PROG(tp_btf__block_rq_complete, struct request *rq, int error, - unsigned int nr_bytes) +int BPF_PROG(block_rq_complete, struct request *rq, int error, + unsigned int nr_bytes) { u64 slot, *tsp, ts = bpf_ktime_get_ns(); struct hist_key hkey = {}; @@ -90,9 +81,12 @@ int BPF_PROG(tp_btf__block_rq_complete, struct request *rq, int error, if (delta < 0) goto cleanup; - if (targ_per_disk) - bpf_probe_read_kernel_str(&hkey.disk, sizeof(hkey.disk), - rq->rq_disk->disk_name); + if (targ_per_disk) { + struct gendisk *disk = BPF_CORE_READ(rq, rq_disk); + + hkey.dev = disk ? MKDEV(BPF_CORE_READ(disk, major), + BPF_CORE_READ(disk, first_minor)) : 0; + } if (targ_per_flag) hkey.cmd_flags = rq->cmd_flags; @@ -105,9 +99,9 @@ int BPF_PROG(tp_btf__block_rq_complete, struct request *rq, int error, } if (targ_ms) - delta /= 1000000; + delta /= 1000000U; else - delta /= 1000; + delta /= 1000U; slot = log2l(delta); if (slot >= MAX_SLOTS) slot = MAX_SLOTS - 1; diff --git a/libbpf-tools/biolatency.c b/libbpf-tools/biolatency.c index 25e78b921..3bd8672ae 100644 --- a/libbpf-tools/biolatency.c +++ b/libbpf-tools/biolatency.c @@ -20,7 +20,6 @@ static struct env { char *disk; - int disk_len; time_t interval; int times; bool timestamp; @@ -37,23 +36,22 @@ static struct env { static volatile bool exiting; const char *argp_program_version = "biolatency 0.1"; -const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; const char argp_program_doc[] = - "Summarize block device I/O latency as a histogram.\n" - "\n" - "USAGE: biolatency [-h] [-T] [-m] [-Q] [-D] [-F] [-d] [interval] [count]\n" - "\n" - "EXAMPLES:\n" - " biolatency # summarize block I/O latency as a histogram\n" - " biolatency 1 10 # print 1 second summaries, 10 times\n" - " biolatency -mT 1 # 1s summaries, milliseconds, and timestamps\n" - " biolatency -Q # include OS queued time in I/O time\n" - " biolatency -D # show each disk device separately\n" - " biolatency -F # show I/O flags separately\n" - " biolatency -d sdc # Trace sdc only\n"; +"Summarize block device I/O latency as a histogram.\n" +"\n" +"USAGE: biolatency [--help] [-T] [-m] [-Q] [-D] [-F] [-d] [interval] [count]\n" +"\n" +"EXAMPLES:\n" +" biolatency # summarize block I/O latency as a histogram\n" +" biolatency 1 10 # print 1 second summaries, 10 times\n" +" biolatency -mT 1 # 1s summaries, milliseconds, and timestamps\n" +" biolatency -Q # include OS queued time in I/O time\n" +" biolatency -D # show each disk device separately\n" +" biolatency -F # show I/O flags separately\n" +" biolatency -d sdc # Trace sdc only\n"; static const struct argp_option opts[] = { - { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, { "milliseconds", 'm', NULL, 0, "Millisecond histogram" }, { "queued", 'Q', NULL, 0, "Include OS queued time in I/O time" }, @@ -72,9 +70,6 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) case 'v': env.verbose = true; break; - case 'h': - argp_usage(state); - break; case 'm': env.milliseconds = true; break; @@ -87,10 +82,12 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) case 'F': env.per_flag = true; break; + case 'T': + env.timestamp = true; + break; case 'd': env.disk = arg; - env.disk_len = strlen(arg) + 1; - if (env.disk_len > DISK_NAME_LEN) { + if (strlen(arg) + 1 > DISK_NAME_LEN) { fprintf(stderr, "invaild disk name: too long\n"); argp_usage(state); } @@ -183,12 +180,14 @@ static void print_cmd_flags(int cmd_flags) printf("Unknown"); } -static int print_log2_hists(int fd) +static +int print_log2_hists(struct bpf_map *hists, struct partitions *partitions) { struct hist_key lookup_key = { .cmd_flags = -1 }, next_key; - char *units = env.milliseconds ? "msecs" : "usecs"; + const char *units = env.milliseconds ? "msecs" : "usecs"; + const struct partition *partition; + int err, fd = bpf_map__fd(hists); struct hist hist; - int err; while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { err = bpf_map_lookup_elem(fd, &next_key, &hist); @@ -196,9 +195,12 @@ static int print_log2_hists(int fd) fprintf(stderr, "failed to lookup hist: %d\n", err); return -1; } - if (env.per_disk) - printf("\ndisk = %s\t", next_key.disk[0] != '\0' ? - next_key.disk : "unnamed"); + if (env.per_disk) { + partition = partitions__get_by_dev(partitions, + next_key.dev); + printf("\ndisk = %s\t", partition ? partition->name : + "Unknown"); + } if (env.per_flag) print_cmd_flags(next_key.cmd_flags); printf("\n"); @@ -221,6 +223,8 @@ static int print_log2_hists(int fd) int main(int argc, char **argv) { + struct partitions *partitions = NULL; + const struct partition *partition; static const struct argp argp = { .options = opts, .parser = parse_arg, @@ -250,9 +254,21 @@ int main(int argc, char **argv) return 1; } + partitions = partitions__load(); + if (!partitions) { + fprintf(stderr, "failed to load partitions info\n"); + goto cleanup; + } + /* initialize global data (filtering options) */ - if (env.disk) - strncpy((char*)obj->rodata->targ_disk, env.disk, env.disk_len); + if (env.disk) { + partition = partitions__get_by_name(partitions, env.disk); + if (!partition) { + fprintf(stderr, "invaild partition name: not exist\n"); + goto cleanup; + } + obj->rodata->targ_dev = partition->dev; + } obj->rodata->targ_per_disk = env.per_disk; obj->rodata->targ_per_flag = env.per_flag; obj->rodata->targ_ms = env.milliseconds; @@ -265,24 +281,24 @@ int main(int argc, char **argv) } if (env.queued) { - obj->links.tp_btf__block_rq_insert = - bpf_program__attach(obj->progs.tp_btf__block_rq_insert); - err = libbpf_get_error(obj->links.tp_btf__block_rq_insert); + obj->links.block_rq_insert = + bpf_program__attach(obj->progs.block_rq_insert); + err = libbpf_get_error(obj->links.block_rq_insert); if (err) { fprintf(stderr, "failed to attach: %s\n", strerror(-err)); goto cleanup; } } - obj->links.tp_btf__block_rq_issue = - bpf_program__attach(obj->progs.tp_btf__block_rq_issue); - err = libbpf_get_error(obj->links.tp_btf__block_rq_issue); + obj->links.block_rq_issue = + bpf_program__attach(obj->progs.block_rq_issue); + err = libbpf_get_error(obj->links.block_rq_issue); if (err) { fprintf(stderr, "failed to attach: %s\n", strerror(-err)); goto cleanup; } - obj->links.tp_btf__block_rq_complete = - bpf_program__attach(obj->progs.tp_btf__block_rq_complete); - err = libbpf_get_error(obj->links.tp_btf__block_rq_complete); + obj->links.block_rq_complete = + bpf_program__attach(obj->progs.block_rq_complete); + err = libbpf_get_error(obj->links.block_rq_complete); if (err) { fprintf(stderr, "failed to attach: %s\n", strerror(-err)); goto cleanup; @@ -304,7 +320,7 @@ int main(int argc, char **argv) printf("%-8s\n", ts); } - err = print_log2_hists(bpf_map__fd(obj->maps.hists)); + err = print_log2_hists(obj->maps.hists, partitions); if (err) break; @@ -314,6 +330,7 @@ int main(int argc, char **argv) cleanup: biolatency_bpf__destroy(obj); + partitions__free(partitions); return err != 0; } diff --git a/libbpf-tools/biolatency.h b/libbpf-tools/biolatency.h index 83d4386ff..e12515bbb 100644 --- a/libbpf-tools/biolatency.h +++ b/libbpf-tools/biolatency.h @@ -5,9 +5,14 @@ #define DISK_NAME_LEN 32 #define MAX_SLOTS 27 +#define MINORBITS 20 +#define MINORMASK ((1U << MINORBITS) - 1) + +#define MKDEV(ma, mi) (((ma) << MINORBITS) | (mi)) + struct hist_key { - char disk[DISK_NAME_LEN]; __u32 cmd_flags; + __u32 dev; }; struct hist { diff --git a/libbpf-tools/biopattern.bpf.c b/libbpf-tools/biopattern.bpf.c index 673d23578..835936b3f 100644 --- a/libbpf-tools/biopattern.bpf.c +++ b/libbpf-tools/biopattern.bpf.c @@ -17,7 +17,7 @@ struct { } counters SEC(".maps"); SEC("tracepoint/block/block_rq_complete") -int tp__block__block_rq_complete(struct trace_event_raw_block_rq_complete *ctx) +int handle__block_rq_complete(struct trace_event_raw_block_rq_complete *ctx) { sector_t *last_sectorp, sector = ctx->sector; struct counter *counterp, zero = {}; diff --git a/libbpf-tools/biopattern.c b/libbpf-tools/biopattern.c index 851412a07..121e5f8e1 100644 --- a/libbpf-tools/biopattern.c +++ b/libbpf-tools/biopattern.c @@ -14,63 +14,53 @@ #include "biopattern.skel.h" #include "trace_helpers.h" -#define MINORBITS 20 -#define MINORMASK ((1U << MINORBITS) - 1) - -#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS)) -#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK)) -#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi)) - static struct env { + char *disk; time_t interval; bool timestamp; bool verbose; int times; - __u32 dev; } env = { .interval = 99999999, .times = 99999999, - .dev = -1, }; static volatile bool exiting; const char *argp_program_version = "biopattern 0.1"; -const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; const char argp_program_doc[] = "Show block device I/O pattern.\n" "\n" -"USAGE: biopattern [-h] [-T] [-m] [interval] [count]\n" +"USAGE: biopattern [--help] [-T] [-d] [interval] [count]\n" "\n" "EXAMPLES:\n" " biopattern # show block I/O pattern\n" " biopattern 1 10 # print 1 second summaries, 10 times\n" " biopattern -T 1 # 1s summaries with timestamps\n" -" biopattern -d 8:0 # trace 8:0 only\n"; +" biopattern -d sdc # trace sdc only\n"; static const struct argp_option opts[] = { - { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, - { "dev", 'd', "DEV", 0, "Trace this dev only" }, + { "disk", 'd', "DISK", 0, "Trace this disk only" }, { "verbose", 'v', NULL, 0, "Verbose debug output" }, {}, }; static error_t parse_arg(int key, char *arg, struct argp_state *state) { - static __u32 major, minor; static int pos_args; switch (key) { case 'v': env.verbose = true; break; - case 'h': - argp_usage(state); - break; case 'd': - sscanf(arg,"%d:%d", &major, &minor); - env.dev = MKDEV(major, minor); + env.disk = arg; + if (strlen(arg) + 1 > DISK_NAME_LEN) { + fprintf(stderr, "invaild disk name: too long\n"); + argp_usage(state); + } break; case 'T': env.timestamp = true; @@ -115,14 +105,15 @@ static void sig_handler(int sig) exiting = true; } -static int print_map(int fd) +static int print_map(struct bpf_map *counters, struct partitions *partitions) { __u32 total, lookup_key = -1, next_key; + int err, fd = bpf_map__fd(counters); + const struct partition *partition; struct counter counter; struct tm *tm; char ts[32]; time_t t; - int err; while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { err = bpf_map_lookup_elem(fd, &next_key, &counter); @@ -140,8 +131,10 @@ static int print_map(int fd) strftime(ts, sizeof(ts), "%H:%M:%S", tm); printf("%-9s ", ts); } - printf("%3d:%-2d %5ld %5ld %8d %10lld\n", MAJOR(next_key), - MINOR(next_key), counter.random * 100L / total, + partition = partitions__get_by_dev(partitions, next_key); + printf("%-7s %5ld %5ld %8d %10lld\n", + partition ? partition->name : "Unknown", + counter.random * 100L / total, counter.sequential * 100L / total, total, counter.bytes / 1024); } @@ -161,6 +154,8 @@ static int print_map(int fd) int main(int argc, char **argv) { + struct partitions *partitions = NULL; + const struct partition *partition; static const struct argp argp = { .options = opts, .parser = parse_arg, @@ -187,8 +182,21 @@ int main(int argc, char **argv) return 1; } - if (env.dev != -1) - obj->rodata->targ_dev = env.dev; + partitions = partitions__load(); + if (!partitions) { + fprintf(stderr, "failed to load partitions info\n"); + goto cleanup; + } + + /* initialize global data (filtering options) */ + if (env.disk) { + partition = partitions__get_by_name(partitions, env.disk); + if (!partition) { + fprintf(stderr, "invaild partition name: not exist\n"); + goto cleanup; + } + obj->rodata->targ_dev = partition->dev; + } err = biopattern_bpf__load(obj); if (err) { @@ -208,14 +216,14 @@ int main(int argc, char **argv) "end.\n"); if (env.timestamp) printf("%-9s ", "TIME"); - printf("%-6s %5s %5s %8s %10s\n", " DEV", "%RND", "%SEQ", + printf("%-7s %5s %5s %8s %10s\n", "DISK", "%RND", "%SEQ", "COUNT", "KBYTES"); /* main: poll */ while (1) { sleep(env.interval); - err = print_map(bpf_map__fd(obj->maps.counters)); + err = print_map(obj->maps.counters, partitions); if (err) break; @@ -225,6 +233,7 @@ int main(int argc, char **argv) cleanup: biopattern_bpf__destroy(obj); + partitions__free(partitions); return err != 0; } diff --git a/libbpf-tools/biopattern.h b/libbpf-tools/biopattern.h index e23982e25..18860a53e 100644 --- a/libbpf-tools/biopattern.h +++ b/libbpf-tools/biopattern.h @@ -1,6 +1,9 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) #ifndef __BIOPATTERN_H #define __BIOPATTERN_H +#define DISK_NAME_LEN 32 + struct counter { __u64 last_sector; __u64 bytes; diff --git a/libbpf-tools/biosnoop.bpf.c b/libbpf-tools/biosnoop.bpf.c index 31545608c..20f0c7788 100644 --- a/libbpf-tools/biosnoop.bpf.c +++ b/libbpf-tools/biosnoop.bpf.c @@ -6,10 +6,10 @@ #include <bpf/bpf_tracing.h> #include "biosnoop.h" -#define MAX_ENTRIES 10240 +#define MAX_ENTRIES 10240 -const volatile char targ_disk[DISK_NAME_LEN] = {}; const volatile bool targ_queued = false; +const volatile dev_t targ_dev = -1; struct piddata { char comm[TASK_COMM_LEN]; @@ -27,6 +27,7 @@ struct { struct stage { u64 insert; u64 issue; + dev_t dev; }; struct { @@ -55,43 +56,31 @@ int trace_pid(struct request *rq) } SEC("fentry/blk_account_io_start") -int BPF_PROG(fentry__blk_account_io_start, struct request *rq) +int BPF_PROG(blk_account_io_start, struct request *rq) { return trace_pid(rq); } SEC("kprobe/blk_account_io_merge_bio") -int BPF_KPROBE(kprobe__blk_account_io_merge_bio, struct request *rq) +int BPF_KPROBE(blk_account_io_merge_bio, struct request *rq) { return trace_pid(rq); } -static __always_inline bool disk_filtered(const char *disk) -{ - int i; - - for (i = 0; targ_disk[i] != '\0' && i < DISK_NAME_LEN; i++) { - if (disk[i] != targ_disk[i]) - return false; - } - return true; -} - static __always_inline int trace_rq_start(struct request *rq, bool insert) { struct stage *stagep, stage = {}; u64 ts = bpf_ktime_get_ns(); - char disk[DISK_NAME_LEN]; stagep = bpf_map_lookup_elem(&start, &rq); if (!stagep) { - bpf_probe_read_kernel_str(&disk, sizeof(disk), - rq->rq_disk->disk_name); - if (!disk_filtered(disk)) { - bpf_map_delete_elem(&infobyreq, &rq); + struct gendisk *disk = BPF_CORE_READ(rq, rq_disk); + + stage.dev = disk ? MKDEV(BPF_CORE_READ(disk, major), + BPF_CORE_READ(disk, first_minor)) : 0; + if (targ_dev != -1 && targ_dev != stage.dev) return 0; - } stagep = &stage; } if (insert) @@ -104,21 +93,19 @@ int trace_rq_start(struct request *rq, bool insert) } SEC("tp_btf/block_rq_insert") -int BPF_PROG(tp_btf__block_rq_insert, struct request_queue *q, - struct request *rq) +int BPF_PROG(block_rq_insert, struct request_queue *q, struct request *rq) { return trace_rq_start(rq, true); } SEC("tp_btf/block_rq_issue") -int BPF_PROG(tp_btf__block_rq_issue, struct request_queue *q, - struct request *rq) +int BPF_PROG(block_rq_issue, struct request_queue *q, struct request *rq) { return trace_rq_start(rq, false); } SEC("tp_btf/block_rq_complete") -int BPF_PROG(tp_btf__block_rq_complete, struct request *rq, int error, +int BPF_PROG(block_rq_complete, struct request *rq, int error, unsigned int nr_bytes) { u64 slot, ts = bpf_ktime_get_ns(); @@ -152,8 +139,7 @@ int BPF_PROG(tp_btf__block_rq_complete, struct request *rq, int error, event.sector = rq->__sector; event.len = rq->__data_len; event.cmd_flags = rq->cmd_flags; - bpf_probe_read_kernel_str(&event.disk, sizeof(event.disk), - rq->rq_disk->disk_name); + event.dev = stagep->dev; bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, &event, sizeof(event)); diff --git a/libbpf-tools/biosnoop.c b/libbpf-tools/biosnoop.c index 2811c6d4a..3bdfd8c6d 100644 --- a/libbpf-tools/biosnoop.c +++ b/libbpf-tools/biosnoop.c @@ -20,7 +20,6 @@ static struct env { char *disk; - int disk_len; int duration; bool timestamp; bool queued; @@ -30,20 +29,19 @@ static struct env { static volatile __u64 start_ts; const char *argp_program_version = "biosnoop 0.1"; -const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; const char argp_program_doc[] = -"Summarize block device I/O latency as a histogram.\n" +"Trace block I/O.\n" "\n" -"USAGE: biosnoop [-h] [-T] [-Q]\n" +"USAGE: biosnoop [--help] [-d] [-Q]\n" "\n" "EXAMPLES:\n" -" biosnoop # summarize block I/O latency as a histogram\n" +" biosnoop # trace all block I/O\n" " biosnoop -Q # include OS queued time in I/O time\n" " biosnoop 10 # trace for 10 seconds only\n" " biosnoop -d sdc # trace sdc only\n"; static const struct argp_option opts[] = { - { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, { "queued", 'Q', NULL, 0, "Include OS queued time in I/O time" }, { "disk", 'd', "DISK", 0, "Trace this disk only" }, { "verbose", 'v', NULL, 0, "Verbose debug output" }, @@ -58,16 +56,12 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) case 'v': env.verbose = true; break; - case 'h': - argp_usage(state); - break; case 'Q': env.queued = true; break; case 'd': env.disk = arg; - env.disk_len = strlen(arg) + 1; - if (env.disk_len > DISK_NAME_LEN) { + if (strlen(arg) + 1 > DISK_NAME_LEN) { fprintf(stderr, "invaild disk name: too long\n"); argp_usage(state); } @@ -84,6 +78,7 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) fprintf(stderr, "invalid delay (in us): %s\n", arg); argp_usage(state); } + break; default: return ARGP_ERR_UNKNOWN; } @@ -139,17 +134,22 @@ static void blk_fill_rwbs(char *rwbs, unsigned int op) rwbs[i] = '\0'; } +static struct partitions *partitions; + void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) { + const struct partition *partition; const struct event *e = data; char rwbs[RWBS_LEN]; if (!start_ts) start_ts = e->ts; blk_fill_rwbs(rwbs, e->cmd_flags); + partition = partitions__get_by_dev(partitions, e->dev); printf("%-11.6f %-14.14s %-6d %-7s %-4s %-10lld %-7d ", (e->ts - start_ts) / 1000000000.0, - e->comm, e->pid, e->disk, rwbs, e->sector, e->len); + e->comm, e->pid, partition ? partition->name : "Unknown", rwbs, + e->sector, e->len); if (env.queued) printf("%7.3f ", e->qdelta != -1 ? e->qdelta / 1000000.0 : -1); @@ -163,6 +163,7 @@ void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt) int main(int argc, char **argv) { + const struct partition *partition; static const struct argp argp = { .options = opts, .parser = parse_arg, @@ -193,9 +194,20 @@ int main(int argc, char **argv) return 1; } + partitions = partitions__load(); + if (!partitions) { + fprintf(stderr, "failed to load partitions info\n"); + goto cleanup; + } + /* initialize global data (filtering options) */ - if (env.disk) - strncpy((char*)obj->rodata->targ_disk, env.disk, env.disk_len); + if (env.disk) { + partition = partitions__get_by_name(partitions, env.disk); + if (!partition) { + fprintf(stderr, "invaild partition name: not exist\n"); + goto cleanup; + } + } obj->rodata->targ_queued = env.queued; err = biosnoop_bpf__load(obj); @@ -204,9 +216,9 @@ int main(int argc, char **argv) goto cleanup; } - obj->links.fentry__blk_account_io_start = - bpf_program__attach(obj->progs.fentry__blk_account_io_start); - err = libbpf_get_error(obj->links.fentry__blk_account_io_start); + obj->links.blk_account_io_start = + bpf_program__attach(obj->progs.blk_account_io_start); + err = libbpf_get_error(obj->links.blk_account_io_start); if (err) { fprintf(stderr, "failed to attach blk_account_io_start: %s\n", strerror(err)); @@ -218,11 +230,9 @@ int main(int argc, char **argv) goto cleanup; } if (ksyms__get_symbol(ksyms, "blk_account_io_merge_bio")) { - obj->links.kprobe__blk_account_io_merge_bio = - bpf_program__attach(obj-> - progs.kprobe__blk_account_io_merge_bio); - err = libbpf_get_error(obj-> - links.kprobe__blk_account_io_merge_bio); + obj->links.blk_account_io_merge_bio = + bpf_program__attach(obj->progs.blk_account_io_merge_bio); + err = libbpf_get_error(obj->links.blk_account_io_merge_bio); if (err) { fprintf(stderr, "failed to attach " "blk_account_io_merge_bio: %s\n", @@ -231,26 +241,26 @@ int main(int argc, char **argv) } } if (env.queued) { - obj->links.tp_btf__block_rq_insert = - bpf_program__attach(obj->progs.tp_btf__block_rq_insert); - err = libbpf_get_error(obj->links.tp_btf__block_rq_insert); + obj->links.block_rq_insert = + bpf_program__attach(obj->progs.block_rq_insert); + err = libbpf_get_error(obj->links.block_rq_insert); if (err) { fprintf(stderr, "failed to attach block_rq_insert: %s\n", strerror(err)); goto cleanup; } } - obj->links.tp_btf__block_rq_issue = - bpf_program__attach(obj->progs.tp_btf__block_rq_issue); - err = libbpf_get_error(obj->links.tp_btf__block_rq_issue); + obj->links.block_rq_issue = + bpf_program__attach(obj->progs.block_rq_issue); + err = libbpf_get_error(obj->links.block_rq_issue); if (err) { fprintf(stderr, "failed to attach block_rq_issue: %s\n", strerror(err)); goto cleanup; } - obj->links.tp_btf__block_rq_complete = - bpf_program__attach(obj->progs.tp_btf__block_rq_complete); - err = libbpf_get_error(obj->links.tp_btf__block_rq_complete); + obj->links.block_rq_complete = + bpf_program__attach(obj->progs.block_rq_complete); + err = libbpf_get_error(obj->links.block_rq_complete); if (err) { fprintf(stderr, "failed to attach block_rq_complete: %s\n", strerror(err)); @@ -290,6 +300,7 @@ int main(int argc, char **argv) cleanup: biosnoop_bpf__destroy(obj); ksyms__free(ksyms); + partitions__free(partitions); return err != 0; } diff --git a/libbpf-tools/biosnoop.h b/libbpf-tools/biosnoop.h index b7e5d21f4..ffa149c9b 100644 --- a/libbpf-tools/biosnoop.h +++ b/libbpf-tools/biosnoop.h @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) #ifndef __BIOSNOOP_H #define __BIOSNOOP_H @@ -5,6 +6,11 @@ #define TASK_COMM_LEN 16 #define RWBS_LEN 8 +#define MINORBITS 20 +#define MINORMASK ((1U << MINORBITS) - 1) + +#define MKDEV(ma, mi) (((ma) << MINORBITS) | (mi)) + struct event { char comm[TASK_COMM_LEN]; __u64 delta; @@ -14,7 +20,7 @@ struct event { __u32 len; __u32 pid; __u32 cmd_flags; - char disk[DISK_NAME_LEN]; + __u32 dev; }; #endif /* __BIOSNOOP_H */ diff --git a/libbpf-tools/biostacks.bpf.c b/libbpf-tools/biostacks.bpf.c index 30e5c9d43..f3d159abd 100644 --- a/libbpf-tools/biostacks.bpf.c +++ b/libbpf-tools/biostacks.bpf.c @@ -99,9 +99,9 @@ int BPF_PROG(blk_account_io_done, struct request *rq) if (!histp) goto cleanup; if (targ_ms) - delta /= 1000000; + delta /= 1000000U; else - delta /= 1000; + delta /= 1000U; slot = log2l(delta); if (slot >= MAX_SLOTS) slot = MAX_SLOTS - 1; diff --git a/libbpf-tools/biostacks.c b/libbpf-tools/biostacks.c index ed788944c..3d25d2c2a 100644 --- a/libbpf-tools/biostacks.c +++ b/libbpf-tools/biostacks.c @@ -23,11 +23,11 @@ static struct env { }; const char *argp_program_version = "biostacks 0.1"; -const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; const char argp_program_doc[] = "Tracing block I/O with init stacks.\n" "\n" -"USAGE: biostacks [--help] [-d disk] [duration]\n" +"USAGE: biostacks [--help] [-d disk] [-m] [duration]\n" "\n" "EXAMPLES:\n" " biostacks # trace block I/O with init stacks.\n" @@ -49,9 +49,6 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) case 'v': env.verbose = true; break; - case 'h': - argp_usage(state); - break; case 'd': env.disk = arg; if (strlen(arg) + 1 > DISK_NAME_LEN) { @@ -96,7 +93,7 @@ static void sig_handler(int sig) static void print_map(struct ksyms *ksyms, struct partitions *partitions, int fd) { - char *units = env.milliseconds ? "msecs" : "usecs"; + const char *units = env.milliseconds ? "msecs" : "usecs"; struct rqinfo lookup_key = {}, next_key; const struct partition *partition; const struct ksym *ksym; @@ -168,7 +165,7 @@ int main(int argc, char **argv) if (env.disk) { partition = partitions__get_by_name(partitions, env.disk); if (!partition) { - fprintf(stderr, "invaild partition name: not exit\n"); + fprintf(stderr, "invaild partition name: not exist\n"); goto cleanup; } obj->rodata->targ_dev = partition->dev; diff --git a/libbpf-tools/biostacks.h b/libbpf-tools/biostacks.h index fdb5999ef..9917fb1d9 100644 --- a/libbpf-tools/biostacks.h +++ b/libbpf-tools/biostacks.h @@ -10,7 +10,7 @@ #define MINORBITS 20 #define MINORMASK ((1U << MINORBITS) - 1) -#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi)) +#define MKDEV(ma, mi) (((ma) << MINORBITS) | (mi)) struct rqinfo { __u32 pid; diff --git a/libbpf-tools/bitesize.bpf.c b/libbpf-tools/bitesize.bpf.c index 2c0c59dc0..faa69acc5 100644 --- a/libbpf-tools/bitesize.bpf.c +++ b/libbpf-tools/bitesize.bpf.c @@ -3,10 +3,12 @@ #include "vmlinux.h" #include <bpf/bpf_helpers.h> #include <bpf/bpf_tracing.h> +#include <bpf/bpf_core_read.h> #include "bitesize.h" #include "bits.bpf.h" const volatile char targ_comm[TASK_COMM_LEN] = {}; +const volatile dev_t targ_dev = -1; struct { __uint(type, BPF_MAP_TYPE_HASH); @@ -18,7 +20,7 @@ struct { static struct hist initial_hist; -static __always_inline bool comm_filtered(const char *comm) +static __always_inline bool comm_allowed(const char *comm) { int i; @@ -30,15 +32,23 @@ static __always_inline bool comm_filtered(const char *comm) } SEC("tp_btf/block_rq_issue") -int BPF_PROG(tp_btf__block_rq_issue, struct request_queue *q, - struct request *rq) +int BPF_PROG(block_rq_issue, struct request_queue *q, struct request *rq) { struct hist_key hkey; struct hist *histp; u64 slot; + if (targ_dev != -1) { + struct gendisk *disk = BPF_CORE_READ(rq, rq_disk); + dev_t dev; + + dev = disk ? MKDEV(BPF_CORE_READ(disk, major), + BPF_CORE_READ(disk, first_minor)) : 0; + if (targ_dev != dev) + return 0; + } bpf_get_current_comm(&hkey.comm, sizeof(hkey.comm)); - if (!comm_filtered(hkey.comm)) + if (!comm_allowed(hkey.comm)) return 0; histp = bpf_map_lookup_elem(&hists, &hkey); diff --git a/libbpf-tools/bitesize.c b/libbpf-tools/bitesize.c index 16657d62b..967bf80a3 100644 --- a/libbpf-tools/bitesize.c +++ b/libbpf-tools/bitesize.c @@ -15,6 +15,7 @@ #include "trace_helpers.h" static struct env { + char *disk; char *comm; int comm_len; time_t interval; @@ -29,11 +30,11 @@ static struct env { static volatile bool exiting; const char *argp_program_version = "bitesize 0.1"; -const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; const char argp_program_doc[] = "Summarize block device I/O size as a histogram.\n" "\n" -"USAGE: bitesize [-h] [-T] [-m] [interval] [count]\n" +"USAGE: bitesize [--help] [-T] [-c] [-d] [interval] [count]\n" "\n" "EXAMPLES:\n" " bitesize # summarize block I/O latency as a histogram\n" @@ -42,9 +43,9 @@ const char argp_program_doc[] = " bitesize -c fio # trace fio only\n"; static const struct argp_option opts[] = { - { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, { "comm", 'c', "COMM", 0, "Trace this comm only" }, + { "disk", 'd', "DISK", 0, "Trace this disk only" }, { "verbose", 'v', NULL, 0, "Verbose debug output" }, {}, }; @@ -57,14 +58,18 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) case 'v': env.verbose = true; break; - case 'h': - argp_usage(state); - break; case 'c': env.comm = arg; len = strlen(arg) + 1; env.comm_len = len > TASK_COMM_LEN ? TASK_COMM_LEN : len; break; + case 'd': + env.disk = arg; + if (strlen(arg) + 1 > DISK_NAME_LEN) { + fprintf(stderr, "invaild disk name: too long\n"); + argp_usage(state); + } + break; case 'T': env.timestamp = true; break; @@ -141,6 +146,8 @@ static int print_log2_hists(int fd) int main(int argc, char **argv) { + struct partitions *partitions = NULL; + const struct partition *partition; static const struct argp argp = { .options = opts, .parser = parse_arg, @@ -170,9 +177,23 @@ int main(int argc, char **argv) return 1; } + partitions = partitions__load(); + if (!partitions) { + fprintf(stderr, "failed to load partitions info\n"); + goto cleanup; + } + /* initialize global data (filtering options) */ if (env.comm) strncpy((char*)obj->rodata->targ_comm, env.comm, env.comm_len); + if (env.disk) { + partition = partitions__get_by_name(partitions, env.disk); + if (!partition) { + fprintf(stderr, "invaild partition name: not exist\n"); + goto cleanup; + } + obj->rodata->targ_dev = partition->dev; + } err = bitesize_bpf__load(obj); if (err) { @@ -214,6 +235,7 @@ int main(int argc, char **argv) cleanup: bitesize_bpf__destroy(obj); + partitions__free(partitions); return err != 0; } diff --git a/libbpf-tools/bitesize.h b/libbpf-tools/bitesize.h index 9ebbb7009..2b4543e41 100644 --- a/libbpf-tools/bitesize.h +++ b/libbpf-tools/bitesize.h @@ -1,9 +1,16 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) #ifndef __BITESIZE_H #define __BITESIZE_H #define TASK_COMM_LEN 16 +#define DISK_NAME_LEN 32 #define MAX_SLOTS 20 +#define MINORBITS 20 +#define MINORMASK ((1U << MINORBITS) - 1) + +#define MKDEV(ma, mi) (((ma) << MINORBITS) | (mi)) + struct hist_key { char comm[TASK_COMM_LEN]; }; diff --git a/libbpf-tools/cpudist.bpf.c b/libbpf-tools/cpudist.bpf.c index 380c3461e..af0cc81f6 100644 --- a/libbpf-tools/cpudist.bpf.c +++ b/libbpf-tools/cpudist.bpf.c @@ -7,7 +7,7 @@ #include "cpudist.h" #include "bits.bpf.h" -#define TASK_RUNNING 0 +#define TASK_RUNNING 0 const volatile bool targ_per_process = false; const volatile bool targ_per_thread = false; @@ -76,7 +76,7 @@ static __always_inline void update_hist(struct task_struct *task, } SEC("kprobe/finish_task_switch") -int BPF_KPROBE(kprobe__finish_task_switch, struct task_struct *prev) +int BPF_KPROBE(finish_task_switch, struct task_struct *prev) { u32 prev_tgid = BPF_CORE_READ(prev, tgid); u32 prev_pid = BPF_CORE_READ(prev, pid); diff --git a/libbpf-tools/cpudist.c b/libbpf-tools/cpudist.c index fc7d20a24..2315fb55b 100644 --- a/libbpf-tools/cpudist.c +++ b/libbpf-tools/cpudist.c @@ -33,11 +33,11 @@ static struct env { static volatile bool exiting; const char *argp_program_version = "cpudist 0.1"; -const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; const char argp_program_doc[] = "Summarize on-CPU time per task as a histogram.\n" "\n" -"USAGE: cpudist [-h] [-O] [-T] [-m] [-P] [-L] [-p PID] [interval] [count]\n" +"USAGE: cpudist [--help] [-O] [-T] [-m] [-P] [-L] [-p PID] [interval] [count]\n" "\n" "EXAMPLES:\n" " cpudist # summarize on-CPU time as a histogram" @@ -48,7 +48,6 @@ const char argp_program_doc[] = " cpudist -p 185 # trace PID 185 only"; static const struct argp_option opts[] = { - { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, { "offcpu", 'O', NULL, 0, "Measure off-CPU time" }, { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, { "milliseconds", 'm', NULL, 0, "Millisecond histogram" }, @@ -67,9 +66,6 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) case 'v': env.verbose = true; break; - case 'h': - argp_usage(state); - break; case 'm': env.milliseconds = true; break; diff --git a/libbpf-tools/drsnoop.bpf.c b/libbpf-tools/drsnoop.bpf.c index 91072cbb3..5f9ff8490 100644 --- a/libbpf-tools/drsnoop.bpf.c +++ b/libbpf-tools/drsnoop.bpf.c @@ -2,6 +2,7 @@ // Copyright (c) 2020 Wenbo Zhang #include "vmlinux.h" #include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> #include "drsnoop.h" const volatile pid_t targ_pid = 0; @@ -27,7 +28,7 @@ struct { } events SEC(".maps"); SEC("tp_btf/mm_vmscan_direct_reclaim_begin") -int handle__mm_vmscan_direct_reclaim_begin(u64 *ctx) +int BPF_PROG(direct_reclaim_begin) { u64 *vm_zone_stat_kaddrp = (u64*)vm_zone_stat_kaddr; u64 id = bpf_get_current_pid_tgid(); @@ -52,16 +53,14 @@ int handle__mm_vmscan_direct_reclaim_begin(u64 *ctx) } SEC("tp_btf/mm_vmscan_direct_reclaim_end") -int handle__mm_vmscan_direct_reclaim_end(u64 *ctx) +int BPF_PROG(direct_reclaim_end, unsigned long nr_reclaimed) { u64 id = bpf_get_current_pid_tgid(); - /* TP_PROTO(unsigned long nr_reclaimed) */ - u64 nr_reclaimed = ctx[0]; struct piddata *piddatap; struct event event = {}; u32 tgid = id >> 32; u32 pid = id; - u64 delta_ns; + s64 delta_ns; if (targ_tgid && targ_tgid != tgid) return 0; @@ -74,6 +73,8 @@ int handle__mm_vmscan_direct_reclaim_end(u64 *ctx) return 0; /* missed entry */ delta_ns = bpf_ktime_get_ns() - piddatap->ts; + if (delta_ns < 0) + goto cleanup; event.pid = pid; event.nr_reclaimed = nr_reclaimed; @@ -85,6 +86,7 @@ int handle__mm_vmscan_direct_reclaim_end(u64 *ctx) bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, &event, sizeof(event)); +cleanup: bpf_map_delete_elem(&start, &pid); return 0; } diff --git a/libbpf-tools/drsnoop.c b/libbpf-tools/drsnoop.c index 0275d02ab..68903a7f2 100644 --- a/libbpf-tools/drsnoop.c +++ b/libbpf-tools/drsnoop.c @@ -27,7 +27,7 @@ static struct env { } env = { }; const char *argp_program_version = "drsnoop 0.1"; -const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; const char argp_program_doc[] = "Trace direct reclaim latency.\n" "\n" @@ -115,7 +115,7 @@ void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) tm = localtime(&t); strftime(ts, sizeof(ts), "%H:%M:%S", tm); printf("%-8s %-16s %-6d %8.3f %5lld", - ts, e->task, e->pid, (double)e->delta_ns / 1000000, + ts, e->task, e->pid, e->delta_ns / 1000000.0, e->nr_reclaimed); if (env.extended) printf(" %8llu", e->nr_free_pages * page_size / 1024); diff --git a/libbpf-tools/drsnoop.h b/libbpf-tools/drsnoop.h index bdd5b7d5d..28826d262 100644 --- a/libbpf-tools/drsnoop.h +++ b/libbpf-tools/drsnoop.h @@ -2,7 +2,7 @@ #ifndef __DRSNOOP_H #define __DRSNOOP_H -#define TASK_COMM_LEN 16 +#define TASK_COMM_LEN 16 struct event { char task[TASK_COMM_LEN]; diff --git a/libbpf-tools/drsnoop_example.txt b/libbpf-tools/drsnoop_example.txt index ae96c31ef..44c014cb4 100644 --- a/libbpf-tools/drsnoop_example.txt +++ b/libbpf-tools/drsnoop_example.txt @@ -68,4 +68,4 @@ EXAMPLES: --usage Give a short usage message -V, --version Print program version -Report bugs to <ethercflow@gmail.com>. +Report bugs to <bpf@vger.kernel.org>. diff --git a/libbpf-tools/execsnoop.bpf.c b/libbpf-tools/execsnoop.bpf.c index 40a1bfc30..e6bc7c06a 100644 --- a/libbpf-tools/execsnoop.bpf.c +++ b/libbpf-tools/execsnoop.bpf.c @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) #include "vmlinux.h" #include <bpf/bpf_helpers.h> #include <bpf/bpf_core_read.h> diff --git a/libbpf-tools/filelife.bpf.c b/libbpf-tools/filelife.bpf.c index 657217200..b066565ff 100644 --- a/libbpf-tools/filelife.bpf.c +++ b/libbpf-tools/filelife.bpf.c @@ -37,20 +37,20 @@ probe_create(struct inode *dir, struct dentry *dentry) } SEC("kprobe/vfs_create") -int BPF_KPROBE(kprobe__vfs_create, struct inode *dir, struct dentry *dentry) +int BPF_KPROBE(vfs_create, struct inode *dir, struct dentry *dentry) { return probe_create(dir, dentry); } SEC("kprobe/security_inode_create") -int BPF_KPROBE(kprobe__security_inode_create, struct inode *dir, +int BPF_KPROBE(security_inode_create, struct inode *dir, struct dentry *dentry) { return probe_create(dir, dentry); } SEC("kprobe/vfs_unlink") -int BPF_KPROBE(kprobe__vfs_unlink, struct inode *dir, struct dentry *dentry) +int BPF_KPROBE(vfs_unlink, struct inode *dir, struct dentry *dentry) { u64 id = bpf_get_current_pid_tgid(); struct event event = {}; diff --git a/libbpf-tools/filelife.c b/libbpf-tools/filelife.c index 2dc64c20b..22028412a 100644 --- a/libbpf-tools/filelife.c +++ b/libbpf-tools/filelife.c @@ -24,11 +24,11 @@ static struct env { } env = { }; const char *argp_program_version = "filelife 0.1"; -const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; const char argp_program_doc[] = "Trace the lifespan of short-lived files.\n" "\n" -"USAGE: filelife [-p PID]\n" +"USAGE: filelife [--help] [-p PID]\n" "\n" "EXAMPLES:\n" " filelife # trace all events\n" diff --git a/libbpf-tools/filelife.h b/libbpf-tools/filelife.h index 13b11418d..d1040cc54 100644 --- a/libbpf-tools/filelife.h +++ b/libbpf-tools/filelife.h @@ -2,8 +2,8 @@ #ifndef __FILELIFE_H #define __FILELIFE_H -#define DNAME_INLINE_LEN 32 -#define TASK_COMM_LEN 16 +#define DNAME_INLINE_LEN 32 +#define TASK_COMM_LEN 16 struct event { char file[DNAME_INLINE_LEN]; diff --git a/libbpf-tools/numamove.c b/libbpf-tools/numamove.c index e03f91c92..fa4fa1355 100644 --- a/libbpf-tools/numamove.c +++ b/libbpf-tools/numamove.c @@ -20,7 +20,7 @@ static struct env { static volatile bool exiting; const char *argp_program_version = "numamove 0.1"; -const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; const char argp_program_doc[] = "Show page migrations of type NUMA misplaced per second.\n" "\n" @@ -30,7 +30,7 @@ const char argp_program_doc[] = " numamove # Show page migrations' count and latency"; static const struct argp_option opts[] = { - { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, {}, }; @@ -40,9 +40,6 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) case 'v': env.verbose = true; break; - case 'h': - argp_usage(state); - break; default: return ARGP_ERR_UNKNOWN; } diff --git a/libbpf-tools/opensnoop.bpf.c b/libbpf-tools/opensnoop.bpf.c index 4689d403a..eb8516d97 100644 --- a/libbpf-tools/opensnoop.bpf.c +++ b/libbpf-tools/opensnoop.bpf.c @@ -5,7 +5,7 @@ #include <bpf/bpf_helpers.h> #include "opensnoop.h" -#define TASK_RUNNING 0 +#define TASK_RUNNING 0 const volatile __u64 min_us = 0; const volatile pid_t targ_pid = 0; @@ -31,22 +31,22 @@ static __always_inline bool valid_uid(uid_t uid) { } static __always_inline -int trace_filtered(u32 tgid, u32 pid) +bool trace_allowed(u32 tgid, u32 pid) { u32 uid; /* filters */ if (targ_tgid && targ_tgid != tgid) - return 1; + return false; if (targ_pid && targ_pid != pid) - return 1; + return false; if (valid_uid(targ_uid)) { uid = (u32)bpf_get_current_uid_gid(); if (targ_uid != uid) { - return 1; + return false; } } - return 0; + return true; } SEC("tracepoint/syscalls/sys_enter_open") @@ -58,7 +58,7 @@ int tracepoint__syscalls__sys_enter_open(struct trace_event_raw_sys_enter* ctx) u32 pid = id; /* store arg info for later lookup */ - if (!trace_filtered(tgid, pid)) { + if (trace_allowed(tgid, pid)) { struct args_t args = {}; args.fname = (const char *)ctx->args[0]; args.flags = (int)ctx->args[1]; @@ -76,7 +76,7 @@ int tracepoint__syscalls__sys_enter_openat(struct trace_event_raw_sys_enter* ctx u32 pid = id; /* store arg info for later lookup */ - if (!trace_filtered(tgid, pid)) { + if (trace_allowed(tgid, pid)) { struct args_t args = {}; args.fname = (const char *)ctx->args[1]; args.flags = (int)ctx->args[2]; diff --git a/libbpf-tools/readahead.bpf.c b/libbpf-tools/readahead.bpf.c index 5cd27a01d..4f4e5eee9 100644 --- a/libbpf-tools/readahead.bpf.c +++ b/libbpf-tools/readahead.bpf.c @@ -6,7 +6,7 @@ #include "readahead.h" #include "bits.bpf.h" -#define MAX_ENTRIES 10240 +#define MAX_ENTRIES 10240 struct { __uint(type, BPF_MAP_TYPE_HASH); @@ -27,7 +27,7 @@ struct { static struct hist hist; SEC("fentry/__do_page_cache_readahead") -int BPF_PROG(fentry__do_page_cache_readahead) +int BPF_PROG(do_page_cache_readahead) { u32 pid = bpf_get_current_pid_tgid(); u64 one = 1; @@ -37,7 +37,7 @@ int BPF_PROG(fentry__do_page_cache_readahead) } SEC("fexit/__page_cache_alloc") -int BPF_PROG(fexit__page_cache_alloc, gfp_t gfp, struct page *ret) +int BPF_PROG(page_cache_alloc_ret, gfp_t gfp, struct page *ret) { u32 pid = bpf_get_current_pid_tgid(); u64 ts; @@ -54,7 +54,7 @@ int BPF_PROG(fexit__page_cache_alloc, gfp_t gfp, struct page *ret) } SEC("fexit/__do_page_cache_readahead") -int BPF_PROG(fexit__do_page_cache_readahead) +int BPF_PROG(do_page_cache_readahead_ret) { u32 pid = bpf_get_current_pid_tgid(); @@ -63,7 +63,7 @@ int BPF_PROG(fexit__do_page_cache_readahead) } SEC("fentry/mark_page_accessed") -int BPF_PROG(fentry__mark_page_accessed, struct page *page) +int BPF_PROG(mark_page_accessed, struct page *page) { u64 *tsp, slot, ts = bpf_ktime_get_ns(); s64 delta; @@ -74,7 +74,7 @@ int BPF_PROG(fentry__mark_page_accessed, struct page *page) delta = (s64)(ts - *tsp); if (delta < 0) goto update_and_cleanup; - slot = log2l(delta / 1000000); + slot = log2l(delta / 1000000U); if (slot >= MAX_SLOTS) slot = MAX_SLOTS - 1; __sync_fetch_and_add(&hist.slots[slot], 1); diff --git a/libbpf-tools/readahead.c b/libbpf-tools/readahead.c index 547f2bd0e..f2460af8b 100644 --- a/libbpf-tools/readahead.c +++ b/libbpf-tools/readahead.c @@ -23,18 +23,17 @@ static struct env { static volatile bool exiting; const char *argp_program_version = "readahead 0.1"; -const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; const char argp_program_doc[] = "Show fs automatic read-ahead usage.\n" "\n" -"USAGE: readahead [-d DURATION]\n" +"USAGE: readahead [--help] [-d DURATION]\n" "\n" "EXAMPLES:\n" " readahead # summarize on-CPU time as a histogram" " readahead -d 10 # trace for 10 seconds only\n"; static const struct argp_option opts[] = { - { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, { "duration", 'd', "DURATION", 0, "Duration to trace"}, { "verbose", 'v', NULL, 0, "Verbose debug output" }, {}, @@ -54,9 +53,6 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) argp_usage(state); } break; - case 'h': - argp_usage(state); - break; default: return ARGP_ERR_UNKNOWN; } diff --git a/libbpf-tools/readahead.h b/libbpf-tools/readahead.h index a41188abb..15dc02647 100644 --- a/libbpf-tools/readahead.h +++ b/libbpf-tools/readahead.h @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) #ifndef __READAHEAD_H #define __READAHEAD_H diff --git a/libbpf-tools/runqslower.bpf.c b/libbpf-tools/runqslower.bpf.c index 94b215b8a..12e26888f 100644 --- a/libbpf-tools/runqslower.bpf.c +++ b/libbpf-tools/runqslower.bpf.c @@ -4,7 +4,7 @@ #include <bpf/bpf_helpers.h> #include "runqslower.h" -#define TASK_RUNNING 0 +#define TASK_RUNNING 0 const volatile __u64 min_us = 0; const volatile pid_t targ_pid = 0; diff --git a/libbpf-tools/tcpconnect.bpf.c b/libbpf-tools/tcpconnect.bpf.c index 525d62c0d..9fbe6f09c 100644 --- a/libbpf-tools/tcpconnect.bpf.c +++ b/libbpf-tools/tcpconnect.bpf.c @@ -192,25 +192,25 @@ exit_tcp_connect(struct pt_regs *ctx, int ret, int ip_ver) } SEC("kprobe/tcp_v4_connect") -int BPF_KPROBE(kprobe__tcp_v4_connect, struct sock *sk) +int BPF_KPROBE(tcp_v4_connect, struct sock *sk) { return enter_tcp_connect(ctx, sk); } SEC("kretprobe/tcp_v4_connect") -int BPF_KRETPROBE(kretprobe__tcp_v4_connect, int ret) +int BPF_KRETPROBE(tcp_v4_connect_ret, int ret) { return exit_tcp_connect(ctx, ret, 4); } SEC("kprobe/tcp_v6_connect") -int BPF_KPROBE(kprobe__tcp_v6_connect, struct sock *sk) +int BPF_KPROBE(tcp_v6_connect, struct sock *sk) { return enter_tcp_connect(ctx, sk); } SEC("kretprobe/tcp_v6_connect") -int BPF_KRETPROBE(kretprobe__tcp_v6_connect, int ret) +int BPF_KRETPROBE(tcp_v6_connect_ret, int ret) { return exit_tcp_connect(ctx, ret, 6); } diff --git a/libbpf-tools/tcpconnlat.bpf.c b/libbpf-tools/tcpconnlat.bpf.c index b6c36112f..b0995a4bb 100644 --- a/libbpf-tools/tcpconnlat.bpf.c +++ b/libbpf-tools/tcpconnlat.bpf.c @@ -47,19 +47,19 @@ static __always_inline int trace_connect(struct sock *sk) } SEC("fentry/tcp_v4_connect") -int BPF_PROG(fentry__tcp_v4_connect, struct sock *sk) +int BPF_PROG(tcp_v4_connect, struct sock *sk) { return trace_connect(sk); } SEC("kprobe/tcp_v6_connect") -int BPF_KPROBE(kprobe__tcp_v6_connect, struct sock *sk) +int BPF_KPROBE(tcp_v6_connect, struct sock *sk) { return trace_connect(sk); } SEC("fentry/tcp_rcv_state_process") -int BPF_PROG(fentry__tcp_rcv_state_process, struct sock *sk) +int BPF_PROG(tcp_rcv_state_process, struct sock *sk) { struct piddata *piddatap; struct event event = {}; @@ -78,7 +78,7 @@ int BPF_PROG(fentry__tcp_rcv_state_process, struct sock *sk) if (delta < 0) goto cleanup; - event.delta_us = delta / 1000; + event.delta_us = delta / 1000U; if (targ_min_us && event.delta_us < targ_min_us) goto cleanup; __builtin_memcpy(&event.comm, piddatap->comm, diff --git a/libbpf-tools/tcpconnlat.c b/libbpf-tools/tcpconnlat.c index 46b6a60cd..b53bf1e35 100644 --- a/libbpf-tools/tcpconnlat.c +++ b/libbpf-tools/tcpconnlat.c @@ -25,11 +25,11 @@ static struct env { } env; const char *argp_program_version = "tcpconnlat 0.1"; -const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; const char argp_program_doc[] = "\nTrace TCP connects and show connection latency.\n" "\n" -"USAGE: tcpconnlat [-h] [-t] [-p PID]\n" +"USAGE: tcpconnlat [--help] [-t] [-p PID]\n" "\n" "EXAMPLES:\n" " tcpconnlat # summarize on-CPU time as a histogram" @@ -39,7 +39,6 @@ const char argp_program_doc[] = " tcpconnlat -p 185 # trace PID 185 only"; static const struct argp_option opts[] = { - { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, { "timestamp", 't', NULL, 0, "Include timestamp on output" }, { "pid", 'p', "PID", 0, "Trace this PID only" }, { "verbose", 'v', NULL, 0, "Verbose debug output" }, @@ -54,9 +53,6 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) case 'v': env.verbose = true; break; - case 'h': - argp_usage(state); - break; case 'p': errno = 0; env.pid = strtol(arg, NULL, 10); diff --git a/libbpf-tools/tcpconnlat.h b/libbpf-tools/tcpconnlat.h index 63d09476b..208a71d12 100644 --- a/libbpf-tools/tcpconnlat.h +++ b/libbpf-tools/tcpconnlat.h @@ -1,3 +1,4 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ #ifndef __TCPCONNLAT_H #define __TCPCONNLAT_H diff --git a/libbpf-tools/trace_helpers.c b/libbpf-tools/trace_helpers.c index d4ae3aede..ede618f99 100644 --- a/libbpf-tools/trace_helpers.c +++ b/libbpf-tools/trace_helpers.c @@ -1,4 +1,8 @@ /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +// Copyright (c) 2020 Wenbo Zhang +// +// Based on ksyms improvements from Andrii Nakryiko, add more helpers. +// 28-Feb-2020 Wenbo Zhang Created this. #include <stdio.h> #include <stdlib.h> #include <string.h> @@ -18,7 +22,7 @@ #define MINORBITS 20 #define MINORMASK ((1U << MINORBITS) - 1) -#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi)) +#define MKDEV(ma, mi) (((ma) << MINORBITS) | (mi)) struct ksyms { struct ksym *syms; diff --git a/libbpf-tools/vfsstat.bpf.c b/libbpf-tools/vfsstat.bpf.c index 1ffacebaa..414b8909f 100644 --- a/libbpf-tools/vfsstat.bpf.c +++ b/libbpf-tools/vfsstat.bpf.c @@ -16,31 +16,31 @@ static __always_inline int inc_stats(int key) } SEC("kprobe/vfs_read") -int BPF_KPROBE(kprobe__vfs_read) +int BPF_KPROBE(vfs_read) { return inc_stats(S_READ); } SEC("kprobe/vfs_write") -int BPF_KPROBE(kprobe__vfs_write) +int BPF_KPROBE(vfs_write) { return inc_stats(S_WRITE); } SEC("kprobe/vfs_fsync") -int BPF_KPROBE(kprobe__vfs_fsync) +int BPF_KPROBE(vfs_fsync) { return inc_stats(S_FSYNC); } SEC("kprobe/vfs_open") -int BPF_KPROBE(kprobe__vfs_open) +int BPF_KPROBE(vfs_open) { return inc_stats(S_OPEN); } SEC("kprobe/vfs_create") -int BPF_KPROBE(kprobe__vfs_create) +int BPF_KPROBE(vfs_create) { return inc_stats(S_CREATE); } diff --git a/libbpf-tools/xfsslower.bpf.c b/libbpf-tools/xfsslower.bpf.c index 9c0bc105e..65644bc36 100644 --- a/libbpf-tools/xfsslower.bpf.c +++ b/libbpf-tools/xfsslower.bpf.c @@ -6,7 +6,7 @@ #include <bpf/bpf_tracing.h> #include "xfsslower.h" -#define NULL 0 +#define NULL 0 const volatile pid_t targ_tgid = 0; const volatile __u64 min_lat = 0; @@ -53,7 +53,7 @@ probe_entry(struct file *fp, loff_t s, loff_t e) } SEC("kprobe/xfs_file_read_iter") -int BPF_KPROBE(kprobe__xfs_file_read_iter, struct kiocb *iocb) +int BPF_KPROBE(xfs_file_read_iter, struct kiocb *iocb) { struct file *fp = BPF_CORE_READ(iocb, ki_filp); loff_t start = BPF_CORE_READ(iocb, ki_pos); @@ -62,7 +62,7 @@ int BPF_KPROBE(kprobe__xfs_file_read_iter, struct kiocb *iocb) } SEC("kprobe/xfs_file_write_iter") -int BPF_KPROBE(kprobe__xfs_file_write_iter, struct kiocb *iocb) +int BPF_KPROBE(xfs_file_write_iter, struct kiocb *iocb) { struct file *fp = BPF_CORE_READ(iocb, ki_filp); loff_t start = BPF_CORE_READ(iocb, ki_pos); @@ -71,13 +71,13 @@ int BPF_KPROBE(kprobe__xfs_file_write_iter, struct kiocb *iocb) } SEC("kprobe/xfs_file_open") -int BPF_KPROBE(kprobe__xfs_file_open, struct inode *inode, struct file *file) +int BPF_KPROBE(xfs_file_open, struct inode *inode, struct file *file) { return probe_entry(file, 0, 0); } SEC("kprobe/xfs_file_fsync") -int BPF_KPROBE(kprobe__xfs_file_fsync, struct file *file, loff_t start, +int BPF_KPROBE(xfs_file_fsync, struct file *file, loff_t start, loff_t end) { return probe_entry(file, start, end); @@ -134,25 +134,25 @@ probe_exit(struct pt_regs *ctx, char type, ssize_t size) } SEC("kretprobe/xfs_file_read_iter") -int BPF_KRETPROBE(kretprobe__xfs_file_read_iters, ssize_t ret) +int BPF_KRETPROBE(xfs_file_read_iters_ret, ssize_t ret) { return probe_exit(ctx, TRACE_READ, ret); } SEC("kretprobe/xfs_file_write_iter") -int BPF_KRETPROBE(kretprobe__xfs_file_write_iter, ssize_t ret) +int BPF_KRETPROBE(xfs_file_write_iter_ret, ssize_t ret) { return probe_exit(ctx, TRACE_WRITE, ret); } SEC("kretprobe/xfs_file_open") -int BPF_KRETPROBE(kretprobe__xfs_file_open) +int BPF_KRETPROBE(xfs_file_open_ret) { return probe_exit(ctx, TRACE_OPEN, 0); } SEC("kretprobe/xfs_file_fsync") -int BPF_KRETPROBE(kretprobe__xfs_file_sync) +int BPF_KRETPROBE(xfs_file_sync_ret) { return probe_exit(ctx, TRACE_FSYNC, 0); } diff --git a/libbpf-tools/xfsslower.c b/libbpf-tools/xfsslower.c index 2c8a2b375..f94216d4d 100644 --- a/libbpf-tools/xfsslower.c +++ b/libbpf-tools/xfsslower.c @@ -33,7 +33,7 @@ static struct env { }; const char *argp_program_version = "xfsslower 0.1"; -const char *argp_program_bug_address = "<ethercflow@gmail.com>"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; const char argp_program_doc[] = "Trace common XFS file operations slower than a threshold.\n" "\n" @@ -48,7 +48,6 @@ const char argp_program_doc[] = static const struct argp_option opts[] = { { "csv", 'c', NULL, 0, "Output as csv" }, { "duration", 'd', "DURATION", 0, "Total duration of trace in seconds" }, - { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help"}, { "pid", 'p', "PID", 0, "Process PID to trace" }, { "min", 'm', "MIN", 0, "Min latency of trace in ms (default 10)" }, { "verbose", 'v', NULL, 0, "Verbose debug output" }, @@ -65,9 +64,6 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state) case 'v': env.verbose = true; break; - case 'h': - argp_usage(state); - break; case 'c': env.csv = true; break; diff --git a/libbpf-tools/xfsslower.h b/libbpf-tools/xfsslower.h index 76860fea0..16db77ebf 100644 --- a/libbpf-tools/xfsslower.h +++ b/libbpf-tools/xfsslower.h @@ -2,8 +2,8 @@ #ifndef __XFSSLOWER_H #define __XFSSLOWER_H -#define DNAME_INLINE_LEN 32 -#define TASK_COMM_LEN 16 +#define DNAME_INLINE_LEN 32 +#define TASK_COMM_LEN 16 #define TRACE_READ 'R' #define TRACE_WRITE 'W' From 17e14efccdd1324e39ad9413f2eeba5d93fc6b44 Mon Sep 17 00:00:00 2001 From: Yonghong Song <yhs@fb.com> Date: Thu, 1 Oct 2020 13:34:43 -0700 Subject: [PATCH 258/278] Revert "tools/biolatency: Handle signals from user" This reverts commit 87792ce6b783941ea1d8bcd29812a55520930c95. Let us have a consensus about how bcc tools should interact with external signals etc. before applying such changes to this tool and other tools. --- tools/biolatency.py | 35 ++++++++++------------------------- 1 file changed, 10 insertions(+), 25 deletions(-) diff --git a/tools/biolatency.py b/tools/biolatency.py index 532b7ae21..c608dcb5d 100755 --- a/tools/biolatency.py +++ b/tools/biolatency.py @@ -15,7 +15,6 @@ from bcc import BPF from time import sleep, strftime import argparse -import signal # arguments examples = """examples: @@ -194,7 +193,15 @@ def flags_print(flags): desc = "NoWait-" + desc return desc -def print_hist(): +# output +exiting = 0 if args.interval else 1 +dist = b.get_table("dist") +while (1): + try: + sleep(int(args.interval)) + except KeyboardInterrupt: + exiting = 1 + print() if args.timestamp: print("%-8s\n" % strftime("%H:%M:%S"), end="") @@ -205,28 +212,6 @@ def print_hist(): dist.print_log2_hist(label, "disk") dist.clear() -def exit_handler(): - print_hist() - exit() - -def signal_handler(sig, frame): - exit_handler() - -signal.signal(signal.SIGTERM, signal_handler) -signal.signal(signal.SIGINT, signal_handler) -signal.signal(signal.SIGQUIT, signal_handler) - -exiting = 0 if args.interval else 1 -dist = b.get_table("dist") - -while (1): - try: - sleep(int(args.interval)) - except KeyboardInterrupt: - exiting = 1 - - print_hist() - countdown -= 1 if exiting or countdown == 0: - exit_handler() + exit() From d0e1c932ff97401640cdfe02317c7583da775f19 Mon Sep 17 00:00:00 2001 From: Yonghong Song <yhs@fb.com> Date: Thu, 1 Oct 2020 17:32:16 -0700 Subject: [PATCH 259/278] sync with latest libbpf repo 11 new helpers are added so far in 5.10, added helper function prototypes and related documentation, etc. Signed-off-by: Yonghong Song <yhs@fb.com> --- docs/kernel-versions.md | 13 +- introspection/bps.c | 1 + src/cc/compat/linux/virtual_bpf.h | 554 ++++++++++++++++++++++++++++-- src/cc/export/helpers.h | 48 ++- src/cc/libbpf | 2 +- src/cc/libbpf.c | 13 +- 6 files changed, 595 insertions(+), 36 deletions(-) diff --git a/docs/kernel-versions.md b/docs/kernel-versions.md index ed95b7e46..288fb0772 100644 --- a/docs/kernel-versions.md +++ b/docs/kernel-versions.md @@ -200,10 +200,12 @@ Helper | Kernel version | License | Commit | -------|----------------|---------|--------| `BPF_FUNC_bind()` | 4.17 | | [`d74bad4e74ee`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d74bad4e74ee373787a9ae24197c17b7cdc428d5) | `BPF_FUNC_clone_redirect()` | 4.2 | | [`3896d655f4d4`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=3896d655f4d491c67d669a15f275a39f713410f8) +`BPF_FUNC_copy_from_user()` | 5.10 | | [`07be4c4a3e7a`](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit?id=07be4c4a3e7a0db148e44b16c5190e753d1c8569) `BPF_FUNC_csum_diff()` | 4.6 | | [`7d672345ed29`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=7d672345ed295b1356a5d9f7111da1d1d7d65867) `BPF_FUNC_csum_level()` | 5.7 | | [`7cdec54f9713`](https://github.com/torvalds/linux/commit/7cdec54f9713256bb170873a1fc5c75c9127c9d2) `BPF_FUNC_csum_update()` | 4.9 | | [`36bbef52c7eb`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=36bbef52c7eb646ed6247055a2acd3851e317857) `BPF_FUNC_current_task_under_cgroup()` | 4.9 | | [`60d20f9195b2`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=60d20f9195b260bdf0ac10c275ae9f6016f9c069) +`BPF_FUNC_d_path()` | 5.10 | | [`6e22ab9da793`](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit?id=6e22ab9da79343532cd3cde39df25e5a5478c692) `BPF_FUNC_fib_lookup()` | 4.18 | GPL | [`87f5fc7e48dd`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=87f5fc7e48dd3175b30dd03b41564e1a8e136323) `BPF_FUNC_get_current_ancestor_cgroup_id()` | 5.6 | | [`b4490c5c4e02`](https://github.com/torvalds/linux/commit/b4490c5c4e023f09b7d27c9a9d3e7ad7d09ea6bf) `BPF_FUNC_get_cgroup_classid()` | 4.3 | | [`8d20aabe1c76`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=8d20aabe1c76cccac544d9fcc3ad7823d9e98a2d) @@ -227,11 +229,14 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_get_stackid()` | 4.6 | GPL | [`d5a3b1f69186`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d5a3b1f691865be576c2bffa708549b8cdccda19) `BPF_FUNC_get_task_stack()` | 5.9 | | [`fa28dcb82a38`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/fa28dcb82a38f8e3993b0fae9106b1a80b59e4f0) `BPF_FUNC_getsockopt()` | 4.15 | | [`cd86d1fd2102`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=cd86d1fd21025fdd6daf23d1288da405e7ad0ec6) +`BPF_FUNC_inode_storage_delete()` | 5.10 | | [`8ea636848aca`](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit?id=8ea636848aca35b9f97c5b5dee30225cf2dd0fe6) +`BPF_FUNC_inode_storage_get()` | 5.10 | | [`8ea636848aca`](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit?id=8ea636848aca35b9f97c5b5dee30225cf2dd0fe6) `BPF_FUNC_jiffies64()` | 5.5 | | [`5576b991e9c1`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=5576b991e9c1a11d2cc21c4b94fc75ec27603896) `BPF_FUNC_ktime_get_boot_ns()` | 5.7 | GPL | [`71d19214776e`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/71d19214776e61b33da48f7c1b46e522c7f78221) `BPF_FUNC_ktime_get_ns()` | 4.1 | GPL | [`d9847d310ab4`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d9847d310ab4003725e6ed1822682e24bd406908) `BPF_FUNC_l3_csum_replace()` | 4.1 | | [`91bc4822c3d6`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=91bc4822c3d61b9bb7ef66d3b77948a4f9177954) `BPF_FUNC_l4_csum_replace()` | 4.1 | | [`91bc4822c3d6`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=91bc4822c3d61b9bb7ef66d3b77948a4f9177954) +`BPF_FUNC_load_hdr_opt()` | 5.10 | | [`0813a841566f`](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit?id=0813a841566f0962a5551be7749b43c45f0022a0) `BPF_FUNC_lwt_push_encap()` | 4.18 | | [`fe94cc290f53`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=fe94cc290f535709d3c5ebd1e472dfd0aec7ee79) `BPF_FUNC_lwt_seg6_action()` | 4.18 | | [`fe94cc290f53`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=fe94cc290f535709d3c5ebd1e472dfd0aec7ee79) `BPF_FUNC_lwt_seg6_adjust_srh()` | 4.18 | | [`fe94cc290f53`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=fe94cc290f535709d3c5ebd1e472dfd0aec7ee79) @@ -266,6 +271,8 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_read_branch_records()` | 5.6 | GPL | [`fff7b64355ea`](https://github.com/torvalds/linux/commit/fff7b64355eac6e29b50229ad1512315bc04b44e) `BPF_FUNC_redirect()` | 4.4 | | [`27b29f63058d`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=27b29f63058d26c6c1742f1993338280d5a41dc6) `BPF_FUNC_redirect_map()` | 4.14 | | [`97f91a7cf04f`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=97f91a7cf04ff605845c20948b8a80e54cbd3376) +`BPF_FUNC_redirect_neigh()` | 5.10 | | [`b4ab31414970`](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit/?id=b4ab31414970a7a03a5d55d75083f2c101a30592) +`BPF_FUNC_reserve_hdr_opt()` | 5.10 | | [`0813a841566f`](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit?id=0813a841566f0962a5551be7749b43c45f0022a0) `BPF_FUNC_ringbuf_discard()` | 5.8 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) `BPF_FUNC_ringbuf_output()` | 5.8 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) `BPF_FUNC_ringbuf_query()` | 5.8 | | [`457f44363a88`](https://github.com/torvalds/linux/commit/457f44363a8894135c85b7a9afd2bd8196db24ab) @@ -274,6 +281,7 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_send_signal()` | 5.3 | | [`8b401f9ed244`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=8b401f9ed2441ad9e219953927a842d24ed051fc) `BPF_FUNC_send_signal_thread()` | 5.5 | | [`8482941f0906`](https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/commit/?id=8482941f09067da42f9c3362e15bfb3f3c19d610) `BPF_FUNC_seq_printf()` | 5.7 | GPL | [`492e639f0c22`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/492e639f0c222784e2e0f121966375f641c61b15) +`BPF_FUNC_seq_printf_btf()` | 5.10 | | [`eb411377aed9`](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit/?id=eb411377aed9e27835e77ee0710ee8f4649958f3) `BPF_FUNC_seq_write()` | 5.7 | GPL | [`492e639f0c22`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/492e639f0c222784e2e0f121966375f641c61b15) `BPF_FUNC_set_hash()` | 4.13 | | [`ded092cd73c2`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=ded092cd73c2c56a394b936f86897f29b2e131c0) `BPF_FUNC_set_hash_invalid()` | 4.9 | | [`7a4b28c6cc9f`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=7a4b28c6cc9ffac50f791b99cc7e46106436e5d8) @@ -296,6 +304,7 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_skb_change_proto()` | 4.8 | | [`6578171a7ff0`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6578171a7ff0c31dc73258f93da7407510abf085) `BPF_FUNC_skb_change_tail()` | 4.9 | | [`5293efe62df8`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=5293efe62df81908f2e90c9820c7edcc8e61f5e9) `BPF_FUNC_skb_change_type()` | 4.8 | | [`d2485c4242a8`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d2485c4242a826fdf493fd3a27b8b792965b9b9e) +`BPF_FUNC_skb_cgroup_classid()` | 5.10 | | [`b426ce83baa7`](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit/?id=b426ce83baa7dff947fb354118d3133f2953aac8) `BPF_FUNC_skb_cgroup_id()` | 4.18 | | [`cb20b08ead40`](https://github.com/torvalds/linux/commit/cb20b08ead401fd17627a36f035c0bf5bfee5567) `BPF_FUNC_skb_ecn_set_ce()` | 5.1 | | [`f7c917ba11a6`](https://github.com/torvalds/linux/commit/f7c917ba11a67632a8452ea99fe132f626a7a2cc) `BPF_FUNC_skb_get_tunnel_key()` | 4.3 | | [`d3aa45ce6b94`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d3aa45ce6b94c65b83971257317867db13e5f492) @@ -317,10 +326,12 @@ Helper | Kernel version | License | Commit | `BPF_FUNC_skc_to_tcp_timewait_sock()` | 5.9 | | [`478cfbdf5f13`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/478cfbdf5f13dfe09cfd0b1cbac821f5e27f6108) `BPF_FUNC_skc_to_tcp6_sock()` | 5.9 | | [`af7ec1383361`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/af7ec13833619e17f03aa73a785a2f871da6d66b) `BPF_FUNC_skc_to_udp6_sock()` | 5.9 | | [`0d4fad3e57df`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/bpf/bpf-next/+/0d4fad3e57df2bf61e8ffc8d12a34b1caf9b8835) +`BPF_FUNC_snprintf_btf()` | 5.10 | | [`c4d0bfb45068`](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit/?id=c4d0bfb45068d853a478b9067a95969b1886a30f) `BPF_FUNC_sock_hash_update()` | 4.18 | | [`81110384441a`](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=81110384441a59cff47430f20f049e69b98c17f4) `BPF_FUNC_sock_map_update()` | 4.14 | | [`174a79ff9515`](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=174a79ff9515f400b9a6115643dafd62a635b7e6) `BPF_FUNC_spin_lock()` | 5.1 | | [`d83525ca62cf`](https://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git/commit/?id=d83525ca62cf8ebe3271d14c36fb900c294274a2) `BPF_FUNC_spin_unlock()` | 5.1 | | [`d83525ca62cf`](https://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git/commit/?id=d83525ca62cf8ebe3271d14c36fb900c294274a2) +`BPF_FUNC_store_hdr_opt()` | 5.10 | | [`0813a841566f`](https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit?id=0813a841566f0962a5551be7749b43c45f0022a0) `BPF_FUNC_strtol()` | 5.2 | | [`d7a4cb9b6705`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/davem/net-next/+/d7a4cb9b6705a89937d12c8158a35a3145dc967a) `BPF_FUNC_strtoul()` | 5.2 | | [`d7a4cb9b6705`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/davem/net-next/+/d7a4cb9b6705a89937d12c8158a35a3145dc967a) `BPF_FUNC_sysctl_get_current_value()` | 5.2 | | [`1d11b3016cec`](https://kernel.googlesource.com/pub/scm/linux/kernel/git/davem/net-next/+/1d11b3016cec4ed9770b98e82a61708c8f4926e7) @@ -361,7 +372,7 @@ The list of program types and supported helper functions can be retrieved with: |`BPF_PROG_TYPE_SOCKET_FILTER`|`BPF_FUNC_skb_load_bytes()` <br> `BPF_FUNC_skb_load_bytes_relative()` <br> `BPF_FUNC_get_socket_cookie()` <br> `BPF_FUNC_get_socket_uid()` <br> `BPF_FUNC_perf_event_output()` <br> `Base functions`| |`BPF_PROG_TYPE_KPROBE`|`BPF_FUNC_perf_event_output()` <br> `BPF_FUNC_get_stackid()` <br> `BPF_FUNC_get_stack()` <br> `BPF_FUNC_perf_event_read_value()` <br> `BPF_FUNC_override_return()` <br> `Tracing functions`| |`BPF_PROG_TYPE_SCHED_CLS` <br> `BPF_PROG_TYPE_SCHED_ACT`|`BPF_FUNC_skb_store_bytes()` <br> `BPF_FUNC_skb_load_bytes()` <br> `BPF_FUNC_skb_load_bytes_relative()` <br> `BPF_FUNC_skb_pull_data()` <br> `BPF_FUNC_csum_diff()` <br> `BPF_FUNC_csum_update()` <br> `BPF_FUNC_l3_csum_replace()` <br> `BPF_FUNC_l4_csum_replace()` <br> `BPF_FUNC_clone_redirect()` <br> `BPF_FUNC_get_cgroup_classid()` <br> `BPF_FUNC_skb_vlan_push()` <br> `BPF_FUNC_skb_vlan_pop()` <br> `BPF_FUNC_skb_change_proto()` <br> `BPF_FUNC_skb_change_type()` <br> `BPF_FUNC_skb_adjust_room()` <br> `BPF_FUNC_skb_change_tail()` <br> `BPF_FUNC_skb_get_tunnel_key()` <br> `BPF_FUNC_skb_set_tunnel_key()` <br> `BPF_FUNC_skb_get_tunnel_opt()` <br> `BPF_FUNC_skb_set_tunnel_opt()` <br> `BPF_FUNC_redirect()` <br> `BPF_FUNC_get_route_realm()` <br> `BPF_FUNC_get_hash_recalc()` <br> `BPF_FUNC_set_hash_invalid()` <br> `BPF_FUNC_set_hash()` <br> `BPF_FUNC_perf_event_output()` <br> `BPF_FUNC_get_smp_processor_id()` <br> `BPF_FUNC_skb_under_cgroup()` <br> `BPF_FUNC_get_socket_cookie()` <br> `BPF_FUNC_get_socket_uid()` <br> `BPF_FUNC_fib_lookup()` <br> `BPF_FUNC_skb_get_xfrm_state()` <br> `BPF_FUNC_skb_cgroup_id()` <br> `Base functions`| -|`BPF_PROG_TYPE_TRACEPOINT`|`BPF_FUNC_perf_event_output()` <br> `BPF_FUNC_get_stackid()` <br> `BPF_FUNC_get_stack()` <br> `Tracing functions`| +|`BPF_PROG_TYPE_TRACEPOINT`|`BPF_FUNC_perf_event_output()` <br> `BPF_FUNC_get_stackid()` <br> `BPF_FUNC_get_stack()` <br> `BPF_FUNC_d_path()` <br> `Tracing functions`| |`BPF_PROG_TYPE_XDP`| `BPF_FUNC_perf_event_output()` <br> `BPF_FUNC_get_smp_processor_id()` <br> `BPF_FUNC_csum_diff()` <br> `BPF_FUNC_xdp_adjust_head()` <br> `BPF_FUNC_xdp_adjust_meta()` <br> `BPF_FUNC_redirect()` <br> `BPF_FUNC_redirect_map()` <br> `BPF_FUNC_xdp_adjust_tail()` <br> `BPF_FUNC_fib_lookup()` <br> `Base functions`| |`BPF_PROG_TYPE_PERF_EVENT`| `BPF_FUNC_perf_event_output()` <br> `BPF_FUNC_get_stackid()` <br> `BPF_FUNC_get_stack()` <br> `BPF_FUNC_perf_prog_read_value()` <br> `Tracing functions`| |`BPF_PROG_TYPE_CGROUP_SKB`|`BPF_FUNC_skb_load_bytes()` <br> `BPF_FUNC_skb_load_bytes_relative()` <br> `BPF_FUNC_get_socket_cookie()` <br> `BPF_FUNC_get_socket_uid()` <br> `Base functions`| diff --git a/introspection/bps.c b/introspection/bps.c index 9d7659e3e..b5595442f 100644 --- a/introspection/bps.c +++ b/introspection/bps.c @@ -77,6 +77,7 @@ static const char * const map_type_strings[] = { [BPF_MAP_TYPE_DEVMAP_HASH] = "devmap_hash", [BPF_MAP_TYPE_STRUCT_OPS] = "struct_ops", [BPF_MAP_TYPE_RINGBUF] = "ringbuf", + [BPF_MAP_TYPE_INODE_STORAGE] = "inode_storage", }; #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x))) diff --git a/src/cc/compat/linux/virtual_bpf.h b/src/cc/compat/linux/virtual_bpf.h index 0387b9707..a997ab5a4 100644 --- a/src/cc/compat/linux/virtual_bpf.h +++ b/src/cc/compat/linux/virtual_bpf.h @@ -125,6 +125,7 @@ enum bpf_cmd { BPF_ENABLE_STATS, BPF_ITER_CREATE, BPF_LINK_DETACH, + BPF_PROG_BIND_MAP, }; enum bpf_map_type { @@ -156,6 +157,7 @@ enum bpf_map_type { BPF_MAP_TYPE_DEVMAP_HASH, BPF_MAP_TYPE_STRUCT_OPS, BPF_MAP_TYPE_RINGBUF, + BPF_MAP_TYPE_INODE_STORAGE, }; /* Note that tracing related programs such as @@ -346,6 +348,14 @@ enum bpf_link_type { /* The verifier internal test flag. Behavior is undefined */ #define BPF_F_TEST_STATE_FREQ (1U << 3) +/* If BPF_F_SLEEPABLE is used in BPF_PROG_LOAD command, the verifier will + * restrict map and helper usage for such programs. Sleepable BPF programs can + * only be attached to hooks where kernel execution context allows sleeping. + * Such programs are allowed to use helpers that may sleep like + * bpf_copy_from_user(). + */ +#define BPF_F_SLEEPABLE (1U << 4) + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have * two extensions: * @@ -415,6 +425,11 @@ enum { */ #define BPF_F_QUERY_EFFECTIVE (1U << 0) +/* Flags for BPF_PROG_TEST_RUN */ + +/* If set, run the test on the cpu specified by bpf_attr.test.cpu */ +#define BPF_F_TEST_RUN_ON_CPU (1U << 0) + /* type for BPF_ENABLE_STATS */ enum bpf_stats_type { /* enabled run_time_ns and run_cnt */ @@ -557,6 +572,8 @@ union bpf_attr { */ __aligned_u64 ctx_in; __aligned_u64 ctx_out; + __u32 flags; + __u32 cpu; } test; struct { /* anonymous struct used by BPF_*_GET_*_ID */ @@ -623,8 +640,13 @@ union bpf_attr { }; __u32 attach_type; /* attach type */ __u32 flags; /* extra flags */ - __aligned_u64 iter_info; /* extra bpf_iter_link_info */ - __u32 iter_info_len; /* iter_info length */ + union { + __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ + }; + }; } link_create; struct { /* struct used by BPF_LINK_UPDATE command */ @@ -650,6 +672,12 @@ union bpf_attr { __u32 flags; } iter_create; + struct { /* struct used by BPF_PROG_BIND_MAP command */ + __u32 prog_fd; + __u32 map_fd; + __u32 flags; /* extra flags */ + } prog_bind_map; + } __attribute__((aligned(8))); /* The description below is an attempt at providing documentation to eBPF @@ -1439,8 +1467,8 @@ union bpf_attr { * Return * The return value depends on the result of the test, and can be: * - * * 0, if the *skb* task belongs to the cgroup2. - * * 1, if the *skb* task does not belong to the cgroup2. + * * 0, if current task belongs to the cgroup2. + * * 1, if current task does not belong to the cgroup2. * * A negative error code, if an error occurred. * * long bpf_skb_change_tail(struct sk_buff *skb, u32 len, u64 flags) @@ -2497,7 +2525,7 @@ union bpf_attr { * result is from *reuse*\ **->socks**\ [] using the hash of the * tuple. * - * long bpf_sk_release(struct bpf_sock *sock) + * long bpf_sk_release(void *sock) * Description * Release the reference held by *sock*. *sock* must be a * non-**NULL** pointer that was returned from @@ -2677,7 +2705,7 @@ union bpf_attr { * result is from *reuse*\ **->socks**\ [] using the hash of the * tuple. * - * long bpf_tcp_check_syncookie(struct bpf_sock *sk, void *iph, u32 iph_len, struct tcphdr *th, u32 th_len) + * long bpf_tcp_check_syncookie(void *sk, void *iph, u32 iph_len, struct tcphdr *th, u32 th_len) * Description * Check whether *iph* and *th* contain a valid SYN cookie ACK for * the listening socket in *sk*. @@ -2808,7 +2836,7 @@ union bpf_attr { * * **-ERANGE** if resulting value was out of range. * - * void *bpf_sk_storage_get(struct bpf_map *map, struct bpf_sock *sk, void *value, u64 flags) + * void *bpf_sk_storage_get(struct bpf_map *map, void *sk, void *value, u64 flags) * Description * Get a bpf-local-storage from a *sk*. * @@ -2824,6 +2852,9 @@ union bpf_attr { * "type". The bpf-local-storage "type" (i.e. the *map*) is * searched against all bpf-local-storages residing at *sk*. * + * *sk* is a kernel **struct sock** pointer for LSM program. + * *sk* is a **struct bpf_sock** pointer for other program types. + * * An optional *flags* (**BPF_SK_STORAGE_GET_F_CREATE**) can be * used such that a new bpf-local-storage will be * created if one does not exist. *value* can be used @@ -2836,13 +2867,14 @@ union bpf_attr { * **NULL** if not found or there was an error in adding * a new bpf-local-storage. * - * long bpf_sk_storage_delete(struct bpf_map *map, struct bpf_sock *sk) + * long bpf_sk_storage_delete(struct bpf_map *map, void *sk) * Description * Delete a bpf-local-storage from a *sk*. * Return * 0 on success. * * **-ENOENT** if the bpf-local-storage cannot be found. + * **-EINVAL** if sk is not a fullsock (e.g. a request_sock). * * long bpf_send_signal(u32 sig) * Description @@ -2859,7 +2891,7 @@ union bpf_attr { * * **-EAGAIN** if bpf program can try again. * - * s64 bpf_tcp_gen_syncookie(struct bpf_sock *sk, void *iph, u32 iph_len, struct tcphdr *th, u32 th_len) + * s64 bpf_tcp_gen_syncookie(void *sk, void *iph, u32 iph_len, struct tcphdr *th, u32 th_len) * Description * Try to issue a SYN cookie for the packet with corresponding * IP/TCP headers, *iph* and *th*, on the listening socket in *sk*. @@ -3088,7 +3120,7 @@ union bpf_attr { * Return * The id is returned or 0 in case the id could not be retrieved. * - * long bpf_sk_assign(struct sk_buff *skb, struct bpf_sock *sk, u64 flags) + * long bpf_sk_assign(struct sk_buff *skb, void *sk, u64 flags) * Description * Helper is overloaded depending on BPF program type. This * description applies to **BPF_PROG_TYPE_SCHED_CLS** and @@ -3216,11 +3248,11 @@ union bpf_attr { * * **-EOVERFLOW** if an overflow happened: The same object will be tried again. * - * u64 bpf_sk_cgroup_id(struct bpf_sock *sk) + * u64 bpf_sk_cgroup_id(void *sk) * Description * Return the cgroup v2 id of the socket *sk*. * - * *sk* must be a non-**NULL** pointer to a full socket, e.g. one + * *sk* must be a non-**NULL** pointer to a socket, e.g. one * returned from **bpf_sk_lookup_xxx**\ (), * **bpf_sk_fullsock**\ (), etc. The format of returned id is * same as in **bpf_skb_cgroup_id**\ (). @@ -3230,7 +3262,7 @@ union bpf_attr { * Return * The id is returned or 0 in case the id could not be retrieved. * - * u64 bpf_sk_ancestor_cgroup_id(struct bpf_sock *sk, int ancestor_level) + * u64 bpf_sk_ancestor_cgroup_id(void *sk, int ancestor_level) * Description * Return id of cgroup v2 that is ancestor of cgroup associated * with the *sk* at the *ancestor_level*. The root cgroup is at @@ -3338,38 +3370,38 @@ union bpf_attr { * Description * Dynamically cast a *sk* pointer to a *tcp6_sock* pointer. * Return - * *sk* if casting is valid, or NULL otherwise. + * *sk* if casting is valid, or **NULL** otherwise. * * struct tcp_sock *bpf_skc_to_tcp_sock(void *sk) * Description * Dynamically cast a *sk* pointer to a *tcp_sock* pointer. * Return - * *sk* if casting is valid, or NULL otherwise. + * *sk* if casting is valid, or **NULL** otherwise. * * struct tcp_timewait_sock *bpf_skc_to_tcp_timewait_sock(void *sk) * Description * Dynamically cast a *sk* pointer to a *tcp_timewait_sock* pointer. * Return - * *sk* if casting is valid, or NULL otherwise. + * *sk* if casting is valid, or **NULL** otherwise. * * struct tcp_request_sock *bpf_skc_to_tcp_request_sock(void *sk) * Description * Dynamically cast a *sk* pointer to a *tcp_request_sock* pointer. * Return - * *sk* if casting is valid, or NULL otherwise. + * *sk* if casting is valid, or **NULL** otherwise. * * struct udp6_sock *bpf_skc_to_udp6_sock(void *sk) * Description * Dynamically cast a *sk* pointer to a *udp6_sock* pointer. * Return - * *sk* if casting is valid, or NULL otherwise. + * *sk* if casting is valid, or **NULL** otherwise. * * long bpf_get_task_stack(struct task_struct *task, void *buf, u32 size, u64 flags) * Description * Return a user or a kernel stack in bpf program provided buffer. * To achieve this, the helper needs *task*, which is a valid - * pointer to struct task_struct. To store the stacktrace, the - * bpf program provides *buf* with a nonnegative *size*. + * pointer to **struct task_struct**. To store the stacktrace, the + * bpf program provides *buf* with a nonnegative *size*. * * The last argument, *flags*, holds the number of stack frames to * skip (from 0 to 255), masked with @@ -3396,6 +3428,244 @@ union bpf_attr { * A non-negative value equal to or less than *size* on success, * or a negative error in case of failure. * + * long bpf_load_hdr_opt(struct bpf_sock_ops *skops, void *searchby_res, u32 len, u64 flags) + * Description + * Load header option. Support reading a particular TCP header + * option for bpf program (**BPF_PROG_TYPE_SOCK_OPS**). + * + * If *flags* is 0, it will search the option from the + * *skops*\ **->skb_data**. The comment in **struct bpf_sock_ops** + * has details on what skb_data contains under different + * *skops*\ **->op**. + * + * The first byte of the *searchby_res* specifies the + * kind that it wants to search. + * + * If the searching kind is an experimental kind + * (i.e. 253 or 254 according to RFC6994). It also + * needs to specify the "magic" which is either + * 2 bytes or 4 bytes. It then also needs to + * specify the size of the magic by using + * the 2nd byte which is "kind-length" of a TCP + * header option and the "kind-length" also + * includes the first 2 bytes "kind" and "kind-length" + * itself as a normal TCP header option also does. + * + * For example, to search experimental kind 254 with + * 2 byte magic 0xeB9F, the searchby_res should be + * [ 254, 4, 0xeB, 0x9F, 0, 0, .... 0 ]. + * + * To search for the standard window scale option (3), + * the *searchby_res* should be [ 3, 0, 0, .... 0 ]. + * Note, kind-length must be 0 for regular option. + * + * Searching for No-Op (0) and End-of-Option-List (1) are + * not supported. + * + * *len* must be at least 2 bytes which is the minimal size + * of a header option. + * + * Supported flags: + * + * * **BPF_LOAD_HDR_OPT_TCP_SYN** to search from the + * saved_syn packet or the just-received syn packet. + * + * Return + * > 0 when found, the header option is copied to *searchby_res*. + * The return value is the total length copied. On failure, a + * negative error code is returned: + * + * **-EINVAL** if a parameter is invalid. + * + * **-ENOMSG** if the option is not found. + * + * **-ENOENT** if no syn packet is available when + * **BPF_LOAD_HDR_OPT_TCP_SYN** is used. + * + * **-ENOSPC** if there is not enough space. Only *len* number of + * bytes are copied. + * + * **-EFAULT** on failure to parse the header options in the + * packet. + * + * **-EPERM** if the helper cannot be used under the current + * *skops*\ **->op**. + * + * long bpf_store_hdr_opt(struct bpf_sock_ops *skops, const void *from, u32 len, u64 flags) + * Description + * Store header option. The data will be copied + * from buffer *from* with length *len* to the TCP header. + * + * The buffer *from* should have the whole option that + * includes the kind, kind-length, and the actual + * option data. The *len* must be at least kind-length + * long. The kind-length does not have to be 4 byte + * aligned. The kernel will take care of the padding + * and setting the 4 bytes aligned value to th->doff. + * + * This helper will check for duplicated option + * by searching the same option in the outgoing skb. + * + * This helper can only be called during + * **BPF_SOCK_OPS_WRITE_HDR_OPT_CB**. + * + * Return + * 0 on success, or negative error in case of failure: + * + * **-EINVAL** If param is invalid. + * + * **-ENOSPC** if there is not enough space in the header. + * Nothing has been written + * + * **-EEXIST** if the option already exists. + * + * **-EFAULT** on failrue to parse the existing header options. + * + * **-EPERM** if the helper cannot be used under the current + * *skops*\ **->op**. + * + * long bpf_reserve_hdr_opt(struct bpf_sock_ops *skops, u32 len, u64 flags) + * Description + * Reserve *len* bytes for the bpf header option. The + * space will be used by **bpf_store_hdr_opt**\ () later in + * **BPF_SOCK_OPS_WRITE_HDR_OPT_CB**. + * + * If **bpf_reserve_hdr_opt**\ () is called multiple times, + * the total number of bytes will be reserved. + * + * This helper can only be called during + * **BPF_SOCK_OPS_HDR_OPT_LEN_CB**. + * + * Return + * 0 on success, or negative error in case of failure: + * + * **-EINVAL** if a parameter is invalid. + * + * **-ENOSPC** if there is not enough space in the header. + * + * **-EPERM** if the helper cannot be used under the current + * *skops*\ **->op**. + * + * void *bpf_inode_storage_get(struct bpf_map *map, void *inode, void *value, u64 flags) + * Description + * Get a bpf_local_storage from an *inode*. + * + * Logically, it could be thought of as getting the value from + * a *map* with *inode* as the **key**. From this + * perspective, the usage is not much different from + * **bpf_map_lookup_elem**\ (*map*, **&**\ *inode*) except this + * helper enforces the key must be an inode and the map must also + * be a **BPF_MAP_TYPE_INODE_STORAGE**. + * + * Underneath, the value is stored locally at *inode* instead of + * the *map*. The *map* is used as the bpf-local-storage + * "type". The bpf-local-storage "type" (i.e. the *map*) is + * searched against all bpf_local_storage residing at *inode*. + * + * An optional *flags* (**BPF_LOCAL_STORAGE_GET_F_CREATE**) can be + * used such that a new bpf_local_storage will be + * created if one does not exist. *value* can be used + * together with **BPF_LOCAL_STORAGE_GET_F_CREATE** to specify + * the initial value of a bpf_local_storage. If *value* is + * **NULL**, the new bpf_local_storage will be zero initialized. + * Return + * A bpf_local_storage pointer is returned on success. + * + * **NULL** if not found or there was an error in adding + * a new bpf_local_storage. + * + * int bpf_inode_storage_delete(struct bpf_map *map, void *inode) + * Description + * Delete a bpf_local_storage from an *inode*. + * Return + * 0 on success. + * + * **-ENOENT** if the bpf_local_storage cannot be found. + * + * long bpf_d_path(struct path *path, char *buf, u32 sz) + * Description + * Return full path for given **struct path** object, which + * needs to be the kernel BTF *path* object. The path is + * returned in the provided buffer *buf* of size *sz* and + * is zero terminated. + * + * Return + * On success, the strictly positive length of the string, + * including the trailing NUL character. On error, a negative + * value. + * + * long bpf_copy_from_user(void *dst, u32 size, const void *user_ptr) + * Description + * Read *size* bytes from user space address *user_ptr* and store + * the data in *dst*. This is a wrapper of **copy_from_user**\ (). + * Return + * 0 on success, or a negative error in case of failure. + * + * long bpf_snprintf_btf(char *str, u32 str_size, struct btf_ptr *ptr, u32 btf_ptr_size, u64 flags) + * Description + * Use BTF to store a string representation of *ptr*->ptr in *str*, + * using *ptr*->type_id. This value should specify the type + * that *ptr*->ptr points to. LLVM __builtin_btf_type_id(type, 1) + * can be used to look up vmlinux BTF type ids. Traversing the + * data structure using BTF, the type information and values are + * stored in the first *str_size* - 1 bytes of *str*. Safe copy of + * the pointer data is carried out to avoid kernel crashes during + * operation. Smaller types can use string space on the stack; + * larger programs can use map data to store the string + * representation. + * + * The string can be subsequently shared with userspace via + * bpf_perf_event_output() or ring buffer interfaces. + * bpf_trace_printk() is to be avoided as it places too small + * a limit on string size to be useful. + * + * *flags* is a combination of + * + * **BTF_F_COMPACT** + * no formatting around type information + * **BTF_F_NONAME** + * no struct/union member names/types + * **BTF_F_PTR_RAW** + * show raw (unobfuscated) pointer values; + * equivalent to printk specifier %px. + * **BTF_F_ZERO** + * show zero-valued struct/union members; they + * are not displayed by default + * + * Return + * The number of bytes that were written (or would have been + * written if output had to be truncated due to string size), + * or a negative error in cases of failure. + * + * long bpf_seq_printf_btf(struct seq_file *m, struct btf_ptr *ptr, u32 ptr_size, u64 flags) + * Description + * Use BTF to write to seq_write a string representation of + * *ptr*->ptr, using *ptr*->type_id as per bpf_snprintf_btf(). + * *flags* are identical to those used for bpf_snprintf_btf. + * Return + * 0 on success or a negative error in case of failure. + * + * u64 bpf_skb_cgroup_classid(struct sk_buff *skb) + * Description + * See **bpf_get_cgroup_classid**\ () for the main description. + * This helper differs from **bpf_get_cgroup_classid**\ () in that + * the cgroup v1 net_cls class is retrieved only from the *skb*'s + * associated socket instead of the current process. + * Return + * The id is returned or 0 in case the id could not be retrieved. + * + * long bpf_redirect_neigh(u32 ifindex, u64 flags) + * Description + * Redirect the packet to another net device of index *ifindex* + * and fill in L2 addresses from neighboring subsystem. This helper + * is somewhat similar to **bpf_redirect**\ (), except that it + * fills in e.g. MAC addresses based on the L3 information from + * the packet. This helper is supported for IPv4 and IPv6 protocols. + * The *flags* argument is reserved and must be 0. The helper is + * currently only supported for tc BPF program types. + * Return + * The helper returns **TC_ACT_REDIRECT** on success or + * **TC_ACT_SHOT** on error. */ #define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ @@ -3540,6 +3810,17 @@ union bpf_attr { FN(skc_to_tcp_request_sock), \ FN(skc_to_udp6_sock), \ FN(get_task_stack), \ + FN(load_hdr_opt), \ + FN(store_hdr_opt), \ + FN(reserve_hdr_opt), \ + FN(inode_storage_get), \ + FN(inode_storage_delete), \ + FN(d_path), \ + FN(copy_from_user), \ + FN(snprintf_btf), \ + FN(seq_printf_btf), \ + FN(skb_cgroup_classid), \ + FN(redirect_neigh), \ /* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper @@ -3649,9 +3930,13 @@ enum { BPF_F_SYSCTL_BASE_NAME = (1ULL << 0), }; -/* BPF_FUNC_sk_storage_get flags */ +/* BPF_FUNC_<kernel_obj>_storage_get flags */ enum { - BPF_SK_STORAGE_GET_F_CREATE = (1ULL << 0), + BPF_LOCAL_STORAGE_GET_F_CREATE = (1ULL << 0), + /* BPF_SK_STORAGE_GET_F_CREATE is only kept for backward compatibility + * and BPF_LOCAL_STORAGE_GET_F_CREATE must be used instead. + */ + BPF_SK_STORAGE_GET_F_CREATE = BPF_LOCAL_STORAGE_GET_F_CREATE, }; /* BPF_FUNC_read_branch_records flags. */ @@ -4076,8 +4361,10 @@ struct bpf_link_info { __aligned_u64 target_name; /* in/out: target_name buffer ptr */ __u32 target_name_len; /* in/out: target_name buffer len */ union { - __u32 map_id; - } map; + struct { + __u32 map_id; + } map; + }; } iter; struct { __u32 netns_ino; @@ -4166,6 +4453,36 @@ struct bpf_sock_ops { __u64 bytes_received; __u64 bytes_acked; __bpf_md_ptr(struct bpf_sock *, sk); + /* [skb_data, skb_data_end) covers the whole TCP header. + * + * BPF_SOCK_OPS_PARSE_HDR_OPT_CB: The packet received + * BPF_SOCK_OPS_HDR_OPT_LEN_CB: Not useful because the + * header has not been written. + * BPF_SOCK_OPS_WRITE_HDR_OPT_CB: The header and options have + * been written so far. + * BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB: The SYNACK that concludes + * the 3WHS. + * BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB: The ACK that concludes + * the 3WHS. + * + * bpf_load_hdr_opt() can also be used to read a particular option. + */ + __bpf_md_ptr(void *, skb_data); + __bpf_md_ptr(void *, skb_data_end); + __u32 skb_len; /* The total length of a packet. + * It includes the header, options, + * and payload. + */ + __u32 skb_tcp_flags; /* tcp_flags of the header. It provides + * an easy way to check for tcp_flags + * without parsing skb_data. + * + * In particular, the skb_tcp_flags + * will still be available in + * BPF_SOCK_OPS_HDR_OPT_LEN even though + * the outgoing header has not + * been written yet. + */ }; /* Definitions for bpf_sock_ops_cb_flags */ @@ -4174,8 +4491,51 @@ enum { BPF_SOCK_OPS_RETRANS_CB_FLAG = (1<<1), BPF_SOCK_OPS_STATE_CB_FLAG = (1<<2), BPF_SOCK_OPS_RTT_CB_FLAG = (1<<3), + /* Call bpf for all received TCP headers. The bpf prog will be + * called under sock_ops->op == BPF_SOCK_OPS_PARSE_HDR_OPT_CB + * + * Please refer to the comment in BPF_SOCK_OPS_PARSE_HDR_OPT_CB + * for the header option related helpers that will be useful + * to the bpf programs. + * + * It could be used at the client/active side (i.e. connect() side) + * when the server told it that the server was in syncookie + * mode and required the active side to resend the bpf-written + * options. The active side can keep writing the bpf-options until + * it received a valid packet from the server side to confirm + * the earlier packet (and options) has been received. The later + * example patch is using it like this at the active side when the + * server is in syncookie mode. + * + * The bpf prog will usually turn this off in the common cases. + */ + BPF_SOCK_OPS_PARSE_ALL_HDR_OPT_CB_FLAG = (1<<4), + /* Call bpf when kernel has received a header option that + * the kernel cannot handle. The bpf prog will be called under + * sock_ops->op == BPF_SOCK_OPS_PARSE_HDR_OPT_CB. + * + * Please refer to the comment in BPF_SOCK_OPS_PARSE_HDR_OPT_CB + * for the header option related helpers that will be useful + * to the bpf programs. + */ + BPF_SOCK_OPS_PARSE_UNKNOWN_HDR_OPT_CB_FLAG = (1<<5), + /* Call bpf when the kernel is writing header options for the + * outgoing packet. The bpf prog will first be called + * to reserve space in a skb under + * sock_ops->op == BPF_SOCK_OPS_HDR_OPT_LEN_CB. Then + * the bpf prog will be called to write the header option(s) + * under sock_ops->op == BPF_SOCK_OPS_WRITE_HDR_OPT_CB. + * + * Please refer to the comment in BPF_SOCK_OPS_HDR_OPT_LEN_CB + * and BPF_SOCK_OPS_WRITE_HDR_OPT_CB for the header option + * related helpers that will be useful to the bpf programs. + * + * The kernel gets its chance to reserve space and write + * options first before the BPF program does. + */ + BPF_SOCK_OPS_WRITE_HDR_OPT_CB_FLAG = (1<<6), /* Mask of all currently supported cb flags */ - BPF_SOCK_OPS_ALL_CB_FLAGS = 0xF, + BPF_SOCK_OPS_ALL_CB_FLAGS = 0x7F, }; /* List of known BPF sock_ops operators. @@ -4231,6 +4591,63 @@ enum { */ BPF_SOCK_OPS_RTT_CB, /* Called on every RTT. */ + BPF_SOCK_OPS_PARSE_HDR_OPT_CB, /* Parse the header option. + * It will be called to handle + * the packets received at + * an already established + * connection. + * + * sock_ops->skb_data: + * Referring to the received skb. + * It covers the TCP header only. + * + * bpf_load_hdr_opt() can also + * be used to search for a + * particular option. + */ + BPF_SOCK_OPS_HDR_OPT_LEN_CB, /* Reserve space for writing the + * header option later in + * BPF_SOCK_OPS_WRITE_HDR_OPT_CB. + * Arg1: bool want_cookie. (in + * writing SYNACK only) + * + * sock_ops->skb_data: + * Not available because no header has + * been written yet. + * + * sock_ops->skb_tcp_flags: + * The tcp_flags of the + * outgoing skb. (e.g. SYN, ACK, FIN). + * + * bpf_reserve_hdr_opt() should + * be used to reserve space. + */ + BPF_SOCK_OPS_WRITE_HDR_OPT_CB, /* Write the header options + * Arg1: bool want_cookie. (in + * writing SYNACK only) + * + * sock_ops->skb_data: + * Referring to the outgoing skb. + * It covers the TCP header + * that has already been written + * by the kernel and the + * earlier bpf-progs. + * + * sock_ops->skb_tcp_flags: + * The tcp_flags of the outgoing + * skb. (e.g. SYN, ACK, FIN). + * + * bpf_store_hdr_opt() should + * be used to write the + * option. + * + * bpf_load_hdr_opt() can also + * be used to search for a + * particular option that + * has already been written + * by the kernel or the + * earlier bpf-progs. + */ }; /* List of TCP states. There is a build check in net/ipv4/tcp.c to detect @@ -4258,6 +4675,63 @@ enum { enum { TCP_BPF_IW = 1001, /* Set TCP initial congestion window */ TCP_BPF_SNDCWND_CLAMP = 1002, /* Set sndcwnd_clamp */ + TCP_BPF_DELACK_MAX = 1003, /* Max delay ack in usecs */ + TCP_BPF_RTO_MIN = 1004, /* Min delay ack in usecs */ + /* Copy the SYN pkt to optval + * + * BPF_PROG_TYPE_SOCK_OPS only. It is similar to the + * bpf_getsockopt(TCP_SAVED_SYN) but it does not limit + * to only getting from the saved_syn. It can either get the + * syn packet from: + * + * 1. the just-received SYN packet (only available when writing the + * SYNACK). It will be useful when it is not necessary to + * save the SYN packet for latter use. It is also the only way + * to get the SYN during syncookie mode because the syn + * packet cannot be saved during syncookie. + * + * OR + * + * 2. the earlier saved syn which was done by + * bpf_setsockopt(TCP_SAVE_SYN). + * + * The bpf_getsockopt(TCP_BPF_SYN*) option will hide where the + * SYN packet is obtained. + * + * If the bpf-prog does not need the IP[46] header, the + * bpf-prog can avoid parsing the IP header by using + * TCP_BPF_SYN. Otherwise, the bpf-prog can get both + * IP[46] and TCP header by using TCP_BPF_SYN_IP. + * + * >0: Total number of bytes copied + * -ENOSPC: Not enough space in optval. Only optlen number of + * bytes is copied. + * -ENOENT: The SYN skb is not available now and the earlier SYN pkt + * is not saved by setsockopt(TCP_SAVE_SYN). + */ + TCP_BPF_SYN = 1005, /* Copy the TCP header */ + TCP_BPF_SYN_IP = 1006, /* Copy the IP[46] and TCP header */ + TCP_BPF_SYN_MAC = 1007, /* Copy the MAC, IP[46], and TCP header */ +}; + +enum { + BPF_LOAD_HDR_OPT_TCP_SYN = (1ULL << 0), +}; + +/* args[0] value during BPF_SOCK_OPS_HDR_OPT_LEN_CB and + * BPF_SOCK_OPS_WRITE_HDR_OPT_CB. + */ +enum { + BPF_WRITE_HDR_TCP_CURRENT_MSS = 1, /* Kernel is finding the + * total option spaces + * required for an established + * sk in order to calculate the + * MSS. No skb is actually + * sent. + */ + BPF_WRITE_HDR_TCP_SYNACK_COOKIE = 2, /* Kernel is in syncookie mode + * when sending a SYN. + */ }; struct bpf_perf_event_value { @@ -4455,5 +4929,35 @@ struct bpf_sk_lookup { __u32 local_port; /* Host byte order */ }; +/* + * struct btf_ptr is used for typed pointer representation; the + * type id is used to render the pointer data as the appropriate type + * via the bpf_snprintf_btf() helper described above. A flags field - + * potentially to specify additional details about the BTF pointer + * (rather than its mode of display) - is included for future use. + * Display flags - BTF_F_* - are passed to bpf_snprintf_btf separately. + */ +struct btf_ptr { + void *ptr; + __u32 type_id; + __u32 flags; /* BTF ptr flags; unused at present. */ +}; + +/* + * Flags to control bpf_snprintf_btf() behaviour. + * - BTF_F_COMPACT: no formatting around type information + * - BTF_F_NONAME: no struct/union member names/types + * - BTF_F_PTR_RAW: show raw (unobfuscated) pointer values; + * equivalent to %px. + * - BTF_F_ZERO: show zero-valued struct/union members; they + * are not displayed by default + */ +enum { + BTF_F_COMPACT = (1ULL << 0), + BTF_F_NONAME = (1ULL << 1), + BTF_F_PTR_RAW = (1ULL << 2), + BTF_F_ZERO = (1ULL << 3), +}; + #endif /* _UAPI__LINUX_BPF_H__ */ )********" diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index d1807a7c2..b8ec99e17 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -521,7 +521,7 @@ static int (*bpf_sysctl_get_new_value)(struct bpf_sysctl *ctx, char *buf, size_t (void *) BPF_FUNC_sysctl_get_new_value; static int (*bpf_sysctl_set_new_value)(struct bpf_sysctl *ctx, const char *buf, size_t buf_len) = (void *) BPF_FUNC_sysctl_set_new_value; -static int (*bpf_tcp_check_syncookie)(struct bpf_sock *sk, void *ip, int ip_len, void *tcp, +static int (*bpf_tcp_check_syncookie)(void *sk, void *ip, int ip_len, void *tcp, int tcp_len) = (void *) BPF_FUNC_tcp_check_syncookie; static int (*bpf_xdp_adjust_meta)(void *ctx, int offset) = @@ -637,7 +637,7 @@ static struct bpf_sock *(*bpf_sk_lookup_udp)(void *ctx, int size, unsigned int netns_id, unsigned long long flags) = (void *) BPF_FUNC_sk_lookup_udp; -static int (*bpf_sk_release)(struct bpf_sock *sk) = +static int (*bpf_sk_release)(void *sk) = (void *) BPF_FUNC_sk_release; static int (*bpf_map_push_elem)(void *map, const void *value, u64 flags) = (void *) BPF_FUNC_map_push_elem; @@ -663,13 +663,13 @@ static int (*bpf_skb_ecn_set_ce)(void *ctx) = (void *) BPF_FUNC_skb_ecn_set_ce; static struct bpf_sock *(*bpf_get_listener_sock)(struct bpf_sock *sk) = (void *) BPF_FUNC_get_listener_sock; -static void *(*bpf_sk_storage_get)(void *map, struct bpf_sock *sk, +static void *(*bpf_sk_storage_get)(void *map, void *sk, void *value, __u64 flags) = (void *) BPF_FUNC_sk_storage_get; -static int (*bpf_sk_storage_delete)(void *map, struct bpf_sock *sk) = +static int (*bpf_sk_storage_delete)(void *map, void *sk) = (void *)BPF_FUNC_sk_storage_delete; static int (*bpf_send_signal)(unsigned sig) = (void *)BPF_FUNC_send_signal; -static long long (*bpf_tcp_gen_syncookie)(struct bpf_sock *sk, void *ip, +static long long (*bpf_tcp_gen_syncookie)(void *sk, void *ip, int ip_len, void *tcp, int tcp_len) = (void *) BPF_FUNC_tcp_gen_syncookie; static int (*bpf_skb_output)(void *ctx, void *map, __u64 flags, void *data, @@ -712,7 +712,7 @@ static __u64 (*bpf_get_current_ancestor_cgroup_id)(int ancestor_level) = (void *)BPF_FUNC_get_current_ancestor_cgroup_id; struct sk_buff; -static int (*bpf_sk_assign)(void *skb, struct bpf_sock *sk, __u64 flags) = +static int (*bpf_sk_assign)(void *skb, void *sk, __u64 flags) = (void *)BPF_FUNC_sk_assign; static __u64 (*bpf_ktime_get_boot_ns)(void) = (void *)BPF_FUNC_ktime_get_boot_ns; @@ -724,8 +724,8 @@ static int (*bpf_seq_printf)(struct seq_file *m, const char *fmt, __u32 fmt_size static int (*bpf_seq_write)(struct seq_file *m, const void *data, __u32 len) = (void *)BPF_FUNC_seq_write; -static __u64 (*bpf_sk_cgroup_id)(struct bpf_sock *sk) = (void *)BPF_FUNC_sk_cgroup_id; -static __u64 (*bpf_sk_ancestor_cgroup_id)(struct bpf_sock *sk, int ancestor_level) = +static __u64 (*bpf_sk_cgroup_id)(void *sk) = (void *)BPF_FUNC_sk_cgroup_id; +static __u64 (*bpf_sk_ancestor_cgroup_id)(void *sk, int ancestor_level) = (void *)BPF_FUNC_sk_ancestor_cgroup_id; static int (*bpf_ringbuf_output)(void *ringbuf, void *data, __u64 size, __u64 flags) = @@ -763,6 +763,38 @@ static long (*bpf_get_task_stack)(struct task_struct *task, void *buf, __u32 size, __u64 flags) = (void *)BPF_FUNC_get_task_stack; +struct bpf_sock_ops; +static long (*bpf_load_hdr_opt)(struct bpf_sock_ops *skops, void *searchby_res, + u32 len, u64 flags) = + (void *)BPF_FUNC_load_hdr_opt; +static long (*bpf_store_hdr_opt)(struct bpf_sock_ops *skops, const void *from, + u32 len, u64 flags) = + (void *)BPF_FUNC_store_hdr_opt; +static long (*bpf_reserve_hdr_opt)(struct bpf_sock_ops *skops, u32 len, + u64 flags) = + (void *)BPF_FUNC_reserve_hdr_opt; +static void *(*bpf_inode_storage_get)(struct bpf_map *map, void *inode, + void *value, u64 flags) = + (void *)BPF_FUNC_inode_storage_get; +static int (*bpf_inode_storage_delete)(struct bpf_map *map, void *inode) = + (void *)BPF_FUNC_inode_storage_delete; +struct path; +static long (*bpf_d_path)(struct path *path, char *buf, u32 sz) = + (void *)BPF_FUNC_d_path; +static long (*bpf_copy_from_user)(void *dst, u32 size, const void *user_ptr) = + (void *)BPF_FUNC_copy_from_user; + +static long (*bpf_snprintf_btf)(char *str, __u32 str_size, struct btf_ptr *ptr, + __u32 btf_ptr_size, __u64 flags) = + (void *)BPF_FUNC_snprintf_btf; +static long (*bpf_seq_printf_btf)(struct seq_file *m, struct btf_ptr *ptr, + __u32 ptr_size, __u64 flags) = + (void *)BPF_FUNC_seq_printf_btf; +static __u64 (*bpf_skb_cgroup_classid)(struct __sk_buff *skb) = + (void *)BPF_FUNC_skb_cgroup_classid; +static long (*bpf_redirect_neigh)(__u32 ifindex, __u64 flags) = + (void *)BPF_FUNC_redirect_neigh; + /* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions */ diff --git a/src/cc/libbpf b/src/cc/libbpf index 4001a658e..b6dd2f2b7 160000 --- a/src/cc/libbpf +++ b/src/cc/libbpf @@ -1 +1 @@ -Subproject commit 4001a658e05f4385cc7764bbe0e6a110be26a468 +Subproject commit b6dd2f2b7df4d3bd35d64aaf521d9ad18d766f53 diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index 165c08869..8912bc885 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -237,7 +237,18 @@ static struct bpf_helper helpers[] = { {"skc_to_tcp_timewait_sock", "5.9"}, {"skc_to_tcp_request_sock", "5.9"}, {"skc_to_udp6_sock", "5.9"}, - {"bpf_get_task_stack", "5.9"}, + {"get_task_stack", "5.9"}, + {"load_hdr_opt", "5.10"}, + {"store_hdr_opt", "5.10"}, + {"reserve_hdr_opt", "5.10"}, + {"inode_storage_get", "5.10"}, + {"inode_storage_delete", "5.10"}, + {"d_path", "5.10"}, + {"copy_from_user", "5.10"}, + {"snprintf_btf", "5.10"}, + {"seq_printf_btf", "5.10"}, + {"skb_cgroup_classid", "5.10"}, + {"redirect_neigh", "5.10"}, }; static uint64_t ptr_to_u64(void *ptr) From 5fe35766ac0e2860c7e6c1694a2338365e9497a6 Mon Sep 17 00:00:00 2001 From: Yonghong Song <yhs@fb.com> Date: Sat, 3 Oct 2020 18:04:01 -0700 Subject: [PATCH 260/278] add C++ bpf_iter support bpf iterator is introduced in linux kernel 5.8. https://lore.kernel.org/bpf/20200509175859.2474608-1-yhs@fb.com/ In 5.8, iterator support for task, task_file, bpf_map, netlink_sock and ipv6_route. In 5.9, tcp, udp and hash/array/sk_local_storage map iterators are implemented. This patch added necessary interface to support bpf_iter in bcc. A few C++ APIs are added to bcc. Two bpf_iter examples, task and sk_local_storage_map, are added to illustrate how bpf iterator can be implemented. Python interface can be added later if there is a need. Signed-off-by: Yonghong Song <yhs@fb.com> --- docs/reference_guide.md | 24 ++++ examples/cpp/CMakeLists.txt | 6 + examples/cpp/SkLocalStorageIterator.cc | 183 +++++++++++++++++++++++++ examples/cpp/TaskIterator.cc | 141 +++++++++++++++++++ src/cc/export/helpers.h | 3 + src/cc/libbpf.c | 18 +++ src/cc/libbpf.h | 4 + 7 files changed, 379 insertions(+) create mode 100644 examples/cpp/SkLocalStorageIterator.cc create mode 100644 examples/cpp/TaskIterator.cc diff --git a/docs/reference_guide.md b/docs/reference_guide.md index 82d510530..cfd1ad473 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -19,6 +19,7 @@ This guide is incomplete. If something feels missing, check the bcc and kernel s - [9. kfuncs](#9-kfuncs) - [10. kretfuncs](#10-kretfuncs) - [11. lsm probes](#11-lsm-probes) + - [12. bpf iterators](#12-bpf-iterators) - [Data](#data) - [1. bpf_probe_read_kernel()](#1-bpf_probe_read_kernel) - [2. bpf_probe_read_kernel_str()](#2-bpf_probe_read_kernel_str) @@ -423,6 +424,29 @@ LSM probes require at least a 5.7+ kernel with the following configuation option Examples in situ: [search /tests](https://github.com/iovisor/bcc/search?q=LSM_PROBE+path%3Atests&type=Code) +### 12. BPF ITERATORS + +Syntax: BPF_ITER(target) + +This is a macro to define a program signature for a bpf iterator program. The argument *target* specifies what to iterate for the program. + +Currently, kernel does not have interface to discover what targets are supported. A good place to find what is supported is in [tools/testing/selftests/bpf/prog_test/bpf_iter.c](https://github.com/torvalds/linux/blob/master/tools/testing/selftests/bpf/prog_tests/bpf_iter.c) and some sample bpf iter programs are in [tools/testing/selftests/bpf/progs](https://github.com/torvalds/linux/tree/master/tools/testing/selftests/bpf/progs) with file name prefix *bpf_iter*. + +The following example defines a program for target *task*, which traverses all tasks in the kernel. +```C +BPF_ITER(task) +{ + struct seq_file *seq = ctx->meta->seq; + struct task_struct *task = ctx->task; + + if (task == (void *)0) + return 0; + + ... task->pid, task->tgid, task->comm, ... + return 0; +} + +BPF iterators are introduced in 5.8 kernel for task, task_file, bpf_map, netlink_sock and ipv6_route . In 5.9, support is added to tcp/udp sockets and bpf map element (hashmap, arraymap and sk_local_storage_map) traversal. ## Data diff --git a/examples/cpp/CMakeLists.txt b/examples/cpp/CMakeLists.txt index 58a4be769..dae0e9ce7 100644 --- a/examples/cpp/CMakeLists.txt +++ b/examples/cpp/CMakeLists.txt @@ -38,6 +38,12 @@ target_link_libraries(UseExternalMap bcc-static) add_executable(CGroupTest CGroupTest.cc) target_link_libraries(CGroupTest bcc-static) +add_executable(TaskIterator TaskIterator.cc) +target_link_libraries(TaskIterator bcc-static) + +add_executable(SkLocalStorageIterator SkLocalStorageIterator.cc) +target_link_libraries(SkLocalStorageIterator bcc-static) + if(INSTALL_CPP_EXAMPLES) install (TARGETS HelloWorld DESTINATION share/bcc/examples/cpp) install (TARGETS CPUDistribution DESTINATION share/bcc/examples/cpp) diff --git a/examples/cpp/SkLocalStorageIterator.cc b/examples/cpp/SkLocalStorageIterator.cc new file mode 100644 index 000000000..fdcf1d5f0 --- /dev/null +++ b/examples/cpp/SkLocalStorageIterator.cc @@ -0,0 +1,183 @@ +/* + * Copyright (c) Facebook, Inc. + * Licensed under the Apache License, Version 2.0 (the "License") + * + * Usage: + * ./SkLocalStorageIterator + * + * BPF socket local storage map iterator supported is added in 5.9. + * But since it takes locks during iterating, it may have performance + * implication if in parallel some other bpf program or user space + * is doing map update/delete for sockets in the same bucket. The issue + * is fixed in 5.10 with the following patch which uses rcu lock instead: + * https://lore.kernel.org/bpf/20200916224645.720172-1-yhs@fb.com + * + * This example shows how to dump local storage data from all sockets + * associated with one socket local storage map. + * An example output likes below: + * family prot val + * 2 17 20 + * 2 17 10 + */ + +#include <unistd.h> +#include <fstream> +#include <iostream> +#include <string> +#include <net/if.h> + +#include "bcc_version.h" +#include "BPF.h" + +const std::string BPF_PROGRAM = R"( + +#include <linux/bpf.h> +#include <linux/seq_file.h> +#include <net/sock.h> + +/* the structure is defined in .c file, so explicitly define + * the structure here. + */ +struct bpf_iter__bpf_sk_storage_map { + union { + struct bpf_iter_meta *meta; + }; + union { + struct bpf_map *map; + }; + union { + struct sock *sk; + }; + union { + void *value; + }; +}; + +BPF_SK_STORAGE(sk_data_map, __u64); + +struct info_t { + __u32 family; + __u32 protocol; + __u64 val; +}; + +BPF_ITER(bpf_sk_storage_map) { + struct seq_file *seq = ctx->meta->seq; + struct sock *sk = ctx->sk; + __u64 *val = ctx->value; + struct info_t info = {}; + + if (sk == (void *)0 || val == (void *)0) + return 0; + + info.family = sk->sk_family; + info.protocol = sk->sk_protocol; + info.val = *val; + bpf_seq_write(seq, &info, sizeof(info)); + + return 0; +} +)"; + +struct info_t { + unsigned family; + unsigned protocol; + unsigned long long val; +}; + +int main() { + ebpf::BPF bpf; + auto res = bpf.init(BPF_PROGRAM); + if (res.code() != 0) { + std::cerr << res.msg() << std::endl; + return 1; + } + + // create two sockets + int sockfd1 = socket(AF_INET, SOCK_DGRAM, 0); + if (sockfd1 < 0) { + std::cerr << "socket1 create failure: " << sockfd1 << std::endl; + return 1; + } + + int sockfd2 = socket(AF_INET, SOCK_DGRAM, 0); + if (sockfd2 < 0) { + std::cerr << "socket2 create failure: " << sockfd2 << std::endl; + close(sockfd1); + return 1; + } + + unsigned long long v1 = 10, v2 = 20; + auto sk_table = bpf.get_sk_storage_table<unsigned long long>("sk_data_map"); + + res = sk_table.update_value(sockfd1, v1); + if (res.code() != 0) { + std::cerr << "sk_data_map sockfd1 update failure: " << res.msg() << std::endl; + close(sockfd2); + close(sockfd1); + return 1; + } + + res = sk_table.update_value(sockfd2, v2); + if (res.code() != 0) { + std::cerr << "sk_data_map sockfd2 update failure: " << res.msg() << std::endl; + close(sockfd2); + close(sockfd1); + return 1; + } + + int prog_fd; + res = bpf.load_func("bpf_iter__bpf_sk_storage_map", BPF_PROG_TYPE_TRACING, prog_fd); + if (res.code() != 0) { + std::cerr << res.msg() << std::endl; + return 1; + } + + union bpf_iter_link_info link_info = {}; + link_info.map.map_fd = sk_table.get_fd(); + int link_fd = bcc_iter_attach(prog_fd, &link_info, sizeof(union bpf_iter_link_info)); + if (link_fd < 0) { + std::cerr << "bcc_iter_attach failed: " << link_fd << std::endl; + close(sockfd2); + close(sockfd1); + return 1; + } + + int iter_fd = bcc_iter_create(link_fd); + if (iter_fd < 0) { + std::cerr << "bcc_iter_create failed: " << iter_fd << std::endl; + close(link_fd); + close(sockfd2); + close(sockfd1); + return 1; + } + + // Header. + printf("family\tprot\tval\n"); + + struct info_t info[20]; + int len, leftover = 0, info_size = 20 * sizeof(struct info_t); + while ((len = read(iter_fd, (char *)info + leftover, info_size - leftover))) { + if (len < 0) { + if (len == -EAGAIN) + continue; + std::cerr << "read failed: " << len << std::endl; + break; + } + + int num_info = len / sizeof(struct info_t); + for (int i = 0; i < num_info; i++) { + printf("%d\t%d\t%lld\n", info[i].family, info[i].protocol, info[i].val); + } + + leftover = len % sizeof(struct info_t); + if (num_info > 0) + memcpy(info, (void *)&info[num_info], leftover); + } + + close(iter_fd); + close(link_fd); + close(sockfd2); + close(sockfd1); + return 0; +} diff --git a/examples/cpp/TaskIterator.cc b/examples/cpp/TaskIterator.cc new file mode 100644 index 000000000..3815e3aa1 --- /dev/null +++ b/examples/cpp/TaskIterator.cc @@ -0,0 +1,141 @@ +/* + * Copyright (c) Facebook, Inc. + * Licensed under the Apache License, Version 2.0 (the "License") + * + * Usage: + * ./TaskIterator + * + * BPF task iterator is available since linux 5.8. + * This example shows how to dump all threads in the system with + * bpf iterator. An example output likes below: + * tid comm + * 1 systemd + * 2 kthreadd + * 3 rcu_gp + * 4 rcu_par_gp + * 6 kworker/0:0H + * ... + * 2613386 sleep + * 2613474 GetCountersCPU6 + * 2613587 GetCountersCPU7 + * 2613621 CPUThreadPool69 + * 2613906 GetCountersCPU5 + * 2614140 GetCountersCPU2 + * 2614193 CfgrExtension56 + * 2614449 ruby-timer-thr + * 2614529 chef-client + * 2615122 systemd-hostnam + * ... + * 2608477 sudo + * 2608478 TaskIterator + */ + +#include <unistd.h> +#include <fstream> +#include <iostream> +#include <string> + +#include "bcc_version.h" +#include "BPF.h" + +const std::string BPF_PROGRAM = R"( +#include <linux/bpf.h> +#include <linux/seq_file.h> +#include <linux/sched.h> + +/* the structure is defined in .c file, so explicitly define + * the structure here. + */ +struct bpf_iter__task { + union { + struct bpf_iter_meta *meta; + }; + union { + struct task_struct *task; + }; +}; + +struct info_t { + int tid; + char comm[TASK_COMM_LEN]; +}; + +BPF_ITER(task) { + struct seq_file *seq = ctx->meta->seq; + struct task_struct *task = ctx->task; + struct info_t info = {}; + + if (task == (void *)0) + return 0; + + info.tid = task->pid; + __builtin_memcpy(&info.comm, task->comm, sizeof(info.comm)); + bpf_seq_write(seq, &info, sizeof(info)); + + return 0; +} +)"; + +// linux/sched.h +#define TASK_COMM_LEN 16 + +struct info_t { + int tid; + char comm[TASK_COMM_LEN]; +}; + +int main() { + ebpf::BPF bpf; + auto res = bpf.init(BPF_PROGRAM); + if (res.code() != 0) { + std::cerr << res.msg() << std::endl; + return 1; + } + + int prog_fd; + res = bpf.load_func("bpf_iter__task", BPF_PROG_TYPE_TRACING, prog_fd); + if (res.code() != 0) { + std::cerr << res.msg() << std::endl; + return 1; + } + + int link_fd = bcc_iter_attach(prog_fd, NULL, 0); + if (link_fd < 0) { + std::cerr << "bcc_iter_attach failed: " << link_fd << std::endl; + return 1; + } + + int iter_fd = bcc_iter_create(link_fd); + if (iter_fd < 0) { + std::cerr << "bcc_iter_create failed: " << iter_fd << std::endl; + close(link_fd); + return 1; + } + + // Header. + printf("tid\tcomm\n"); + + struct info_t info[20]; + int len, leftover = 0, info_size = 20 * sizeof(struct info_t); + while ((len = read(iter_fd, (char *)info + leftover, info_size - leftover))) { + if (len < 0) { + if (len == -EAGAIN) + continue; + std::cerr << "read failed: " << len << std::endl; + break; + } + + int num_info = len / sizeof(struct info_t); + for (int i = 0; i < num_info; i++) { + printf("%d\t%s\n", info[i].tid, info[i].comm); + } + + leftover = len % sizeof(struct info_t); + if (num_info > 0) + memcpy(info, (void *)&info[num_info], leftover); + } + + close(iter_fd); + close(link_fd); + return 0; +} diff --git a/src/cc/export/helpers.h b/src/cc/export/helpers.h index b8ec99e17..b3d37dfb9 100644 --- a/src/cc/export/helpers.h +++ b/src/cc/export/helpers.h @@ -1174,6 +1174,9 @@ static int ____##name(unsigned long long *ctx, ##args) #define LSM_PROBE(event, args...) \ BPF_PROG(lsm__ ## event, args) +#define BPF_ITER(target) \ + int bpf_iter__ ## target (struct bpf_iter__ ## target *ctx) + #define TP_DATA_LOC_READ_CONST(dst, field, length) \ do { \ unsigned short __offset = args->data_loc_##field & 0xFFFF; \ diff --git a/src/cc/libbpf.c b/src/cc/libbpf.c index 8912bc885..329741e37 100644 --- a/src/cc/libbpf.c +++ b/src/cc/libbpf.c @@ -595,6 +595,9 @@ int bcc_prog_load_xattr(struct bpf_load_program_attr *attr, int prog_len, } else if (strncmp(attr->name, "lsm__", 5) == 0) { name_offset = 5; expected_attach_type = BPF_LSM_MAC; + } else if (strncmp(attr->name, "bpf_iter__", 10) == 0) { + name_offset = 10; + expected_attach_type = BPF_TRACE_ITER; } if (attr->prog_type == BPF_PROG_TYPE_TRACING || @@ -1463,3 +1466,18 @@ int bpf_poll_ringbuf(struct ring_buffer *rb, int timeout_ms) { int bpf_consume_ringbuf(struct ring_buffer *rb) { return ring_buffer__consume(rb); } + +int bcc_iter_attach(int prog_fd, union bpf_iter_link_info *link_info, + uint32_t link_info_len) +{ + DECLARE_LIBBPF_OPTS(bpf_link_create_opts, link_create_opts); + + link_create_opts.iter_info = link_info; + link_create_opts.iter_info_len = link_info_len; + return bpf_link_create(prog_fd, 0, BPF_TRACE_ITER, &link_create_opts); +} + +int bcc_iter_create(int link_fd) +{ + return bpf_iter_create(link_fd); +} diff --git a/src/cc/libbpf.h b/src/cc/libbpf.h index 5ff9d485d..a4914cf1a 100644 --- a/src/cc/libbpf.h +++ b/src/cc/libbpf.h @@ -144,6 +144,10 @@ int bpf_prog_get_fd_by_id(uint32_t id); int bpf_map_get_fd_by_id(uint32_t id); int bpf_obj_get_info_by_fd(int prog_fd, void *info, uint32_t *info_len); +int bcc_iter_attach(int prog_fd, union bpf_iter_link_info *link_info, + uint32_t link_info_len); +int bcc_iter_create(int link_fd); + #define LOG_BUF_SIZE 65536 // Put non-static/inline functions in their own section with this prefix + From 5e55c22cc76687881e32ee997d79c056558b3479 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mauricio=20V=C3=A1squez?= <mauricio@kinvolk.io> Date: Tue, 6 Oct 2020 20:26:43 -0500 Subject: [PATCH 261/278] docs: Add missing code block closure MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mauricio Vásquez <mauricio@kinvolk.io> --- docs/reference_guide.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/reference_guide.md b/docs/reference_guide.md index cfd1ad473..3315b8c13 100644 --- a/docs/reference_guide.md +++ b/docs/reference_guide.md @@ -445,6 +445,7 @@ BPF_ITER(task) ... task->pid, task->tgid, task->comm, ... return 0; } +``` BPF iterators are introduced in 5.8 kernel for task, task_file, bpf_map, netlink_sock and ipv6_route . In 5.9, support is added to tcp/udp sockets and bpf map element (hashmap, arraymap and sk_local_storage_map) traversal. From 884799f06d7e398f5cf3e1ad28e3feca16b1eac5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mauricio=20V=C3=A1squez?= <mauricio@kinvolk.io> Date: Wed, 7 Oct 2020 20:11:25 -0500 Subject: [PATCH 262/278] tools: Use correct key key when deleting item from map MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The correct key to use is "tig" instead of "pid". Signed-off-by: Mauricio Vásquez <mauricio@kinvolk.io> --- tools/bindsnoop.py | 2 +- tools/tcpconnect.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/bindsnoop.py b/tools/bindsnoop.py index e08ebf857..e1472a40f 100755 --- a/tools/bindsnoop.py +++ b/tools/bindsnoop.py @@ -344,7 +344,7 @@ sports = [int(sport) for sport in args.port.split(',')] sports_if = ' && '.join(['sport != %d' % sport for sport in sports]) bpf_text = bpf_text.replace('FILTER_PORT', - 'if (%s) { currsock.delete(&pid); return 0; }' % sports_if) + 'if (%s) { currsock.delete(&tid); return 0; }' % sports_if) if args.uid: bpf_text = bpf_text.replace('FILTER_UID', 'if (uid != %s) { return 0; }' % args.uid) diff --git a/tools/tcpconnect.py b/tools/tcpconnect.py index 8cb6e4d82..7c2cea126 100755 --- a/tools/tcpconnect.py +++ b/tools/tcpconnect.py @@ -241,7 +241,7 @@ dports = [int(dport) for dport in args.port.split(',')] dports_if = ' && '.join(['dport != %d' % ntohs(dport) for dport in dports]) bpf_text = bpf_text.replace('FILTER_PORT', - 'if (%s) { currsock.delete(&pid); return 0; }' % dports_if) + 'if (%s) { currsock.delete(&tid); return 0; }' % dports_if) if args.uid: bpf_text = bpf_text.replace('FILTER_UID', 'if (uid != %s) { return 0; }' % args.uid) From 49fdec6a53b524bde53e39d24b2f06ba44531eed Mon Sep 17 00:00:00 2001 From: keyolk <chanhun.jeong@navercorp.com> Date: Thu, 8 Oct 2020 05:45:00 +0000 Subject: [PATCH 263/278] sslsniff: fix comparing bytes to string Signed-off-by: keyolk <chanhun.jeong@navercorp.com> --- tools/sslsniff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/sslsniff.py b/tools/sslsniff.py index f5a2279e2..0200750fb 100755 --- a/tools/sslsniff.py +++ b/tools/sslsniff.py @@ -197,7 +197,7 @@ def print_event(cpu, data, size, rw, evt): # Filter events by command if args.comm: - if not args.comm == event.comm: + if not args.comm == event.comm.decode('utf-8', 'replace'): return if start == 0: From 6ce68b940bd520ee827b1ff089f3baa2bb30f93b Mon Sep 17 00:00:00 2001 From: Sam Lunt <samuel.j.lunt@gmail.com> Date: Tue, 13 Oct 2020 21:11:59 -0500 Subject: [PATCH 264/278] Update installation instructions for Arch Linux The bcc packages were recently moved from the AUR to the standard Arch repos, so the installation instructions for Arch should be updated to reflect that. Additionally, the Arch "linux-lts" package was upgraded to 4.4.7 in April 2016, so it is safe to assume that any Arch installations that are still in use have been upgraded by this point. Therefore, the note about upgrading to kernel 4.3.1 is removed. --- INSTALL.md | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/INSTALL.md b/INSTALL.md index a2c3d107a..adae865ad 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -4,7 +4,7 @@ * [Packages](#packages) - [Ubuntu](#ubuntu---binary) - [Fedora](#fedora---binary) - - [Arch](#arch---aur) + - [Arch](#arch---binary) - [Gentoo](#gentoo---portage) - [openSUSE](#opensuse---binary) - [RHEL](#rhel---binary) @@ -160,15 +160,12 @@ echo -e '[iovisor]\nbaseurl=https://repo.iovisor.org/yum/main/f27/$basearch\nena sudo dnf install bcc-tools kernel-devel-$(uname -r) kernel-headers-$(uname -r) ``` -## Arch - AUR +## Arch - Binary -Upgrade the kernel to minimum 4.3.1-1 first; the ```CONFIG_BPF_SYSCALL=y``` configuration was not added until [this kernel release](https://bugs.archlinux.org/task/47008). - -Install these packages using any AUR helper such as [pacaur](https://aur.archlinux.org/packages/pacaur), [yaourt](https://aur.archlinux.org/packages/yaourt), [cower](https://aur.archlinux.org/packages/cower), etc.: +bcc is available in the standard Arch repos, so it can be installed with the `pacman` command: ``` -bcc bcc-tools python-bcc +# pacman -S bcc bcc-tools python-bcc ``` -All build and install dependencies are listed [in the PKGBUILD](https://aur.archlinux.org/cgit/aur.git/tree/PKGBUILD?h=bcc) and should install automatically. ## Gentoo - Portage From 4354c9ce33496df82c8ffd30497141daae28afaa Mon Sep 17 00:00:00 2001 From: Chunmei Xu <xuchunmei@linux.alibaba.com> Date: Tue, 13 Oct 2020 17:45:48 +0800 Subject: [PATCH 265/278] set larger range to get probes evnet for test_usdt2.py I test test_usdt2.py on aarch64 with kernel-5.9-rc5, gcc-9.2.1 and glibc2.32. with the current range of 3, always get failure: ====================================================================== FAIL: test_attach1 (__main__.TestUDST) ---------------------------------------------------------------------- Traceback (most recent call last): File "test_usdt2.py", line 170, in test_attach1 self.assertTrue(self.evt_st_6 == 1) AssertionError: False is not true ---------------------------------------------------------------------- Ran 1 test in 1.068s FAILED (failures=1) Signed-off-by: Chunmei Xu <xuchunmei@linux.alibaba.com> --- tests/python/test_usdt2.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/python/test_usdt2.py b/tests/python/test_usdt2.py index a2f461106..c8c47fe6b 100755 --- a/tests/python/test_usdt2.py +++ b/tests/python/test_usdt2.py @@ -149,7 +149,7 @@ def print_event6(cpu, data, size): b["event6"].open_perf_buffer(print_event6) # three iterations to make sure we get some probes and have time to process them - for i in range(3): + for i in range(5): b.perf_buffer_poll() # note that event1 and event4 do not really fire, so their state should be 0 From 5f53dbe182da54d6a05931d69c289ed0a4ebc339 Mon Sep 17 00:00:00 2001 From: Andrew Stribblehill <ads@wompom.org> Date: Fri, 16 Oct 2020 02:58:00 +0200 Subject: [PATCH 266/278] Add install instructions for Debian --- INSTALL.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/INSTALL.md b/INSTALL.md index adae865ad..76ac16f98 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -2,6 +2,7 @@ * [Kernel Configuration](#kernel-configuration) * [Packages](#packages) + - [Debian](#debian--binary) - [Ubuntu](#ubuntu---binary) - [Fedora](#fedora---binary) - [Arch](#arch---binary) @@ -58,6 +59,10 @@ Kernel compile flags can usually be checked by looking at `/proc/config.gz` or # Packages +## Debian - Binary + +`bcc` and its tools are available in the standard Debian main repository, from the source package [bpfcc](https://packages.debian.org/source/sid/bpfcc) under the names `bpfcc-tools`, `python-bpfcc`, `libbpfcc` and `libbpfcc-dev`. + ## Ubuntu - Binary Versions of bcc are available in the standard Ubuntu From 8c2d67e861e07f4125dc2b448f2dc5833b524a17 Mon Sep 17 00:00:00 2001 From: Juraj Vijtiuk <juraj.vijtiuk@sartura.hr> Date: Tue, 6 Oct 2020 13:21:41 +0200 Subject: [PATCH 267/278] libbpf-tools: initialize global structs in runqlen and softirqs Signed-off-by: Juraj Vijtiuk <juraj.vijtiuk@sartura.hr> --- libbpf-tools/runqlen.bpf.c | 2 +- libbpf-tools/softirqs.bpf.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/libbpf-tools/runqlen.bpf.c b/libbpf-tools/runqlen.bpf.c index ecb834bd5..ae2493b29 100644 --- a/libbpf-tools/runqlen.bpf.c +++ b/libbpf-tools/runqlen.bpf.c @@ -8,7 +8,7 @@ const volatile bool targ_per_cpu = false; -struct hist hists[MAX_CPU_NR]; +struct hist hists[MAX_CPU_NR] = {}; SEC("perf_event") int do_sample(struct bpf_perf_event_data *ctx) diff --git a/libbpf-tools/softirqs.bpf.c b/libbpf-tools/softirqs.bpf.c index f3fa79599..44812ce82 100644 --- a/libbpf-tools/softirqs.bpf.c +++ b/libbpf-tools/softirqs.bpf.c @@ -17,8 +17,8 @@ struct { __type(value, u64); } start SEC(".maps"); -__u64 counts[NR_SOFTIRQS]; -struct hist hists[NR_SOFTIRQS]; +__u64 counts[NR_SOFTIRQS] = {}; +struct hist hists[NR_SOFTIRQS] = {}; SEC("tp_btf/softirq_entry") int BPF_PROG(softirq_entry, unsigned int vec_nr) From 6929626b4c4ef610ea7dfa0568d5e2267c006313 Mon Sep 17 00:00:00 2001 From: Wenbo Zhang <ethercflow@gmail.com> Date: Tue, 29 Sep 2020 07:30:09 -0400 Subject: [PATCH 268/278] libbpf-tools: add llcstat Signed-off-by: Wenbo Zhang <ethercflow@gmail.com> --- libbpf-tools/.gitignore | 1 + libbpf-tools/Makefile | 1 + libbpf-tools/llcstat.bpf.c | 51 ++++++++ libbpf-tools/llcstat.c | 238 +++++++++++++++++++++++++++++++++++++ libbpf-tools/llcstat.h | 13 ++ 5 files changed, 304 insertions(+) create mode 100644 libbpf-tools/llcstat.bpf.c create mode 100644 libbpf-tools/llcstat.c create mode 100644 libbpf-tools/llcstat.h diff --git a/libbpf-tools/.gitignore b/libbpf-tools/.gitignore index b9d1f8823..795c529dc 100644 --- a/libbpf-tools/.gitignore +++ b/libbpf-tools/.gitignore @@ -9,6 +9,7 @@ /execsnoop /filelife /hardirqs +/llcstat /numamove /opensnoop /readahead diff --git a/libbpf-tools/Makefile b/libbpf-tools/Makefile index e0f308ccc..8559b2dac 100644 --- a/libbpf-tools/Makefile +++ b/libbpf-tools/Makefile @@ -20,6 +20,7 @@ APPS = \ execsnoop \ filelife \ hardirqs \ + llcstat \ numamove \ opensnoop \ readahead \ diff --git a/libbpf-tools/llcstat.bpf.c b/libbpf-tools/llcstat.bpf.c new file mode 100644 index 000000000..e514e135b --- /dev/null +++ b/libbpf-tools/llcstat.bpf.c @@ -0,0 +1,51 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Wenbo Zhang +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> +#include "llcstat.h" + +#define MAX_ENTRIES 10240 + +struct { + __uint(type, BPF_MAP_TYPE_HASH); + __uint(max_entries, MAX_ENTRIES); + __type(key, u64); + __type(value, struct info); +} infos SEC(".maps"); + +static __always_inline +int trace_event(__u64 sample_period, bool miss) +{ + u64 pid = bpf_get_current_pid_tgid(); + u32 cpu = bpf_get_smp_processor_id(); + struct info *infop, info = {}; + u64 key = pid << 32 | cpu; + + infop = bpf_map_lookup_elem(&infos, &key); + if (!infop) { + bpf_get_current_comm(info.comm, sizeof(info.comm)); + infop = &info; + } + if (miss) + infop->miss += sample_period; + else + infop->ref += sample_period; + if (infop == &info) + bpf_map_update_elem(&infos, &key, infop, 0); + return 0; +} + +SEC("perf_event/1") +int on_cache_miss(struct bpf_perf_event_data *ctx) +{ + return trace_event(ctx->sample_period, true); +} + +SEC("perf_event/2") +int on_cache_ref(struct bpf_perf_event_data *ctx) +{ + return trace_event(ctx->sample_period, false); +} + +char LICENSE[] SEC("license") = "GPL"; diff --git a/libbpf-tools/llcstat.c b/libbpf-tools/llcstat.c new file mode 100644 index 000000000..d6ec8636c --- /dev/null +++ b/libbpf-tools/llcstat.c @@ -0,0 +1,238 @@ +// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) +// Copyright (c) 2020 Wenbo Zhang +// +// Based on llcstat(8) from BCC by Teng Qin. +// 29-Sep-2020 Wenbo Zhang Created this. +#include <argp.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <linux/perf_event.h> +#include <asm/unistd.h> +#include <bpf/libbpf.h> +#include <bpf/bpf.h> +#include "llcstat.h" +#include "llcstat.skel.h" +#include "trace_helpers.h" + +struct env { + int sample_period; + time_t duration; + bool verbose; +} env = { + .sample_period = 100, + .duration = 10, +}; + +static volatile bool exiting; + +const char *argp_program_version = "llcstat 0.1"; +const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; +const char argp_program_doc[] = +"Summarize cache references and misses by PID.\n" +"\n" +"USAGE: llcstat [--help] [-c SAMPLE_PERIOD] [duration]\n"; + +static const struct argp_option opts[] = { + { "sample_period", 'c', "SAMPLE_PERIOD", 0, "Sample one in this many " + "number of cache reference / miss events" }, + { "verbose", 'v', NULL, 0, "Verbose debug output" }, + {}, +}; + +static error_t parse_arg(int key, char *arg, struct argp_state *state) +{ + static int pos_args; + + switch (key) { + case 'v': + env.verbose = true; + break; + case 'c': + errno = 0; + env.sample_period = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid sample period\n"); + argp_usage(state); + } + break; + case ARGP_KEY_ARG: + if (pos_args++) { + fprintf(stderr, + "unrecognized positional argument: %s\n", arg); + argp_usage(state); + } + errno = 0; + env.duration = strtol(arg, NULL, 10); + if (errno) { + fprintf(stderr, "invalid duration\n"); + argp_usage(state); + } + break; + default: + return ARGP_ERR_UNKNOWN; + } + return 0; +} + +static int nr_cpus; + +static int open_and_attach_perf_event(__u64 config, int period, + struct bpf_program *prog, + struct bpf_link *links[]) +{ + struct perf_event_attr attr = { + .type = PERF_TYPE_HARDWARE, + .freq = 0, + .sample_period = period, + .config = config, + }; + int i, fd; + + for (i = 0; i < nr_cpus; i++) { + fd = syscall(__NR_perf_event_open, &attr, -1, i, -1, 0); + if (fd < 0) { + fprintf(stderr, "failed to init perf sampling: %s\n", + strerror(errno)); + return -1; + } + links[i] = bpf_program__attach_perf_event(prog, fd); + if (libbpf_get_error(links[i])) { + fprintf(stderr, "failed to attach perf event on cpu: " + "%d\n", i); + links[i] = NULL; + close(fd); + return -1; + } + } + return 0; +} + +int libbpf_print_fn(enum libbpf_print_level level, + const char *format, va_list args) +{ + if (level == LIBBPF_DEBUG && !env.verbose) + return 0; + return vfprintf(stderr, format, args); +} + +static void sig_handler(int sig) +{ + exiting = true; +} + +static void print_map(struct bpf_map *map) +{ + __u64 total_ref = 0, total_miss = 0, total_hit, hit; + __u64 lookup_key = -1, next_key; + int err, fd = bpf_map__fd(map); + struct info info; + __u32 pid, cpu; + + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_lookup_elem(fd, &next_key, &info); + if (err < 0) { + fprintf(stderr, "failed to lookup infos: %d\n", err); + return; + } + hit = info.ref > info.miss ? info.ref - info.miss : 0; + pid = next_key >> 32; + cpu = next_key; + printf("%-8u %-16s %-4u %12llu %12llu %6.2f%%\n", pid, info.comm, + cpu, info.ref, info.miss, info.ref > 0 ? + hit * 1.0 / info.ref * 100 : 0); + total_miss += info.miss; + total_ref += info.ref; + lookup_key = next_key; + } + total_hit = total_ref > total_miss ? total_ref - total_miss : 0; + printf("Total References: %llu Total Misses: %llu Hit Rate: %.2f%%\n", + total_ref, total_miss, total_ref > 0 ? + total_hit * 1.0 / total_ref * 100 : 0); + + lookup_key = -1; + while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { + err = bpf_map_delete_elem(fd, &next_key); + if (err < 0) { + fprintf(stderr, "failed to cleanup infos: %d\n", err); + return; + } + lookup_key = next_key; + } +} + +int main(int argc, char **argv) +{ + struct bpf_link **rlinks = NULL, **mlinks = NULL; + static const struct argp argp = { + .options = opts, + .parser = parse_arg, + .doc = argp_program_doc, + }; + struct llcstat_bpf *obj; + int err, i; + + err = argp_parse(&argp, argc, argv, 0, NULL, NULL); + if (err) + return err; + + libbpf_set_print(libbpf_print_fn); + + err = bump_memlock_rlimit(); + if (err) { + fprintf(stderr, "failed to increase rlimit: %d\n", err); + return 1; + } + + obj = llcstat_bpf__open(); + if (!obj) { + fprintf(stderr, "failed to open and/or load BPF object\n"); + return 1; + } + + nr_cpus = libbpf_num_possible_cpus(); + mlinks = calloc(nr_cpus, sizeof(*mlinks)); + rlinks = calloc(nr_cpus, sizeof(*rlinks)); + if (!mlinks || !rlinks) { + fprintf(stderr, "failed to alloc mlinks or rlinks\n"); + goto cleanup; + } + + err = llcstat_bpf__load(obj); + if (err) { + fprintf(stderr, "failed to load BPF object: %d\n", err); + goto cleanup; + } + + if (open_and_attach_perf_event(PERF_COUNT_HW_CACHE_MISSES, + env.sample_period, + obj->progs.on_cache_miss, mlinks)) + goto cleanup; + if (open_and_attach_perf_event(PERF_COUNT_HW_CACHE_REFERENCES, + env.sample_period, + obj->progs.on_cache_ref, rlinks)) + goto cleanup; + + printf("Running for %ld seconds or Hit Ctrl-C to end.\n", env.duration); + + signal(SIGINT, sig_handler); + + sleep(env.duration); + + printf("%-8s %-16s %-4s %12s %12s %7s\n", + "PID", "NAME", "CPU", "REFERENCE", "MISS", "HIT%"); + + print_map(obj->maps.infos); + +cleanup: + for (i = 0; i < nr_cpus; i++) { + bpf_link__destroy(mlinks[i]); + bpf_link__destroy(rlinks[i]); + } + free(mlinks); + free(rlinks); + llcstat_bpf__destroy(obj); + + return err != 0; +} diff --git a/libbpf-tools/llcstat.h b/libbpf-tools/llcstat.h new file mode 100644 index 000000000..8123cd7d9 --- /dev/null +++ b/libbpf-tools/llcstat.h @@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ +#ifndef __LLCSTAT_H +#define __LLCSTAT_H + +#define TASK_COMM_LEN 16 + +struct info { + __u64 ref; + __u64 miss; + char comm[TASK_COMM_LEN]; +}; + +#endif /* __LLCSTAT_H */ From 1efba05d3296907bf12558445ed698a459e081c4 Mon Sep 17 00:00:00 2001 From: William Findlay <william@williamfindlay.com> Date: Fri, 16 Oct 2020 13:06:36 -0400 Subject: [PATCH 269/278] Fix python2.7 support for dirtop tool * Catch TypeError raised by Python3 glob and fall back to Python2 interface --- tools/dirtop.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tools/dirtop.py b/tools/dirtop.py index d7c9e0c75..ec6b077ba 100755 --- a/tools/dirtop.py +++ b/tools/dirtop.py @@ -148,7 +148,10 @@ def get_searched_ids(root_directories): inodes = "{" total_dirs = 0 for root_directory in root_directories.split(','): - searched_dirs = glob(root_directory, recursive=True) + try: + searched_dirs = glob(root_directory, recursive=True) + except TypeError: + searched_dirs = glob(root_directory) if not searched_dirs: continue From 6ba4dc1fb110b1db4a3ba187fa60a152f64c413f Mon Sep 17 00:00:00 2001 From: Yonghong Song <yhs@fb.com> Date: Fri, 16 Oct 2020 11:12:53 -0700 Subject: [PATCH 270/278] fix python3 compatible issue for netqtop and tcprtt tools Otherwise, we have: ... File "bcc/tools/netqtop.py", line 54 print(hd.center(COL_WIDTH)), ^ TabError: inconsistent use of tabs and spaces in indentation ... File "bcc/tools/tcprtt.py", line 117, in <module> bpf_text = bpf_text.replace(b'LPORTFILTER', b'') TypeError: replace() argument 1 must be str, not bytes ... Signed-off-by: Yonghong Song <yhs@fb.com> --- tools/netqtop.py | 10 +++++----- tools/tcprtt.py | 24 ++++++++++++------------ 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/tools/netqtop.py b/tools/netqtop.py index e2823ac6e..dbe9206a0 100755 --- a/tools/netqtop.py +++ b/tools/netqtop.py @@ -51,7 +51,7 @@ def print_table(table, qnum): headers.append("PPS") for hd in headers: - print(hd.center(COL_WIDTH)), + print(hd.center(COL_WIDTH)) print # ------- calculates -------------- @@ -180,7 +180,7 @@ def print_result(b): print_interval = args.interval + 0.0 if print_interval == 0: - print "print interval must be non-zero" + print ("print interval must be non-zero") exit() ################ get number of queues ##################### @@ -188,7 +188,7 @@ def print_result(b): rx_num = 0 path = ROOT_PATH + "/" + dev_name + "/queues" if not os.path.exists(path): - print "Net interface", dev_name, "does not exits." + print ("Net interface", dev_name, "does not exits.") exit() list = os.listdir(path) @@ -199,7 +199,7 @@ def print_result(b): tx_num += 1 if tx_num > MAX_QUEUE_NUM or rx_num > MAX_QUEUE_NUM: - print "number of queues over 1024 is not supported." + print ("number of queues over 1024 is not supported.") exit() ################## start tracing ################## @@ -207,7 +207,7 @@ def print_result(b): # --------- set hash array -------- devname_map = b['name_map'] _name = Devname() -_name.name = dev_name +_name.name = dev_name.encode() devname_map[0] = _name while 1: diff --git a/tools/tcprtt.py b/tools/tcprtt.py index 155ccffb2..0b3b3aa44 100755 --- a/tools/tcprtt.py +++ b/tools/tcprtt.py @@ -111,35 +111,35 @@ # filter for local port if args.lport: - bpf_text = bpf_text.replace(b'LPORTFILTER', - b"""if (ntohs(sport) != %d) + bpf_text = bpf_text.replace('LPORTFILTER', + """if (ntohs(sport) != %d) return 0;""" % int(args.lport)) else: - bpf_text = bpf_text.replace(b'LPORTFILTER', b'') + bpf_text = bpf_text.replace('LPORTFILTER', '') # filter for remote port if args.rport: - bpf_text = bpf_text.replace(b'RPORTFILTER', - b"""if (ntohs(dport) != %d) + bpf_text = bpf_text.replace('RPORTFILTER', + """if (ntohs(dport) != %d) return 0;""" % int(args.rport)) else: - bpf_text = bpf_text.replace(b'RPORTFILTER', b'') + bpf_text = bpf_text.replace('RPORTFILTER', '') # filter for local address if args.laddr: - bpf_text = bpf_text.replace(b'LADDRFILTER', - b"""if (saddr != %d) + bpf_text = bpf_text.replace('LADDRFILTER', + """if (saddr != %d) return 0;""" % struct.unpack("=I", socket.inet_aton(args.laddr))[0]) else: - bpf_text = bpf_text.replace(b'LADDRFILTER', b'') + bpf_text = bpf_text.replace('LADDRFILTER', '') # filter for remote address if args.raddr: - bpf_text = bpf_text.replace(b'RADDRFILTER', - b"""if (daddr != %d) + bpf_text = bpf_text.replace('RADDRFILTER', + """if (daddr != %d) return 0;""" % struct.unpack("=I", socket.inet_aton(args.raddr))[0]) else: - bpf_text = bpf_text.replace(b'RADDRFILTER', b'') + bpf_text = bpf_text.replace('RADDRFILTER', '') # show msecs or usecs[default] if args.milliseconds: From ec3747ed6b16f9eec36a204dfbe3506d3778dcb4 Mon Sep 17 00:00:00 2001 From: Hao <1075808668@qq.com> Date: Mon, 19 Oct 2020 22:21:10 +0800 Subject: [PATCH 271/278] fix netqtop python3 compatible (#3140) * fix netqtop python3 compatible * delete import types --- tools/netqtop.py | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/tools/netqtop.py b/tools/netqtop.py index dbe9206a0..47e9103e4 100755 --- a/tools/netqtop.py +++ b/tools/netqtop.py @@ -1,11 +1,11 @@ #!/usr/bin/python +from __future__ import print_function from bcc import BPF from ctypes import * import argparse import os from time import sleep,time,localtime,asctime -import types # pre defines ------------------------------- ROOT_PATH = "/sys/class/net" @@ -28,7 +28,7 @@ def to_str(num): elif num > 1000: return str(round(num/1024.0, 2)) + 'K' else: - if type(num) == types.FloatType: + if isinstance(num, float): return str(round(num, 2)) else: return str(num) @@ -50,9 +50,10 @@ def print_table(table, qnum): headers.append("BPS") headers.append("PPS") + print(" ", end="") for hd in headers: - print(hd.center(COL_WIDTH)) - print + print( "%-11s" % hd, end="") + print() # ------- calculates -------------- qids=[] @@ -97,7 +98,7 @@ def print_table(table, qnum): avg = 0 if data[2] != 0: avg = data[1] / data[2] - print("%5d %11s %10s %10s %10s %10s %10s" % ( + print(" %-11d%-11s%-11s%-11s%-11s%-11s%-11s" % ( data[0], to_str(avg), to_str(data[3]), @@ -105,34 +106,34 @@ def print_table(table, qnum): to_str(data[5]), to_str(data[6]), to_str(data[7]) - )), + ), end="") if args.throughput: BPS = data[1] / print_interval PPS = data[2] / print_interval - print("%10s %10s" % ( + print("%-11s%-11s" % ( to_str(BPS), to_str(PPS) )) else: - print + print() # ------- print total -------------- - print(" Total %10s %10s %10s %10s %10s %10s" % ( + print(" Total %-11s%-11s%-11s%-11s%-11s%-11s" % ( to_str(tAVG), to_str(tGroup[0]), to_str(tGroup[1]), to_str(tGroup[2]), to_str(tGroup[3]), to_str(tGroup[4]) - )), + ), end="") if args.throughput: - print("%10s %10s" % ( + print("%-11s%-11s" % ( to_str(tBPS), to_str(tPPS) )) else: - print + print() def print_result(b): @@ -152,7 +153,7 @@ def print_result(b): if args.throughput: print("-"*95) else: - print("-"*76) + print("-"*77) ############## specify network interface ################# parser = argparse.ArgumentParser(description="") From d4aecc6555688911a8b950d99c430e96ef369576 Mon Sep 17 00:00:00 2001 From: Dale Hamel <dale.hamel@shopify.com> Date: Mon, 19 Oct 2020 10:24:04 -0400 Subject: [PATCH 272/278] Refactor docker image publishing This adds support to push docker images to quay.io, like other projects in the iovisor org. It separates docker image builds into a separate github workflow, and refactors the package building process slightly, to be generic, in order to create builds for both ubuntu 16.04 and ubuntu 18.04. This provides a means to distribute intermediate apt packages between releases, and also enables uploading these as CI artifacts. As recent releases have not annotated their tags, it drops the requirement for tags to be annotated in selecting the version to use. --- .github/workflows/bcc-test.yml | 35 ------------ .github/workflows/publish.yml | 101 +++++++++++++++++++++++++++++++++ .gitignore | 4 ++ Dockerfile.ubuntu | 12 ++-- scripts/build-deb.sh | 2 +- scripts/docker/auth.sh | 19 +++++++ scripts/docker/build.sh | 27 +++++++++ scripts/docker/push.sh | 64 +++++++++++++++++++++ scripts/git-tag.sh | 2 +- 9 files changed, 225 insertions(+), 41 deletions(-) create mode 100644 .github/workflows/publish.yml create mode 100755 scripts/docker/auth.sh create mode 100755 scripts/docker/build.sh create mode 100755 scripts/docker/push.sh diff --git a/.github/workflows/bcc-test.yml b/.github/workflows/bcc-test.yml index 1a72ff541..4907e2941 100644 --- a/.github/workflows/bcc-test.yml +++ b/.github/workflows/bcc-test.yml @@ -92,38 +92,3 @@ jobs: # https://github.com/marketplace/actions/debugging-with-tmate # - name: Setup tmate session # uses: mxschmitt/action-tmate@v1 - - # Optionally publish container images, guarded by the GitHub secret - # DOCKER_PUBLISH. - # GitHub secrets can be configured as follows: - # - DOCKER_PUBLISH = 1 - # - DOCKER_IMAGE = docker.io/myorg/bcc - # - DOCKER_USERNAME = username - # - DOCKER_PASSWORD = password - publish: - name: Publish - runs-on: ubuntu-latest - steps: - - - uses: actions/checkout@v1 - - - name: Initialize workflow variables - id: vars - shell: bash - run: | - echo ::set-output name=DOCKER_PUBLISH::${DOCKER_PUBLISH} - env: - DOCKER_PUBLISH: "${{ secrets.DOCKER_PUBLISH }}" - - - name: Build container image and publish to registry - id: publish-registry - uses: elgohr/Publish-Docker-Github-Action@2.8 - if: ${{ steps.vars.outputs.DOCKER_PUBLISH }} - with: - name: ${{ secrets.DOCKER_IMAGE }} - username: ${{ secrets.DOCKER_USERNAME }} - password: ${{ secrets.DOCKER_PASSWORD }} - workdir: . - dockerfile: Dockerfile.ubuntu - snapshot: true - cache: ${{ github.event_name != 'schedule' }} diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 000000000..3021a9594 --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,101 @@ +name: Publish Build Artifacts + +on: push + +jobs: + publish_images: + # Optionally publish container images, guarded by the GitHub secret + # QUAY_PUBLISH. + # To set this up, sign up for quay.io (you can connect it to your github) + # then create a robot user with write access user called "bcc_buildbot", + # and add the secret token for it to GitHub secrets as: + # - QUAY_TOKEN = <token from quay.io> + name: Publish to quay.io + runs-on: ubuntu-latest + strategy: + matrix: + env: + - NAME: xenial-release + OS_RELEASE: 16.04 + - NAME: bionic-release + OS_RELEASE: 18.04 + steps: + + - uses: actions/checkout@v1 + + - name: Initialize workflow variables + id: vars + shell: bash + run: | + if [ -n "${QUAY_TOKEN}" ];then + echo "Quay token is set, will push an image" + echo ::set-output name=QUAY_PUBLISH::true + else + echo "Quay token not set, skipping" + fi + + env: + QUAY_TOKEN: ${{ secrets.QUAY_TOKEN }} + + - name: Authenticate with quay.io docker registry + if: > + steps.vars.outputs.QUAY_PUBLISH + env: + QUAY_TOKEN: ${{ secrets.QUAY_TOKEN }} + run: ./scripts/docker/auth.sh ${{ github.repository }} + + - name: Package docker image and push to quay.io + if: > + steps.vars.outputs.QUAY_PUBLISH + run: > + ./scripts/docker/push.sh + ${{ github.repository }} + ${{ github.ref }} + ${{ github.sha }} + ${{ matrix.env['NAME'] }} + ${{ matrix.env['OS_RELEASE'] }} + + # Uploads the packages built in docker to the github build as an artifact for convenience + - uses: actions/upload-artifact@v1 + with: + name: ${{ matrix.env['NAME'] }} + path: output + + # Optionally publish container images to custom docker repository, + # guarded by presence of all required github secrets. + # GitHub secrets can be configured as follows: + # - DOCKER_IMAGE = docker.io/myorg/bcc + # - DOCKER_USERNAME = username + # - DOCKER_PASSWORD = password + publish_dockerhub: + name: Publish To Dockerhub + runs-on: ubuntu-latest + steps: + + - uses: actions/checkout@v1 + + - name: Initialize workflow variables + id: vars + shell: bash + run: | + if [ -n "${DOCKER_IMAGE}" ] && \ + [ -n "${DOCKER_USERNAME}" ] && \ + [ -n "${DOCKER_PASSWORD}" ];then + echo "Custom docker credentials set, will push an image" + echo ::set-output name=DOCKER_PUBLISH::true + else + echo "Custom docker credentials not, skipping" + fi + + - name: Build container image and publish to registry + id: publish-registry + uses: elgohr/Publish-Docker-Github-Action@2.8 + if: ${{ steps.vars.outputs.DOCKER_PUBLISH }} + with: + name: ${{ secrets.DOCKER_IMAGE }} + username: ${{ secrets.DOCKER_USERNAME }} + password: ${{ secrets.DOCKER_PASSWORD }} + workdir: . + dockerfile: Dockerfile.ubuntu + snapshot: true + cache: ${{ github.event_name != 'schedule' }} diff --git a/.gitignore b/.gitignore index 14994d761..18a6f5a74 100644 --- a/.gitignore +++ b/.gitignore @@ -12,3 +12,7 @@ debian/**/*.log *critical.log obj-x86_64-linux-gnu examples/cgroupid/cgroupid + +# Output from docker builds +scripts/docker/output/ +/output/ diff --git a/Dockerfile.ubuntu b/Dockerfile.ubuntu index a2582cd91..1aeb84182 100644 --- a/Dockerfile.ubuntu +++ b/Dockerfile.ubuntu @@ -1,4 +1,9 @@ -FROM ubuntu:bionic as builder +ARG OS_TAG=18.04 +FROM ubuntu:${OS_TAG} as builder + +ARG OS_TAG +ARG BUILD_TYPE=release +ARG DEBIAN_FRONTEND=noninteractive MAINTAINER Brenden Blanco <bblanco@gmail.com> @@ -10,10 +15,9 @@ COPY ./ /root/bcc WORKDIR /root/bcc RUN /usr/lib/pbuilder/pbuilder-satisfydepends && \ - ./scripts/build-deb.sh - + ./scripts/build-deb.sh ${BUILD_TYPE} -FROM ubuntu:bionic +FROM ubuntu:${OS_TAG} COPY --from=builder /root/bcc/*.deb /root/bcc/ diff --git a/scripts/build-deb.sh b/scripts/build-deb.sh index 1e450b664..2fe7e3bc1 100755 --- a/scripts/build-deb.sh +++ b/scripts/build-deb.sh @@ -1,6 +1,6 @@ #!/bin/bash -# helper script to be invoked by jenkins/buildbot +# helper script to be invoked by jenkins/buildbot or github actions # $1 [optional]: the build type - release | nightly | test buildtype=${1:-test} diff --git a/scripts/docker/auth.sh b/scripts/docker/auth.sh new file mode 100755 index 000000000..a4166be4d --- /dev/null +++ b/scripts/docker/auth.sh @@ -0,0 +1,19 @@ +#!/bin/bash +set -e + +# For now only quay.io is supported, but this could be portable to dockerhub +# and other image repositories. + +# Forks can push using this approach if they create a quay.io bot user +# with name matching of ORGNAME+bcc_buildbot, or by setting QUAY_BOT_NAME + +git_repo=$1 # github.repository format: ORGNAME/REPONAME + +# Set this value as QUAY_TOKEN in the github repository settings "Secrets" tab +[[ -z "${QUAY_TOKEN}" ]] && echo "QUAY_TOKEN not set" && exit 0 + +# Set this to match the name of the bot user on quay.io +[[ -z "${QUAY_BOT_NAME}" ]] && QUAY_BOT_NAME="bcc_buildbot" + +quay_user="$(dirname ${git_repo})+${QUAY_BOT_NAME}" +echo "${QUAY_TOKEN}" | docker login -u="${quay_user}" --password-stdin quay.io diff --git a/scripts/docker/build.sh b/scripts/docker/build.sh new file mode 100755 index 000000000..728ef6d97 --- /dev/null +++ b/scripts/docker/build.sh @@ -0,0 +1,27 @@ +#!/bin/bash + +# Builds debian packages using docker wrapper + +function help() { + message=$1 + echo "USAGE: build.sh DOCKER_REPO DOCKER_TAG OS_TAG [DISTRO]" + echo "hint: ${message}" +} + +docker_repo=$1 +docker_tag=$2 +os_tag=$3 +distro=${4:-ubuntu} + +[ -z "${docker_repo}" ] && help "You must specify repo, eg: quay.io/iovisoc/bcc" && exit 1 +[ -z "${docker_tag}" ] && help "You must specify tag, eg: bionic-release-master, latest, SHA, git tag, etc " && exit 1 +[ -z "${os_tag}" ] && help "You must specify os tag, eg: 18.04, bionic, etc " && exit 1 + + +# The main docker image build, +echo "Building ${distro} ${os_tag} release docker image for ${docker_repo}:${docker_tag}" +docker build -t ${docker_repo}:${docker_tag} --build-arg OS_TAG=${os_tag} -f Dockerfile.${distro} . + +echo "Copying build artifacts to $(pwd)/output" +mkdir output +docker run -v $(pwd)/output:/output ${docker_repo}:${docker_tag} /bin/bash -c "cp /root/bcc/* /output" diff --git a/scripts/docker/push.sh b/scripts/docker/push.sh new file mode 100755 index 000000000..8a485263e --- /dev/null +++ b/scripts/docker/push.sh @@ -0,0 +1,64 @@ +#!/bin/bash +set -e + +# Push docker tags to a configured docker repo, defaulting to quay.io +# You must run login.sh before running this script. + +DEFAULT_DOCKER_REPO="quay.io" +DEFAULT_RELEASE_TARGET="bionic-release" # will allow unprefixed tags + +# Currently only support pushing to quay.io +DOCKER_REPO=${DEFAULT_DOCKER_REPO} + +git_repo=$1 # github.repository format: ORGNAME/REPONAME +git_ref=$2 # github.ref format: refs/REMOTE/REF + # eg, refs/heads/BRANCH + # refs/tags/v0.9.6-pre +git_sha=$3 # github.sha GIT_SHA +type_name=$4 # build name, s/+/_/g eg, bionic-release +os_tag=${5:-18.04} # numeric docker tag eg, 18.04 + +# refname will be either a branch like "master" or "some-branch", +# or a tag, like "v1.17.0-pre". +# When a tag is pushed, a build is done for both the branch and the tag, as +# separate builds. +# This is a feature specific to github actions based on the `github.ref` object +refname=$(basename ${git_ref}) + +# The build type needs to be sanitized into a valid tag, replacing + with _ +type_tag="$(echo ${type_name} | sed 's/+/_/g')" + + +echo "Triggering image build" +SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" +${SCRIPT_DIR}/build.sh ${DOCKER_REPO}/${git_repo} ${git_sha}-${type_tag} ${os_tag} + +echo "Upload image for git sha ${git_sha} to ${DOCKER_REPO}/${git_repo}" +docker push ${DOCKER_REPO}/${git_repo}:${git_sha}-${type_tag} + +echo "Push tags to branch or git tag HEAD refs" +docker tag ${DOCKER_REPO}/${git_repo}:${git_sha}-${type_tag} ${DOCKER_REPO}/${git_repo}:${refname}-${type_tag} +docker push ${DOCKER_REPO}/${git_repo}:${refname}-${type_tag} + +# Only push to un-suffixed tags for the default release target build type +if [[ "${type_name}" == "${DEFAULT_RELEASE_TARGET}"* ]];then + + # Update branch / git tag ref + echo "Pushing tags for ${DOCKER_REPO}/${git_repo}:${refname}" + docker tag ${DOCKER_REPO}/${git_repo}:${git_sha}-${type_tag} ${DOCKER_REPO}/${git_repo}:${refname} + docker push ${DOCKER_REPO}/${git_repo}:${refname} + + if [[ "${refname}" == "master" ]];then + if [[ "${edge}" == "ON" ]];then + echo "This is an edge build on master, pushing ${DOCKER_REPO}/${git_repo}:edge" + docker tag ${DOCKER_REPO}/${git_repo}:${git_sha}-${type_tag} ${DOCKER_REPO}/${git_repo}:edge + docker push ${DOCKER_REPO}/${git_repo}:edge + else + echo "This is a build on master, pushing ${DOCKER_REPO}/${git_repo}:latest :SHA as well" + docker tag ${DOCKER_REPO}/${git_repo}:${git_sha}-${type_tag} ${DOCKER_REPO}/${git_repo}:latest + docker tag ${DOCKER_REPO}/${git_repo}:${git_sha}-${type_tag} ${DOCKER_REPO}/${git_repo}:${git_sha} + docker push ${DOCKER_REPO}/${git_repo}:latest + docker push ${DOCKER_REPO}/${git_repo}:${git_sha} + fi + fi +fi diff --git a/scripts/git-tag.sh b/scripts/git-tag.sh index 073b4a175..5aef730d5 100644 --- a/scripts/git-tag.sh +++ b/scripts/git-tag.sh @@ -1,4 +1,4 @@ -git_tag_latest=$(git describe --abbrev=0) +git_tag_latest=$(git describe --tags --abbrev=0) git_rev_count=$(git rev-list $git_tag_latest.. --count) git_rev_count=$[$git_rev_count+1] git_subject=$(git log --pretty="%s" -n 1) From 20b098ae9d7ad2bcf5cbfb49202012848257b73d Mon Sep 17 00:00:00 2001 From: Dale Hamel <dale.hamel@shopify.com> Date: Mon, 19 Oct 2020 10:27:06 -0400 Subject: [PATCH 273/278] Add ubuntu 20.04 build support --- .github/workflows/publish.yml | 2 ++ debian/control | 10 +++++----- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 3021a9594..03cb60f8c 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -19,6 +19,8 @@ jobs: OS_RELEASE: 16.04 - NAME: bionic-release OS_RELEASE: 18.04 + - NAME: focal-release + OS_RELEASE: 20.04 steps: - uses: actions/checkout@v1 diff --git a/debian/control b/debian/control index 272b9b965..77180ded3 100644 --- a/debian/control +++ b/debian/control @@ -4,12 +4,12 @@ Section: misc Priority: optional Standards-Version: 3.9.5 Build-Depends: debhelper (>= 9), cmake, - libllvm3.7 [!arm64] | libllvm3.8 [!arm64] | libllvm6.0, - llvm-3.7-dev [!arm64] | llvm-3.8-dev [!arm64] | llvm-6.0-dev, - libclang-3.7-dev [!arm64] | libclang-3.8-dev [!arm64] | libclang-6.0-dev, - clang-format | clang-format-3.7 [!arm64] | clang-format-3.8 [!arm64] | clang-format-6.0, + libllvm3.7 [!arm64] | libllvm3.8 [!arm64] | libllvm6.0 | libllvm8.0 | libllvm9, + llvm-3.7-dev [!arm64] | llvm-3.8-dev [!arm64] | llvm-6.0-dev | llvm-8.0-dev | llvm-9-dev, + libclang-3.7-dev [!arm64] | libclang-3.8-dev [!arm64] | libclang-6.0-dev | libclang-8.0-dev | libclang-9-dev, + clang-format | clang-format-3.7 [!arm64] | clang-format-3.8 [!arm64] | clang-format-6.0 | clang-format-8.0 | clang-format-9, libelf-dev, bison, flex, libfl-dev, libedit-dev, zlib1g-dev, git, - python (>= 2.7), python-netaddr, python-pyroute2, luajit, + python (>= 2.7), python-netaddr, python-pyroute2 | python3-pyroute2, luajit, libluajit-5.1-dev, arping, inetutils-ping | iputils-ping, iperf, netperf, ethtool, devscripts, python3, dh-python Homepage: https://github.com/iovisor/bcc From d35a2dc38514f4a0235f957606ab825c97d651eb Mon Sep 17 00:00:00 2001 From: Dale Hamel <dale.hamel@srvthe.net> Date: Wed, 21 Oct 2020 02:17:57 -0400 Subject: [PATCH 274/278] Guard artifact upload with environment variable --- .github/workflows/publish.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 03cb60f8c..6bd81a350 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -59,6 +59,8 @@ jobs: # Uploads the packages built in docker to the github build as an artifact for convenience - uses: actions/upload-artifact@v1 + if: > + steps.vars.outputs.QUAY_PUBLISH with: name: ${{ matrix.env['NAME'] }} path: output From 9269e48712d754b1e0ea91dc2fc21b6e9127c4e6 Mon Sep 17 00:00:00 2001 From: Dale Hamel <dale.hamel@shopify.com> Date: Wed, 21 Oct 2020 13:12:27 -0400 Subject: [PATCH 275/278] Prefer newer llvm/clang versions in debian packaging --- debian/control | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/debian/control b/debian/control index 77180ded3..bb799173a 100644 --- a/debian/control +++ b/debian/control @@ -4,10 +4,10 @@ Section: misc Priority: optional Standards-Version: 3.9.5 Build-Depends: debhelper (>= 9), cmake, - libllvm3.7 [!arm64] | libllvm3.8 [!arm64] | libllvm6.0 | libllvm8.0 | libllvm9, - llvm-3.7-dev [!arm64] | llvm-3.8-dev [!arm64] | llvm-6.0-dev | llvm-8.0-dev | llvm-9-dev, - libclang-3.7-dev [!arm64] | libclang-3.8-dev [!arm64] | libclang-6.0-dev | libclang-8.0-dev | libclang-9-dev, - clang-format | clang-format-3.7 [!arm64] | clang-format-3.8 [!arm64] | clang-format-6.0 | clang-format-8.0 | clang-format-9, + libllvm9 | libllvm8.0 | libllvm6.0 | libllvm3.8 [!arm64] | libllvm3.7 [!arm64], + llvm-9-dev | llvm-8.0-dev | llvm-6.0-dev | llvm-3.8-dev [!arm64] | llvm-3.7-dev [!arm64], + libclang-9-dev | libclang-8.0-dev | libclang-6.0-dev | libclang-3.8-dev [!arm64] | libclang-3.7-dev [!arm64], + clang-format-9 | clang-format-8.0 | clang-format-6.0 | clang-format-3.8 [!arm64] | clang-format-3.7 [!arm64] | clang-format, libelf-dev, bison, flex, libfl-dev, libedit-dev, zlib1g-dev, git, python (>= 2.7), python-netaddr, python-pyroute2 | python3-pyroute2, luajit, libluajit-5.1-dev, arping, inetutils-ping | iputils-ping, iperf, netperf, From 4967a61ddaf032f4d0bd5ee73360bff400f447e5 Mon Sep 17 00:00:00 2001 From: Dale Hamel <dale.hamel@shopify.com> Date: Wed, 21 Oct 2020 14:43:52 -0400 Subject: [PATCH 276/278] Do not permit errors in docker build --- scripts/docker/build.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/docker/build.sh b/scripts/docker/build.sh index 728ef6d97..e2952c337 100755 --- a/scripts/docker/build.sh +++ b/scripts/docker/build.sh @@ -1,5 +1,5 @@ #!/bin/bash - +set -e # Builds debian packages using docker wrapper function help() { @@ -23,5 +23,5 @@ echo "Building ${distro} ${os_tag} release docker image for ${docker_repo}:${doc docker build -t ${docker_repo}:${docker_tag} --build-arg OS_TAG=${os_tag} -f Dockerfile.${distro} . echo "Copying build artifacts to $(pwd)/output" -mkdir output +mkdir -p output docker run -v $(pwd)/output:/output ${docker_repo}:${docker_tag} /bin/bash -c "cp /root/bcc/* /output" From 48946d2f31afbfb7b4bc7c62a9d3d6f1d2ffc330 Mon Sep 17 00:00:00 2001 From: Lorenzo Saino <lsaino@fastly.com> Date: Thu, 22 Oct 2020 00:57:29 +0100 Subject: [PATCH 277/278] python: import ABCs from collections.abc Importing Abstract Base Classes (ABCs) from the collections module is deprecated since Python 3.3, it emits a warning since Python 3.8, and it will stop working in Python 3.10. Try importing MutableMapping from collections.abc (the preferred way since Python 3.3) and, in case of error (Python < 3.3) fall back to importing it from collections. --- src/python/bcc/table.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/python/bcc/table.py b/src/python/bcc/table.py index 1a283e8a4..98a91febd 100644 --- a/src/python/bcc/table.py +++ b/src/python/bcc/table.py @@ -13,7 +13,10 @@ # limitations under the License. from __future__ import print_function -from collections import MutableMapping +try: + from collections.abc import MutableMapping +except ImportError: + from collections import MutableMapping import ctypes as ct from functools import reduce import multiprocessing From d37492af897d788e5439cb640f70722c03070bde Mon Sep 17 00:00:00 2001 From: Pavel Zakharov <pavel.zakharov@delphix.com> Date: Wed, 28 Oct 2020 16:42:36 -0400 Subject: [PATCH 278/278] disable unwanted publish.yml workflow --- .github/{workflows => disabled-workflows}/publish.yml | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename .github/{workflows => disabled-workflows}/publish.yml (100%) diff --git a/.github/workflows/publish.yml b/.github/disabled-workflows/publish.yml similarity index 100% rename from .github/workflows/publish.yml rename to .github/disabled-workflows/publish.yml