blob: 3b66610d41562035c541304924fc27a4eb416a6e [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 -070086
87static inline int tcp_probe_used(void)
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070088{
Stephen Hemmingerf81074f2010-01-25 15:47:50 -080089 return (tcp_probe.head - tcp_probe.tail) & (bufsize - 1);
Stephen Hemminger662ad4f2007-07-11 19:43:52 -070090}
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070091
Stephen Hemminger662ad4f2007-07-11 19:43:52 -070092static inline int tcp_probe_avail(void)
93{
Stephen Hemmingerf81074f2010-01-25 15:47:50 -080094 return bufsize - tcp_probe_used() - 1;
David S. Miller14a49e12007-06-05 00:19:24 -070095}
Stephen Hemmingera42e9d62006-06-05 17:30:32 -070096
Daniel Borkmannf925d0a2013-08-21 19:48:00 +020097#define tcp_probe_copy_fl_to_si4(inet, si4, mem) \
98 do { \
99 si4.sin_family = AF_INET; \
100 si4.sin_port = inet->inet_##mem##port; \
101 si4.sin_addr.s_addr = inet->inet_##mem##addr; \
102 } while (0) \
103
Daniel Borkmannf925d0a2013-08-21 19:48:00 +0200104
Stephen Hemminger85795d62007-03-24 21:35:33 -0700105/*
106 * Hook inserted to be called before each receive packet.
107 * Note: arguments must match tcp_rcv_established()!
108 */
Vijay Subramanianc995ae22013-09-03 12:23:22 -0700109static void jtcp_rcv_established(struct sock *sk, struct sk_buff *skb,
110 const struct tcphdr *th, unsigned int len)
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700111{
112 const struct tcp_sock *tp = tcp_sk(sk);
113 const struct inet_sock *inet = inet_sk(sk);
114
Daniel Borkmannb1dcdc62013-08-23 16:16:33 +0200115 /* Only update if port or skb mark matches */
116 if (((port == 0 && fwmark == 0) ||
117 ntohs(inet->inet_dport) == port ||
118 ntohs(inet->inet_sport) == port ||
119 (fwmark > 0 && skb->mark == fwmark)) &&
Joe Perches9d4fb272009-11-23 10:41:23 -0800120 (full || tp->snd_cwnd != tcp_probe.lastcwnd)) {
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700121
122 spin_lock(&tcp_probe.lock);
123 /* If log fills, just silently drop */
124 if (tcp_probe_avail() > 1) {
125 struct tcp_log *p = tcp_probe.log + tcp_probe.head;
126
127 p->tstamp = ktime_get();
Daniel Borkmannf925d0a2013-08-21 19:48:00 +0200128 switch (sk->sk_family) {
129 case AF_INET:
130 tcp_probe_copy_fl_to_si4(inet, p->src.v4, s);
131 tcp_probe_copy_fl_to_si4(inet, p->dst.v4, d);
132 break;
133 case AF_INET6:
Eric Dumazetefe42082013-10-03 15:42:29 -0700134 memset(&p->src.v6, 0, sizeof(p->src.v6));
135 memset(&p->dst.v6, 0, sizeof(p->dst.v6));
136#if IS_ENABLED(CONFIG_IPV6)
137 p->src.v6.sin6_family = AF_INET6;
138 p->src.v6.sin6_port = inet->inet_sport;
139 p->src.v6.sin6_addr = inet6_sk(sk)->saddr;
140
141 p->dst.v6.sin6_family = AF_INET6;
142 p->dst.v6.sin6_port = inet->inet_dport;
143 p->dst.v6.sin6_addr = sk->sk_v6_daddr;
144#endif
Daniel Borkmannf925d0a2013-08-21 19:48:00 +0200145 break;
146 default:
147 BUG();
148 }
149
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700150 p->length = skb->len;
151 p->snd_nxt = tp->snd_nxt;
152 p->snd_una = tp->snd_una;
153 p->snd_cwnd = tp->snd_cwnd;
154 p->snd_wnd = tp->snd_wnd;
Daniel Borkmannb4c1c1d2013-08-21 19:47:58 +0200155 p->rcv_wnd = tp->rcv_wnd;
Stephen Hemmingerb3b0b682007-07-14 18:57:19 -0700156 p->ssthresh = tcp_current_ssthresh(sk);
Eric Dumazet740b0f12014-02-26 14:02:48 -0800157 p->srtt = tp->srtt_us >> 3;
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700158
Stephen Hemmingerf81074f2010-01-25 15:47:50 -0800159 tcp_probe.head = (tcp_probe.head + 1) & (bufsize - 1);
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700160 }
161 tcp_probe.lastcwnd = tp->snd_cwnd;
162 spin_unlock(&tcp_probe.lock);
163
164 wake_up(&tcp_probe.wait);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700165 }
166
167 jprobe_return();
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700168}
169
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700170static struct jprobe tcp_jprobe = {
Ananth N Mavinakayanahalli3a872d82006-10-02 02:17:30 -0700171 .kp = {
Stephen Hemminger85795d62007-03-24 21:35:33 -0700172 .symbol_name = "tcp_rcv_established",
Ananth N Mavinakayanahalli3a872d82006-10-02 02:17:30 -0700173 },
Michael Ellerman9e367d82007-07-19 01:48:10 -0700174 .entry = jtcp_rcv_established,
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700175};
176
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000177static int tcpprobe_open(struct inode *inode, struct file *file)
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700178{
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700179 /* Reset (empty) log */
180 spin_lock_bh(&tcp_probe.lock);
181 tcp_probe.head = tcp_probe.tail = 0;
182 tcp_probe.start = ktime_get();
183 spin_unlock_bh(&tcp_probe.lock);
184
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700185 return 0;
186}
187
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700188static int tcpprobe_sprint(char *tbuf, int n)
189{
190 const struct tcp_log *p
Stephen Hemmingerf81074f2010-01-25 15:47:50 -0800191 = tcp_probe.log + tcp_probe.tail;
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700192 struct timespec tv
193 = ktime_to_timespec(ktime_sub(p->tstamp, tcp_probe.start));
194
Vasiliy Kulikovdda0b382010-11-14 07:06:08 +0000195 return scnprintf(tbuf, n,
Daniel Borkmannf925d0a2013-08-21 19:48:00 +0200196 "%lu.%09lu %pISpc %pISpc %d %#x %#x %u %u %u %u %u\n",
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700197 (unsigned long) tv.tv_sec,
198 (unsigned long) tv.tv_nsec,
Daniel Borkmannf925d0a2013-08-21 19:48:00 +0200199 &p->src, &p->dst, p->length, p->snd_nxt, p->snd_una,
Daniel Borkmannb4c1c1d2013-08-21 19:47:58 +0200200 p->snd_cwnd, p->ssthresh, p->snd_wnd, p->srtt, p->rcv_wnd);
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700201}
202
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700203static ssize_t tcpprobe_read(struct file *file, char __user *buf,
204 size_t len, loff_t *ppos)
205{
Roel Kluina2025b82009-03-13 16:05:14 -0700206 int error = 0;
207 size_t cnt = 0;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700208
Roel Kluina2025b82009-03-13 16:05:14 -0700209 if (!buf)
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700210 return -EINVAL;
211
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700212 while (cnt < len) {
Daniel Borkmanncc8c6c12013-09-03 18:24:02 +0200213 char tbuf[256];
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700214 int width;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700215
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700216 /* Wait for data in buffer */
217 error = wait_event_interruptible(tcp_probe.wait,
218 tcp_probe_used() > 0);
219 if (error)
220 break;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700221
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700222 spin_lock_bh(&tcp_probe.lock);
223 if (tcp_probe.head == tcp_probe.tail) {
224 /* multiple readers race? */
225 spin_unlock_bh(&tcp_probe.lock);
226 continue;
227 }
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700228
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700229 width = tcpprobe_sprint(tbuf, sizeof(tbuf));
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700230
Tom Quetchenbach8d390ef2008-04-24 21:11:58 -0700231 if (cnt + width < len)
Stephen Hemmingerf81074f2010-01-25 15:47:50 -0800232 tcp_probe.tail = (tcp_probe.tail + 1) & (bufsize - 1);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700233
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700234 spin_unlock_bh(&tcp_probe.lock);
235
236 /* if record greater than space available
237 return partial buffer (so far) */
Tom Quetchenbach8d390ef2008-04-24 21:11:58 -0700238 if (cnt + width >= len)
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700239 break;
240
Tom Quetchenbach8d390ef2008-04-24 21:11:58 -0700241 if (copy_to_user(buf + cnt, tbuf, width))
242 return -EFAULT;
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700243 cnt += width;
244 }
245
246 return cnt == 0 ? error : cnt;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700247}
248
Arjan van de Ven9a321442007-02-12 00:55:35 -0800249static const struct file_operations tcpprobe_fops = {
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700250 .owner = THIS_MODULE,
251 .open = tcpprobe_open,
252 .read = tcpprobe_read,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200253 .llseek = noop_llseek,
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700254};
255
256static __init int tcpprobe_init(void)
257{
258 int ret = -ENOMEM;
259
Daniel Borkmannd8cdeda2013-08-21 19:47:59 +0200260 /* Warning: if the function signature of tcp_rcv_established,
261 * has been changed, you also have to change the signature of
262 * jtcp_rcv_established, otherwise you end up right here!
263 */
264 BUILD_BUG_ON(__same_type(tcp_rcv_established,
265 jtcp_rcv_established) == 0);
266
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700267 init_waitqueue_head(&tcp_probe.wait);
268 spin_lock_init(&tcp_probe.lock);
269
Stephen Hemmingerf81074f2010-01-25 15:47:50 -0800270 if (bufsize == 0)
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700271 return -EINVAL;
272
Stephen Hemmingerf81074f2010-01-25 15:47:50 -0800273 bufsize = roundup_pow_of_two(bufsize);
Milton Miller3d8ea1f2008-07-10 16:51:32 -0700274 tcp_probe.log = kcalloc(bufsize, sizeof(struct tcp_log), GFP_KERNEL);
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700275 if (!tcp_probe.log)
276 goto err0;
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700277
Gao fengd4beaa62013-02-18 01:34:54 +0000278 if (!proc_create(procname, S_IRUSR, init_net.proc_net, &tcpprobe_fops))
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700279 goto err0;
280
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700281 ret = register_jprobe(&tcp_jprobe);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700282 if (ret)
283 goto err1;
284
Daniel Borkmannb1dcdc62013-08-23 16:16:33 +0200285 pr_info("probe registered (port=%d/fwmark=%u) bufsize=%u\n",
286 port, fwmark, bufsize);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700287 return 0;
288 err1:
Gao fengece31ff2013-02-18 01:34:56 +0000289 remove_proc_entry(procname, init_net.proc_net);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700290 err0:
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700291 kfree(tcp_probe.log);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700292 return ret;
293}
294module_init(tcpprobe_init);
295
296static __exit void tcpprobe_exit(void)
297{
Gao fengece31ff2013-02-18 01:34:56 +0000298 remove_proc_entry(procname, init_net.proc_net);
Stephen Hemminger662ad4f2007-07-11 19:43:52 -0700299 unregister_jprobe(&tcp_jprobe);
300 kfree(tcp_probe.log);
Stephen Hemmingera42e9d62006-06-05 17:30:32 -0700301}
302module_exit(tcpprobe_exit);