bpf/progs/bpf_iter_tcp6.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright (c) 2020 Facebook */
0003 #include "bpf_iter.h"
0004 #include "bpf_tracing_net.h"
0005 #include <bpf/bpf_helpers.h>
0006 #include <bpf/bpf_endian.h>
0007
0008 char _license[] SEC("license") = "GPL";
0009
0010 static int hlist_unhashed_lockless(const struct hlist_node *h)
0011 {
0012         return !(h->pprev);
0013 }
0014
0015 static int timer_pending(const struct timer_list * timer)
0016 {
0017     return !hlist_unhashed_lockless(&timer->entry);
0018 }
0019
0020 extern unsigned CONFIG_HZ __kconfig;
0021
0022 #define USER_HZ     100
0023 #define NSEC_PER_SEC    1000000000ULL
0024 static clock_t jiffies_to_clock_t(unsigned long x)
0025 {
0026     /* The implementation here tailored to a particular
0027      * setting of USER_HZ.
0028      */
0029     u64 tick_nsec = (NSEC_PER_SEC + CONFIG_HZ/2) / CONFIG_HZ;
0030     u64 user_hz_nsec = NSEC_PER_SEC / USER_HZ;
0031
0032     if ((tick_nsec % user_hz_nsec) == 0) {
0033         if (CONFIG_HZ < USER_HZ)
0034             return x * (USER_HZ / CONFIG_HZ);
0035         else
0036             return x / (CONFIG_HZ / USER_HZ);
0037     }
0038     return x * tick_nsec/user_hz_nsec;
0039 }
0040
0041 static clock_t jiffies_delta_to_clock_t(long delta)
0042 {
0043     if (delta <= 0)
0044         return 0;
0045
0046     return jiffies_to_clock_t(delta);
0047 }
0048
0049 static long sock_i_ino(const struct sock *sk)
0050 {
0051     const struct socket *sk_socket = sk->sk_socket;
0052     const struct inode *inode;
0053     unsigned long ino;
0054
0055     if (!sk_socket)
0056         return 0;
0057
0058     inode = &container_of(sk_socket, struct socket_alloc, socket)->vfs_inode;
0059     bpf_probe_read_kernel(&ino, sizeof(ino), &inode->i_ino);
0060     return ino;
0061 }
0062
0063 static bool
0064 inet_csk_in_pingpong_mode(const struct inet_connection_sock *icsk)
0065 {
0066     return icsk->icsk_ack.pingpong >= TCP_PINGPONG_THRESH;
0067 }
0068
0069 static bool tcp_in_initial_slowstart(const struct tcp_sock *tcp)
0070 {
0071     return tcp->snd_ssthresh >= TCP_INFINITE_SSTHRESH;
0072 }
0073
0074 static int dump_tcp6_sock(struct seq_file *seq, struct tcp6_sock *tp,
0075              uid_t uid, __u32 seq_num)
0076 {
0077     const struct inet_connection_sock *icsk;
0078     const struct fastopen_queue *fastopenq;
0079     const struct in6_addr *dest, *src;
0080     const struct inet_sock *inet;
0081     unsigned long timer_expires;
0082     const struct sock *sp;
0083     __u16 destp, srcp;
0084     int timer_active;
0085     int rx_queue;
0086     int state;
0087
0088     icsk = &tp->tcp.inet_conn;
0089     inet = &icsk->icsk_inet;
0090     sp = &inet->sk;
0091     fastopenq = &icsk->icsk_accept_queue.fastopenq;
0092
0093     dest = &sp->sk_v6_daddr;
0094     src = &sp->sk_v6_rcv_saddr;
0095     destp = bpf_ntohs(inet->inet_dport);
0096     srcp = bpf_ntohs(inet->inet_sport);
0097
0098     if (icsk->icsk_pending == ICSK_TIME_RETRANS ||
0099         icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
0100         icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
0101         timer_active = 1;
0102         timer_expires = icsk->icsk_timeout;
0103     } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
0104         timer_active = 4;
0105         timer_expires = icsk->icsk_timeout;
0106     } else if (timer_pending(&sp->sk_timer)) {
0107         timer_active = 2;
0108         timer_expires = sp->sk_timer.expires;
0109     } else {
0110         timer_active = 0;
0111         timer_expires = bpf_jiffies64();
0112     }
0113
0114     state = sp->sk_state;
0115     if (state == TCP_LISTEN) {
0116         rx_queue = sp->sk_ack_backlog;
0117     } else {
0118         rx_queue = tp->tcp.rcv_nxt - tp->tcp.copied_seq;
0119         if (rx_queue < 0)
0120             rx_queue = 0;
0121     }
0122
0123     BPF_SEQ_PRINTF(seq, "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X ",
0124                seq_num,
0125                src->s6_addr32[0], src->s6_addr32[1],
0126                src->s6_addr32[2], src->s6_addr32[3], srcp,
0127                dest->s6_addr32[0], dest->s6_addr32[1],
0128                dest->s6_addr32[2], dest->s6_addr32[3], destp);
0129     BPF_SEQ_PRINTF(seq, "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d ",
0130                state,
0131                tp->tcp.write_seq - tp->tcp.snd_una, rx_queue,
0132                timer_active,
0133                jiffies_delta_to_clock_t(timer_expires - bpf_jiffies64()),
0134                icsk->icsk_retransmits, uid,
0135                icsk->icsk_probes_out,
0136                sock_i_ino(sp),
0137                sp->sk_refcnt.refs.counter);
0138     BPF_SEQ_PRINTF(seq, "%pK %lu %lu %u %u %d\n",
0139                tp,
0140                jiffies_to_clock_t(icsk->icsk_rto),
0141                jiffies_to_clock_t(icsk->icsk_ack.ato),
0142                (icsk->icsk_ack.quick << 1) | inet_csk_in_pingpong_mode(icsk),
0143                tp->tcp.snd_cwnd,
0144                state == TCP_LISTEN ? fastopenq->max_qlen
0145                 : (tcp_in_initial_slowstart(&tp->tcp) ? -1
0146                                       : tp->tcp.snd_ssthresh)
0147               );
0148
0149     return 0;
0150 }
0151
0152 static int dump_tw_sock(struct seq_file *seq, struct tcp_timewait_sock *ttw,
0153             uid_t uid, __u32 seq_num)
0154 {
0155     struct inet_timewait_sock *tw = &ttw->tw_sk;
0156     const struct in6_addr *dest, *src;
0157     __u16 destp, srcp;
0158     long delta;
0159
0160     delta = tw->tw_timer.expires - bpf_jiffies64();
0161     dest = &tw->tw_v6_daddr;
0162     src  = &tw->tw_v6_rcv_saddr;
0163     destp = bpf_ntohs(tw->tw_dport);
0164     srcp  = bpf_ntohs(tw->tw_sport);
0165
0166     BPF_SEQ_PRINTF(seq, "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X ",
0167                seq_num,
0168                src->s6_addr32[0], src->s6_addr32[1],
0169                src->s6_addr32[2], src->s6_addr32[3], srcp,
0170                dest->s6_addr32[0], dest->s6_addr32[1],
0171                dest->s6_addr32[2], dest->s6_addr32[3], destp);
0172
0173     BPF_SEQ_PRINTF(seq, "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
0174                tw->tw_substate, 0, 0,
0175                3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
0176                tw->tw_refcnt.refs.counter, tw);
0177
0178     return 0;
0179 }
0180
0181 static int dump_req_sock(struct seq_file *seq, struct tcp_request_sock *treq,
0182              uid_t uid, __u32 seq_num)
0183 {
0184     struct inet_request_sock *irsk = &treq->req;
0185     struct request_sock *req = &irsk->req;
0186     struct in6_addr *src, *dest;
0187     long ttd;
0188
0189     ttd = req->rsk_timer.expires - bpf_jiffies64();
0190     src = &irsk->ir_v6_loc_addr;
0191     dest = &irsk->ir_v6_rmt_addr;
0192
0193     if (ttd < 0)
0194         ttd = 0;
0195
0196     BPF_SEQ_PRINTF(seq, "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X ",
0197                seq_num,
0198                src->s6_addr32[0], src->s6_addr32[1],
0199                src->s6_addr32[2], src->s6_addr32[3],
0200                irsk->ir_num,
0201                dest->s6_addr32[0], dest->s6_addr32[1],
0202                dest->s6_addr32[2], dest->s6_addr32[3],
0203                bpf_ntohs(irsk->ir_rmt_port));
0204     BPF_SEQ_PRINTF(seq, "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
0205                TCP_SYN_RECV, 0, 0, 1, jiffies_to_clock_t(ttd),
0206                req->num_timeout, uid, 0, 0, 0, req);
0207
0208     return 0;
0209 }
0210
0211 SEC("iter/tcp")
0212 int dump_tcp6(struct bpf_iter__tcp *ctx)
0213 {
0214     struct sock_common *sk_common = ctx->sk_common;
0215     struct seq_file *seq = ctx->meta->seq;
0216     struct tcp_timewait_sock *tw;
0217     struct tcp_request_sock *req;
0218     struct tcp6_sock *tp;
0219     uid_t uid = ctx->uid;
0220     __u32 seq_num;
0221
0222     if (sk_common == (void *)0)
0223         return 0;
0224
0225     seq_num = ctx->meta->seq_num;
0226     if (seq_num == 0)
0227         BPF_SEQ_PRINTF(seq, "  sl  "
0228                     "local_address                         "
0229                     "remote_address                        "
0230                     "st tx_queue rx_queue tr tm->when retrnsmt"
0231                     "   uid  timeout inode\n");
0232
0233     if (sk_common->skc_family != AF_INET6)
0234         return 0;
0235
0236     tp = bpf_skc_to_tcp6_sock(sk_common);
0237     if (tp)
0238         return dump_tcp6_sock(seq, tp, uid, seq_num);
0239
0240     tw = bpf_skc_to_tcp_timewait_sock(sk_common);
0241     if (tw)
0242         return dump_tw_sock(seq, tw, uid, seq_num);
0243
0244     req = bpf_skc_to_tcp_request_sock(sk_common);
0245     if (req)
0246         return dump_req_sock(seq, req, uid, seq_num);
0247
0248     return 0;
0249 }