From owner-svn-src-head@freebsd.org Fri Nov 20 11:01:39 2015 Return-Path: Delivered-To: svn-src-head@mailman.ysv.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:1900:2254:206a::19:1]) by mailman.ysv.freebsd.org (Postfix) with ESMTP id 3A8E7A33F66 for ; Fri, 20 Nov 2015 11:01:39 +0000 (UTC) (envelope-from oliver.pinter@hardenedbsd.org) Received: from mail-wm0-x22f.google.com (mail-wm0-x22f.google.com [IPv6:2a00:1450:400c:c09::22f]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (Client CN "smtp.gmail.com", Issuer "Google Internet Authority G2" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id B08991263 for ; Fri, 20 Nov 2015 11:01:38 +0000 (UTC) (envelope-from oliver.pinter@hardenedbsd.org) Received: by wmdw130 with SMTP id w130so14956121wmd.0 for ; Fri, 20 Nov 2015 03:01:36 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=hardenedbsd-org.20150623.gappssmtp.com; s=20150623; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :cc:content-type; bh=QlghX0mKpYB64D419YpltielYF/xYyi4sViIGTl2m1k=; b=hphms+oCnusukC4UiZDktV0KAd1+tDfRxGxqrm5k14rLBbW5oErmuue4RZ74lKR/oz HofjJ5+8f9X74IM0SwaqpYs3GxP5W+vl/KUeiVoIHfayY4LuQDKM85CNFGN9ilDhaenT ivfS3sOvUD7bTKkmVU1vxkNpfzGG5oMSduTQxUgyqzD8m14nVHaH19rhP6Ptf+xYLqWT olnPqfxIZwPVgL5LLixfL/KYAjS2PpSa68w3uf7aJZEQoNJvW8mwGE9vtwraFeBuJHKG sEpZKnhBAJMXXdig4LW15efQhSGjtMTV3mHZ+cyRHo91vDQZCvMhFuT4vHWhSKk30ZYy a0tw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:in-reply-to:references:date :message-id:subject:from:to:cc:content-type; bh=QlghX0mKpYB64D419YpltielYF/xYyi4sViIGTl2m1k=; b=aLNDreO59CpMOjStunC/qMLl5hUQU09qh/lazzq8ikVGmeP1tAaInSih16n+gjIotd 7GPU8JDt8prmbd6gAIbYChdQsJDGZeQbKpQTA80io3aBiT4kiHCxD8cKtQogCZpTfDQa ZryjkrWNT9BbbbocwzgpbfHrjWmC+vIUgdLUtRPMkuzsZzMs+4dloWju8ZLoCeTsqppx IlRaaiaGxqAiGWR36op9W033xdSs3ULAXsZA2seJgEO/sMK3GbEtGS9yPjoIQJOW8GA/ u4ZNllKYrIg4IbEBrNdWU8m0DYZBVuZwhFfEzhRXQEdqBbFgQsfNVLciiXbBIrazgOV1 oSuA== X-Gm-Message-State: ALoCoQnPc43kofcGiDkLKfpOBj8QRjJgoug5CiXjRZOKK1ZymYZPTM7jRIfm/QPzcNGt5G5ieY/T MIME-Version: 1.0 X-Received: by 10.194.202.163 with SMTP id kj3mr13297006wjc.93.1448017296683; Fri, 20 Nov 2015 03:01:36 -0800 (PST) Received: by 10.194.158.225 with HTTP; Fri, 20 Nov 2015 03:01:36 -0800 (PST) In-Reply-To: <201511200515.tAK5FZT8037263@repo.freebsd.org> References: <201511200515.tAK5FZT8037263@repo.freebsd.org> Date: Fri, 20 Nov 2015 12:01:36 +0100 Message-ID: Subject: Re: svn commit: r291090 - head/usr.bin/vmstat From: Oliver Pinter To: Craig Rodrigues Cc: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org Content-Type: text/plain; charset=UTF-8 X-BeenThere: svn-src-head@freebsd.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: SVN commit messages for the src tree for head/-current List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 20 Nov 2015 11:01:39 -0000 On 11/20/15, Craig Rodrigues wrote: > Author: rodrigc > Date: Fri Nov 20 05:15:34 2015 > New Revision: 291090 > URL: https://svnweb.freebsd.org/changeset/base/291090 > > Log: > Convert vmstat to use libxo. > > This patch was based on this patch: > https://github.com/Juniper/libxo/blob/master/patches/vmstat.patch > > by Phil Shafer at Juniper Networks, but updated to the latest > vmstat code. > > Reviewed by: allanjude > Differential Revision: https://reviews.freebsd.org/D3935 > > Modified: > head/usr.bin/vmstat/Makefile > head/usr.bin/vmstat/vmstat.8 > head/usr.bin/vmstat/vmstat.c > > Modified: head/usr.bin/vmstat/Makefile > ============================================================================== > --- head/usr.bin/vmstat/Makefile Fri Nov 20 03:24:04 2015 (r291089) > +++ head/usr.bin/vmstat/Makefile Fri Nov 20 05:15:34 2015 (r291090) > @@ -3,7 +3,7 @@ > > PROG= vmstat > MAN= vmstat.8 > -LIBADD= devstat kvm memstat util > +LIBADD= devstat kvm memstat xo util > > WARNS?= 1 > > > Modified: head/usr.bin/vmstat/vmstat.8 > ============================================================================== > --- head/usr.bin/vmstat/vmstat.8 Fri Nov 20 03:24:04 2015 (r291089) > +++ head/usr.bin/vmstat/vmstat.8 Fri Nov 20 05:15:34 2015 (r291090) > @@ -28,7 +28,7 @@ > .\" @(#)vmstat.8 8.1 (Berkeley) 6/6/93 > .\" $FreeBSD$ > .\" > -.Dd August 8, 2014 > +.Dd November 19, 2015 > .Dt VMSTAT 8 > .Os > .Sh NAME > @@ -37,6 +37,7 @@ > .Sh SYNOPSIS > .Nm > .\" .Op Fl fimst > +.Op Fl -libxo > .Op Fl afHhimoPsz > .Op Fl M Ar core Op Fl N Ar system > .Op Fl c Ar count > @@ -68,6 +69,13 @@ the default image). > .Pp > The options are as follows: > .Bl -tag -width indent > +.It Fl -libxo > +Generate output via > +.Xr libxo 3 > +in a selection of different human and machine readable formats. > +See > +.Xr xo_parse_args 3 > +for details on command line arguments. > .It Fl a > When used with > .Fl i , > @@ -361,6 +369,8 @@ statistics every second. > .Xr ps 1 , > .Xr systat 1 , > .Xr libmemstat 3 , > +.Xr libxo 3 , > +.Xr xo_parse_args 3 , > .Xr gstat 8 , > .Xr iostat 8 , > .Xr pstat 8 , > > Modified: head/usr.bin/vmstat/vmstat.c > ============================================================================== > --- head/usr.bin/vmstat/vmstat.c Fri Nov 20 03:24:04 2015 (r291089) > +++ head/usr.bin/vmstat/vmstat.c Fri Nov 20 05:15:34 2015 (r291090) > @@ -76,6 +76,9 @@ __FBSDID("$FreeBSD$"); > #include > #include > #include > +#include > + > +#define VMSTAT_XO_VERSION "1" > > static char da[] = "da"; > > @@ -184,6 +187,11 @@ main(int argc, char *argv[]) > interval = reps = todo = 0; > maxshowdevs = 2; > hflag = isatty(1); > + > + argc = xo_parse_args(argc, argv); > + if (argc < 0) > + return argc; > + > while ((c = getopt(argc, argv, "ac:fhHiM:mN:n:oPp:stw:z")) != -1) { > switch (c) { > case 'a': > @@ -220,7 +228,7 @@ main(int argc, char *argv[]) > nflag = 1; > maxshowdevs = atoi(optarg); > if (maxshowdevs < 0) > - errx(1, "number of devices %d is < 0", > + xo_errx(1, "number of devices %d is < 0", > maxshowdevs); > break; > case 'o': > @@ -228,7 +236,7 @@ main(int argc, char *argv[]) > break; > case 'p': > if (devstat_buildmatch(optarg, &matches, &num_matches) != 0) > - errx(1, "%s", devstat_errbuf); > + xo_errx(1, "%s", devstat_errbuf); > break; > case 's': > todo |= SUMSTAT; > @@ -237,7 +245,7 @@ main(int argc, char *argv[]) > #ifdef notyet > todo |= TIMESTAT; > #else > - errx(EX_USAGE, "sorry, -t is not (re)implemented yet"); > + xo_errx(EX_USAGE, "sorry, -t is not (re)implemented yet"); > #endif > break; > case 'w': > @@ -256,18 +264,21 @@ main(int argc, char *argv[]) > argc -= optind; > argv += optind; > > + xo_set_version(VMSTAT_XO_VERSION); > if (todo == 0) > todo = VMSTAT; > > if (memf != NULL) { > kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, errbuf); > if (kd == NULL) > - errx(1, "kvm_openfiles: %s", errbuf); > + xo_errx(1, "kvm_openfiles: %s", errbuf); > } > > retry_nlist: > if (kd != NULL && (c = kvm_nlist(kd, namelist)) != 0) { > if (c > 0) { > + int bufsize = 0, len = 0; > + char *buf, *bp; > /* > * 'cnt' was renamed to 'vm_cnt'. If 'vm_cnt' is not > * found try looking up older 'cnt' symbol. > @@ -277,20 +288,34 @@ retry_nlist: > namelist[X_SUM].n_name = "_cnt"; > goto retry_nlist; > } > - warnx("undefined symbols:"); > for (c = 0; > c < (int)(sizeof(namelist)/sizeof(namelist[0])); > c++) > if (namelist[c].n_type == 0) > - (void)fprintf(stderr, " %s", > + bufsize += strlen(namelist[c].n_name) + 1; > + bufsize += len + 1; > + buf = bp = alloca(bufsize); > + > + for (c = 0; > + c < (int)(sizeof(namelist)/sizeof(namelist[0])); > + c++) > + if (namelist[c].n_type == 0) { > + xo_error(" %s", > namelist[c].n_name); > - (void)fputc('\n', stderr); > + len = strlen(namelist[c].n_name); > + *bp++ = ' '; > + memcpy(bp, namelist[c].n_name, len); > + bp += len; > + } > + *bp = '\0'; > + xo_error("undefined symbols:\n", buf); > } else > - warnx("kvm_nlist: %s", kvm_geterr(kd)); > + xo_warnx("kvm_nlist: %s", kvm_geterr(kd)); > + xo_finish(); > exit(1); > } > if (kd && Pflag) > - errx(1, "Cannot use -P with crash dumps"); > + xo_errx(1, "Cannot use -P with crash dumps"); > > if (todo & VMSTAT) { > /* > @@ -299,7 +324,7 @@ retry_nlist: > * message informing the user of his mistake. > */ > if (devstat_checkversion(NULL) < 0) > - errx(1, "%s", devstat_errbuf); > + xo_errx(1, "%s", devstat_errbuf); > > > argv = getdrivedata(argv); > @@ -336,6 +361,7 @@ retry_nlist: > dointr(interval, reps); > if (todo & VMSTAT) > dovmstat(interval, reps); > + xo_finish(); > exit(0); > } > > @@ -347,7 +373,7 @@ mysysctl(const char *name, void *oldp, s > > error = sysctlbyname(name, oldp, oldlenp, newp, newlen); > if (error != 0 && errno != ENOMEM) > - err(1, "sysctl(%s)", name); > + xo_err(1, "sysctl(%s)", name); > return (error); > } > > @@ -355,13 +381,13 @@ static char ** > getdrivedata(char **argv) > { > if ((num_devices = devstat_getnumdevs(NULL)) < 0) > - errx(1, "%s", devstat_errbuf); > + xo_errx(1, "%s", devstat_errbuf); > > cur.dinfo = (struct devinfo *)calloc(1, sizeof(struct devinfo)); > last.dinfo = (struct devinfo *)calloc(1, sizeof(struct devinfo)); > > if (devstat_getdevs(NULL, &cur) == -1) > - errx(1, "%s", devstat_errbuf); > + xo_errx(1, "%s", devstat_errbuf); > > num_devices = cur.dinfo->numdevs; > generation = cur.dinfo->generation; > @@ -393,7 +419,7 @@ getdrivedata(char **argv) > */ > if ((num_devices_specified == 0) && (num_matches == 0)) { > if (devstat_buildmatch(da, &matches, &num_matches) != 0) > - errx(1, "%s", devstat_errbuf); > + xo_errx(1, "%s", devstat_errbuf); > > select_mode = DS_SELECT_ADD; > } else > @@ -409,7 +435,7 @@ getdrivedata(char **argv) > num_devices, matches, num_matches, specified_devices, > num_devices_specified, select_mode, > maxshowdevs, 0) == -1) > - errx(1, "%s", devstat_errbuf); > + xo_errx(1, "%s", devstat_errbuf); > > return(argv); > } > @@ -439,16 +465,16 @@ fill_pcpu(struct pcpu ***pcpup, int* max > > maxcpu = kvm_getmaxcpu(kd); > if (maxcpu < 0) > - errx(1, "kvm_getmaxcpu: %s", kvm_geterr(kd)); > + xo_errx(1, "kvm_getmaxcpu: %s", kvm_geterr(kd)); > > pcpu = calloc(maxcpu, sizeof(struct pcpu *)); > if (pcpu == NULL) > - err(1, "calloc"); > + xo_err(1, "calloc"); > > for (i = 0; i < maxcpu; i++) { > pcpu[i] = kvm_getpcpu(kd, i); > if (pcpu[i] == (struct pcpu *)-1) > - errx(1, "kvm_getpcpu: %s", kvm_geterr(kd)); > + xo_errx(1, "kvm_getpcpu: %s", kvm_geterr(kd)); > } > > *maxcpup = maxcpu; > @@ -576,12 +602,12 @@ fill_vmtotal(struct vmtotal *vmtp) > { > if (kd != NULL) { > /* XXX fill vmtp */ > - errx(1, "not implemented"); > + xo_errx(1, "not implemented"); > } else { > size_t size = sizeof(*vmtp); > mysysctl("vm.vmtotal", vmtp, &size, NULL, 0); > if (size != sizeof(*vmtp)) > - errx(1, "vm.total size mismatch"); > + xo_errx(1, "vm.total size mismatch"); > } > } > > @@ -599,17 +625,17 @@ getcpuinfo(u_long *maskp, int *maxidp) > u_long mask; > > if (kd != NULL) > - errx(1, "not implemented"); > + xo_errx(1, "not implemented"); > mask = 0; > ncpus = 0; > size = sizeof(maxcpu); > mysysctl("kern.smp.maxcpus", &maxcpu, &size, NULL, 0); > if (size != sizeof(maxcpu)) > - errx(1, "sysctl kern.smp.maxcpus"); > + xo_errx(1, "sysctl kern.smp.maxcpus"); > size = sizeof(long) * maxcpu * CPUSTATES; > times = malloc(size); > if (times == NULL) > - err(1, "malloc %zd bytes", size); > + xo_err(1, "malloc %zd bytes", size); > mysysctl("kern.cp_times", times, &size, NULL, 0); > maxid = (size / CPUSTATES / sizeof(long)) - 1; > for (i = 0; i <= maxid; i++) { > @@ -632,16 +658,20 @@ getcpuinfo(u_long *maskp, int *maxidp) > > > static void > -prthuman(u_int64_t val, int size) > +prthuman(const char *name, u_int64_t val, int size) > { > char buf[10]; > int flags; > + char fmt[128]; > + > + snprintf(fmt, sizeof(fmt), "{:%s/%%*s}", name); > > if (size < 5 || size > 9) > - errx(1, "doofus"); > + xo_errx(1, "doofus"); > flags = HN_B | HN_NOSPACE | HN_DECIMAL; > humanize_number(buf, size, val, "", HN_AUTOSCALE, flags); > - printf("%*s", size, buf); > + xo_attr("value", "%ju", (uintmax_t) val); > + xo_emit(fmt, size, buf); > } > > static int hz, hdrcnt; > @@ -699,7 +729,7 @@ dovmstat(unsigned int interval, int reps > size = sizeof(clockrate); > mysysctl("kern.clockrate", &clockrate, &size, NULL, 0); > if (size != sizeof(clockrate)) > - errx(1, "clockrate size mismatch"); > + xo_errx(1, "clockrate size mismatch"); > hz = clockrate.hz; > } > > @@ -714,18 +744,18 @@ dovmstat(unsigned int interval, int reps > printhdr(maxid, cpumask); > if (kd != NULL) { > if (kvm_getcptime(kd, cur.cp_time) < 0) > - errx(1, "kvm_getcptime: %s", kvm_geterr(kd)); > + xo_errx(1, "kvm_getcptime: %s", kvm_geterr(kd)); > } else { > size = sizeof(cur.cp_time); > mysysctl("kern.cp_time", &cur.cp_time, &size, NULL, 0); > if (size != sizeof(cur.cp_time)) > - errx(1, "cp_time size mismatch"); > + xo_errx(1, "cp_time size mismatch"); > } > if (Pflag) { > size = size_cp_times; > mysysctl("kern.cp_times", cur_cp_times, &size, NULL, 0); > if (size != size_cp_times) > - errx(1, "cp_times mismatch"); > + xo_errx(1, "cp_times mismatch"); > } > > tmp_dinfo = last.dinfo; > @@ -742,7 +772,7 @@ dovmstat(unsigned int interval, int reps > */ > switch (devstat_getdevs(NULL, &cur)) { > case -1: > - errx(1, "%s", devstat_errbuf); > + xo_errx(1, "%s", devstat_errbuf); > break; > case 1: { > int retval; > @@ -759,7 +789,7 @@ dovmstat(unsigned int interval, int reps > maxshowdevs, 0); > switch (retval) { > case -1: > - errx(1, "%s", devstat_errbuf); > + xo_errx(1, "%s", devstat_errbuf); > break; > case 1: > printhdr(maxid, cpumask); > @@ -774,49 +804,64 @@ dovmstat(unsigned int interval, int reps > > fill_vmmeter(&sum); > fill_vmtotal(&total); > - (void)printf("%1d %1d %1d", > + xo_open_container("processes"); > + xo_emit("{:runnable/%1d} {:waiting/%ld} " > + "{:swapped-out/%ld}", Are these %1d -> %ld conversions here intended or a typo? > total.t_rq - 1, total.t_dw + total.t_pw, total.t_sw); > + xo_close_container("processes"); > + xo_open_container("memory"); > #define vmstat_pgtok(a) ((a) * (sum.v_page_size >> 10)) > #define rate(x) (((x) * rate_adj + halfuptime) / uptime) /* round */ > if (hflag) { > - printf(""); > - prthuman(total.t_avm * (u_int64_t)sum.v_page_size, 5); > - printf(" "); > - prthuman(total.t_free * (u_int64_t)sum.v_page_size, 5); > - printf(" "); > - (void)printf("%5lu ", > - (unsigned long)rate(sum.v_vm_faults - > - osum.v_vm_faults)); > + xo_emit(""); > + prthuman("available-memory", > + total.t_avm * (u_int64_t)sum.v_page_size, 5); > + xo_emit(" "); > + prthuman("free-memory", > + total.t_free * (u_int64_t)sum.v_page_size, 5); > + xo_emit(" "); > } else { > - printf(" %7d", vmstat_pgtok(total.t_avm)); > - printf(" %7d ", vmstat_pgtok(total.t_free)); > - (void)printf("%4lu ", > - (unsigned long)rate(sum.v_vm_faults - > - osum.v_vm_faults)); > - } > - (void)printf("%3lu ", > + xo_emit(" "); > + xo_emit("{:available-memory/%7d}", > + vmstat_pgtok(total.t_avm)); > + xo_emit(" "); > + xo_emit("{:free-memory/%7d}", > + vmstat_pgtok(total.t_free)); > + } > + xo_emit("{:total-page-faults/%5lu} ", > + (unsigned long)rate(sum.v_vm_faults - > + osum.v_vm_faults)); > + xo_close_container("memory"); > + > + xo_open_container("paging-rates"); > + xo_emit("{:page-reactivated/%3lu} ", > (unsigned long)rate(sum.v_reactivated - osum.v_reactivated)); > - (void)printf("%3lu ", > + xo_emit("{:paged-in/%3lu} ", > (unsigned long)rate(sum.v_swapin + sum.v_vnodein - > (osum.v_swapin + osum.v_vnodein))); > - (void)printf("%3lu ", > + xo_emit("{:paged-out/%3lu} ", > (unsigned long)rate(sum.v_swapout + sum.v_vnodeout - > (osum.v_swapout + osum.v_vnodeout))); > - (void)printf("%5lu ", > + xo_emit("{:freed/%5lu} ", > (unsigned long)rate(sum.v_tfree - osum.v_tfree)); > - (void)printf("%4lu ", > + xo_emit("{:scanned/%4lu} ", > (unsigned long)rate(sum.v_pdpages - osum.v_pdpages)); > + xo_close_container("paging-rates"); > + > devstats(); > - (void)printf("%4lu %5lu %5lu", > + xo_open_container("fault-rates"); > + xo_emit("{:interrupts/%4lu} {:system-calls/%5lu} " > + "{:context-switches/%5u}", > (unsigned long)rate(sum.v_intr - osum.v_intr), > (unsigned long)rate(sum.v_syscall - osum.v_syscall), > (unsigned long)rate(sum.v_swtch - osum.v_swtch)); > + xo_close_container("fault-rates"); > if (Pflag) > pcpustats(ncpus, cpumask, maxid); > else > cpustats(); > - (void)printf("\n"); > - (void)fflush(stdout); > + xo_emit("\n"); > + xo_flush(); > if (reps >= 0 && --reps <= 0) > break; > osum = sum; > @@ -841,43 +886,43 @@ printhdr(int maxid, u_long cpumask) > > num_shown = (num_selected < maxshowdevs) ? num_selected : maxshowdevs; > if (hflag) { > - (void)printf("procs memory page%*s ", 19, ""); > + xo_emit("{T:procs} {T:memory} ${T:/page%*s}", 19, ""); > } else { > - (void)printf("procs memory page%*s ", 19, ""); > + xo_emit("{T:procs} {T:memory} ${T:/page%*s}", 19, ""); > } > if (num_shown > 1) > - (void)printf(" disks %*s", num_shown * 4 - 7, ""); > + xo_emit(" {T:/disks %*s}", num_shown * 4 - 7, ""); > else if (num_shown == 1) > - (void)printf(" disk"); > - (void)printf(" faults "); > + xo_emit(" {T:disks}"); > + xo_emit(" {T:faults} "); > if (Pflag) { > for (i = 0; i <= maxid; i++) { > if (cpumask & (1ul << i)) > - printf(" cpu%d ", i); > + xo_emit(" {T:/cpu%d} ", i); > } > - printf("\n"); > + xo_emit("\n"); > } else > - printf(" cpu\n"); > + xo_emit(" {T:cpu}\n"); > if (hflag) { > - (void)printf("r b w avm fre flt re pi po fr sr "); > + xo_emit("{T:r} {T:b} {T:w} {T:avm} {T:fre} {T:flt} {T:re} {T:pi} > {T:po} {T:fr} {T:sr} "); > } else { > - (void)printf("r b w avm fre flt re pi po fr sr "); > + xo_emit("{T:r} {T:b} {T:w} {T:avm} {T:fre} {T:flt} {T:re} > {T:pi} {T:po} {T:fr} {T:sr} "); > } > for (i = 0; i < num_devices; i++) > if ((dev_select[i].selected) > && (dev_select[i].selected <= maxshowdevs)) > - (void)printf("%c%c%d ", dev_select[i].device_name[0], > + xo_emit("{T:/%c%c%d} ", dev_select[i].device_name[0], > dev_select[i].device_name[1], > dev_select[i].unit_number); > - (void)printf(" in sy cs"); > + xo_emit(" {T:in} {T:sy} {T:cs}"); > if (Pflag) { > for (i = 0; i <= maxid; i++) { > if (cpumask & (1ul << i)) > - printf(" us sy id"); > + xo_emit(" {T:us} {T:sy} {T:id}"); > } > - printf("\n"); > + xo_emit("\n"); > } else > - printf(" us sy id\n"); > + xo_emit(" {T:us} {T:sy} {T:id}\n"); > if (wresized != 0) > doresize(); > hdrcnt = winlines; > @@ -920,7 +965,7 @@ doresize(void) > if (status == -1 && errno == EINTR) > continue; > else if (status == -1) > - err(1, "ioctl"); > + xo_err(1, "ioctl"); > if (w.ws_row > 3) > winlines = w.ws_row - 3; > else > @@ -943,13 +988,16 @@ dotimes(void) > kread(X_REC, &rectime, sizeof(rectime)); > kread(X_PGIN, &pgintime, sizeof(pgintime)); > kread(X_SUM, &sum, sizeof(sum)); > - (void)printf("%u reclaims, %u total time (usec)\n", > + xo_emit("{:page-reclaims/%u} {N:reclaims}, " > + "{:reclaim-time/%u} {N:total time (usec)}\n", > sum.v_pgrec, rectime); > - (void)printf("average: %u usec / reclaim\n", rectime / sum.v_pgrec); > - (void)printf("\n"); > - (void)printf("%u page ins, %u total time (msec)\n", > + xo_emit("{L:average}: {:reclaim-average/%u} {N:usec \\/ reclaim}\n", > + rectime / sum.v_pgrec); > + xo_emit("\n"); > + xo_emit("{:page-ins/%u} {N:page ins}, " > + "{:page-in-time/%u} {N:total time (msec)}\n", > sum.v_pgin, pgintime / 10); > - (void)printf("average: %8.1f msec / page in\n", > + xo_emit("{L:average}: {:average/%8.1f} {N:msec \\/ page in}\n", > pgintime / (sum.v_pgin * 10.0)); > } > #endif > @@ -974,87 +1022,136 @@ dosum(void) > long nchtotal; > > fill_vmmeter(&sum); > - (void)printf("%9u cpu context switches\n", sum.v_swtch); > - (void)printf("%9u device interrupts\n", sum.v_intr); > - (void)printf("%9u software interrupts\n", sum.v_soft); > - (void)printf("%9u traps\n", sum.v_trap); > - (void)printf("%9u system calls\n", sum.v_syscall); > - (void)printf("%9u kernel threads created\n", sum.v_kthreads); > - (void)printf("%9u fork() calls\n", sum.v_forks); > - (void)printf("%9u vfork() calls\n", sum.v_vforks); > - (void)printf("%9u rfork() calls\n", sum.v_rforks); > - (void)printf("%9u swap pager pageins\n", sum.v_swapin); > - (void)printf("%9u swap pager pages paged in\n", sum.v_swappgsin); > - (void)printf("%9u swap pager pageouts\n", sum.v_swapout); > - (void)printf("%9u swap pager pages paged out\n", sum.v_swappgsout); > - (void)printf("%9u vnode pager pageins\n", sum.v_vnodein); > - (void)printf("%9u vnode pager pages paged in\n", sum.v_vnodepgsin); > - (void)printf("%9u vnode pager pageouts\n", sum.v_vnodeout); > - (void)printf("%9u vnode pager pages paged out\n", sum.v_vnodepgsout); > - (void)printf("%9u page daemon wakeups\n", sum.v_pdwakeups); > - (void)printf("%9u pages examined by the page daemon\n", sum.v_pdpages); > - (void)printf("%9u pages reactivated\n", sum.v_reactivated); > - (void)printf("%9u copy-on-write faults\n", sum.v_cow_faults); > - (void)printf("%9u copy-on-write optimized faults\n", sum.v_cow_optim); > - (void)printf("%9u zero fill pages zeroed\n", sum.v_zfod); > - (void)printf("%9u zero fill pages prezeroed\n", sum.v_ozfod); > - (void)printf("%9u intransit blocking page faults\n", sum.v_intrans); > - (void)printf("%9u total VM faults taken\n", sum.v_vm_faults); > - (void)printf("%9u page faults requiring I/O\n", sum.v_io_faults); > - (void)printf("%9u pages affected by kernel thread creation\n", > - sum.v_kthreadpages); > - (void)printf("%9u pages affected by fork()\n", sum.v_forkpages); > - (void)printf("%9u pages affected by vfork()\n", sum.v_vforkpages); > - (void)printf("%9u pages affected by rfork()\n", sum.v_rforkpages); > - (void)printf("%9u pages cached\n", sum.v_tcached); > - (void)printf("%9u pages freed\n", sum.v_tfree); > - (void)printf("%9u pages freed by daemon\n", sum.v_dfree); > - (void)printf("%9u pages freed by exiting processes\n", sum.v_pfree); > - (void)printf("%9u pages active\n", sum.v_active_count); > - (void)printf("%9u pages inactive\n", sum.v_inactive_count); > - (void)printf("%9u pages in VM cache\n", sum.v_cache_count); > - (void)printf("%9u pages wired down\n", sum.v_wire_count); > - (void)printf("%9u pages free\n", sum.v_free_count); > - (void)printf("%9u bytes per page\n", sum.v_page_size); > + xo_open_container("summary-statistics"); > + xo_emit("{:context-switches/%9u} {N:cpu context switches}\n", > + sum.v_swtch); > + xo_emit("{:interrupts/%9u} {N:device interrupts}\n", > + sum.v_intr); > + xo_emit("{:software-interrupts/%9u} {N:software interrupts}\n", > + sum.v_soft); > + xo_emit("{:traps/%9u} {N:traps}\n", sum.v_trap); > + xo_emit("{:system-calls/%9u} {N:system calls}\n", > + sum.v_syscall); > + xo_emit("{:kernel-threads/%9u} {N:kernel threads created}\n", > + sum.v_kthreads); > + xo_emit("{:forks/%9u} {N: fork() calls}\n", sum.v_forks); > + xo_emit("{:vforks/%9u} {N:vfork() calls}\n", > + sum.v_vforks); > + xo_emit("{:rforks/%9u} {N:rfork() calls}\n", > + sum.v_rforks); > + xo_emit("{:swap-ins/%9u} {N:swap pager pageins}\n", > + sum.v_swapin); > + xo_emit("{:swap-in-pages/%9u} {N:swap pager pages paged in}\n", > + sum.v_swappgsin); > + xo_emit("{:swap-outs/%9u} {N:swap pager pageouts}\n", > + sum.v_swapout); > + xo_emit("{:swap-out-pages/%9u} {N:swap pager pages paged out}\n", > + sum.v_swappgsout); > + xo_emit("{:vnode-page-ins/%9u} {N:vnode pager pageins}\n", > + sum.v_vnodein); > + xo_emit("{:vnode-page-in-pages/%9u} {N:vnode pager pages paged in}\n", > + sum.v_vnodepgsin); > + xo_emit("{:vnode-page-outs/%9u} {N:vnode pager pageouts}\n", > + sum.v_vnodeout); > + xo_emit("{:vnode-page-outs/%9u} {N:vnode pager pages paged out}\n", > + sum.v_vnodepgsout); > + xo_emit("{:page-daemon-wakeups/%9u} {N:page daemon wakeups}\n", > + sum.v_pdwakeups); > + xo_emit("{:page-daemon-pages/%9u} {N:pages examined by the page > daemon}\n", > + sum.v_pdpages); > + xo_emit("{:reactivated/%9u} {N:pages reactivated}\n", > + sum.v_reactivated); > + xo_emit("{:copy-on-write-faults/%9u} {N:copy-on-write faults}\n", > + sum.v_cow_faults); > + xo_emit("{:copy-on-write-optimized-faults/%9u} {N:copy-on-write optimized > faults}\n", > + sum.v_cow_optim); > + xo_emit("{:zero-fill-pages/%9u} {N:zero fill pages zeroed}\n", > + sum.v_zfod); > + xo_emit("{:zero-fill-prezeroed/%9u} {N:zero fill pages prezeroed}\n", > + sum.v_ozfod); > + xo_emit("{:intransit-blocking/%9u} {N:intransit blocking page faults}\n", > + sum.v_intrans); > + xo_emit("{:total-faults/%9u} {N:total VM faults taken}\n", > + sum.v_vm_faults); > + xo_emit("{:faults-requiring-io/%9u} {N:page faults requiring I\\/O}\n", > + sum.v_io_faults); > + xo_emit("{:faults-from-thread-creation/%9u} {N:pages affected by kernel > thread creation}\n", > + sum.v_kthreadpages); > + xo_emit("{:faults-from-fork/%9u} {N:pages affected by fork}()\n", > + sum.v_forkpages); > + xo_emit("{:faults-from-vfork/%9u} {N:pages affected by vfork}()\n", > + sum.v_vforkpages); > + xo_emit("{:pages-rfork/%9u} {N:pages affected by rfork}()\n", > + sum.v_rforkpages); > + xo_emit("{:pages-total-cached/%9u} {N:pages cached}\n", > + sum.v_tcached); > + xo_emit("{:pages-freed/%9u} {N:pages freed}\n", > + sum.v_tfree); > + xo_emit("{:pages-freed-by-daemon/%9u} {N:pages freed by daemon}\n", > + sum.v_dfree); > + xo_emit("{:pages-freed-on-exit/%9u} {N:pages freed by exiting > processes}\n", > + sum.v_pfree); > + xo_emit("{:active-pages/%9u} {N:pages active}\n", > + sum.v_active_count); > + xo_emit("{:inactive-pages/%9u} {N:pages inactive}\n", > + sum.v_inactive_count); > + xo_emit("{:vm-cache/%9u} {N:pages in VM cache}\n", > + sum.v_cache_count); > + xo_emit("{:wired-pages/%9u} {N:pages wired down}\n", > + sum.v_wire_count); > + xo_emit("{:free-pages/%9u} {N:pages free}\n", > + sum.v_free_count); > + xo_emit("{:bytes-per-page/%9u} {N:bytes per page}\n", sum.v_page_size); > if (kd != NULL) { > kread(X_NCHSTATS, &lnchstats, sizeof(lnchstats)); > } else { > size_t size = sizeof(lnchstats); > mysysctl("vfs.cache.nchstats", &lnchstats, &size, NULL, 0); > if (size != sizeof(lnchstats)) > - errx(1, "vfs.cache.nchstats size mismatch"); > + xo_errx(1, "vfs.cache.nchstats size mismatch"); > } > nchtotal = lnchstats.ncs_goodhits + lnchstats.ncs_neghits + > lnchstats.ncs_badhits + lnchstats.ncs_falsehits + > lnchstats.ncs_miss + lnchstats.ncs_long; > - (void)printf("%9ld total name lookups\n", nchtotal); > - (void)printf( > - "%9s cache hits (%ld%% pos + %ld%% neg) system %ld%% > per-directory\n", > + xo_emit(":total-name-lookups/%9ld} {N:total name lookups}\n", > + nchtotal); > + xo_emit("{P:/%9s} {N:cache hits} " > + "({:positive-cache-hits/%ld}% pos + " > + "{:negative-cache-hits/%ld}% {N:neg}) " > + "system {:cache-hit-percent/%ld}% per-directory\n", > "", PCT(lnchstats.ncs_goodhits, nchtotal), > PCT(lnchstats.ncs_neghits, nchtotal), > PCT(lnchstats.ncs_pass2, nchtotal)); > - (void)printf("%9s deletions %ld%%, falsehits %ld%%, toolong %ld%%\n", "", > + xo_emit("{P:/%9s} {L:deletions} {:deletions/%ld}%, " > + "{L:falsehits} {:false-hits/%ld}%, " > + "{L:toolong} {:too-long/%ld}%\n", "", > PCT(lnchstats.ncs_badhits, nchtotal), > PCT(lnchstats.ncs_falsehits, nchtotal), > PCT(lnchstats.ncs_long, nchtotal)); > + xo_close_container("summary-statistics"); > } > > static void > doforkst(void) > { > fill_vmmeter(&sum); > - (void)printf("%u forks, %u pages, average %.2f\n", > + xo_open_container("fork-statistics"); > + xo_emit("{:fork/%u} {N:forks}, {:fork-pages/%u} {N:pages}, " > + "{L:average} {:fork-average/%.2f}\n", > sum.v_forks, sum.v_forkpages, > sum.v_forks == 0 ? 0.0 : > (double)sum.v_forkpages / sum.v_forks); > - (void)printf("%u vforks, %u pages, average %.2f\n", > + xo_emit("{:vfork/%u} {N:vforks}, {:vfork-pages/%u} {N:pages}, " > + "{L:average} {:vfork-average/%.2f}\n", > sum.v_vforks, sum.v_vforkpages, > sum.v_vforks == 0 ? 0.0 : > (double)sum.v_vforkpages / sum.v_vforks); > - (void)printf("%u rforks, %u pages, average %.2f\n", > + xo_emit("{:rfork/%u} {N:rforks}, {:rfork-pages/%u} {N:pages}, " > + "{L:average} {:rfork-average/%.2f}\n", > sum.v_rforks, sum.v_rforkpages, > sum.v_rforks == 0 ? 0.0 : > (double)sum.v_rforkpages / sum.v_rforks); > + xo_close_container("fork-statistics"); > } > > static void > @@ -1073,6 +1170,7 @@ devstats(void) > > busy_seconds = cur.snap_time - last.snap_time; > > + xo_open_list("device"); > for (dn = 0; dn < num_devices; dn++) { > int di; > > @@ -1086,24 +1184,33 @@ devstats(void) > &last.dinfo->devices[di], busy_seconds, > DSM_TRANSFERS_PER_SECOND, &transfers_per_second, > DSM_NONE) != 0) > - errx(1, "%s", devstat_errbuf); > + xo_errx(1, "%s", devstat_errbuf); > > - (void)printf("%3.0Lf ", transfers_per_second); > + xo_open_instance("device"); > + xo_emit("{ekq:name/%c%c%d}{:transfers/%3.0Lf} ", > + dev_select[dn].device_name[0], > + dev_select[dn].device_name[1], > + dev_select[dn].unit_number, > + transfers_per_second); > + xo_close_instance("device"); > } > + xo_close_list("device"); > } > > static void > -percent(double pct, int *over) > +percent(const char *name, double pct, int *over) > { > char buf[10]; > + char fmt[128]; > int l; > > + snprintf(fmt, sizeof(fmt), " {:%s/%%*s}", name); > l = snprintf(buf, sizeof(buf), "%.0f", pct); > if (l == 1 && *over) { > - printf("%s", buf); > + xo_emit(fmt, 1, buf); > (*over)--; > } else > - printf("%2s", buf); > + xo_emit(fmt, 2, buf); > if (l > 2) > (*over)++; > } > @@ -1122,12 +1229,11 @@ cpustats(void) > else > lpct = 0.0; > over = 0; > - printf(" "); > - percent((cur.cp_time[CP_USER] + cur.cp_time[CP_NICE]) * lpct, &over); > - printf(" "); > - percent((cur.cp_time[CP_SYS] + cur.cp_time[CP_INTR]) * lpct, &over); > - printf(" "); > - percent(cur.cp_time[CP_IDLE] * lpct, &over); > + xo_open_container("cpu-statistics"); > + percent("user", (cur.cp_time[CP_USER] + cur.cp_time[CP_NICE]) * lpct, > &over); > + percent("system", (cur.cp_time[CP_SYS] + cur.cp_time[CP_INTR]) * lpct, > &over); > + percent("idle", cur.cp_time[CP_IDLE] * lpct, &over); > + xo_close_container("cpu-statistics"); > } > > static void > @@ -1151,9 +1257,12 @@ pcpustats(int ncpus, u_long cpumask, int > } > > over = 0; > + xo_open_list("cpu"); > for (i = 0; i <= maxid; i++) { > if ((cpumask & (1ul << i)) == 0) > continue; > + xo_open_instance("cpu"); > + xo_emit("{ke:name/%d}", i); > total = 0; > for (state = 0; state < CPUSTATES; ++state) > total += cur_cp_times[i * CPUSTATES + state]; > @@ -1161,15 +1270,15 @@ pcpustats(int ncpus, u_long cpumask, int > lpct = 100.0 / total; > else > lpct = 0.0; > - printf(" "); > - percent((cur_cp_times[i * CPUSTATES + CP_USER] + > + percent("user", (cur_cp_times[i * CPUSTATES + CP_USER] + > cur_cp_times[i * CPUSTATES + CP_NICE]) * lpct, &over); > - printf(" "); > - percent((cur_cp_times[i * CPUSTATES + CP_SYS] + > + percent("system", (cur_cp_times[i * CPUSTATES + CP_SYS] + > cur_cp_times[i * CPUSTATES + CP_INTR]) * lpct, &over); > - printf(" "); > - percent(cur_cp_times[i * CPUSTATES + CP_IDLE] * lpct, &over); > + percent("idle", cur_cp_times[i * CPUSTATES + CP_IDLE] * lpct, > + &over); > + xo_close_instance("cpu"); > } > + xo_close_list("cpu"); > } > > static unsigned int > @@ -1209,14 +1318,19 @@ print_intrcnts(unsigned long *intrcnts, > inttotal = 0; > old_inttotal = 0; > intrname = intrnames; > + xo_emit("{T:/%-*s} {T:/%20s} {T:/%10s}\n", > + (int)istrnamlen, "interrupt", "total", "rate"); > + xo_open_list("interrupt"); > for (i = 0, intrcnt=intrcnts, old_intrcnt=old_intrcnts; i < nintr; i++) { > if (intrname[0] != '\0' && (*intrcnt != 0 || aflag)) { > unsigned long count, rate; > > count = *intrcnt - *old_intrcnt; > rate = (count * 1000 + period_ms / 2) / period_ms; > - (void)printf("%-*s %20lu %10lu\n", (int)istrnamlen, > - intrname, count, rate); > + xo_open_instance("interrupt"); > + xo_emit("{k:name/%-*s} {:total/%20lu} {:rate/%10lu}\n", > + (int)istrnamlen, intrname, count, rate); > + xo_close_instance("interrupt"); > } > intrname += strlen(intrname) + 1; > inttotal += *intrcnt++; > @@ -1224,8 +1338,10 @@ print_intrcnts(unsigned long *intrcnts, > } > total_count = inttotal - old_inttotal; > total_rate = (total_count * 1000 + period_ms / 2) / period_ms; > - (void)printf("%-*s %20" PRIu64 " %10" PRIu64 "\n", (int)istrnamlen, > - "Total", total_count, total_rate); > + xo_close_list("interrupt"); > + xo_emit("{L:/%-*s} {:total-interrupts/%20" PRIu64 "} " > + "{:total-rate/%10" PRIu64 "}\n", (int)istrnamlen, > + "Total", total_count, total_rate); > } > > static void > @@ -1243,12 +1359,12 @@ dointr(unsigned int interval, int reps) > if (kd != NULL) { > kread(X_SINTRNAMES, &inamlen, sizeof(inamlen)); > if ((intrnames = malloc(inamlen)) == NULL) > - err(1, "malloc()"); > + xo_err(1, "malloc()"); > kread(X_INTRNAMES, intrnames, inamlen); > } else { > for (intrnames = NULL, inamlen = 1024; ; inamlen *= 2) { > if ((intrnames = reallocf(intrnames, inamlen)) == NULL) > - err(1, "reallocf()"); > + xo_err(1, "reallocf()"); > if (mysysctl("hw.intrnames", > intrnames, &inamlen, NULL, 0) == 0) > break; > @@ -1264,8 +1380,8 @@ dointr(unsigned int interval, int reps) > istrnamlen = clen; > intrname += strlen(intrname) + 1; > } > - (void)printf("%-*s %20s %10s\n", (int)istrnamlen, "interrupt", "total", > - "rate"); > + xo_emit("%{T:/%-%s} {T:/%20s} {T:/%10s\n", > + (int)istrnamlen, "interrupt", "total", "rate"); > > /* > * Loop reps times printing differential interrupt counts. If reps is > @@ -1284,7 +1400,7 @@ dointr(unsigned int interval, int reps) > if (old_intrcnts == NULL) { > old_intrcnts = calloc(nintr, sizeof(unsigned long)); > if (old_intrcnts == NULL) > - err(1, "calloc()"); > + xo_err(1, "calloc()"); > } > > print_intrcnts(intrcnts, old_intrcnts, intrnames, nintr, > @@ -1310,12 +1426,12 @@ domemstat_malloc(void) > > mtlp = memstat_mtl_alloc(); > if (mtlp == NULL) { > - warn("memstat_mtl_alloc"); > + xo_warn("memstat_mtl_alloc"); > return; > } > if (kd == NULL) { > if (memstat_sysctl_malloc(mtlp, 0) < 0) { > - warnx("memstat_sysctl_malloc: %s", > + xo_warnx("memstat_sysctl_malloc: %s", > memstat_strerror(memstat_mtl_geterror(mtlp))); > return; > } > @@ -1323,35 +1439,43 @@ domemstat_malloc(void) > if (memstat_kvm_malloc(mtlp, kd) < 0) { > error = memstat_mtl_geterror(mtlp); > if (error == MEMSTAT_ERROR_KVM) > - warnx("memstat_kvm_malloc: %s", > + xo_warnx("memstat_kvm_malloc: %s", > kvm_geterr(kd)); > else > - warnx("memstat_kvm_malloc: %s", > + xo_warnx("memstat_kvm_malloc: %s", > memstat_strerror(error)); > } > } > - printf("%13s %5s %6s %7s %8s Size(s)\n", "Type", "InUse", "MemUse", > - "HighUse", "Requests"); > + xo_emit("{T:/%13s} {T:/%5s} {T:/%6s} {T:/%7s} {T:/%8s} {T:Size(s)}\n", > + "Type", "InUse", "MemUse", "HighUse", "Requests"); > + xo_open_list("memory"); > for (mtp = memstat_mtl_first(mtlp); mtp != NULL; > mtp = memstat_mtl_next(mtp)) { > if (memstat_get_numallocs(mtp) == 0 && > memstat_get_count(mtp) == 0) > continue; > - printf("%13s %5" PRIu64 " %5" PRIu64 "K %7s %8" PRIu64 " ", > + xo_open_instance("memory"); > + xo_emit("{k:type/%13s} {:in-use/%5" PRIu64 "} " > + "{:memory-use/%5" PRIu64 "}{U:K} {:high-use/%7s} " > + "{:requests/%8" PRIu64 "} ", > memstat_get_name(mtp), memstat_get_count(mtp), > (memstat_get_bytes(mtp) + 1023) / 1024, "-", > memstat_get_numallocs(mtp)); > first = 1; > + xo_open_list("size"); > for (i = 0; i < 32; i++) { > if (memstat_get_sizemask(mtp) & (1 << i)) { > if (!first) > - printf(","); > - printf("%d", 1 << (i + 4)); > + xo_emit(","); > + xo_emit("{l:size/%d}", 1 << (i + 4)); > first = 0; > } > } > - printf("\n"); > + xo_close_list("size"); > + xo_close_instance("memory"); > + xo_emit("\n"); > } > + xo_close_list("memory"); > memstat_mtl_free(mtlp); > } > > @@ -1365,12 +1489,12 @@ domemstat_zone(void) > > mtlp = memstat_mtl_alloc(); > if (mtlp == NULL) { > - warn("memstat_mtl_alloc"); > + xo_warn("memstat_mtl_alloc"); > return; > } > if (kd == NULL) { > if (memstat_sysctl_uma(mtlp, 0) < 0) { > - warnx("memstat_sysctl_uma: %s", > + xo_warnx("memstat_sysctl_uma: %s", > memstat_strerror(memstat_mtl_geterror(mtlp))); > return; > } > @@ -1378,28 +1502,35 @@ domemstat_zone(void) > if (memstat_kvm_uma(mtlp, kd) < 0) { > error = memstat_mtl_geterror(mtlp); > if (error == MEMSTAT_ERROR_KVM) > - warnx("memstat_kvm_uma: %s", > + xo_warnx("memstat_kvm_uma: %s", > kvm_geterr(kd)); > else > - warnx("memstat_kvm_uma: %s", > + xo_warnx("memstat_kvm_uma: %s", > memstat_strerror(error)); > } > } > - printf("%-20s %6s %6s %8s %8s %8s %4s %4s\n\n", "ITEM", "SIZE", > - "LIMIT", "USED", "FREE", "REQ", "FAIL", "SLEEP"); > + xo_emit("{T:/%-20s} {T:/%6s} {T:/%6s} {T:/%8s} {T:/%8s} {T:/%8s} " > + "{T:/%4s} {T:/%4s}\n\n", "ITEM", "SIZE", > + "LIMIT", "USED", "FREE", "REQ", "FAIL", "SLEEP"); > + xo_open_list("zone"); > for (mtp = memstat_mtl_first(mtlp); mtp != NULL; > mtp = memstat_mtl_next(mtp)) { > strlcpy(name, memstat_get_name(mtp), MEMTYPE_MAXNAME); > strcat(name, ":"); > - printf("%-20s %6" PRIu64 ", %6" PRIu64 ",%8" PRIu64 ",%8" PRIu64 > - ",%8" PRIu64 ",%4" PRIu64 ",%4" PRIu64 "\n", name, > - memstat_get_size(mtp), memstat_get_countlimit(mtp), > - memstat_get_count(mtp), memstat_get_free(mtp), > > *** DIFF OUTPUT TRUNCATED AT 1000 LINES *** > _______________________________________________ > svn-src-head@freebsd.org mailing list > https://lists.freebsd.org/mailman/listinfo/svn-src-head > To unsubscribe, send any mail to "svn-src-head-unsubscribe@freebsd.org" >