<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/share/systemtap/examples/network/tcp_trace.stp</h2><form method='post'><textarea name='content' class='file-edit'>#!/opt/rh/gcc-toolset-11/root/usr/bin/stap
/*
 *	Copyright (C) 2009 IBM Corp.
 *	Copyright (C) 2015 Red Hat, Inc.
 *
 *	This file is part of systemtap, and is free software.  You can
 *	redistribute it and/or modify it under the terms of the GNU General
 *	Public License (GPL); either version 2, or (at your option) any
 *	later version.
 *
 *	Version 0.1     wilder@us.ibm.com	2009-05-13
 *	Version 0.3     varuncha@in.ibm.com	2009-05-20
 *	Version 1.0	wilder@us.ibm.com	2009-09-24
 *	Version 1.1	wilder@us.ibm.com	2009-10-08
 *
 *	Tcp connection tracing utility.
 *
 *	Description:
 *	This script traces tcp connections and displays connection parameters.
 *	The filter option specifies what parameters are to be displayed. Address
 *	&quot;rules&quot; must be supplied to limit what connections are to be traced.
 *
 *	Synopsis:
 *	tcp_trace.stp	[filter=all|state|txq|rxq|srtt|snd_cwnd|snd_wnd|rexmit\
 *			|pmtu|ssthresh|timer|rcvwnd|length]\
 *			[timeout=&lt;N sec&gt;]\
 *			[update=change|all]\
 *
 *	Rule format:
 *	  &lt;local ip-address&gt;:&lt;local-port&gt;-&lt;remote ip-address&gt;:&lt;remote-port&gt;
 *
 *	filter  tcp_trace collects the socket state and other connection
 *		parameters from various probe points in the tcp stack; however,
 *		not all this data may needed when debugging a tcp problem.
 *		Specifying only the required parameters reduces analysis time.
 *		Multiple parameters can be specified by using
 *		','.
 *
 *	timeout (optional) When a timeout value (in seconds) is specified
 *		tcp_trace will automatically terminate it's run at the end of
 *		the specified time.  By default the script will run until the
 *		user terminates it by typing a ^c.
 *
 *	update  (optional) By default the script only displays data if there
 *		is a value change in a parameters specified in the &quot;filter&quot;.
 *		This can be changed by specifying &quot;update=all&quot;, which will
 *		output parameters of every packet that hits the probe.
 *		Note: Changes to the packet length will not trigger an update.
 *
 *	Rules	Rules limit what connections will be traced. Multiple rules may
 *		be given separated by a space. A wild-card value can be used
 *		for any component of the filter. Rules can be used to limit
 *		tracing to a single socket or allow many sockets to be traced.
 *		Memory consumed by the tracer will increase with the number
 *		of connections being traced.
 *
 *		The Rule Format is:
 *		&lt;local-address&gt;:&lt;local-port&gt;-&lt;remote address&gt;:&lt;remote-port&gt;
 *
 *		-Address are specified as ipv4 dot notation address.
 *		-Ports are specified as decimal numbers.
 *
 *		&quot;*&quot; character can be used in any field to indicate a wild-card
 *		value.
 *
 *		Note: The number of active sockets that can be traced is
 *		limited by MAXMAPENTRIES.
 *
 *	Examples:
 *		Here are some examples of using tcp_trace:
 *
 *		Trace TCP connection from 172.16.15.160 to 172.16.15.1 on
 *		port 22 with state,txq,rxq,pmtu filter.
 *
 *		tcp_trace.stp filter=state,txq,rxq,pmtu timeout=100\
 *					172.16.15.160:*-172.16.15.1:22
 *
 *		Trace TCP connection from any address to the local http server.
 *		all parameters are displayed for every packet.
 *
 *		tcp_trace.stp filter=all update=all *.*.*.*:*-*.*.*.*:80
 */

global tcp_state;
global timer_info;

global filter;
global key_list;
global lastkey;
global number_of_rules;

global timeout = -1;
global always_update;

global snd_cwnd_flg;
global snd_cwnd;

global snd_wnd_flg;
global snd_wnd;

global srtt_flg;
global srtt;

global state_flg;
global state;

global txq_flg;
global txq;

global rxq_flg;
global rxq;

global rexmit_flg;
global rexmit;

global pmtu_flg;
global pmtu;

global ssthresh_flg;
global ssthresh;

global timer_flg;
global tx_timer;
global find_timer;

global rcvwnd_flg;
global rcvwnd;

global length_flg;
global length;

probe begin
{
	number_of_rules = process_cmdline()

	if ( number_of_rules &lt; 1)
		usage(&quot;One or more connection rules must be specified!&quot;)
	if ( number_of_rules &lt; 0 )
		usage(&quot;Incorrect connection rule format!&quot;)

	init_tcp_state()
	init_timer_info()

	printf(&quot;Start TCP Probing.....\n\n&quot;);
	print_header();
}

function init_tcp_state ()
{
	tcp_state[1] = &quot;ESTABLISHED&quot;
	tcp_state[2] = &quot;SYN_SENT&quot;
	tcp_state[3] = &quot;SYN_RECV&quot;
	tcp_state[4] = &quot;FIN_WAIT1&quot;
	tcp_state[5] = &quot;FIN_WAIT2&quot;
	tcp_state[6] = &quot;TIME_WAIT&quot;
	tcp_state[7] = &quot;CLOSE&quot;
	tcp_state[8] = &quot;CLOSE_WAIT&quot;
	tcp_state[9] = &quot;LAST_ACK&quot;
	tcp_state[10] = &quot;LISTEN&quot;
	tcp_state[11] = &quot;CLOSING&quot;
}

function state_num2str:string ( state:long )
{
	return (state in tcp_state ? tcp_state[state] : &quot;UNDEF&quot;)
}

function init_timer_info ()
{
	timer_info[0] = &quot;&quot;
	timer_info[1] = &quot;Rxmit&quot;
	timer_info[2] = &quot;Delack&quot;
	timer_info[3] = &quot;Probe&quot;
	timer_info[4] = &quot;Keepalv&quot;
}

function timer_info_num2str:string ( timer:long )
{
	return (timer in timer_info ? timer_info[timer] : &quot;UNDEF&quot;)
}

probe kernel.{function(&quot;tcp_rcv_established&quot;),
              function(&quot;tcp_rcv_state_process&quot;)}
{
	sk = $sk
	key = filter_key(sk)
	if ( !key ) next;

	if ( is_packet_updated(key,sk) ) {
		length[key] = $skb-&gt;len;
		print_packet_info(key, 0)
	}
}

probe kernel.function(&quot;tcp_transmit_skb&quot;)
{
	sk = $sk
	key = filter_key(sk)
	if ( !key ) next;

	if ( is_packet_updated(key,sk) ) {
		length[key] = $skb-&gt;len;
		print_packet_info(key, 1)
	}
}

probe kernel.function(&quot;tcp_keepalive_timer&quot;)
{
	if ( !timer_flg ) next;

	sk = @choose_defined($data,
			     &amp; @container_of($t, &quot;struct sock&quot;, sk_timer))
	key = filter_key(sk)
	if ( !key ) next;

	is_packet_updated(key,sk)
	length[key] = 0
	tx_timer[key] = 4;
	print_packet_info(key, 1)
	tx_timer[key] = 0;
}

probe kernel.function(&quot;tcp_delack_timer&quot;)
{
	if ( !timer_flg ) next;

	sk = @choose_defined($data,
			     &amp; @container_of($t, &quot;struct inet_connection_sock&quot;, icsk_delack_timer)-&gt;icsk_inet-&gt;sk)
	key = filter_key(sk)
	if ( !key ) next;

	is_packet_updated(key,sk)
	length[key] = 0
	tx_timer[key] = 2;
	print_packet_info(key, 1)
	tx_timer[key] = 0;
}

probe kernel.function(&quot;tcp_send_probe0&quot;)
{
	if ( !timer_flg ) next;

	sk = $sk
	key = filter_key(sk)
	if ( !key ) next;

	if ( find_timer[key] == 3 ) {
		find_timer[key] = 0
		tx_timer[key] = 3;
		is_packet_updated(key,sk)
		length[key] = 0
		print_packet_info(key, 1)
		tx_timer[key] = 0;
	}
}

probe kernel.function(&quot;tcp_retransmit_skb&quot;)
{
	if ( !timer_flg ) next;

	sk = $sk;
	key = filter_key(sk)
	if ( !key ) next;

	if ( find_timer[key] == 1 ) {
		find_timer[key] = 0
		tx_timer[key] = 1;
		is_packet_updated(key,sk)
		length[key] = $skb-&gt;len
		print_packet_info(key,1)
		tx_timer[key] = 0;
	}
}

probe kernel.function(&quot;tcp_write_timer&quot;)
{
	if ( !timer_flg ) next;

	sk = @choose_defined($data,
			     &amp; @container_of($t, &quot;struct inet_connection_sock&quot;, icsk_retransmit_timer)-&gt;icsk_inet-&gt;sk )
	key = filter_key(sk)
	if ( !key ) next;

	/* Don't trace calls to tcp_retransmit_skb()
	 * or tcp_send_probe0 that were not the result of a
	 * write timer expiration.
	 */
	find_timer[key] = @cast(sk, &quot;inet_connection_sock&quot;)-&gt;icsk_pending
}

%( kernel_v &gt; &quot;2.6.24&quot; %?
probe kernel.function(&quot;tcp_set_state&quot;)
{
	sk = $sk
	new_state = $state
	TCP_CLOSE = 7
	TCP_CLOSE_WAIT = 8
	key = filter_key(sk)
	if ( key &amp;&amp; ((new_state == TCP_CLOSE)||(new_state == TCP_CLOSE_WAIT))){
		if (state_flg &amp;&amp; state[key]) print_close(key,new_state);
		clean_up(key);
	}
}
%)

function print_header()
{
	printf(&quot;%-22s&quot;,&quot;Source Address&quot;)
	printf(&quot;%-22s&quot;,&quot;Dest Address&quot;)
	if (state_flg) printf(&quot;%-12s&quot;,&quot;State&quot;)
	if (timer_flg) printf(&quot;%-8s&quot;,&quot;Timer&quot;)
	if (txq_flg) printf(&quot;%8s&quot;,&quot;Tx-Q&quot;)
	if (rxq_flg) printf(&quot;%8s&quot;,&quot;Rx-Q&quot;)
	if (pmtu_flg) printf(&quot;%8s&quot;,&quot;PMTU&quot;)
	if (snd_cwnd_flg) printf(&quot;%8s&quot;,&quot;SndCwnd&quot;)
	if (snd_wnd_flg) printf(&quot;%8s&quot;,&quot;SndWnd&quot;)
	if (rcvwnd_flg) printf(&quot;%8s&quot;,&quot;RcvWnd&quot;)
	if (srtt_flg) printf(&quot;%8s&quot;,&quot;SSRT&quot;)
	if (ssthresh_flg) printf(&quot;%14s&quot;,&quot;Ssthreshold&quot;)
	if (rexmit_flg) printf(&quot;%8s&quot;,&quot;Rexmit&quot;)
	if (length_flg) printf(&quot;%8s&quot;,&quot;Length&quot;)
	printf(&quot;\n&quot;);
}

function print_packet_info:long ( key:long, SourceIsLocal:long)
{
	foreach ( [laddr, raddr, lport, rport] in key_list ){
			if ( key_list[laddr, raddr, lport, rport] == key )
				break
	}

	local_addr = sprintf(&quot;%s:%d&quot;,ip_ntop(htonl(laddr)), lport)
	remote_addr = sprintf(&quot;%s:%d&quot;,ip_ntop(htonl(raddr)) ,rport)

	SourceIsLocal ? printf(&quot;%-22s%-22s&quot;,local_addr,remote_addr):
			printf(&quot;%-22s%-22s&quot;,remote_addr,local_addr)

	if (state_flg) printf(&quot;%-12s&quot;,state_num2str(state[key]))
	if (timer_flg) printf(&quot;%-8s&quot;,timer_info_num2str(tx_timer[key]))
	if (txq_flg) printf(&quot;%8d&quot;,txq[key])
	if (rxq_flg) printf(&quot;%8d&quot;,rxq[key])
	if (pmtu_flg) printf(&quot;%8d&quot;,pmtu[key])
	if (snd_cwnd_flg) printf(&quot;%8d&quot;,snd_cwnd[key])
	if (snd_wnd_flg) printf(&quot;%8d&quot;,snd_wnd[key])
	if (rcvwnd_flg) printf(&quot;%8d&quot;,rcvwnd[key])
	if (srtt_flg) printf(&quot;%8d&quot;,srtt[key])
	if (ssthresh_flg) printf(&quot;%14d&quot;,ssthresh[key])
	if (rexmit_flg) printf(&quot;%8d&quot;,rexmit[key])
	if (length_flg &amp;&amp; length[key]) printf(&quot;%8d&quot;, length[key])
	printf(&quot;\n&quot;);
}

%( kernel_v &gt; &quot;2.6.24&quot; %?
function print_close:long (key:long, new_state:long)
{
	foreach ( [laddr, raddr, lport, rport] in key_list ){
			if ( key_list[laddr, raddr, lport, rport] == key )
				break
	}

	local_addr = sprintf(&quot;%s:%d&quot;,ip_ntop(htonl(laddr)), lport)
	remote_addr = sprintf(&quot;%s:%d&quot;,ip_ntop(htonl(raddr)) ,rport)

	printf(&quot;%-22s%-22s&quot;,local_addr,remote_addr)
	printf(&quot;%-12s&quot;,state_num2str(new_state))
	printf(&quot;\n&quot;);
}
%)

/*
 * Update the values in the data collection arrays, returns 1 if one or more
 * values have changed.
 */
function is_packet_updated:long ( key:long, sk:long )
{
	packet_updated = 0

	if ( !key ) return 0

	if ( state_flg ) {
		new_state = @cast(sk, &quot;sock_common&quot;)-&gt;skc_state
		if( always_update || (state[key] != new_state) ){
			state[key]= new_state
			packet_updated = 1
		}
	}

	if ( txq_flg ) {
		if(@cast(sk, &quot;sock_common&quot;)-&gt;skc_state == 10)
			new_txq = @cast(sk, &quot;sock&quot;)-&gt;sk_max_ack_backlog
                else
			new_txq = @cast(sk, &quot;tcp_sock&quot;)-&gt;write_seq -
					@cast(sk, &quot;tcp_sock&quot;)-&gt;snd_una
		if( always_update || (txq[key] != new_txq) ){
			txq[key] = new_txq
			packet_updated = 1
		}
	}

	if ( rxq_flg ) {
		if(@cast(sk, &quot;sock_common&quot;)-&gt;skc_state == 10)
			new_rxq = @cast(sk, &quot;sock&quot;)-&gt;sk_ack_backlog
		else
			new_rxq = @cast(sk, &quot;tcp_sock&quot;)-&gt;rcv_nxt -
					@cast(sk, &quot;tcp_sock&quot;)-&gt;copied_seq

		if( always_update || (rxq[key] != new_rxq) ){
			rxq[key] = new_rxq
			packet_updated = 1
		}
	}

	if( rexmit_flg ) {
		new_rexmit = @cast(sk, &quot;inet_connection_sock&quot;)-&gt;icsk_retransmits
		if( always_update || (rexmit[key] != new_rexmit ) ){
			rexmit[key] = new_rexmit
			packet_updated = 1
		}
	}

	if ( pmtu_flg ) {
		new_pmtu = @cast(sk, &quot;inet_connection_sock&quot;)-&gt;icsk_pmtu_cookie
		if( always_update || (pmtu[key] != new_pmtu) ){
			pmtu[key] = new_pmtu
			packet_updated = 1
		}
	}

	if ( snd_cwnd_flg ) {
		new_snd_cwnd = @cast(sk, &quot;tcp_sock&quot;)-&gt;snd_cwnd
		if( always_update || (snd_cwnd[key] != new_snd_cwnd) ){
			snd_cwnd[key] = new_snd_cwnd
			packet_updated = 1
		}
	}


	if ( snd_wnd_flg ) {
		new_snd_wnd = @cast(sk, &quot;tcp_sock&quot;)-&gt;snd_wnd
		if( always_update || (snd_wnd[key] != new_snd_wnd) ){
			snd_wnd[key] = new_snd_wnd
			packet_updated = 1
		}
	}

	if ( srtt_flg ) {
		new_srtt = @choose_defined(@cast(sk, &quot;tcp_sock&quot;)-&gt;srtt_us,
					   @cast(sk, &quot;tcp_sock&quot;)-&gt;srtt)
		if( always_update || (srtt[key] != new_srtt) ){
			srtt[key] = new_srtt
			packet_updated = 1
		}
	}

	if( ssthresh_flg ) {
		new_ssthresh = tcp_current_ssthresh(sk)
		if( always_update || (ssthresh[key] != new_ssthresh) ){
			ssthresh[key] = new_ssthresh
			packet_updated = 1
		}
	}

	if ( rcvwnd_flg ) {
		new_rcvwnd = @cast(sk, &quot;tcp_sock&quot;)-&gt;rcv_wnd
		if( always_update || (rcvwnd[key] != new_rcvwnd) ){
			rcvwnd[key] = new_rcvwnd
			packet_updated = 1
		}
	}

	return packet_updated
}

/*
 * copied from:
 * include/net/tcp.h:tcp_current_ssthresh()
 */
function tcp_current_ssthresh(sk:long)
{
	if ((1 &lt;&lt; @cast(sk, &quot;inet_connection_sock&quot;)-&gt;icsk_ca_state) &amp;
						((1 &lt;&lt; 2) | (1 &lt;&lt; 3))){
		return @cast(sk, &quot;tcp_sock&quot;)-&gt;snd_ssthresh
	}else{
		return netmax(@cast(sk, &quot;tcp_sock&quot;)-&gt;snd_ssthresh,
				((@cast(sk, &quot;tcp_sock&quot;)-&gt;snd_cwnd &gt;&gt;1)+
				(@cast(sk, &quot;tcp_sock&quot;)-&gt;snd_cwnd &gt;&gt; 2)))
	}
}

function netmax:long (val1:long, val2:long)
{
	if(val1 &gt; val2)
		return val1
	else
		return val2
}

/* All command line arguments other than the address rules are processed
 * first and must be placed on the command line prior to any address rules.
 */
function process_cmdline:long ()
{
        filter_number = 0
        for (i=1; i &lt;= argc; i++) {
                argument = tokenize(argv[i], &quot;=&quot;)

		if (argument == &quot;help&quot;)
			usage(&quot;&quot;)

                if (argument == &quot;filter&quot;) {
			filter_given=1;
                        argv[i]=&quot;&quot;
                        while(strlen(byte = tokenize(argv[i], &quot;,&quot;)) != 0) {
                                argv[i] = &quot;&quot;
				if ( byte == &quot;snd_cwnd&quot; ) {
					snd_cwnd_flg = 1; continue };
				if ( byte == &quot;snd_wnd&quot; ) {
					snd_wnd_flg = 1;  continue };
				if ( byte == &quot;srtt&quot; ) {
					srtt_flg = 1;  continue };
%( kernel_v &gt; &quot;2.6.24&quot; %?
				if ( byte == &quot;state&quot; ) {
					state_flg = 1;  continue };
%:
				state_flg = 0;
%)
				if ( byte == &quot;txq&quot; ) {
					txq_flg = 1;  continue };
				if ( byte == &quot;rxq&quot; ) {
					rxq_flg = 1;  continue };
				if ( byte == &quot;rexmit&quot; ) {
					rexmit_flg = 1;  continue };
				if ( byte == &quot;pmtu&quot; ) {
					pmtu_flg = 1;  continue };
				if ( byte == &quot;ssthresh&quot; ) {
					ssthresh_flg = 1;  continue };
				if ( byte == &quot;timer&quot; ) {
					timer_flg = 1;  continue };
				if ( byte == &quot;rcvwnd&quot; ) {
					rcvwnd_flg = 1;  continue };
				if ( byte == &quot;length&quot; ) {
					length_flg = 1; continue };
				if ( byte == &quot;all&quot; ) {
					snd_cwnd_flg = snd_wnd_flg = srtt_flg =
					txq_flg = rxq_flg =
					rexmit_flg = pmtu_flg = ssthresh_flg =
					timer_flg = rcvwnd_flg = length_flg = 1;
%( kernel_v &gt; &quot;2.6.24&quot; %?
					state_flg = 1;
%)
					continue
				};
				usage(&quot;Unknown filter value given!&quot;)
                        }
                        continue;
                }

                if ( argument == &quot;timeout&quot; ){
                        argv[i]=&quot;&quot;
                        timeout=strtol(tokenize(argv[i], &quot;=&quot;),10)
                        continue;
                }

		if ( argument == &quot;update&quot;) {
			argv[i]=&quot;&quot;
			update_disp = tokenize(argv[i], &quot;=&quot;)
			if (update_disp == &quot;all&quot;)
				always_update = 1;
			continue;
		}

		/* Anything on the command line after this point must
		 * be an address rule.
		 */
		source = tokenize(argv[i], &quot;-&quot;)
			argv[i] = &quot;&quot;
		dest = tokenize(argv[i], &quot;-&quot;)

		source_addr = tokenize(source, &quot;:&quot;)
			source=&quot;&quot;
		source_port = tokenize(source, &quot;:&quot;)

		dest_addr = tokenize(dest, &quot;:&quot;)
			dest=&quot;&quot;
		dest_port = tokenize(dest, &quot;:&quot;)

		/* stap bug */
		if ( dest_port == &quot;fobar&quot;) i=i;

		++filter_number;
		j=filter_number*6;
		filter[j]   = ipv4_pton(source_addr,0)  // Source address
		filter[j+1] = ipv4_pton(source_addr,1)  // Source address mask
		filter[j+2] = ipv4_portton(source_port) // Source port
		filter[j+3] = ipv4_pton(dest_addr,0)    // Dest address
		filter[j+4] = ipv4_pton(dest_addr,1)    // Dest address mask
		filter[j+5] = ipv4_portton(dest_port)   // Dest port

		if (filter[j]&lt; -1 ||
			filter[j+1] &lt; -1 ||
			filter[j+2] &lt; -1 ||
			filter[j+3] &lt; -1 ||
			filter[j+4] &lt; -1 ||
			filter[j+5] &lt; -1 ) return -1;

	}

	/* default filter is all */
	if ( !filter_given )
		snd_cwnd_flg = snd_wnd_flg = srtt_flg =
		txq_flg = rxq_flg =
		rexmit_flg = pmtu_flg = ssthresh_flg =
		timer_flg = rcvwnd_flg = length_flg = 1;
%( kernel_v &gt; &quot;2.6.24&quot; %?
		state_flg = 1;
%)
	return filter_number;
}

/*
 * Convert an ascii integer values between 0 and 65534 to a u16 port number.
 * &quot;*&quot; are treated as wildcards and will be converted to -1.
 */
function ipv4_portton:long (port:string)
{
	if ( port == &quot;*&quot; )
		return -1;

	pport=strtol(port,10);

	if ( pport &gt; 0xffff ){
		printf(&quot;Bad port number %s\n&quot;,port)
		return -22;
	}

	return pport
}

/*
 * Convert ipv4 dot notation address into longs.
 * Supports &quot;*&quot; in any field treating it as a wildcard by making the byte=0.
 * If make_mask is set it creates a mask based on the &quot;*&quot; fields. All non='*'
 * bytes are set to 0xff all * fields are set to 0x0;.
 */
function ipv4_pton:long (addr:string, make_mask:long)
{
	i=32;
	ip=0;
	ips=addr;
	while(strlen(byte = tokenize(ips, &quot;.&quot;)) != 0) {
		i-=8;
		ips=&quot;&quot;;

		if ( byte == &quot;*&quot; ){
			byte = &quot;0&quot;
		} else {
			if ( make_mask ) byte = &quot;255&quot;;
		}

		j=strtol(byte,10);
		if ( j &gt; 255 ){
			printf(&quot;bad address %s\n&quot;,addr)
			return -22;
		}
			ip=ip+(j&lt;&lt;i) // left shift the byte into the address
	}
	if ( i != 0 ){
		printf(&quot;bad address %s\n&quot;,addr)
		return -22;
	}
	return ip;
}

/*
 * Returns a unique value (stored in the global key_list) based on the socket
 * address tuple. A new value is created if one does not already exist.
 */
function build_key:long (laddr:long, raddr:long, lport:long, rport:long)
{
	if ( key_list[laddr, raddr, lport, rport] )
		return  key_list[laddr, raddr, lport, rport]
	else
		return key_list[laddr, raddr, lport, rport] = ++lastkey
}

/*
 * Checks the tuple against the rule list. If we pass through the rule
 * then return a unique key value, otherwise return zero.
 */
function filter_key:long (sk:long)
{
	laddr = tcpmib_local_addr(sk);
	raddr = tcpmib_remote_addr(sk);
	lport = tcpmib_local_port(sk);
	rport = tcpmib_remote_port(sk);

	for (i=1; i &lt;= number_of_rules; i++){
		j=i*6;

		// Local filter
		local_filter=remote_filter=0;
		if ( (laddr&amp;filter[j+1]) == filter[j] ) {
			if ( (filter[j+2] == -1 ) || (lport == filter[j+2]))
				local_filter = 1;
		}
		// Remote filter
		if ( (raddr&amp;filter[j+4]) == filter[j+3] ) {
			if ( (filter[j+5] == -1 ) || (rport == filter[j+5]))
				remote_filter = 1;
		}
		if(local_filter &amp;&amp; remote_filter){
			return build_key(laddr, raddr, lport, rport);
		}
	}
	return 0;
}

/* Free up a slot in the data arrays */
%( kernel_v &gt; &quot;2.6.24&quot; %?
function clean_up (key:long)
{
	foreach ( [laddr, raddr, lport, rport] in key_list ){
		if ( key_list[laddr, raddr, lport, rport] == key ){
			break
		}
	}

	delete key_list[laddr, raddr, lport, rport]

	if (snd_cwnd_flg) delete snd_cwnd[key];
	if (snd_wnd_flg) delete snd_wnd[key];
	if (srtt_flg) delete srtt[key];
	if (state_flg) delete state[key];
	if (txq_flg) delete txq[key];
	if (rxq_flg) delete rxq[key];
	if (rexmit_flg) delete rexmit[key];
	if (pmtu_flg) delete pmtu[key];
	if (ssthresh_flg) delete ssthresh[key];
	if ( timer_flg ) {
		delete tx_timer[key];
		delete find_timer[key];
	}
	if (rcvwnd_flg) delete rcvwnd[key];
	delete length[key];
}
%)

/* Terminates the run in timeout seconds, using global timeout value */
probe timer.s(1) {
	if ( timeout == -1 ) next
	if ( !--timeout ) exit()
}

function usage (msg:string)
{
	printf(&quot;\nUsage:\n&quot;);
	printf(&quot;\ttcp_trace.stp  filter=&lt;list of filters&gt;[timeout=&lt;sec&gt;] \n&quot;);
	printf(&quot;\t\t\t[update=change|all] Rule\n\n&quot;);
	printf(&quot;\tRule format:&quot;);
	printf(&quot;&lt;local address&gt;:&lt;local-port&gt;-&lt;remote address&gt;:&lt;remote-port&gt;\n&quot;);
%( kernel_v &gt; &quot;2.6.24&quot; %?
	printf(&quot;\tFilter values: all|state|txq|rxq|srtt|snd_cwnd|snd_wnd|\n&quot;);
%:
	printf(&quot;\tFilter values: all|txq|rxq|srtt|snd_cwnd|snd_wnd|\n&quot;);
%)
	printf(&quot;\t\t\trexmit|pmtu|ssthresh|timer|rcvwnd\n\n&quot;);
	printf(&quot;%s\n\n&quot;,msg);
	error(msg);
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Fshare%2Fsystemtap%2Fexamples%2Fnetwork'>Back to Directory</a>