From owner-svn-src-user@FreeBSD.ORG Mon Apr 8 20:11:05 2013 Return-Path: Delivered-To: svn-src-user@freebsd.org Received: from mx1.freebsd.org (mx1.FreeBSD.org [8.8.178.115]) by hub.freebsd.org (Postfix) with ESMTP id 6CF3DD94; Mon, 8 Apr 2013 20:11:05 +0000 (UTC) (envelope-from attilio@FreeBSD.org) Received: from svn.freebsd.org (svn.freebsd.org [IPv6:2001:1900:2254:2068::e6a:0]) by mx1.freebsd.org (Postfix) with ESMTP id 5FA37890; Mon, 8 Apr 2013 20:11:05 +0000 (UTC) Received: from svn.freebsd.org ([127.0.1.70]) by svn.freebsd.org (8.14.6/8.14.6) with ESMTP id r38KB5iv006453; Mon, 8 Apr 2013 20:11:05 GMT (envelope-from attilio@svn.freebsd.org) Received: (from attilio@localhost) by svn.freebsd.org (8.14.6/8.14.5/Submit) id r38KB3BO006443; Mon, 8 Apr 2013 20:11:03 GMT (envelope-from attilio@svn.freebsd.org) Message-Id: <201304082011.r38KB3BO006443@svn.freebsd.org> From: Attilio Rao Date: Mon, 8 Apr 2013 20:11:03 +0000 (UTC) To: src-committers@freebsd.org, svn-src-user@freebsd.org Subject: svn commit: r249279 - in user/attilio/vmcontention: sys/kern sys/netinet sys/vm usr.bin/netstat X-SVN-Group: user MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: svn-src-user@freebsd.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: "SVN commit messages for the experimental " user" src tree" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 08 Apr 2013 20:11:05 -0000 Author: attilio Date: Mon Apr 8 20:11:03 2013 New Revision: 249279 URL: http://svnweb.freebsd.org/changeset/base/249279 Log: MFC Modified: user/attilio/vmcontention/sys/kern/imgact_elf.c user/attilio/vmcontention/sys/kern/kern_proc.c user/attilio/vmcontention/sys/kern/sys_process.c user/attilio/vmcontention/sys/netinet/ip_input.c user/attilio/vmcontention/sys/netinet/ip_var.h user/attilio/vmcontention/sys/netinet/tcp_input.c user/attilio/vmcontention/sys/netinet/tcp_var.h user/attilio/vmcontention/sys/vm/vm_page.h user/attilio/vmcontention/sys/vm/vm_pageout.c user/attilio/vmcontention/usr.bin/netstat/inet.c Directory Properties: user/attilio/vmcontention/ (props changed) user/attilio/vmcontention/sys/ (props changed) Modified: user/attilio/vmcontention/sys/kern/imgact_elf.c ============================================================================== --- user/attilio/vmcontention/sys/kern/imgact_elf.c Mon Apr 8 20:02:27 2013 (r249278) +++ user/attilio/vmcontention/sys/kern/imgact_elf.c Mon Apr 8 20:11:03 2013 (r249279) @@ -1277,15 +1277,15 @@ each_writable_segment(td, func, closure) continue; /* Ignore memory-mapped devices and such things. */ - VM_OBJECT_WLOCK(object); + VM_OBJECT_RLOCK(object); while ((backing_object = object->backing_object) != NULL) { - VM_OBJECT_WLOCK(backing_object); - VM_OBJECT_WUNLOCK(object); + VM_OBJECT_RLOCK(backing_object); + VM_OBJECT_RUNLOCK(object); object = backing_object; } ignore_entry = object->type != OBJT_DEFAULT && object->type != OBJT_SWAP && object->type != OBJT_VNODE; - VM_OBJECT_WUNLOCK(object); + VM_OBJECT_RUNLOCK(object); if (ignore_entry) continue; Modified: user/attilio/vmcontention/sys/kern/kern_proc.c ============================================================================== --- user/attilio/vmcontention/sys/kern/kern_proc.c Mon Apr 8 20:02:27 2013 (r249278) +++ user/attilio/vmcontention/sys/kern/kern_proc.c Mon Apr 8 20:11:03 2013 (r249279) @@ -1995,7 +1995,7 @@ sysctl_kern_proc_ovmmap(SYSCTL_HANDLER_A kve->kve_private_resident = 0; obj = entry->object.vm_object; if (obj != NULL) { - VM_OBJECT_WLOCK(obj); + VM_OBJECT_RLOCK(obj); if (obj->shadow_count == 1) kve->kve_private_resident = obj->resident_page_count; @@ -2010,9 +2010,9 @@ sysctl_kern_proc_ovmmap(SYSCTL_HANDLER_A for (lobj = tobj = obj; tobj; tobj = tobj->backing_object) { if (tobj != obj) - VM_OBJECT_WLOCK(tobj); + VM_OBJECT_RLOCK(tobj); if (lobj != obj) - VM_OBJECT_WUNLOCK(lobj); + VM_OBJECT_RUNLOCK(lobj); lobj = tobj; } @@ -2072,11 +2072,11 @@ sysctl_kern_proc_ovmmap(SYSCTL_HANDLER_A break; } if (lobj != obj) - VM_OBJECT_WUNLOCK(lobj); + VM_OBJECT_RUNLOCK(lobj); kve->kve_ref_count = obj->ref_count; kve->kve_shadow_count = obj->shadow_count; - VM_OBJECT_WUNLOCK(obj); + VM_OBJECT_RUNLOCK(obj); if (vp != NULL) { vn_fullpath(curthread, vp, &fullpath, &freepath); @@ -2162,7 +2162,7 @@ sysctl_kern_proc_vmmap(SYSCTL_HANDLER_AR kve->kve_private_resident = 0; obj = entry->object.vm_object; if (obj != NULL) { - VM_OBJECT_WLOCK(obj); + VM_OBJECT_RLOCK(obj); if (obj->shadow_count == 1) kve->kve_private_resident = obj->resident_page_count; @@ -2183,9 +2183,9 @@ sysctl_kern_proc_vmmap(SYSCTL_HANDLER_AR for (lobj = tobj = obj; tobj; tobj = tobj->backing_object) { if (tobj != obj) - VM_OBJECT_WLOCK(tobj); + VM_OBJECT_RLOCK(tobj); if (lobj != obj) - VM_OBJECT_WUNLOCK(lobj); + VM_OBJECT_RUNLOCK(lobj); lobj = tobj; } @@ -2247,11 +2247,11 @@ sysctl_kern_proc_vmmap(SYSCTL_HANDLER_AR break; } if (lobj != obj) - VM_OBJECT_WUNLOCK(lobj); + VM_OBJECT_RUNLOCK(lobj); kve->kve_ref_count = obj->ref_count; kve->kve_shadow_count = obj->shadow_count; - VM_OBJECT_WUNLOCK(obj); + VM_OBJECT_RUNLOCK(obj); if (vp != NULL) { vn_fullpath(curthread, vp, &fullpath, &freepath); Modified: user/attilio/vmcontention/sys/kern/sys_process.c ============================================================================== --- user/attilio/vmcontention/sys/kern/sys_process.c Mon Apr 8 20:02:27 2013 (r249278) +++ user/attilio/vmcontention/sys/kern/sys_process.c Mon Apr 8 20:11:03 2013 (r249279) @@ -382,7 +382,7 @@ ptrace_vm_entry(struct thread *td, struc obj = entry->object.vm_object; if (obj != NULL) - VM_OBJECT_WLOCK(obj); + VM_OBJECT_RLOCK(obj); } while (0); vm_map_unlock_read(map); @@ -395,9 +395,9 @@ ptrace_vm_entry(struct thread *td, struc lobj = obj; for (tobj = obj; tobj != NULL; tobj = tobj->backing_object) { if (tobj != obj) - VM_OBJECT_WLOCK(tobj); + VM_OBJECT_RLOCK(tobj); if (lobj != obj) - VM_OBJECT_WUNLOCK(lobj); + VM_OBJECT_RUNLOCK(lobj); lobj = tobj; pve->pve_offset += tobj->backing_object_offset; } @@ -405,8 +405,8 @@ ptrace_vm_entry(struct thread *td, struc if (vp != NULL) vref(vp); if (lobj != obj) - VM_OBJECT_WUNLOCK(lobj); - VM_OBJECT_WUNLOCK(obj); + VM_OBJECT_RUNLOCK(lobj); + VM_OBJECT_RUNLOCK(obj); if (vp != NULL) { freepath = NULL; Modified: user/attilio/vmcontention/sys/netinet/ip_input.c ============================================================================== --- user/attilio/vmcontention/sys/netinet/ip_input.c Mon Apr 8 20:02:27 2013 (r249278) +++ user/attilio/vmcontention/sys/netinet/ip_input.c Mon Apr 8 20:11:03 2013 (r249279) @@ -153,11 +153,6 @@ VNET_DEFINE(struct in_ifaddrhead, in_ifa VNET_DEFINE(struct in_ifaddrhashhead *, in_ifaddrhashtbl); /* inet addr hash table */ VNET_DEFINE(u_long, in_ifaddrhmask); /* mask for hash table */ -VNET_DEFINE(struct ipstat, ipstat); -SYSCTL_VNET_STRUCT(_net_inet_ip, IPCTL_STATS, stats, CTLFLAG_RW, - &VNET_NAME(ipstat), ipstat, - "IP statistics (struct ipstat, netinet/ip_var.h)"); - static VNET_DEFINE(uma_zone_t, ipq_zone); static VNET_DEFINE(TAILQ_HEAD(ipqhead, ipq), ipq[IPREASS_NHASH]); static struct mtx ipqlock; @@ -213,24 +208,89 @@ SYSCTL_VNET_INT(_net_inet_ip, OID_AUTO, static void ip_freef(struct ipqhead *, struct ipq *); /* + * IP statistics are stored in struct ipstat_p, which is + * an "array" of counter(9)s. Although it isn't a real + * array, we treat it as array to reduce code bloat. + */ +VNET_DEFINE(struct ipstat_p, ipstatp); + +static void +vnet_ipstatp_init(const void *unused) +{ + counter_u64_t *c; + int i; + + for (i = 0, c = (counter_u64_t *)&V_ipstatp; + i < sizeof(V_ipstatp) / sizeof(counter_u64_t); + i++, c++) { + *c = counter_u64_alloc(M_WAITOK); + counter_u64_zero(*c); + } +} +VNET_SYSINIT(vnet_ipstatp_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, + vnet_ipstatp_init, NULL); + +#ifdef VIMAGE +static void +vnet_ipstatp_uninit(const void *unused) +{ + counter_u64_t *c; + int i; + + for (i = 0, c = (counter_u64_t *)&V_ipstatp; + i < sizeof(V_ipstatp) / sizeof(counter_u64_t); + i++, c++) + counter_u64_free(*c); +} +VNET_SYSUNINIT(vnet_ipstatp_uninit, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, + vnet_ipstatp_uninit, NULL); +#endif /* VIMAGE */ + +static int +ipstat_sysctl(SYSCTL_HANDLER_ARGS) +{ + struct ipstat ipstat; + counter_u64_t *c; + uint64_t *v; + int i; + + for (i = 0, c = (counter_u64_t *)&V_ipstatp, v = (uint64_t *)&ipstat; + i < sizeof(V_ipstatp) / sizeof(counter_u64_t); + i++, c++, v++) { + *v = counter_u64_fetch(*c); + /* + * Old interface allowed to rewrite 'struct ipstat', and + * netstat(1) used it to zero the structure. To keep + * compatibility with old netstat(1) we will zero out + * statistics on every write attempt, however we no longer + * support writing arbitrary fake values to the statistics. + */ + if (req->newptr) + counter_u64_zero(*c); + } + + return (SYSCTL_OUT(req, &ipstat, sizeof(ipstat))); +} +SYSCTL_VNET_PROC(_net_inet_ip, IPCTL_STATS, stats, CTLTYPE_OPAQUE | CTLFLAG_RW, + NULL, 0, ipstat_sysctl, "I", + "IP statistics (struct ipstat, netinet/ip_var.h)"); + +/* * Kernel module interface for updating ipstat. The argument is an index - * into ipstat treated as an array of u_long. While this encodes the general - * layout of ipstat into the caller, it doesn't encode its location, so that - * future changes to add, for example, per-CPU stats support won't cause - * binary compatibility problems for kernel modules. + * into ipstat treated as an array. */ void kmod_ipstat_inc(int statnum) { - (*((u_long *)&V_ipstat + statnum))++; + counter_u64_add((counter_u64_t )&V_ipstatp + statnum, 1); } void kmod_ipstat_dec(int statnum) { - (*((u_long *)&V_ipstat + statnum))--; + counter_u64_add((counter_u64_t )&V_ipstatp + statnum, -1); } static int Modified: user/attilio/vmcontention/sys/netinet/ip_var.h ============================================================================== --- user/attilio/vmcontention/sys/netinet/ip_var.h Mon Apr 8 20:02:27 2013 (r249278) +++ user/attilio/vmcontention/sys/netinet/ip_var.h Mon Apr 8 20:11:03 2013 (r249279) @@ -97,59 +97,95 @@ struct ip_moptions { }; struct ipstat { - u_long ips_total; /* total packets received */ - u_long ips_badsum; /* checksum bad */ - u_long ips_tooshort; /* packet too short */ - u_long ips_toosmall; /* not enough data */ - u_long ips_badhlen; /* ip header length < data size */ - u_long ips_badlen; /* ip length < ip header length */ - u_long ips_fragments; /* fragments received */ - u_long ips_fragdropped; /* frags dropped (dups, out of space) */ - u_long ips_fragtimeout; /* fragments timed out */ - u_long ips_forward; /* packets forwarded */ - u_long ips_fastforward; /* packets fast forwarded */ - u_long ips_cantforward; /* packets rcvd for unreachable dest */ - u_long ips_redirectsent; /* packets forwarded on same net */ - u_long ips_noproto; /* unknown or unsupported protocol */ - u_long ips_delivered; /* datagrams delivered to upper level*/ - u_long ips_localout; /* total ip packets generated here */ - u_long ips_odropped; /* lost packets due to nobufs, etc. */ - u_long ips_reassembled; /* total packets reassembled ok */ - u_long ips_fragmented; /* datagrams successfully fragmented */ - u_long ips_ofragments; /* output fragments created */ - u_long ips_cantfrag; /* don't fragment flag was set, etc. */ - u_long ips_badoptions; /* error in option processing */ - u_long ips_noroute; /* packets discarded due to no route */ - u_long ips_badvers; /* ip version != 4 */ - u_long ips_rawout; /* total raw ip packets generated */ - u_long ips_toolong; /* ip length > max ip packet size */ - u_long ips_notmember; /* multicasts for unregistered grps */ - u_long ips_nogif; /* no match gif found */ - u_long ips_badaddr; /* invalid address on header */ + uint64_t ips_total; /* total packets received */ + uint64_t ips_badsum; /* checksum bad */ + uint64_t ips_tooshort; /* packet too short */ + uint64_t ips_toosmall; /* not enough data */ + uint64_t ips_badhlen; /* ip header length < data size */ + uint64_t ips_badlen; /* ip length < ip header length */ + uint64_t ips_fragments; /* fragments received */ + uint64_t ips_fragdropped; /* frags dropped (dups, out of space) */ + uint64_t ips_fragtimeout; /* fragments timed out */ + uint64_t ips_forward; /* packets forwarded */ + uint64_t ips_fastforward; /* packets fast forwarded */ + uint64_t ips_cantforward; /* packets rcvd for unreachable dest */ + uint64_t ips_redirectsent; /* packets forwarded on same net */ + uint64_t ips_noproto; /* unknown or unsupported protocol */ + uint64_t ips_delivered; /* datagrams delivered to upper level*/ + uint64_t ips_localout; /* total ip packets generated here */ + uint64_t ips_odropped; /* lost packets due to nobufs, etc. */ + uint64_t ips_reassembled; /* total packets reassembled ok */ + uint64_t ips_fragmented; /* datagrams successfully fragmented */ + uint64_t ips_ofragments; /* output fragments created */ + uint64_t ips_cantfrag; /* don't fragment flag was set, etc. */ + uint64_t ips_badoptions; /* error in option processing */ + uint64_t ips_noroute; /* packets discarded due to no route */ + uint64_t ips_badvers; /* ip version != 4 */ + uint64_t ips_rawout; /* total raw ip packets generated */ + uint64_t ips_toolong; /* ip length > max ip packet size */ + uint64_t ips_notmember; /* multicasts for unregistered grps */ + uint64_t ips_nogif; /* no match gif found */ + uint64_t ips_badaddr; /* invalid address on header */ }; #ifdef _KERNEL +#include #include +/* Should match 'struct ipstat' above. */ +struct ipstat_p { + counter_u64_t ips_total; + counter_u64_t ips_badsum; + counter_u64_t ips_tooshort; + counter_u64_t ips_toosmall; + counter_u64_t ips_badhlen; + counter_u64_t ips_badlen; + counter_u64_t ips_fragments; + counter_u64_t ips_fragdropped; + counter_u64_t ips_fragtimeout; + counter_u64_t ips_forward; + counter_u64_t ips_fastforward; + counter_u64_t ips_cantforward; + counter_u64_t ips_redirectsent; + counter_u64_t ips_noproto; + counter_u64_t ips_delivered; + counter_u64_t ips_localout; + counter_u64_t ips_odropped; + counter_u64_t ips_reassembled; + counter_u64_t ips_fragmented; + counter_u64_t ips_ofragments; + counter_u64_t ips_cantfrag; + counter_u64_t ips_badoptions; + counter_u64_t ips_noroute; + counter_u64_t ips_badvers; + counter_u64_t ips_rawout; + counter_u64_t ips_toolong; + counter_u64_t ips_notmember; + counter_u64_t ips_nogif; + counter_u64_t ips_badaddr; +}; +VNET_DECLARE(struct ipstat_p, ipstatp); +#define V_ipstatp VNET(ipstatp) + /* * In-kernel consumers can use these accessor macros directly to update * stats. */ -#define IPSTAT_ADD(name, val) V_ipstat.name += (val) -#define IPSTAT_SUB(name, val) V_ipstat.name -= (val) +#define IPSTAT_ADD(name, val) counter_u64_add(V_ipstatp.name, (val)) +#define IPSTAT_SUB(name, val) counter_u64_subtract(V_ipstatp.name, (val)) #define IPSTAT_INC(name) IPSTAT_ADD(name, 1) -#define IPSTAT_DEC(name) IPSTAT_SUB(name, 1) +#define IPSTAT_DEC(name) IPSTAT_ADD(name, -1) /* * Kernel module consumers must use this accessor macro. */ void kmod_ipstat_inc(int statnum); #define KMOD_IPSTAT_INC(name) \ - kmod_ipstat_inc(offsetof(struct ipstat, name) / sizeof(u_long)) + kmod_ipstat_inc(offsetof(struct ipstat_p, name) / sizeof(counter_u64_t)) void kmod_ipstat_dec(int statnum); #define KMOD_IPSTAT_DEC(name) \ - kmod_ipstat_dec(offsetof(struct ipstat, name) / sizeof(u_long)) + kmod_ipstat_dec(offsetof(struct ipstat_p, name) / sizeof(counter_u64_t)) /* flags passed to ip_output as last parameter */ #define IP_FORWARDING 0x1 /* most of ip header exists */ @@ -176,7 +212,6 @@ struct inpcb; struct route; struct sockopt; -VNET_DECLARE(struct ipstat, ipstat); VNET_DECLARE(u_short, ip_id); /* ip packet ctr, for ids */ VNET_DECLARE(int, ip_defttl); /* default IP ttl */ VNET_DECLARE(int, ipforwarding); /* ip forwarding */ @@ -192,7 +227,6 @@ VNET_DECLARE(int, rsvp_on); VNET_DECLARE(int, drop_redirect); extern struct pr_usrreqs rip_usrreqs; -#define V_ipstat VNET(ipstat) #define V_ip_id VNET(ip_id) #define V_ip_defttl VNET(ip_defttl) #define V_ipforwarding VNET(ipforwarding) Modified: user/attilio/vmcontention/sys/netinet/tcp_input.c ============================================================================== --- user/attilio/vmcontention/sys/netinet/tcp_input.c Mon Apr 8 20:02:27 2013 (r249278) +++ user/attilio/vmcontention/sys/netinet/tcp_input.c Mon Apr 8 20:11:03 2013 (r249279) @@ -120,11 +120,6 @@ __FBSDID("$FreeBSD$"); const int tcprexmtthresh = 3; -VNET_DEFINE(struct tcpstat, tcpstat); -SYSCTL_VNET_STRUCT(_net_inet_tcp, TCPCTL_STATS, stats, CTLFLAG_RW, - &VNET_NAME(tcpstat), tcpstat, - "TCP statistics (struct tcpstat, netinet/tcp_var.h)"); - int tcp_log_in_vain = 0; SYSCTL_INT(_net_inet_tcp, OID_AUTO, log_in_vain, CTLFLAG_RW, &tcp_log_in_vain, 0, @@ -245,17 +240,76 @@ static void inline hhook_run_tcp_est_in( struct tcphdr *th, struct tcpopt *to); /* + * TCP statistics are stored in struct tcpstat_p, which is + * an "array" of counter(9)s. Although it isn't a real + * array, we treat it as array to reduce code bloat. + */ +VNET_DEFINE(struct tcpstat_p, tcpstatp); + +static void +vnet_tcpstatp_init(const void *unused) +{ + counter_u64_t *c; + int i; + + for (i = 0, c = (counter_u64_t *)&V_tcpstatp; + i < sizeof(V_tcpstatp) / sizeof(counter_u64_t); + i++, c++) { + *c = counter_u64_alloc(M_WAITOK); + counter_u64_zero(*c); + } +} +VNET_SYSINIT(vnet_tcpstatp_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, + vnet_tcpstatp_init, NULL); + +#ifdef VIMAGE +static void +vnet_tcpstatp_uninit(const void *unused) +{ + counter_u64_t *c; + int i; + + for (i = 0, c = (counter_u64_t *)&V_tcpstatp; + i < sizeof(V_tcpstatp) / sizeof(counter_u64_t); + i++, c++) + counter_u64_free(*c); +} +VNET_SYSUNINIT(vnet_tcpstatp_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, + vnet_ipstatp_uninit, NULL); +#endif /* VIMAGE */ + +static int +tcpstat_sysctl(SYSCTL_HANDLER_ARGS) +{ + struct tcpstat tcpstat; + counter_u64_t *c; + uint64_t *v; + int i; + + for (i = 0, c = (counter_u64_t *)&V_tcpstatp, v = (uint64_t *)&tcpstat; + i < sizeof(V_tcpstatp) / sizeof(counter_u64_t); + i++, c++, v++) { + *v = counter_u64_fetch(*c); + if (req->newptr) + counter_u64_zero(*c); + } + + return (SYSCTL_OUT(req, &tcpstat, sizeof(tcpstat))); +} + +SYSCTL_VNET_PROC(_net_inet_tcp, TCPCTL_STATS, stats, CTLTYPE_OPAQUE | + CTLFLAG_RW, NULL, 0, tcpstat_sysctl, "I", + "TCP statistics (struct tcpstat, netinet/tcp_var.h)"); + +/* * Kernel module interface for updating tcpstat. The argument is an index - * into tcpstat treated as an array of u_long. While this encodes the - * general layout of tcpstat into the caller, it doesn't encode its location, - * so that future changes to add, for example, per-CPU stats support won't - * cause binary compatibility problems for kernel modules. + * into tcpstat treated as an array. */ void kmod_tcpstat_inc(int statnum) { - (*((u_long *)&V_tcpstat + statnum))++; + counter_u64_add((counter_u64_t )&V_tcpstatp + statnum, 1); } /* Modified: user/attilio/vmcontention/sys/netinet/tcp_var.h ============================================================================== --- user/attilio/vmcontention/sys/netinet/tcp_var.h Mon Apr 8 20:02:27 2013 (r249278) +++ user/attilio/vmcontention/sys/netinet/tcp_var.h Mon Apr 8 20:11:03 2013 (r249279) @@ -389,125 +389,233 @@ struct tcptw { * but that's inconvenient at the moment. */ struct tcpstat { - u_long tcps_connattempt; /* connections initiated */ - u_long tcps_accepts; /* connections accepted */ - u_long tcps_connects; /* connections established */ - u_long tcps_drops; /* connections dropped */ - u_long tcps_conndrops; /* embryonic connections dropped */ - u_long tcps_minmssdrops; /* average minmss too low drops */ - u_long tcps_closed; /* conn. closed (includes drops) */ - u_long tcps_segstimed; /* segs where we tried to get rtt */ - u_long tcps_rttupdated; /* times we succeeded */ - u_long tcps_delack; /* delayed acks sent */ - u_long tcps_timeoutdrop; /* conn. dropped in rxmt timeout */ - u_long tcps_rexmttimeo; /* retransmit timeouts */ - u_long tcps_persisttimeo; /* persist timeouts */ - u_long tcps_keeptimeo; /* keepalive timeouts */ - u_long tcps_keepprobe; /* keepalive probes sent */ - u_long tcps_keepdrops; /* connections dropped in keepalive */ - - u_long tcps_sndtotal; /* total packets sent */ - u_long tcps_sndpack; /* data packets sent */ - u_long tcps_sndbyte; /* data bytes sent */ - u_long tcps_sndrexmitpack; /* data packets retransmitted */ - u_long tcps_sndrexmitbyte; /* data bytes retransmitted */ - u_long tcps_sndrexmitbad; /* unnecessary packet retransmissions */ - u_long tcps_sndacks; /* ack-only packets sent */ - u_long tcps_sndprobe; /* window probes sent */ - u_long tcps_sndurg; /* packets sent with URG only */ - u_long tcps_sndwinup; /* window update-only packets sent */ - u_long tcps_sndctrl; /* control (SYN|FIN|RST) packets sent */ - - u_long tcps_rcvtotal; /* total packets received */ - u_long tcps_rcvpack; /* packets received in sequence */ - u_long tcps_rcvbyte; /* bytes received in sequence */ - u_long tcps_rcvbadsum; /* packets received with ccksum errs */ - u_long tcps_rcvbadoff; /* packets received with bad offset */ - u_long tcps_rcvmemdrop; /* packets dropped for lack of memory */ - u_long tcps_rcvshort; /* packets received too short */ - u_long tcps_rcvduppack; /* duplicate-only packets received */ - u_long tcps_rcvdupbyte; /* duplicate-only bytes received */ - u_long tcps_rcvpartduppack; /* packets with some duplicate data */ - u_long tcps_rcvpartdupbyte; /* dup. bytes in part-dup. packets */ - u_long tcps_rcvoopack; /* out-of-order packets received */ - u_long tcps_rcvoobyte; /* out-of-order bytes received */ - u_long tcps_rcvpackafterwin; /* packets with data after window */ - u_long tcps_rcvbyteafterwin; /* bytes rcvd after window */ - u_long tcps_rcvafterclose; /* packets rcvd after "close" */ - u_long tcps_rcvwinprobe; /* rcvd window probe packets */ - u_long tcps_rcvdupack; /* rcvd duplicate acks */ - u_long tcps_rcvacktoomuch; /* rcvd acks for unsent data */ - u_long tcps_rcvackpack; /* rcvd ack packets */ - u_long tcps_rcvackbyte; /* bytes acked by rcvd acks */ - u_long tcps_rcvwinupd; /* rcvd window update packets */ - u_long tcps_pawsdrop; /* segments dropped due to PAWS */ - u_long tcps_predack; /* times hdr predict ok for acks */ - u_long tcps_preddat; /* times hdr predict ok for data pkts */ - u_long tcps_pcbcachemiss; - u_long tcps_cachedrtt; /* times cached RTT in route updated */ - u_long tcps_cachedrttvar; /* times cached rttvar updated */ - u_long tcps_cachedssthresh; /* times cached ssthresh updated */ - u_long tcps_usedrtt; /* times RTT initialized from route */ - u_long tcps_usedrttvar; /* times RTTVAR initialized from rt */ - u_long tcps_usedssthresh; /* times ssthresh initialized from rt*/ - u_long tcps_persistdrop; /* timeout in persist state */ - u_long tcps_badsyn; /* bogus SYN, e.g. premature ACK */ - u_long tcps_mturesent; /* resends due to MTU discovery */ - u_long tcps_listendrop; /* listen queue overflows */ - u_long tcps_badrst; /* ignored RSTs in the window */ - - u_long tcps_sc_added; /* entry added to syncache */ - u_long tcps_sc_retransmitted; /* syncache entry was retransmitted */ - u_long tcps_sc_dupsyn; /* duplicate SYN packet */ - u_long tcps_sc_dropped; /* could not reply to packet */ - u_long tcps_sc_completed; /* successful extraction of entry */ - u_long tcps_sc_bucketoverflow; /* syncache per-bucket limit hit */ - u_long tcps_sc_cacheoverflow; /* syncache cache limit hit */ - u_long tcps_sc_reset; /* RST removed entry from syncache */ - u_long tcps_sc_stale; /* timed out or listen socket gone */ - u_long tcps_sc_aborted; /* syncache entry aborted */ - u_long tcps_sc_badack; /* removed due to bad ACK */ - u_long tcps_sc_unreach; /* ICMP unreachable received */ - u_long tcps_sc_zonefail; /* zalloc() failed */ - u_long tcps_sc_sendcookie; /* SYN cookie sent */ - u_long tcps_sc_recvcookie; /* SYN cookie received */ + uint64_t tcps_connattempt; /* connections initiated */ + uint64_t tcps_accepts; /* connections accepted */ + uint64_t tcps_connects; /* connections established */ + uint64_t tcps_drops; /* connections dropped */ + uint64_t tcps_conndrops; /* embryonic connections dropped */ + uint64_t tcps_minmssdrops; /* average minmss too low drops */ + uint64_t tcps_closed; /* conn. closed (includes drops) */ + uint64_t tcps_segstimed; /* segs where we tried to get rtt */ + uint64_t tcps_rttupdated; /* times we succeeded */ + uint64_t tcps_delack; /* delayed acks sent */ + uint64_t tcps_timeoutdrop; /* conn. dropped in rxmt timeout */ + uint64_t tcps_rexmttimeo; /* retransmit timeouts */ + uint64_t tcps_persisttimeo; /* persist timeouts */ + uint64_t tcps_keeptimeo; /* keepalive timeouts */ + uint64_t tcps_keepprobe; /* keepalive probes sent */ + uint64_t tcps_keepdrops; /* connections dropped in keepalive */ + + uint64_t tcps_sndtotal; /* total packets sent */ + uint64_t tcps_sndpack; /* data packets sent */ + uint64_t tcps_sndbyte; /* data bytes sent */ + uint64_t tcps_sndrexmitpack; /* data packets retransmitted */ + uint64_t tcps_sndrexmitbyte; /* data bytes retransmitted */ + uint64_t tcps_sndrexmitbad; /* unnecessary packet retransmissions */ + uint64_t tcps_sndacks; /* ack-only packets sent */ + uint64_t tcps_sndprobe; /* window probes sent */ + uint64_t tcps_sndurg; /* packets sent with URG only */ + uint64_t tcps_sndwinup; /* window update-only packets sent */ + uint64_t tcps_sndctrl; /* control (SYN|FIN|RST) packets sent */ + + uint64_t tcps_rcvtotal; /* total packets received */ + uint64_t tcps_rcvpack; /* packets received in sequence */ + uint64_t tcps_rcvbyte; /* bytes received in sequence */ + uint64_t tcps_rcvbadsum; /* packets received with ccksum errs */ + uint64_t tcps_rcvbadoff; /* packets received with bad offset */ + uint64_t tcps_rcvmemdrop; /* packets dropped for lack of memory */ + uint64_t tcps_rcvshort; /* packets received too short */ + uint64_t tcps_rcvduppack; /* duplicate-only packets received */ + uint64_t tcps_rcvdupbyte; /* duplicate-only bytes received */ + uint64_t tcps_rcvpartduppack; /* packets with some duplicate data */ + uint64_t tcps_rcvpartdupbyte; /* dup. bytes in part-dup. packets */ + uint64_t tcps_rcvoopack; /* out-of-order packets received */ + uint64_t tcps_rcvoobyte; /* out-of-order bytes received */ + uint64_t tcps_rcvpackafterwin; /* packets with data after window */ + uint64_t tcps_rcvbyteafterwin; /* bytes rcvd after window */ + uint64_t tcps_rcvafterclose; /* packets rcvd after "close" */ + uint64_t tcps_rcvwinprobe; /* rcvd window probe packets */ + uint64_t tcps_rcvdupack; /* rcvd duplicate acks */ + uint64_t tcps_rcvacktoomuch; /* rcvd acks for unsent data */ + uint64_t tcps_rcvackpack; /* rcvd ack packets */ + uint64_t tcps_rcvackbyte; /* bytes acked by rcvd acks */ + uint64_t tcps_rcvwinupd; /* rcvd window update packets */ + uint64_t tcps_pawsdrop; /* segments dropped due to PAWS */ + uint64_t tcps_predack; /* times hdr predict ok for acks */ + uint64_t tcps_preddat; /* times hdr predict ok for data pkts */ + uint64_t tcps_pcbcachemiss; + uint64_t tcps_cachedrtt; /* times cached RTT in route updated */ + uint64_t tcps_cachedrttvar; /* times cached rttvar updated */ + uint64_t tcps_cachedssthresh; /* times cached ssthresh updated */ + uint64_t tcps_usedrtt; /* times RTT initialized from route */ + uint64_t tcps_usedrttvar; /* times RTTVAR initialized from rt */ + uint64_t tcps_usedssthresh; /* times ssthresh initialized from rt*/ + uint64_t tcps_persistdrop; /* timeout in persist state */ + uint64_t tcps_badsyn; /* bogus SYN, e.g. premature ACK */ + uint64_t tcps_mturesent; /* resends due to MTU discovery */ + uint64_t tcps_listendrop; /* listen queue overflows */ + uint64_t tcps_badrst; /* ignored RSTs in the window */ + + uint64_t tcps_sc_added; /* entry added to syncache */ + uint64_t tcps_sc_retransmitted; /* syncache entry was retransmitted */ + uint64_t tcps_sc_dupsyn; /* duplicate SYN packet */ + uint64_t tcps_sc_dropped; /* could not reply to packet */ + uint64_t tcps_sc_completed; /* successful extraction of entry */ + uint64_t tcps_sc_bucketoverflow;/* syncache per-bucket limit hit */ + uint64_t tcps_sc_cacheoverflow; /* syncache cache limit hit */ + uint64_t tcps_sc_reset; /* RST removed entry from syncache */ + uint64_t tcps_sc_stale; /* timed out or listen socket gone */ + uint64_t tcps_sc_aborted; /* syncache entry aborted */ + uint64_t tcps_sc_badack; /* removed due to bad ACK */ + uint64_t tcps_sc_unreach; /* ICMP unreachable received */ + uint64_t tcps_sc_zonefail; /* zalloc() failed */ + uint64_t tcps_sc_sendcookie; /* SYN cookie sent */ + uint64_t tcps_sc_recvcookie; /* SYN cookie received */ - u_long tcps_hc_added; /* entry added to hostcache */ - u_long tcps_hc_bucketoverflow; /* hostcache per bucket limit hit */ + uint64_t tcps_hc_added; /* entry added to hostcache */ + uint64_t tcps_hc_bucketoverflow;/* hostcache per bucket limit hit */ - u_long tcps_finwait2_drops; /* Drop FIN_WAIT_2 connection after time limit */ + uint64_t tcps_finwait2_drops; /* Drop FIN_WAIT_2 connection after time limit */ /* SACK related stats */ - u_long tcps_sack_recovery_episode; /* SACK recovery episodes */ - u_long tcps_sack_rexmits; /* SACK rexmit segments */ - u_long tcps_sack_rexmit_bytes; /* SACK rexmit bytes */ - u_long tcps_sack_rcv_blocks; /* SACK blocks (options) received */ - u_long tcps_sack_send_blocks; /* SACK blocks (options) sent */ - u_long tcps_sack_sboverflow; /* times scoreboard overflowed */ + uint64_t tcps_sack_recovery_episode; /* SACK recovery episodes */ + uint64_t tcps_sack_rexmits; /* SACK rexmit segments */ + uint64_t tcps_sack_rexmit_bytes; /* SACK rexmit bytes */ + uint64_t tcps_sack_rcv_blocks; /* SACK blocks (options) received */ + uint64_t tcps_sack_send_blocks; /* SACK blocks (options) sent */ + uint64_t tcps_sack_sboverflow; /* times scoreboard overflowed */ /* ECN related stats */ - u_long tcps_ecn_ce; /* ECN Congestion Experienced */ - u_long tcps_ecn_ect0; /* ECN Capable Transport */ - u_long tcps_ecn_ect1; /* ECN Capable Transport */ - u_long tcps_ecn_shs; /* ECN successful handshakes */ - u_long tcps_ecn_rcwnd; /* # times ECN reduced the cwnd */ + uint64_t tcps_ecn_ce; /* ECN Congestion Experienced */ + uint64_t tcps_ecn_ect0; /* ECN Capable Transport */ + uint64_t tcps_ecn_ect1; /* ECN Capable Transport */ + uint64_t tcps_ecn_shs; /* ECN successful handshakes */ + uint64_t tcps_ecn_rcwnd; /* # times ECN reduced the cwnd */ /* TCP_SIGNATURE related stats */ - u_long tcps_sig_rcvgoodsig; /* Total matching signature received */ - u_long tcps_sig_rcvbadsig; /* Total bad signature received */ - u_long tcps_sig_err_buildsig; /* Mismatching signature received */ - u_long tcps_sig_err_sigopt; /* No signature expected by socket */ - u_long tcps_sig_err_nosigopt; /* No signature provided by segment */ + uint64_t tcps_sig_rcvgoodsig; /* Total matching signature received */ + uint64_t tcps_sig_rcvbadsig; /* Total bad signature received */ + uint64_t tcps_sig_err_buildsig; /* Mismatching signature received */ + uint64_t tcps_sig_err_sigopt; /* No signature expected by socket */ + uint64_t tcps_sig_err_nosigopt; /* No signature provided by segment */ - u_long _pad[12]; /* 6 UTO, 6 TBD */ + uint64_t _pad[12]; /* 6 UTO, 6 TBD */ }; #ifdef _KERNEL + +#include + +/* Should match 'struct tcpstat' above. */ +struct tcpstat_p { + counter_u64_t tcps_connattempt; + counter_u64_t tcps_accepts; + counter_u64_t tcps_connects; + counter_u64_t tcps_drops; + counter_u64_t tcps_conndrops; + counter_u64_t tcps_minmssdrops; + counter_u64_t tcps_closed; + counter_u64_t tcps_segstimed; + counter_u64_t tcps_rttupdated; + counter_u64_t tcps_delack; + counter_u64_t tcps_timeoutdrop; + counter_u64_t tcps_rexmttimeo; + counter_u64_t tcps_persisttimeo; + counter_u64_t tcps_keeptimeo; + counter_u64_t tcps_keepprobe; + counter_u64_t tcps_keepdrops; + counter_u64_t tcps_sndtotal; + counter_u64_t tcps_sndpack; + counter_u64_t tcps_sndbyte; + counter_u64_t tcps_sndrexmitpack; + counter_u64_t tcps_sndrexmitbyte; + counter_u64_t tcps_sndrexmitbad; + counter_u64_t tcps_sndacks; + counter_u64_t tcps_sndprobe; + counter_u64_t tcps_sndurg; + counter_u64_t tcps_sndwinup; + counter_u64_t tcps_sndctrl; + counter_u64_t tcps_rcvtotal; + counter_u64_t tcps_rcvpack; + counter_u64_t tcps_rcvbyte; + counter_u64_t tcps_rcvbadsum; + counter_u64_t tcps_rcvbadoff; + counter_u64_t tcps_rcvmemdrop; + counter_u64_t tcps_rcvshort; + counter_u64_t tcps_rcvduppack; + counter_u64_t tcps_rcvdupbyte; + counter_u64_t tcps_rcvpartduppack; + counter_u64_t tcps_rcvpartdupbyte; + counter_u64_t tcps_rcvoopack; + counter_u64_t tcps_rcvoobyte; + counter_u64_t tcps_rcvpackafterwin; + counter_u64_t tcps_rcvbyteafterwin; + counter_u64_t tcps_rcvafterclose; + counter_u64_t tcps_rcvwinprobe; + counter_u64_t tcps_rcvdupack; + counter_u64_t tcps_rcvacktoomuch; + counter_u64_t tcps_rcvackpack; + counter_u64_t tcps_rcvackbyte; + counter_u64_t tcps_rcvwinupd; + counter_u64_t tcps_pawsdrop; + counter_u64_t tcps_predack; + counter_u64_t tcps_preddat; + counter_u64_t tcps_pcbcachemiss; + counter_u64_t tcps_cachedrtt; + counter_u64_t tcps_cachedrttvar; + counter_u64_t tcps_cachedssthresh; + counter_u64_t tcps_usedrtt; + counter_u64_t tcps_usedrttvar; + counter_u64_t tcps_usedssthresh; + counter_u64_t tcps_persistdrop; + counter_u64_t tcps_badsyn; + counter_u64_t tcps_mturesent; + counter_u64_t tcps_listendrop; + counter_u64_t tcps_badrst; + counter_u64_t tcps_sc_added; + counter_u64_t tcps_sc_retransmitted; + counter_u64_t tcps_sc_dupsyn; + counter_u64_t tcps_sc_dropped; + counter_u64_t tcps_sc_completed; + counter_u64_t tcps_sc_bucketoverflow; + counter_u64_t tcps_sc_cacheoverflow; + counter_u64_t tcps_sc_reset; + counter_u64_t tcps_sc_stale; + counter_u64_t tcps_sc_aborted; + counter_u64_t tcps_sc_badack; + counter_u64_t tcps_sc_unreach; + counter_u64_t tcps_sc_zonefail; + counter_u64_t tcps_sc_sendcookie; + counter_u64_t tcps_sc_recvcookie; + counter_u64_t tcps_hc_added; + counter_u64_t tcps_hc_bucketoverflow; + counter_u64_t tcps_finwait2_drops; + counter_u64_t tcps_sack_recovery_episode; + counter_u64_t tcps_sack_rexmits; + counter_u64_t tcps_sack_rexmit_bytes; + counter_u64_t tcps_sack_rcv_blocks; + counter_u64_t tcps_sack_send_blocks; + counter_u64_t tcps_sack_sboverflow; + counter_u64_t tcps_ecn_ce; + counter_u64_t tcps_ecn_ect0; + counter_u64_t tcps_ecn_ect1; + counter_u64_t tcps_ecn_shs; + counter_u64_t tcps_ecn_rcwnd; + counter_u64_t tcps_sig_rcvgoodsig; + counter_u64_t tcps_sig_rcvbadsig; + counter_u64_t tcps_sig_err_buildsig; + counter_u64_t tcps_sig_err_sigopt; + counter_u64_t tcps_sig_err_nosigopt; +}; + +VNET_DECLARE(struct tcpstat_p, tcpstatp); /* tcp statistics */ +#define V_tcpstatp VNET(tcpstatp) + /* * In-kernel consumers can use these accessor macros directly to update * stats. */ -#define TCPSTAT_ADD(name, val) V_tcpstat.name += (val) +#define TCPSTAT_ADD(name, val) counter_u64_add(V_tcpstatp.name, (val)) #define TCPSTAT_INC(name) TCPSTAT_ADD(name, 1) /* @@ -515,7 +623,8 @@ struct tcpstat { */ void kmod_tcpstat_inc(int statnum); #define KMOD_TCPSTAT_INC(name) \ - kmod_tcpstat_inc(offsetof(struct tcpstat, name) / sizeof(u_long)) + kmod_tcpstat_inc(offsetof(struct tcpstat_p, name) / \ + sizeof(counter_u64_t)) /* * TCP specific helper hook point identifiers. @@ -605,7 +714,6 @@ MALLOC_DECLARE(M_TCPLOG); VNET_DECLARE(struct inpcbhead, tcb); /* queue of active tcpcb's */ VNET_DECLARE(struct inpcbinfo, tcbinfo); -VNET_DECLARE(struct tcpstat, tcpstat); /* tcp statistics */ extern int tcp_log_in_vain; VNET_DECLARE(int, tcp_mssdflt); /* XXX */ VNET_DECLARE(int, tcp_minmss); @@ -619,7 +727,6 @@ VNET_DECLARE(int, tcp_do_rfc3465); VNET_DECLARE(int, tcp_abc_l_var); #define V_tcb VNET(tcb) #define V_tcbinfo VNET(tcbinfo) -#define V_tcpstat VNET(tcpstat) #define V_tcp_mssdflt VNET(tcp_mssdflt) #define V_tcp_minmss VNET(tcp_minmss) #define V_tcp_delack_enabled VNET(tcp_delack_enabled) Modified: user/attilio/vmcontention/sys/vm/vm_page.h ============================================================================== --- user/attilio/vmcontention/sys/vm/vm_page.h Mon Apr 8 20:02:27 2013 (r249278) +++ user/attilio/vmcontention/sys/vm/vm_page.h Mon Apr 8 20:11:03 2013 (r249279) @@ -143,7 +143,7 @@ struct vm_page { uint8_t aflags; /* access is atomic */ uint8_t oflags; /* page VPO_* flags (O) */ uint16_t flags; /* page PG_* flags (P) */ - u_char act_count; /* page usage count (O) */ + u_char act_count; /* page usage count (P) */ u_char busy; /* page busy count (O) */ /* NOTE that these must support one bit per DEV_BSIZE in a page!!! */ /* so, on normal X86 kernels, they must be at least 8 bits wide */ Modified: user/attilio/vmcontention/sys/vm/vm_pageout.c ============================================================================== --- user/attilio/vmcontention/sys/vm/vm_pageout.c Mon Apr 8 20:02:27 2013 (r249278) +++ user/attilio/vmcontention/sys/vm/vm_pageout.c Mon Apr 8 20:11:03 2013 (r249279) @@ -1015,9 +1015,9 @@ vm_pageout_scan(int pass) } else if ((m->aflags & PGA_REFERENCED) == 0 && (actcount = pmap_ts_referenced(m)) != 0) { vm_page_activate(m); - vm_page_unlock(m); - m->act_count += actcount + ACT_ADVANCE; VM_OBJECT_WUNLOCK(object); + m->act_count += actcount + ACT_ADVANCE; + vm_page_unlock(m); goto relock_queues; } @@ -1031,9 +1031,9 @@ vm_pageout_scan(int pass) vm_page_aflag_clear(m, PGA_REFERENCED); actcount = pmap_ts_referenced(m); vm_page_activate(m); - vm_page_unlock(m); - m->act_count += actcount + ACT_ADVANCE + 1; VM_OBJECT_WUNLOCK(object); + m->act_count += actcount + ACT_ADVANCE + 1; + vm_page_unlock(m); goto relock_queues; } Modified: user/attilio/vmcontention/usr.bin/netstat/inet.c ============================================================================== --- user/attilio/vmcontention/usr.bin/netstat/inet.c Mon Apr 8 20:02:27 2013 (r249278) +++ user/attilio/vmcontention/usr.bin/netstat/inet.c Mon Apr 8 20:11:03 2013 (r249279) @@ -608,115 +608,121 @@ tcp_stats(u_long off, const char *name, printf ("%s:\n", name); -#define p(f, m) if (tcpstat.f || sflag <= 1) \ - printf(m, tcpstat.f, plural(tcpstat.f)) -#define p1a(f, m) if (tcpstat.f || sflag <= 1) \ - printf(m, tcpstat.f) -#define p2(f1, f2, m) if (tcpstat.f1 || tcpstat.f2 || sflag <= 1) \ - printf(m, tcpstat.f1, plural(tcpstat.f1), tcpstat.f2, plural(tcpstat.f2)) -#define p2a(f1, f2, m) if (tcpstat.f1 || tcpstat.f2 || sflag <= 1) \ - printf(m, tcpstat.f1, plural(tcpstat.f1), tcpstat.f2) -#define p3(f, m) if (tcpstat.f || sflag <= 1) \ - printf(m, tcpstat.f, pluralies(tcpstat.f)) +#define p(f, m) if (tcpstat.f || sflag <= 1) \ + printf(m, (uintmax_t )tcpstat.f, plural(tcpstat.f)) - p(tcps_sndtotal, "\t%lu packet%s sent\n"); - p2(tcps_sndpack,tcps_sndbyte, "\t\t%lu data packet%s (%lu byte%s)\n"); +#define p1a(f, m) if (tcpstat.f || sflag <= 1) \ + printf(m, (uintmax_t )tcpstat.f) + +#define p2(f1, f2, m) if (tcpstat.f1 || tcpstat.f2 || sflag <= 1) \ + printf(m, (uintmax_t )tcpstat.f1, plural(tcpstat.f1), \ + (uintmax_t )tcpstat.f2, plural(tcpstat.f2)) + +#define p2a(f1, f2, m) if (tcpstat.f1 || tcpstat.f2 || sflag <= 1) \ + printf(m, (uintmax_t )tcpstat.f1, plural(tcpstat.f1), \ + (uintmax_t )tcpstat.f2) + +#define p3(f, m) if (tcpstat.f || sflag <= 1) \ + printf(m, (uintmax_t )tcpstat.f, pluralies(tcpstat.f)) + + p(tcps_sndtotal, "\t%ju packet%s sent\n"); + p2(tcps_sndpack,tcps_sndbyte, "\t\t%ju data packet%s (%ju byte%s)\n"); p2(tcps_sndrexmitpack, tcps_sndrexmitbyte, - "\t\t%lu data packet%s (%lu byte%s) retransmitted\n"); + "\t\t%ju data packet%s (%ju byte%s) retransmitted\n"); p(tcps_sndrexmitbad, - "\t\t%lu data packet%s unnecessarily retransmitted\n"); - p(tcps_mturesent, "\t\t%lu resend%s initiated by MTU discovery\n"); + "\t\t%ju data packet%s unnecessarily retransmitted\n"); + p(tcps_mturesent, "\t\t%ju resend%s initiated by MTU discovery\n"); p2a(tcps_sndacks, tcps_delack, - "\t\t%lu ack-only packet%s (%lu delayed)\n"); - p(tcps_sndurg, "\t\t%lu URG only packet%s\n"); - p(tcps_sndprobe, "\t\t%lu window probe packet%s\n"); - p(tcps_sndwinup, "\t\t%lu window update packet%s\n"); - p(tcps_sndctrl, "\t\t%lu control packet%s\n"); - p(tcps_rcvtotal, "\t%lu packet%s received\n"); + "\t\t%ju ack-only packet%s (%ju delayed)\n"); + p(tcps_sndurg, "\t\t%ju URG only packet%s\n"); + p(tcps_sndprobe, "\t\t%ju window probe packet%s\n"); + p(tcps_sndwinup, "\t\t%ju window update packet%s\n"); + p(tcps_sndctrl, "\t\t%ju control packet%s\n"); + p(tcps_rcvtotal, "\t%ju packet%s received\n"); p2(tcps_rcvackpack, tcps_rcvackbyte, - "\t\t%lu ack%s (for %lu byte%s)\n"); - p(tcps_rcvdupack, "\t\t%lu duplicate ack%s\n"); - p(tcps_rcvacktoomuch, "\t\t%lu ack%s for unsent data\n"); + "\t\t%ju ack%s (for %ju byte%s)\n"); + p(tcps_rcvdupack, "\t\t%ju duplicate ack%s\n"); + p(tcps_rcvacktoomuch, "\t\t%ju ack%s for unsent data\n"); p2(tcps_rcvpack, tcps_rcvbyte, - "\t\t%lu packet%s (%lu byte%s) received in-sequence\n"); + "\t\t%ju packet%s (%ju byte%s) received in-sequence\n"); p2(tcps_rcvduppack, tcps_rcvdupbyte, - "\t\t%lu completely duplicate packet%s (%lu byte%s)\n"); - p(tcps_pawsdrop, "\t\t%lu old duplicate packet%s\n"); + "\t\t%ju completely duplicate packet%s (%ju byte%s)\n"); + p(tcps_pawsdrop, "\t\t%ju old duplicate packet%s\n"); p2(tcps_rcvpartduppack, tcps_rcvpartdupbyte, - "\t\t%lu packet%s with some dup. data (%lu byte%s duped)\n"); + "\t\t%ju packet%s with some dup. data (%ju byte%s duped)\n"); p2(tcps_rcvoopack, tcps_rcvoobyte, - "\t\t%lu out-of-order packet%s (%lu byte%s)\n"); + "\t\t%ju out-of-order packet%s (%ju byte%s)\n"); p2(tcps_rcvpackafterwin, tcps_rcvbyteafterwin, - "\t\t%lu packet%s (%lu byte%s) of data after window\n"); - p(tcps_rcvwinprobe, "\t\t%lu window probe%s\n"); - p(tcps_rcvwinupd, "\t\t%lu window update packet%s\n"); - p(tcps_rcvafterclose, "\t\t%lu packet%s received after close\n"); - p(tcps_rcvbadsum, "\t\t%lu discarded for bad checksum%s\n"); - p(tcps_rcvbadoff, "\t\t%lu discarded for bad header offset field%s\n"); - p1a(tcps_rcvshort, "\t\t%lu discarded because packet too short\n"); - p1a(tcps_rcvmemdrop, "\t\t%lu discarded due to memory problems\n"); - p(tcps_connattempt, "\t%lu connection request%s\n"); - p(tcps_accepts, "\t%lu connection accept%s\n"); - p(tcps_badsyn, "\t%lu bad connection attempt%s\n"); - p(tcps_listendrop, "\t%lu listen queue overflow%s\n"); - p(tcps_badrst, "\t%lu ignored RSTs in the window%s\n"); - p(tcps_connects, "\t%lu connection%s established (including accepts)\n"); + "\t\t%ju packet%s (%ju byte%s) of data after window\n"); + p(tcps_rcvwinprobe, "\t\t%ju window probe%s\n"); + p(tcps_rcvwinupd, "\t\t%ju window update packet%s\n"); + p(tcps_rcvafterclose, "\t\t%ju packet%s received after close\n"); + p(tcps_rcvbadsum, "\t\t%ju discarded for bad checksum%s\n"); + p(tcps_rcvbadoff, "\t\t%ju discarded for bad header offset field%s\n"); + p1a(tcps_rcvshort, "\t\t%ju discarded because packet too short\n"); + p1a(tcps_rcvmemdrop, "\t\t%ju discarded due to memory problems\n"); + p(tcps_connattempt, "\t%ju connection request%s\n"); + p(tcps_accepts, "\t%ju connection accept%s\n"); + p(tcps_badsyn, "\t%ju bad connection attempt%s\n"); + p(tcps_listendrop, "\t%ju listen queue overflow%s\n"); + p(tcps_badrst, "\t%ju ignored RSTs in the window%s\n"); + p(tcps_connects, "\t%ju connection%s established (including accepts)\n"); p2(tcps_closed, tcps_drops, - "\t%lu connection%s closed (including %lu drop%s)\n"); - p(tcps_cachedrtt, "\t\t%lu connection%s updated cached RTT on close\n"); + "\t%ju connection%s closed (including %ju drop%s)\n"); + p(tcps_cachedrtt, "\t\t%ju connection%s updated cached RTT on close\n"); p(tcps_cachedrttvar, - "\t\t%lu connection%s updated cached RTT variance on close\n"); + "\t\t%ju connection%s updated cached RTT variance on close\n"); *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***