forked from Qortal/Brooklyn
2a709f28fa
* 0day explit mitigation * Memory corruption prevention * Privilege escalation prevention * Buffer over flow prevention * File System corruption defense * Thread escape prevention This may very well be the most intensive inclusion to BrooklynR. This will not be part of an x86 suite nor it will be released as tool kit. The security core toolkit will remain part of kernel base.
626 lines
17 KiB
C
626 lines
17 KiB
C
/* AF_RXRPC tracepoints
|
|
*
|
|
* Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public Licence
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the Licence, or (at your option) any later version.
|
|
*/
|
|
#undef TRACE_SYSTEM
|
|
#define TRACE_SYSTEM rxrpc
|
|
|
|
#if !defined(_TRACE_RXRPC_H) || defined(TRACE_HEADER_MULTI_READ)
|
|
#define _TRACE_RXRPC_H
|
|
|
|
#include <linux/tracepoint.h>
|
|
|
|
TRACE_EVENT(rxrpc_conn,
|
|
TP_PROTO(struct rxrpc_connection *conn, enum rxrpc_conn_trace op,
|
|
int usage, const void *where),
|
|
|
|
TP_ARGS(conn, op, usage, where),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_connection *, conn )
|
|
__field(int, op )
|
|
__field(int, usage )
|
|
__field(const void *, where )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->conn = conn;
|
|
__entry->op = op;
|
|
__entry->usage = usage;
|
|
__entry->where = where;
|
|
),
|
|
|
|
TP_printk("C=%p %s u=%d sp=%pSR",
|
|
__entry->conn,
|
|
rxrpc_conn_traces[__entry->op],
|
|
__entry->usage,
|
|
__entry->where)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_client,
|
|
TP_PROTO(struct rxrpc_connection *conn, int channel,
|
|
enum rxrpc_client_trace op),
|
|
|
|
TP_ARGS(conn, channel, op),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_connection *, conn )
|
|
__field(u32, cid )
|
|
__field(int, channel )
|
|
__field(int, usage )
|
|
__field(enum rxrpc_client_trace, op )
|
|
__field(enum rxrpc_conn_cache_state, cs )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->conn = conn;
|
|
__entry->channel = channel;
|
|
__entry->usage = atomic_read(&conn->usage);
|
|
__entry->op = op;
|
|
__entry->cid = conn->proto.cid;
|
|
__entry->cs = conn->cache_state;
|
|
),
|
|
|
|
TP_printk("C=%p h=%2d %s %s i=%08x u=%d",
|
|
__entry->conn,
|
|
__entry->channel,
|
|
rxrpc_client_traces[__entry->op],
|
|
rxrpc_conn_cache_states[__entry->cs],
|
|
__entry->cid,
|
|
__entry->usage)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_call,
|
|
TP_PROTO(struct rxrpc_call *call, enum rxrpc_call_trace op,
|
|
int usage, const void *where, const void *aux),
|
|
|
|
TP_ARGS(call, op, usage, where, aux),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(int, op )
|
|
__field(int, usage )
|
|
__field(const void *, where )
|
|
__field(const void *, aux )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->op = op;
|
|
__entry->usage = usage;
|
|
__entry->where = where;
|
|
__entry->aux = aux;
|
|
),
|
|
|
|
TP_printk("c=%p %s u=%d sp=%pSR a=%p",
|
|
__entry->call,
|
|
rxrpc_call_traces[__entry->op],
|
|
__entry->usage,
|
|
__entry->where,
|
|
__entry->aux)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_skb,
|
|
TP_PROTO(struct sk_buff *skb, enum rxrpc_skb_trace op,
|
|
int usage, int mod_count, const void *where),
|
|
|
|
TP_ARGS(skb, op, usage, mod_count, where),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct sk_buff *, skb )
|
|
__field(enum rxrpc_skb_trace, op )
|
|
__field(int, usage )
|
|
__field(int, mod_count )
|
|
__field(const void *, where )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->skb = skb;
|
|
__entry->op = op;
|
|
__entry->usage = usage;
|
|
__entry->mod_count = mod_count;
|
|
__entry->where = where;
|
|
),
|
|
|
|
TP_printk("s=%p %s u=%d m=%d p=%pSR",
|
|
__entry->skb,
|
|
rxrpc_skb_traces[__entry->op],
|
|
__entry->usage,
|
|
__entry->mod_count,
|
|
__entry->where)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_rx_packet,
|
|
TP_PROTO(struct rxrpc_skb_priv *sp),
|
|
|
|
TP_ARGS(sp),
|
|
|
|
TP_STRUCT__entry(
|
|
__field_struct(struct rxrpc_host_header, hdr )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(&__entry->hdr, &sp->hdr, sizeof(__entry->hdr));
|
|
),
|
|
|
|
TP_printk("%08x:%08x:%08x:%04x %08x %08x %02x %02x %s",
|
|
__entry->hdr.epoch, __entry->hdr.cid,
|
|
__entry->hdr.callNumber, __entry->hdr.serviceId,
|
|
__entry->hdr.serial, __entry->hdr.seq,
|
|
__entry->hdr.type, __entry->hdr.flags,
|
|
__entry->hdr.type <= 15 ? rxrpc_pkts[__entry->hdr.type] : "?UNK")
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_rx_done,
|
|
TP_PROTO(int result, int abort_code),
|
|
|
|
TP_ARGS(result, abort_code),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(int, result )
|
|
__field(int, abort_code )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->result = result;
|
|
__entry->abort_code = abort_code;
|
|
),
|
|
|
|
TP_printk("r=%d a=%d", __entry->result, __entry->abort_code)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_abort,
|
|
TP_PROTO(const char *why, u32 cid, u32 call_id, rxrpc_seq_t seq,
|
|
int abort_code, int error),
|
|
|
|
TP_ARGS(why, cid, call_id, seq, abort_code, error),
|
|
|
|
TP_STRUCT__entry(
|
|
__array(char, why, 4 )
|
|
__field(u32, cid )
|
|
__field(u32, call_id )
|
|
__field(rxrpc_seq_t, seq )
|
|
__field(int, abort_code )
|
|
__field(int, error )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(__entry->why, why, 4);
|
|
__entry->cid = cid;
|
|
__entry->call_id = call_id;
|
|
__entry->abort_code = abort_code;
|
|
__entry->error = error;
|
|
__entry->seq = seq;
|
|
),
|
|
|
|
TP_printk("%08x:%08x s=%u a=%d e=%d %s",
|
|
__entry->cid, __entry->call_id, __entry->seq,
|
|
__entry->abort_code, __entry->error, __entry->why)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_transmit,
|
|
TP_PROTO(struct rxrpc_call *call, enum rxrpc_transmit_trace why),
|
|
|
|
TP_ARGS(call, why),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(enum rxrpc_transmit_trace, why )
|
|
__field(rxrpc_seq_t, tx_hard_ack )
|
|
__field(rxrpc_seq_t, tx_top )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->why = why;
|
|
__entry->tx_hard_ack = call->tx_hard_ack;
|
|
__entry->tx_top = call->tx_top;
|
|
),
|
|
|
|
TP_printk("c=%p %s f=%08x n=%u",
|
|
__entry->call,
|
|
rxrpc_transmit_traces[__entry->why],
|
|
__entry->tx_hard_ack + 1,
|
|
__entry->tx_top - __entry->tx_hard_ack)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_rx_ack,
|
|
TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t first, u8 reason, u8 n_acks),
|
|
|
|
TP_ARGS(call, first, reason, n_acks),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(rxrpc_seq_t, first )
|
|
__field(u8, reason )
|
|
__field(u8, n_acks )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->first = first;
|
|
__entry->reason = reason;
|
|
__entry->n_acks = n_acks;
|
|
),
|
|
|
|
TP_printk("c=%p %s f=%08x n=%u",
|
|
__entry->call,
|
|
rxrpc_ack_names[__entry->reason],
|
|
__entry->first,
|
|
__entry->n_acks)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_tx_data,
|
|
TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t seq,
|
|
rxrpc_serial_t serial, u8 flags, bool retrans, bool lose),
|
|
|
|
TP_ARGS(call, seq, serial, flags, retrans, lose),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(rxrpc_seq_t, seq )
|
|
__field(rxrpc_serial_t, serial )
|
|
__field(u8, flags )
|
|
__field(bool, retrans )
|
|
__field(bool, lose )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->seq = seq;
|
|
__entry->serial = serial;
|
|
__entry->flags = flags;
|
|
__entry->retrans = retrans;
|
|
__entry->lose = lose;
|
|
),
|
|
|
|
TP_printk("c=%p DATA %08x q=%08x fl=%02x%s%s",
|
|
__entry->call,
|
|
__entry->serial,
|
|
__entry->seq,
|
|
__entry->flags,
|
|
__entry->retrans ? " *RETRANS*" : "",
|
|
__entry->lose ? " *LOSE*" : "")
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_tx_ack,
|
|
TP_PROTO(struct rxrpc_call *call, rxrpc_serial_t serial,
|
|
rxrpc_seq_t ack_first, rxrpc_serial_t ack_serial,
|
|
u8 reason, u8 n_acks),
|
|
|
|
TP_ARGS(call, serial, ack_first, ack_serial, reason, n_acks),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(rxrpc_serial_t, serial )
|
|
__field(rxrpc_seq_t, ack_first )
|
|
__field(rxrpc_serial_t, ack_serial )
|
|
__field(u8, reason )
|
|
__field(u8, n_acks )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->serial = serial;
|
|
__entry->ack_first = ack_first;
|
|
__entry->ack_serial = ack_serial;
|
|
__entry->reason = reason;
|
|
__entry->n_acks = n_acks;
|
|
),
|
|
|
|
TP_printk(" c=%p ACK %08x %s f=%08x r=%08x n=%u",
|
|
__entry->call,
|
|
__entry->serial,
|
|
rxrpc_ack_names[__entry->reason],
|
|
__entry->ack_first,
|
|
__entry->ack_serial,
|
|
__entry->n_acks)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_receive,
|
|
TP_PROTO(struct rxrpc_call *call, enum rxrpc_receive_trace why,
|
|
rxrpc_serial_t serial, rxrpc_seq_t seq),
|
|
|
|
TP_ARGS(call, why, serial, seq),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(enum rxrpc_receive_trace, why )
|
|
__field(rxrpc_serial_t, serial )
|
|
__field(rxrpc_seq_t, seq )
|
|
__field(rxrpc_seq_t, hard_ack )
|
|
__field(rxrpc_seq_t, top )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->why = why;
|
|
__entry->serial = serial;
|
|
__entry->seq = seq;
|
|
__entry->hard_ack = call->rx_hard_ack;
|
|
__entry->top = call->rx_top;
|
|
),
|
|
|
|
TP_printk("c=%p %s r=%08x q=%08x w=%08x-%08x",
|
|
__entry->call,
|
|
rxrpc_receive_traces[__entry->why],
|
|
__entry->serial,
|
|
__entry->seq,
|
|
__entry->hard_ack,
|
|
__entry->top)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_recvmsg,
|
|
TP_PROTO(struct rxrpc_call *call, enum rxrpc_recvmsg_trace why,
|
|
rxrpc_seq_t seq, unsigned int offset, unsigned int len,
|
|
int ret),
|
|
|
|
TP_ARGS(call, why, seq, offset, len, ret),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(enum rxrpc_recvmsg_trace, why )
|
|
__field(rxrpc_seq_t, seq )
|
|
__field(unsigned int, offset )
|
|
__field(unsigned int, len )
|
|
__field(int, ret )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->why = why;
|
|
__entry->seq = seq;
|
|
__entry->offset = offset;
|
|
__entry->len = len;
|
|
__entry->ret = ret;
|
|
),
|
|
|
|
TP_printk("c=%p %s q=%08x o=%u l=%u ret=%d",
|
|
__entry->call,
|
|
rxrpc_recvmsg_traces[__entry->why],
|
|
__entry->seq,
|
|
__entry->offset,
|
|
__entry->len,
|
|
__entry->ret)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_rtt_tx,
|
|
TP_PROTO(struct rxrpc_call *call, enum rxrpc_rtt_tx_trace why,
|
|
rxrpc_serial_t send_serial),
|
|
|
|
TP_ARGS(call, why, send_serial),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(enum rxrpc_rtt_tx_trace, why )
|
|
__field(rxrpc_serial_t, send_serial )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->why = why;
|
|
__entry->send_serial = send_serial;
|
|
),
|
|
|
|
TP_printk("c=%p %s sr=%08x",
|
|
__entry->call,
|
|
rxrpc_rtt_tx_traces[__entry->why],
|
|
__entry->send_serial)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_rtt_rx,
|
|
TP_PROTO(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why,
|
|
rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial,
|
|
s64 rtt, u8 nr, s64 avg),
|
|
|
|
TP_ARGS(call, why, send_serial, resp_serial, rtt, nr, avg),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(enum rxrpc_rtt_rx_trace, why )
|
|
__field(u8, nr )
|
|
__field(rxrpc_serial_t, send_serial )
|
|
__field(rxrpc_serial_t, resp_serial )
|
|
__field(s64, rtt )
|
|
__field(u64, avg )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->why = why;
|
|
__entry->send_serial = send_serial;
|
|
__entry->resp_serial = resp_serial;
|
|
__entry->rtt = rtt;
|
|
__entry->nr = nr;
|
|
__entry->avg = avg;
|
|
),
|
|
|
|
TP_printk("c=%p %s sr=%08x rr=%08x rtt=%lld nr=%u avg=%lld",
|
|
__entry->call,
|
|
rxrpc_rtt_rx_traces[__entry->why],
|
|
__entry->send_serial,
|
|
__entry->resp_serial,
|
|
__entry->rtt,
|
|
__entry->nr,
|
|
__entry->avg)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_timer,
|
|
TP_PROTO(struct rxrpc_call *call, enum rxrpc_timer_trace why,
|
|
ktime_t now, unsigned long now_j),
|
|
|
|
TP_ARGS(call, why, now, now_j),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(enum rxrpc_timer_trace, why )
|
|
__field_struct(ktime_t, now )
|
|
__field_struct(ktime_t, expire_at )
|
|
__field_struct(ktime_t, ack_at )
|
|
__field_struct(ktime_t, resend_at )
|
|
__field(unsigned long, now_j )
|
|
__field(unsigned long, timer )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->why = why;
|
|
__entry->now = now;
|
|
__entry->expire_at = call->expire_at;
|
|
__entry->ack_at = call->ack_at;
|
|
__entry->resend_at = call->resend_at;
|
|
__entry->now_j = now_j;
|
|
__entry->timer = call->timer.expires;
|
|
),
|
|
|
|
TP_printk("c=%p %s x=%lld a=%lld r=%lld t=%ld",
|
|
__entry->call,
|
|
rxrpc_timer_traces[__entry->why],
|
|
ktime_to_ns(ktime_sub(__entry->expire_at, __entry->now)),
|
|
ktime_to_ns(ktime_sub(__entry->ack_at, __entry->now)),
|
|
ktime_to_ns(ktime_sub(__entry->resend_at, __entry->now)),
|
|
__entry->timer - __entry->now_j)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_rx_lose,
|
|
TP_PROTO(struct rxrpc_skb_priv *sp),
|
|
|
|
TP_ARGS(sp),
|
|
|
|
TP_STRUCT__entry(
|
|
__field_struct(struct rxrpc_host_header, hdr )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
memcpy(&__entry->hdr, &sp->hdr, sizeof(__entry->hdr));
|
|
),
|
|
|
|
TP_printk("%08x:%08x:%08x:%04x %08x %08x %02x %02x %s *LOSE*",
|
|
__entry->hdr.epoch, __entry->hdr.cid,
|
|
__entry->hdr.callNumber, __entry->hdr.serviceId,
|
|
__entry->hdr.serial, __entry->hdr.seq,
|
|
__entry->hdr.type, __entry->hdr.flags,
|
|
__entry->hdr.type <= 15 ? rxrpc_pkts[__entry->hdr.type] : "?UNK")
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_propose_ack,
|
|
TP_PROTO(struct rxrpc_call *call, enum rxrpc_propose_ack_trace why,
|
|
u8 ack_reason, rxrpc_serial_t serial, bool immediate,
|
|
bool background, enum rxrpc_propose_ack_outcome outcome),
|
|
|
|
TP_ARGS(call, why, ack_reason, serial, immediate, background,
|
|
outcome),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(enum rxrpc_propose_ack_trace, why )
|
|
__field(rxrpc_serial_t, serial )
|
|
__field(u8, ack_reason )
|
|
__field(bool, immediate )
|
|
__field(bool, background )
|
|
__field(enum rxrpc_propose_ack_outcome, outcome )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->why = why;
|
|
__entry->serial = serial;
|
|
__entry->ack_reason = ack_reason;
|
|
__entry->immediate = immediate;
|
|
__entry->background = background;
|
|
__entry->outcome = outcome;
|
|
),
|
|
|
|
TP_printk("c=%p %s %s r=%08x i=%u b=%u%s",
|
|
__entry->call,
|
|
rxrpc_propose_ack_traces[__entry->why],
|
|
rxrpc_ack_names[__entry->ack_reason],
|
|
__entry->serial,
|
|
__entry->immediate,
|
|
__entry->background,
|
|
rxrpc_propose_ack_outcomes[__entry->outcome])
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_retransmit,
|
|
TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t seq, u8 annotation,
|
|
s64 expiry),
|
|
|
|
TP_ARGS(call, seq, annotation, expiry),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(rxrpc_seq_t, seq )
|
|
__field(u8, annotation )
|
|
__field(s64, expiry )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->seq = seq;
|
|
__entry->annotation = annotation;
|
|
__entry->expiry = expiry;
|
|
),
|
|
|
|
TP_printk("c=%p q=%x a=%02x xp=%lld",
|
|
__entry->call,
|
|
__entry->seq,
|
|
__entry->annotation,
|
|
__entry->expiry)
|
|
);
|
|
|
|
TRACE_EVENT(rxrpc_congest,
|
|
TP_PROTO(struct rxrpc_call *call, struct rxrpc_ack_summary *summary,
|
|
rxrpc_serial_t ack_serial, enum rxrpc_congest_change change),
|
|
|
|
TP_ARGS(call, summary, ack_serial, change),
|
|
|
|
TP_STRUCT__entry(
|
|
__field(struct rxrpc_call *, call )
|
|
__field(enum rxrpc_congest_change, change )
|
|
__field(rxrpc_seq_t, hard_ack )
|
|
__field(rxrpc_seq_t, top )
|
|
__field(rxrpc_seq_t, lowest_nak )
|
|
__field(rxrpc_serial_t, ack_serial )
|
|
__field_struct(struct rxrpc_ack_summary, sum )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->call = call;
|
|
__entry->change = change;
|
|
__entry->hard_ack = call->tx_hard_ack;
|
|
__entry->top = call->tx_top;
|
|
__entry->lowest_nak = call->acks_lowest_nak;
|
|
__entry->ack_serial = ack_serial;
|
|
memcpy(&__entry->sum, summary, sizeof(__entry->sum));
|
|
),
|
|
|
|
TP_printk("c=%p %08x %s %08x %s cw=%u ss=%u nr=%u,%u nw=%u,%u r=%u b=%u u=%u d=%u l=%x%s%s%s",
|
|
__entry->call,
|
|
__entry->ack_serial,
|
|
rxrpc_ack_names[__entry->sum.ack_reason],
|
|
__entry->hard_ack,
|
|
rxrpc_congest_modes[__entry->sum.mode],
|
|
__entry->sum.cwnd,
|
|
__entry->sum.ssthresh,
|
|
__entry->sum.nr_acks, __entry->sum.nr_nacks,
|
|
__entry->sum.nr_new_acks, __entry->sum.nr_new_nacks,
|
|
__entry->sum.nr_rot_new_acks,
|
|
__entry->top - __entry->hard_ack,
|
|
__entry->sum.cumulative_acks,
|
|
__entry->sum.dup_acks,
|
|
__entry->lowest_nak, __entry->sum.new_low_nack ? "!" : "",
|
|
rxrpc_congest_changes[__entry->change],
|
|
__entry->sum.retrans_timeo ? " rTxTo" : "")
|
|
);
|
|
|
|
#endif /* _TRACE_RXRPC_H */
|
|
|
|
/* This part must be outside protection */
|
|
#include <trace/define_trace.h>
|