/* Copyright (C) 1998-99 Martin Baulig This file is part of LibGTop 1.0. Contributed by Martin Baulig , April 1998. LibGTop is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. LibGTop is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with LibGTop; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include #include #ifdef __FreeBSD__ #include #endif static const unsigned long _glibtop_sysdeps_proc_time = (1L << GLIBTOP_PROC_TIME_RTIME) + (1L << GLIBTOP_PROC_TIME_FREQUENCY); static const unsigned long _glibtop_sysdeps_proc_time_user = (1L << GLIBTOP_PROC_TIME_UTIME) + (1L << GLIBTOP_PROC_TIME_STIME) + (1L << GLIBTOP_PROC_TIME_CUTIME) + (1L << GLIBTOP_PROC_TIME_CSTIME) + (1L << GLIBTOP_PROC_TIME_START_TIME); #define tv2sec(tv) (((guint64) tv.tv_sec * 1000000) + (guint64) tv.tv_usec) /* Init function. */ void _glibtop_init_proc_time_p (glibtop *server) { server->sysdeps.proc_time = _glibtop_sysdeps_proc_time | _glibtop_sysdeps_proc_time_user; } /* Taken from /usr/src/sys/kern/kern_resource.c */ /* * Transform the running time and tick information in proc p into user, * system, and interrupt time usage. */ #if !(defined(__FreeBSD__) || defined(__FreeBSD_kernel__)) static void calcru(p, up, sp, ip) struct proc *p; struct timeval *up; struct timeval *sp; struct timeval *ip; { quad_t totusec; u_quad_t u, st, ut, it, tot; long sec, usec; struct timeval tv; st = p->p_sticks; ut = p->p_uticks; it = p->p_iticks; tot = st + ut + it; if (tot == 0) { st = 1; tot = 1; } sec = p->p_rtime.tv_sec; usec = p->p_rtime.tv_usec; totusec = (quad_t)sec * 1000000 + usec; if (totusec < 0) { /* XXX no %qd in kernel. Truncate. */ fprintf (stderr, "calcru: negative time: %ld usec\n", (long)totusec); totusec = 0; } u = totusec; st = (u * st) / tot; sp->tv_sec = st / 1000000; sp->tv_usec = st % 1000000; ut = (u * ut) / tot; up->tv_sec = ut / 1000000; up->tv_usec = ut % 1000000; if (ip != NULL) { it = (u * it) / tot; ip->tv_sec = it / 1000000; ip->tv_usec = it % 1000000; } } #endif /* !__FreeBSD__ */ /* Provides detailed information about a process. */ void glibtop_get_proc_time_p (glibtop *server, glibtop_proc_time *buf, pid_t pid) { struct kinfo_proc *pinfo; #if (defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000)) || (defined(OpenBSD) && (OpenBSD >= 199912)) register struct rusage *rup; #else struct user *u_addr = (struct user *)USRSTACK; #endif struct pstats pstats; int count; glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_TIME), 0); memset (buf, 0, sizeof (glibtop_proc_time)); /* It does not work for the swapper task. */ if (pid == 0) return; #if (defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000)) if (server->sysdeps.proc_time == 0) return; #endif /* Get the process information */ pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count); if ((pinfo == NULL) || (count != 1)) { glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid); return; } #if (defined(__FreeBSD__) && (__FreeBSD_version >= 500013)) || defined(__FreeBSD_kernel__) buf->rtime = pinfo [0].ki_runtime; #elif (defined __FreeBSD__) && (__FreeBSD_version <= 500013) buf->rtime = pinfo [0].kp_proc.p_runtime; #else buf->rtime = tv2sec (pinfo [0].kp_proc.p_rtime); #endif buf->frequency = 1000000; buf->flags = _glibtop_sysdeps_proc_time; #if (defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000)) || (defined(OpenBSD) && (OpenBSD >= 199912)) glibtop_suid_enter (server); if (kvm_read (server->machine.kd, (unsigned long) pinfo [0].kp_proc.p_stats, &pstats, sizeof (pstats)) != sizeof (pstats)) { glibtop_warn_io_r (server, "kvm_read (pstats)"); return; } glibtop_suid_leave (server); rup = &pstats.p_ru; calcru(&(pinfo [0]).kp_proc, &rup->ru_utime, &rup->ru_stime, NULL); buf->utime = tv2sec (pstats.p_ru.ru_utime); buf->stime = tv2sec (pstats.p_ru.ru_stime); buf->cutime = tv2sec (pstats.p_cru.ru_utime); buf->cstime = tv2sec (pstats.p_cru.ru_stime); buf->start_time = (guint64) pstats.p_start.tv_sec; buf->flags |= _glibtop_sysdeps_proc_time_user; #else #if (defined(__FreeBSD__) && (__FreeBSD_version >= 500013)) || defined(__FreeBSD_kernel__) #if (__FreeBSD_version >= 500016) || defined(__FreeBSD_kernel__) if ((pinfo [0].ki_flag & PS_INMEM)) { #else if ((pinfo [0].ki_flag & P_INMEM)) { #endif buf->utime = pinfo [0].ki_runtime; buf->stime = tv2sec (pinfo [0].ki_rusage.ru_stime); buf->cutime = tv2sec (pinfo [0].ki_childtime); #if (__FreeBSD_version >= 600000) || (__FreeBSD_kernel_version >= 600000) buf->cstime = tv2sec (pinfo [0].ki_rusage_ch.ru_stime); #else buf->cstime = 0; #endif buf->start_time = tv2sec (pinfo [0].ki_start); buf->flags = _glibtop_sysdeps_proc_time_user; } glibtop_suid_enter (server); #elif (__FreeBSD_version <= 500013) if ((pinfo [0].kp_proc.p_flag & P_INMEM) && kvm_uread (server->machine.kd, &(pinfo [0]).kp_proc, (unsigned long) &u_addr->u_stats, (char *) &pstats, sizeof (pstats)) == sizeof (pstats)) { buf->utime = tv2sec (pinfo[0].kp_eproc.e_stats.p_ru.ru_utime); buf->stime = tv2sec (pinfo[0].kp_eproc.e_stats.p_ru.ru_stime); buf->cutime = tv2sec (pinfo[0].kp_eproc.e_stats.p_cru.ru_utime); buf->cstime = tv2sec (pinfo[0].kp_eproc.e_stats.p_cru.ru_stime); buf->start_time = tv2sec (pinfo[0].kp_eproc.e_stats.p_start); buf->flags = _glibtop_sysdeps_proc_time_user; glibtop_suid_leave (server); } #else if ((pinfo [0].kp_proc.p_flag & P_INMEM) && kvm_uread (server->machine.kd, &(pinfo [0]).kp_proc, (unsigned long) &u_addr->u_stats, (char *) &pstats, sizeof (pstats)) == sizeof (pstats)) { /* This is taken form the kernel source code of * FreeBSD 2.2.6. */ /* Well, we just do the same getrusage () does ... */ register struct rusage *rup; glibtop_suid_leave (server); rup = &pstats.p_ru; calcru(&(pinfo [0]).kp_proc, &rup->ru_utime, &rup->ru_stime, NULL); buf->utime = tv2sec (pstats.p_ru.ru_utime); buf->stime = tv2sec (pstats.p_ru.ru_stime); buf->cutime = tv2sec (pstats.p_cru.ru_utime); buf->cstime = tv2sec (pstats.p_cru.ru_stime); buf->start_time = tv2sec (pstats.p_start); buf->flags = _glibtop_sysdeps_proc_time_user; } #endif glibtop_suid_leave (server); #endif }