blob: f6c50af24a64737672f7ede2ff41158bfed5f1b4 [file] [log] [blame]
Stephen Hemmingera42e9d62006-06-05 17:30:32 -07001/*
2 * tcpprobe - Observe the TCP flow with kprobes.
3 *
4 * The idea for this came from Werner Almesberger's umlsim
5 * Copyright (C) 2004, Stephen Hemminger <shemminger@osdl.org>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
Stephen Hemminger662ad4f2007-07-11 19:43:52 -07009 * the Free Software Foundation; either version 2 of the License.
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070010 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
Joe Perchesafd465032012-03-12 07:03:32 +000021#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070023#include <linux/kernel.h>
24#include <linux/kprobes.h>
25#include <linux/socket.h>
26#include <linux/tcp.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090027#include <linux/slab.h>
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070028#include <linux/proc_fs.h>
29#include <linux/module.h>
Stephen Hemminger85795d62007-03-24 21:35:33 -070030#include <linux/ktime.h>
31#include <linux/time.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020032#include <net/net_namespace.h>
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070033
34#include <net/tcp.h>
35
Stephen Hemminger65ebe6342007-01-23 11:38:57 -080036MODULE_AUTHOR("Stephen Hemminger <shemminger@linux-foundation.org>");
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070037MODULE_DESCRIPTION("TCP cwnd snooper");
38MODULE_LICENSE("GPL");
Stephen Hemminger662ad4f2007-07-11 19:43:52 -070039MODULE_VERSION("1.1");
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070040
Weilong Chen47d18a92013-12-23 14:37:30 +080041static int port __read_mostly;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070042MODULE_PARM_DESC(port, "Port to match (0=all)");
43module_param(port, int, 0);
44
Stephen Hemmingerf81074f2010-01-25 15:47:50 -080045static unsigned int bufsize __read_mostly = 4096;
Stephen Hemminger662ad4f2007-07-11 19:43:52 -070046MODULE_PARM_DESC(bufsize, "Log buffer size in packets (4096)");
Stephen Hemmingerf81074f2010-01-25 15:47:50 -080047module_param(bufsize, uint, 0);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070048
Weilong Chen47d18a92013-12-23 14:37:30 +080049static unsigned int fwmark __read_mostly;
Daniel Borkmannb1dcdc62013-08-23 16:16:33 +020050MODULE_PARM_DESC(fwmark, "skb mark to match (0=no mark)");
51module_param(fwmark, uint, 0);
52
Stephen Hemminger85795d62007-03-24 21:35:33 -070053static int full __read_mostly;
54MODULE_PARM_DESC(full, "Full log (1=every ack packet received, 0=only cwnd changes)");
55module_param(full, int, 0);
56
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070057static const char procname[] = "tcpprobe";
58
Stephen Hemminger662ad4f2007-07-11 19:43:52 -070059struct tcp_log {
60 ktime_t tstamp;
Daniel Borkmannf925d0a2013-08-21 19:48:00 +020061 union {
62 struct sockaddr raw;
63 struct sockaddr_in v4;
64 struct sockaddr_in6 v6;
65 } src, dst;
Stephen Hemminger662ad4f2007-07-11 19:43:52 -070066 u16 length;
67 u32 snd_nxt;
68 u32 snd_una;
69 u32 snd_wnd;
Daniel Borkmannb4c1c1d2013-08-21 19:47:58 +020070 u32 rcv_wnd;
Stephen Hemminger662ad4f2007-07-11 19:43:52 -070071 u32 snd_cwnd;
72 u32 ssthresh;
73 u32 srtt;
74};
75
76static struct {
Stephen Hemminger85795d62007-03-24 21:35:33 -070077 spinlock_t lock;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070078 wait_queue_head_t wait;
Stephen Hemminger85795d62007-03-24 21:35:33 -070079 ktime_t start;
80 u32 lastcwnd;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070081
Stephen Hemminger662ad4f2007-07-11 19:43:52 -070082 unsigned long head, tail;
83 struct tcp_log *log;
84} tcp_probe;
David S. Miller14a49e12007-06-05 00:19:24 -070085
Stephen Hemminger662ad4f2007-07-11 19:43:52 -070086static inline int tcp_probe_used(void)
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070087{
Stephen Hemmingerf81074f2010-01-25 15:47:50 -080088 return (tcp_probe.head - tcp_probe.tail) & (bufsize - 1);
Stephen Hemminger662ad4f2007-07-11 19:43:52 -070089}
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070090
Stephen Hemminger662ad4f2007-07-11 19:43:52 -070091static inline int tcp_probe_avail(void)
92{
Stephen Hemmingerf81074f2010-01-25 15:47:50 -080093 return bufsize - tcp_probe_used() - 1;
David S. Miller14a49e12007-06-05 00:19:24 -070094}
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070095
Daniel Borkmannf925d0a2013-08-21 19:48:00 +020096#define tcp_probe_copy_fl_to_si4(inet, si4, mem) \
97 do { \
98 si4.sin_family = AF_INET; \
99 si4.sin_port = inet->inet_##mem##port; \
100 si4.sin_addr.s_addr = inet->inet_##mem##addr; \
101 } while (0) \
102
Stephen Hemminger85795d62007-03-24 21:35:33 -0700103/*
104 * Hook inserted to be called before each receive packet.
105 * Note: arguments must match tcp_rcv_established()!
106 */
Vijay Subramanianc995ae22013-09-03 12:23:22 -0700107static void jtcp_rcv_established(struct sock *sk, struct sk_buff *skb,
108 const struct tcphdr *th, unsigned int len)
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700109{
110 const struct tcp_sock *tp = tcp_sk(sk);
111 const struct inet_sock *inet = inet_sk(sk);
112
Daniel Borkmannb1dcdc62013-08-23 16:16:33 +0200113 /* Only update if port or skb mark matches */
114 if (((port == 0 && fwmark == 0) ||
115 ntohs(inet->inet_dport) == port ||
116 ntohs(inet->inet_sport) == port ||
117 (fwmark > 0 && skb->mark == fwmark)) &&
Joe Perches9d4fb272009-11-23 10:41:23 -0800118 (full || tp->snd_cwnd != tcp_probe.lastcwnd)) {
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700119
120 spin_lock(&tcp_probe.lock);
121 /* If log fills, just silently drop */
122 if (tcp_probe_avail() > 1) {
123 struct tcp_log *p = tcp_probe.log + tcp_probe.head;
124
125 p->tstamp = ktime_get();
Daniel Borkmannf925d0a2013-08-21 19:48:00 +0200126 switch (sk->sk_family) {
127 case AF_INET:
128 tcp_probe_copy_fl_to_si4(inet, p->src.v4, s);
129 tcp_probe_copy_fl_to_si4(inet, p->dst.v4, d);
130 break;
131 case AF_INET6:
Eric Dumazetefe42082013-10-03 15:42:29 -0700132 memset(&p->src.v6, 0, sizeof(p->src.v6));
133 memset(&p->dst.v6, 0, sizeof(p->dst.v6));
134#if IS_ENABLED(CONFIG_IPV6)
135 p->src.v6.sin6_family = AF_INET6;
136 p->src.v6.sin6_port = inet->inet_sport;
137 p->src.v6.sin6_addr = inet6_sk(sk)->saddr;
138
139 p->dst.v6.sin6_family = AF_INET6;
140 p->dst.v6.sin6_port = inet->inet_dport;
141 p->dst.v6.sin6_addr = sk->sk_v6_daddr;
142#endif
Daniel Borkmannf925d0a2013-08-21 19:48:00 +0200143 break;
144 default:
145 BUG();
146 }
147
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700148 p->length = skb->len;
149 p->snd_nxt = tp->snd_nxt;
150 p->snd_una = tp->snd_una;
151 p->snd_cwnd = tp->snd_cwnd;
152 p->snd_wnd = tp->snd_wnd;
Daniel Borkmannb4c1c1d2013-08-21 19:47:58 +0200153 p->rcv_wnd = tp->rcv_wnd;
Stephen Hemmingerb3b0b682007-07-14 18:57:19 -0700154 p->ssthresh = tcp_current_ssthresh(sk);
Eric Dumazet740b0f12014-02-26 14:02:48 -0800155 p->srtt = tp->srtt_us >> 3;
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700156
Stephen Hemmingerf81074f2010-01-25 15:47:50 -0800157 tcp_probe.head = (tcp_probe.head + 1) & (bufsize - 1);
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700158 }
159 tcp_probe.lastcwnd = tp->snd_cwnd;
160 spin_unlock(&tcp_probe.lock);
161
162 wake_up(&tcp_probe.wait);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700163 }
164
165 jprobe_return();
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700166}
167
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700168static struct jprobe tcp_jprobe = {
Ananth N Mavinakayanahalli3a872d82006-10-02 02:17:30 -0700169 .kp = {
Stephen Hemminger85795d62007-03-24 21:35:33 -0700170 .symbol_name = "tcp_rcv_established",
Ananth N Mavinakayanahalli3a872d82006-10-02 02:17:30 -0700171 },
Michael Ellerman9e367d82007-07-19 01:48:10 -0700172 .entry = jtcp_rcv_established,
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700173};
174
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000175static int tcpprobe_open(struct inode *inode, struct file *file)
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700176{
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700177 /* Reset (empty) log */
178 spin_lock_bh(&tcp_probe.lock);
179 tcp_probe.head = tcp_probe.tail = 0;
180 tcp_probe.start = ktime_get();
181 spin_unlock_bh(&tcp_probe.lock);
182
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700183 return 0;
184}
185
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700186static int tcpprobe_sprint(char *tbuf, int n)
187{
188 const struct tcp_log *p
Stephen Hemmingerf81074f2010-01-25 15:47:50 -0800189 = tcp_probe.log + tcp_probe.tail;
Deepa Dinamanib1b270d2016-02-27 00:32:16 -0800190 struct timespec64 ts
191 = ktime_to_timespec64(ktime_sub(p->tstamp, tcp_probe.start));
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700192
Vasiliy Kulikovdda0b382010-11-14 07:06:08 +0000193 return scnprintf(tbuf, n,
Daniel Borkmannf925d0a2013-08-21 19:48:00 +0200194 "%lu.%09lu %pISpc %pISpc %d %#x %#x %u %u %u %u %u\n",
Deepa Dinamanib1b270d2016-02-27 00:32:16 -0800195 (unsigned long)ts.tv_sec,
196 (unsigned long)ts.tv_nsec,
Daniel Borkmannf925d0a2013-08-21 19:48:00 +0200197 &p->src, &p->dst, p->length, p->snd_nxt, p->snd_una,
Daniel Borkmannb4c1c1d2013-08-21 19:47:58 +0200198 p->snd_cwnd, p->ssthresh, p->snd_wnd, p->srtt, p->rcv_wnd);
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700199}
200
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700201static ssize_t tcpprobe_read(struct file *file, char __user *buf,
202 size_t len, loff_t *ppos)
203{
Roel Kluina2025b82009-03-13 16:05:14 -0700204 int error = 0;
205 size_t cnt = 0;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700206
Roel Kluina2025b82009-03-13 16:05:14 -0700207 if (!buf)
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700208 return -EINVAL;
209
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700210 while (cnt < len) {
Daniel Borkmanncc8c6c12013-09-03 18:24:02 +0200211 char tbuf[256];
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700212 int width;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700213
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700214 /* Wait for data in buffer */
215 error = wait_event_interruptible(tcp_probe.wait,
216 tcp_probe_used() > 0);
217 if (error)
218 break;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700219
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700220 spin_lock_bh(&tcp_probe.lock);
221 if (tcp_probe.head == tcp_probe.tail) {
222 /* multiple readers race? */
223 spin_unlock_bh(&tcp_probe.lock);
224 continue;
225 }
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700226
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700227 width = tcpprobe_sprint(tbuf, sizeof(tbuf));
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700228
Tom Quetchenbach8d390ef2008-04-24 21:11:58 -0700229 if (cnt + width < len)
Stephen Hemmingerf81074f2010-01-25 15:47:50 -0800230 tcp_probe.tail = (tcp_probe.tail + 1) & (bufsize - 1);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700231
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700232 spin_unlock_bh(&tcp_probe.lock);
233
234 /* if record greater than space available
235 return partial buffer (so far) */
Tom Quetchenbach8d390ef2008-04-24 21:11:58 -0700236 if (cnt + width >= len)
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700237 break;
238
Tom Quetchenbach8d390ef2008-04-24 21:11:58 -0700239 if (copy_to_user(buf + cnt, tbuf, width))
240 return -EFAULT;
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700241 cnt += width;
242 }
243
244 return cnt == 0 ? error : cnt;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700245}
246
Arjan van de Ven9a321442007-02-12 00:55:35 -0800247static const struct file_operations tcpprobe_fops = {
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700248 .owner = THIS_MODULE,
249 .open = tcpprobe_open,
250 .read = tcpprobe_read,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200251 .llseek = noop_llseek,
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700252};
253
254static __init int tcpprobe_init(void)
255{
256 int ret = -ENOMEM;
257
Daniel Borkmannd8cdeda2013-08-21 19:47:59 +0200258 /* Warning: if the function signature of tcp_rcv_established,
259 * has been changed, you also have to change the signature of
260 * jtcp_rcv_established, otherwise you end up right here!
261 */
262 BUILD_BUG_ON(__same_type(tcp_rcv_established,
263 jtcp_rcv_established) == 0);
264
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700265 init_waitqueue_head(&tcp_probe.wait);
266 spin_lock_init(&tcp_probe.lock);
267
Stephen Hemmingerf81074f2010-01-25 15:47:50 -0800268 if (bufsize == 0)
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700269 return -EINVAL;
270
Stephen Hemmingerf81074f2010-01-25 15:47:50 -0800271 bufsize = roundup_pow_of_two(bufsize);
Milton Miller3d8ea1f2008-07-10 16:51:32 -0700272 tcp_probe.log = kcalloc(bufsize, sizeof(struct tcp_log), GFP_KERNEL);
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700273 if (!tcp_probe.log)
274 goto err0;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700275
Gao fengd4beaa62013-02-18 01:34:54 +0000276 if (!proc_create(procname, S_IRUSR, init_net.proc_net, &tcpprobe_fops))
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700277 goto err0;
278
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700279 ret = register_jprobe(&tcp_jprobe);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700280 if (ret)
281 goto err1;
282
Daniel Borkmannb1dcdc62013-08-23 16:16:33 +0200283 pr_info("probe registered (port=%d/fwmark=%u) bufsize=%u\n",
284 port, fwmark, bufsize);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700285 return 0;
286 err1:
Gao fengece31ff2013-02-18 01:34:56 +0000287 remove_proc_entry(procname, init_net.proc_net);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700288 err0:
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700289 kfree(tcp_probe.log);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700290 return ret;
291}
292module_init(tcpprobe_init);
293
294static __exit void tcpprobe_exit(void)
295{
Gao fengece31ff2013-02-18 01:34:56 +0000296 remove_proc_entry(procname, init_net.proc_net);
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700297 unregister_jprobe(&tcp_jprobe);
298 kfree(tcp_probe.log);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700299}
300module_exit(tcpprobe_exit);