1// SPDX-License-Identifier: GPL-2.0
  2/* Copyright (c) 2020 Facebook */
  3#include "bpf_iter.h"
  4#include "bpf_tracing_net.h"
  5#include <bpf/bpf_helpers.h>
  6#include <bpf/bpf_endian.h>
  7
  8char _license[] SEC("license") = "GPL";
  9
 10static int hlist_unhashed_lockless(const struct hlist_node *h)
 11{
 12        return !(h->pprev);
 13}
 14
 15static int timer_pending(const struct timer_list * timer)
 16{
 17	return !hlist_unhashed_lockless(&timer->entry);
 18}
 19
 20extern unsigned CONFIG_HZ __kconfig;
 21
 22#define USER_HZ		100
 23#define NSEC_PER_SEC	1000000000ULL
 24static clock_t jiffies_to_clock_t(unsigned long x)
 25{
 26	/* The implementation here tailored to a particular
 27	 * setting of USER_HZ.
 28	 */
 29	u64 tick_nsec = (NSEC_PER_SEC + CONFIG_HZ/2) / CONFIG_HZ;
 30	u64 user_hz_nsec = NSEC_PER_SEC / USER_HZ;
 31
 32	if ((tick_nsec % user_hz_nsec) == 0) {
 33		if (CONFIG_HZ < USER_HZ)
 34			return x * (USER_HZ / CONFIG_HZ);
 35		else
 36			return x / (CONFIG_HZ / USER_HZ);
 37	}
 38	return x * tick_nsec/user_hz_nsec;
 39}
 40
 41static clock_t jiffies_delta_to_clock_t(long delta)
 42{
 43	if (delta <= 0)
 44		return 0;
 45
 46	return jiffies_to_clock_t(delta);
 47}
 48
 49static long sock_i_ino(const struct sock *sk)
 50{
 51	const struct socket *sk_socket = sk->sk_socket;
 52	const struct inode *inode;
 53	unsigned long ino;
 54
 55	if (!sk_socket)
 56		return 0;
 57
 58	inode = &container_of(sk_socket, struct socket_alloc, socket)->vfs_inode;
 59	bpf_probe_read_kernel(&ino, sizeof(ino), &inode->i_ino);
 60	return ino;
 61}
 62
 63static bool
 64inet_csk_in_pingpong_mode(const struct inet_connection_sock *icsk)
 65{
 66	return icsk->icsk_ack.pingpong >= TCP_PINGPONG_THRESH;
 67}
 68
 69static bool tcp_in_initial_slowstart(const struct tcp_sock *tcp)
 70{
 71	return tcp->snd_ssthresh >= TCP_INFINITE_SSTHRESH;
 72}
 73
 74static int dump_tcp_sock(struct seq_file *seq, struct tcp_sock *tp,
 75			 uid_t uid, __u32 seq_num)
 76{
 77	const struct inet_connection_sock *icsk;
 78	const struct fastopen_queue *fastopenq;
 79	const struct inet_sock *inet;
 80	unsigned long timer_expires;
 81	const struct sock *sp;
 82	__u16 destp, srcp;
 83	__be32 dest, src;
 84	int timer_active;
 85	int rx_queue;
 86	int state;
 87
 88	icsk = &tp->inet_conn;
 89	inet = &icsk->icsk_inet;
 90	sp = &inet->sk;
 91	fastopenq = &icsk->icsk_accept_queue.fastopenq;
 92
 93	dest = inet->inet_daddr;
 94	src = inet->inet_rcv_saddr;
 95	destp = bpf_ntohs(inet->inet_dport);
 96	srcp = bpf_ntohs(inet->inet_sport);
 97
 98	if (icsk->icsk_pending == ICSK_TIME_RETRANS ||
 99	    icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
100	    icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
101		timer_active = 1;
102		timer_expires = icsk->icsk_timeout;
103	} else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
104		timer_active = 4;
105		timer_expires = icsk->icsk_timeout;
106	} else if (timer_pending(&sp->sk_timer)) {
107		timer_active = 2;
108		timer_expires = sp->sk_timer.expires;
109	} else {
110		timer_active = 0;
111		timer_expires = bpf_jiffies64();
112	}
113
114	state = sp->sk_state;
115	if (state == TCP_LISTEN) {
116		rx_queue = sp->sk_ack_backlog;
117	} else {
118		rx_queue = tp->rcv_nxt - tp->copied_seq;
119		if (rx_queue < 0)
120			rx_queue = 0;
121	}
122
123	BPF_SEQ_PRINTF(seq, "%4d: %08X:%04X %08X:%04X ",
124		       seq_num, src, srcp, dest, destp);
125	BPF_SEQ_PRINTF(seq, "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d ",
126		       state,
127		       tp->write_seq - tp->snd_una, rx_queue,
128		       timer_active,
129		       jiffies_delta_to_clock_t(timer_expires - bpf_jiffies64()),
130		       icsk->icsk_retransmits, uid,
131		       icsk->icsk_probes_out,
132		       sock_i_ino(sp),
133		       sp->sk_refcnt.refs.counter);
134	BPF_SEQ_PRINTF(seq, "%pK %lu %lu %u %u %d\n",
135		       tp,
136		       jiffies_to_clock_t(icsk->icsk_rto),
137		       jiffies_to_clock_t(icsk->icsk_ack.ato),
138		       (icsk->icsk_ack.quick << 1) | inet_csk_in_pingpong_mode(icsk),
139		       tp->snd_cwnd,
140		       state == TCP_LISTEN ? fastopenq->max_qlen
141				: (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh)
142		      );
143
144	return 0;
145}
146
147static int dump_tw_sock(struct seq_file *seq, struct tcp_timewait_sock *ttw,
148			uid_t uid, __u32 seq_num)
149{
150	struct inet_timewait_sock *tw = &ttw->tw_sk;
151	__u16 destp, srcp;
152	__be32 dest, src;
153	long delta;
154
155	delta = tw->tw_timer.expires - bpf_jiffies64();
156	dest = tw->tw_daddr;
157	src  = tw->tw_rcv_saddr;
158	destp = bpf_ntohs(tw->tw_dport);
159	srcp  = bpf_ntohs(tw->tw_sport);
160
161	BPF_SEQ_PRINTF(seq, "%4d: %08X:%04X %08X:%04X ",
162		       seq_num, src, srcp, dest, destp);
163
164	BPF_SEQ_PRINTF(seq, "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
165		       tw->tw_substate, 0, 0,
166		       3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
167		       tw->tw_refcnt.refs.counter, tw);
168
169	return 0;
170}
171
172static int dump_req_sock(struct seq_file *seq, struct tcp_request_sock *treq,
173			 uid_t uid, __u32 seq_num)
174{
175	struct inet_request_sock *irsk = &treq->req;
176	struct request_sock *req = &irsk->req;
177	long ttd;
178
179	ttd = req->rsk_timer.expires - bpf_jiffies64();
180
181	if (ttd < 0)
182		ttd = 0;
183
184	BPF_SEQ_PRINTF(seq, "%4d: %08X:%04X %08X:%04X ",
185		       seq_num, irsk->ir_loc_addr,
186		       irsk->ir_num, irsk->ir_rmt_addr,
187		       bpf_ntohs(irsk->ir_rmt_port));
188	BPF_SEQ_PRINTF(seq, "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
189		       TCP_SYN_RECV, 0, 0, 1, jiffies_to_clock_t(ttd),
190		       req->num_timeout, uid, 0, 0, 0, req);
191
192	return 0;
193}
194
195SEC("iter/tcp")
196int dump_tcp4(struct bpf_iter__tcp *ctx)
197{
198	struct sock_common *sk_common = ctx->sk_common;
199	struct seq_file *seq = ctx->meta->seq;
200	struct tcp_timewait_sock *tw;
201	struct tcp_request_sock *req;
202	struct tcp_sock *tp;
203	uid_t uid = ctx->uid;
204	__u32 seq_num;
205
206	if (sk_common == (void *)0)
207		return 0;
208
209	seq_num = ctx->meta->seq_num;
210	if (seq_num == 0)
211		BPF_SEQ_PRINTF(seq, "  sl  "
212				    "local_address "
213				    "rem_address   "
214				    "st tx_queue rx_queue tr tm->when retrnsmt"
215				    "   uid  timeout inode\n");
216
217	if (sk_common->skc_family != AF_INET)
218		return 0;
219
220	tp = bpf_skc_to_tcp_sock(sk_common);
221	if (tp)
222		return dump_tcp_sock(seq, tp, uid, seq_num);
223
224	tw = bpf_skc_to_tcp_timewait_sock(sk_common);
225	if (tw)
226		return dump_tw_sock(seq, tw, uid, seq_num);
227
228	req = bpf_skc_to_tcp_request_sock(sk_common);
229	if (req)
230		return dump_req_sock(seq, req, uid, seq_num);
231
232	return 0;
233}