/*      $NetBSD: syscall.c,v 1.10 2019/01/25 15:31:11 christos Exp $    */

/*-
* Copyright (c) 2006 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by David Laight.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__RCSID("$NetBSD: syscall.c,v 1.10 2019/01/25 15:31:11 christos Exp $");

/* System call stats */

#include <sys/param.h>
#include <sys/namei.h>
#include <sys/sysctl.h>

#include <uvm/uvm_extern.h>

#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <util.h>

#include "systat.h"
#include "extern.h"
#include "drvstats.h"
#include "utmpentry.h"
#include "vmstat.h"

#include <sys/syscall.h>
#include <../../sys/kern/syscalls.c>

static struct Info {
       struct   uvmexp_sysctl uvmexp;
       struct   vmtotal Total;
       uint64_t counts[SYS_NSYSENT];
       uint64_t times[SYS_NSYSENT];
} s, s1, s2;

static uint64_t irf[SYS_NSYSENT], val[SYS_NSYSENT];
static int irf_first = 1;

int syscall_sort[SYS_NSYSENT];

static  enum sort_order { UNSORTED, NAMES, COUNTS } sort_order = NAMES;

#define SHOW_COUNTS     1
#define SHOW_TIMES      2
static int show = SHOW_COUNTS;

static void getinfo(struct Info *, int);

static  char buf[32];

static size_t counts_mib_len, times_mib_len;
static int counts_mib[4], times_mib[4];

WINDOW *
opensyscall(void)
{
       return (stdscr);
}

void
closesyscall(WINDOW *w)
{

       if (w == NULL)
               return;
       wclear(w);
       wrefresh(w);
}


/*
* These constants define where the major pieces are laid out
*/
#define SYSCALLROW      9       /* Below the vmstat header */

int
initsyscall(void)
{
       static char name[] = "name";

       hertz = stathz ? stathz : hz;

       syscall_order(name);

       /* drvinit gets number of cpus! */
       drvinit(1);

       counts_mib_len = __arraycount(counts_mib);
       if (sysctlnametomib("kern.syscalls.counts", counts_mib,
           &counts_mib_len))
               counts_mib_len = 0;

       times_mib_len = __arraycount(times_mib);
       if (sysctlnametomib("kern.syscalls.times", times_mib, &times_mib_len))
               times_mib_len = 0;

       getinfo(&s2, SHOW_COUNTS | SHOW_TIMES);
       s1 = s2;

       return(1);
}

void
fetchsyscall(void)
{
       time_t now;

       time(&now);
       strlcpy(buf, ctime(&now), sizeof(buf));
       buf[19] = '\0';
       getinfo(&s, show);
}

void
labelsyscall(void)
{
       labelvmstat_top();
}

static void
putuint64(uint64_t v, int row, int col, int width)
{
       static const char suffix[] = "KMDT";
       int len, i;

       len = snprintf(buf, sizeof buf, "%" PRIu64, v);
       if (len > width) {
               i = (len - width) / 3;
               if (i >= (int)sizeof(suffix)) {
                       memset(buf, '*', width);
                       len = width;
               } else {
                       len -= (i + 1) * 3;
                       buf[len++] = suffix[i];
               }
               buf[len] = 0;
       }
       mvprintw(row, col, "%*s", width, buf);
}

static int
compare_irf(const void *a, const void *b)
{
       int ia = *(const int *)a, ib = *(const int *)b;
       int64_t delta;

       delta = irf[ib] - irf[ia];
       return delta ? delta < 0 ? -1 : 1 : 0;
}

void
showsyscall(void)
{
       int i, ii, l, c;
       uint64_t v;
       static int failcnt = 0;
       static int relabel = 0;
       uint64_t itime;

       if (relabel) {
               labelsyscall();
               relabel = 0;
       }

       cpuswap();
       if (display_mode == TIME) {
               if (toofast(&failcnt))
                       return;
       } else
               etime = 1.0;
       itime = etime * 100;

       failcnt = 0;

       show_vmstat_top(&s.Total, &s.uvmexp, &s1.uvmexp);

       /* Sort out the values we are going to display */
       for (i = 0; i < (int)__arraycount(s.counts); i++) {
               switch (show) {
               default:
               case SHOW_COUNTS:
                       v = s.counts[i] - s1.counts[i];
                       break;
               case SHOW_TIMES:
                       v = s.times[i] - s1.times[i];
                       break;
               case SHOW_COUNTS | SHOW_TIMES:    /* time/count */
                       v = s.counts[i] - s1.counts[i];
                       v = v ? (s.times[i] - s1.times[i]) / v : 0;
               }

               if (display_mode == TIME)
                   v = (v * 100 + itime/2) / itime;

               val[i] = v;

               /*
                * We use an 'infinite response filter' in a vague
                * attempt to stop the data leaping around too much.
                * I suspect there are other/better methods in use.
                */
               if (irf_first) {
                       irf[i] = v;
                       irf_first = 0;
               } else {
                       irf[i] = irf[i] * 7 / 8 + v;
               }
       }

       if (sort_order == COUNTS) {
               /* mergesort() doesn't swap equal values about... */
               mergesort(syscall_sort, __arraycount(syscall_sort),
                       sizeof syscall_sort[0], compare_irf);
       }

       l = SYSCALLROW;
       c = 0;
       move(l, c);
#define FMT "compile kernel with \"options SYSCALL_%s\" to get syscall %s"
       if (counts_mib_len == 0) {
               mvprintw(l, c, FMT, "STATS", "counts");
               l++;
       }
       if (times_mib_len == 0) {
               mvprintw(l, c, FMT, "TIMES", "times");
               l++;
       }
       for (ii = 0; ii < (int)__arraycount(s.counts); ii++) {
               i = syscall_sort[ii];
               if (val[i] == 0 && irf[i] == 0)
                       continue;

               if (i < (int)__arraycount(syscallnames)) {
                       const char *name = syscallnames[i];
                       while (name[0] == '_')
                               name++;
                       if (name[0] == 'c' && !strcmp(name + 1, "ompat_"))
                               name += 7;
                       mvprintw(l, c, "%17.17s", name);
               } else
                       mvprintw(l, c, "syscall #%d       ", i);

               putuint64(val[i], l, c + 18, 8);
               c += 27;
               if (c + 26 > COLS) {
                       c = 0;
                       l++;
                       if (l >= LINES - 1)
                               break;
               }
       }
       if (display_mode == TIME) {
               memcpy(s1.counts, s.counts, sizeof s1.counts);
               memcpy(s1.times, s.times, sizeof s1.times);
       }
       while (l < LINES - 1) {
           clrtoeol();
           move(++l, 0);
       }
}

void
syscall_boot(char *args)
{
       memset(&s1, 0, sizeof s1);
       display_mode = BOOT;
}

void
syscall_run(char *args)
{
       s1 = s2;
       display_mode = RUN;
}

void
syscall_time(char *args)
{
       display_mode = TIME;
}

void
syscall_zero(char *args)
{
       s1 = s;
}

static int
compare_names(const void *a, const void *b)
{
       const char *name_a = syscallnames[*(const int *)a];
       const char *name_b = syscallnames[*(const int *)b];

       while (*name_a == '_')
               name_a++;
       while (*name_b == '_')
               name_b++;

       return strcmp(name_a, name_b);
}

void
syscall_order(char *args)
{
       int i, len;

       if (args == NULL)
               goto usage;

       len = strcspn(args, " \t\r\n");

       if (args[len + strspn(args + len, " \t\r\n")])
               goto usage;

       if (memcmp(args, "count", len) == 0)
               sort_order = COUNTS;
       else if (memcmp(args, "name", len) == 0)
               sort_order = NAMES;
       else if (memcmp(args, "syscall", len) == 0)
               sort_order = UNSORTED;
       else
               goto usage;

       /* Undo all the sorting */
       for (i = 0; i < (int)__arraycount(syscall_sort); i++)
               syscall_sort[i] = i;

       if (sort_order == NAMES) {
               /* Only sort the entries we have names for */
               qsort(syscall_sort, __arraycount(syscallnames), sizeof syscall_sort[0],
                       compare_names);
       }
       return;

   usage:
       error("Usage: sort [count|name|syscall]");
}

void
syscall_show(char *args)
{
       int len;

       if (args == NULL)
               goto usage;

       len = strcspn(args, " \t\r\n");

       if (args[len + strspn(args + len, " \t\r\n")])
               goto usage;

       if (memcmp(args, "counts", len) == 0)
               show = SHOW_COUNTS;
       else if (memcmp(args, "times", len) == 0)
               show = SHOW_TIMES;
       else if (memcmp(args, "ratio", len) == 0)
               show = SHOW_COUNTS | SHOW_TIMES;
       else
               goto usage;

       memset(&irf, 0, sizeof irf);
       irf_first = 1;

       return;

   usage:
       error("Usage: show [counts|times|ratio]");
}

static void
getinfo(struct Info *stats, int get_what)
{
       int mib[2];
       size_t size;

       cpureadstats();

       if (get_what & SHOW_COUNTS) {
               size = sizeof stats->counts;
               if (counts_mib_len != 0) {
                       if (sysctl(counts_mib, counts_mib_len, &stats->counts,
                           &size, NULL, 0)) {
                               error("can't get syscall counts: %s\n",
                                   strerror(errno));
                               memset(&stats->counts, 0, sizeof stats->counts);
                       }
               }
       }

       if (get_what & SHOW_TIMES) {
               size = sizeof stats->times;
               if (times_mib_len != 0) {
                       if (sysctl(times_mib, times_mib_len, &stats->times,
                           &size, NULL, 0)) {
                               error("can't get syscall times: %s\n",
                                   strerror(errno));
                               memset(&stats->times, 0, sizeof stats->times);
                       }
               }
       }

       size = sizeof(stats->uvmexp);
       mib[0] = CTL_VM;
       mib[1] = VM_UVMEXP2;
       if (sysctl(mib, 2, &stats->uvmexp, &size, NULL, 0) < 0) {
               error("can't get uvmexp: %s\n", strerror(errno));
               memset(&stats->uvmexp, 0, sizeof(stats->uvmexp));
       }
       size = sizeof(stats->Total);
       mib[0] = CTL_VM;
       mib[1] = VM_METER;
       if (sysctl(mib, 2, &stats->Total, &size, NULL, 0) < 0) {
               error("Can't get kernel info: %s\n", strerror(errno));
               memset(&stats->Total, 0, sizeof(stats->Total));
       }
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.