oxmc/libgtop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reverted libgtop changes. It's a common module and I should not modify it.

Browse Source 
2003-10-19  Carlos Perelló Marín <carlos@gnome.org>

	* support/*: Reverted libgtop changes. It's a common module
	and I should not modify it.
	* Added/removed files. Now the move should be done.
This commit is contained in:
Carlos Perelló Marín
2003-10-19 16:55:56 +00:00
committed by Carlos Perelló Marín
parent bae16b467f
commit 4c8ae9e25c
380 changed files with 49862 additions and 8205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
sysdeps/solaris/.cvsignore Normal file
View File

@@ -0,0 +1,7 @@
.deps
.libs
Makefile
Makefile.in
libgtop_sysdeps.la
*.lo
libgtop_sysdeps_suid.la

2
sysdeps/solaris/AUTHORS Normal file
View File

@@ -0,0 +1,2 @@
Drazen Kacar (dave@srce.hr)
Martin Baulig (martin@home-of-linux.org)

284
sysdeps/solaris/ChangeLog Normal file
View File

@@ -0,0 +1,284 @@
2001-10-17 Abel Cheung <maddog@linux.org.hk>
* Makefile.am: move header to $(includedir)/libgtop-1.0/glibtop.
2001-02-18 Martin Baulig <baulig@suse.de>
Applied a patch from Laszlo PETER <Laszlo.Peter@ireland.sun.com>
for Solaris 8.
* msg_limits.c: `struct msginfo' no longer has msgmap and msgssz.
* sem_limits.c: `struct seminfo' no longer has a semmap field.
1999-10-17 Martin Baulig <martin@home-of-linux.org>
* Makefile.am (libgtop_sysdeps_la_LIBADD): Added `@DL_LIB@'.
1999-09-28 Drazen Kacar <dave@srce.hr>
* proclist.c (glibtop_get_proclist_s): Bugfix. It wasn't
excluding system, non-tty or idle processes if that was
requested.
1999-07-29 Martin Baulig <martin@home-of-linux.org>
* proctime.c (glibtop_get_proc_time_p): Fix bug reported by
Takis Psarogiannakopoulos: `start_time' are seconds since the
epoch as it is stated in the manual.
1999-07-16 Drazen Kacar <dave@srce.hr>
* proclist.c: Bug fix. All Solaris versions have RUID and
RGID in /proc.
1999-06-07 Drazen Kacar <dave@srce.hr>
* glibtop_machine.h, open.c, procargs.c, proclist.c, procmap.c:
Solaris 2.5 & 2.5.1 portability fixes, based on patches
from Steve Murphy <murf@e-tools.com>.
1999-05-30 Drazen Kacar <dave@srce.hr>
* procargs.c: Fixed bug in calculation of process argument list.
1999-05-27 Drazen Kacar <dave@srce.hr>
* glibtop_machine.h, open.c, procmap.c: Get the file name
from inode number.
1999-05-17 Drazen Kacar <dave@srce.hr>
* procargs.c: Implemented what Solaris has to offer cheaply.
It sucks, but digging in process address space would be
too slow.
1999-05-11 Drazen Kacar <dave@srce.hr>
* proctime.c: Return 0 usage times for scheaduler (PID 0).
1999-05-10 Drazen Kacar <dave@srce.hr>
* proclist.c: Added process selection mechanism. It's not
included in Solaris 2.5 build, since we first have to decide
what will be dispatched to daemon.
1999-05-10 Drazen Kacar <dave@srce.hr>
There be some useful documentation now. Syncing...
* mem.c: Output values in bytes, as the documentation requires.
It was a bit odd when gtop reported 256K of total memory.
1999-05-09 Drazen Kacar <dave@srce.hr>
* glibtop_machine.h, procdata.c, proclist.c, procmap.c, procmem.c,
procsignal.c, procstate.c, procuid.c, open.c, mem.c: Initial
Solaris 2.5 port. It's far from being complete and hasn't been
tested properly. We'll need setuid root daemon, which is
currently not implemented. #ifdef symbols to check are
HAVE_PROCFS_H and KSTAT_DATA_UINT32. These will be defined on
Solaris 2.6 and later, but not on earlier releases.
1999-05-08 Drazen Kacar <dave@srce.hr>
* safeio.c, safeio.h: Added s_open(), s_close() etc. with EINTR
wrappers.
* procdata.c, procmap.c, proclist.c: Use them.
1999-05-08 Drazen Kacar <dave@srce.hr>
* procmem.c: Use bytes as units for memory consumption.
1999-05-08 Drazen Kacar <dave@srce.hr>
* procuid.c: Fixed nice value.
1999-05-08 Martin Baulig <martin@home-of-linux.org>
Use the setgid server for IPC Limits.
* shm_limits.c, msg_limits.c, sem_limits.c: Moved them into the
setgid server since they need to access kvm data.
* open_suid.c, close_suid.c: New file. We do the initialization and cleanup
for the setgid server here.
* glibtop_suid.h: New file. We include this in the setgid files.
* open.c: Moved kvm opening code into open_suid.c.
1999-05-07 Drazen Kacar <dave@srce.hr>
* glibtop_machine.h, open.c, mem.c, procmem.c: machine.pagesize
is now number of bits we need for shifting, ie. 2^pagesize
will give pagesize in Kb.
1999-05-07 Drazen Kacar <dave@srce.hr>
* procmem.c: Implemented size, vsize, resident and rss.
1999-05-06 Drazen Kacar <dave@srce.hr>
* siglist.c: Fixed, valid for Solaris 2.6 & 7.
1999-05-06 Drazen Kacar <dave@srce.hr>
* glibtop_private.h, procuid.c, procdata.c: List of supplementary
groups was not correct. Fixed.
1999-05-04 Drazen Kacar <dave@srce.hr>
* glibtop_machine.h: Changed boot time to unsigned long long.
* open.c: Added proper type checking for boot value. There's
no point in saving a few nanoseconds in init function. And
one day it will become 64-bit value.
In glibtop_get_kstats(): Don't reread vminfo_snaptime when
reinitializing kstats.
1999-05-03 Drazen Kacar <dave@srce.hr>
* glibtop_private.h: Fixed typoo.
* procmap.c (glibtop_get_proc_map_s): Implemented start, end,
offset and perm for mapped segments. File name and inode
should be accessible from bunyip kstat data. The only
obstacle is that the data format is undocumented and
possibly not the same accross releases.
1999-05-03 Drazen Kacar <dave@srce.hr>
* glibtop_private.h, procdata.c (glibtop_get_proc_status_s):
Read pstatus info from /proc
* procsignal.c (glibtop_get_proc_signal_s): Implemented
set of pending and blocked signals. The rest should probably
be read from /proc/<pid>/sigact, but I'm not sure it's
worth implementing before thread API comes into place.
* siglist.c: Added Solaris 7 signals. Someone will gettextize
it eventually. Besides, signal list should become a pointer
instead of being fixed field. We need some run time initializations.
The code is written, but commented out.
1999-05-03 Drazen Kacar <dave@srce.hr>
* glibtop_private.h: Ups, forgot to put prototypes in.
1999-05-02 Drazen Kacar <dave@srce.hr>
* open.c (glibtop_get_kstats): Yet another kstat_chain_update
check. Added machine.cpu_stat_kstat[x] = NULL when processor
x is not configured.
* procdata.c (glibtop_get_proc_credentials_s): Read prcred
structure from /proc.
* procstate.c (glibtop_get_proc_state_s): Added ruid, rgid,
has_cpu, processor and last_processor.
* procuid.c (glibtop_get_proc_uid_s): Added priority, nice,
suid, sgid, ngroups and groups. The last four will be
filled only if our process has the authority to read prcred
structure of another process.
1999-05-02 Drazen Kacar <dave@srce.hr>
procdata.c: Use pread() instead of read().
1999-05-02 Drazen Kacar <dave@srce.hr>
* glibtop_machine.h: added fields for page size, clock ticks and
boot time. These are constants. Also added three new kstats.
* open.c (glibtop_get_kstats): Initialize kstats in *server.
We need to call this at init time (obviously) and each time
kstat_chain_update() says that kstat chain has changed. In this
case all kstat pointers and data are invalid, so we need to
reinitialize everything.
(glibtop_open_s): Made it call glibtop_get_kstats(). Added
initialization for run time constants in struct machine.
* cpu.c (glibtop_get_cpu_s): Call kstat_chain_update().
See if processor is on-line and set bits in xcpu_flags.
Added frequency (bad name, should have been ticks).
* swap.c (glibtop_get_swap_s): Call kstat_chain_update().
I probably broke vminfo_snaptime consistency. Fix later.
* uptime.c (glibtop_get_uptime_s): Implemented uptime and boot_time.
Still looking for a sane way to get idletime.
* mem.c (glibtop_get_mem_s): Implemented. Will use bunyip
module if it's loaded. Or when it gets loaded. kstat_chain_update()
is our friend. And with a friends like that...
* loadavg.c (glibtop_get_loadavg_s): Solaris 2.6 code brought
into sync with everything else.
* msg_limits.c (glibtop_init_msg_limits_s): Implemented.
* sem_limits.c (glibtop_get_sem_limits_s): Implemented.
Solaris takes kernel modularity too seriously. We can't get
IPC configuration data if the kernel module is not loaded and
it won't be loaded until some process actually asks for a
particular IPC resource. There's no way to tell our applications
about this. Possible API additions?
All three IPC functions should go into daemon, but I'm keeping
them in the normal library because I can't build daemon yet. All
praise 64 bits!
1999-04-29 Drazen Kacar <dave@srce.hr>
* glibtop_machine.h: added field for kvm descriptor.
* open.c: added code for opening kernel name space.
* shm_limits.c: implemented.
1999-03-31 Drazen Kacar <dave@srce.hr>
* loadavg.c: make it work with Solaris 2.6 and older. A part
of it should be moved to open.c.
1999-03-19 Martin Baulig <martin@home-of-linux.org>
Added first kstat based implementation for Solaris 7.
* open.c (glibtop_open_s): Walk kstat list and save interesting
kstats in the `server->machine'.
* cpu.c: This can already provide `idle', `user' and `sys' with
full SMP support.
* swap.c: This can already provide `total', `used' and `free'.
1999-03-17 Martin Baulig <martin@home-of-linux.org>
Initial import of my Solaris 7 port.
* loadavg.c: We use getloadavg () to get the `loadavg' field.
* procdata.c: This file will handle all interaction with the
/proc filesystem.
(glibtop_get_proc_data_psinfo_s): Read `/proc/<pid>/psinfo' and
return the resulting `struct psinfo'.
(glibtop_get_proc_data_usage_s): Read `/proc/<pid>/usage' and
return the resulting `struct prusage'.
* proclist.c: We use readdir () on /proc to get the list of
all pids.
* procstate.c: Read `uid' and `gid' from the `struct psinfo'.
* proctime.c: Read `start_time', `rtime', `utime' and `stime'
from the `struct prusage'.
* procuid.c: Read `euid', `uid', `egid', `gid', `pid', `ppid',
`pgrp', `session' and `tty' from the `struct psinfo'.

28
sysdeps/solaris/Makefile.am Normal file
View File

@@ -0,0 +1,28 @@
LINK = $(LIBTOOL) --mode=link $(CC) $(CFLAGS) $(LDFLAGS) -o $@
INCLUDES = @INCLUDES@
lib_LTLIBRARIES = libgtop_sysdeps-2.0.la libgtop_sysdeps_suid-2.0.la
libgtop_sysdeps_2_0_la_SOURCES = open.c close.c siglist.c cpu.c mem.c \
safeio.c swap.c uptime.c loadavg.c \
proclist.c procstate.c procuid.c \
proctime.c procmem.c procsignal.c \
prockernel.c procsegment.c procargs.c \
procmap.c netload.c ppp.c procdata.c
libgtop_sysdeps_2_0_la_LDFLAGS = $(LT_VERSION_INFO)
libgtop_sysdeps_2_0_la_LIBADD = @DL_LIB@
libgtop_sysdeps_suid_2_0_la_SOURCES = open_suid.c close_suid.c \
shm_limits.c msg_limits.c sem_limits.c
libgtop_sysdeps_suid_2_0_la_LDFLAGS = $(LT_VERSION_INFO)
libgtopinclude_HEADERS = glibtop_server.h glibtop_machine.h
libgtopincludedir = $(includedir)/libgtop-2.0
noinst_HEADERS = glibtop_private.h glibtop_suid.h safeio.h

30
sysdeps/solaris/close.c Normal file
View File

@@ -0,0 +1,30 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop/close.h>
/* Closes pipe to gtop server. */
void
glibtop_close_s (glibtop *server)
{ }

30
sysdeps/solaris/close_suid.c Normal file
View File

@@ -0,0 +1,30 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop/close.h>
/* Closes pipe to gtop server. */
void
glibtop_close_p (glibtop *server)
{ }

113
sysdeps/solaris/cpu.c Normal file
View File

@@ -0,0 +1,113 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/error.h>
#include <glibtop/cpu.h>
#include <assert.h>
#include <sys/processor.h>
#include <glibtop_private.h>
static const unsigned long _glibtop_sysdeps_cpu =
(1L << GLIBTOP_CPU_TOTAL) + (1L << GLIBTOP_CPU_USER) +
(1L << GLIBTOP_CPU_SYS) + (1L << GLIBTOP_CPU_IDLE) +
(1L << GLIBTOP_XCPU_TOTAL) + (1L << GLIBTOP_XCPU_USER) +
(1L << GLIBTOP_XCPU_SYS) + (1L << GLIBTOP_XCPU_IDLE) +
#if LIBGTOP_VERSION_CODE >= 1001002
(1L << GLIBTOP_XCPU_FLAGS) +
#endif
(1L << GLIBTOP_CPU_FREQUENCY);
/* Init function. */
void
glibtop_init_cpu_s (glibtop *server)
{
server->sysdeps.cpu = _glibtop_sysdeps_cpu;
}
/* Provides information about cpu usage. */
void
glibtop_get_cpu_s (glibtop *server, glibtop_cpu *buf)
{
kstat_ctl_t *kc = server->machine.kc;
cpu_stat_t cpu_stat;
processorid_t cpu;
int ncpu, found;
kid_t ret;
memset (buf, 0, sizeof (glibtop_cpu));
if(!kc)
return;
switch(kstat_chain_update(kc))
{
case -1: assert(0); /* Debugging purposes, shouldn't happen */
case 0: break;
default: glibtop_get_kstats(server);
}
ncpu = server->ncpu;
if (ncpu > GLIBTOP_NCPU)
ncpu = GLIBTOP_NCPU;
for (cpu = 0, found = 0; cpu < GLIBTOP_NCPU && found != ncpu; cpu++)
{
kstat_t *ksp = server->machine.cpu_stat_kstat [cpu];
if (!ksp) continue;
++found;
if(p_online(cpu, P_STATUS) == P_ONLINE)
#if LIBGTOP_VERSION_CODE >= 1001002
buf->xcpu_flags |= (1L << cpu);
#else
;
#endif
else
continue;
ret = kstat_read (kc, ksp, &cpu_stat);
if (ret == -1) {
glibtop_warn_io_r (server, "kstat_read (cpu_stat%d)", cpu);
continue;
}
buf->xcpu_idle [cpu] = cpu_stat.cpu_sysinfo.cpu [CPU_IDLE];
buf->xcpu_user [cpu] = cpu_stat.cpu_sysinfo.cpu [CPU_USER];
buf->xcpu_sys [cpu] = cpu_stat.cpu_sysinfo.cpu [CPU_KERNEL];
buf->xcpu_total [cpu] = buf->xcpu_idle [cpu] + buf->xcpu_user [cpu] +
buf->xcpu_sys [cpu];
buf->idle += cpu_stat.cpu_sysinfo.cpu [CPU_IDLE];
buf->user += cpu_stat.cpu_sysinfo.cpu [CPU_USER];
buf->sys += cpu_stat.cpu_sysinfo.cpu [CPU_KERNEL];
}
buf->total = buf->idle + buf->user + buf->sys;
buf->frequency = server->machine.ticks;
buf->flags = _glibtop_sysdeps_cpu;
}

78
sysdeps/solaris/glibtop_machine.h Normal file
View File

@@ -0,0 +1,78 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, March 1999.
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.
*/
#ifndef __GLIBTOP_MACHINE_H__
#define __GLIBTOP_MACHINE_H__
#include <sys/param.h>
#ifdef HAVE_PROCFS_H
#include <procfs.h>
#else
#include <sys/procfs.h>
#endif
#include <fcntl.h>
#include <kstat.h>
#include <kvm.h>
#include <sys/sysinfo.h>
BEGIN_LIBGTOP_DECLS
typedef struct _glibtop_machine glibtop_machine;
struct _glibtop_machine
{
uid_t uid, euid;
gid_t gid, egid;
pid_t me; /* Don't ask why we need this */
kvm_t *kd;
kstat_ctl_t *kc;
kstat_t *vminfo_kstat;
hrtime_t vminfo_snaptime;
vminfo_t vminfo;
kstat_t *cpu_stat_kstat [64];
kstat_t *system; /* boot_time & avenrun* where needed */
kstat_t *syspages; /* memory usage */
kstat_t *bunyip; /* more memory usage */
int pagesize; /* in bits to shift, ie. 2^pagesize gives Kb */
int ticks; /* clock ticks, as returned by sysconf() */
unsigned long long boot; /* boot time, although it's ui32 in kstat */
void *libproc; /* libproc handle */
#if GLIBTOP_SOLARIS_RELEASE >= 560
void (*objname)(void *, uintptr_t, const char *, size_t);
struct ps_prochandle *(*pgrab)(pid_t, int, int *);
void (*pfree)(void *);
#else
void *filler[3];
#endif
};
END_LIBGTOP_DECLS
#endif /* __GLIBTOP_MACHINE_H__ */

68
sysdeps/solaris/glibtop_private.h Normal file
View File

@@ -0,0 +1,68 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, March 1999.
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.
*/
#ifndef __GLIBTOP_PRIVATE_H__
#define __GLIBTOP_PRIVATE_H__
#include <glibtop.h>
#include <glibtop/error.h>
#include <sys/param.h>
#include <kstat.h>
#include <fcntl.h>
#if defined(HAVE_PROCFS_H)
# include <procfs.h>
#elif defined(HAVE_SYS_PROCFS_H)
# include <sys/procfs.h>
#else
# error Cannot compile without <procfs.h> or <sys/procfs.h>
#endif
BEGIN_LIBGTOP_DECLS
#ifdef HAVE_PROCFS_H
/* Read /proc/<pid>/psinfo */
int glibtop_get_proc_data_psinfo_s(glibtop *, struct psinfo *, pid_t pid);
/* Read /proc/<pid>/status */
int glibtop_get_proc_status_s(glibtop *, struct pstatus *, pid_t);
#else
int glibtop_get_proc_data_psinfo_s(glibtop *, struct prpsinfo *, pid_t);
int glibtop_get_proc_status_s(glibtop *, struct prstatus *, pid_t);
#endif
/* Read /proc/<pid>/usage */
int glibtop_get_proc_data_usage_s(glibtop *, struct prusage *, pid_t);
#if LIBGTOP_VERSION_CODE >= 1001002
/* Read /proc/<pid>/cred */
int glibtop_get_proc_credentials_s(glibtop *, struct prcred *, gid_t *, pid_t);
#endif
/* Reread kstat chains */
void glibtop_get_kstats(glibtop *);
END_LIBGTOP_DECLS
#endif /* __GLIBTOP_PRIVATE_H__ */

52
sysdeps/solaris/glibtop_server.h Normal file
View File

@@ -0,0 +1,52 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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.
*/
#ifndef __GLIBTOP_SERVER_H__
#define __GLIBTOP_SERVER_H__
BEGIN_LIBGTOP_DECLS
#define GLIBTOP_SUID_CPU 0
#define GLIBTOP_SUID_MEM 0
#define GLIBTOP_SUID_SWAP 0
#define GLIBTOP_SUID_UPTIME 0
#define GLIBTOP_SUID_LOADAVG 0
#define GLIBTOP_SUID_SHM_LIMITS (1L << GLIBTOP_SYSDEPS_SHM_LIMITS)
#define GLIBTOP_SUID_MSG_LIMITS (1L << GLIBTOP_SYSDEPS_MSG_LIMITS)
#define GLIBTOP_SUID_SEM_LIMITS (1L << GLIBTOP_SYSDEPS_SEM_LIMITS)
#define GLIBTOP_SUID_PROCLIST 0
#define GLIBTOP_SUID_PROC_STATE 0
#define GLIBTOP_SUID_PROC_UID 0
#define GLIBTOP_SUID_PROC_MEM 0
#define GLIBTOP_SUID_PROC_TIME 0
#define GLIBTOP_SUID_PROC_SIGNAL 0
#define GLIBTOP_SUID_PROC_KERNEL 0
#define GLIBTOP_SUID_PROC_SEGMENT 0
#define GLIBTOP_SUID_PROC_ARGS 0
#define GLIBTOP_SUID_PROC_MAP 0
#define GLIBTOP_SUID_NETLOAD 0
#define GLIBTOP_SUID_PPP 0
END_LIBGTOP_DECLS
#endif

48
sysdeps/solaris/glibtop_suid.h Normal file
View File

@@ -0,0 +1,48 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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.
*/
#ifndef __GLIBTOP_SUID_H__
#define __GLIBTOP_SUID_H__
BEGIN_LIBGTOP_DECLS
static inline void glibtop_suid_enter (glibtop *server) {
setreuid (server->machine.uid, server->machine.euid);
};
static inline void glibtop_suid_leave (glibtop *server) {
if (setreuid (server->machine.euid, server->machine.uid))
_exit (1);
};
void
glibtop_init_p (glibtop *server, const unsigned long features,
const unsigned flags);
void
glibtop_open_p (glibtop *server, const char *program_name,
const unsigned long features,
const unsigned flags);
END_LIBGTOP_DECLS
#endif

87
sysdeps/solaris/loadavg.c Normal file
View File

@@ -0,0 +1,87 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, March 1999.
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 <glibtop.h>
#include <glibtop/loadavg.h>
#ifdef HAVE_GETLOADAVG
#include <sys/loadavg.h>
#else
#include <assert.h>
#include <sys/param.h>
#include <kstat.h>
#endif
static const unsigned long _glibtop_sysdeps_loadavg =
(1L << GLIBTOP_LOADAVG_LOADAVG);
/* Init function. */
void
glibtop_init_loadavg_s (glibtop *server)
{
server->sysdeps.loadavg = _glibtop_sysdeps_loadavg;
}
/* Provides load average. */
void
glibtop_get_loadavg_s (glibtop *server, glibtop_loadavg *buf)
{
#ifndef HAVE_GETLOADAVG
kstat_ctl_t *kc;
kstat_t *ksp;
int i;
static char *avestrings[] = { "avenrun_1min",
"avenrun_5min",
"avenrun_15min" };
#endif
memset (buf, 0, sizeof (glibtop_loadavg));
#ifdef HAVE_GETLOADAVG
if (getloadavg (buf->loadavg, 3))
return;
#else
if(!(kc = server->machine.kc))
return;
switch(kstat_chain_update(kc))
{
case -1: assert(0); /* Debugging, shouldn't happen */
case 0: break;
default: glibtop_get_kstats(server);
}
if(!(ksp = server->machine.system))
return;
if(kstat_read(kc, ksp, NULL) < 0)
return;
for(i = 0; i < 3; ++i) /* Do we have a countof macro? */
{
kstat_named_t *kn;
kn = (kstat_named_t *)kstat_data_lookup(ksp, avestrings[i]);
if(kn)
buf->loadavg[i] = (double)kn->value.ul / FSCALE;
}
#endif
buf->flags = _glibtop_sysdeps_loadavg;
}

127
sysdeps/solaris/mem.c Normal file
View File

@@ -0,0 +1,127 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/mem.h>
#include <assert.h>
#include <unistd.h>
#include <glibtop_private.h>
static const unsigned long _glibtop_sysdeps_mem_os_sysconf =
(1L << GLIBTOP_MEM_TOTAL);
static const unsigned long _glibtop_sysdeps_mem_os_kstat =
(1L << GLIBTOP_MEM_FREE) + (1L << GLIBTOP_MEM_USED) +
(1L << GLIBTOP_MEM_LOCKED);
static const unsigned long _glibtop_sysdeps_mem_bunyip =
(1L << GLIBTOP_MEM_SHARED) + (1L << GLIBTOP_MEM_BUFFER) +
(1L << GLIBTOP_MEM_USER);
/* Init function. */
void
glibtop_init_mem_s (glibtop *server)
{
server->sysdeps.mem = _glibtop_sysdeps_mem_os_sysconf +
_glibtop_sysdeps_mem_os_kstat + _glibtop_sysdeps_mem_bunyip;
}
/* Provides information about memory usage. */
void
glibtop_get_mem_s (glibtop *server, glibtop_mem *buf)
{
kstat_ctl_t *kc = server->machine.kc;
kstat_t *ksp;
kstat_named_t *kn;
int pagesize = server->machine.pagesize;
#ifndef KSTAT_DATA_UINT32
#define ui32 ul
#endif
memset (buf, 0, sizeof (glibtop_mem));
buf->total = (u_int64_t)sysconf(_SC_PHYS_PAGES) << pagesize << 10;
buf->flags = _glibtop_sysdeps_mem_os_sysconf;
if(!kc)
return;
switch(kstat_chain_update(kc))
{
case -1: assert(0); /* Debugging purposes, shouldn't happen */
case 0: break;
default: glibtop_get_kstats(server);
}
if((ksp = server->machine.syspages) && kstat_read(kc, ksp, NULL) >= 0)
{
kn = (kstat_named_t *)kstat_data_lookup(ksp, "pagesfree");
if(kn)
{
#ifdef _LP64
buf->free = kn->value.ui64 << pagesize << 10;
#else
buf->free = kn->value.ui32 << pagesize << 10;
#endif
buf->used = buf->total - buf->free;
}
kn = (kstat_named_t *)kstat_data_lookup(ksp, "pageslocked");
if(kn)
#ifdef _LP64
buf->locked = kn->value.ui64 << pagesize;
#else
buf->locked = kn->value.ui32 << pagesize;
#endif
buf->flags += _glibtop_sysdeps_mem_os_kstat;
}
/* Bunyip module provides data in multiples of system page size */
if((ksp = server->machine.bunyip) && kstat_read(kc, ksp, NULL) >= 0)
{
kn = (kstat_named_t *)kstat_data_lookup(ksp, "pages_anon");
if(kn)
#ifdef _LP64
buf->user = kn->value.ui64 << pagesize << 10;
#else
buf->user = kn->value.ui32 << pagesize << 10;
#endif
kn = (kstat_named_t *)kstat_data_lookup(ksp, "pages_exec");
if(kn)
#ifdef _LP64
buf->shared = kn->value.ui64 << pagesize << 10;
#else
buf->shared = kn->value.ui32 << pagesize << 10;
#endif
kn = (kstat_named_t *)kstat_data_lookup(ksp, "pages_vnode");
if(kn)
#ifdef _LP64
buf->buffer = kn->value.ui64 << pagesize << 10;
#else
buf->buffer = kn->value.ui32 << pagesize << 10;
#endif
buf->flags += _glibtop_sysdeps_mem_bunyip;
}
}

80
sysdeps/solaris/msg_limits.c Normal file
View File

@@ -0,0 +1,80 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/msg_limits.h>
#include <kvm.h>
#include <sys/msg.h>
static struct nlist nlst[] = { {"msginfo"}, {NULL} };
static const unsigned long _glibtop_sysdeps_msg_limits =
#if GLIBTOP_SOLARIS_RELEASE <= 570
(1L << GLIBTOP_IPC_MSGMAP) + (1L << GLIBTOP_IPC_MSGSSZ) +
#endif
(1L << GLIBTOP_IPC_MSGPOOL) + (1L << GLIBTOP_IPC_MSGMAX) +
(1L << GLIBTOP_IPC_MSGMNB) + (1L << GLIBTOP_IPC_MSGMNI) +
(1L << GLIBTOP_IPC_MSGTQL);
/* Init function. */
void
glibtop_init_msg_limits_p (glibtop *server)
{
kvm_t *kd = server->machine.kd;
if(kd && !kvm_nlist(kd, nlst))
server->sysdeps.msg_limits = _glibtop_sysdeps_msg_limits;
else
server->sysdeps.msg_limits = 0;
}
/* Provides information about sysv ipc limits. */
void
glibtop_get_msg_limits_p (glibtop *server, glibtop_msg_limits *buf)
{
kvm_t *kd = server->machine.kd;
struct msginfo minfo;
memset (buf, 0, sizeof (glibtop_msg_limits));
if(!(server->sysdeps.msg_limits))
return;
if(kvm_read(kd, nlst[0].n_value, (void *)&minfo,
sizeof(struct msginfo)) != sizeof(struct msginfo))
return;
#if GLIBTOP_SOLARIS_RELEASE <= 570
/* These fields don't exist anymore in Solaris 8.
* Thanks to Laszlo PETER <Laszlo.Peter@ireland.sun.com>. */
buf->msgmap = minfo.msgmap;
buf->msgssz = minfo.msgssz;
#endif
buf->msgmax = minfo.msgmax;
buf->msgmnb = minfo.msgmnb;
buf->msgmni = minfo.msgmni;
buf->msgtql = minfo.msgtql;
buf->msgpool = minfo.msgmni * minfo.msgmnb >> 10;
buf->flags = _glibtop_sysdeps_msg_limits;
}

45
sysdeps/solaris/netload.c Normal file
View File

@@ -0,0 +1,45 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, October 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 <glibtop.h>
#include <glibtop/error.h>
#include <glibtop/netload.h>
static const unsigned long _glibtop_sysdeps_netload = 0;
/* Init function. */
void
glibtop_init_netload_s (glibtop *server)
{
server->sysdeps.netload = _glibtop_sysdeps_netload;
}
/* Provides network statistics. */
void
glibtop_get_netload_s (glibtop *server, glibtop_netload *buf,
const char *interface)
{
memset (buf, 0, sizeof (glibtop_netload));
}

234
sysdeps/solaris/open.c Normal file
View File

@@ -0,0 +1,234 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop/open.h>
#include <glibtop/cpu.h>
#include <unistd.h>
#include <dlfcn.h>
#include <sys/types.h>
#include <sys/processor.h>
#include <glibtop_private.h>
/* We need to call this when kstat_chain_update() returns new KID.
* In that case all kstat pointers and data are invalid, so we
* need to reread everything. The condition shouldn't happen very
* often.
*/
void
glibtop_get_kstats(glibtop *server)
{
kstat_ctl_t *kc = server->machine.kc;
kstat_t *ksp;
int nproc_same, new_ncpu;
new_ncpu = sysconf(_SC_NPROCESSORS_CONF);
if(!kc)
{
server->ncpu = new_ncpu;
server->machine.vminfo_kstat = NULL;
server->machine.system = NULL;
server->machine.syspages = NULL;
server->machine.bunyip = NULL;
return;
}
do {
ksp = kstat_lookup(kc, "unix", -1, "vminfo");
server->machine.vminfo_kstat = ksp;
if(ksp)
{
kstat_read(kc, ksp, &server->machine.vminfo);
/* Don't change snaptime if we only need to reinitialize kstats */
if(!(server->machine.vminfo_snaptime))
server->machine.vminfo_snaptime = ksp->ks_snaptime;
}
/* We don't know why was kstat chain invalidated. It could have
been because the number of processors changed. The sysconf()
man page says that values returned won't change during the
life time of a process, but let's hope that's just an error in
the documentation. */
if((nproc_same = new_ncpu) == server->ncpu)
{
int checked, i;
char cpu[20];
for(i = 0, checked = 0; i < GLIBTOP_NCPU || checked == new_ncpu; ++i)
if(server->machine.cpu_stat_kstat[i])
{
sprintf(cpu, "cpu_stat%d", i);
if(!(server->machine.cpu_stat_kstat[i] =
kstat_lookup(kc, "cpu_stat", -1, cpu)))
{
nproc_same = 0;
break;
}
++checked;
}
}
if(!nproc_same)
{
processorid_t p;
int found;
char cpu[20];
if(new_ncpu > GLIBTOP_NCPU)
new_ncpu = GLIBTOP_NCPU;
server->ncpu = new_ncpu;
for(p = 0, found = 0; p < GLIBTOP_NCPU && found != new_ncpu; ++p)
{
if(p_online(p, P_STATUS) < 0)
{
server->machine.cpu_stat_kstat[p] = NULL;
continue;
}
sprintf(cpu, "cpu_stat%d", (int)p);
server->machine.cpu_stat_kstat[p] =
kstat_lookup(kc, "cpu_stat", -1, cpu);
++found;
}
}
server->machine.system = kstat_lookup(kc, "unix", -1, "system_misc");
server->machine.syspages = kstat_lookup(kc, "unix", -1, "system_pages");
server->machine.bunyip = kstat_lookup(kc, "bunyip", -1, "mempages");
} while(kstat_chain_update(kc) > 0 &&
(new_ncpu = sysconf(_SC_NPROCESSORS_CONF)));
/* We'll ignore -1 from kstat_chain_update here, since it really
shouldn't happen */
}
void
glibtop_open_s (glibtop *server, const char *program_name,
const unsigned long features, const unsigned flags)
{
kstat_ctl_t *kc;
kstat_t *ksp;
kstat_named_t *kn;
int i, page;
void *dl;
server->name = program_name;
page = sysconf(_SC_PAGESIZE) >> 10;
for(i = 0; page; ++i, page >>= 1);
server->machine.pagesize = i - 1;
server->machine.ticks = sysconf(_SC_CLK_TCK);
server->machine.kc = kc = kstat_open ();
#if 0
for (ksp = server->machine.kc->kc_chain; ksp != NULL; ksp = ksp->ks_next) {
if (!strcmp (ksp->ks_class, "vm") && !strcmp (ksp->ks_name, "vminfo")) {
server->machine.vminfo_kstat = ksp;
kstat_read (server->machine.kc, ksp, &server->machine.vminfo);
server->machine.vminfo_snaptime = ksp->ks_snaptime;
continue;
}
if (!strcmp (ksp->ks_class, "misc") && !strncmp (ksp->ks_name, "cpu_stat", 8)) {
int cpu;
if ((sscanf (ksp->ks_name+8, "%d", &cpu) != 1) || (cpu > 63))
continue;
if (cpu >= server->ncpu)
server->ncpu = cpu+1;
server->machine.cpu_stat_kstat [cpu] = ksp;
continue;
}
}
#endif
if (!kc)
glibtop_warn_io_r (server, "kstat_open ()");
server->ncpu = -1; /* Force processor detection */
server->machine.vminfo_snaptime = 0; /* Force snaptime read */
glibtop_get_kstats(server);
server->machine.boot = 0;
if((ksp = server->machine.system) && kstat_read(kc, ksp, NULL) >= 0)
{
kn = (kstat_named_t *)kstat_data_lookup(ksp, "boot_time");
if(kn)
switch(kn->data_type)
{
#ifdef KSTAT_DATA_INT32
case KSTAT_DATA_INT32: server->machine.boot = kn->value.i32;
break;
case KSTAT_DATA_UINT32: server->machine.boot = kn->value.ui32;
break;
case KSTAT_DATA_INT64: server->machine.boot = kn->value.i64;
break;
case KSTAT_DATA_UINT64: server->machine.boot = kn->value.ui64;
break;
#else
case KSTAT_DATA_LONG: server->machine.boot = kn->value.l;
break;
case KSTAT_DATA_ULONG: server->machine.boot = kn->value.ul;
break;
case KSTAT_DATA_LONGLONG: server->machine.boot = kn->value.ll;
break;
case KSTAT_DATA_ULONGLONG: server->machine.boot = kn->value.ull;
break;
#endif
}
}
/* Now let's have a bit of magic dust... */
#if GLIBTOP_SOLARIS_RELEASE >= 560
dl = dlopen("/usr/lib/libproc.so", RTLD_LAZY);
server->machine.libproc = dl;
if(dl)
{
void *func;
func = dlsym(dl, "Pobjname"); /* Solaris 8 */
if(!func)
func = dlsym(dl, "proc_objname"); /* Solaris 7 */
server->machine.objname = (void (*)
(void *, uintptr_t, const char *, size_t))func;
server->machine.pgrab = (struct ps_prochandle *(*)(pid_t, int, int *))
dlsym(dl, "Pgrab");
server->machine.pfree = (void (*)(void *))dlsym(dl, "Pfree");
}
else
{
server->machine.objname = NULL;
server->machine.pgrab = NULL;
server->machine.pfree = NULL;
}
#endif
server->machine.me = getpid();
}

92
sysdeps/solaris/open_suid.c Normal file
View File

@@ -0,0 +1,92 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/open.h>
#include <glibtop_suid.h>
#include <unistd.h>
#include <sys/types.h>
/* !!! THIS FUNCTION RUNS SUID ROOT - CHANGE WITH CAUTION !!! */
void
glibtop_init_p (glibtop *server, const unsigned long features,
const unsigned flags)
{
glibtop_init_func_t *init_fkt;
if (server == NULL)
glibtop_error_r (NULL, "glibtop_init_p (server == NULL)");
/* Do the initialization, but only if not already initialized. */
if ((server->flags & _GLIBTOP_INIT_STATE_INIT) == 0) {
glibtop_open_p (server, "glibtop", features, flags);
for (init_fkt = _glibtop_init_hook_p; *init_fkt; init_fkt++)
(*init_fkt) (server);
server->flags |= _GLIBTOP_INIT_STATE_INIT;
}
}
/* !!! THIS FUNCTION RUNS SUID ROOT - CHANGE WITH CAUTION !!! */
void
glibtop_open_p (glibtop *server, const char *program_name,
const unsigned long features, const unsigned flags)
{
/* !!! WE ARE ROOT HERE - CHANGE WITH CAUTION !!! */
server->name = program_name;
server->machine.uid = getuid ();
server->machine.euid = geteuid ();
server->machine.gid = getgid ();
server->machine.egid = getegid ();
server->machine.kd = kvm_open(NULL, NULL, NULL, O_RDONLY, NULL);
if(!server->machine.kd)
glibtop_warn_io_r(server, "kvm_open()");
/* Drop priviledges; we only become root when necessary.
setreuid (ruid, euid) - set real and effective user id;
setregid (rgid, egid) - set real and effective group id;
*/
if (setreuid (server->machine.euid, server->machine.uid))
_exit (1);
if (setregid (server->machine.egid, server->machine.gid))
_exit (1);
/* !!! END OF SUID ROOT PART !!! */
/* Our effective uid is now those of the user invoking the server,
so we do no longer have any priviledges.
*/
}

44
sysdeps/solaris/ppp.c Normal file
View File

@@ -0,0 +1,44 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, October 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 <glibtop.h>
#include <glibtop/error.h>
#include <glibtop/ppp.h>
static const unsigned long _glibtop_sysdeps_ppp = 0;
/* Init function. */
void
glibtop_init_ppp_s (glibtop *server)
{
server->sysdeps.ppp = _glibtop_sysdeps_ppp;
}
/* Provides PPP/ISDN information. */
void
glibtop_get_ppp_s (glibtop *server, glibtop_ppp *buf, unsigned short device)
{
memset (buf, 0, sizeof (glibtop_ppp));
}

83
sysdeps/solaris/procargs.c Normal file
View File

@@ -0,0 +1,83 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/error.h>
#include <glibtop/xmalloc.h>
#include <glibtop/procargs.h>
static const unsigned long _glibtop_sysdeps_proc_args =
(1L << GLIBTOP_PROC_ARGS_SIZE);
/* Init function. */
void
glibtop_init_proc_args_s (glibtop *server)
{
server->sysdeps.proc_args = _glibtop_sysdeps_proc_args;
}
/* Provides detailed information about a process. */
char *
glibtop_get_proc_args_s (glibtop *server, glibtop_proc_args *buf,
pid_t pid, unsigned max_len)
{
#ifdef HAVE_PROCFS_H
struct psinfo pinfo;
#else
struct prpsinfo pinfo;
#endif
int len, i;
char *ret, *p;
memset (buf, 0, sizeof (glibtop_proc_args));
if(glibtop_get_proc_data_psinfo_s(server, &pinfo, pid))
return NULL;
for(len = 0; len < PRARGSZ; ++len)
if(!(pinfo.pr_psargs[len]))
break;
if(max_len)
{
ret = glibtop_malloc_r(server, max_len + 1);
if(max_len < len)
len = max_len;
memcpy(ret, pinfo.pr_psargs, len);
ret[len] = 0;
}
else
{
ret = glibtop_malloc_r(server, len + 1);
memcpy(ret, pinfo.pr_psargs, len);
ret[len] = 0;
buf->size = len;
buf->flags = _glibtop_sysdeps_proc_args;
}
for(p = ret; *p; ++p)
if(*p == ' ')
*p = 0;
return ret;
}

268
sysdeps/solaris/procdata.c Normal file
View File

@@ -0,0 +1,268 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop_private.h>
#include <glibtop/procuid.h>
#include <errno.h>
#include "safeio.h"
/*
* The differences between old and new procfs API are:
* - old has /proc/<pid> file and ioctl() is used to obtain the data.
* - new has /proc/<pid>/* files and read() & friends are used to
* obtain the data.
* - names of structures and members are different. It's mostly the
* prefix. Old uses `pr' and new uses `ps'.
*
* Since almost every line would be in #ifdef, I think it would
* be more readable to just copy everything twice. This is not a big
* file, after all.
*/
#ifdef HAVE_PROCFS_H
/* Read /proc/<pid>/psinfo. */
int
glibtop_get_proc_data_psinfo_s (glibtop *server, struct psinfo *psinfo, pid_t pid)
{
int fd;
char buffer [BUFSIZ];
sprintf (buffer, "/proc/%d/psinfo", (int) pid);
fd = s_open (buffer, O_RDONLY);
if (fd < 0) {
glibtop_warn_io_r (server, "open (%s)", buffer);
return -1;
}
if (s_pread (fd, psinfo, sizeof (struct psinfo), 0) !=
sizeof (struct psinfo))
{
s_close (fd);
glibtop_warn_io_r (server, "pread (%s)", buffer);
return -1;
}
s_close (fd);
return 0;
}
int
glibtop_get_proc_data_usage_s (glibtop *server, struct prusage *prusage, pid_t pid)
{
int fd;
char buffer [BUFSIZ];
sprintf (buffer, "/proc/%d/usage", (int) pid);
fd = s_open (buffer, O_RDONLY);
if (fd < 0) {
glibtop_warn_io_r (server, "open (%s)", buffer);
return -1;
}
if (s_pread (fd, prusage, sizeof (struct prusage), 0) !=
sizeof (struct prusage))
{
s_close (fd);
glibtop_warn_io_r (server, "pread (%s)", buffer);
return -1;
}
s_close (fd);
return 0;
}
#if LIBGTOP_VERSION_CODE >= 1001002
int
glibtop_get_proc_credentials_s(glibtop *server,
struct prcred *prcred,
gid_t *groups,
pid_t pid)
{
int fd;
size_t toread;
char buffer[BUFSIZ];
sprintf(buffer, "/proc/%d/cred", (int)pid);
if((fd = s_open(buffer, O_RDONLY)) < 0)
{
if(errno != EPERM && errno != EACCES)
glibtop_warn_io_r(server, "open (%s)", buffer);
return -1;
}
if(s_pread(fd, prcred, sizeof(struct prcred), 0) !=
sizeof(struct prcred))
{
s_close(fd);
glibtop_warn_io_r(server, "pread (%s)", buffer);
return -1;
}
if(prcred->pr_ngroups >= 0)
{
if(prcred->pr_ngroups <= GLIBTOP_MAX_GROUPS)
toread = prcred->pr_ngroups * sizeof(gid_t);
else
toread = GLIBTOP_MAX_GROUPS * sizeof(gid_t);
if(s_pread(fd, groups, toread,
&(((struct prcred *)0)->pr_groups[0])) != toread)
prcred->pr_ngroups = 0;
}
s_close(fd);
return 0;
}
#endif
int
glibtop_get_proc_status_s(glibtop *server, struct pstatus *pstatus, pid_t pid)
{
int fd;
char buffer[BUFSIZ];
sprintf(buffer, "/proc/%d/status", (int)pid);
if((fd = s_open(buffer, O_RDONLY)) < 0)
{
if(errno != EPERM && errno != EACCES)
glibtop_warn_io_r(server, "open (%s)", buffer);
return -1;
}
if(s_pread(fd, pstatus, sizeof(struct pstatus), 0) !=
sizeof(struct pstatus))
{
s_close(fd);
glibtop_warn_io_r(server, "pread (%s)", buffer);
return -1;
}
s_close(fd);
return 0;
}
#else /* old API */
int
glibtop_get_proc_data_psinfo_s (glibtop *server,
struct prpsinfo *psinfo,
pid_t pid)
{
int fd;
char buffer [BUFSIZ];
sprintf (buffer, "/proc/%d", (int) pid);
fd = s_open (buffer, O_RDONLY);
if (fd < 0) {
if(errno != EPERM && errno != EACCES)
glibtop_warn_io_r (server, "open (%s)", buffer);
return -1;
}
if(ioctl(fd, PIOCPSINFO, psinfo) < 0)
{
s_close (fd);
glibtop_warn_io_r (server, "ioctl(%s, PIOCPSINFO)", buffer);
return -1;
}
s_close (fd);
return 0;
}
int
glibtop_get_proc_data_usage_s (glibtop *server,
struct prusage *prusage,
pid_t pid)
{
int fd;
char buffer [BUFSIZ];
sprintf (buffer, "/proc/%d", (int) pid);
fd = s_open (buffer, O_RDONLY);
if (fd < 0) {
if(errno != EPERM && errno != EACCES)
glibtop_warn_io_r (server, "open (%s)", buffer);
return -1;
}
if(ioctl(fd, PIOCUSAGE, prusage) < 0)
{
s_close (fd);
glibtop_warn_io_r (server, "ioctl(%s, PIOCUSAGE)", buffer);
return -1;
}
s_close (fd);
return 0;
}
int
glibtop_get_proc_credentials_s(glibtop *server,
struct prcred *prcred,
gid_t *groups,
pid_t pid)
{
int fd;
size_t toread;
char buffer[BUFSIZ];
sprintf(buffer, "/proc/%d", (int)pid);
if((fd = s_open(buffer, O_RDONLY)) < 0)
{
if(errno != EPERM && errno != EACCES)
glibtop_warn_io_r(server, "open (%s)", buffer);
return -1;
}
if(ioctl(fd, PIOCCRED, prcred) < 0)
{
s_close(fd);
glibtop_warn_io_r(server, "ioctl(%s, PIOCCRED)", buffer);
return -1;
}
s_close(fd);
return 0;
}
int
glibtop_get_proc_status_s(glibtop *server, struct prstatus *pstatus, pid_t pid)
{
int fd;
char buffer[BUFSIZ];
sprintf(buffer, "/proc/%d", (int)pid);
if((fd = s_open(buffer, O_RDONLY)) < 0)
{
if(errno != EPERM && errno != EACCES)
glibtop_warn_io_r(server, "open (%s)", buffer);
return -1;
}
if(ioctl(fd, PIOCSTATUS, pstatus) < 0)
{
s_close(fd);
glibtop_warn_io_r(server, "ioctl(%s, PIOCSTATUS)", buffer);
return -1;
}
s_close(fd);
return 0;
}
#endif

44
sysdeps/solaris/prockernel.c Normal file
View File

@@ -0,0 +1,44 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/prockernel.h>
static const unsigned long _glibtop_sysdeps_proc_kernel = 0;
/* Init function. */
void
glibtop_init_proc_kernel_s (glibtop *server)
{
server->sysdeps.proc_kernel = _glibtop_sysdeps_proc_kernel;
}
/* Provides detailed information about a process. */
void
glibtop_get_proc_kernel_s (glibtop *server, glibtop_proc_kernel *buf,
pid_t pid)
{
memset (buf, 0, sizeof (glibtop_proc_kernel));
}

251
sysdeps/solaris/proclist.c Normal file
View File

@@ -0,0 +1,251 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/proclist.h>
#include <glibtop/xmalloc.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <ctype.h>
#define GLIBTOP_PROCLIST_FLAGS 3
static const unsigned long _glibtop_sysdeps_proclist =
(1L << GLIBTOP_PROCLIST_TOTAL) + (1L << GLIBTOP_PROCLIST_NUMBER) +
(1L << GLIBTOP_PROCLIST_SIZE);
/* Init function. */
void
glibtop_init_proclist_s (glibtop *server)
{
server->sysdeps.proclist = _glibtop_sysdeps_proclist;
}
#define BLOCK_COUNT 256
#define BLOCK_SIZE (BLOCK_COUNT * sizeof (unsigned))
/* Fetch list of currently running processes.
*
* IMPORTANT NOTE:
* On error, this function MUST return NULL and set buf->flags to zero !
* On success, it returnes a pointer to a list of buf->number elements
* each buf->size big. The total size is stored in buf->total. */
unsigned *
glibtop_get_proclist_s (glibtop *server, glibtop_proclist *buf,
int64_t which, int64_t arg)
{
DIR *proc;
struct dirent *entry;
char buffer [BUFSIZ];
unsigned count, total, pid, mask;
unsigned pids [BLOCK_COUNT], *pids_chain = NULL;
unsigned pids_size = 0, pids_offset = 0, new_size;
struct stat statb;
int len, i, ok;
memset (buf, 0, sizeof (glibtop_proclist));
mask = which & ~GLIBTOP_KERN_PROC_MASK;
which &= GLIBTOP_KERN_PROC_MASK;
/* Check if the user wanted only one process */
if(which == GLIBTOP_KERN_PROC_PID)
{
if(mask)
{
#ifdef HAVE_PROCFS_H
struct psinfo psinfo;
#else
struct prpsinfo psinfo;
#endif
if(glibtop_get_proc_data_psinfo_s(server, &psinfo, pid))
return NULL;
if(mask & GLIBTOP_EXCLUDE_IDLE && !psinfo.pr_pctcpu)
return NULL;
if(mask & GLIBTOP_EXCLUDE_SYSTEM && psinfo.pr_flag & SSYS)
return NULL;
if(mask & GLIBTOP_EXCLUDE_NOTTY && psinfo.pr_ttydev == PRNODEV)
return NULL;
}
else
{
sprintf(buffer, "/proc/%d", arg);
if(s_stat(buffer, &statb) < 0)
return NULL;
}
if(!(pids_chain = glibtop_malloc(sizeof(unsigned))))
return NULL;
*pids_chain = pid;
return pids_chain;
}
proc = opendir ("/proc");
if (!proc) return NULL;
/* read every every entry in /proc */
for (count = total = 0, entry = readdir (proc);
entry; entry = readdir (proc)) {
ok = 1; len = strlen (entry->d_name);
/* does it consist entirely of digits? */
#if 0
/* It does, except for "." and "..". Let's speed up */
for (i = 0; i < len; i++)
if (!isdigit (entry->d_name [i])) ok = 0;
if (!ok) continue;
#else
if(entry->d_name[0] == '.')
continue;
#endif
/* convert it in a number */
#if 0
if (sscanf (entry->d_name, "%u", &pid) != 1) continue;
#else
pid = (unsigned)atol(entry->d_name);
#endif
#ifdef HAVE_PROCFS_H
/* Can we skip it based on the request? We have
RUID and RGID in struct stat. But we can't do it
like this for LP64 process, because stat() will fail.
XXX Unimplemented for now */
if(!mask && which == GLIBTOP_KERN_PROC_RUID)
{
sprintf (buffer, "/proc/%d", pid);
if (s_stat (buffer, &statb)) continue;
if (!S_ISDIR (statb.st_mode)) continue;
if(statb.st_uid != arg) continue;
}
if(mask || which != GLIBTOP_KERN_PROC_ALL)
{
struct psinfo psinfo;
if(glibtop_get_proc_data_psinfo_s(server, &psinfo, pid))
continue;
if(mask)
{
if(mask & GLIBTOP_EXCLUDE_IDLE && !psinfo.pr_pctcpu)
continue;
if(mask & GLIBTOP_EXCLUDE_SYSTEM && psinfo.pr_flag & SSYS)
continue;
if(mask & GLIBTOP_EXCLUDE_NOTTY
&& psinfo.pr_ttydev == PRNODEV)
continue;
}
switch(which)
{
case GLIBTOP_KERN_PROC_PGRP: if(psinfo.pr_pgid != arg)
continue;
break;
case GLIBTOP_KERN_PROC_SESSION: if(psinfo.pr_sid != arg)
continue;
break;
case GLIBTOP_KERN_PROC_TTY: if(psinfo.pr_ttydev != arg)
continue;
break;
case GLIBTOP_KERN_PROC_UID: if(psinfo.pr_euid != arg)
continue;
break;
case GLIBTOP_KERN_PROC_RUID: if(psinfo.pr_uid != arg)
continue;
break;
default: break;
}
}
#endif
/* Fine. Now we first try to store it in pids. If this buffer is
* full, we copy it to the pids_chain. */
if (count >= BLOCK_COUNT) {
/* The following call to glibtop_realloc will be
* equivalent to glibtop_malloc () if `pids_chain' is
* NULL. We just calculate the new size and copy `pids'
* to the beginning of the newly allocated block. */
new_size = pids_size + BLOCK_SIZE;
pids_chain = glibtop_realloc_r
(server, pids_chain, new_size);
memcpy (pids_chain + pids_offset, pids, BLOCK_SIZE);
pids_size = new_size;
pids_offset += BLOCK_COUNT;
count = 0;
}
/* pids is now big enough to hold at least one single pid. */
pids [count++] = pid;
total++;
}
s_closedir (proc);
/* count is only zero if an error occured (one a running Linux system,
* we have at least one single process). */
if (!count) return NULL;
/* The following call to glibtop_realloc will be equivalent to
* glibtop_malloc if pids_chain is NULL. We just calculate the
* new size and copy pids to the beginning of the newly allocated
* block. */
new_size = pids_size + count * sizeof (unsigned);
pids_chain = glibtop_realloc_r (server, pids_chain, new_size);
memcpy (pids_chain + pids_offset, pids, count * sizeof (unsigned));
pids_size = new_size;
pids_offset += BLOCK_COUNT;
/* Since everything is ok now, we can set buf->flags, fill in the
* remaining fields and return the `pids_chain'. */
buf->flags = _glibtop_sysdeps_proclist;
buf->size = sizeof (unsigned);
buf->number = total;
buf->total = total * sizeof (unsigned);
return pids_chain;
}

207
sysdeps/solaris/procmap.c Normal file
View File

@@ -0,0 +1,207 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/error.h>
#include <glibtop/xmalloc.h>
#include <glibtop/procmap.h>
#include <errno.h>
#include <alloca.h>
#include "safeio.h"
static const unsigned long _glibtop_sysdeps_proc_map =
(1L << GLIBTOP_PROC_MAP_NUMBER) + (1L << GLIBTOP_PROC_MAP_TOTAL) +
(1L << GLIBTOP_PROC_MAP_SIZE);
static const unsigned long _glibtop_sysdeps_map_entry =
(1L << GLIBTOP_MAP_ENTRY_START) + (1L << GLIBTOP_MAP_ENTRY_END) +
(1L << GLIBTOP_MAP_ENTRY_OFFSET) + (1L << GLIBTOP_MAP_ENTRY_PERM);
static const unsigned long _glibtop_sysdeps_map_device =
(1L << GLIBTOP_MAP_ENTRY_DEVICE) + (1L << GLIBTOP_MAP_ENTRY_INODE);
/* Init function. */
void
glibtop_init_proc_map_s (glibtop *server)
{
server->sysdeps.proc_map = _glibtop_sysdeps_proc_map;
}
/* Provides detailed information about a process. */
glibtop_map_entry *
glibtop_get_proc_map_s (glibtop *server, glibtop_proc_map *buf, pid_t pid)
{
int fd, i, nmaps, pr_err, heap;
#if GLIBTOP_SOLARIS_RELEASE >= 560
prxmap_t *maps;
struct ps_prochandle *Pr;
#else
prmap_t *maps;
#endif
/* A few defines, to make it shorter down there */
#ifdef HAVE_PROCFS_H
# define OFFSET pr_offset
#else
# define OFFSET pr_off
#endif
glibtop_map_entry *entry;
struct stat inode;
char buffer[BUFSIZ];
memset (buf, 0, sizeof (glibtop_proc_map));
#ifdef HAVE_PROCFS_H
sprintf(buffer, "/proc/%d/xmap", (int)pid);
#else
sprintf(buffer, "/proc/%d", (int)pid);
#endif
if((fd = s_open(buffer, O_RDONLY)) < 0)
{
if(errno != EPERM && errno != EACCES)
glibtop_warn_io_r(server, "open (%s)", buffer);
return NULL;
}
#ifdef HAVE_PROCFS_H
if(fstat(fd, &inode) < 0)
{
if(errno != EOVERFLOW)
glibtop_warn_io_r(server, "fstat (%s)", buffer);
/* else call daemon for 64-bit support */
s_close(fd);
return NULL;
}
maps = alloca(inode.st_size);
nmaps = inode.st_size / sizeof(prxmap_t);
if(s_pread(fd, maps, inode.st_size, 0) != inode.st_size)
{
glibtop_warn_io_r(server, "pread (%s)", buffer);
s_close(fd);
return NULL;
}
#else
if(ioctl(fd, PIOCNMAP, &nmaps) < 0)
{
glibtop_warn_io_r(server, "ioctl(%s, PIOCNMAP)", buffer);
s_close(fd);
return NULL;
}
maps = alloca((nmaps + 1) * sizeof(prmap_t));
if(ioctl(fd, PIOCMAP, maps) < 0)
{
glibtop_warn_io_r(server, "ioctl(%s, PIOCMAP)", buffer);
s_close(fd);
return NULL;
}
#endif
if(!(entry = glibtop_malloc_r(server,
nmaps * sizeof(glibtop_map_entry))))
return NULL;
buf->number = nmaps;
buf->size = sizeof(glibtop_map_entry);
buf->total = nmaps * sizeof(glibtop_map_entry);
memset(entry, 0, nmaps * sizeof(glibtop_map_entry));
#if GLIBTOP_SOLARIS_RELEASE >= 560
if(server->machine.objname && server->machine.pgrab &&
server->machine.pfree)
Pr = (server->machine.pgrab)(pid, 1, &pr_err);
#endif
for(heap = 0,i = 0; i < nmaps; ++i)
{
int len;
entry[i].start = maps[i].pr_vaddr;
entry[i].end = maps[i].pr_vaddr + maps[i].pr_size;
#if GLIBTOP_SOLARIS_RELEASE >= 560
if(maps[i].pr_dev != PRNODEV)
{
entry[i].device = maps[i].pr_dev;
entry[i].inode = maps[i].pr_ino;
entry[i].flags |= _glibtop_sysdeps_map_device;
}
#endif
entry[i].offset = maps[i].OFFSET;
if(maps[i].pr_mflags & MA_READ)
entry[i].perm |= GLIBTOP_MAP_PERM_READ;
if(maps[i].pr_mflags & MA_WRITE)
entry[i].perm |= GLIBTOP_MAP_PERM_WRITE;
if(maps[i].pr_mflags & MA_EXEC)
entry[i].perm |= GLIBTOP_MAP_PERM_EXECUTE;
if(maps[i].pr_mflags & MA_SHARED)
entry[i].perm |= GLIBTOP_MAP_PERM_SHARED;
else
entry[i].perm |= GLIBTOP_MAP_PERM_PRIVATE;
entry[i].flags = _glibtop_sysdeps_map_entry;
#if GLIBTOP_SOLARIS_RELEASE >= 560
if(maps[i].pr_mflags & MA_ANON)
{
if(!heap)
{
++heap;
strcpy(entry[i].filename, "[ heap ]");
}
else
if(i == nmaps - 1)
strcpy(entry[i].filename, "[ stack ]");
else
strcpy(entry[i].filename, "[ anon ]");
entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
}
else
if(Pr)
{
server->machine.objname(Pr, maps[i].pr_vaddr, buffer,
BUFSIZ);
if((len = resolvepath(buffer, entry[i].filename,
GLIBTOP_MAP_FILENAME_LEN)) > 0)
{
entry[i].filename[len] = 0;
entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
}
}
#endif
}
#if GLIBTOP_SOLARIS_RELEASE >= 560
if(Pr)
server->machine.pfree(Pr);
#endif
buf->flags = _glibtop_sysdeps_proc_map;
s_close(fd);
return entry;
}

64
sysdeps/solaris/procmem.c Normal file
View File

@@ -0,0 +1,64 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/procmem.h>
static const unsigned long _glibtop_sysdeps_proc_mem =
(1L << GLIBTOP_PROC_MEM_SIZE) + (1L << GLIBTOP_PROC_MEM_VSIZE) +
(1L << GLIBTOP_PROC_MEM_RESIDENT) + (1L << GLIBTOP_PROC_MEM_RSS);
/* Init function. */
void
glibtop_init_proc_mem_s (glibtop *server)
{
server->sysdeps.proc_mem = _glibtop_sysdeps_proc_mem;
}
/* Provides detailed information about a process. */
void
glibtop_get_proc_mem_s (glibtop *server, glibtop_proc_mem *buf, pid_t pid)
{
#ifdef HAVE_PROCFS_H
struct psinfo psinfo;
#else
struct prpsinfo psinfo;
int pagesize = server->machine.pagesize;
#endif
memset (buf, 0, sizeof (glibtop_proc_mem));
if(glibtop_get_proc_data_psinfo_s(server, &psinfo, pid))
return;
#ifdef HAVE_PROCFS_H
buf->size = buf->vsize = psinfo.pr_size << 10;
buf->resident = buf->rss = psinfo.pr_rssize << 10;
#else
buf->size = buf->vsize = psinfo.pr_size << pagesize << 10;
buf->resident = buf->rss = psinfo.pr_rssize << pagesize << 10;
#endif
buf->flags = _glibtop_sysdeps_proc_mem;
}

44
sysdeps/solaris/procsegment.c Normal file
View File

@@ -0,0 +1,44 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/procsegment.h>
static const unsigned long _glibtop_sysdeps_proc_segment = 0;
/* Init function. */
void
glibtop_init_proc_segment_s (glibtop *server)
{
server->sysdeps.proc_segment = _glibtop_sysdeps_proc_segment;
}
/* Provides detailed information about a process. */
void
glibtop_get_proc_segment_s (glibtop *server, glibtop_proc_segment *buf,
pid_t pid)
{
memset (buf, 0, sizeof (glibtop_proc_segment));
}

74
sysdeps/solaris/procsignal.c Normal file
View File

@@ -0,0 +1,74 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/procsignal.h>
#include <glibtop_private.h>
static const unsigned long _glibtop_sysdeps_proc_signal =
(1L << GLIBTOP_PROC_SIGNAL_SIGNAL) + (1L << GLIBTOP_PROC_SIGNAL_BLOCKED);
/* Init function. */
void
glibtop_init_proc_signal_s (glibtop *server)
{
server->sysdeps.proc_signal = _glibtop_sysdeps_proc_signal;
}
/* Provides detailed information about a process. */
void
glibtop_get_proc_signal_s (glibtop *server, glibtop_proc_signal *buf,
pid_t pid)
{
#ifdef HAVE_PROCFS_H
struct pstatus pstatus;
#else
struct prstatus pstatus;
#endif
int size;
memset (buf, 0, sizeof (glibtop_proc_signal));
if(glibtop_get_proc_status_s(server, &pstatus, pid))
return;
if(sizeof(buf->signal) < sizeof(sigset_t))
size = sizeof(buf->signal);
else
size = sizeof(sigset_t);
memcpy(buf->signal, &pstatus.pr_sigpend, size);
#ifdef HAVE_PROCFS_H
memcpy(buf->blocked, &pstatus.pr_lwp.pr_lwphold, size);
#else
memcpy(buf->blocked, &pstatus.pr_lwppend, size);
#endif
/* Technically, most of this is meaningless on a process level,
but this should be a good enough approximation. */
buf->flags = _glibtop_sysdeps_proc_signal;
}

122
sysdeps/solaris/procstate.c Normal file
View File

@@ -0,0 +1,122 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/procstate.h>
#include <glibtop_private.h>
static const unsigned long _glibtop_sysdeps_proc_state =
#if (LIBGTOP_VERSION_CODE >= 1001002) && defined(HAVE_PROCFS_H)
(1L << GLIBTOP_PROC_STATE_HAS_CPU) + (1L << GLIBTOP_PROC_STATE_PROCESSOR) +
(1L << GLIBTOP_PROC_STATE_LAST_PROCESSOR) +
#endif
#if LIBGTOP_VERSION_CODE >= 1001002
(1L << GLIBTOP_PROC_STATE_RUID) + (1L << GLIBTOP_PROC_STATE_RGID) +
#endif
(1L << GLIBTOP_PROC_STATE_CMD) + (1L << GLIBTOP_PROC_STATE_STATE) +
(1L << GLIBTOP_PROC_STATE_UID) + (1L << GLIBTOP_PROC_STATE_GID);
/* Init function. */
void
glibtop_init_proc_state_s (glibtop *server)
{
server->sysdeps.proc_state = _glibtop_sysdeps_proc_state;
}
/* Provides detailed information about a process. */
void
glibtop_get_proc_state_s (glibtop *server, glibtop_proc_state *buf, pid_t pid)
{
#ifdef HAVE_PROCFS_H
struct psinfo psinfo;
#else
struct prpsinfo psinfo;
#endif
memset (buf, 0, sizeof (glibtop_proc_state));
if (glibtop_get_proc_data_psinfo_s (server, &psinfo, pid))
return;
buf->uid = psinfo.pr_euid;
buf->gid = psinfo.pr_egid;
#if LIBGTOP_VERSION_CODE >= 1001002
buf->ruid = psinfo.pr_uid;
buf->rgid = psinfo.pr_gid;
#endif
#ifdef HAVE_PROCFS_H
switch(psinfo.pr_lwp.pr_state)
#else
switch(psinfo.pr_state)
#endif
{
case SONPROC:
#if (LIBGTOP_VERSION_CODE >= 1001002) && defined(HAVE_PROCFS_H)
buf->has_cpu = 1;
buf->processor = psinfo.pr_lwp.pr_onpro;
#endif
case SRUN:
#if LIBGTOP_VERSION_CODE >= 1001002
buf->state = GLIBTOP_PROCESS_RUNNING;
#else
buf->state = 'R';
#endif
break;
case SZOMB:
#if LIBGTOP_VERSION_CODE >= 1001002
buf->state = GLIBTOP_PROCESS_ZOMBIE;
#else
buf->state = 'Z';
#endif
break;
case SSLEEP:
#if LIBGTOP_VERSION_CODE >= 1001002
buf->state = GLIBTOP_PROCESS_INTERRUPTIBLE;
#else
buf->state = 'S';
#endif
break;
case SSTOP:
#if LIBGTOP_VERSION_CODE >= 1001002
buf->state = GLIBTOP_PROCESS_STOPPED;
#else
buf->state = 'T';
#endif
break;
case SIDL:
#if LIBGTOP_VERSION_CODE >= 1001002
buf->state = GLIBTOP_PROCESS_UNINTERRUPTIBLE;
#else
buf->state = 'D';
#endif
}
#if (LIBGTOP_VERSION_CODE >= 1001002) && defined(HAVE_PROCFS_H)
buf->last_processor = psinfo.pr_lwp.pr_onpro;
#endif
strncpy (buf->cmd, psinfo.pr_fname, 39);
buf->flags = _glibtop_sysdeps_proc_state;
}

69
sysdeps/solaris/proctime.c Normal file
View File

@@ -0,0 +1,69 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/proctime.h>
#include <glibtop_private.h>
static const unsigned long _glibtop_sysdeps_proc_time =
(1L << GLIBTOP_PROC_TIME_START_TIME) + (1L << GLIBTOP_PROC_TIME_RTIME) +
(1L << GLIBTOP_PROC_TIME_UTIME) + (1L << GLIBTOP_PROC_TIME_STIME);
/* Init function. */
void
glibtop_init_proc_time_s (glibtop *server)
{
server->sysdeps.proc_time = _glibtop_sysdeps_proc_time;
}
/* Provides detailed information about a process. */
void
glibtop_get_proc_time_s (glibtop *server, glibtop_proc_time *buf,
pid_t pid)
{
struct prusage prusage;
memset (buf, 0, sizeof (glibtop_proc_time));
/* Don't do it for scheduler, we don't want to frighten our users */
if(pid)
{
if (glibtop_get_proc_data_usage_s (server, &prusage, pid))
return;
buf->start_time = prusage.pr_create.tv_sec;
buf->rtime = prusage.pr_rtime.tv_sec * 1E+6 +
prusage.pr_rtime.tv_nsec / 1E+3;
buf->utime = prusage.pr_utime.tv_sec * 1E+6 +
prusage.pr_utime.tv_nsec / 1E+3;
buf->stime = prusage.pr_stime.tv_sec * 1E+6 +
prusage.pr_stime.tv_nsec / 1E+3;
}
buf->flags = _glibtop_sysdeps_proc_time;
}

127
sysdeps/solaris/procuid.c Normal file
View File

@@ -0,0 +1,127 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/procuid.h>
#include <glibtop_private.h>
static const unsigned long _glibtop_sysdeps_proc_uid_psinfo =
(1L << GLIBTOP_PROC_UID_EUID) + (1L << GLIBTOP_PROC_UID_UID) +
(1L << GLIBTOP_PROC_UID_EGID) + (1L << GLIBTOP_PROC_UID_GID) +
(1L << GLIBTOP_PROC_UID_PID) + (1L << GLIBTOP_PROC_UID_PPID) +
(1L << GLIBTOP_PROC_UID_PGRP) + (1L << GLIBTOP_PROC_UID_SESSION) +
(1L << GLIBTOP_PROC_UID_TTY) + (1L << GLIBTOP_PROC_UID_PRIORITY) +
(1L << GLIBTOP_PROC_UID_NICE);
static const unsigned long _glibtop_sysdeps_proc_uid_prcred =
#if LIBGTOP_VERSION_CODE >= 1001002
#ifdef HAVE_PROCFS_H
(1L << GLIBTOP_PROC_UID_GROUPS) +
#endif
(1L << GLIBTOP_PROC_UID_SUID) + (1L << GLIBTOP_PROC_UID_SGID) +
(1L << GLIBTOP_PROC_UID_NGROUPS);
#else
0;
#endif
/* Init function. */
void
glibtop_init_proc_uid_s (glibtop *server)
{
server->sysdeps.proc_uid = _glibtop_sysdeps_proc_uid_psinfo +
_glibtop_sysdeps_proc_uid_prcred;
}
/* Provides detailed information about a process. */
void
glibtop_get_proc_uid_s (glibtop *server, glibtop_proc_uid *buf, pid_t pid)
{
#if LIBGTOP_VERSION_CODE >= 1001002
struct prcred prcred;
#endif
#ifdef HAVE_PROCFS_H
struct psinfo psinfo;
#if LIBGTOP_VERSION_CODE >= 1001002
gid_t groups[GLIBTOP_MAX_GROUPS];
#endif
#else
struct prpsinfo psinfo;
gid_t groups[1]; /* dummy for consistent function prototype */
#endif
memset (buf, 0, sizeof (glibtop_proc_uid));
if (glibtop_get_proc_data_psinfo_s (server, &psinfo, pid))
return;
buf->euid = psinfo.pr_euid;
buf->uid = psinfo.pr_uid;
buf->egid = psinfo.pr_egid;
buf->gid = psinfo.pr_gid;
buf->pid = psinfo.pr_pid;
buf->ppid = psinfo.pr_ppid;
#ifdef HAVE_PROCFS_H
buf->pgrp = psinfo.pr_pgid;
#else
buf->pgrp = psinfo.pr_pgrp;
#endif
buf->session = psinfo.pr_sid;
buf->tty = psinfo.pr_ttydev;
#ifdef HAVE_PROCFS_H
buf->priority = psinfo.pr_lwp.pr_pri;
buf->nice = psinfo.pr_lwp.pr_nice - NZERO;
#else
buf->priority = psinfo.pr_pri;
buf->nice = psinfo.pr_nice - NZERO;
#endif
buf->flags = _glibtop_sysdeps_proc_uid_psinfo;
#if LIBGTOP_VERSION_CODE >= 1001002
if(glibtop_get_proc_credentials_s(server, &prcred, groups, pid))
return;
buf->suid = prcred.pr_suid;
buf->sgid = prcred.pr_sgid;
buf->ngroups = (prcred.pr_ngroups <= GLIBTOP_MAX_GROUPS) ?
prcred.pr_ngroups : GLIBTOP_MAX_GROUPS;
#ifdef HAVE_PROCFS_H
if(sizeof(int) == sizeof(gid_t))
memcpy(buf->groups, &groups, buf->ngroups * sizeof(gid_t));
else
{
int i;
for(i = 0; i < buf->ngroups; ++i)
buf->groups[i] = groups[i];
}
#endif
#endif
buf->flags += _glibtop_sysdeps_proc_uid_prcred;
}

84
sysdeps/solaris/safeio.c Normal file
View File

@@ -0,0 +1,84 @@
/* Copyright (C) 1999 Drazen Kacar
This file is part of LibGTop 1.0.
Contributed by Drazen Kacar <dave@srce.hr>, May 1999.
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 <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <errno.h>
int
s_open(const char *file, int mode)
{
int fd;
do {
fd = open(file, mode);
} while(fd < 0 && errno == EINTR);
return fd;
}
int
s_stat(const char *path, struct stat *buf)
{
int status;
do {
status = stat(path, buf);
} while(status < 0 && errno == EINTR);
return status;
}
int
s_close(int fd)
{
int status;
do {
status = close(fd);
} while(status < 0 && errno == EINTR);
return status;
}
ssize_t
s_pread(int fd, void *buf, size_t nbytes, off_t offset)
{
ssize_t len;
/* Now, why doesn't the pread(2) man page say anything about pread()
return values? Can it read less bytes than requested? */
do {
len = pread(fd, buf, nbytes, offset);
} while(len < 0 && errno == EINTR);
return len;
}
int s_closedir(DIR *dirp)
{
int status;
do {
status = closedir(dirp);
} while(status < 0 && errno == EINTR);
return status;
}

48
sysdeps/solaris/safeio.h Normal file
View File

@@ -0,0 +1,48 @@
/* Copyright (C) 1999 Drazen Kacar
This file is part of LibGTop 1.0.
Contributed by Drazen Kacar <dave@srce.hr>, May 1999.
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.
*/
#ifndef __GLIBTOP_SAFEIO_H__
#define __GLIBTOP_SAFEIO_H__
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
BEGIN_LIBGTOP_DECLS
int
s_open(const char *, int);
int
s_stat(const char *, struct stat *);
int
s_close(int);
ssize_t
s_pread(int, void *, size_t, off_t);
int
s_closedir(DIR *);
END_LIBGTOP_DECLS
#endif

85
sysdeps/solaris/sem_limits.c Normal file
View File

@@ -0,0 +1,85 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/sem_limits.h>
#include <kvm.h>
#include <sys/sem.h>
static struct nlist nlst[] = { {"seminfo"}, {NULL} };
static const unsigned long _glibtop_sysdeps_sem_limits =
#if GLIBTOP_SOLARIS_RELEASE <= 570
(1L << GLIBTOP_IPC_SEMMAP) +
#endif
(1L << GLIBTOP_IPC_SEMMNI) + (1L << GLIBTOP_IPC_SEMMNS) +
(1L << GLIBTOP_IPC_SEMMNU) + (1L << GLIBTOP_IPC_SEMMSL) +
(1L << GLIBTOP_IPC_SEMOPM) + (1L << GLIBTOP_IPC_SEMUME) +
(1L << GLIBTOP_IPC_SEMUSZ) + (1L << GLIBTOP_IPC_SEMVMX) +
(1L << GLIBTOP_IPC_SEMAEM);
/* Init function. */
void
glibtop_init_sem_limits_p (glibtop *server)
{
kvm_t *kd = server->machine.kd;
if(kd && !kvm_nlist(kd, nlst))
server->sysdeps.sem_limits = _glibtop_sysdeps_sem_limits;
else
server->sysdeps.sem_limits = 0;
}
/* Provides information about sysv sem limits. */
void
glibtop_get_sem_limits_p (glibtop *server, glibtop_sem_limits *buf)
{
kvm_t *kd = server->machine.kd;
struct seminfo sinfo;
memset (buf, 0, sizeof (glibtop_sem_limits));
if(!(server->sysdeps.sem_limits))
return;
if(kvm_read(kd, nlst[0].n_value, (void *)&sinfo,
sizeof(struct seminfo)) != sizeof(struct seminfo))
return;
#if GLIBTOP_SOLARIS_RELEASE <= 570
/* This field don't exist anymore in Solaris 8.
* Thanks to Laszlo PETER <Laszlo.Peter@ireland.sun.com>. */
buf->semmap = sinfo.semmap;
#endif
buf->semmni = sinfo.semmni;
buf->semmns = sinfo.semmns;
buf->semmnu = sinfo.semmnu;
buf->semmsl = sinfo.semmsl;
buf->semopm = sinfo.semopm;
buf->semume = sinfo.semume;
buf->semusz = sinfo.semusz;
buf->semvmx = sinfo.semvmx;
buf->semaem = sinfo.semaem;
buf->flags = _glibtop_sysdeps_sem_limits;
}

68
sysdeps/solaris/shm_limits.c Normal file
View File

@@ -0,0 +1,68 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/shm_limits.h>
#include <kvm.h>
#include <sys/shm.h>
static struct nlist nlst[] = { {"shminfo"}, {NULL} };
static const unsigned long _glibtop_sysdeps_shm_limits =
(1L << GLIBTOP_IPC_SHMMAX) + (1L << GLIBTOP_IPC_SHMMIN) +
(1L << GLIBTOP_IPC_SHMMNI) + (1L << GLIBTOP_IPC_SHMSEG);
/* Init function. */
void
glibtop_init_shm_limits_p (glibtop *server)
{
kvm_t *kd = server->machine.kd;
if(kd && !kvm_nlist(kd, nlst))
server->sysdeps.shm_limits = _glibtop_sysdeps_shm_limits;
else
server->sysdeps.shm_limits = 0;
}
/* Provides information about sysv ipc limits. */
void
glibtop_get_shm_limits_p (glibtop *server, glibtop_shm_limits *buf)
{
kvm_t *kd = server->machine.kd;
struct shminfo sinfo;
memset (buf, 0, sizeof (glibtop_shm_limits));
if(!(server->sysdeps.shm_limits))
return;
if(kvm_read(kd, nlst[0].n_value, (void *)&sinfo,
sizeof(struct shminfo)) != sizeof(struct shminfo))
return;
buf->shmmax = sinfo.shmmax;
buf->shmmin = sinfo.shmmin;
buf->shmmni = sinfo.shmmni;
buf->shmseg = sinfo.shmseg;
buf->flags = _glibtop_sysdeps_shm_limits;
}

74
sysdeps/solaris/siglist.c Normal file
View File

@@ -0,0 +1,74 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/signal.h>
const glibtop_signame glibtop_sys_siglist [] =
{ { 1, "SIGHUP", "Hangup" },
{ 2, "SIGINT", "Interrupt" },
{ 3, "SIGQUIT", "Quit" },
{ 4, "SIGILL", "Illegal Instruction" },
{ 5, "SIGTRAP", "Trace/Breakpoint Trap" },
{ 6, "SIGABRT", "Abort" },
{ 7, "SIGEMT", "Emulation Trap" },
{ 8, "SIGFPE", "Arithmetic Exception" },
{ 9, "SIGKILL", "Killed" },
{ 10, "SIGBUS", "Bus Error" },
{ 11, "SIGSEGV", "Segmentation Fault" },
{ 12, "SIGSYS", "Bad System Call" },
{ 13, "SIGPIPE", "Broken Pipe" },
{ 14, "SIGALRM", "Alarm Clock" },
{ 15, "SIGTERM", "Terminated" },
{ 16, "SIGUSR1", "User Signal 1" },
{ 17, "SIGUSR2", "User Signal 2" },
{ 18, "SIGCHLD", "Child Status Changed" },
{ 19, "SIGPWR", "Power-Fail/Restart" },
{ 20, "SIGWINCH","Window Size Change" },
{ 21, "SIGURG", "Urgent Socket Condition" },
{ 22, "SIGPOLL", "Pollable Event" },
{ 23, "SIGSTOP", "Stoped (signal)" },
{ 24, "SIGTSTP", "Stopped (user)" },
{ 25, "SIGCONT", "Continued" },
{ 26, "SIGTTIN", "Stopped (tty input)" },
{ 27, "SIGTTOU", "Stopped (tty output)" },
{ 28, "SIGVTALRM","Virtual Timer Expired" },
{ 29, "SIGPROF", "Profiling Timer Expired" },
{ 30, "SIGXCPU", "Cpu Limit Exceeded" },
{ 31, "SIGXFSZ", "File Size Limit Exceeded" },
{ 32, "SIGWAITING","No runnable lwp" },
{ 33, "SIGLWP", "Inter-lwp signal" },
{ 34, "SIGFREEZE","Checkpoint Freeze" },
{ 35, "SIGTHAW", "Checkpoint Thaw" },
{ 36, "SIGCANCEL","Thread Cancelation" },
{ 37, "SIGLOST", "Resource Lost" },
{ 38, "SIGRTMIN","First Realtime Signal" },
{ 39, "SIGRTMIN+1", "Second Realtime Signal" },
{ 40, "SIGRTMIN+2", "Third Realtime Signal" },
{ 41, "SIGRTMIN+3", "Fourth Realtime Signal" },
{ 42, "SIGRTMAX-3", "Fourth Last Realtime Signal" },
{ 43, "SIGRTMAX-2", "Third Last Realtime Signal" },
{ 44, "SIGRTMAX-1", "Second Last Realtime Signal" },
{ 45, "SIGRTMAX", "Last Realtime Signal" },
{ 0, NULL, NULL }
};

89
sysdeps/solaris/swap.c Normal file
View File

@@ -0,0 +1,89 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/error.h>
#include <glibtop/swap.h>
#include <assert.h>
#include <sys/sysinfo.h>
#include <glibtop_private.h>
static const unsigned long _glibtop_sysdeps_swap =
(1L << GLIBTOP_SWAP_TOTAL) + (1L << GLIBTOP_SWAP_USED) +
(1L << GLIBTOP_SWAP_FREE);
/* Init function. */
void
glibtop_init_swap_s (glibtop *server)
{
server->sysdeps.swap = _glibtop_sysdeps_swap;
}
/* Provides information about swap usage. */
void
glibtop_get_swap_s (glibtop *server, glibtop_swap *buf)
{
kstat_ctl_t *kc = server->machine.kc;
kstat_t *ksp = server->machine.vminfo_kstat;
u_int64_t swap_resv, swap_alloc, swap_avail, swap_free;
vminfo_t vminfo;
double rate;
kid_t ret;
memset (buf, 0, sizeof (glibtop_swap));
if (!ksp) return;
switch(kstat_chain_update(kc))
{
case -1: assert(0); /* Debugging, shouldn't happen */
case 0: break;
default: glibtop_get_kstats(server);
}
ret = kstat_read (kc, ksp, &vminfo);
if (ret == -1) {
glibtop_warn_io_r (server, "kstat_read (vminfo)");
return;
}
rate = (ksp->ks_snaptime - server->machine.vminfo_snaptime) / 1E+9;
swap_resv = (vminfo.swap_resv - server->machine.vminfo.swap_resv) / rate;
swap_alloc = (vminfo.swap_alloc - server->machine.vminfo.swap_alloc) / rate;
swap_avail = (vminfo.swap_avail - server->machine.vminfo.swap_avail) / rate;
swap_free = (vminfo.swap_free - server->machine.vminfo.swap_free) / rate;
memcpy (&server->machine.vminfo, &vminfo, sizeof (vminfo_t));
server->machine.vminfo_snaptime = ksp->ks_snaptime;
buf->total = swap_resv + swap_avail;
buf->used = swap_alloc;
buf->free = buf->total - buf->used;
buf->flags = _glibtop_sysdeps_swap;
}

58
sysdeps/solaris/uptime.c Normal file
View File

@@ -0,0 +1,58 @@
/* $Id$ */
/* Copyright (C) 1998-99 Martin Baulig
This file is part of LibGTop 1.0.
Contributed by Martin Baulig <martin@home-of-linux.org>, 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 <glibtop.h>
#include <glibtop/uptime.h>
#include <time.h>
static const unsigned long _glibtop_sysdeps_uptime =
#if LIBGTOP_VERSION_CODE >= 1001002
(1L <<GLIBTOP_UPTIME_BOOT_TIME) +
#endif
(1L << GLIBTOP_UPTIME_UPTIME);
/* Init function. */
void
glibtop_init_uptime_s (glibtop *server)
{
server->sysdeps.uptime = _glibtop_sysdeps_uptime;
}
/* Provides uptime and idle time. */
void
glibtop_get_uptime_s (glibtop *server, glibtop_uptime *buf)
{
memset (buf, 0, sizeof (glibtop_uptime));
if(!(server->machine.boot))
return;
#if LIBGTOP_VERSION_CODE >= 1001002
buf->boot_time = server->machine.boot;
#endif
buf->uptime = time(NULL) - server->machine.boot;
buf->flags = _glibtop_sysdeps_uptime;
}