Importing `stub' sysdeps code here.

1999-03-21  Martin Baulig  <martin@home-of-linux.org>

	Added a new sysctl () interface to the Linux Kernel.

	* kernel/sysctl: Imported.

	* libgtop-sysdeps.m4: If `--enable-hacker-mode' is given, check
	for my new sysctl () interface.

.cvsignore

@@ -32,3 +32,8 @@ ABOUT-NLS
 libgtop.spec
 libgtop-0.99.*.tar.gz
 libgtop-0.99.*
+install-sh
+mkinstalldirs
+missing
+INSTALL
+COPYING

ChangeLog

@@ -1,3 +1,42 @@
+1999-03-21  Martin Baulig  <martin@home-of-linux.org>
+
+	Added a new sysctl () interface to the Linux Kernel.
+	
+	* kernel/sysctl: Imported.
+	
+	* libgtop-sysdeps.m4: If `--enable-hacker-mode' is given, check
+	for my new sysctl () interface.
+
+1999-03-20  Martin Baulig  <martin@home-of-linux.org>
+
+	Removed all traces of my old table () Linux kernel hack.
+
+	* kernel: Removed.
+	* sysdeps/kernel: Removed.
+	* libgtop-sysdeps.m4: Don't check for table (); it does not
+	exist any longer.
+
+1999-03-19  Martin Baulig  <martin@home-of-linux.org>
+
+	This is *untested* - please read "sysdeps/freebsd/ChangeLog" !
+
+	* libgtop-sysdeps.m4: Use the `freebsd' sysdeps directory for
+	BSDI as well if the `--enable-hacker-mode' parameter was given.
+
+1999-03-18  Martin Baulig  <martin@home-of-linux.org>
+
+	* LIBGTOP-VERSION: Set version number to 1.0.2 binary age 1,
+	intergace age 1.
+
+1999-03-17  Martin Baulig  <martin@home-of-linux.org>
+
+	Imported first version of my Solaris port.
+
+	* configure.in: Check for `kstat_open' in `-lkstat'.
+
+	* libgtop-sysdeps.m4: Recognize the `solaris' sysdeps directory
+	when the `--enable-hacker-mode' parameter was given.
+
 1999-03-01  Martin Baulig  <martin@home-of-linux.org>
 
 	Released LibGTop 1.0.1.

LIBGTOP-VERSION

@@ -8,10 +8,10 @@
 #
 LIBGTOP_MAJOR_VERSION=1
 LIBGTOP_MINOR_VERSION=0
-LIBGTOP_MICRO_VERSION=1
+LIBGTOP_MICRO_VERSION=2
 
-LIBGTOP_INTERFACE_AGE=0
-LIBGTOP_BINARY_AGE=0
+LIBGTOP_INTERFACE_AGE=1
+LIBGTOP_BINARY_AGE=1
 
 # Increase each time you change the client/server protocol.
 LIBGTOP_SERVER_VERSION=5

acconfig.h

@@ -138,7 +138,7 @@
 
 #undef NEED_LIBGTOP
 
-#undef HAVE_LINUX_TABLE
+#undef HAVE_LINUX_SYSCTL
 #undef HAVE_LIBGTOP_SMP
 
 #undef HAVE_XAUTH

configure.in

@@ -183,6 +183,9 @@ AC_CHECK_HEADERS(string.h strings.h, break)
 AC_REPLACE_FUNCS(strerror)
 AC_CHECK_LIB(kvm, kvm_open)
 
+dnl Solaris 7
+AC_CHECK_LIB(kstat, kstat_open)
+
 dnl For DEC OSF1
 AC_CHECK_LIB(mach, vm_statistics)
 
@@ -399,8 +402,8 @@ sysdeps/stub_suid/Makefile
 sysdeps/sun4/Makefile
 sysdeps/osf1/Makefile
 sysdeps/linux/Makefile
-sysdeps/kernel/Makefile
 sysdeps/freebsd/Makefile
+sysdeps/solaris/Makefile
 src/Makefile
 src/daemon/Makefile
 src/inodedb/Makefile

examples/.cvsignore

@@ -11,4 +11,5 @@ third_linux
 third_static
 second_static
 second_linux
+smp_static sysdeps_static netload_static procmap_static mountlist_static
 smp sysdeps netload procmap mountlist

examples/ChangeLog

@@ -1,3 +1,8 @@
+1999-03-17  Martin Baulig  <martin@home-of-linux.org>
+
+	* first.c, second.c: Fixed a bug that caused a core dump when
+	the sysdeps code does not return all data.
+
 1998-11-22  Martin Baulig  <baulig@taurus.uni-trier.de>
 
 	* netload.c: Call inet_ntoa () to get address and subnet

examples/first.c

@@ -344,7 +344,7 @@ main (int argc, char *argv [])
 	printf ("Proc_Args    PID  %5d (0x%08lx): %lu - '%s'\n", (int) pid,
 		(unsigned long) data.proc_args.flags,
 		(unsigned long) data.proc_args.size,
-		args);
+		args ? args : "");
 
 	glibtop_free (args);
 
@@ -454,7 +454,7 @@ main (int argc, char *argv [])
 	printf ("Proc_Args    PID  %5d (0x%08lx): %lu - '%s'\n", (int) ppid,
 		(unsigned long) data.proc_args.flags,
 		(unsigned long) data.proc_args.size,
-		args);
+		args ? args : "");
 
 	glibtop_free (args);
 
@@ -565,7 +565,7 @@ main (int argc, char *argv [])
 	printf ("Proc_Args    PID  %5d (0x%08lx): %lu - '%s'\n", 1,
 		(unsigned long) data.proc_args.flags,
 		(unsigned long) data.proc_args.size,
-		args);
+		args ? args : "");
 
 	glibtop_free (args);
 

examples/second.c

@@ -150,7 +150,7 @@ output (pid_t pid)
 	printf ("Proc_Args    PID  %5d (0x%08lx): %lu - '%s'\n", (int) pid,
 		(unsigned long) data.proc_args.flags,
 		(unsigned long) data.proc_args.size,
-		args);
+		args ? args : "");
 
 	glibtop_free (args);
 

kernel/ChangeLog

@@ -1,14 +0,0 @@
-1998-07-21  Martin Baulig  <martin@home-of-linux.org>
-
-	* table20: New directory for 2.0.xx kernels.
-
-	* table21: New directory for 2.1.xx kernels.
-
-	* *: Moved into `table20' and `table21'.
-
-1998-06-14  Martin Baulig  <baulig@taurus.uni-trier.de>
-
-	* README: Added README.
-
-	* kernel.patch: Patch for the Linux kernel to add the
-	new system call.

kernel/sysctl/Makefile

@@ -1,5 +1,5 @@
 #
-# Makefile for the linux system information tables.
+# Makefile for the LibGTop linux sysctl interface.
 #
 # Note! Dependencies are done automagically by 'make dep', which also
 # removes any old dependencies. DON'T put your own dependencies here
@@ -7,7 +7,16 @@
 #
 # Note 2! The CFLAGS definition is now in the main makefile...
 
-O_TARGET := table.o
+O_TARGET := kernel.o
+ifeq ($(CONFIG_LIBGTOP),y)
+O_OJBS   := main.o libgtop.o
+else
 O_OBJS   := main.o
+endif
+OX_OBJS  := libgtop_syms.o
+
+ifeq ($(CONFIG_LIBGTOP),m)
+M_OBJS   := libgtop.o
+endif
 
 include $(TOPDIR)/Rules.make

kernel/sysctl/libgtop.c

@@ -0,0 +1,320 @@
+/*
+ * linux/libgtop/module.c
+ * Copyright (C) 1999 Martin Baulig
+ */
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/kernel_stat.h>
+#include <linux/tty.h>
+#include <linux/user.h>
+#include <linux/a.out.h>
+#include <linux/string.h>
+#include <linux/mman.h>
+#include <linux/proc_fs.h>
+#include <linux/ioport.h>
+#include <linux/config.h>
+#include <linux/mm.h>
+#include <linux/pagemap.h>
+#include <linux/swap.h>
+#include <linux/slab.h>
+#include <linux/smp.h>
+#include <linux/signal.h>
+
+#include <asm/uaccess.h>
+#include <asm/pgtable.h>
+#include <asm/io.h>
+
+#include <linux/sysctl.h>
+#include <linux/module.h>
+
+#include <linux/libgtop.h>
+
+EXPORT_NO_SYMBOLS;
+
+static int system_ctl_handler (ctl_table *table, int *name, int nlen,
+			       void *oldval, size_t *oldlenp, void *newval,
+			       size_t newlen, void **context);
+
+static int proc_ctl_handler (ctl_table *table, int *name, int nlen,
+			     void *oldval, size_t *oldlenp, void *newval,
+			     size_t newlen, void **context);
+
+static int libgtop_sysctl_version = 1;
+static int libgtop_update_expensive = 5000;
+
+static struct ctl_table_header *libgtop_sysctl_header = NULL;
+
+static libgtop_stat_t libgtop_stat;
+static unsigned int libgtop_mem_timestamp = 0;
+static libgtop_mem_t libgtop_mem;
+static unsigned int libgtop_swap_timestamp = 0;
+static libgtop_swap_t libgtop_swap;
+static libgtop_proclist_t libgtop_proclist;
+
+static ctl_table libgtop_table[];
+static ctl_table proc_table[];
+
+static ctl_table libgtop_root_table[] = {
+    {CTL_LIBGTOP, "libgtop", NULL, 0, 0555, libgtop_table},
+    {0}
+};
+
+#ifdef MODULE
+static
+#endif
+ctl_table libgtop_table[] = {
+    {LIBGTOP_VERSION, "version", &libgtop_sysctl_version,
+     sizeof (int), 0444, NULL, &proc_dointvec},
+    {LIBGTOP_PROC, NULL, NULL, 0, 0555, proc_table},
+    {LIBGTOP_UPDATE_EXPENSIVE, "update_expensive",
+     &libgtop_update_expensive, sizeof (int), 0664, NULL, &proc_dointvec},
+    {LIBGTOP_STAT, NULL, &libgtop_stat, sizeof (libgtop_stat),
+     0444, NULL, NULL, &system_ctl_handler},
+    {LIBGTOP_MEM, NULL, &libgtop_mem, sizeof (libgtop_mem),
+     0444, NULL, NULL, &system_ctl_handler},
+    {LIBGTOP_SWAP, NULL, &libgtop_swap, sizeof (libgtop_swap),
+     0444, NULL, NULL, &system_ctl_handler},
+    {LIBGTOP_PROCLIST, NULL, &libgtop_proclist, sizeof (libgtop_proclist),
+     0444, NULL, NULL, &system_ctl_handler},
+    {0}
+};
+
+static ctl_table proc_table[] = {
+    {CTL_ANY, NULL, NULL, 0, 04444, NULL, NULL, &proc_ctl_handler},
+    {0}
+};
+
+#ifdef MODULE
+static void
+libgtop_sysctl_register(void)
+{
+    static int initialized = 0;
+
+    if (initialized == 1)
+	return;
+
+    libgtop_sysctl_header = register_sysctl_table(libgtop_root_table, 1);
+    initialized = 1;
+}
+
+static void
+libgtop_sysctl_unregister(void)
+{
+    unregister_sysctl_table(libgtop_sysctl_header);
+}
+
+int init_module(void)
+{
+    libgtop_sysctl_register();
+    return 0;
+}
+
+void cleanup_module(void)
+{
+    libgtop_sysctl_unregister();
+}
+
+#endif /* MODULE */
+
+static int
+libgtop_sysctl (ctl_table *table, int nlen, int *name)
+{
+    extern unsigned long total_forks;
+    int index, tindex, tty, which, arg;
+    libgtop_stat_t *lstat;
+    libgtop_mem_t *mem;
+    libgtop_swap_t *swap;
+    libgtop_proclist_t *proclist;
+    struct task_struct *tsk = NULL;
+    struct sysinfo i;
+
+    switch (table->ctl_name) {
+    case LIBGTOP_STAT:
+	lstat = table->data;
+	lstat->cpu.total = jiffies;
+	lstat->cpu.user  = kstat.cpu_user;
+	lstat->cpu.nice  = kstat.cpu_nice;
+	lstat->cpu.sys   = kstat.cpu_system;
+	lstat->cpu.idle  = jiffies*smp_num_cpus -
+	    (lstat->cpu.user + lstat->cpu.nice + lstat->cpu.sys);
+#ifdef __SMP__
+	for (i = 0; i < smp_num_cpus; i++) {
+	    lstat->xcpu[i].user = kstat.per_cpu_user[cpu_logical_map(i)];
+	    lstat->xcpu[i].nice = kstat.per_cpu_nice[cpu_logical_map(i)];
+	    lstat->xcpu[i].sys = kstat.per_cpu_system[cpu_logical_map(i)];
+	    lstat->xcpu[i].idle = jiffies -
+		(lstat->xcpu[i].user + lstat->xcpu[i].nice +
+		 lstat->xcpu[i].sys);
+	}
+
+	lstat->ncpu = smp_num_cpus;
+#else
+	lstat->ncpu = 0;
+#endif
+
+	lstat->frequency = HZ;
+
+	lstat->loadavg [0] = (double) avenrun [0] / (1 << FSHIFT);
+	lstat->loadavg [1] = (double) avenrun [1] / (1 << FSHIFT);
+	lstat->loadavg [2] = (double) avenrun [2] / (1 << FSHIFT);
+
+	lstat->pgpgin = kstat.pgpgin;
+	lstat->pgpgout = kstat.pgpgout;
+	lstat->pswpin = kstat.pswpin;
+	lstat->pswpout = kstat.pswpout;
+
+	lstat->context_swtch = kstat.context_swtch;
+	lstat->boot_time = xtime.tv_sec - jiffies / HZ;
+	lstat->total_forks = total_forks;
+	break;
+    case LIBGTOP_MEM:
+	if (jiffies - libgtop_mem_timestamp < libgtop_update_expensive)
+	    return 0;
+	libgtop_mem_timestamp = jiffies;
+
+	mem = table->data;
+	si_meminfo (&i);
+
+	mem->totalram = i.totalram;
+	mem->freeram = i.freeram;
+	mem->sharedram = i.sharedram;
+	mem->bufferram = i.bufferram;
+	return 0;
+    case LIBGTOP_SWAP:
+	if (jiffies - libgtop_swap_timestamp < libgtop_update_expensive)
+	    return 0;
+	libgtop_swap_timestamp = jiffies;
+
+	swap = table->data;
+	si_swapinfo (&i);
+
+	swap->totalswap = i.totalswap;
+	swap->freeswap = i.freeswap;
+	return 0;
+    case LIBGTOP_PROCLIST:
+	proclist = table->data;
+
+	if (nlen == 1) {
+	    which = 0;
+	    arg = 0;
+	} else if (nlen == 2) {
+	    which = name [1];
+	    arg = 0;
+	} else if (nlen == 3) {
+	    which = name [1];
+	    arg = name [2];
+	} else {
+	    return -EINVAL;
+	}
+
+	tsk = task [0];
+	read_lock (&tasklist_lock);
+	for (index = tindex = 0; index < nr_tasks;
+	     index++, tsk = tsk->next_task) {
+	    if (tsk->pid == 0) continue;
+	    switch (which & LIBGTOP_PROCLIST_MASK) {
+	    case LIBGTOP_PROCLIST_PID:
+		if (tsk->pid != arg) continue;
+		break;
+	    case LIBGTOP_PROCLIST_PGRP:
+		if (tsk->pgrp != arg) continue;
+		break;
+	    case LIBGTOP_PROCLIST_SESSION:
+		if (tsk->session != arg) continue;
+		break;
+	    case LIBGTOP_PROCLIST_TTY:
+		tty = tsk->tty ?
+		    kdev_t_to_nr (tsk->tty->device) : 0;
+		if (tty != arg) continue;
+		break;
+	    case LIBGTOP_PROCLIST_UID:
+		if (tsk->uid != arg) continue;
+		break;
+	    case LIBGTOP_PROCLIST_RUID:
+		if (tsk->euid != arg) continue;
+		break;
+	    }
+
+	    if ((which & LIBGTOP_EXCLUDE_IDLE) && (tsk->state != 0))
+		continue;
+
+	    if ((which & LIBGTOP_EXCLUDE_NOTTY) && (tsk->tty == NULL))
+		continue;
+			
+	    proclist->pids [tindex++] = tsk->pid;
+	}
+
+	proclist->nr_running = nr_running;
+	proclist->last_pid = last_pid;
+	proclist->nr_tasks = tindex;
+	read_unlock(&tasklist_lock);
+	return 0;
+    default:
+	return -EINVAL;
+    }
+
+    return 0;
+}
+
+static int
+system_ctl_handler (ctl_table *table, int *name, int nlen,
+		    void *oldval, size_t *oldlenp, void *newval,
+		    size_t newlen, void **context)
+{
+    int ret, len, len_name;
+
+    if (!table->data || !table->maxlen)
+	return -ENOTDIR;
+
+    if (!oldval || !oldlenp || get_user(len, oldlenp))
+	return -EFAULT;
+
+    if (!name || !nlen || get_user(len_name, name))
+	return -EFAULT;
+
+    if (len != table->maxlen)
+	return -EFAULT;
+
+    ret = libgtop_sysctl (table, nlen, name);
+    if (ret) return ret;
+
+    if(copy_to_user(oldval, table->data, len))
+	return -EFAULT;
+
+    return 1;
+}
+
+static int
+proc_ctl_handler (ctl_table *table, int *name, int nlen,
+		  void *oldval, size_t *oldlenp, void *newval,
+		  size_t newlen, void **context)
+{
+    int ret, len;
+
+#if 0
+    printk ("proc_ctl_handler: %p - %p - %d - (%p,%p) - (%p,%d) - %p\n",
+	    table, name, nlen, oldval, oldlenp, newval, newlen, context);
+#endif
+
+    if (!name || !nlen || get_user(len, name))
+	return -EFAULT;
+
+#if 0
+    printk ("FUNCTION: %d - %d - %p\n", table->ctl_name,
+	    *name, table->de);
+#endif
+
+    if (!table->data || !table->maxlen)
+	return -ENOTDIR;
+
+    if (!oldval || !oldlenp || get_user(len, oldlenp))
+	return -EFAULT;
+
+    if (len != table->maxlen)
+	return -EFAULT;
+
+    return -ENOSYS;
+}

kernel/sysctl/libgtop.h

@@ -0,0 +1,82 @@
+#ifndef _LINUX_LIBGTOP_H
+#define _LINUX_LIBGTOP_H 1
+
+#include <linux/tasks.h>
+
+enum {
+    LIBGTOP_VERSION = 1,
+    LIBGTOP_PROC,
+    LIBGTOP_UPDATE_EXPENSIVE,
+    LIBGTOP_STAT,
+    LIBGTOP_MEM,
+    LIBGTOP_SWAP,
+    LIBGTOP_PROCLIST
+};
+
+enum {
+    LIBGTOP_PROCLIST_ALL = 0,
+    LIBGTOP_PROCLIST_PID,
+    LIBGTOP_PROCLIST_PGRP,
+    LIBGTOP_PROCLIST_SESSION,
+    LIBGTOP_PROCLIST_TTY,
+    LIBGTOP_PROCLIST_UID,
+    LIBGTOP_PROCLIST_RUID
+};
+
+#define LIBGTOP_PROCLIST_MASK		15	
+
+#define LIBGTOP_EXCLUDE_IDLE		0x1000
+#define LIBGTOP_EXCLUDE_SYSTEM		0x2000
+#define LIBGTOP_EXCLUDE_NOTTY		0x4000
+
+typedef struct libgtop_stat libgtop_stat_t;
+
+typedef struct libgtop_cpu libgtop_cpu_t;
+typedef struct libgtop_mem libgtop_mem_t;
+typedef struct libgtop_swap libgtop_swap_t;
+typedef struct libgtop_proclist libgtop_proclist_t;
+
+struct libgtop_cpu
+{
+    unsigned long total;		/* Total CPU Time		*/
+    unsigned long user;			/* CPU Time in User Mode	*/
+    unsigned long nice;			/* CPU Time in User Mode (nice)	*/
+    unsigned long sys;			/* CPU Time in System Mode	*/
+    unsigned long idle;			/* CPU Time in the Idle Task	*/
+};
+
+struct libgtop_mem
+{
+    unsigned long totalram;		/* Total usable main memory size */
+    unsigned long freeram;		/* Available memory size */
+    unsigned long sharedram;		/* Amount of shared memory */
+    unsigned long bufferram;		/* Memory used by buffers */
+};
+
+struct libgtop_swap
+{
+    unsigned long totalswap;		/* Total swap space size */
+    unsigned long freeswap;		/* swap space still available */
+};
+
+struct libgtop_proclist
+{
+    int nr_running, nr_tasks, last_pid;
+    unsigned pids [NR_TASKS];
+};
+
+struct libgtop_stat
+{
+    int ncpu;				/* Number of CPUs		*/
+    unsigned long frequency;		/* Tick frequency (HZ)		*/
+    libgtop_cpu_t cpu;			/* CPU statistics		*/
+    libgtop_cpu_t xcpu [NR_CPUS];	/* SMP per-CPU statistics	*/
+    double loadavg [3];			/* Load average			*/
+    unsigned long total_forks;		/* Total # of forks		*/
+    unsigned int context_swtch;		/* Total # of context switches	*/
+    unsigned long boot_time;		/* Boot time (seconds s. epoch)	*/
+    unsigned int pgpgin, pgpgout;	/* # of pages paged in/out	*/
+    unsigned int pswpin, pswpout;	/* # of swap pgs brought in/out	*/
+};
+
+#endif

kernel/sysctl/libgtop_syms.c

@@ -0,0 +1,24 @@
+/*
+ * linux/libgtop/libgtop_syms.c
+ * Copyright (C) 1999 Martin Baulig
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+
+#include <linux/sched.h>
+
+#include <linux/mm.h>
+#include <linux/pagemap.h>
+#include <linux/swap.h>
+
+extern unsigned long total_forks;
+
+EXPORT_SYMBOL(task);
+EXPORT_SYMBOL(avenrun);
+EXPORT_SYMBOL(nr_running);
+EXPORT_SYMBOL(nr_tasks);
+EXPORT_SYMBOL(last_pid);
+EXPORT_SYMBOL(total_forks);
+EXPORT_SYMBOL(si_swapinfo);
+

kernel/sysctl/main.c

@@ -0,0 +1,4 @@
+/*
+ * linux/libgtop/main.c
+ * Copyright (C) 1999 Martin Baulig
+ */

kernel/sysctl/patch-2.2.1

@@ -0,0 +1,81 @@
+diff -ru linux-2.2.1/Makefile hacker/Makefile
+--- linux-2.2.1/Makefile	Sun Jan 31 22:45:42 1999
++++ hacker/Makefile	Sun Mar 21 16:10:41 1999
+@@ -109,6 +109,7 @@
+ DRIVERS		=drivers/block/block.a \
+ 		 drivers/char/char.a \
+ 	         drivers/misc/misc.a
++EXTRAS		=
+ LIBS		=$(TOPDIR)/lib/lib.a
+ SUBDIRS		=kernel drivers mm fs net ipc lib
+ 
+@@ -186,6 +187,11 @@
+ DRIVERS := $(DRIVERS) drivers/net/irda/irda_drivers.a
+ endif
+ 
++ifdef CONFIG_LIBGTOP
++SUBDIRS := $(SUBDIRS) libgtop
++EXTRAS  := $(EXTRAS) libgtop/kernel.o
++endif
++
+ include arch/$(ARCH)/Makefile
+ 
+ .S.s:
+@@ -206,6 +212,7 @@
+ 		$(FILESYSTEMS) \
+ 		$(NETWORKS) \
+ 		$(DRIVERS) \
++		$(EXTRAS) \
+ 		$(LIBS) \
+ 		--end-group \
+ 		-o vmlinux
+diff -ru linux-2.2.1/arch/i386/config.in hacker/arch/i386/config.in
+--- linux-2.2.1/arch/i386/config.in	Sun Jan 31 22:25:25 1999
++++ hacker/arch/i386/config.in	Sat Mar 20 18:26:18 1999
+@@ -84,6 +84,9 @@
+ bool 'System V IPC' CONFIG_SYSVIPC
+ bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
+ bool 'Sysctl support' CONFIG_SYSCTL
++if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
++  tristate 'LibGTop support' CONFIG_LIBGTOP
++fi
+ tristate 'Kernel support for a.out binaries' CONFIG_BINFMT_AOUT
+ tristate 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF
+ tristate 'Kernel support for MISC binaries' CONFIG_BINFMT_MISC
+diff -ru linux-2.2.1/include/linux/sysctl.h hacker/include/linux/sysctl.h
+--- linux-2.2.1/include/linux/sysctl.h	Sun Jan 31 22:24:14 1999
++++ hacker/include/linux/sysctl.h	Sat Mar 20 19:12:54 1999
+@@ -56,7 +56,8 @@
+ 	CTL_PROC=4,		/* Process info */
+ 	CTL_FS=5,		/* Filesystems */
+ 	CTL_DEBUG=6,		/* Debugging */
+-	CTL_DEV=7		/* Devices */
++	CTL_DEV=7,		/* Devices */
++	CTL_LIBGTOP=408		/* LibGTop */
+ };
+ 
+ 
+diff -ru linux-2.2.1/kernel/sysctl.c hacker/kernel/sysctl.c
+--- linux-2.2.1/kernel/sysctl.c	Sun Jan 31 22:24:43 1999
++++ hacker/kernel/sysctl.c	Sat Mar 20 19:24:34 1999
+@@ -82,7 +82,9 @@
+ static ctl_table fs_table[];
+ static ctl_table debug_table[];
+ static ctl_table dev_table[];
+-
++#ifdef CONFIG_LIBGTOP
++extern ctl_table libgtop_table[];
++#endif
+ 
+ /* /proc declarations: */
+ 
+@@ -148,6 +150,9 @@
+ 	{CTL_FS, "fs", NULL, 0, 0555, fs_table},
+ 	{CTL_DEBUG, "debug", NULL, 0, 0555, debug_table},
+         {CTL_DEV, "dev", NULL, 0, 0555, dev_table},
++#ifdef CONFIG_LIBGTOP
++	{CTL_LIBGTOP, "libgtop", NULL, 0, 0555, libgtop_table},
++#endif
+ 	{0}
+ };
+ 

kernel/table.h

@@ -1,188 +0,0 @@
-#ifndef _LINUX_TABLE_H
-#define _LINUX_TABLE_H
-
-#ifdef _KERNEL
-#include <linux/types.h>
-#else
-#define NR_TASKS		512
-#endif
-
-#define TABLE_KERN_PROC_ALL		0	/* all processes */
-#define TABLE_KERN_PROC_PID		1
-#define TABLE_KERN_PROC_PGRP		2
-#define TABLE_KERN_PROC_SESSION		3
-#define TABLE_KERN_PROC_TTY		4
-#define TABLE_KERN_PROC_UID		5
-#define TABLE_KERN_PROC_RUID		6
-
-#define TABLE_KERN_PROC_MASK		15	
-
-#define TABLE_EXCLUDE_IDLE		0x1000
-#define TABLE_EXCLUDE_SYSTEM		0x2000
-#define TABLE_EXCLUDE_NOTTY		0x4000
-
-#define TABLE_VERSION		0
-#define TABLE_CPU		1
-#define TABLE_MEM		2
-#define TABLE_SWAP		3
-#define TABLE_LOADAVG		4
-#define TABLE_UPTIME		5
-#define TABLE_PROCLIST		6
-#define TABLE_PROC_UID		7
-#define TABLE_PROC_MEM		8
-#define TABLE_PROC_SEGMENT	9
-#define TABLE_PROC_TIME		10
-#define TABLE_PROC_STATE	11
-#define TABLE_PROC_SIGNAL	12
-#define TABLE_PROC_KERNEL	13
-
-/* CPU Usage (in jiffies = 1/100th seconds) */
-
-struct table_cpu
-{
-	unsigned long total;		/* Total CPU Time		*/
-	unsigned long user;		/* CPU Time in User Mode	*/
-	unsigned long nice;		/* CPU Time in User Mode (nice)	*/
-	unsigned long sys;		/* CPU Time in System Mode	*/
-	unsigned long idle;		/* CPU Time in the Idle Task	*/
-	unsigned long frequency;	/* Tick frequency		*/
-};
-
-/* Memory Usage (in bytes) */
-
-struct table_mem
-{
-	unsigned long total;		/* Total physical memory	*/
-	unsigned long used;		/* Used memory size		*/
-	unsigned long free;		/* Free memory size		*/
-	unsigned long shared;		/* Shared memory size		*/
-	unsigned long buffer;		/* Size of buffers		*/
-	unsigned long cached;		/* Size of cached memory       	*/
-};
-
-/* Swap Space (in bytes) */
-
-struct table_swap
-{
-	unsigned long total;		/* Total swap space		*/
-	unsigned long used;		/* Used swap space		*/
-	unsigned long free;		/* Free swap space		*/
-	unsigned long pagein;		/* Total # of pages swapped in	*/
-	unsigned long pageout;		/* Total # of pages swapped out	*/
-};
-
-/* Load average */
-
-struct table_loadavg
-{
-	double loadavg [3];
-	unsigned nr_running;
-	unsigned nr_tasks;
-	unsigned last_pid;
-};
-
-/* Uptime */
-
-struct table_uptime
-{
-	unsigned long uptime;
-	unsigned long idle;
-};
-
-/* Process list. */
-
-struct proclist_args
-{
-	int which, arg;
-};
-
-struct table_proclist
-{
-	int nr_running, nr_tasks, last_pid;
-	unsigned pids [NR_TASKS];
-};
-
-/* Information about processes. */
-
-struct table_proc_state
-{
-	long state;
-	unsigned long flags;
-	char comm[16];
-	int uid, gid;
-};
-
-struct table_proc_uid
-{
-	int uid, euid, suid, fsuid;
-	int gid, egid, sgid, fsgid;
-	int pid, pgrp, ppid;
-	int session;
-	unsigned int tty;
-	int tpgid;
-	long priority;
-	long counter;
-	long def_priority;
-};
-
-struct table_proc_mem
-{
-	unsigned long context;
-	unsigned long start_code, end_code, start_data, end_data;
-	unsigned long start_brk, brk, start_stack, start_mmap;
-	unsigned long arg_start, arg_end, env_start, env_end;
-	unsigned long rss, rlim, total_vm, locked_vm;
-};
-
-struct table_proc_segment
-{
-	unsigned long vsize;
-	unsigned long size, resident, shared;
-	unsigned long trs, lrs, drs, srs, dt;
-};
-
-struct table_proc_time
-{
-	long utime, stime, cutime, cstime, start_time;
-	unsigned long timeout, policy, rt_priority;
-	unsigned long it_real_value, it_prof_value, it_virt_value;
-	unsigned long it_real_incr, it_prof_incr, it_virt_incr;
-};
-
-struct table_proc_signal
-{
-	unsigned long long signal,
-		blocked,	/* bitmap of masked signals */
-		ignored,	/* mask of ignored signals */
-		caught;		/* mask of caught signals */
-};
-
-struct table_proc_kernel
-{
-	unsigned long keip, kesp, wchan;
-	unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
-	unsigned long nswap, cnswap;
-};
-
-/* Union */
-
-union table
-{
-	struct table_cpu cpu;
-	struct table_mem mem;
-	struct table_swap swap;
-	struct table_loadavg loadavg;
-	struct table_uptime uptime;
-	struct table_proclist proclist;
-	struct table_proc_uid proc_uid;
-	struct table_proc_mem proc_mem;
-	struct table_proc_segment proc_segment;
-	struct table_proc_time proc_time;
-	struct table_proc_state proc_state;	
-	struct table_proc_signal proc_signal;
-	struct table_proc_kernel proc_kernel;
-};
-
-#endif /* _LINUX_IPC_H */
-
-

kernel/table20/README

@@ -1,21 +0,0 @@
-This is a new system call `table ()' for the Linux table. It is faster
-than reading from /proc and can be used to fetch all information required
-for libgtop until whe have some other function (extended sysctl, ...) in
-standard kernels.
-
-I didn't want to change sysctl or some other function myself cause this may
-cause other applications relying upon those function to fail. This is
-something for the ``real'' kernel gurus ...
-
-To use this new system call for libgtop, do the following:
-
-* Copy this directory to /usr/src/linux/table
-* Make /usr/src/linux/include/linux/table.h symlink to /usr/src/linux/table/table.h
-* Apply the patch `kernel.patch' to the kernel, compile, install and reboot
-* Recompile libgtop (remove `config.cache' and run the `autogen.sh' again).
-
-If you want to change and/or add something - feel free to do so !
-
-Have fun,
-
-Martin

kernel/table20/entry-i386.S

@@ -1,706 +0,0 @@
-/*
- *  linux/arch/i386/entry.S
- *
- *  Copyright (C) 1991, 1992  Linus Torvalds
- */
-
-/*
- * entry.S contains the system-call and fault low-level handling routines.
- * This also contains the timer-interrupt handler, as well as all interrupts
- * and faults that can result in a task-switch.
- *
- * NOTE: This code handles signal-recognition, which happens every time
- * after a timer-interrupt and after each system call.
- *
- * I changed all the .align's to 4 (16 byte alignment), as that's faster
- * on a 486.
- *
- * Stack layout in 'ret_from_system_call':
- * 	ptrace needs to have all regs on the stack.
- *	if the order here is changed, it needs to be 
- *	updated in fork.c:copy_process, signal.c:do_signal,
- *	ptrace.c and ptrace.h
- *
- *	 0(%esp) - %ebx
- *	 4(%esp) - %ecx
- *	 8(%esp) - %edx
- *       C(%esp) - %esi
- *	10(%esp) - %edi
- *	14(%esp) - %ebp
- *	18(%esp) - %eax
- *	1C(%esp) - %ds
- *	20(%esp) - %es
- *      24(%esp) - %fs
- *	28(%esp) - %gs
- *	2C(%esp) - orig_eax
- *	30(%esp) - %eip
- *	34(%esp) - %cs
- *	38(%esp) - %eflags
- *	3C(%esp) - %oldesp
- *	40(%esp) - %oldss
- */
-
-#include <linux/sys.h>
-#include <linux/linkage.h>
-#include <asm/segment.h>
-#define ASSEMBLY
-#include <asm/smp.h>
-
-EBX		= 0x00
-ECX		= 0x04
-EDX		= 0x08
-ESI		= 0x0C
-EDI		= 0x10
-EBP		= 0x14
-EAX		= 0x18
-DS		= 0x1C
-ES		= 0x20
-FS		= 0x24
-GS		= 0x28
-ORIG_EAX	= 0x2C
-EIP		= 0x30
-CS		= 0x34
-EFLAGS		= 0x38
-OLDESP		= 0x3C
-OLDSS		= 0x40
-
-CF_MASK		= 0x00000001
-IF_MASK		= 0x00000200
-NT_MASK		= 0x00004000
-VM_MASK		= 0x00020000
-
-/*
- * these are offsets into the task-struct.
- */
-state		=  0
-counter		=  4
-priority	=  8
-signal		= 12
-blocked		= 16
-flags		= 20
-dbgreg6		= 52
-dbgreg7		= 56
-exec_domain	= 60
-
-ENOSYS = 38
-
-#define SAVE_ALL \
-	cld; \
-	push %gs; \
-	push %fs; \
-	push %es; \
-	push %ds; \
-	pushl %eax; \
-	pushl %ebp; \
-	pushl %edi; \
-	pushl %esi; \
-	pushl %edx; \
-	pushl %ecx; \
-	pushl %ebx; \
-	movl $(KERNEL_DS),%edx; \
-	mov %dx,%ds; \
-	mov %dx,%es; \
-	movl $(USER_DS),%edx; \
-	mov %dx,%fs;
-
-#ifdef	__SMP__
-
-#define GET_PROCESSOR_ID \
-	movl SYMBOL_NAME(apic_reg), %edx; \
-	movl 32(%edx), %eax;\
-	movl %eax,SYMBOL_NAME(apic_retval); \
-	shrl $24,%eax; \
-	andb $0x0F,%al;
-
-/*
- *	Get the processor ID multiplied by 4
- */
-
-#define GET_PROCESSOR_OFFSET(x) \
-	movl SYMBOL_NAME(apic_reg), x ; \
-	movl 32( x ), x ; \
-	shrl $22, x ; \
-	andl $0x3C, x ;
-
-/* macro LEAVE_KERNEL decrements kernel_counter and resets kernel_flag and
-   saves processor variables if zero */
-#define	LEAVE_KERNEL \
-	pushfl; \
-	cli; \
-	GET_PROCESSOR_ID \
-	btrl $ SMP_FROM_SYSCALL,SYMBOL_NAME(smp_proc_in_lock)(,%eax,4); \
-	decl SYMBOL_NAME(syscall_count); \
-	decl SYMBOL_NAME(kernel_counter); \
-	jnz 1f;	\
-	movb SYMBOL_NAME(saved_active_kernel_processor), %al; \
-	movb %al, SYMBOL_NAME(active_kernel_processor); \
-	cmpb $(NO_PROC_ID), %al; \
-	jnz 1f; \
-	lock; \
-	btrl $0, SYMBOL_NAME(kernel_flag); \
-1:	popfl;
-
-/* macro ENTER_KERNEL waits for entering the kernel, increments
-   kernel_counter, and reloads the processor variables if necessary
-   uses : %eax, %edx (pushed and popped) 
-
-   Note: We go to great pains to minimise the number of locked operations.
-   We want to spin without locking, and lock when we attempt an update.
-   The pentium has a MESI cache so the spin without lock will exit when
-   another CPU write invalidates our cache, and the lock is avoided when
-   possible so we don't play ping-pong games with the cache line.
-
-*/
-
-#ifndef __SMP_PROF__
-
-#define SMP_PROF_A
-#define SMP_PROF_B 
-
-#else
-
-#define SMP_PROF_A movl $0,SYMBOL_NAME(smp_spins_syscall_cur)(,%eax,4);
-#define SMP_PROF_B incl SYMBOL_NAME(smp_spins_syscall)(,%eax,4); \
-        incl SYMBOL_NAME(smp_spins_syscall_cur)(,%eax,4);
-#endif
-
-#define	ENTER_KERNEL \
-	pushl %eax; \
-	pushl %ebx; \
-	pushl %ecx; \
-	pushl %edx; \
-	pushfl; \
-	cli; \
-	movl $6000, %ebx; \
-	movl SYMBOL_NAME(smp_loops_per_tick), %ecx; \
-	GET_PROCESSOR_ID \
-	btsl $ SMP_FROM_SYSCALL,SYMBOL_NAME(smp_proc_in_lock)(,%eax,4); \
-	SMP_PROF_A \
-1:	lock; \
-	btsl $0, SYMBOL_NAME(kernel_flag); \
-	jnc 3f; \
-	cmpb SYMBOL_NAME(active_kernel_processor), %al; \
-	je 4f; \
-2:	SMP_PROF_B \
-	btl %eax, SYMBOL_NAME(smp_invalidate_needed); \
-	jnc 5f; \
-	lock; \
-	btrl %eax, SYMBOL_NAME(smp_invalidate_needed); \
-	jnc 5f; \
-	movl %cr3,%edx; \
-	movl %edx,%cr3; \
-5:	sti; \
-	decl %ecx; \
-	cli; \
-	jne 7f; \
-	decl %ebx; \
-	jne 6f; \
-	call SYMBOL_NAME(non_irq_deadlock_detected); \
-6:	movl SYMBOL_NAME(smp_loops_per_tick), %ecx; \
-	cmpb SYMBOL_NAME(boot_cpu_id), %al; \
-	jne 7f; \
-	incl SYMBOL_NAME(jiffies);  \
-7:	btl $0, SYMBOL_NAME(kernel_flag); \
-	jc 2b; \
-	jmp 1b; \
-3:	movb %al, SYMBOL_NAME(active_kernel_processor); \
-4:	incl SYMBOL_NAME(kernel_counter); \
-	incl SYMBOL_NAME(syscall_count); \
-	popfl; \
-	popl %edx; \
-	popl %ecx; \
-	popl %ebx; \
-	popl %eax;
-
-
-#define RESTORE_ALL \
-	cmpw $(KERNEL_CS),CS(%esp); \
-	je 1f;   \
-	GET_PROCESSOR_OFFSET(%edx) \
-	movl SYMBOL_NAME(current_set)(,%edx), %eax ; ; \
-	movl dbgreg7(%eax),%ebx; \
-	movl %ebx,%db7;	\
-1:	LEAVE_KERNEL \
-	popl %ebx; \
-	popl %ecx; \
-	popl %edx; \
-	popl %esi; \
-	popl %edi; \
-	popl %ebp; \
-	popl %eax; \
-	pop %ds; \
-	pop %es; \
-	pop %fs; \
-	pop %gs; \
-	addl $4,%esp; \
-	iret
-
-#else
-
-#define RESTORE_ALL \
-	cmpw $(KERNEL_CS),CS(%esp); \
-	je 1f;   \
-	movl SYMBOL_NAME(current_set),%eax; \
-	movl dbgreg7(%eax),%ebx; \
-	movl %ebx,%db7;	\
-1:	\
-	popl %ebx; \
-	popl %ecx; \
-	popl %edx; \
-	popl %esi; \
-	popl %edi; \
-	popl %ebp; \
-	popl %eax; \
-	pop %ds; \
-	pop %es; \
-	pop %fs; \
-	pop %gs; \
-	addl $4,%esp; \
-	iret
-#endif
-
-ENTRY(lcall7)
-	pushfl			# We get a different stack layout with call gates,
-	pushl %eax		# which has to be cleaned up later..
-	SAVE_ALL
-#ifdef __SMP__
-	ENTER_KERNEL
-#endif
-	movl EIP(%esp),%eax	# due to call gates, this is eflags, not eip..
-	movl CS(%esp),%edx	# this is eip..
-	movl EFLAGS(%esp),%ecx	# and this is cs..
-	movl %eax,EFLAGS(%esp)	#
-	movl %edx,EIP(%esp)	# Now we move them to their "normal" places
-	movl %ecx,CS(%esp)	#
-	movl %esp,%eax
-#ifdef __SMP__
-	GET_PROCESSOR_OFFSET(%edx)	# Processor offset into edx
-	movl SYMBOL_NAME(current_set)(,%edx),%edx
-#else
-	movl SYMBOL_NAME(current_set),%edx
-#endif
-	pushl %eax
-	movl exec_domain(%edx),%edx	# Get the execution domain
-	movl 4(%edx),%edx	# Get the lcall7 handler for the domain
-	call *%edx
-	popl %eax
-	jmp ret_from_sys_call
-
-	ALIGN
-handle_bottom_half:
-	incl SYMBOL_NAME(intr_count)
-	call SYMBOL_NAME(do_bottom_half)
-	decl SYMBOL_NAME(intr_count)
-	jmp 9f
-	ALIGN
-reschedule:
-	pushl $ret_from_sys_call
-	jmp SYMBOL_NAME(schedule)    # test
-
-ENTRY(system_call)
-	pushl %eax			# save orig_eax
-	SAVE_ALL
-#ifdef __SMP__
-	ENTER_KERNEL
-#endif
-	movl $-ENOSYS,EAX(%esp)
-	cmpl $(NR_syscalls),%eax
-	jae ret_from_sys_call
-	movl SYMBOL_NAME(sys_call_table)(,%eax,4),%eax
-	testl %eax,%eax
-	je ret_from_sys_call
-#ifdef __SMP__
-	GET_PROCESSOR_OFFSET(%edx)
-	movl SYMBOL_NAME(current_set)(,%edx),%ebx
-#else
-	movl SYMBOL_NAME(current_set),%ebx
-#endif
-	andl $~CF_MASK,EFLAGS(%esp)	# clear carry - assume no errors
-	movl %db6,%edx
-	movl %edx,dbgreg6(%ebx)  # save current hardware debugging status
-	testb $0x20,flags(%ebx)		# PF_TRACESYS
-	jne 1f
-	call *%eax
-	movl %eax,EAX(%esp)		# save the return value
-	jmp ret_from_sys_call
-	ALIGN
-1:	call SYMBOL_NAME(syscall_trace)
-	movl ORIG_EAX(%esp),%eax
-	call SYMBOL_NAME(sys_call_table)(,%eax,4)
-	movl %eax,EAX(%esp)		# save the return value
-#ifdef __SMP__
-	GET_PROCESSOR_OFFSET(%eax)
-	movl SYMBOL_NAME(current_set)(,%eax),%eax
-#else
-	movl SYMBOL_NAME(current_set),%eax
-#endif
-	call SYMBOL_NAME(syscall_trace)
-
-	ALIGN
-	.globl ret_from_sys_call
-ret_from_sys_call:
-	cmpl $0,SYMBOL_NAME(intr_count)
-	jne 2f
-9:	movl SYMBOL_NAME(bh_mask),%eax
-	andl SYMBOL_NAME(bh_active),%eax
-	jne handle_bottom_half
-#ifdef __SMP__
-	cmpb $(NO_PROC_ID), SYMBOL_NAME(saved_active_kernel_processor)
-	jne 2f
-#endif
-	movl EFLAGS(%esp),%eax		# check VM86 flag: CS/SS are
-	testl $(VM_MASK),%eax		# different then
-	jne 1f
-	cmpw $(KERNEL_CS),CS(%esp)	# was old code segment supervisor ?
-	je 2f
-1:	sti
-	orl $(IF_MASK),%eax		# these just try to make sure
-	andl $~NT_MASK,%eax		# the program doesn't do anything
-	movl %eax,EFLAGS(%esp)		# stupid
-	cmpl $0,SYMBOL_NAME(need_resched)
-	jne reschedule
-#ifdef __SMP__
-	GET_PROCESSOR_OFFSET(%eax)
-	movl SYMBOL_NAME(current_set)(,%eax), %eax
-#else
-	movl SYMBOL_NAME(current_set),%eax
-#endif
-	cmpl SYMBOL_NAME(task),%eax	# task[0] cannot have signals
-	je 2f
-	movl blocked(%eax),%ecx
-	movl %ecx,%ebx			# save blocked in %ebx for signal handling
-	notl %ecx
-	andl signal(%eax),%ecx
-	jne signal_return
-2:	RESTORE_ALL
-	ALIGN
-signal_return:
-	movl %esp,%ecx
-	pushl %ecx
-	testl $(VM_MASK),EFLAGS(%ecx)
-	jne v86_signal_return
-	pushl %ebx
-	call SYMBOL_NAME(do_signal)
-	popl %ebx
-	popl %ebx
-	RESTORE_ALL
-	ALIGN
-v86_signal_return:
-	call SYMBOL_NAME(save_v86_state)
-	movl %eax,%esp
-	pushl %eax
-	pushl %ebx
-	call SYMBOL_NAME(do_signal)
-	popl %ebx
-	popl %ebx
-	RESTORE_ALL
-
-ENTRY(divide_error)
-	pushl $0		# no error code
-	pushl $ SYMBOL_NAME(do_divide_error)
-	ALIGN
-error_code:
-	push %fs
-	push %es
-	push %ds
-	pushl %eax
-	xorl %eax,%eax
-	pushl %ebp
-	pushl %edi
-	pushl %esi
-	pushl %edx
-	decl %eax			# eax = -1
-	pushl %ecx
-	pushl %ebx
-	cld
-	xorl %ebx,%ebx			# zero ebx
-	xchgl %eax, ORIG_EAX(%esp)	# orig_eax (get the error code. )
-	mov %gs,%bx			# get the lower order bits of gs
-	movl %esp,%edx
-	xchgl %ebx, GS(%esp)		# get the address and save gs.
-	pushl %eax			# push the error code
-	pushl %edx
-	movl $(KERNEL_DS),%edx
-	mov %dx,%ds
-	mov %dx,%es
-	movl $(USER_DS),%edx
-	mov %dx,%fs
-#ifdef __SMP__
-	ENTER_KERNEL
-	GET_PROCESSOR_OFFSET(%eax)
-	movl SYMBOL_NAME(current_set)(,%eax), %eax
-#else
-	movl SYMBOL_NAME(current_set),%eax
-#endif
-	movl %db6,%edx
-	movl %edx,dbgreg6(%eax)  # save current hardware debugging status
-	call *%ebx
-	addl $8,%esp
-	jmp ret_from_sys_call
-
-ENTRY(coprocessor_error)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_coprocessor_error)
-	jmp error_code
-
-ENTRY(device_not_available)
-	pushl $-1		# mark this as an int
-	SAVE_ALL
-#ifdef __SMP__
-	ENTER_KERNEL
-#endif
-	pushl $ret_from_sys_call
-	movl %cr0,%eax
-	testl $0x4,%eax			# EM (math emulation bit)
-	je SYMBOL_NAME(math_state_restore)
-	pushl $0		# temporary storage for ORIG_EIP
-	call  SYMBOL_NAME(math_emulate)
-	addl $4,%esp
-	ret
-
-ENTRY(debug)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_debug)
-	jmp error_code
-
-ENTRY(nmi)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_nmi)
-	jmp error_code
-
-ENTRY(int3)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_int3)
-	jmp error_code
-
-ENTRY(overflow)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_overflow)
-	jmp error_code
-
-ENTRY(bounds)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_bounds)
-	jmp error_code
-
-ENTRY(invalid_op)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_invalid_op)
-	jmp error_code
-
-ENTRY(coprocessor_segment_overrun)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_coprocessor_segment_overrun)
-	jmp error_code
-
-ENTRY(reserved)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_reserved)
-	jmp error_code
-
-ENTRY(double_fault)
-	pushl $ SYMBOL_NAME(do_double_fault)
-	jmp error_code
-
-ENTRY(invalid_TSS)
-	pushl $ SYMBOL_NAME(do_invalid_TSS)
-	jmp error_code
-
-ENTRY(segment_not_present)
-	pushl $ SYMBOL_NAME(do_segment_not_present)
-	jmp error_code
-
-ENTRY(stack_segment)
-	pushl $ SYMBOL_NAME(do_stack_segment)
-	jmp error_code
-
-ENTRY(general_protection)
-	pushl $ SYMBOL_NAME(do_general_protection)
-	jmp error_code
-
-ENTRY(alignment_check)
-	pushl $ SYMBOL_NAME(do_alignment_check)
-	jmp error_code
-
-ENTRY(page_fault)
-	pushl $ SYMBOL_NAME(do_page_fault)
-	jmp error_code
-
-ENTRY(spurious_interrupt_bug)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_spurious_interrupt_bug)
-	jmp error_code
-
-.data
-ENTRY(sys_call_table)
-	.long SYMBOL_NAME(sys_setup)		/* 0 */
-	.long SYMBOL_NAME(sys_exit)
-	.long SYMBOL_NAME(sys_fork)
-	.long SYMBOL_NAME(sys_read)
-	.long SYMBOL_NAME(sys_write)
-	.long SYMBOL_NAME(sys_open)		/* 5 */
-	.long SYMBOL_NAME(sys_close)
-	.long SYMBOL_NAME(sys_waitpid)
-	.long SYMBOL_NAME(sys_creat)
-	.long SYMBOL_NAME(sys_link)
-	.long SYMBOL_NAME(sys_unlink)		/* 10 */
-	.long SYMBOL_NAME(sys_execve)
-	.long SYMBOL_NAME(sys_chdir)
-	.long SYMBOL_NAME(sys_time)
-	.long SYMBOL_NAME(sys_mknod)
-	.long SYMBOL_NAME(sys_chmod)		/* 15 */
-	.long SYMBOL_NAME(sys_chown)
-	.long SYMBOL_NAME(sys_break)
-	.long SYMBOL_NAME(sys_stat)
-	.long SYMBOL_NAME(sys_lseek)
-	.long SYMBOL_NAME(sys_getpid)		/* 20 */
-	.long SYMBOL_NAME(sys_mount)
-	.long SYMBOL_NAME(sys_umount)
-	.long SYMBOL_NAME(sys_setuid)
-	.long SYMBOL_NAME(sys_getuid)
-	.long SYMBOL_NAME(sys_stime)		/* 25 */
-	.long SYMBOL_NAME(sys_ptrace)
-	.long SYMBOL_NAME(sys_alarm)
-	.long SYMBOL_NAME(sys_fstat)
-	.long SYMBOL_NAME(sys_pause)
-	.long SYMBOL_NAME(sys_utime)		/* 30 */
-	.long SYMBOL_NAME(sys_stty)
-	.long SYMBOL_NAME(sys_gtty)
-	.long SYMBOL_NAME(sys_access)
-	.long SYMBOL_NAME(sys_nice)
-	.long SYMBOL_NAME(sys_ftime)		/* 35 */
-	.long SYMBOL_NAME(sys_sync)
-	.long SYMBOL_NAME(sys_kill)
-	.long SYMBOL_NAME(sys_rename)
-	.long SYMBOL_NAME(sys_mkdir)
-	.long SYMBOL_NAME(sys_rmdir)		/* 40 */
-	.long SYMBOL_NAME(sys_dup)
-	.long SYMBOL_NAME(sys_pipe)
-	.long SYMBOL_NAME(sys_times)
-	.long SYMBOL_NAME(sys_prof)
-	.long SYMBOL_NAME(sys_brk)		/* 45 */
-	.long SYMBOL_NAME(sys_setgid)
-	.long SYMBOL_NAME(sys_getgid)
-	.long SYMBOL_NAME(sys_signal)
-	.long SYMBOL_NAME(sys_geteuid)
-	.long SYMBOL_NAME(sys_getegid)		/* 50 */
-	.long SYMBOL_NAME(sys_acct)
-	.long SYMBOL_NAME(sys_phys)
-	.long SYMBOL_NAME(sys_lock)
-	.long SYMBOL_NAME(sys_ioctl)
-	.long SYMBOL_NAME(sys_fcntl)		/* 55 */
-	.long SYMBOL_NAME(sys_mpx)
-	.long SYMBOL_NAME(sys_setpgid)
-	.long SYMBOL_NAME(sys_ulimit)
-	.long SYMBOL_NAME(sys_olduname)
-	.long SYMBOL_NAME(sys_umask)		/* 60 */
-	.long SYMBOL_NAME(sys_chroot)
-	.long SYMBOL_NAME(sys_ustat)
-	.long SYMBOL_NAME(sys_dup2)
-	.long SYMBOL_NAME(sys_getppid)
-	.long SYMBOL_NAME(sys_getpgrp)		/* 65 */
-	.long SYMBOL_NAME(sys_setsid)
-	.long SYMBOL_NAME(sys_sigaction)
-	.long SYMBOL_NAME(sys_sgetmask)
-	.long SYMBOL_NAME(sys_ssetmask)
-	.long SYMBOL_NAME(sys_setreuid)		/* 70 */
-	.long SYMBOL_NAME(sys_setregid)
-	.long SYMBOL_NAME(sys_sigsuspend)
-	.long SYMBOL_NAME(sys_sigpending)
-	.long SYMBOL_NAME(sys_sethostname)
-	.long SYMBOL_NAME(sys_setrlimit)	/* 75 */
-	.long SYMBOL_NAME(sys_getrlimit)
-	.long SYMBOL_NAME(sys_getrusage)
-	.long SYMBOL_NAME(sys_gettimeofday)
-	.long SYMBOL_NAME(sys_settimeofday)
-	.long SYMBOL_NAME(sys_getgroups)	/* 80 */
-	.long SYMBOL_NAME(sys_setgroups)
-	.long SYMBOL_NAME(old_select)
-	.long SYMBOL_NAME(sys_symlink)
-	.long SYMBOL_NAME(sys_lstat)
-	.long SYMBOL_NAME(sys_readlink)		/* 85 */
-	.long SYMBOL_NAME(sys_uselib)
-	.long SYMBOL_NAME(sys_swapon)
-	.long SYMBOL_NAME(sys_reboot)
-	.long SYMBOL_NAME(old_readdir)
-	.long SYMBOL_NAME(old_mmap)		/* 90 */
-	.long SYMBOL_NAME(sys_munmap)
-	.long SYMBOL_NAME(sys_truncate)
-	.long SYMBOL_NAME(sys_ftruncate)
-	.long SYMBOL_NAME(sys_fchmod)
-	.long SYMBOL_NAME(sys_fchown)		/* 95 */
-	.long SYMBOL_NAME(sys_getpriority)
-	.long SYMBOL_NAME(sys_setpriority)
-	.long SYMBOL_NAME(sys_profil)
-	.long SYMBOL_NAME(sys_statfs)
-	.long SYMBOL_NAME(sys_fstatfs)		/* 100 */
-	.long SYMBOL_NAME(sys_ioperm)
-	.long SYMBOL_NAME(sys_socketcall)
-	.long SYMBOL_NAME(sys_syslog)
-	.long SYMBOL_NAME(sys_setitimer)
-	.long SYMBOL_NAME(sys_getitimer)	/* 105 */
-	.long SYMBOL_NAME(sys_newstat)
-	.long SYMBOL_NAME(sys_newlstat)
-	.long SYMBOL_NAME(sys_newfstat)
-	.long SYMBOL_NAME(sys_uname)
-	.long SYMBOL_NAME(sys_iopl)		/* 110 */
-	.long SYMBOL_NAME(sys_vhangup)
-	.long SYMBOL_NAME(sys_idle)
-	.long SYMBOL_NAME(sys_vm86old)
-	.long SYMBOL_NAME(sys_wait4)
-	.long SYMBOL_NAME(sys_swapoff)		/* 115 */
-	.long SYMBOL_NAME(sys_sysinfo)
-	.long SYMBOL_NAME(sys_ipc)
-	.long SYMBOL_NAME(sys_fsync)
-	.long SYMBOL_NAME(sys_sigreturn)
-	.long SYMBOL_NAME(sys_clone)		/* 120 */
-	.long SYMBOL_NAME(sys_setdomainname)
-	.long SYMBOL_NAME(sys_newuname)
-	.long SYMBOL_NAME(sys_modify_ldt)
-	.long SYMBOL_NAME(sys_adjtimex)
-	.long SYMBOL_NAME(sys_mprotect)		/* 125 */
-	.long SYMBOL_NAME(sys_sigprocmask)
-	.long SYMBOL_NAME(sys_create_module)
-	.long SYMBOL_NAME(sys_init_module)
-	.long SYMBOL_NAME(sys_delete_module)
-	.long SYMBOL_NAME(sys_get_kernel_syms)	/* 130 */
-	.long SYMBOL_NAME(sys_quotactl)
-	.long SYMBOL_NAME(sys_getpgid)
-	.long SYMBOL_NAME(sys_fchdir)
-	.long SYMBOL_NAME(sys_bdflush)
-	.long SYMBOL_NAME(sys_sysfs)		/* 135 */
-	.long SYMBOL_NAME(sys_personality)
-	.long 0					/* for afs_syscall */
-	.long SYMBOL_NAME(sys_setfsuid)
-	.long SYMBOL_NAME(sys_setfsgid)
-	.long SYMBOL_NAME(sys_llseek)		/* 140 */
-	.long SYMBOL_NAME(sys_getdents)
-	.long SYMBOL_NAME(sys_select)
-	.long SYMBOL_NAME(sys_flock)
-	.long SYMBOL_NAME(sys_msync)
-	.long SYMBOL_NAME(sys_readv)		/* 145 */
-	.long SYMBOL_NAME(sys_writev)
-	.long SYMBOL_NAME(sys_getsid)
-	.long SYMBOL_NAME(sys_fdatasync)
-	.long SYMBOL_NAME(sys_sysctl)
-	.long SYMBOL_NAME(sys_mlock)		/* 150 */
-	.long SYMBOL_NAME(sys_munlock)
-	.long SYMBOL_NAME(sys_mlockall)
-	.long SYMBOL_NAME(sys_munlockall)
-	.long SYMBOL_NAME(sys_sched_setparam)
-	.long SYMBOL_NAME(sys_sched_getparam)   /* 155 */
-	.long SYMBOL_NAME(sys_sched_setscheduler)
-	.long SYMBOL_NAME(sys_sched_getscheduler)
-	.long SYMBOL_NAME(sys_sched_yield)
-	.long SYMBOL_NAME(sys_sched_get_priority_max)
-	.long SYMBOL_NAME(sys_sched_get_priority_min)  /* 160 */
-	.long SYMBOL_NAME(sys_sched_rr_get_interval)
-	.long SYMBOL_NAME(sys_nanosleep)
-	.long SYMBOL_NAME(sys_mremap)
-	.long 0,0
-	.long SYMBOL_NAME(sys_vm86)
-	.long 0,0,0,0					/* 170 */
-	.long 0,0,0,0,0,0,0,0,0,0			/* 180 */
-	.long 0,0,0,0,0,0,0
-	.long SYMBOL_NAME(sys_table)
-	.space (NR_syscalls-188)*4

kernel/table20/kernel.patch

@@ -1,51 +0,0 @@
-diff -ur linux-2.0.32/Makefile linux-hacked/Makefile
---- linux-2.0.32/Makefile	Fri Nov  7 19:51:05 1997
-+++ linux-hacked/Makefile	Thu Jun 11 20:41:12 1998
-@@ -87,7 +87,7 @@
- # standard CFLAGS
- #
- 
--CFLAGS = -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -fno-strength-reduce
-+CFLAGS = -Wall -Wstrict-prototypes -g -O2 -fomit-frame-pointer -fno-strength-reduce
- 
- ifdef CONFIG_CPP
- CFLAGS := $(CFLAGS) -x c++
-@@ -113,12 +113,12 @@
- # Include the make variables (CC, etc...)
- #
- 
--ARCHIVES	=kernel/kernel.o mm/mm.o fs/fs.o ipc/ipc.o net/network.a
-+ARCHIVES	=kernel/kernel.o mm/mm.o fs/fs.o ipc/ipc.o net/network.a table/table.o
- FILESYSTEMS	=fs/filesystems.a
- DRIVERS		=drivers/block/block.a \
- 		 drivers/char/char.a
- LIBS		=$(TOPDIR)/lib/lib.a
--SUBDIRS		=kernel drivers mm fs net ipc lib
-+SUBDIRS		=kernel drivers mm fs net ipc lib table
- 
- ifeq ($(CONFIG_ISDN),y)
- DRIVERS := $(DRIVERS) drivers/isdn/isdn.a
-diff -ur linux-2.0.32/arch/i386/kernel/entry.S linux-hacked/arch/i386/kernel/entry.S
---- linux-2.0.32/arch/i386/kernel/entry.S	Tue Sep 16 23:42:45 1997
-+++ linux-hacked/arch/i386/kernel/entry.S	Thu Jun 11 21:37:20 1998
-@@ -699,4 +699,8 @@
- 	.long SYMBOL_NAME(sys_mremap)
- 	.long 0,0
- 	.long SYMBOL_NAME(sys_vm86)
--	.space (NR_syscalls-166)*4
-+	.long 0,0,0,0					/* 170 */
-+	.long 0,0,0,0,0,0,0,0,0,0			/* 180 */
-+	.long 0,0,0,0,0,0,0
-+	.long SYMBOL_NAME(sys_table)
-+	.space (NR_syscalls-188)*4
-diff -ur linux-2.0.32/include/asm-i386/unistd.h linux-hacked/include/asm-i386/unistd.h
---- linux-2.0.32/include/asm-i386/unistd.h	Fri Mar 22 07:34:02 1996
-+++ linux-hacked/include/asm-i386/unistd.h	Thu Jun 11 21:37:03 1998
-@@ -169,6 +169,7 @@
- #define __NR_sched_rr_get_interval	161
- #define __NR_nanosleep		162
- #define __NR_mremap		163
-+#define __NR_table		188
- 
- /* XXX - _foo needs to be __foo, while __NR_bar could be _NR_bar. */
- #define _syscall0(type,name) \

kernel/table20/main.c

@@ -1,468 +0,0 @@
-/*
- * linux/table/table_impl.c
- * Copyright (C) 1998 Martin Baulig
- */
-
-#include <linux/types.h>
-#include <linux/errno.h>
-#include <linux/sched.h>
-#include <linux/kernel.h>
-#include <linux/kernel_stat.h>
-#include <linux/tty.h>
-#include <linux/user.h>
-#include <linux/a.out.h>
-#include <linux/string.h>
-#include <linux/mman.h>
-#include <linux/proc_fs.h>
-#include <linux/ioport.h>
-#include <linux/config.h>
-#include <linux/mm.h>
-#include <linux/pagemap.h>
-#include <linux/swap.h>
-
-#include <asm/segment.h>
-#include <asm/pgtable.h>
-#include <asm/io.h>
-
-#include <linux/table.h>
-
-#include "version.h"
-
-#if defined(__i386__)
-# define KSTK_EIP(tsk)	(((unsigned long *)tsk->kernel_stack_page)[1019])
-# define KSTK_ESP(tsk)	(((unsigned long *)tsk->kernel_stack_page)[1022])
-#elif defined(__alpha__)
-  /*
-   * See arch/alpha/kernel/ptrace.c for details.
-   */
-# define PT_REG(reg)		(PAGE_SIZE - sizeof(struct pt_regs)	\
-				 + (long)&((struct pt_regs *)0)->reg)
-# define KSTK_EIP(tsk)	(*(unsigned long *)(tsk->kernel_stack_page + PT_REG(pc)))
-# define KSTK_ESP(tsk)	((tsk) == current ? rdusp() : (tsk)->tss.usp)
-#elif defined(__sparc__)
-# define PT_REG(reg)            (PAGE_SIZE - sizeof(struct pt_regs)     \
-                                 + (long)&((struct pt_regs *)0)->reg)
-# define KSTK_EIP(tsk)  (*(unsigned long *)(tsk->kernel_stack_page + PT_REG(pc)))
-# define KSTK_ESP(tsk)  (*(unsigned long *)(tsk->kernel_stack_page + PT_REG(u_regs[UREG_FP])))
-#endif
-
-static struct task_struct *
-get_task (pid_t pid)
-{
-	struct task_struct ** p;
-	
-	p = task;
-	while (++p < task+NR_TASKS) {
-		if (*p && (*p)->pid == pid)
-			return *p;
-	}
-
-	return NULL;
-}
-
-static inline void statm_pte_range(pmd_t * pmd, unsigned long address, unsigned long size,
-	int * pages, int * shared, int * dirty, int * total)
-{
-	pte_t * pte;
-	unsigned long end;
-
-	if (pmd_none(*pmd))
-		return;
-	if (pmd_bad(*pmd)) {
-		printk("statm_pte_range: bad pmd (%08lx)\n", pmd_val(*pmd));
-		pmd_clear(pmd);
-		return;
-	}
-	pte = pte_offset(pmd, address);
-	address &= ~PMD_MASK;
-	end = address + size;
-	if (end > PMD_SIZE)
-		end = PMD_SIZE;
-	do {
-		pte_t page = *pte;
-
-		address += PAGE_SIZE;
-		pte++;
-		if (pte_none(page))
-			continue;
-		++*total;
-		if (!pte_present(page))
-			continue;
-		++*pages;
-		if (pte_dirty(page))
-			++*dirty;
-		if (pte_page(page) >= high_memory)
-			continue;
-		if (mem_map[MAP_NR(pte_page(page))].count > 1)
-			++*shared;
-	} while (address < end);
-}
-
-static inline void statm_pmd_range(pgd_t * pgd, unsigned long address, unsigned long size,
-	int * pages, int * shared, int * dirty, int * total)
-{
-	pmd_t * pmd;
-	unsigned long end;
-
-	if (pgd_none(*pgd))
-		return;
-	if (pgd_bad(*pgd)) {
-		printk("statm_pmd_range: bad pgd (%08lx)\n", pgd_val(*pgd));
-		pgd_clear(pgd);
-		return;
-	}
-	pmd = pmd_offset(pgd, address);
-	address &= ~PGDIR_MASK;
-	end = address + size;
-	if (end > PGDIR_SIZE)
-		end = PGDIR_SIZE;
-	do {
-		statm_pte_range(pmd, address, end - address, pages, shared, dirty, total);
-		address = (address + PMD_SIZE) & PMD_MASK;
-		pmd++;
-	} while (address < end);
-}
-
-static void statm_pgd_range(pgd_t * pgd, unsigned long address, unsigned long end,
-	int * pages, int * shared, int * dirty, int * total)
-{
-	while (address < end) {
-		statm_pmd_range(pgd, address, end - address, pages, shared, dirty, total);
-		address = (address + PGDIR_SIZE) & PGDIR_MASK;
-		pgd++;
-	}
-}
-
-static unsigned long
-get_wchan (struct task_struct *p)
-{
-	if (!p || p == current || p->state == TASK_RUNNING)
-		return 0;
-#if defined(__i386__)
-	{
-		unsigned long ebp, eip;
-		unsigned long stack_page;
-		int count = 0;
-
-		stack_page = p->kernel_stack_page;
-		if (!stack_page)
-			return 0;
-		ebp = p->tss.ebp;
-		do {
-			if (ebp < stack_page || ebp >= 4092+stack_page)
-				return 0;
-			eip = *(unsigned long *) (ebp+4);
-			if (eip < (unsigned long) interruptible_sleep_on
-			    || eip >= (unsigned long) add_timer)
-				return eip;
-			ebp = *(unsigned long *) ebp;
-		} while (count++ < 16);
-	}
-#elif defined(__alpha__)
-	/*
-	 * This one depends on the frame size of schedule().  Do a
-	 * "disass schedule" in gdb to find the frame size.  Also, the
-	 * code assumes that sleep_on() follows immediately after
-	 * interruptible_sleep_on() and that add_timer() follows
-	 * immediately after interruptible_sleep().  Ugly, isn't it?
-	 * Maybe adding a wchan field to task_struct would be better,
-	 * after all...
-	 */
-	{
-		unsigned long schedule_frame;
-		unsigned long pc;
-		
-		pc = thread_saved_pc(&p->tss);
-		if (pc >= (unsigned long) interruptible_sleep_on && pc < (unsigned long) add_timer) {
-			schedule_frame = ((unsigned long *)p->tss.ksp)[6];
-			return ((unsigned long *)schedule_frame)[12];
-		}
-		return pc;
-	}
-#endif
-	return 0;
-}
-
-asmlinkage int
-sys_table (int type, union table *buf, const void *param)
-{
-	union table tbl;
-	struct sysinfo i;
-	struct task_struct *tsk = NULL;
-	struct ip_chain *chain;
-	struct ip_fwkernel *rule;
-	char devname [9];
-	int index, err;
-	pid_t pid;
-
-	if (type == TABLE_VERSION)
-		return _TABLE_VERSION;
-
-	if (!buf)
-		return -EFAULT;
-
-	memset (&tbl, 0, sizeof (union table));
-
-	/* For TABLE_PROC_*, read pid and get task_struct */
-
-	switch (type) {
-	case TABLE_PROC_UID:
-	case TABLE_PROC_MEM:
-	case TABLE_PROC_SEGMENT:
-	case TABLE_PROC_TIME:
-	case TABLE_PROC_STATE:
-	case TABLE_PROC_SIGNAL:
-	case TABLE_PROC_KERNEL:
-	  err = verify_area (VERIFY_READ, param, sizeof (pid_t));
-		if (err)
-			return err;
-		memcpy_fromfs (&pid, param, sizeof (pid_t));
-
-		tsk = get_task (pid);
-		if (tsk == NULL)
-			return -ESRCH;
-		break;
-	case TABLE_NETACCT:
-		err = verify_area (VERIFY_READ, param, 5);
-		if (err)
-			return err;
-		copy_from_user (devname, param, 5);
-		devname [5] = 0;
-
-		break;
-	}
-
-	/* Main function dispatcher */
-
-	switch (type) {
-	case TABLE_PROCLIST:
-		tsk = task [0];
-		for (index = 0; index < nr_tasks; index++) {
-			tbl.proclist.pids [index] = tsk->pid;
-			tsk = tsk->next_task;
-		}
-		tbl.proclist.nr_running = nr_running;
-		tbl.proclist.nr_tasks = nr_tasks;
-		tbl.proclist.last_pid = last_pid;
-		break;
-	case TABLE_CPU:
-		tbl.cpu.total = jiffies;    
-		tbl.cpu.user  = kstat.cpu_user;
-		tbl.cpu.nice  = kstat.cpu_nice;
-		tbl.cpu.sys   = kstat.cpu_system;
-		tbl.cpu.idle  = tbl.cpu.total -
-			(tbl.cpu.user + tbl.cpu.nice + tbl.cpu.sys);
-		tbl.cpu.frequency = HZ;
-		break;
-	case TABLE_MEM:
-		si_meminfo (&i);
-		tbl.mem.total  = i.totalram;
-		tbl.mem.used   = i.totalram - i.freeram;
-		tbl.mem.free   = i.freeram;
-		tbl.mem.shared = i.sharedram;
-		tbl.mem.buffer = i.bufferram;
-		tbl.mem.cached = page_cache_size << PAGE_SHIFT;
-		break;
-	case TABLE_SWAP:
-		si_swapinfo (&i);
-		tbl.swap.total = i.totalswap;
-		tbl.swap.used  = i.totalswap - i.freeswap;
-		tbl.swap.free  = i.freeswap;
-		tbl.swap.pagein = kstat.pswpin;
-		tbl.swap.pageout = kstat.pswpout;
-		break;
-	case TABLE_LOADAVG:
-		tbl.loadavg.loadavg [0] = (double) avenrun [0] / (1 << FSHIFT);
-		tbl.loadavg.loadavg [1] = (double) avenrun [1] / (1 << FSHIFT);
-		tbl.loadavg.loadavg [2] = (double) avenrun [2] / (1 << FSHIFT);
-		tbl.loadavg.nr_running = nr_running;
-		tbl.loadavg.nr_tasks = nr_tasks;
-		tbl.loadavg.last_pid = last_pid;
-		break;
-	case TABLE_UPTIME:
-		tbl.uptime.uptime = jiffies;
-		tbl.uptime.idle   = task[0]->utime + task[0]->stime;
-		break;
-	case TABLE_PROC_STATE:
-		tbl.proc_state.state = tsk->state;
-		tbl.proc_state.flags = tsk->flags;
-		memcpy (tbl.proc_state.comm, tsk->comm,
-			sizeof (tbl.proc_state.comm));
-		break;
-	case TABLE_PROC_UID:
-		tbl.proc_uid.uid = tsk->uid;
-		tbl.proc_uid.euid = tsk->euid;
-		tbl.proc_uid.suid = tsk->suid;
-		tbl.proc_uid.fsuid = tsk->fsuid;
-		
-		tbl.proc_uid.gid = tsk->gid;
-		tbl.proc_uid.egid = tsk->egid;
-		tbl.proc_uid.sgid = tsk->sgid;
-		tbl.proc_uid.fsgid = tsk->fsgid;
-		
-		tbl.proc_uid.pid = tsk->pid;
-		tbl.proc_uid.pgrp = tsk->pgrp;
-		tbl.proc_uid.ppid = tsk->p_pptr->pid;
-		
-		tbl.proc_uid.session = tsk->session;
-	        tbl.proc_uid.tty = tsk->tty ?
-			kdev_t_to_nr (tsk->tty->device) : 0;
-		tbl.proc_uid.tpgid = tsk->tty ? tsk->tty->pgrp : -1;
-		
-		tbl.proc_uid.priority = tsk->priority;
-		tbl.proc_uid.counter = tsk->counter;
-		tbl.proc_uid.def_priority = DEF_PRIORITY;
-		break;
-	case TABLE_PROC_SIGNAL:
-		tbl.proc_signal.signal = tsk->signal;
-		tbl.proc_signal.blocked = tsk->blocked;
-
-		if (tsk->sig) {
-			struct sigaction * action = tsk->sig->action;
-			unsigned long sig_ign = 0, sig_caught = 0;
-			unsigned long bit = 1;
-			int i;
-			
-			for (i = 0; i < 32; i++) {
-				switch((unsigned long) action->sa_handler) {
-				case 0:
-					break;
-				case 1:
-					sig_ign |= bit;
-					break;
-				default:
-					sig_caught |= bit;
-				}
-				bit <<= 1;
-				action++;
-			}
-
-			tbl.proc_signal.ignored = sig_ign;
-			tbl.proc_signal.caught  = sig_caught;
-		} else {
-			tbl.proc_signal.ignored = 0;
-			tbl.proc_signal.caught  = 0;
-		}
-		break;
-	case TABLE_PROC_MEM:
-		if (tsk->mm && tsk->mm != &init_mm) {
-			tbl.proc_mem.context = tsk->mm->context;
-			tbl.proc_mem.start_code = tsk->mm->start_code;
-			tbl.proc_mem.end_code = tsk->mm->end_code;
-			tbl.proc_mem.start_data = tsk->mm-> start_data;
-			tbl.proc_mem.end_data = tsk->mm->end_data;
-			tbl.proc_mem.start_brk = tsk->mm->start_brk;
-			tbl.proc_mem.brk = tsk->mm->brk;
-			tbl.proc_mem.start_stack = tsk->mm->start_stack;
-			tbl.proc_mem.start_mmap = tsk->mm->start_mmap;
-			tbl.proc_mem.arg_start = tsk->mm->arg_start;
-			tbl.proc_mem.arg_end = tsk->mm->arg_end;
-			tbl.proc_mem.env_start = tsk->mm->env_start;
-			tbl.proc_mem.env_end = tsk->mm->env_end;
-			tbl.proc_mem.rss = tsk->mm->rss;
-			tbl.proc_mem.total_vm = tsk->mm->total_vm;
-			tbl.proc_mem.locked_vm = tsk->mm->locked_vm;
-		}
-		tbl.proc_mem.rlim = tsk->rlim ?
-			tsk->rlim[RLIMIT_RSS].rlim_cur : 0;
-		break;
-	case TABLE_PROC_SEGMENT:
-		if (tsk->mm && tsk->mm != &init_mm) {
-			unsigned long vsize = 0;
-			int size = 0, resident = 0, share = 0;
-			int trs = 0, lrs = 0, drs = 0, dt = 0;
-			struct vm_area_struct * vma = tsk->mm->mmap;
-
-			while (vma) {
-				pgd_t *pgd = pgd_offset(tsk->mm, vma->vm_start);
-				int pages = 0, shared = 0, dirty = 0, total = 0;
-				
-				vsize += vma->vm_end - vma->vm_start;
-
-				statm_pgd_range (pgd, vma->vm_start, vma->vm_end,
-						 &pages, &shared, &dirty, &total);
-				resident += pages;
-				share += shared;
-				dt += dirty;
-				size += total;
-				if (vma->vm_flags & VM_EXECUTABLE)
-					trs += pages;	/* text */
-				else if (vma->vm_flags & VM_GROWSDOWN)
-					drs += pages;	/* stack */
-				else if (vma->vm_end > 0x60000000)
-					lrs += pages;	/* library */
-				else
-					drs += pages;
-				vma = vma->vm_next;
-			}
-
-			tbl.proc_segment.vsize = vsize;
-			tbl.proc_segment.size = size;
-			tbl.proc_segment.resident = resident;
-			tbl.proc_segment.shared = share;
-			tbl.proc_segment.trs = trs;
-			tbl.proc_segment.lrs = lrs;
-			tbl.proc_segment.dt = dt;
-		}
-		break;
-	case TABLE_PROC_TIME:
-		tbl.proc_time.utime = tsk->utime;
-		tbl.proc_time.stime = tsk->stime;
-		tbl.proc_time.cutime = tsk->cutime;
-		tbl.proc_time.cstime = tsk->cstime;
-
-		tbl.proc_time.start_time = tsk->start_time;
-		tbl.proc_time.timeout = tsk->timeout;
-		tbl.proc_time.policy = tsk->policy;
-		tbl.proc_time.rt_priority = tsk->rt_priority;
-
-		tbl.proc_time.it_real_value = tsk->it_real_value;
-		tbl.proc_time.it_prof_value = tsk->it_prof_value;
-		tbl.proc_time.it_virt_value = tsk->it_virt_value;
-		tbl.proc_time.it_real_incr = tsk->it_real_incr;
-		tbl.proc_time.it_prof_incr = tsk->it_prof_incr;
-		tbl.proc_time.it_virt_incr = tsk->it_virt_incr;
-		break;
-	case TABLE_PROC_KERNEL:
-		tbl.proc_kernel.min_flt = tsk->min_flt;
-		tbl.proc_kernel.cmin_flt = tsk->cmin_flt;
-		tbl.proc_kernel.maj_flt = tsk->maj_flt;
-		tbl.proc_kernel.cmaj_flt = tsk->cmaj_flt;
-		
-		tbl.proc_kernel.kesp = tsk->kernel_stack_page ? KSTK_EIP(tsk) : 0;
-		tbl.proc_kernel.keip = tsk->kernel_stack_page ? KSTK_ESP(tsk) : 0;
-		
-		tbl.proc_kernel.nswap = tsk->nswap;
-		tbl.proc_kernel.cnswap = tsk->cnswap;
-
-		tbl.proc_kernel.wchan = get_wchan (tsk);
-		break;
-	case TABLE_NETACCT:
-		for (chain = ip_fw_chains; chain; chain = chain->next) {
-			for (rule = chain->chain; rule; rule = rule->next) {
-				const char *name = rule->ipfw.fw_vianame;
-				int k;
-				
-				if (name [0] && !strncmp (param, name, 5))
-					continue;
-				
-				for (k = 0; k < NUM_SLOTS; k++) {
-					tbl.netacct.packets +=
-						rule->counters[k].pcnt;
-					tbl.netacct.bytes +=
-						rule->counters[k].bcnt;
-				}
-			}
-		}
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	err = verify_area (VERIFY_WRITE, buf, sizeof (struct table));
-	if (err)
-		return err;
-
-	memcpy_tofs (buf, &tbl, sizeof (union table));
-	return 0;
-}

kernel/table20/unistd-i386.h

@@ -1,324 +0,0 @@
-#ifndef _ASM_I386_UNISTD_H_
-#define _ASM_I386_UNISTD_H_
-
-/*
- * This file contains the system call numbers.
- */
-
-#define __NR_setup		  0	/* used only by init, to get system going */
-#define __NR_exit		  1
-#define __NR_fork		  2
-#define __NR_read		  3
-#define __NR_write		  4
-#define __NR_open		  5
-#define __NR_close		  6
-#define __NR_waitpid		  7
-#define __NR_creat		  8
-#define __NR_link		  9
-#define __NR_unlink		 10
-#define __NR_execve		 11
-#define __NR_chdir		 12
-#define __NR_time		 13
-#define __NR_mknod		 14
-#define __NR_chmod		 15
-#define __NR_chown		 16
-#define __NR_break		 17
-#define __NR_oldstat		 18
-#define __NR_lseek		 19
-#define __NR_getpid		 20
-#define __NR_mount		 21
-#define __NR_umount		 22
-#define __NR_setuid		 23
-#define __NR_getuid		 24
-#define __NR_stime		 25
-#define __NR_ptrace		 26
-#define __NR_alarm		 27
-#define __NR_oldfstat		 28
-#define __NR_pause		 29
-#define __NR_utime		 30
-#define __NR_stty		 31
-#define __NR_gtty		 32
-#define __NR_access		 33
-#define __NR_nice		 34
-#define __NR_ftime		 35
-#define __NR_sync		 36
-#define __NR_kill		 37
-#define __NR_rename		 38
-#define __NR_mkdir		 39
-#define __NR_rmdir		 40
-#define __NR_dup		 41
-#define __NR_pipe		 42
-#define __NR_times		 43
-#define __NR_prof		 44
-#define __NR_brk		 45
-#define __NR_setgid		 46
-#define __NR_getgid		 47
-#define __NR_signal		 48
-#define __NR_geteuid		 49
-#define __NR_getegid		 50
-#define __NR_acct		 51
-#define __NR_phys		 52
-#define __NR_lock		 53
-#define __NR_ioctl		 54
-#define __NR_fcntl		 55
-#define __NR_mpx		 56
-#define __NR_setpgid		 57
-#define __NR_ulimit		 58
-#define __NR_oldolduname	 59
-#define __NR_umask		 60
-#define __NR_chroot		 61
-#define __NR_ustat		 62
-#define __NR_dup2		 63
-#define __NR_getppid		 64
-#define __NR_getpgrp		 65
-#define __NR_setsid		 66
-#define __NR_sigaction		 67
-#define __NR_sgetmask		 68
-#define __NR_ssetmask		 69
-#define __NR_setreuid		 70
-#define __NR_setregid		 71
-#define __NR_sigsuspend		 72
-#define __NR_sigpending		 73
-#define __NR_sethostname	 74
-#define __NR_setrlimit		 75
-#define __NR_getrlimit		 76
-#define __NR_getrusage		 77
-#define __NR_gettimeofday	 78
-#define __NR_settimeofday	 79
-#define __NR_getgroups		 80
-#define __NR_setgroups		 81
-#define __NR_select		 82
-#define __NR_symlink		 83
-#define __NR_oldlstat		 84
-#define __NR_readlink		 85
-#define __NR_uselib		 86
-#define __NR_swapon		 87
-#define __NR_reboot		 88
-#define __NR_readdir		 89
-#define __NR_mmap		 90
-#define __NR_munmap		 91
-#define __NR_truncate		 92
-#define __NR_ftruncate		 93
-#define __NR_fchmod		 94
-#define __NR_fchown		 95
-#define __NR_getpriority	 96
-#define __NR_setpriority	 97
-#define __NR_profil		 98
-#define __NR_statfs		 99
-#define __NR_fstatfs		100
-#define __NR_ioperm		101
-#define __NR_socketcall		102
-#define __NR_syslog		103
-#define __NR_setitimer		104
-#define __NR_getitimer		105
-#define __NR_stat		106
-#define __NR_lstat		107
-#define __NR_fstat		108
-#define __NR_olduname		109
-#define __NR_iopl		110
-#define __NR_vhangup		111
-#define __NR_idle		112
-#define __NR_vm86		113
-#define __NR_wait4		114
-#define __NR_swapoff		115
-#define __NR_sysinfo		116
-#define __NR_ipc		117
-#define __NR_fsync		118
-#define __NR_sigreturn		119
-#define __NR_clone		120
-#define __NR_setdomainname	121
-#define __NR_uname		122
-#define __NR_modify_ldt		123
-#define __NR_adjtimex		124
-#define __NR_mprotect		125
-#define __NR_sigprocmask	126
-#define __NR_create_module	127
-#define __NR_init_module	128
-#define __NR_delete_module	129
-#define __NR_get_kernel_syms	130
-#define __NR_quotactl		131
-#define __NR_getpgid		132
-#define __NR_fchdir		133
-#define __NR_bdflush		134
-#define __NR_sysfs		135
-#define __NR_personality	136
-#define __NR_afs_syscall	137 /* Syscall for Andrew File System */
-#define __NR_setfsuid		138
-#define __NR_setfsgid		139
-#define __NR__llseek		140
-#define __NR_getdents		141
-#define __NR__newselect		142
-#define __NR_flock		143
-#define __NR_msync		144
-#define __NR_readv		145
-#define __NR_writev		146
-#define __NR_getsid		147
-#define __NR_fdatasync		148
-#define __NR__sysctl		149
-#define __NR_mlock		150
-#define __NR_munlock		151
-#define __NR_mlockall		152
-#define __NR_munlockall		153
-#define __NR_sched_setparam		154
-#define __NR_sched_getparam		155
-#define __NR_sched_setscheduler		156
-#define __NR_sched_getscheduler		157
-#define __NR_sched_yield		158
-#define __NR_sched_get_priority_max	159
-#define __NR_sched_get_priority_min	160
-#define __NR_sched_rr_get_interval	161
-#define __NR_nanosleep		162
-#define __NR_mremap		163
-#define __NR_table		188
-
-/* XXX - _foo needs to be __foo, while __NR_bar could be _NR_bar. */
-#define _syscall0(type,name) \
-type name(void) \
-{ \
-long __res; \
-__asm__ volatile ("int $0x80" \
-	: "=a" (__res) \
-	: "0" (__NR_##name)); \
-if (__res >= 0) \
-	return (type) __res; \
-errno = -__res; \
-return -1; \
-}
-
-#define _syscall1(type,name,type1,arg1) \
-type name(type1 arg1) \
-{ \
-long __res; \
-__asm__ volatile ("int $0x80" \
-	: "=a" (__res) \
-	: "0" (__NR_##name),"b" ((long)(arg1))); \
-if (__res >= 0) \
-	return (type) __res; \
-errno = -__res; \
-return -1; \
-}
-
-#define _syscall2(type,name,type1,arg1,type2,arg2) \
-type name(type1 arg1,type2 arg2) \
-{ \
-long __res; \
-__asm__ volatile ("int $0x80" \
-	: "=a" (__res) \
-	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2))); \
-if (__res >= 0) \
-	return (type) __res; \
-errno = -__res; \
-return -1; \
-}
-
-#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
-type name(type1 arg1,type2 arg2,type3 arg3) \
-{ \
-long __res; \
-__asm__ volatile ("int $0x80" \
-	: "=a" (__res) \
-	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
-		  "d" ((long)(arg3))); \
-if (__res>=0) \
-	return (type) __res; \
-errno=-__res; \
-return -1; \
-}
-
-#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
-type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
-{ \
-long __res; \
-__asm__ volatile ("int $0x80" \
-	: "=a" (__res) \
-	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
-	  "d" ((long)(arg3)),"S" ((long)(arg4))); \
-if (__res>=0) \
-	return (type) __res; \
-errno=-__res; \
-return -1; \
-} 
-
-#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
-	  type5,arg5) \
-type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
-{ \
-long __res; \
-__asm__ volatile ("int $0x80" \
-	: "=a" (__res) \
-	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
-	  "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5))); \
-if (__res>=0) \
-	return (type) __res; \
-errno=-__res; \
-return -1; \
-}
-
-#ifdef __KERNEL_SYSCALLS__
-
-/*
- * we need this inline - forking from kernel space will result
- * in NO COPY ON WRITE (!!!), until an execve is executed. This
- * is no problem, but for the stack. This is handled by not letting
- * main() use the stack at all after fork(). Thus, no function
- * calls - which means inline code for fork too, as otherwise we
- * would use the stack upon exit from 'fork()'.
- *
- * Actually only pause and fork are needed inline, so that there
- * won't be any messing with the stack from main(), but we define
- * some others too.
- */
-#define __NR__exit __NR_exit
-static inline _syscall0(int,idle)
-static inline _syscall0(int,fork)
-static inline _syscall2(int,clone,unsigned long,flags,char *,esp)
-static inline _syscall0(int,pause)
-static inline _syscall0(int,setup)
-static inline _syscall0(int,sync)
-static inline _syscall0(pid_t,setsid)
-static inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
-static inline _syscall1(int,dup,int,fd)
-static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
-static inline _syscall3(int,open,const char *,file,int,flag,int,mode)
-static inline _syscall1(int,close,int,fd)
-static inline _syscall1(int,_exit,int,exitcode)
-static inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
-
-static inline pid_t wait(int * wait_stat)
-{
-	return waitpid(-1,wait_stat,0);
-}
-
-/*
- * This is the mechanism for creating a new kernel thread.
- *
- * NOTE! Only a kernel-only process(ie the swapper or direct descendants
- * who haven't done an "execve()") should use this: it will work within
- * a system call from a "real" process, but the process memory space will
- * not be free'd until both the parent and the child have exited.
- */
-static inline pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
-{
-	long retval;
-
-	__asm__ __volatile__(
-		"movl %%esp,%%esi\n\t"
-		"int $0x80\n\t"		/* Linux/i386 system call */
-		"cmpl %%esp,%%esi\n\t"	/* child or parent? */
-		"je 1f\n\t"		/* parent - jump */
-		"pushl %3\n\t"		/* push argument */
-		"call *%4\n\t"		/* call fn */
-		"movl %2,%0\n\t"	/* exit */
-		"int $0x80\n"
-		"1:\t"
-		:"=a" (retval)
-		:"0" (__NR_clone), "i" (__NR_exit),
-		 "r" (arg), "r" (fn),
-		 "b" (flags | CLONE_VM)
-		:"si");
-	return retval;
-}
-
-#endif
-
-#endif /* _ASM_I386_UNISTD_H_ */

kernel/table20/version.h

@@ -1 +0,0 @@
-#define _TABLE_VERSION	1

kernel/table21/.cvsignore

@@ -1,4 +0,0 @@
-kernel.patch
-.main.o.flags
-.table.o.flags
-.module.o.flags

kernel/table21/Makefile

@@ -1,16 +0,0 @@
-#
-# Makefile for the linux system information tables.
-#
-# Note! Dependencies are done automagically by 'make dep', which also
-# removes any old dependencies. DON'T put your own dependencies here
-# unless it's something special (ie not a .c file).
-#
-# Note 2! The CFLAGS definition is now in the main makefile...
-
-O_TARGET := table.o
-OX_OBJS  := main.o
-
-M_TARGET := table_mod.o
-MX_OBJS  := module.o
-
-include $(TOPDIR)/Rules.make

kernel/table21/README

@@ -1,21 +0,0 @@
-This is a new system call `table ()' for the Linux table. It is faster
-than reading from /proc and can be used to fetch all information required
-for libgtop until whe have some other function (extended sysctl, ...) in
-standard kernels.
-
-I didn't want to change sysctl or some other function myself cause this may
-cause other applications relying upon those function to fail. This is
-something for the ``real'' kernel gurus ...
-
-To use this new system call for libgtop, do the following:
-
-* Copy this directory to /usr/src/linux/table
-* Make /usr/src/linux/include/linux/table.h symlink to /usr/src/linux/table/table.h
-* Apply the patch `kernel.patch' to the kernel, compile, install and reboot
-* Recompile libgtop (remove `config.cache' and run the `autogen.sh' again).
-
-If you want to change and/or add something - feel free to do so !
-
-Have fun,
-
-Martin

kernel/table21/entry-i386.S

@@ -1,571 +0,0 @@
-/*
- *  linux/arch/i386/entry.S
- *
- *  Copyright (C) 1991, 1992  Linus Torvalds
- */
-
-/*
- * entry.S contains the system-call and fault low-level handling routines.
- * This also contains the timer-interrupt handler, as well as all interrupts
- * and faults that can result in a task-switch.
- *
- * NOTE: This code handles signal-recognition, which happens every time
- * after a timer-interrupt and after each system call.
- *
- * I changed all the .align's to 4 (16 byte alignment), as that's faster
- * on a 486.
- *
- * Stack layout in 'ret_from_system_call':
- * 	ptrace needs to have all regs on the stack.
- *	if the order here is changed, it needs to be
- *	updated in fork.c:copy_process, signal.c:do_signal,
- *	ptrace.c and ptrace.h
- *
- *	 0(%esp) - %ebx
- *	 4(%esp) - %ecx
- *	 8(%esp) - %edx
- *       C(%esp) - %esi
- *	10(%esp) - %edi
- *	14(%esp) - %ebp
- *	18(%esp) - %eax
- *	1C(%esp) - %ds
- *	20(%esp) - %es
- *	24(%esp) - orig_eax
- *	28(%esp) - %eip
- *	2C(%esp) - %cs
- *	30(%esp) - %eflags
- *	34(%esp) - %oldesp
- *	38(%esp) - %oldss
- *
- * "current" is in register %ebx during any slow entries.
- */
-
-#include <linux/sys.h>
-#include <linux/linkage.h>
-#include <asm/segment.h>
-#define ASSEMBLY
-#include <asm/smp.h>
-
-EBX		= 0x00
-ECX		= 0x04
-EDX		= 0x08
-ESI		= 0x0C
-EDI		= 0x10
-EBP		= 0x14
-EAX		= 0x18
-DS		= 0x1C
-ES		= 0x20
-ORIG_EAX	= 0x24
-EIP		= 0x28
-CS		= 0x2C
-EFLAGS		= 0x30
-OLDESP		= 0x34
-OLDSS		= 0x38
-
-CF_MASK		= 0x00000001
-IF_MASK		= 0x00000200
-NT_MASK		= 0x00004000
-VM_MASK		= 0x00020000
-
-/*
- * these are offsets into the task-struct.
- */
-state		=  0
-flags		=  4
-sigpending	=  8
-addr_limit	= 12
-exec_domain	= 16
-need_resched	= 20
-
-ENOSYS = 38
-
-
-#define SAVE_ALL \
-	cld; \
-	pushl %es; \
-	pushl %ds; \
-	pushl %eax; \
-	pushl %ebp; \
-	pushl %edi; \
-	pushl %esi; \
-	pushl %edx; \
-	pushl %ecx; \
-	pushl %ebx; \
-	movl $(__KERNEL_DS),%edx; \
-	movl %dx,%ds; \
-	movl %dx,%es;
-
-#define RESTORE_ALL	\
-	popl %ebx;	\
-	popl %ecx;	\
-	popl %edx;	\
-	popl %esi;	\
-	popl %edi;	\
-	popl %ebp;	\
-	popl %eax;	\
-1:	popl %ds;	\
-2:	popl %es;	\
-3:	addl $4,%esp;	\
-	iret;		\
-.section fixup,"ax";	\
-4:	pushl $0;	\
-	popl %ds;	\
-	jmp 2b;		\
-5:	pushl $0;	\
-	popl %es;	\
-	jmp 3b;		\
-.previous;		\
-.section __ex_table,"a";\
-	.align 4;	\
-	.long 1b,4b;	\
-	.long 2b,5b;	\
-.previous
-
-#define GET_CURRENT(reg) \
-	movl %esp, reg; \
-	andl $-8192, reg;
-
-ENTRY(lcall7)
-	pushfl			# We get a different stack layout with call gates,
-	pushl %eax		# which has to be cleaned up later..
-	SAVE_ALL
-	movl EIP(%esp),%eax	# due to call gates, this is eflags, not eip..
-	movl CS(%esp),%edx	# this is eip..
-	movl EFLAGS(%esp),%ecx	# and this is cs..
-	movl %eax,EFLAGS(%esp)	#
-	movl %edx,EIP(%esp)	# Now we move them to their "normal" places
-	movl %ecx,CS(%esp)	#
-	movl %esp,%ebx
-	pushl %ebx
-	andl $-8192,%ebx	# GET_CURRENT
-	movl exec_domain(%ebx),%edx	# Get the execution domain
-	movl 4(%edx),%edx	# Get the lcall7 handler for the domain
-	call *%edx
-	popl %eax
-	jmp ret_from_sys_call
-
-
-#ifdef __SMP__
-	ALIGN
-	.globl	ret_from_smpfork
-ret_from_smpfork:
-	GET_CURRENT(%ebx)
-	btrl	$0, SYMBOL_NAME(scheduler_lock)
-	jmp	ret_from_sys_call
-#endif /* __SMP__ */
-
-/*
- * Return to user mode is not as complex as all this looks,
- * but we want the default path for a system call return to
- * go as quickly as possible which is why some of this is
- * less clear than it otherwise should be.
- */
-
-ENTRY(system_call)
-	pushl %eax			# save orig_eax
-	SAVE_ALL
-	GET_CURRENT(%ebx)
-	cmpl $(NR_syscalls),%eax
-	jae badsys
-	testb $0x20,flags(%ebx)		# PF_TRACESYS
-	jne tracesys
-	call *SYMBOL_NAME(sys_call_table)(,%eax,4)
-	movl %eax,EAX(%esp)		# save the return value
-	ALIGN
-	.globl ret_from_sys_call
-	.globl ret_from_intr
-ret_from_sys_call:
-	movl SYMBOL_NAME(bh_mask),%eax
-	andl SYMBOL_NAME(bh_active),%eax
-	jne handle_bottom_half
-ret_with_reschedule:
-	cmpl $0,need_resched(%ebx)
-	jne reschedule
-	cmpl $0,sigpending(%ebx)
-	jne signal_return
-	RESTORE_ALL
-	ALIGN
-signal_return:
-	testl $(VM_MASK),EFLAGS(%esp)
-	pushl %esp
-	jne v86_signal_return
-	pushl $0
-	call SYMBOL_NAME(do_signal)
-	addl $8,%esp
-	RESTORE_ALL
-	ALIGN
-v86_signal_return:
-	call SYMBOL_NAME(save_v86_state)
-	movl %eax,%esp
-	pushl %eax
-	pushl $0
-	call SYMBOL_NAME(do_signal)
-	addl $8,%esp
-	RESTORE_ALL
-	ALIGN
-tracesys:
-	movl $-ENOSYS,EAX(%esp)
-	call SYMBOL_NAME(syscall_trace)
-	movl ORIG_EAX(%esp),%eax
-	call *SYMBOL_NAME(sys_call_table)(,%eax,4)
-	movl %eax,EAX(%esp)		# save the return value
-	call SYMBOL_NAME(syscall_trace)
-	jmp ret_from_sys_call
-badsys:
-	movl $-ENOSYS,EAX(%esp)
-	jmp ret_from_sys_call
-
-	ALIGN
-ret_from_exception:
-	movl SYMBOL_NAME(bh_mask),%eax
-	andl SYMBOL_NAME(bh_active),%eax
-	jne handle_bottom_half
-	ALIGN
-ret_from_intr:
-	GET_CURRENT(%ebx)
-	movl EFLAGS(%esp),%eax		# mix EFLAGS and CS
-	movb CS(%esp),%al
-	testl $(VM_MASK | 3),%eax	# return to VM86 mode or non-supervisor?
-	jne ret_with_reschedule
-	RESTORE_ALL
-
-	ALIGN
-handle_bottom_half:
-	pushl $ret_from_intr
-	jmp SYMBOL_NAME(do_bottom_half)
-
-	ALIGN
-reschedule:
-	pushl $ret_from_sys_call
-	jmp SYMBOL_NAME(schedule)    # test
-
-
-ENTRY(divide_error)
-	pushl $0		# no error code
-	pushl $ SYMBOL_NAME(do_divide_error)
-	ALIGN
-error_code:
-	pushl %ds
-	pushl %eax
-	xorl %eax,%eax
-	pushl %ebp
-	pushl %edi
-	pushl %esi
-	pushl %edx
-	decl %eax			# eax = -1
-	pushl %ecx
-	pushl %ebx
-#if 1
-	xorl %ecx,%ecx			# zero ecx
-	cld
-	mov %es,%cx			# get the lower order bits of es
-#else
-	cld
-# Some older processors leave the top 16 bits of the 32 bit destination
-# register undefined, rather than zeroed in the following instruction.
-# This won't matter when restoring or loading a segment register from the
-# stack.  It may be a problem if any code reads the full 32 bit value.
-# dosemu? kernel?  Would somebody like to verify that this way is really OK?
-	movl %es,%cx
-#endif
-	xchgl %eax, ORIG_EAX(%esp)	# orig_eax (get the error code. )
-	movl %esp,%edx
-	xchgl %ecx, ES(%esp)		# get the address and save es.
-	pushl %eax			# push the error code
-	pushl %edx
-	movl $(__KERNEL_DS),%edx
-	movl %dx,%ds
-	movl %dx,%es
-	GET_CURRENT(%ebx)
-	call *%ecx
-	addl $8,%esp
-	jmp ret_from_exception
-
-ENTRY(coprocessor_error)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_coprocessor_error)
-	jmp error_code
-
-ENTRY(device_not_available)
-	pushl $-1		# mark this as an int
-	SAVE_ALL
-	GET_CURRENT(%ebx)
-	pushl $ret_from_exception
-	movl %cr0,%eax
-	testl $0x4,%eax			# EM (math emulation bit)
-	je SYMBOL_NAME(math_state_restore)
-	pushl $0		# temporary storage for ORIG_EIP
-	call  SYMBOL_NAME(math_emulate)
-	addl $4,%esp
-	ret
-
-ENTRY(debug)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_debug)
-	jmp error_code
-
-ENTRY(nmi)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_nmi)
-	jmp error_code
-
-ENTRY(int3)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_int3)
-	jmp error_code
-
-ENTRY(overflow)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_overflow)
-	jmp error_code
-
-ENTRY(bounds)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_bounds)
-	jmp error_code
-
-ENTRY(invalid_op)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_invalid_op)
-	jmp error_code
-
-ENTRY(coprocessor_segment_overrun)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_coprocessor_segment_overrun)
-	jmp error_code
-
-ENTRY(reserved)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_reserved)
-	jmp error_code
-
-ENTRY(double_fault)
-	pushl $ SYMBOL_NAME(do_double_fault)
-	jmp error_code
-
-ENTRY(invalid_TSS)
-	pushl $ SYMBOL_NAME(do_invalid_TSS)
-	jmp error_code
-
-ENTRY(segment_not_present)
-	pushl $ SYMBOL_NAME(do_segment_not_present)
-	jmp error_code
-
-ENTRY(stack_segment)
-	pushl $ SYMBOL_NAME(do_stack_segment)
-	jmp error_code
-
-ENTRY(general_protection)
-	pushl $ SYMBOL_NAME(do_general_protection)
-	jmp error_code
-
-ENTRY(alignment_check)
-	pushl $ SYMBOL_NAME(do_alignment_check)
-	jmp error_code
-
-ENTRY(page_fault)
-	pushl $ SYMBOL_NAME(do_page_fault)
-	jmp error_code
-
-ENTRY(spurious_interrupt_bug)
-	pushl $0
-	pushl $ SYMBOL_NAME(do_spurious_interrupt_bug)
-	jmp error_code
-
-.data
-ENTRY(sys_call_table)
-	.long SYMBOL_NAME(sys_setup)		/* 0 */
-	.long SYMBOL_NAME(sys_exit)
-	.long SYMBOL_NAME(sys_fork)
-	.long SYMBOL_NAME(sys_read)
-	.long SYMBOL_NAME(sys_write)
-	.long SYMBOL_NAME(sys_open)		/* 5 */
-	.long SYMBOL_NAME(sys_close)
-	.long SYMBOL_NAME(sys_waitpid)
-	.long SYMBOL_NAME(sys_creat)
-	.long SYMBOL_NAME(sys_link)
-	.long SYMBOL_NAME(sys_unlink)		/* 10 */
-	.long SYMBOL_NAME(sys_execve)
-	.long SYMBOL_NAME(sys_chdir)
-	.long SYMBOL_NAME(sys_time)
-	.long SYMBOL_NAME(sys_mknod)
-	.long SYMBOL_NAME(sys_chmod)		/* 15 */
-	.long SYMBOL_NAME(sys_lchown)
-	.long SYMBOL_NAME(sys_ni_syscall)				/* old break syscall holder */
-	.long SYMBOL_NAME(sys_stat)
-	.long SYMBOL_NAME(sys_lseek)
-	.long SYMBOL_NAME(sys_getpid)		/* 20 */
-	.long SYMBOL_NAME(sys_mount)
-	.long SYMBOL_NAME(sys_umount)
-	.long SYMBOL_NAME(sys_setuid)
-	.long SYMBOL_NAME(sys_getuid)
-	.long SYMBOL_NAME(sys_stime)		/* 25 */
-	.long SYMBOL_NAME(sys_ptrace)
-	.long SYMBOL_NAME(sys_alarm)
-	.long SYMBOL_NAME(sys_fstat)
-	.long SYMBOL_NAME(sys_pause)
-	.long SYMBOL_NAME(sys_utime)		/* 30 */
-	.long SYMBOL_NAME(sys_ni_syscall)				/* old stty syscall holder */
-	.long SYMBOL_NAME(sys_ni_syscall)				/* old gtty syscall holder */
-	.long SYMBOL_NAME(sys_access)
-	.long SYMBOL_NAME(sys_nice)
-	.long SYMBOL_NAME(sys_ni_syscall)	/* 35 */		/* old ftime syscall holder */
-	.long SYMBOL_NAME(sys_sync)
-	.long SYMBOL_NAME(sys_kill)
-	.long SYMBOL_NAME(sys_rename)
-	.long SYMBOL_NAME(sys_mkdir)
-	.long SYMBOL_NAME(sys_rmdir)		/* 40 */
-	.long SYMBOL_NAME(sys_dup)
-	.long SYMBOL_NAME(sys_pipe)
-	.long SYMBOL_NAME(sys_times)
-	.long SYMBOL_NAME(sys_ni_syscall)				/* old prof syscall holder */
-	.long SYMBOL_NAME(sys_brk)		/* 45 */
-	.long SYMBOL_NAME(sys_setgid)
-	.long SYMBOL_NAME(sys_getgid)
-	.long SYMBOL_NAME(sys_signal)
-	.long SYMBOL_NAME(sys_geteuid)
-	.long SYMBOL_NAME(sys_getegid)		/* 50 */
-	.long SYMBOL_NAME(sys_acct)
-	.long SYMBOL_NAME(sys_ni_syscall)				/* old phys syscall holder */
-	.long SYMBOL_NAME(sys_ni_syscall)				/* old lock syscall holder */
-	.long SYMBOL_NAME(sys_ioctl)
-	.long SYMBOL_NAME(sys_fcntl)		/* 55 */
-	.long SYMBOL_NAME(sys_ni_syscall)				/* old mpx syscall holder */
-	.long SYMBOL_NAME(sys_setpgid)
-	.long SYMBOL_NAME(sys_ni_syscall)				/* old ulimit syscall holder */
-	.long SYMBOL_NAME(sys_olduname)
-	.long SYMBOL_NAME(sys_umask)		/* 60 */
-	.long SYMBOL_NAME(sys_chroot)
-	.long SYMBOL_NAME(sys_ustat)
-	.long SYMBOL_NAME(sys_dup2)
-	.long SYMBOL_NAME(sys_getppid)
-	.long SYMBOL_NAME(sys_getpgrp)		/* 65 */
-	.long SYMBOL_NAME(sys_setsid)
-	.long SYMBOL_NAME(sys_sigaction)
-	.long SYMBOL_NAME(sys_sgetmask)
-	.long SYMBOL_NAME(sys_ssetmask)
-	.long SYMBOL_NAME(sys_setreuid)		/* 70 */
-	.long SYMBOL_NAME(sys_setregid)
-	.long SYMBOL_NAME(sys_sigsuspend)
-	.long SYMBOL_NAME(sys_sigpending)
-	.long SYMBOL_NAME(sys_sethostname)
-	.long SYMBOL_NAME(sys_setrlimit)	/* 75 */
-	.long SYMBOL_NAME(sys_getrlimit)
-	.long SYMBOL_NAME(sys_getrusage)
-	.long SYMBOL_NAME(sys_gettimeofday)
-	.long SYMBOL_NAME(sys_settimeofday)
-	.long SYMBOL_NAME(sys_getgroups)	/* 80 */
-	.long SYMBOL_NAME(sys_setgroups)
-	.long SYMBOL_NAME(old_select)
-	.long SYMBOL_NAME(sys_symlink)
-	.long SYMBOL_NAME(sys_lstat)
-	.long SYMBOL_NAME(sys_readlink)		/* 85 */
-	.long SYMBOL_NAME(sys_uselib)
-	.long SYMBOL_NAME(sys_swapon)
-	.long SYMBOL_NAME(sys_reboot)
-	.long SYMBOL_NAME(old_readdir)
-	.long SYMBOL_NAME(old_mmap)		/* 90 */
-	.long SYMBOL_NAME(sys_munmap)
-	.long SYMBOL_NAME(sys_truncate)
-	.long SYMBOL_NAME(sys_ftruncate)
-	.long SYMBOL_NAME(sys_fchmod)
-	.long SYMBOL_NAME(sys_fchown)		/* 95 */
-	.long SYMBOL_NAME(sys_getpriority)
-	.long SYMBOL_NAME(sys_setpriority)
-	.long SYMBOL_NAME(sys_ni_syscall)				/* old profil syscall holder */
-	.long SYMBOL_NAME(sys_statfs)
-	.long SYMBOL_NAME(sys_fstatfs)		/* 100 */
-	.long SYMBOL_NAME(sys_ioperm)
-	.long SYMBOL_NAME(sys_socketcall)
-	.long SYMBOL_NAME(sys_syslog)
-	.long SYMBOL_NAME(sys_setitimer)
-	.long SYMBOL_NAME(sys_getitimer)	/* 105 */
-	.long SYMBOL_NAME(sys_newstat)
-	.long SYMBOL_NAME(sys_newlstat)
-	.long SYMBOL_NAME(sys_newfstat)
-	.long SYMBOL_NAME(sys_uname)
-	.long SYMBOL_NAME(sys_iopl)		/* 110 */
-	.long SYMBOL_NAME(sys_vhangup)
-	.long SYMBOL_NAME(sys_idle)
-	.long SYMBOL_NAME(sys_vm86old)
-	.long SYMBOL_NAME(sys_wait4)
-	.long SYMBOL_NAME(sys_swapoff)		/* 115 */
-	.long SYMBOL_NAME(sys_sysinfo)
-	.long SYMBOL_NAME(sys_ipc)
-	.long SYMBOL_NAME(sys_fsync)
-	.long SYMBOL_NAME(sys_sigreturn)
-	.long SYMBOL_NAME(sys_clone)		/* 120 */
-	.long SYMBOL_NAME(sys_setdomainname)
-	.long SYMBOL_NAME(sys_newuname)
-	.long SYMBOL_NAME(sys_modify_ldt)
-	.long SYMBOL_NAME(sys_adjtimex)
-	.long SYMBOL_NAME(sys_mprotect)		/* 125 */
-	.long SYMBOL_NAME(sys_sigprocmask)
-	.long SYMBOL_NAME(sys_create_module)
-	.long SYMBOL_NAME(sys_init_module)
-	.long SYMBOL_NAME(sys_delete_module)
-	.long SYMBOL_NAME(sys_get_kernel_syms)	/* 130 */
-	.long SYMBOL_NAME(sys_quotactl)
-	.long SYMBOL_NAME(sys_getpgid)
-	.long SYMBOL_NAME(sys_fchdir)
-	.long SYMBOL_NAME(sys_bdflush)
-	.long SYMBOL_NAME(sys_sysfs)		/* 135 */
-	.long SYMBOL_NAME(sys_personality)
-	.long SYMBOL_NAME(sys_ni_syscall)	/* for afs_syscall */
-	.long SYMBOL_NAME(sys_setfsuid)
-	.long SYMBOL_NAME(sys_setfsgid)
-	.long SYMBOL_NAME(sys_llseek)		/* 140 */
-	.long SYMBOL_NAME(sys_getdents)
-	.long SYMBOL_NAME(sys_select)
-	.long SYMBOL_NAME(sys_flock)
-	.long SYMBOL_NAME(sys_msync)
-	.long SYMBOL_NAME(sys_readv)		/* 145 */
-	.long SYMBOL_NAME(sys_writev)
-	.long SYMBOL_NAME(sys_getsid)
-	.long SYMBOL_NAME(sys_fdatasync)
-	.long SYMBOL_NAME(sys_sysctl)
-	.long SYMBOL_NAME(sys_mlock)		/* 150 */
-	.long SYMBOL_NAME(sys_munlock)
-	.long SYMBOL_NAME(sys_mlockall)
-	.long SYMBOL_NAME(sys_munlockall)
-	.long SYMBOL_NAME(sys_sched_setparam)
-	.long SYMBOL_NAME(sys_sched_getparam)   /* 155 */
-	.long SYMBOL_NAME(sys_sched_setscheduler)
-	.long SYMBOL_NAME(sys_sched_getscheduler)
-	.long SYMBOL_NAME(sys_sched_yield)
-	.long SYMBOL_NAME(sys_sched_get_priority_max)
-	.long SYMBOL_NAME(sys_sched_get_priority_min)  /* 160 */
-	.long SYMBOL_NAME(sys_sched_rr_get_interval)
-	.long SYMBOL_NAME(sys_nanosleep)
-	.long SYMBOL_NAME(sys_mremap)
-	.long SYMBOL_NAME(sys_setresuid)
-	.long SYMBOL_NAME(sys_getresuid)	/* 165 */
-	.long SYMBOL_NAME(sys_vm86)
-	.long SYMBOL_NAME(sys_query_module)
-	.long SYMBOL_NAME(sys_poll)
-	.long SYMBOL_NAME(sys_nfsservctl)
-	.long SYMBOL_NAME(sys_setresgid)	/* 170 */
-	.long SYMBOL_NAME(sys_getresgid)
-	.long SYMBOL_NAME(sys_prctl)
-	.long SYMBOL_NAME(sys_rt_sigreturn)
-	.long SYMBOL_NAME(sys_rt_sigaction)
-	.long SYMBOL_NAME(sys_rt_sigprocmask)	/* 175 */
-	.long SYMBOL_NAME(sys_rt_sigpending)
-	.long SYMBOL_NAME(sys_rt_sigtimedwait)
-	.long SYMBOL_NAME(sys_rt_sigqueueinfo)
-	.long SYMBOL_NAME(sys_rt_sigsuspend)
-	.long SYMBOL_NAME(sys_pread)		/* 180 */
-	.long SYMBOL_NAME(sys_pwrite)
-	.long SYMBOL_NAME(sys_chown)
-	.long SYMBOL_NAME(sys_getcwd)
-	.long SYMBOL_NAME(sys_capget)
-	.long SYMBOL_NAME(sys_capset)           /* 185 */
-	.long SYMBOL_NAME(sys_sigaltstack)
-	.long SYMBOL_NAME(sys_sendfile)
-	.long SYMBOL_NAME(sys_ni_syscall)		/* streams1 */
-	.long SYMBOL_NAME(sys_ni_syscall)		/* streams2 */
-	.long SYMBOL_NAME(sys_table)		/* 190 */
-	
-	.rept NR_syscalls-190
-		.long SYMBOL_NAME(sys_ni_syscall)
-	.endr

kernel/table21/main.c

@@ -1,61 +0,0 @@
-/*
- * linux/table/table_impl.c
- * Copyright (C) 1998 Martin Baulig
- */
-
-#include <linux/types.h>
-#include <linux/errno.h>
-#include <linux/sched.h>
-#include <linux/kernel.h>
-#include <linux/kernel_stat.h>
-#include <linux/tty.h>
-#include <linux/user.h>
-#include <linux/a.out.h>
-#include <linux/string.h>
-#include <linux/mman.h>
-#include <linux/proc_fs.h>
-#include <linux/ioport.h>
-#include <linux/config.h>
-#include <linux/mm.h>
-#include <linux/pagemap.h>
-#include <linux/swap.h>
-#include <linux/slab.h>
-#include <linux/smp.h>
-#include <linux/signal.h>
-
-#include <asm/uaccess.h>
-#include <asm/pgtable.h>
-#include <asm/io.h>
-
-#include <linux/module.h>
-#include <linux/table.h>
-
-#include "version.h"
-
-extern void scheduling_functions_start_here(void);
-extern void scheduling_functions_end_here(void);
-
-int (*table_function_ptr) (int, union table *, const void *) = 0;
-
-EXPORT_SYMBOL(table_function_ptr);
-
-EXPORT_SYMBOL(nr_running);
-EXPORT_SYMBOL(pidhash);
-EXPORT_SYMBOL(task);
-EXPORT_SYMBOL(si_swapinfo);
-EXPORT_SYMBOL(scheduling_functions_start_here);
-EXPORT_SYMBOL(scheduling_functions_end_here);
-EXPORT_SYMBOL(avenrun);
-EXPORT_SYMBOL(nr_tasks);
-EXPORT_SYMBOL(last_pid);
-EXPORT_SYMBOL(page_cache_size);
-EXPORT_SYMBOL(init_mm);
-
-asmlinkage int
-sys_table (int type, union table *buf, const void *param)
-{
-	if (table_function_ptr == 0)
-		return -ENOSYS;
-
-	return (*table_function_ptr) (type, buf, param);
-}

kernel/table21/module.c

@@ -1,607 +0,0 @@
-/*
- * linux/table/table_impl.c
- * Copyright (C) 1998 Martin Baulig
- */
-
-#include <linux/types.h>
-#include <linux/errno.h>
-#include <linux/sched.h>
-#include <linux/kernel.h>
-#include <linux/kernel_stat.h>
-#include <linux/tty.h>
-#include <linux/user.h>
-#include <linux/a.out.h>
-#include <linux/string.h>
-#include <linux/mman.h>
-#include <linux/proc_fs.h>
-#include <linux/ioport.h>
-#include <linux/config.h>
-#include <linux/mm.h>
-#include <linux/pagemap.h>
-#include <linux/swap.h>
-#include <linux/slab.h>
-#include <linux/smp.h>
-#include <linux/signal.h>
-
-#include <asm/uaccess.h>
-#include <asm/pgtable.h>
-#include <asm/io.h>
-
-#include <linux/module.h>
-#include <linux/table.h>
-
-#include "version.h"
-
-extern int (*table_function_ptr) (int, union table *, const void *);
-
-int table_fkt (int, union table *, const void *);
-
-EXPORT_NO_SYMBOLS;
-
-int
-init_module(void)
-{
-	printk ("init_module () = %p - %d, %d\n",
-		table_fkt, sizeof (union table), sizeof (sigset_t));
-	table_function_ptr = table_fkt;
-	return 0;
-}
-
-void
-cleanup_module(void)
-{
-	table_function_ptr = 0;
-}
-
-#define LOAD_INT(x) ((x) >> FSHIFT)
-#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
-
-#ifdef CONFIG_DEBUG_MALLOC
-int get_malloc(char * buffer);
-#endif
-
-static void collect_sigign_sigcatch(struct task_struct *p, sigset_t *ign,
-				    sigset_t *catch)
-{
-	struct k_sigaction *k;
-	int i;
-
-	sigemptyset(ign);
-	sigemptyset(catch);
-
-#if 0
-	printk ("collect_sigign_sigcatch: %p - %p\n",
-		p, p->sig);
-#endif
-
-	if (p->sig) {
-		k = p->sig->action;
-		for (i = 1; i <= _NSIG; ++i, ++k) {
-#if 0
-			printk ("signal: %d - %p (%p, %p)\n",
-				i, k->sa.sa_handler, SIG_IGN, SIG_DFL);
-#endif
-			if (k->sa.sa_handler == SIG_IGN)
-				sigaddset(ign, i);
-			else if (k->sa.sa_handler != SIG_DFL)
-				sigaddset(catch, i);
-		}
-	}
-}
-
-/*
- * These bracket the sleeping functions..
- */
-extern void scheduling_functions_start_here(void);
-extern void scheduling_functions_end_here(void);
-#define first_sched	((unsigned long) scheduling_functions_start_here)
-#define last_sched	((unsigned long) scheduling_functions_end_here)
-
-static unsigned long get_wchan(struct task_struct *p)
-{
-	if (!p || p == current || p->state == TASK_RUNNING)
-		return 0;
-#if defined(__i386__)
-	{
-		unsigned long ebp, eip;
-		unsigned long stack_page;
-		int count = 0;
-
-		stack_page = 4096 + (unsigned long)p;
-		if (!stack_page)
-			return 0;
-		ebp = p->tss.ebp;
-		do {
-			if (ebp < stack_page || ebp >= 4092+stack_page)
-				return 0;
-			eip = *(unsigned long *) (ebp+4);
-			if (eip < first_sched || eip >= last_sched)
-				return eip;
-			ebp = *(unsigned long *) ebp;
-		} while (count++ < 16);
-	}
-#elif defined(__alpha__)
-	/*
-	 * This one depends on the frame size of schedule().  Do a
-	 * "disass schedule" in gdb to find the frame size.  Also, the
-	 * code assumes that sleep_on() follows immediately after
-	 * interruptible_sleep_on() and that add_timer() follows
-	 * immediately after interruptible_sleep().  Ugly, isn't it?
-	 * Maybe adding a wchan field to task_struct would be better,
-	 * after all...
-	 */
-	{
-	    unsigned long schedule_frame;
-	    unsigned long pc;
-
-	    pc = thread_saved_pc(&p->tss);
-	    if (pc >= first_sched && pc < last_sched) {
-		schedule_frame = ((unsigned long *)p->tss.ksp)[6];
-		return ((unsigned long *)schedule_frame)[12];
-	    }
-	    return pc;
-	}	
-#elif defined(__mc68000__)
-	{
-	    unsigned long fp, pc;
-	    unsigned long stack_page;
-	    int count = 0;
-	    extern int sys_pause (void);
-
-	    stack_page = p->kernel_stack_page;
-	    if (!stack_page)
-		    return 0;
-	    fp = ((struct switch_stack *)p->tss.ksp)->a6;
-	    do {
-		    if (fp < stack_page || fp >= 4088+stack_page)
-			    return 0;
-		    pc = ((unsigned long *)fp)[1];
-		/* FIXME: This depends on the order of these functions. */
-		    if (pc < first_sched || pc >= last_sched)
-		      return pc;
-		    fp = *(unsigned long *) fp;
-	    } while (count++ < 16);
-	}
-#elif defined(__powerpc__)
-	return (p->tss.wchan);
-#elif defined (CONFIG_ARM)
-	{
-		unsigned long fp, lr;
-		unsigned long stack_page;
-		int count = 0;
-
-		stack_page = 4096 + (unsigned long)p;
-		fp = get_css_fp (&p->tss);
-		do {
-			if (fp < stack_page || fp > 4092+stack_page)
-				return 0;
-			lr = pc_pointer (((unsigned long *)fp)[-1]);
-			if (lr < first_sched || lr > last_sched)
-				return lr;
-			fp = *(unsigned long *) (fp - 12);
-		} while (count ++ < 16);
-	}
-#endif
-	return 0;
-}
-
-#if defined(__i386__)
-# define KSTK_EIP(tsk)	(((unsigned long *)(4096+(unsigned long)(tsk)))[1019])
-# define KSTK_ESP(tsk)	(((unsigned long *)(4096+(unsigned long)(tsk)))[1022])
-#elif defined(__alpha__)
-  /*
-   * See arch/alpha/kernel/ptrace.c for details.
-   */
-# define PT_REG(reg)		(PAGE_SIZE - sizeof(struct pt_regs)	\
-				 + (long)&((struct pt_regs *)0)->reg)
-# define KSTK_EIP(tsk) \
-    (*(unsigned long *)(PT_REG(pc) + PAGE_SIZE + (unsigned long)(tsk)))
-# define KSTK_ESP(tsk)	((tsk) == current ? rdusp() : (tsk)->tss.usp)
-#elif defined(CONFIG_ARM)
-# define KSTK_EIP(tsk)	(((unsigned long *)(4096+(unsigned long)(tsk)))[1022])
-# define KSTK_ESP(tsk)	(((unsigned long *)(4096+(unsigned long)(tsk)))[1020])
-#elif defined(__mc68000__)
-#define	KSTK_EIP(tsk)	\
-    ({			\
-	unsigned long eip = 0;	 \
- 	if ((tsk)->tss.esp0 > PAGE_SIZE && \
-	    MAP_NR((tsk)->tss.esp0) < max_mapnr) \
-	      eip = ((struct pt_regs *) (tsk)->tss.esp0)->pc;	 \
-        eip; })
-#define	KSTK_ESP(tsk)	((tsk) == current ? rdusp() : (tsk)->tss.usp)
-#elif defined(__powerpc__)
-#define KSTK_EIP(tsk)	((tsk)->tss.regs->nip)
-#define KSTK_ESP(tsk)	((tsk)->tss.regs->gpr[1])
-#elif defined (__sparc_v9__)
-# define KSTK_EIP(tsk)  ((tsk)->tss.kregs->tpc)
-# define KSTK_ESP(tsk)  ((tsk)->tss.kregs->u_regs[UREG_FP])
-#elif defined(__sparc__)
-# define KSTK_EIP(tsk)  ((tsk)->tss.kregs->pc)
-# define KSTK_ESP(tsk)  ((tsk)->tss.kregs->u_regs[UREG_FP])
-#endif
-
-/* Gcc optimizes away "strlen(x)" for constant x */
-#define ADDBUF(buffer, string) \
-do { memcpy(buffer, string, strlen(string)); \
-     buffer += strlen(string); } while (0)
-
-static inline void statm_pte_range(pmd_t * pmd, unsigned long address, unsigned long size,
-	int * pages, int * shared, int * dirty, int * total)
-{
-	pte_t * pte;
-	unsigned long end;
-
-	if (pmd_none(*pmd))
-		return;
-	if (pmd_bad(*pmd)) {
-		printk("statm_pte_range: bad pmd (%08lx)\n", pmd_val(*pmd));
-		pmd_clear(pmd);
-		return;
-	}
-	pte = pte_offset(pmd, address);
-	address &= ~PMD_MASK;
-	end = address + size;
-	if (end > PMD_SIZE)
-		end = PMD_SIZE;
-	do {
-		pte_t page = *pte;
-
-		address += PAGE_SIZE;
-		pte++;
-		if (pte_none(page))
-			continue;
-		++*total;
-		if (!pte_present(page))
-			continue;
-		++*pages;
-		if (pte_dirty(page))
-			++*dirty;
-		if (MAP_NR(pte_page(page)) >= max_mapnr)
-			continue;
-		if (atomic_read(&mem_map[MAP_NR(pte_page(page))].count) > 1)
-			++*shared;
-	} while (address < end);
-}
-
-static inline void statm_pmd_range(pgd_t * pgd, unsigned long address, unsigned long size,
-	int * pages, int * shared, int * dirty, int * total)
-{
-	pmd_t * pmd;
-	unsigned long end;
-
-	if (pgd_none(*pgd))
-		return;
-	if (pgd_bad(*pgd)) {
-		printk("statm_pmd_range: bad pgd (%08lx)\n", pgd_val(*pgd));
-		pgd_clear(pgd);
-		return;
-	}
-	pmd = pmd_offset(pgd, address);
-	address &= ~PGDIR_MASK;
-	end = address + size;
-	if (end > PGDIR_SIZE)
-		end = PGDIR_SIZE;
-	do {
-		statm_pte_range(pmd, address, end - address, pages, shared, dirty, total);
-		address = (address + PMD_SIZE) & PMD_MASK;
-		pmd++;
-	} while (address < end);
-}
-
-static void statm_pgd_range(pgd_t * pgd, unsigned long address, unsigned long end,
-	int * pages, int * shared, int * dirty, int * total)
-{
-	while (address < end) {
-		statm_pmd_range(pgd, address, end - address, pages, shared, dirty, total);
-		address = (address + PGDIR_SIZE) & PGDIR_MASK;
-		pgd++;
-	}
-}
-
-int
-table_fkt (int type, union table *buf, const void *param)
-{
-	union table tbl;
-	struct sysinfo i;
-	struct task_struct *tsk = NULL;
-	struct proclist_args plistargs;
-	int index, tindex, err, tty;
-	sigset_t sigign, sigcatch;
-	pid_t pid;
-
-	if (type == TABLE_VERSION)
-		return _TABLE_VERSION;
-
-	if (!buf)
-		return -EFAULT;
-
-	memset (&tbl, 0, sizeof (union table));
-
-	/* For TABLE_PROC_*, read pid and get task_struct */
-
-	switch (type) {
-	case TABLE_PROC_UID:
-	case TABLE_PROC_MEM:
-	case TABLE_PROC_SEGMENT:
-	case TABLE_PROC_TIME:
-	case TABLE_PROC_STATE:
-	case TABLE_PROC_SIGNAL:
-	case TABLE_PROC_KERNEL:
-		err = verify_area (VERIFY_READ, param, sizeof (pid_t));
-		if (err)
-			return err;
-		copy_from_user (&pid, param, sizeof (pid_t));
-
-		read_lock (&tasklist_lock);
-		tsk = find_task_by_pid (pid);
-		/* FIXME!! This should be done after the last use */
-		read_unlock(&tasklist_lock);
-
-		if (tsk == NULL)
-			return -ESRCH;
-		break;
-	case TABLE_PROCLIST:
-		err = verify_area (VERIFY_READ, param,
-				   sizeof (struct proclist_args));
-		if (err)
-			return err;
-		copy_from_user (&plistargs, param,
-				sizeof (struct proclist_args));
-		break;
-	}
-
-	/* Main function dispatcher */
-
-	switch (type) {
-	case TABLE_PROCLIST:
-		tsk = task [0];
-		read_lock (&tasklist_lock);
-		for (index = tindex = 0; index < nr_tasks;
-		     index++, tsk = tsk->next_task) {
-			if (tsk->pid == 0) continue;
-			switch (plistargs.which & TABLE_KERN_PROC_MASK) {
-			case TABLE_KERN_PROC_PID:
-				if (tsk->pid != plistargs.arg) continue;
-				break;
-			case TABLE_KERN_PROC_PGRP:
-				if (tsk->pgrp != plistargs.arg) continue;
-				break;
-			case TABLE_KERN_PROC_SESSION:
-				if (tsk->session != plistargs.arg) continue;
-			case TABLE_KERN_PROC_TTY:
-				tty = tsk->tty ?
-					kdev_t_to_nr (tsk->tty->device) : 0;
-				if (tty != plistargs.arg) continue;
-				break;
-			case TABLE_KERN_PROC_UID:
-				if (tsk->uid != plistargs.arg) continue;
-				break;
-			case TABLE_KERN_PROC_RUID:
-				if (tsk->euid != plistargs.arg) continue;
-				break;
-			}
-
-			if ((plistargs.which & TABLE_EXCLUDE_IDLE) &&
-			    (tsk->state != 0))
-				continue;
-
-			if ((plistargs.which & TABLE_EXCLUDE_NOTTY) &&
-			    (tsk->tty == NULL))
-				continue;
-			
-			tbl.proclist.pids [tindex++] = tsk->pid;
-		}
-		tbl.proclist.nr_running = nr_running;
-		tbl.proclist.last_pid = last_pid;
-		tbl.proclist.nr_tasks = tindex;
-		read_unlock(&tasklist_lock);
-		break;
-	case TABLE_CPU:
-		tbl.cpu.total = jiffies;    
-		tbl.cpu.user  = kstat.cpu_user;
-		tbl.cpu.nice  = kstat.cpu_nice;
-		tbl.cpu.sys   = kstat.cpu_system;
-		tbl.cpu.idle  = tbl.cpu.total -
-			(tbl.cpu.user + tbl.cpu.nice + tbl.cpu.sys);
-		tbl.cpu.frequency = HZ;
-		break;
-	case TABLE_MEM:
-		si_meminfo (&i);
-		tbl.mem.total  = i.totalram;
-		tbl.mem.used   = i.totalram - i.freeram;
-		tbl.mem.free   = i.freeram;
-		tbl.mem.shared = i.sharedram;
-		tbl.mem.buffer = i.bufferram;
-		tbl.mem.cached = page_cache_size << PAGE_SHIFT;
-		break;
-	case TABLE_SWAP:
-		si_swapinfo (&i);
-		tbl.swap.total = i.totalswap;
-		tbl.swap.used  = i.totalswap - i.freeswap;
-		tbl.swap.free  = i.freeswap;
-		break;
-	case TABLE_LOADAVG:
-		tbl.loadavg.loadavg [0] = (double) avenrun [0] / (1 << FSHIFT);
-		tbl.loadavg.loadavg [1] = (double) avenrun [1] / (1 << FSHIFT);
-		tbl.loadavg.loadavg [2] = (double) avenrun [2] / (1 << FSHIFT);
-		tbl.loadavg.nr_running = nr_running;
-		tbl.loadavg.nr_tasks = nr_tasks;
-		tbl.loadavg.last_pid = last_pid;
-		break;
-	case TABLE_UPTIME:
-		tbl.uptime.uptime = jiffies;
-		tbl.uptime.idle   = task[0]->times.tms_utime +
-			task[0]->times.tms_stime;
-		break;
-	case TABLE_PROC_STATE:
-		tbl.proc_state.uid = tsk->uid;
-		tbl.proc_state.gid = tsk->gid;
-		tbl.proc_state.state = tsk->state;
-		tbl.proc_state.flags = tsk->flags;
-		memcpy (tbl.proc_state.comm, tsk->comm,
-			sizeof (tbl.proc_state.comm));
-		break;
-	case TABLE_PROC_UID:
-		tbl.proc_uid.uid = tsk->uid;
-		tbl.proc_uid.euid = tsk->euid;
-		tbl.proc_uid.suid = tsk->suid;
-		tbl.proc_uid.fsuid = tsk->fsuid;
-		
-		tbl.proc_uid.gid = tsk->gid;
-		tbl.proc_uid.egid = tsk->egid;
-		tbl.proc_uid.sgid = tsk->sgid;
-		tbl.proc_uid.fsgid = tsk->fsgid;
-		
-		tbl.proc_uid.pid = tsk->pid;
-		tbl.proc_uid.pgrp = tsk->pgrp;
-		tbl.proc_uid.ppid = tsk->p_pptr->pid;
-		
-		tbl.proc_uid.session = tsk->session;
-	        tbl.proc_uid.tty = tsk->tty ?
-			kdev_t_to_nr (tsk->tty->device) : 0;
-		tbl.proc_uid.tpgid = tsk->tty ? tsk->tty->pgrp : -1;
-		
-		tbl.proc_uid.priority = tsk->priority;
-		tbl.proc_uid.counter = tsk->counter;
-		tbl.proc_uid.def_priority = DEF_PRIORITY;
-		break;
-	case TABLE_PROC_SIGNAL:
-		memcpy (&tbl.proc_signal.signal, &tsk->signal,
-			sizeof (tbl.proc_signal.signal));
-
-		memcpy (&tbl.proc_signal.blocked, &tsk->blocked,
-			sizeof (tbl.proc_signal.blocked));
-
-		collect_sigign_sigcatch (tsk, &sigign, &sigcatch);
-
-		memcpy (&tbl.proc_signal.ignored, &sigign,
-			sizeof (tbl.proc_signal.ignored));
-
-		memcpy (&tbl.proc_signal.caught, &sigcatch,
-			sizeof (tbl.proc_signal.caught));
-
-#if 0
-		printk ("PROC_SIGNAL: (%lu, %lu) - (%lu, %lu)\n",
-			tbl.proc_signal.ignored.sig [0],
-			tbl.proc_signal.ignored.sig [1],
-			tbl.proc_signal.caught.sig [0],
-			tbl.proc_signal.caught.sig [1]);
-#endif
-		break;
-	case TABLE_PROC_MEM:
-		if (tsk->mm && tsk->mm != &init_mm) {
-			tbl.proc_mem.context = tsk->mm->context;
-			tbl.proc_mem.start_code = tsk->mm->start_code;
-			tbl.proc_mem.end_code = tsk->mm->end_code;
-			tbl.proc_mem.start_data = tsk->mm-> start_data;
-			tbl.proc_mem.end_data = tsk->mm->end_data;
-			tbl.proc_mem.start_brk = tsk->mm->start_brk;
-			tbl.proc_mem.brk = tsk->mm->brk;
-			tbl.proc_mem.start_stack = tsk->mm->start_stack;
-			tbl.proc_mem.start_mmap = tsk->mm->mmap ?
-				tsk->mm->mmap->vm_start : 0;
-			tbl.proc_mem.arg_start = tsk->mm->arg_start;
-			tbl.proc_mem.arg_end = tsk->mm->arg_end;
-			tbl.proc_mem.env_start = tsk->mm->env_start;
-			tbl.proc_mem.env_end = tsk->mm->env_end;
-			tbl.proc_mem.rss = tsk->mm->rss << PAGE_SHIFT;
-			tbl.proc_mem.total_vm = tsk->mm->total_vm;
-			tbl.proc_mem.locked_vm = tsk->mm->locked_vm;
-		}
-		tbl.proc_mem.rlim = tsk->rlim ? tsk->rlim[RLIMIT_RSS].rlim_cur : 0;
-		break;
-	case TABLE_PROC_SEGMENT:
-		if (tsk->mm && tsk->mm != &init_mm) {
-			unsigned long vsize = 0;
-			int size = 0, resident = 0, share = 0;
-			int trs = 0, lrs = 0, drs = 0, srs = 0, dt = 0;
-			struct vm_area_struct * vma = tsk->mm->mmap;
-
-			while (vma) {
-				pgd_t *pgd = pgd_offset(tsk->mm, vma->vm_start);
-				int pages = 0, shared = 0, dirty = 0, total = 0;
-				
-				vsize += vma->vm_end - vma->vm_start;
-
-				statm_pgd_range (pgd, vma->vm_start, vma->vm_end,
-
-						 &pages, &shared, &dirty, &total);
-
-				resident += pages;
-				share += shared;
-				dt += dirty;
-				size += total;
-
-				/* Well, shared library seem to get mapped
-				 * above 0x40000000 and are executable,
-				 * so I use this hack to get their size.
-				 */
-
-				if (vma->vm_flags & VM_GROWSDOWN)
-					srs += pages;	/* stack */
-				else if ((vma->vm_flags & VM_EXEC) &&
-					 (vma->vm_start > 0x40000000))
-					lrs += pages;	/* library */
-				else if (vma->vm_flags & VM_EXECUTABLE)
-					trs += pages;	/* text */
-				else
-					drs += pages;
-
-				vma = vma->vm_next;
-			}
-
-			tbl.proc_segment.vsize = vsize;
-			tbl.proc_segment.size = size << PAGE_SHIFT;
-			tbl.proc_segment.resident = resident << PAGE_SHIFT;
-			tbl.proc_segment.shared = share << PAGE_SHIFT;
-			tbl.proc_segment.trs = trs << PAGE_SHIFT;
-			tbl.proc_segment.lrs = lrs << PAGE_SHIFT;
-			tbl.proc_segment.drs = drs << PAGE_SHIFT;
-			tbl.proc_segment.srs = srs << PAGE_SHIFT;
-			tbl.proc_segment.dt = dt << PAGE_SHIFT;
-		}
-		break;
-	case TABLE_PROC_TIME:
-		tbl.proc_time.utime = tsk->times.tms_utime;
-		tbl.proc_time.stime = tsk->times.tms_stime;
-		tbl.proc_time.cutime = tsk->times.tms_cutime;
-		tbl.proc_time.cstime = tsk->times.tms_cstime;
-
-		tbl.proc_time.start_time = tsk->start_time;
-		tbl.proc_time.timeout = tsk->timeout;
-		tbl.proc_time.policy = tsk->policy;
-		tbl.proc_time.rt_priority = tsk->rt_priority;
-
-		tbl.proc_time.it_real_value = tsk->it_real_value;
-		tbl.proc_time.it_prof_value = tsk->it_prof_value;
-		tbl.proc_time.it_virt_value = tsk->it_virt_value;
-		tbl.proc_time.it_real_incr = tsk->it_real_incr;
-		tbl.proc_time.it_prof_incr = tsk->it_prof_incr;
-		tbl.proc_time.it_virt_incr = tsk->it_virt_incr;
-		break;
-	case TABLE_PROC_KERNEL:
-		tbl.proc_kernel.min_flt = tsk->min_flt;
-		tbl.proc_kernel.cmin_flt = tsk->cmin_flt;
-		tbl.proc_kernel.maj_flt = tsk->maj_flt;
-		tbl.proc_kernel.cmaj_flt = tsk->cmaj_flt;
-		
-		tbl.proc_kernel.kesp = KSTK_ESP(tsk);
-		tbl.proc_kernel.keip = KSTK_EIP(tsk);
-		
-		tbl.proc_kernel.nswap = tsk->nswap;
-		tbl.proc_kernel.cnswap = tsk->cnswap;
-
-		tbl.proc_kernel.wchan = get_wchan (tsk);
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	err = verify_area (VERIFY_WRITE, buf, sizeof (struct table));
-	if (err)
-		return err;
-
-	copy_to_user (buf, &tbl, sizeof (union table));
-
-	return 0;
-}

kernel/table21/unistd-i386.h

@@ -1,344 +0,0 @@
-#ifndef _ASM_I386_UNISTD_H_
-#define _ASM_I386_UNISTD_H_
-
-/*
- * This file contains the system call numbers.
- */
-
-#define __NR_setup		  0	/* used only by init, to get system going */
-#define __NR_exit		  1
-#define __NR_fork		  2
-#define __NR_read		  3
-#define __NR_write		  4
-#define __NR_open		  5
-#define __NR_close		  6
-#define __NR_waitpid		  7
-#define __NR_creat		  8
-#define __NR_link		  9
-#define __NR_unlink		 10
-#define __NR_execve		 11
-#define __NR_chdir		 12
-#define __NR_time		 13
-#define __NR_mknod		 14
-#define __NR_chmod		 15
-#define __NR_lchown		 16
-#define __NR_break		 17
-#define __NR_oldstat		 18
-#define __NR_lseek		 19
-#define __NR_getpid		 20
-#define __NR_mount		 21
-#define __NR_umount		 22
-#define __NR_setuid		 23
-#define __NR_getuid		 24
-#define __NR_stime		 25
-#define __NR_ptrace		 26
-#define __NR_alarm		 27
-#define __NR_oldfstat		 28
-#define __NR_pause		 29
-#define __NR_utime		 30
-#define __NR_stty		 31
-#define __NR_gtty		 32
-#define __NR_access		 33
-#define __NR_nice		 34
-#define __NR_ftime		 35
-#define __NR_sync		 36
-#define __NR_kill		 37
-#define __NR_rename		 38
-#define __NR_mkdir		 39
-#define __NR_rmdir		 40
-#define __NR_dup		 41
-#define __NR_pipe		 42
-#define __NR_times		 43
-#define __NR_prof		 44
-#define __NR_brk		 45
-#define __NR_setgid		 46
-#define __NR_getgid		 47
-#define __NR_signal		 48
-#define __NR_geteuid		 49
-#define __NR_getegid		 50
-#define __NR_acct		 51
-#define __NR_phys		 52
-#define __NR_lock		 53
-#define __NR_ioctl		 54
-#define __NR_fcntl		 55
-#define __NR_mpx		 56
-#define __NR_setpgid		 57
-#define __NR_ulimit		 58
-#define __NR_oldolduname	 59
-#define __NR_umask		 60
-#define __NR_chroot		 61
-#define __NR_ustat		 62
-#define __NR_dup2		 63
-#define __NR_getppid		 64
-#define __NR_getpgrp		 65
-#define __NR_setsid		 66
-#define __NR_sigaction		 67
-#define __NR_sgetmask		 68
-#define __NR_ssetmask		 69
-#define __NR_setreuid		 70
-#define __NR_setregid		 71
-#define __NR_sigsuspend		 72
-#define __NR_sigpending		 73
-#define __NR_sethostname	 74
-#define __NR_setrlimit		 75
-#define __NR_getrlimit		 76
-#define __NR_getrusage		 77
-#define __NR_gettimeofday	 78
-#define __NR_settimeofday	 79
-#define __NR_getgroups		 80
-#define __NR_setgroups		 81
-#define __NR_select		 82
-#define __NR_symlink		 83
-#define __NR_oldlstat		 84
-#define __NR_readlink		 85
-#define __NR_uselib		 86
-#define __NR_swapon		 87
-#define __NR_reboot		 88
-#define __NR_readdir		 89
-#define __NR_mmap		 90
-#define __NR_munmap		 91
-#define __NR_truncate		 92
-#define __NR_ftruncate		 93
-#define __NR_fchmod		 94
-#define __NR_fchown		 95
-#define __NR_getpriority	 96
-#define __NR_setpriority	 97
-#define __NR_profil		 98
-#define __NR_statfs		 99
-#define __NR_fstatfs		100
-#define __NR_ioperm		101
-#define __NR_socketcall		102
-#define __NR_syslog		103
-#define __NR_setitimer		104
-#define __NR_getitimer		105
-#define __NR_stat		106
-#define __NR_lstat		107
-#define __NR_fstat		108
-#define __NR_olduname		109
-#define __NR_iopl		110
-#define __NR_vhangup		111
-#define __NR_idle		112
-#define __NR_vm86old		113
-#define __NR_wait4		114
-#define __NR_swapoff		115
-#define __NR_sysinfo		116
-#define __NR_ipc		117
-#define __NR_fsync		118
-#define __NR_sigreturn		119
-#define __NR_clone		120
-#define __NR_setdomainname	121
-#define __NR_uname		122
-#define __NR_modify_ldt		123
-#define __NR_adjtimex		124
-#define __NR_mprotect		125
-#define __NR_sigprocmask	126
-#define __NR_create_module	127
-#define __NR_init_module	128
-#define __NR_delete_module	129
-#define __NR_get_kernel_syms	130
-#define __NR_quotactl		131
-#define __NR_getpgid		132
-#define __NR_fchdir		133
-#define __NR_bdflush		134
-#define __NR_sysfs		135
-#define __NR_personality	136
-#define __NR_afs_syscall	137 /* Syscall for Andrew File System */
-#define __NR_setfsuid		138
-#define __NR_setfsgid		139
-#define __NR__llseek		140
-#define __NR_getdents		141
-#define __NR__newselect		142
-#define __NR_flock		143
-#define __NR_msync		144
-#define __NR_readv		145
-#define __NR_writev		146
-#define __NR_getsid		147
-#define __NR_fdatasync		148
-#define __NR__sysctl		149
-#define __NR_mlock		150
-#define __NR_munlock		151
-#define __NR_mlockall		152
-#define __NR_munlockall		153
-#define __NR_sched_setparam		154
-#define __NR_sched_getparam		155
-#define __NR_sched_setscheduler		156
-#define __NR_sched_getscheduler		157
-#define __NR_sched_yield		158
-#define __NR_sched_get_priority_max	159
-#define __NR_sched_get_priority_min	160
-#define __NR_sched_rr_get_interval	161
-#define __NR_nanosleep		162
-#define __NR_mremap		163
-#define __NR_setresuid		164
-#define __NR_getresuid		165
-#define __NR_vm86		166
-#define __NR_query_module	167
-#define __NR_poll		168
-#define __NR_nfsservctl		169
-#define __NR_setresgid		170
-#define __NR_getresgid		171
-#define __NR_prctl              172
-#define __NR_rt_sigreturn	173
-#define __NR_rt_sigaction	174
-#define __NR_rt_sigprocmask	175
-#define __NR_rt_sigpending	176
-#define __NR_rt_sigtimedwait	177
-#define __NR_rt_sigqueueinfo	178
-#define __NR_rt_sigsuspend	179
-#define __NR_pread		180
-#define __NR_pwrite		181
-#define __NR_chown		182
-#define __NR_getcwd		183
-#define __NR_capget		184
-#define __NR_capset		185
-#define __NR_sigaltstack	186
-#define __NR_sendfile		187
-#define __NR_streams1		188	/* some people actually want it */
-#define __NR_streams2		189	/* some people actually want it */
-#define __NR_table		190
-
-/* user-visible error numbers are in the range -1 - -122: see <asm-i386/errno.h> */
-
-#define __syscall_return(type, res) \
-do { \
-	if ((unsigned long)(res) >= (unsigned long)(-125)) { \
-		errno = -(res); \
-		res = -1; \
-	} \
-	return (type) (res); \
-} while (0)
-
-/* XXX - _foo needs to be __foo, while __NR_bar could be _NR_bar. */
-#define _syscall0(type,name) \
-type name(void) \
-{ \
-long __res; \
-__asm__ volatile ("int $0x80" \
-	: "=a" (__res) \
-	: "0" (__NR_##name)); \
-__syscall_return(type,__res); \
-}
-
-#define _syscall1(type,name,type1,arg1) \
-type name(type1 arg1) \
-{ \
-long __res; \
-__asm__ volatile ("int $0x80" \
-	: "=a" (__res) \
-	: "0" (__NR_##name),"b" ((long)(arg1))); \
-__syscall_return(type,__res); \
-}
-
-#define _syscall2(type,name,type1,arg1,type2,arg2) \
-type name(type1 arg1,type2 arg2) \
-{ \
-long __res; \
-__asm__ volatile ("int $0x80" \
-	: "=a" (__res) \
-	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2))); \
-__syscall_return(type,__res); \
-}
-
-#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
-type name(type1 arg1,type2 arg2,type3 arg3) \
-{ \
-long __res; \
-__asm__ volatile ("int $0x80" \
-	: "=a" (__res) \
-	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
-		  "d" ((long)(arg3))); \
-__syscall_return(type,__res); \
-}
-
-#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
-type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
-{ \
-long __res; \
-__asm__ volatile ("int $0x80" \
-	: "=a" (__res) \
-	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
-	  "d" ((long)(arg3)),"S" ((long)(arg4))); \
-__syscall_return(type,__res); \
-} 
-
-#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
-	  type5,arg5) \
-type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
-{ \
-long __res; \
-__asm__ volatile ("int $0x80" \
-	: "=a" (__res) \
-	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
-	  "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5))); \
-__syscall_return(type,__res); \
-}
-
-#ifdef __KERNEL_SYSCALLS__
-
-/*
- * we need this inline - forking from kernel space will result
- * in NO COPY ON WRITE (!!!), until an execve is executed. This
- * is no problem, but for the stack. This is handled by not letting
- * main() use the stack at all after fork(). Thus, no function
- * calls - which means inline code for fork too, as otherwise we
- * would use the stack upon exit from 'fork()'.
- *
- * Actually only pause and fork are needed inline, so that there
- * won't be any messing with the stack from main(), but we define
- * some others too.
- */
-#define __NR__exit __NR_exit
-static inline _syscall0(int,idle)
-static inline _syscall0(int,pause)
-static inline _syscall1(int,setup,int,magic)
-static inline _syscall0(int,sync)
-static inline _syscall0(pid_t,setsid)
-static inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
-static inline _syscall3(int,read,int,fd,char *,buf,off_t,count)
-static inline _syscall3(off_t,lseek,int,fd,off_t,offset,int,count)
-static inline _syscall1(int,dup,int,fd)
-static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
-static inline _syscall3(int,open,const char *,file,int,flag,int,mode)
-static inline _syscall1(int,close,int,fd)
-static inline _syscall1(int,_exit,int,exitcode)
-static inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
-static inline _syscall1(int,delete_module,const char *,name)
-
-static inline pid_t wait(int * wait_stat)
-{
-	return waitpid(-1,wait_stat,0);
-}
-
-/*
- * This is the mechanism for creating a new kernel thread.
- *
- * NOTE! Only a kernel-only process(ie the swapper or direct descendants
- * who haven't done an "execve()") should use this: it will work within
- * a system call from a "real" process, but the process memory space will
- * not be free'd until both the parent and the child have exited.
- */
-static inline pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
-{
-	long retval;
-
-	__asm__ __volatile__(
-		"movl %%esp,%%esi\n\t"
-		"int $0x80\n\t"		/* Linux/i386 system call */
-		"cmpl %%esp,%%esi\n\t"	/* child or parent? */
-		"je 1f\n\t"		/* parent - jump */
-		"pushl %3\n\t"		/* push argument */
-		"call *%4\n\t"		/* call fn */
-		"movl %2,%0\n\t"	/* exit */
-		"int $0x80\n"
-		"1:\t"
-		:"=a" (retval)
-		:"0" (__NR_clone), "i" (__NR_exit),
-		 "r" (arg), "r" (fn),
-		 "b" (flags | CLONE_VM)
-		:"si");
-	return retval;
-}
-
-#endif
-
-#endif /* _ASM_I386_UNISTD_H_ */

kernel/table21/version.h

@@ -1 +0,0 @@
-#define _TABLE_VERSION	1

kernel/version.h

@@ -1 +0,0 @@
-#define _TABLE_VERSION	1

lib/lib.pl

@@ -36,6 +36,10 @@ print 'static void';
 print '_glibtop_missing_feature (glibtop *server, const char *feature,';
 print "\t\t\t  const u_int64_t present, u_int64_t *required)";
 print '{';
+print "\tu_int64_t old_required = *required;\n";
+print "\t/* Return if we have all required fields. */";
+print "\tif ((~present & old_required) == 0)";
+print "\t\treturn;\n";
 print "\tswitch (server->error_method) {";
 print "\tcase GLIBTOP_ERROR_METHOD_WARN_ONCE:";
 print "\t\t*required &= present;";
@@ -43,13 +47,13 @@ print "\tcase GLIBTOP_ERROR_METHOD_WARN:";
 print "\t\tglibtop_warn_r (server,";
 print "\t\t\t\t_(\"glibtop_get_%s (): Client requested \"";
 print "\t\t\t\t  \"field mask %05Lx, but only have %05Lx.\"),";
-print "\t\t\t\t feature, required, present);";
+print "\t\t\t\t feature, old_required, present);";
 print "\t\tbreak;";
 print "\tcase GLIBTOP_ERROR_METHOD_ABORT:";
 print "\t\tglibtop_error_r (server,";
 print "\t\t\t\t _(\"glibtop_get_%s (): Client requested \"";
 print "\t\t\t\t   \"field mask %05x, but only have %05x.\"),";
-print "\t\t\t\t feature, required, present);";
+print "\t\t\t\t feature, old_required, present);";
 print "\t\tbreak;";
 print "\t}";
 print '}';

libgtop-sysdeps.m4

@@ -15,45 +15,44 @@ AC_DEFUN([LIBGTOP_HACKER_TESTS],[
 
 	case "$host_os" in
 	linux*)
-	  AC_ARG_WITH(linux-table,
-	  [  --with-linux-table      Use the table () function from Martin Baulig],[
-	  linux_table="$withval"],[linux_table=auto])
-	  if test $linux_table = yes ; then
-	    AC_CHECK_HEADER(linux/table.h, linux_table=yes, linux_table=no)
-	  elif test $linux_table = auto ; then
-	    AC_MSG_CHECKING(for table function in Linux Kernel)
+	  AC_ARG_WITH(linux-sysctl,
+	  [  --with-linux-sysctl      Use the sysctl () interface from Martin Baulig],[
+	  linux_sysctl="$withval"],[linux_sysctl=auto])
+	  if test $linux_sysctl = yes ; then
+	    AC_CHECK_HEADER(linux/libgtop.h, linux_sysctl=yes, linux_sysctl=no)
+	  elif test $linux_sysctl = auto ; then
+	    AC_MSG_CHECKING(for LibGTop sysctl support in Linux Kernel)
 	    AC_TRY_RUN([
 #include <stdio.h>
 #include <stdlib.h>
 
-#include <unistd.h>
-#include <linux/unistd.h>
-#include <linux/table.h>
+#include <sys/sysctl.h>
+#include <linux/libgtop.h>
 
-#include <syscall.h>
+#define SIZE(x) sizeof(x)/sizeof(x[0])
 
-static inline _syscall3 (int, table, int, type, union table *, tbl, const void *, param);
+int name[2] = { CTL_LIBGTOP, LIBGTOP_VERSION };
 
 int
 main (void)
 {
-	union table tbl;
-	int ret;
+    unsigned version;
+    size_t size = sizeof (version);
 
-	ret = table (TABLE_VERSION, NULL, NULL);
-
-	if (ret == -1)
-		exit (-errno);
-
-	exit (ret < 1 ? ret : 0);
+    if (sysctl (name, SIZE (name), &version, &size, NULL, 0))
+	exit (1);
+    else if (version < 1)
+	exit (2);
+    else
+	exit (0);
 }
-], linux_table=yes, linux_table=no, linux_table=no)
-	    AC_MSG_RESULT($linux_table)
+], linux_sysctl=yes, linux_sysctl=no, linux_sysctl=no)
+	    AC_MSG_RESULT($linux_sysctl)
 	  fi
-	  if test $linux_table = yes ; then
-	    AC_DEFINE(HAVE_LINUX_TABLE)
+	  if test $linux_sysctl = yes ; then
+	    AC_DEFINE(HAVE_LINUX_SYSCTL)
 	  fi
-	  AM_CONDITIONAL(LINUX_TABLE, test $linux_table = yes)
+	  AM_CONDITIONAL(LINUX_SYSCTL, test $linux_sysctl = yes)
 	  ;;
 	esac
 ])
@@ -108,14 +107,14 @@ AC_DEFUN([GNOME_LIBGTOP_SYSDEPS],[
 
 	case "$host_os" in
 	linux*)
-	  if test x$linux_table = xyes ; then
+	  if test x$linux_sysctl = xyes ; then
 	    libgtop_sysdeps_dir=kernel
 	    libgtop_use_machine_h=no
 	  else
 	    libgtop_sysdeps_dir=linux
 	    libgtop_use_machine_h=no
-	    libgtop_have_sysinfo=yes
 	  fi
+	  libgtop_have_sysinfo=yes
 	  libgtop_need_server=no
 	  ;;
 	freebsd*|netbsd*|openbsd*)
@@ -127,9 +126,20 @@ AC_DEFUN([GNOME_LIBGTOP_SYSDEPS],[
 	*)
 	  if test x$hacker_mode = xyes ; then
 	    case "$host_os" in
+            bsdi*)
+	      libgtop_sysdeps_dir=freebsd
+	      libgtop_use_machine_h=yes
+	      libgtop_need_server=yes
+	      libgtop_postinstall='chgrp kmem $(bindir)/libgtop_server && chmod 2755 $(bindir)/libgtop_server'
+	      ;;
+	    solaris*)
+	      libgtop_sysdeps_dir=solaris
+	      libgtop_use_machine_h=yes
+	      libgtop_need_server=no
+	      ;;
 	    sunos4*)
 	      libgtop_sysdeps_dir=sun4
-	        libgtop_use_machine_h=yes
+	      libgtop_use_machine_h=yes
 	      libgtop_need_server=yes
 	      ;;
 	    osf*)

po/.cvsignore

@@ -2,6 +2,6 @@ Makefile
 Makefile.in
 POTFILES
 cat-id-tbl.c
-*.gmo
+*.gmo *.mo
 libgtop.pot
 Makefile.in.in

sysdeps/Makefile.am

@@ -6,5 +6,5 @@ endif
 
 SUBDIRS			= @sysdeps_dir@ common names $(guile_SUBDIRS)
 
-DIST_SUBDIRS		= common guile linux kernel names osf1 \
-			  stub stub_suid sun4 freebsd
+DIST_SUBDIRS		= common guile linux names osf1 \
+			  stub stub_suid sun4 freebsd solaris

sysdeps/freebsd/ChangeLog

@@ -1,3 +1,22 @@
+1999-03-19  Martin Baulig  <martin@home-of-linux.org>
+
+	Added basic support for BSDI. It compiles without problems on
+	BSDI 2.1 and 3.1, but it is *untested* - I'm neither root on
+	the machine nor have I access to /dev/kmem, so I don't know
+	whether it will work.
+
+	You need to give configure the `--enable-hacker-mode' parameter
+	to use the code.
+
+	If someone can verify whether it actually works, please let me
+	know.
+
+1999-03-18  Martin Baulig  <martin@home-of-linux.org>
+
+	* ppp.c: Don't use `sppp.pp_phase' if we don't HAVE_I4B_ACCT.
+	This is an ugly hack until someone tells me which versions have
+	this field and which not.
+
 1999-02-25  Martin Baulig  <martin@home-of-linux.org>
 
 	* prockernel.c, proctime.c: Applied patch Stanislav Grozev for

sysdeps/freebsd/mem.c

@@ -28,12 +28,17 @@
 #include <glibtop_suid.h>
 
 #include <sys/sysctl.h>
+#ifndef __bsdi__
 #include <sys/vmmeter.h>
+#endif
 #include <vm/vm_param.h>
 
 static const unsigned long _glibtop_sysdeps_mem =
 (1 << GLIBTOP_MEM_TOTAL) + (1 << GLIBTOP_MEM_USED) +
-(1 << GLIBTOP_MEM_FREE) + (1 << GLIBTOP_MEM_SHARED) +
+(1 << GLIBTOP_MEM_FREE) +
+#ifndef __bsdi__
+(1 << GLIBTOP_MEM_SHARED) +
+#endif
 (1 << GLIBTOP_MEM_BUFFER) +
 #ifdef __FreeBSD__
 (1 << GLIBTOP_MEM_CACHED) +
@@ -61,9 +66,11 @@ static struct nlist nlst [] = {
 	{ 0 }
 };
 
+#ifndef __bsdi__
 /* MIB array for sysctl */
 /* static int mib_length=2; */
 static int mib [] = { CTL_VM, VM_METER };
+#endif /* __bsdi__ */
 
 /* Init function. */
 
@@ -95,8 +102,10 @@ glibtop_init_mem_p (glibtop *server)
 void
 glibtop_get_mem_p (glibtop *server, glibtop_mem *buf)
 {
+#ifndef __bsdi__
 	struct vmtotal vmt;
 	size_t length_vmt;
+#endif
 	struct vmmeter vmm;
 	u_int v_used_count;
 	u_int v_total_count;
@@ -109,6 +118,7 @@ glibtop_get_mem_p (glibtop *server, glibtop_mem *buf)
 	if (server->sysdeps.mem == 0)
 		return;
 
+#ifndef __bsdi__
 	/* [FIXME: On FreeBSD 2.2.6, sysctl () returns an incorrect
 	 *         value for `vmt.vm'. We use some code from Unix top
 	 *         here.] */
@@ -119,6 +129,7 @@ glibtop_get_mem_p (glibtop *server, glibtop_mem *buf)
 		glibtop_warn_io_r (server, "sysctl");
 		return;
 	}
+#endif
 	
 	/* Get the data from kvm_* */
 	if (kvm_read (server->machine.kd, nlst[0].n_value,
@@ -154,7 +165,9 @@ glibtop_get_mem_p (glibtop *server, glibtop_mem *buf)
 #endif
 
 	buf->locked = (u_int64_t) pagetok (vmm.v_wire_count) << LOG1024;
+#ifndef __bsdi__
 	buf->shared = (u_int64_t) pagetok (vmt.t_rmshr) << LOG1024;
+#endif
 
 #if __FreeBSD__
 	buf->buffer = (u_int64_t) bufspace;

sysdeps/freebsd/msg_limits.c

@@ -27,9 +27,26 @@
 
 #include <glibtop_suid.h>
 
+#if (defined __bsdi__) && (_BSDI_VERSION < 199700)
+/* Older versions of BSDI don't seem to have this. */
+
+void
+glibtop_init_msg_limits_p (glibtop *server)
+{ }
+
+void
+glibtop_get_msg_limits_p (glibtop *server, glibtop_msg_limits *buf)
+{
+        glibtop_init_p (server, (1 << GLIBTOP_SYSDEPS_MSG_LIMITS), 0);
+
+        memset (buf, 0, sizeof (glibtop_msg_limits));
+}
+
+#else
+
 /* #define KERNEL to get declaration of `struct msginfo'. */
 
-#ifdef __FreeBSD__
+#if (defined __FreeBSD__) || (defined __bsdi__)
 #define KERNEL 1
 #else
 #define _KERNEL 1
@@ -93,3 +110,6 @@ glibtop_get_msg_limits_p (glibtop *server, glibtop_msg_limits *buf)
 	
 	buf->flags = _glibtop_sysdeps_msg_limits; 
 }
+
+#endif /* either a newer BSDI or no BSDI at all. */
+

sysdeps/freebsd/netload.c

@@ -107,7 +107,7 @@ glibtop_get_netload_p (glibtop *server, glibtop_netload *buf,
 			  sizeof (ifnet)) != sizeof (ifnet))
 		    glibtop_error_io_r (server, "kvm_read (ifnetaddr)");
 
-#ifdef __FreeBSD__
+#if (defined __FreeBSD__) || (defined __bsdi__)
 	    if (kvm_read (server->machine.kd, (u_long) ifnet.if_name,
 			  tname, 16) != 16)
 		    glibtop_error_io_r (server, "kvm_read (if_name)");
@@ -118,7 +118,7 @@ glibtop_get_netload_p (glibtop *server, glibtop_netload *buf,
 
 #if (defined __FreeBSD__) && (__FreeBSD_version >= 300000)
 	    ifaddraddr = (u_long) ifnet.if_addrhead.tqh_first;
-#elif (defined __FreeBSD__)
+#elif (defined __FreeBSD__) || (defined __bsdi__)
 	    ifaddraddr = (u_long) ifnet.if_addrlist;
 #else
 	    ifaddraddr = (u_long) ifnet.if_addrlist.tqh_first;
@@ -196,7 +196,7 @@ glibtop_get_netload_p (glibtop *server, glibtop_netload *buf,
 
 #if (defined __FreeBSD__) && (__FreeBSD_version >= 300000)
 	    ifaddraddr = (u_long)ifaddr.ifa.ifa_link.tqe_next;
-#elif (defined __FreeBSD__)
+#elif (defined __FreeBSD__) || (defined __bsdi__)
 	    ifaddraddr = (u_long)ifaddr.ifa.ifa_next;
 #else
 	    ifaddraddr = (u_long)ifaddr.ifa.ifa_list.tqe_next;
@@ -205,7 +205,7 @@ glibtop_get_netload_p (glibtop *server, glibtop_netload *buf,
 	
 #if (defined __FreeBSD__) && (__FreeBSD_version >= 300000)
 	ifnetaddr = (u_long) ifnet.if_link.tqe_next;
-#elif (defined __FreeBSD__)
+#elif (defined __FreeBSD__) || (defined __bsdi__)
 	ifnetaddr = (u_long) ifnet.if_next;
 #else
 	ifnetaddr = (u_long) ifnet.if_list.tqe_next;

sysdeps/freebsd/ppp.c

@@ -110,10 +110,15 @@ glibtop_get_ppp_p (glibtop *server, glibtop_ppp *buf, unsigned short device)
 #ifdef HAVE_I4B_ACCT
 	phase = data.sc_if_un.scu_sp.pp_phase;
 #else
+	/* FIXME: Which FreeBSD version have this field and
+	 *        which not. */
+#if 0
 	phase = data.pp_phase;
+#endif
 #endif
 
 	switch (phase) {
+#ifdef HAVE_I4B_ACCT
 	case PHASE_DEAD:
 	case PHASE_TERMINATE:
 		buf->state = GLIBTOP_PPP_STATE_HANGUP;
@@ -122,6 +127,7 @@ glibtop_get_ppp_p (glibtop *server, glibtop_ppp *buf, unsigned short device)
 	case PHASE_NETWORK:
 		buf->state = GLIBTOP_PPP_STATE_ONLINE;
 		break;
+#endif
 	default:
 		buf->state = GLIBTOP_PPP_STATE_UNKNOWN;
 		break;

sysdeps/freebsd/prockernel.c

@@ -31,10 +31,12 @@
 #include <sys/param.h>
 #include <sys/sysctl.h>
 #include <sys/proc.h>
-#ifndef __OpenBSD__
+#if (!defined __OpenBSD__) && (!defined __bsdi__)
 #include <sys/user.h>
 #endif
+#ifndef __bsdi__
 #include <machine/pcb.h>
+#endif
 #ifdef __FreeBSD__
 #include <machine/tss.h>
 #endif
@@ -122,7 +124,7 @@ glibtop_get_proc_kernel_p (glibtop *server,
 	/* NOTE: You need to mount the /proc filesystem to make
 	 *       `kvm_uread' work. */
 
-	sprintf (filename, "/proc/%d/mem", pid);
+	sprintf (filename, "/proc/%d/mem", (int) pid);
 	if (stat (filename, &statb)) return;
 
 	glibtop_suid_enter (server);
@@ -162,7 +164,11 @@ glibtop_get_proc_kernel_p (glibtop *server,
 #endif
 #else
 			buf->kstk_esp = (u_int64_t) pcb.pcb_tss.tss_esp0;
+#ifdef __bsdi__
+			buf->kstk_eip = (u_int64_t) pcb.pcb_tss.tss_eip;
+#else
 			buf->kstk_eip = (u_int64_t) pcb.pcb_tss.__tss_eip;
+#endif
 
 			buf->flags |= _glibtop_sysdeps_proc_kernel_pcb;
 #endif

sysdeps/freebsd/procmap.c

@@ -42,7 +42,7 @@
 #include <ufs/ufs/inode.h>
 
 #include <sys/ucred.h>
-#ifndef __OpenBSD__
+#if (!defined __OpenBSD__) && (!defined __bsdi__)
 #include <sys/user.h>
 #endif
 #include <sys/sysctl.h>

sysdeps/freebsd/procmem.c

@@ -39,7 +39,7 @@
 #include <ufs/ufs/inode.h>
 
 #include <sys/ucred.h>
-#ifndef __OpenBSD__
+#if (!defined __OpenBSD__) && (!defined __bsdi__)
 #include <sys/user.h>
 #endif
 #include <sys/sysctl.h>

sysdeps/freebsd/procstate.c

@@ -27,7 +27,7 @@
 
 #include <glibtop_suid.h>
 
-#ifndef __OpenBSD__
+#if (!defined __OpenBSD__) && (!defined __bsdi__)
 #include <sys/user.h>
 #endif
 

sysdeps/freebsd/proctime.c

@@ -140,7 +140,7 @@ glibtop_get_proc_time_p (glibtop *server, glibtop_proc_time *buf,
 	/* It does not work for the swapper task. */
 	if (pid == 0) return;
 	
-	sprintf (filename, "/proc/%d/mem", pid);
+	sprintf (filename, "/proc/%d/mem", (int) pid);
 	if (stat (filename, &statb)) return;
 
 	/* Get the process information */

sysdeps/freebsd/sem_limits.c

@@ -27,9 +27,26 @@
 
 #include <glibtop_suid.h>
 
+#if (defined __bsdi__) && (_BSDI_VERSION < 199700)
+/* Older versions of BSDI don't seem to have this. */
+
+void
+glibtop_init_sem_limits_p (glibtop *server)
+{ }
+
+void
+glibtop_get_sem_limits_p (glibtop *server, glibtop_sem_limits *buf)
+{
+        glibtop_init_p (server, (1 << GLIBTOP_SYSDEPS_SEM_LIMITS), 0);
+
+        memset (buf, 0, sizeof (glibtop_sem_limits));
+}
+
+#else
+
 /* #define KERNEL to get declaration of `struct seminfo'. */
 
-#ifdef __FreeBSD__
+#if (defined __FreeBSD__) || (defined __bsdi__)
 #define KERNEL 1
 #else
 #define _KERNEL 1
@@ -98,3 +115,6 @@ glibtop_get_sem_limits_p (glibtop *server, glibtop_sem_limits *buf)
 	
 	buf->flags = _glibtop_sysdeps_sem_limits;
 }
+
+#endif /* either a newer BSDI or no BSDI at all. */
+

sysdeps/freebsd/shm_limits.c

@@ -27,9 +27,26 @@
 
 #include <glibtop_suid.h>
 
+#if (defined __bsdi__) && (_BSDI_VERSION < 199700)
+/* Older versions of BSDI don't seem to have this. */
+
+void
+glibtop_init_shm_limits_p (glibtop *server)
+{ }
+
+void
+glibtop_get_shm_limits_p (glibtop *server, glibtop_shm_limits *buf)
+{
+        glibtop_init_p (server, (1 << GLIBTOP_SYSDEPS_SHM_LIMITS), 0);
+
+        memset (buf, 0, sizeof (glibtop_shm_limits));
+}
+
+#else
+
 /* #define KERNEL to get declaration of `struct shminfo'. */
 
-#ifdef __FreeBSD__
+#if (defined __FreeBSD__)  || (defined __bsdi__)
 #define KERNEL 1
 #else
 #define _KERNEL 1
@@ -93,3 +110,6 @@ glibtop_get_shm_limits_p (glibtop *server, glibtop_shm_limits *buf)
 
 	buf->flags = _glibtop_sysdeps_shm_limits;
 }
+
+#endif /* either a newer BSDI or no BSDI at all. */
+

sysdeps/kernel/.cvsignore

@@ -1,28 +0,0 @@
-.deps
-.libs
-Makefile
-Makefile.in
-close.lo
-cpu.lo
-init.lo
-ipc_limits.lo
-libgtop_sysdeps.la
-loadavg.lo
-mem.lo
-msg_limits.lo
-open.lo
-procdata.lo
-prockernel.lo
-proclist.lo
-procmem.lo
-procsegment.lo
-procsignal.lo
-procstate.lo
-proctime.lo
-procuid.lo
-sem_limits.lo
-shm_limits.lo
-swap.lo
-sysdeps.lo
-sysinfo.lo
-uptime.lo

sysdeps/kernel/ChangeLog

@@ -1,23 +0,0 @@
-1998-10-26  Martin Baulig  <martin@home-of-linux.org>
-
-	* netload.c: New file. Currently empty.
-
-1998-10-26  Martin Baulig  <martin@home-of-linux.org>
-
-	* procargs.c: New file. Currently empty.
-
-1998-10-25  Martin Baulig  <martin@home-of-linux.org>
-
-	* ppp.c: New file. Currently empty.
-
-1998-06-14  Martin Baulig  <martin@home-of-linux.org>
-
-	* kernel.s: New file - declaration of the table () function
-	via _syscall3 (); due to a bug in egcs, we cannot put this
-	into a C file.
-
-1998-06-13  Martin Baulig  <martin@home-of-linux.org>
-
-	The code in this directory fetches all information
-	directly from the kernel. It uses the new table ()
-	system call from the `kernel' directory.

sysdeps/kernel/Makefile.am

@@ -4,21 +4,14 @@ INCLUDES			= @INCLUDES@
 
 lib_LTLIBRARIES			= libgtop_sysdeps.la
 
-libgtop_sysdeps_la_SOURCES	= open.c close.c kernel.s cpu.c mem.c swap.c \
+libgtop_sysdeps_la_SOURCES	= open.c close.c siglist.c cpu.c mem.c swap.c \
 				  uptime.c loadavg.c shm_limits.c msg_limits.c \
 				  sem_limits.c proclist.c procstate.c procuid.c \
 				  proctime.c procmem.c procsignal.c prockernel.c \
-				  procsegment.c siglist.c procargs.c procmap.c \
-				  netload.c ppp.c
+				  procsegment.c procargs.c procmap.c netload.c \
+				  ppp.c
 
 libgtop_sysdeps_la_LDFLAGS	= $(LT_VERSION_INFO)
 
 include_HEADERS			= glibtop_server.h
 
-noinst_HEADERS			= kernel.h
-
-kernel.o kernel.lo: $(srcdir)/kernel.s
-	rm -f kernel.o kernel.lo
-	$(AS) -o kernel.o $(srcdir)/kernel.s
-	cp kernel.o kernel.lo
-

sysdeps/kernel/cpu.c

@@ -21,16 +21,10 @@
    Boston, MA 02111-1307, USA.
 */
 
-#include <config.h>
-#include <glibtop/error.h>
+#include <glibtop.h>
 #include <glibtop/cpu.h>
 
-#include "kernel.h"
-
-static const unsigned long _glibtop_sysdeps_cpu =
-(1 << GLIBTOP_CPU_TOTAL) + (1 << GLIBTOP_CPU_USER) +
-(1 << GLIBTOP_CPU_NICE) + (1 << GLIBTOP_CPU_SYS) +
-(1 << GLIBTOP_CPU_IDLE) + (1 << GLIBTOP_CPU_FREQUENCY);
+static const unsigned long _glibtop_sysdeps_cpu = 0;
 
 /* Init function. */
 
@@ -45,21 +39,5 @@ glibtop_init_cpu_s (glibtop *server)
 void
 glibtop_get_cpu_s (glibtop *server, glibtop_cpu *buf)
 {
-	union table tbl;
-
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_CPU, 0);
-
 	memset (buf, 0, sizeof (glibtop_cpu));
-
-	if (table (TABLE_CPU, &tbl, NULL))
-		glibtop_error_io_r (server, "table(TABLE_CPU)");
-
-	buf->flags = _glibtop_sysdeps_cpu;
-
-	buf->total = tbl.cpu.total;
-	buf->user = tbl.cpu.user;
-	buf->nice = tbl.cpu.nice;
-	buf->sys = tbl.cpu.sys;
-	buf->idle = tbl.cpu.idle;
-	buf->frequency = tbl.cpu.frequency;
 }

sysdeps/kernel/kernel.s

@@ -1,42 +0,0 @@
-	.file	"test.c"
-	.version	"01.01"
-/ GNU C version egcs-2.90.29 980515 (egcs-1.0.3 release) (i686-pc-linux-gnu) compiled by GNU C version egcs-2.90.29 980515 (egcs-1.0.3 release).
-/ options passed:  -O2 -Wall -W
-/ options enabled:  -fdefer-pop -fcse-follow-jumps -fcse-skip-blocks
-/ -fexpensive-optimizations -fthread-jumps -fstrength-reduce -fpeephole
-/ -fforce-mem -ffunction-cse -finline -fkeep-static-consts -fcaller-saves
-/ -fpcc-struct-return -frerun-cse-after-loop -frerun-loop-opt
-/ -fschedule-insns2 -fcommon -fverbose-asm -fgnu-linker -fregmove
-/ -falias-check -fargument-alias -m80387 -mhard-float -mno-soft-float
-/ -mieee-fp -mfp-ret-in-387 -mschedule-prologue -mcpu=pentiumpro
-/ -march=pentium
-
-gcc2_compiled.:
-.text
-	.align 4
-.globl table
-	.type	 table,@function
-table:
-	pushl %ebp
-	movl %esp,%ebp
-	movl $190,%eax
-	pushl %ebx
-	movl 8(%ebp),%ebx
-	movl 12(%ebp),%ecx
-	movl 16(%ebp),%edx
-#APP
-	int $0x80
-#NO_APP
-	testl %eax,%eax
-	jge .L3
-	negl %eax
-	movl %eax,errno
-	movl $-1,%eax
-.L3:
-	movl -4(%ebp),%ebx
-	movl %ebp,%esp
-	popl %ebp
-	ret
-.Lfe1:
-	.size	 table,.Lfe1-table
-	.ident	"GCC: (GNU) egcs-2.90.29 980515 (egcs-1.0.3 release)"

sysdeps/kernel/loadavg.c

@@ -21,15 +21,10 @@
    Boston, MA 02111-1307, USA.
 */
 
-#include <config.h>
-#include <glibtop/error.h>
+#include <glibtop.h>
 #include <glibtop/loadavg.h>
 
-#include "kernel.h"
-
-static const unsigned long _glibtop_sysdeps_loadavg =
-(1 << GLIBTOP_LOADAVG_LOADAVG) + (1 << GLIBTOP_LOADAVG_NR_RUNNING) +
-(1 << GLIBTOP_LOADAVG_NR_TASKS) + (1 << GLIBTOP_LOADAVG_LAST_PID);
+static const unsigned long _glibtop_sysdeps_loadavg = 0;
 
 /* Init function. */
 
@@ -39,27 +34,10 @@ glibtop_init_loadavg_s (glibtop *server)
 	server->sysdeps.loadavg = _glibtop_sysdeps_loadavg;
 }
 
-/* Provides load load averange. */
+/* Provides load averange. */
 
 void
 glibtop_get_loadavg_s (glibtop *server, glibtop_loadavg *buf)
 {
-	union table tbl;
-	
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_LOADAVG, 0);
-
 	memset (buf, 0, sizeof (glibtop_loadavg));
-
-	if (table (TABLE_LOADAVG, &tbl, NULL))
-		glibtop_error_io_r (server, "table(TABLE_LOADAVG)");
-	
-	buf->flags = _glibtop_sysdeps_loadavg;
-
-	buf->loadavg [0] = tbl.loadavg.loadavg [0];
-	buf->loadavg [1] = tbl.loadavg.loadavg [1];
-	buf->loadavg [2] = tbl.loadavg.loadavg [2];
-
-	buf->nr_running = tbl.loadavg.nr_running;
-	buf->nr_tasks = tbl.loadavg.nr_tasks;
-	buf->last_pid = tbl.loadavg.last_pid;
 }

sysdeps/kernel/mem.c

@@ -21,17 +21,10 @@
    Boston, MA 02111-1307, USA.
 */
 
-#include <config.h>
-#include <glibtop/error.h>
+#include <glibtop.h>
 #include <glibtop/mem.h>
 
-#include "kernel.h"
-
-static const unsigned long _glibtop_sysdeps_mem =
-(1 << GLIBTOP_MEM_TOTAL) + (1 << GLIBTOP_MEM_USED) +
-(1 << GLIBTOP_MEM_FREE) + (1 << GLIBTOP_MEM_SHARED) +
-(1 << GLIBTOP_MEM_BUFFER) + (1 << GLIBTOP_MEM_CACHED) +
-(1 << GLIBTOP_MEM_USER);
+static const unsigned long _glibtop_sysdeps_mem = 0;
 
 /* Init function. */
 
@@ -46,23 +39,5 @@ glibtop_init_mem_s (glibtop *server)
 void
 glibtop_get_mem_s (glibtop *server, glibtop_mem *buf)
 {
-	union table tbl;
-	
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_MEM, 0);
-
 	memset (buf, 0, sizeof (glibtop_mem));
-
-	if (table (TABLE_MEM, &tbl, NULL))
-		glibtop_error_io_r (server, "table(TABLE_MEM)");
-
-	buf->flags = _glibtop_sysdeps_mem;
-
-	buf->total  = tbl.mem.total;
-	buf->used   = tbl.mem.used;
-	buf->free   = tbl.mem.free;
-	buf->shared = tbl.mem.shared;
-	buf->buffer = tbl.mem.buffer;
-	buf->cached = tbl.mem.cached;
-
-	buf->user = buf->total - buf->free - buf->shared - buf->buffer;
 }

sysdeps/kernel/msg_limits.c

@@ -21,16 +21,10 @@
    Boston, MA 02111-1307, USA.
 */
 
+#include <glibtop.h>
 #include <glibtop/msg_limits.h>
 
-#include <sys/ipc.h>
-#include <sys/msg.h>
-
-static const unsigned long _glibtop_sysdeps_msg_limits =
-(1 << GLIBTOP_IPC_MSGPOOL) + (1 << GLIBTOP_IPC_MSGMAP) +
-(1 << GLIBTOP_IPC_MSGMAX) + (1 << GLIBTOP_IPC_MSGMNB) +
-(1 << GLIBTOP_IPC_MSGMNI) + (1 << GLIBTOP_IPC_MSGSSZ) +
-(1 << GLIBTOP_IPC_MSGTQL);
+static const unsigned long _glibtop_sysdeps_msg_limits = 0;
 
 /* Init function. */
 
@@ -45,21 +39,5 @@ glibtop_init_msg_limits_s (glibtop *server)
 void
 glibtop_get_msg_limits_s (glibtop *server, glibtop_msg_limits *buf)
 {
-	struct msginfo	msginfo;
-  
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_MSG_LIMITS, 0);
-
 	memset (buf, 0, sizeof (glibtop_msg_limits));
-  
-	buf->flags = _glibtop_sysdeps_msg_limits;
-  
-	msgctl (0, IPC_INFO, (struct msqid_ds *) &msginfo);
-  
-	buf->msgpool = msginfo.msgpool;
-	buf->msgmap = msginfo.msgmap;
-	buf->msgmax = msginfo.msgmax;
-	buf->msgmnb = msginfo.msgmnb;
-	buf->msgmni = msginfo.msgmni;
-	buf->msgssz = msginfo.msgssz;
-	buf->msgtql = msginfo.msgtql;
 }

sysdeps/kernel/open.c

@@ -23,33 +23,6 @@
 
 #include <glibtop/open.h>
 
-/* =====================================================
- * Linux kernel version information for procps utilities
- * Copyright (c) 1996 Charles Blake <cblake@bbn.com>
- */
-#include <sys/utsname.h>
-
-#define LINUX_VERSION(x,y,z)   (0x10000*(x) + 0x100*(y) + z)
-
-static int linux_version_code = 0;
-
-static void set_linux_version(void) {
-    static struct utsname uts;
-    int x = 0, y = 0, z = 0;	/* cleared in case sscanf() < 3 */
-    
-    if (linux_version_code) return;
-    if (uname(&uts) == -1)	/* failure most likely implies impending death */
-	exit(1);
-    if (sscanf(uts.release, "%d.%d.%d", &x, &y, &z) < 3)
-	fprintf(stderr,		/* *very* unlikely to happen by accident */
-		"Non-standard uts for running kernel:\n"
-		"release %s=%d.%d.%d gives version code %d\n",
-		uts.release, x, y, z, LINUX_VERSION(x,y,z));
-    linux_version_code = LINUX_VERSION(x, y, z);
-}
-
-/* ======================================================= */
-
 /* Opens pipe to gtop server. Returns 0 on success and -1 on error. */
 
 void
@@ -57,7 +30,4 @@ glibtop_open_s (glibtop *server, const char *program_name,
 		const unsigned long features, const unsigned flags)
 {
 	server->name = program_name;
-	
-	set_linux_version ();
-	server->os_version_code = (unsigned long) linux_version_code;
 }

sysdeps/kernel/procargs.c

@@ -38,7 +38,7 @@ glibtop_init_proc_args_s (glibtop *server)
 
 /* Provides detailed information about a process. */
 
-const char *
+char *
 glibtop_get_proc_args_s (glibtop *server, glibtop_proc_args *buf,
 			 pid_t pid, unsigned max_len)
 {

sysdeps/kernel/procdata.c

@@ -1,180 +0,0 @@
-/* $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 <config.h>
-#include <glibtop/procdata.h>
-
-#include <sys/stat.h>
-
-#define LINUX_VERSION(x,y,z)	(0x10000*(x) + 0x100*(y) + z)
-
-#define BIT_SHIFT(x)		(1 << (x % 32))
-
-static const unsigned long _glibtop_sysdeps_procdata_0 =
-BIT_SHIFT(GLIBTOP_PROCDATA_CMD) +
-BIT_SHIFT(GLIBTOP_PROCDATA_STATE) +
-BIT_SHIFT(GLIBTOP_PROCDATA_UID) +
-BIT_SHIFT(GLIBTOP_PROCDATA_PID) +
-BIT_SHIFT(GLIBTOP_PROCDATA_PPID) +
-BIT_SHIFT(GLIBTOP_PROCDATA_PGRP) +
-BIT_SHIFT(GLIBTOP_PROCDATA_SESSION) +
-BIT_SHIFT(GLIBTOP_PROCDATA_TTY) +
-BIT_SHIFT(GLIBTOP_PROCDATA_TPGID) +
-BIT_SHIFT(GLIBTOP_PROCDATA_PRIORITY) +
-BIT_SHIFT(GLIBTOP_PROCDATA_NICE) +
-BIT_SHIFT(GLIBTOP_PROCDATA_SIGNAL) +
-BIT_SHIFT(GLIBTOP_PROCDATA_BLOCKED) +
-BIT_SHIFT(GLIBTOP_PROCDATA_SIGIGNORE) +
-BIT_SHIFT(GLIBTOP_PROCDATA_SIGCATCH) +
-BIT_SHIFT(GLIBTOP_PROCDATA_START_TIME) +
-BIT_SHIFT(GLIBTOP_PROCDATA_UTIME) +
-BIT_SHIFT(GLIBTOP_PROCDATA_STIME) +
-BIT_SHIFT(GLIBTOP_PROCDATA_CUTIME) +
-BIT_SHIFT(GLIBTOP_PROCDATA_CSTIME) +
-BIT_SHIFT(GLIBTOP_PROCDATA_SIZE) +
-BIT_SHIFT(GLIBTOP_PROCDATA_RESIDENT) +
-BIT_SHIFT(GLIBTOP_PROCDATA_SHARE) +
-BIT_SHIFT(GLIBTOP_PROCDATA_TRS) +
-BIT_SHIFT(GLIBTOP_PROCDATA_LRS) +
-BIT_SHIFT(GLIBTOP_PROCDATA_DRS) +
-BIT_SHIFT(GLIBTOP_PROCDATA_DT) +
-BIT_SHIFT(GLIBTOP_PROCDATA_VSIZE) +
-BIT_SHIFT(GLIBTOP_PROCDATA_RSS) +
-BIT_SHIFT(GLIBTOP_PROCDATA_RSS_RLIM) +
-BIT_SHIFT(GLIBTOP_PROCDATA_TIMEOUT) +
-BIT_SHIFT(GLIBTOP_PROCDATA_IT_REAL_VALUE);
-
-static const unsigned long _glibtop_sysdeps_procdata_1 =
-BIT_SHIFT(GLIBTOP_PROCDATA_K_FLAGS) +
-BIT_SHIFT(GLIBTOP_PROCDATA_MIN_FLT) +
-BIT_SHIFT(GLIBTOP_PROCDATA_MAJ_FLT) +
-BIT_SHIFT(GLIBTOP_PROCDATA_CMIN_FLT) +
-BIT_SHIFT(GLIBTOP_PROCDATA_CMAJ_FLT) +
-BIT_SHIFT(GLIBTOP_PROCDATA_START_CODE) +
-BIT_SHIFT(GLIBTOP_PROCDATA_END_CODE) +
-BIT_SHIFT(GLIBTOP_PROCDATA_START_STACK) +
-BIT_SHIFT(GLIBTOP_PROCDATA_KSTK_ESP) +
-BIT_SHIFT(GLIBTOP_PROCDATA_KSTK_EIP) +
-BIT_SHIFT(GLIBTOP_PROCDATA_WCHAN);
-
-/* Provides detailed information about a process. */
-
-void
-glibtop_get_procdata_s (glibtop *server, glibtop_procdata *buf, pid_t pid)
-{
-	char input [BUFSIZ], *tmp;
-	struct stat statb;
-	int nread;
-	FILE *f;
-	
-	glibtop_init_s (&server, 0, 0);
-	
-	memset (buf, 0, sizeof (glibtop_procdata));
-
-	if (pid == 0) {
-		/* Client is only interested in the flags. */
-		buf->flags [0] = _glibtop_sysdeps_procdata_0;
-		buf->flags [1] = _glibtop_sysdeps_procdata_1;
-		return;
-	}
-
-	
-	sprintf (input, "/proc/%d/stat", pid);
-
-	if (stat (input, &statb)) return;
-
-	buf->uid = statb.st_uid;
-	
-	f = fopen (input, "r");
-	if (!f) return;
-	
-	nread = fread (input, 1, BUFSIZ, f);
-	
-	if (nread < 0) {
-		fclose (f);
-		return;
-	}
-	
-	input [nread] = 0;
-	
-	/* This is from guile-utils/gtop/proc/readproc.c */
-	
-	/* split into "PID (cmd" and "<rest>" */
-	tmp = strrchr (input, ')');
-	*tmp = '\0';		/* replace trailing ')' with NUL */
-	/* parse these two strings separately, skipping the leading "(". */
-	memset (buf->cmd, 0, sizeof (buf->cmd));
-	sscanf (input, "%d (%39c", &buf->pid, buf->cmd);
-	sscanf(tmp + 2,		/* skip space after ')' too */
-	       "%c %d %d %d %d %d %lu %lu %lu %lu %lu "
-	       "%ld %ld %ld %ld %d %d %lu %lu %ld %lu "
-	       "%lu %lu %lu %lu %lu %lu %lu %d %d %d %d %lu",
-	       &buf->state, &buf->ppid, &buf->pgrp, &buf->session,
-	       &buf->tty, &buf->tpgid, &buf->k_flags, &buf->min_flt,
-	       &buf->cmin_flt, &buf->maj_flt, &buf->cmaj_flt,
-	       &buf->utime, &buf->stime, &buf->cutime, &buf->cstime,
-	       &buf->priority, &buf->nice, &buf->timeout,
-	       &buf->it_real_value, &buf->start_time, &buf->vsize,
-	       &buf->rss, &buf->rss_rlim, &buf->start_code,
-	       &buf->end_code, &buf->start_stack, &buf->kstk_esp,
-	       &buf->kstk_eip, &buf->signal, &buf->blocked,
-	       &buf->sigignore, &buf->sigcatch, &buf->wchan);
-
-	if (buf->tty == 0)
-		/* the old notty val, update elsewhere bef. moving to 0 */
-		buf->tty = -1;
-
-	if (server->os_version_code < LINUX_VERSION(1,3,39)) {
-		/* map old meanings to new */
-		buf->priority = 2*15 - buf->priority;
-		buf->nice = 15 - buf->nice;
-	}
-	if (server->os_version_code < LINUX_VERSION(1,1,30) && buf->tty != -1)
-		/* when tty wasn't full devno */
-		buf->tty = 4*0x100 + buf->tty;
-	
-	fclose (f);
-
-	sprintf (input, "/proc/%d/statm", pid);
-
-	f = fopen (input, "r");
-	if (!f) return;
-
-	nread = fread (input, 1, BUFSIZ, f);
-
-	if (nread < 0) {
-		fclose (f);
-		return;
-	}
-
-	input [nread] = 0;
-
-	sscanf (input, "%ld %ld %ld %ld %ld %ld %ld",
-		&buf->size, &buf->resident, &buf->share,
-		&buf->trs, &buf->lrs, &buf->drs, &buf->dt);
-
-	fclose (f);
-
-	buf->flags [0] = _glibtop_sysdeps_procdata_0;
-	buf->flags [1] = _glibtop_sysdeps_procdata_1;
-}

sysdeps/kernel/prockernel.c

@@ -22,16 +22,9 @@
 */
 
 #include <glibtop.h>
-#include <glibtop/error.h>
 #include <glibtop/prockernel.h>
 
-#include "kernel.h"
-
-static const unsigned long _glibtop_sysdeps_proc_kernel =
-(1 << GLIBTOP_PROC_KERNEL_K_FLAGS) + (1 << GLIBTOP_PROC_KERNEL_MIN_FLT) +
-(1 << GLIBTOP_PROC_KERNEL_MAJ_FLT) + (1 << GLIBTOP_PROC_KERNEL_CMIN_FLT) +
-(1 << GLIBTOP_PROC_KERNEL_CMAJ_FLT) + (1 << GLIBTOP_PROC_KERNEL_KSTK_ESP) +
-(1 << GLIBTOP_PROC_KERNEL_KSTK_EIP) + (1 << GLIBTOP_PROC_KERNEL_NWCHAN);
+static const unsigned long _glibtop_sysdeps_proc_kernel = 0;
 
 /* Init function. */
 
@@ -47,22 +40,5 @@ void
 glibtop_get_proc_kernel_s (glibtop *server, glibtop_proc_kernel *buf,
 			   pid_t pid)
 {
-	union table tbl;
-	
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_PROC_KERNEL, 0);
-	
 	memset (buf, 0, sizeof (glibtop_proc_kernel));
-	
-	if (table (TABLE_PROC_KERNEL, &tbl, &pid))
-		glibtop_error_io_r (server, "table(TABLE_PROC_KERNEL)");
-	
-	buf->flags = _glibtop_sysdeps_proc_kernel;
-	
-	buf->min_flt = tbl.proc_kernel.min_flt;
-	buf->cmin_flt = tbl.proc_kernel.cmin_flt;
-	buf->maj_flt = tbl.proc_kernel.maj_flt;
-	buf->cmaj_flt = tbl.proc_kernel.cmaj_flt;
-	buf->kstk_esp = tbl.proc_kernel.kesp;
-	buf->kstk_eip = tbl.proc_kernel.keip;
-	buf->nwchan = tbl.proc_kernel.wchan;
 }

sysdeps/kernel/proclist.c

@@ -22,14 +22,11 @@
 */
 
 #include <glibtop.h>
-#include <glibtop/xmalloc.h>
 #include <glibtop/proclist.h>
 
-#include "kernel.h"
+#define GLIBTOP_PROCLIST_FLAGS	3
 
-static const unsigned long _glibtop_sysdeps_proclist =
-(1 << GLIBTOP_PROCLIST_TOTAL) + (1 << GLIBTOP_PROCLIST_NUMBER) +
-(1 << GLIBTOP_PROCLIST_SIZE);
+static const unsigned long _glibtop_sysdeps_proclist = 0;
 
 /* Init function. */
 
@@ -39,48 +36,17 @@ 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.
  *
- * The interface of this function is a little bit different from the others:
- * buf->flags is only set if the call succeeded, in this case pids_chain,
- * a list of the pids of all currently running processes is returned,
- * buf->number is the number of elements of this list and buf->size is
- * the size of one single element (sizeof (unsigned)). The total size is
- * stored in buf->total.
- *
- * The calling function has to free the memory to which a pointer is returned.
- *
- * On error, NULL is returned and buf->flags is zero. */
+ * 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)
 {
-	union table tbl;
-	unsigned *pids_chain;
-	struct proclist_args args;
-
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_PROCLIST, 0);
-
 	memset (buf, 0, sizeof (glibtop_proclist));
-
-	args.which = which;
-	args.arg = arg;
-
-	if (table (TABLE_PROCLIST, &tbl, &args))
-		glibtop_error_io_r (server, "table(TABLE_PROCLIST)");
-
-	buf->size = sizeof (unsigned);
-	buf->number = tbl.proclist.nr_tasks;
-
-	buf->total = buf->number * sizeof (unsigned);
-
-	pids_chain = glibtop_malloc_r (server, buf->total);
-
-	memcpy (pids_chain, tbl.proclist.pids, buf->total);
-
-	return pids_chain;
+	return NULL;
 }

sysdeps/kernel/procmap.c

@@ -21,6 +21,7 @@
    Boston, MA 02111-1307, USA.
 */
 
+
 #include <glibtop.h>
 #include <glibtop/error.h>
 #include <glibtop/xmalloc.h>

sysdeps/kernel/procmem.c

@@ -22,15 +22,9 @@
 */
 
 #include <glibtop.h>
-#include <glibtop/error.h>
 #include <glibtop/procmem.h>
 
-#include "kernel.h"
-
-static const unsigned long _glibtop_sysdeps_proc_mem =
-(1 << GLIBTOP_PROC_MEM_SIZE) + (1 << GLIBTOP_PROC_MEM_VSIZE) +
-(1 << GLIBTOP_PROC_MEM_RESIDENT) + (1 << GLIBTOP_PROC_MEM_SHARE) +
-(1 << GLIBTOP_PROC_MEM_RSS) + (1 << GLIBTOP_PROC_MEM_RSS_RLIM);
+static const unsigned long _glibtop_sysdeps_proc_mem = 0;
 
 /* Init function. */
 
@@ -46,25 +40,5 @@ void
 glibtop_get_proc_mem_s (glibtop *server, glibtop_proc_mem *buf,
 			pid_t pid)
 {
-	union table tbl;
-
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_PROC_MEM, 0);
-
 	memset (buf, 0, sizeof (glibtop_proc_mem));
-
-	if (table (TABLE_PROC_MEM, &tbl, &pid))
-		glibtop_error_io_r (server, "table(TABLE_PROC_MEM)");
-	
-	buf->rss = tbl.proc_mem.rss;
-	buf->rss_rlim = tbl.proc_mem.rlim;
-
-	if (table (TABLE_PROC_SEGMENT, &tbl, &pid))
-		glibtop_error_io_r (server, "table(TABLE_PROC_SEGMENT)");
-	
-	buf->flags = _glibtop_sysdeps_proc_mem;
-
-	buf->vsize = tbl.proc_segment.vsize;
-	buf->size = tbl.proc_segment.size;
-	buf->resident = tbl.proc_segment.resident;
-	buf->share = tbl.proc_segment.shared;
 }

sysdeps/kernel/procsegment.c

@@ -21,21 +21,10 @@
    Boston, MA 02111-1307, USA.
 */
 
-#include <config.h>
-#include <glibtop/error.h>
+#include <glibtop.h>
 #include <glibtop/procsegment.h>
 
-#include "kernel.h"
-
-static const unsigned long _glibtop_sysdeps_proc_segment =
-(1 << GLIBTOP_PROC_SEGMENT_TEXT_RSS) +
-(1 << GLIBTOP_PROC_SEGMENT_SHLIB_RSS) +
-(1 << GLIBTOP_PROC_SEGMENT_DATA_RSS) +
-(1 << GLIBTOP_PROC_SEGMENT_STACK_RSS) +
-(1 << GLIBTOP_PROC_SEGMENT_DIRTY_SIZE) +
-(1 << GLIBTOP_PROC_SEGMENT_START_CODE) +
-(1 << GLIBTOP_PROC_SEGMENT_END_CODE) +
-(1 << GLIBTOP_PROC_SEGMENT_START_STACK);
+static const unsigned long _glibtop_sysdeps_proc_segment = 0;
 
 /* Init function. */
 
@@ -51,27 +40,5 @@ void
 glibtop_get_proc_segment_s (glibtop *server, glibtop_proc_segment *buf,
 			    pid_t pid)
 {
-	union table tbl;
-
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_PROC_SEGMENT, 0);
-
 	memset (buf, 0, sizeof (glibtop_proc_segment));
-
-	if (table (TABLE_PROC_MEM, &tbl, &pid))
-		glibtop_error_io_r (server, "table(TABLE_PROC_MEM)");
-	
-	buf->start_code = tbl.proc_mem.start_code;
-	buf->end_code = tbl.proc_mem.end_code;
-	buf->start_stack = tbl.proc_mem.start_stack;
-
-	if (table (TABLE_PROC_SEGMENT, &tbl, &pid))
-		glibtop_error_io_r (server, "table(TABLE_PROC_SEGMENT)");
-
-	buf->flags = _glibtop_sysdeps_proc_segment;
-
-	buf->text_rss	= tbl.proc_segment.trs;
-	buf->shlib_rss	= tbl.proc_segment.lrs;
-	buf->data_rss	= tbl.proc_segment.drs;
-	buf->stack_rss	= tbl.proc_segment.srs;
-	buf->dirty_size	= tbl.proc_segment.dt;
 }

sysdeps/kernel/procsignal.c

@@ -22,14 +22,9 @@
 */
 
 #include <glibtop.h>
-#include <glibtop/error.h>
 #include <glibtop/procsignal.h>
 
-#include "kernel.h"
-
-static const unsigned long _glibtop_sysdeps_proc_signal =
-(1 << GLIBTOP_PROC_SIGNAL_SIGNAL) + (1 << GLIBTOP_PROC_SIGNAL_BLOCKED) +
-(1 << GLIBTOP_PROC_SIGNAL_SIGIGNORE) + (1 << GLIBTOP_PROC_SIGNAL_SIGCATCH);
+static const unsigned long _glibtop_sysdeps_proc_signal = 0;
 
 /* Init function. */
 
@@ -45,19 +40,5 @@ void
 glibtop_get_proc_signal_s (glibtop *server, glibtop_proc_signal *buf,
 			   pid_t pid)
 {
-	union table tbl;
-
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_PROC_SIGNAL, 0);
-
 	memset (buf, 0, sizeof (glibtop_proc_signal));
-
-	if (table (TABLE_PROC_SIGNAL, &tbl, &pid))
-		glibtop_error_io_r (server, "table(TABLE_PROC_SIGNAL)");
-
-	buf->flags = _glibtop_sysdeps_proc_signal;
-
-	buf->signal [0] = tbl.proc_signal.signal;
-	buf->blocked [0] = tbl.proc_signal.blocked;
-	buf->sigignore [0] = tbl.proc_signal.ignored;
-	buf->sigcatch [0] = tbl.proc_signal.caught;
 }

sysdeps/kernel/procstate.c

@@ -22,14 +22,9 @@
 */
 
 #include <glibtop.h>
-#include <glibtop/error.h>
 #include <glibtop/procstate.h>
 
-#include "kernel.h"
-
-static const unsigned long _glibtop_sysdeps_proc_state =
-(1 << GLIBTOP_PROC_STATE_CMD) + (1 << GLIBTOP_PROC_STATE_STATE) +
-(1 << GLIBTOP_PROC_STATE_UID) + (1 << GLIBTOP_PROC_STATE_GID);
+static const unsigned long _glibtop_sysdeps_proc_state = 0;
 
 /* Init function. */
 
@@ -41,35 +36,9 @@ glibtop_init_proc_state_s (glibtop *server)
 
 /* Provides detailed information about a process. */
 
-#define NR_STATES	7
-
 void
 glibtop_get_proc_state_s (glibtop *server, glibtop_proc_state *buf,
 			  pid_t pid)
 {
-	union table tbl;
-	static const char states [NR_STATES] =
-	{ 'R', 'S', 'D', 'Z', 'T', 'W', '.' };
-	unsigned state;
-
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_PROC_STATE, 0);
-
 	memset (buf, 0, sizeof (glibtop_proc_state));
-
-	if (table (TABLE_PROC_STATE, &tbl, &pid))
-		glibtop_error_io_r (server, "table(TABLE_PROC_STATE)");
-
-	buf->flags = _glibtop_sysdeps_proc_state;
-
-	memcpy (buf->cmd, tbl.proc_state.comm, sizeof (tbl.proc_state.comm));
-
-	buf->uid = tbl.proc_state.uid;
-	buf->gid = tbl.proc_state.state;
-
-	state = (unsigned) tbl.proc_state.state;
-
-	if (state >= NR_STATES)
-		state = NR_STATES;
-
-	buf->state = states [state];
 }

sysdeps/kernel/proctime.c

@@ -22,17 +22,9 @@
 */
 
 #include <glibtop.h>
-#include <glibtop/error.h>
 #include <glibtop/proctime.h>
 
-#include "kernel.h"
-
-static const unsigned long _glibtop_sysdeps_proc_time =
-(1 << GLIBTOP_PROC_TIME_UTIME) + (1 << GLIBTOP_PROC_TIME_CUTIME) +
-(1 << GLIBTOP_PROC_TIME_STIME) + (1 << GLIBTOP_PROC_TIME_CSTIME) +
-(1 << GLIBTOP_PROC_TIME_RTIME) + (1 << GLIBTOP_PROC_TIME_FREQUENCY) +
-(1 << GLIBTOP_PROC_TIME_TIMEOUT) + (1 << GLIBTOP_PROC_TIME_IT_REAL_VALUE) +
-(1 << GLIBTOP_PROC_TIME_START_TIME);
+static const unsigned long _glibtop_sysdeps_proc_time = 0;
 
 /* Init function. */
 
@@ -48,26 +40,5 @@ void
 glibtop_get_proc_time_s (glibtop *server, glibtop_proc_time *buf,
 			 pid_t pid)
 {
-	union table tbl;
-
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_PROC_TIME, 0);
-
 	memset (buf, 0, sizeof (glibtop_proc_time));
-
-	if (table (TABLE_PROC_TIME, &tbl, &pid))
-	  glibtop_error_io_r (server, "table(TABLE_PROC_TIME)");
-
-	buf->utime = tbl.proc_time.utime;
-	buf->stime = tbl.proc_time.stime;
-
-	buf->rtime = buf->utime + buf->stime;
-
-	buf->cutime = tbl.proc_time.cutime;
-	buf->cstime = tbl.proc_time.cstime;
-
-	buf->frequency = 100;
-
-	buf->timeout = tbl.proc_time.timeout;
-	buf->it_real_value = tbl.proc_time.it_real_value;
-	buf->start_time = tbl.proc_time.start_time;
 }

sysdeps/kernel/procuid.c

@@ -22,18 +22,9 @@
 */
 
 #include <glibtop.h>
-#include <glibtop/error.h>
 #include <glibtop/procuid.h>
 
-#include "kernel.h"
-
-static const unsigned long _glibtop_sysdeps_proc_uid =
-(1 << GLIBTOP_PROC_UID_UID) + (1 << GLIBTOP_PROC_UID_EUID) +
-(1 << GLIBTOP_PROC_UID_GID) + (1 << GLIBTOP_PROC_UID_EGID) +
-(1 << GLIBTOP_PROC_UID_PID) + (1 << GLIBTOP_PROC_UID_PPID) +
-(1 << GLIBTOP_PROC_UID_PGRP) + (1 << GLIBTOP_PROC_UID_SESSION) +
-(1 << GLIBTOP_PROC_UID_TTY) + (1 << GLIBTOP_PROC_UID_TPGID) +
-(1 << GLIBTOP_PROC_UID_PRIORITY) + (1 << GLIBTOP_PROC_UID_NICE);
+static const unsigned long _glibtop_sysdeps_proc_uid = 0;
 
 /* Init function. */
 
@@ -43,63 +34,11 @@ glibtop_init_proc_uid_s (glibtop *server)
 	server->sysdeps.proc_uid = _glibtop_sysdeps_proc_uid;
 }
 
-#define LINUX_VERSION(x,y,z)	(0x10000*(x) + 0x100*(y) + z)
-
 /* Provides detailed information about a process. */
 
 void
 glibtop_get_proc_uid_s (glibtop *server, glibtop_proc_uid *buf,
 			pid_t pid)
 {
-	union table tbl;
-	long def_priority, priority, nice;
-	
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_PROC_UID, 0);
-
 	memset (buf, 0, sizeof (glibtop_proc_uid));
-
-	if (table (TABLE_PROC_UID, &tbl, &pid))
-	  glibtop_error_io_r (server, "table(TABLE_PROC_UID)");
-
-	buf->flags = _glibtop_sysdeps_proc_uid;
-
-	buf->uid = tbl.proc_uid.uid;
-	buf->euid = tbl.proc_uid.euid;
-	buf->gid = tbl.proc_uid.gid;
-	buf->egid = tbl.proc_uid.egid;
-
-	buf->pid = tbl.proc_uid.pid;
-	buf->ppid = tbl.proc_uid.ppid;
-	buf->pgrp = tbl.proc_uid.pgrp;
-	buf->session = tbl.proc_uid.session;
-	buf->tty = tbl.proc_uid.tty;
-	buf->tpgid = tbl.proc_uid.tpgid;
-
-	/* scale priority and nice values from timeslices to -20..20 */
-	/* to make it look like a "normal" unix priority/nice value  */
-
-	def_priority = tbl.proc_uid.def_priority;
-
-	priority = tbl.proc_uid.counter;
-	priority = 20 - (priority * 10 + def_priority / 2) / def_priority;
-	nice = tbl.proc_uid.priority;
-	nice = 20 - (nice * 20 + def_priority / 2) / def_priority;
-
-	buf->priority = (int) priority;
-	buf->nice = (int) nice;
-
-	if (buf->tty == 0)
-		/* the old notty val, update elsewhere bef. moving to 0 */
-		buf->tty = -1;
-	
-	if (server->os_version_code < LINUX_VERSION(1,3,39)) {
-		/* map old meanings to new */
-		buf->priority = 2*15 - buf->priority;
-		buf->nice = 15 - buf->nice;
-	}
-	if (server->os_version_code < LINUX_VERSION(1,1,30) && buf->tty != -1)
-		/* when tty wasn't full devno */
-		buf->tty = 4*0x100 + buf->tty;
-	
-	buf->flags = _glibtop_sysdeps_proc_uid;
 }

sysdeps/kernel/sem_limits.c

@@ -21,32 +21,10 @@
    Boston, MA 02111-1307, USA.
 */
 
+#include <glibtop.h>
 #include <glibtop/sem_limits.h>
 
-#include <sys/ipc.h>
-#include <sys/sem.h>
-
-#ifdef _SEM_SEMUN_UNDEFINED
-
-/* glibc 2.1 will no longer defines semun, instead it defines
- * _SEM_SEMUN_UNDEFINED so users can define semun on their own.
- * Thanks to Albert K T Hui <avatar@deva.net>. */
-
-union semun
-{
-	int val;
-	struct semid_ds *buf;
-	unsigned short int *array;
-	struct seminfo *__buf;
-};
-#endif
-
-static unsigned long _glibtop_sysdeps_sem_limits =
-(1 << GLIBTOP_IPC_SEMMAP) + (1 << GLIBTOP_IPC_SEMMNI) +
-(1 << GLIBTOP_IPC_SEMMNS) + (1 << GLIBTOP_IPC_SEMMNU) +
-(1 << GLIBTOP_IPC_SEMMSL) + (1 << GLIBTOP_IPC_SEMOPM) +
-(1 << GLIBTOP_IPC_SEMUME) + (1 << GLIBTOP_IPC_SEMUSZ) +
-(1 << GLIBTOP_IPC_SEMVMX) + (1 << GLIBTOP_IPC_SEMAEM);
+static const unsigned long _glibtop_sysdeps_sem_limits = 0;
 
 /* Init function. */
 
@@ -56,31 +34,10 @@ glibtop_init_sem_limits_s (glibtop *server)
 	server->sysdeps.sem_limits = _glibtop_sysdeps_sem_limits;
 }
 
-/* Provides information about sysv ipc limits. */
+/* Provides information about sysv sem limits. */
 
 void
 glibtop_get_sem_limits_s (glibtop *server, glibtop_sem_limits *buf)
 {
-	struct seminfo	seminfo;
-	union semun	arg;  
-  
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_SEM_LIMITS, 0);
-
 	memset (buf, 0, sizeof (glibtop_sem_limits));
-  
-	buf->flags = _glibtop_sysdeps_sem_limits;
-  
-	arg.array = (ushort *) &seminfo;
-	semctl (0, 0, IPC_INFO, arg);
-  
-	buf->semmap = seminfo.semmap;
-	buf->semmni = seminfo.semmni;
-	buf->semmns = seminfo.semmns;
-	buf->semmnu = seminfo.semmnu;
-	buf->semmsl = seminfo.semmsl;
-	buf->semopm = seminfo.semopm;
-	buf->semume = seminfo.semume;
-	buf->semusz = seminfo.semusz;
-	buf->semvmx = seminfo.semvmx;
-	buf->semaem = seminfo.semaem;
 }

sysdeps/kernel/shm_limits.c

@@ -21,15 +21,10 @@
    Boston, MA 02111-1307, USA.
 */
 
+#include <glibtop.h>
 #include <glibtop/shm_limits.h>
 
-#include <sys/ipc.h>
-#include <sys/shm.h>
-
-static unsigned long _glibtop_sysdeps_shm_limits =
-(1 << GLIBTOP_IPC_SHMMAX) + (1 << GLIBTOP_IPC_SHMMIN) +
-(1 << GLIBTOP_IPC_SHMMNI) + (1 << GLIBTOP_IPC_SHMSEG) +
-(1 << GLIBTOP_IPC_SHMALL);
+static const unsigned long _glibtop_sysdeps_shm_limits = 0;
 
 /* Init function. */
 
@@ -44,19 +39,5 @@ glibtop_init_shm_limits_s (glibtop *server)
 void
 glibtop_get_shm_limits_s (glibtop *server, glibtop_shm_limits *buf)
 {
-	struct shminfo	shminfo;
-  
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_SHM_LIMITS, 0);
-
 	memset (buf, 0, sizeof (glibtop_shm_limits));
-  
-	buf->flags = _glibtop_sysdeps_shm_limits;
-  
-	shmctl (0, IPC_INFO, (struct shmid_ds *) &shminfo);
-  
-	buf->shmmax = shminfo.shmmax;
-	buf->shmmin = shminfo.shmmin;
-	buf->shmmni = shminfo.shmmni;
-	buf->shmseg = shminfo.shmseg;
-	buf->shmall = shminfo.shmall;
 }

sysdeps/kernel/siglist.c

@@ -25,36 +25,4 @@
 #include <glibtop/signal.h>
 
 const glibtop_signame glibtop_sys_siglist [] =
-{ {  1, "SIGHUP",    NULL },	/* Hangup (POSIX).  */
-  {  2, "SIGINT",    NULL },	/* Interrupt (ANSI).  */
-  {  3, "SIGQUIT",   NULL },	/* Quit (POSIX).  */
-  {  4, "SIGILL",    NULL },	/* Illegal instruction (ANSI).  */
-  {  5, "SIGTRAP",   NULL },	/* Trace trap (POSIX).  */
-  {  6, "SIGABRT",   NULL },	/* Abort (ANSI).  */
-  {  7, "SIGBUS",    NULL },	/* BUS error (4.2 BSD).  */
-  {  8, "SIGFPE",    NULL },	/* Floating-point exception (ANSI).  */
-  {  9, "SIGKILL",   NULL },	/* Kill, unblockable (POSIX).  */
-  { 10, "SIGUSR1",   NULL },	/* User-defined signal 1 (POSIX).  */
-  { 11, "SIGSEGV",   NULL },	/* Segmentation violation (ANSI).  */
-  { 12, "SIGUSR2",   NULL },	/* User-defined signal 2 (POSIX).  */
-  { 13, "SIGPIPE",   NULL },	/* Broken pipe (POSIX).  */
-  { 14, "SIGALRM",   NULL },	/* Alarm clock (POSIX).  */
-  { 15, "SIGTERM",   NULL },	/* Termination (ANSI).  */
-  { 16, "SIGSTKFLT", NULL },	/* ??? */
-  { 17, "SIGCHLD",   NULL },	/* Child status has changed (POSIX).  */
-  { 18, "SIGCONT",   NULL },	/* Continue (POSIX).  */
-  { 19, "SIGSTOP",   NULL },	/* Stop, unblockable (POSIX).  */
-  { 20, "SIGTSTP",   NULL },	/* Keyboard stop (POSIX).  */
-  { 21, "SIGTTIN",   NULL },	/* Background read from tty (POSIX).  */
-  { 22, "SIGTTOU",   NULL },	/* Background write to tty (POSIX).  */
-  { 23, "SIGURG",    NULL },	/* Urgent condition on socket (4.2 BSD).  */
-  { 24, "SIGXCPU",   NULL },	/* CPU limit exceeded (4.2 BSD).  */
-  { 25, "SIGXFSZ",   NULL },	/* File size limit exceeded (4.2 BSD).  */
-  { 26, "SIGVTALRM", NULL },	/* Virtual alarm clock (4.2 BSD).  */
-  { 27, "SIGPROF",   NULL },	/* Profiling alarm clock (4.2 BSD).  */
-  { 28, "SIGWINCH",  NULL },	/* Window size change (4.3 BSD, Sun).  */
-  { 29, "SIGIO",     NULL },	/* I/O now possible (4.2 BSD).  */
-  { 30, "SIGPWR",    NULL },	/* Power failure restart (System V).  */
-  { 31, "SIGUNUSED", NULL },
-  {  0, NULL,        NULL },
-};
+{ { 0, NULL, NULL } };

sysdeps/kernel/swap.c

@@ -21,16 +21,10 @@
    Boston, MA 02111-1307, USA.
 */
 
-#include <config.h>
-#include <glibtop/error.h>
+#include <glibtop.h>
 #include <glibtop/swap.h>
 
-#include "kernel.h"
-
-static unsigned long _glibtop_sysdeps_swap =
-(1 << GLIBTOP_SWAP_TOTAL) + (1 << GLIBTOP_SWAP_USED) +
-(1 << GLIBTOP_SWAP_FREE) + (1 << GLIBTOP_SWAP_PAGEIN) +
-(1 << GLIBTOP_SWAP_PAGEOUT);
+static const unsigned long _glibtop_sysdeps_swap = 0;
 
 /* Init function. */
 
@@ -45,21 +39,5 @@ glibtop_init_swap_s (glibtop *server)
 void
 glibtop_get_swap_s (glibtop *server, glibtop_swap *buf)
 {
-	union table tbl;
-	
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_SWAP, 0);
-
 	memset (buf, 0, sizeof (glibtop_swap));
-
-	if (table (TABLE_SWAP, &tbl, NULL))
-		glibtop_error_io_r (server, "table(TABLE_SWAP)");
-
-	buf->flags = _glibtop_sysdeps_swap;
-
-	buf->total = tbl.swap.total;
-	buf->used  = tbl.swap.used;
-	buf->free  = tbl.swap.free;
-
-	buf->pagein  = tbl.swap.pagein;
-	buf->pageout = tbl.swap.pageout;
 }

sysdeps/kernel/uptime.c

@@ -21,14 +21,10 @@
    Boston, MA 02111-1307, USA.
 */
 
-#include <config.h>
-#include <glibtop/error.h>
+#include <glibtop.h>
 #include <glibtop/uptime.h>
 
-#include "kernel.h"
-
-static unsigned long _glibtop_sysdeps_uptime =
-(1 << GLIBTOP_UPTIME_UPTIME) + (1 << GLIBTOP_UPTIME_IDLETIME);
+static const unsigned long _glibtop_sysdeps_uptime = 0;
 
 /* Init function. */
 
@@ -43,22 +39,5 @@ glibtop_init_uptime_s (glibtop *server)
 void
 glibtop_get_uptime_s (glibtop *server, glibtop_uptime *buf)
 {
-	union table tbl;
-	
-	glibtop_init_s (&server, GLIBTOP_SYSDEPS_UPTIME, 0);
-
 	memset (buf, 0, sizeof (glibtop_uptime));
-
-	if (table (TABLE_UPTIME, &tbl, NULL))
-		glibtop_error_io_r (server, "table(TABLE_UPTIME)");
-	
-	buf->flags = _glibtop_sysdeps_uptime;
-
-#if 0
-	fprintf (stderr, "Table (%u) = %lu, %lu\n",
-		 TABLE_UPTIME, tbl.uptime.uptime, tbl.uptime.idle);
-#endif
-
-	buf->uptime = (double) tbl.uptime.uptime / HZ;
-	buf->idletime = (double) tbl.uptime.idle / HZ;
 }

sysdeps/linux/sysinfo.c

@@ -64,11 +64,13 @@ init_sysinfo (glibtop *server)
 
 		p = strchr (buffer, ':');
 		if (!p) continue;
-		
+
+		/* Remove leading spaces from `p'. */
 		*p = '\0'; start = p; p++;
 		while (isspace (*p)) p++;
 
-		while ((start > buffer) && isspace (*start))
+		/* Remove trailing spaces from `buffer'. */
+		while ((start > buffer) && (*start) && isspace (*start))
 			*start-- = '\0';
 
 		key = g_strdup (buffer);

sysdeps/solaris/.cvsignore

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

sysdeps/solaris/ChangeLog

@@ -0,0 +1,36 @@
+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'.
+

sysdeps/solaris/Makefile.am

@@ -0,0 +1,18 @@
+LINK				= $(LIBTOOL) --mode=link $(CC) $(CFLAGS) $(LDFLAGS) -o $@
+
+INCLUDES			= @INCLUDES@
+
+lib_LTLIBRARIES			= libgtop_sysdeps.la
+
+libgtop_sysdeps_la_SOURCES	= open.c close.c siglist.c cpu.c mem.c swap.c \
+				  uptime.c loadavg.c shm_limits.c msg_limits.c \
+				  sem_limits.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_la_LDFLAGS	= $(LT_VERSION_INFO)
+
+include_HEADERS			= glibtop_server.h glibtop_machine.h
+noinst_HEADERS			= glibtop_private.h
+

sysdeps/solaris/close.c

@@ -21,20 +21,10 @@
    Boston, MA 02111-1307, USA.
 */
 
-#ifndef __GLIBTOP_KERNEL_KERNEL_H__
-#define __GLIBTOP_KERNEL_KERNEL_H__
+#include <glibtop/close.h>
 
-#include <linux/unistd.h>
-#include <linux/table.h>
+/* Closes pipe to gtop server. */
 
-#include <sys/param.h>
-
-#include <syscall.h>
-
-BEGIN_LIBGTOP_DECLS
-
-extern int table (int, union table *, const void *);
-
-END_LIBGTOP_DECLS
-
-#endif
+void
+glibtop_close_s (glibtop *server)
+{ }

sysdeps/solaris/cpu.c

@@ -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/cpu.h>
+
+static const unsigned long _glibtop_sysdeps_cpu =
+(1 << GLIBTOP_CPU_TOTAL) + (1 << GLIBTOP_CPU_USER) +
+(1 << GLIBTOP_CPU_SYS) + (1 << GLIBTOP_CPU_IDLE) +
+(1 << GLIBTOP_XCPU_TOTAL) + (1 << GLIBTOP_XCPU_USER) +
+(1 << GLIBTOP_XCPU_SYS) + (1 << GLIBTOP_XCPU_IDLE);
+
+/* 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;
+    int cpu, ncpu;
+    kid_t ret;
+
+    memset (buf, 0, sizeof (glibtop_cpu));
+
+    ncpu = server->ncpu;
+    if (ncpu > GLIBTOP_NCPU) ncpu = GLIBTOP_NCPU;
+
+    for (cpu = 0; cpu < ncpu; cpu++) {
+	kstat_t *ksp = server->machine.cpu_stat_kstat [cpu];
+	if (!ksp) 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_IDLE];
+	buf->xcpu_sys [cpu] = cpu_stat.cpu_sysinfo.cpu [CPU_IDLE];
+
+	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->flags = _glibtop_sysdeps_cpu;
+}

sysdeps/solaris/glibtop_machine.h

@@ -0,0 +1,54 @@
+/* $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>
+#include <procfs.h>
+#include <fcntl.h>
+
+#include <kstat.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;
+
+    kstat_ctl_t *kc;
+    
+    kstat_t *vminfo_kstat;
+    hrtime_t vminfo_snaptime;
+    vminfo_t vminfo;
+
+    kstat_t *cpu_stat_kstat [64];
+};
+
+END_LIBGTOP_DECLS
+
+#endif __GLIBTOP_MACHINE_H__

sysdeps/solaris/glibtop_private.h

@@ -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>, 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 <procfs.h>
+#include <kstat.h>
+#include <fcntl.h>
+
+BEGIN_LIBGTOP_DECLS
+
+/* Read /proc/<pid>/psinfo */
+int glibtop_get_proc_data_psinfo_s (glibtop *server, struct psinfo *psinfo, pid_t pid);
+
+/* Read /proc/<pid>/usage */
+int glibtop_get_proc_data_usage_s (glibtop *server, struct prusage *prusage, pid_t pid);
+
+END_LIBGTOP_DECLS
+
+#endif __GLIBTOP_PRIVATE_H__

sysdeps/solaris/glibtop_server.h

@@ -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		0
+#define GLIBTOP_SUID_MSG_LIMITS		0
+#define GLIBTOP_SUID_SEM_LIMITS		0
+#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

sysdeps/solaris/loadavg.c

@@ -0,0 +1,51 @@
+/* $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>
+
+#include <sys/loadavg.h>
+
+static const unsigned long _glibtop_sysdeps_loadavg =
+(1 << GLIBTOP_LOADAVG_LOADAVG);
+
+/* Init function. */
+
+void
+glibtop_init_loadavg_s (glibtop *server)
+{
+	server->sysdeps.loadavg = _glibtop_sysdeps_loadavg;
+}
+
+/* Provides load averange. */
+
+void
+glibtop_get_loadavg_s (glibtop *server, glibtop_loadavg *buf)
+{
+	memset (buf, 0, sizeof (glibtop_loadavg));
+
+	if (getloadavg (buf->loadavg, 3))
+		return;
+
+	buf->flags = _glibtop_sysdeps_loadavg;
+}

sysdeps/solaris/mem.c

@@ -0,0 +1,43 @@
+/* $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>
+
+static const unsigned long _glibtop_sysdeps_mem = 0;
+
+/* Init function. */
+
+void
+glibtop_init_mem_s (glibtop *server)
+{
+	server->sysdeps.mem = _glibtop_sysdeps_mem;
+}
+
+/* Provides information about memory usage. */
+
+void
+glibtop_get_mem_s (glibtop *server, glibtop_mem *buf)
+{
+	memset (buf, 0, sizeof (glibtop_mem));
+}

sysdeps/solaris/msg_limits.c

@@ -0,0 +1,43 @@
+/* $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>
+
+static const unsigned long _glibtop_sysdeps_msg_limits = 0;
+
+/* Init function. */
+
+void
+glibtop_init_msg_limits_s (glibtop *server)
+{
+	server->sysdeps.msg_limits = _glibtop_sysdeps_msg_limits;
+}
+
+/* Provides information about sysv ipc limits. */
+
+void
+glibtop_get_msg_limits_s (glibtop *server, glibtop_msg_limits *buf)
+{
+	memset (buf, 0, sizeof (glibtop_msg_limits));
+}

sysdeps/solaris/netload.c

@@ -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));
+}

sysdeps/solaris/open.c

@@ -0,0 +1,65 @@
+/* $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>
+
+/* Opens pipe to gtop server. Returns 0 on success and -1 on error. */
+
+void
+glibtop_open_s (glibtop *server, const char *program_name,
+		const unsigned long features, const unsigned flags)
+{
+    kstat_t *ksp;
+
+    server->name = program_name;
+
+    server->machine.kc = kstat_open ();
+
+    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;
+	}
+    }
+
+    if (!server->machine.kc)
+	glibtop_error_io_r (server, "kstat_open ()");
+
+    fprintf (stderr, "Sleeping 2 seconds, please wait ...\n");
+    sleep (2);
+}

sysdeps/solaris/ppp.c

@@ -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));
+}

sysdeps/solaris/procargs.c

@@ -0,0 +1,47 @@
+/* $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 = 0;
+
+/* 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)
+{
+	memset (buf, 0, sizeof (glibtop_proc_args));
+	return NULL;
+}

sysdeps/solaris/procdata.c

@@ -0,0 +1,73 @@
+/* $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>
+
+/* 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 = open (buffer, O_RDONLY);
+	if (fd < 0) {
+		glibtop_warn_io_r (server, "open (%s)", buffer);
+		return -1;
+	}
+
+	if (read (fd, psinfo, sizeof (struct psinfo)) != sizeof (struct psinfo)) {
+		close (fd);
+		glibtop_warn_io_r (server, "read (%s)", buffer);
+		return -1;
+	}
+
+	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 = open (buffer, O_RDONLY);
+	if (fd < 0) {
+		glibtop_warn_io_r (server, "open (%s)", buffer);
+		return -1;
+	}
+
+	if (read (fd, prusage, sizeof (struct prusage)) != sizeof (struct prusage)) {
+		close (fd);
+		glibtop_warn_io_r (server, "read (%s)", buffer);
+		return -1;
+	}
+
+	close (fd);
+	return 0;
+}

sysdeps/solaris/prockernel.c

@@ -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));
+}

sysdeps/solaris/proclist.c

@@ -0,0 +1,162 @@
+/* $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 =
+(1 << GLIBTOP_PROCLIST_TOTAL) + (1 << GLIBTOP_PROCLIST_NUMBER) +
+(1 << 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;
+	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));
+
+	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? */
+		
+		for (i = 0; i < len; i++)
+			if (!isdigit (entry->d_name [i])) ok = 0;
+		if (!ok) continue;
+
+		/* convert it in a number */
+
+		if (sscanf (entry->d_name, "%u", &pid) != 1) continue;
+
+		/* is it really a directory? */
+
+		sprintf (buffer, "/proc/%d", pid);
+		
+		if (stat (buffer, &statb)) continue;
+
+		if (!S_ISDIR (statb.st_mode)) continue;
+
+		/* 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++;
+	}
+	
+	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;
+}

sysdeps/solaris/procmap.c

@@ -0,0 +1,50 @@
+/* $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>
+
+static const unsigned long _glibtop_sysdeps_proc_map = 0;
+
+/* 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)
+{
+	glibtop_init_s (&server, GLIBTOP_SYSDEPS_PROC_MAP, 0);
+	
+	memset (buf, 0, sizeof (glibtop_proc_map));
+	
+	return NULL;
+}

sysdeps/solaris/procmem.c

@@ -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/procmem.h>
+
+static const unsigned long _glibtop_sysdeps_proc_mem = 0;
+
+/* 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)
+{
+	memset (buf, 0, sizeof (glibtop_proc_mem));
+}

sysdeps/solaris/procsegment.c

@@ -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));
+}

sysdeps/solaris/procsignal.c

@@ -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/procsignal.h>
+
+static const unsigned long _glibtop_sysdeps_proc_signal = 0;
+
+/* 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)
+{
+	memset (buf, 0, sizeof (glibtop_proc_signal));
+}

sysdeps/solaris/procstate.c

@@ -0,0 +1,59 @@
+/* $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 =
+(1 << GLIBTOP_PROC_STATE_UID) + (1 << GLIBTOP_PROC_STATE_GID) +
+(1 << GLIBTOP_PROC_STATE_CMD);
+
+/* 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)
+{
+	struct psinfo psinfo;
+
+	memset (buf, 0, sizeof (glibtop_proc_state));
+
+	if (glibtop_get_proc_data_psinfo_s (server, &psinfo, pid))
+		return;
+
+	buf->uid = psinfo.pr_uid;
+	buf->gid = psinfo.pr_gid;
+
+	strncpy (buf->cmd, psinfo.pr_fname, 39);
+
+	buf->flags = _glibtop_sysdeps_proc_state;
+}

sysdeps/solaris/proctime.c

@@ -0,0 +1,65 @@
+/* $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 =
+(1 << GLIBTOP_PROC_TIME_START_TIME) + (1 << GLIBTOP_PROC_TIME_RTIME) +
+(1 << GLIBTOP_PROC_TIME_UTIME) + (1 << 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));
+
+	if (glibtop_get_proc_data_usage_s (server, &prusage, pid))
+		return;
+
+	buf->start_time = prusage.pr_create.tv_sec * 1E+6 +
+		prusage.pr_create.tv_nsec / 1E+3;
+
+	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;
+}

sysdeps/solaris/procuid.c

@@ -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/procuid.h>
+
+#include <glibtop_private.h>
+
+static const unsigned long _glibtop_sysdeps_proc_uid =
+(1 << GLIBTOP_PROC_UID_EUID) + (1 << GLIBTOP_PROC_UID_UID) +
+(1 << GLIBTOP_PROC_UID_EGID) + (1 << GLIBTOP_PROC_UID_GID) +
+(1 << GLIBTOP_PROC_UID_PID) + (1 << GLIBTOP_PROC_UID_PPID) +
+(1 << GLIBTOP_PROC_UID_PGRP) + (1 << GLIBTOP_PROC_UID_SESSION) +
+(1 << GLIBTOP_PROC_UID_TTY);
+
+/* Init function. */
+
+void
+glibtop_init_proc_uid_s (glibtop *server)
+{
+	server->sysdeps.proc_uid = _glibtop_sysdeps_proc_uid;
+}
+
+/* Provides detailed information about a process. */
+
+void
+glibtop_get_proc_uid_s (glibtop *server, glibtop_proc_uid *buf, pid_t pid)
+{
+	struct psinfo psinfo;
+
+	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;
+	buf->pgrp = psinfo.pr_pgid;
+
+	buf->session = psinfo.pr_sid;
+	buf->tty = psinfo.pr_ttydev;
+
+	buf->flags = _glibtop_sysdeps_proc_uid;
+}

sysdeps/solaris/sem_limits.c

@@ -0,0 +1,43 @@
+/* $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>
+
+static const unsigned long _glibtop_sysdeps_sem_limits = 0;
+
+/* Init function. */
+
+void
+glibtop_init_sem_limits_s (glibtop *server)
+{
+	server->sysdeps.sem_limits = _glibtop_sysdeps_sem_limits;
+}
+
+/* Provides information about sysv sem limits. */
+
+void
+glibtop_get_sem_limits_s (glibtop *server, glibtop_sem_limits *buf)
+{
+	memset (buf, 0, sizeof (glibtop_sem_limits));
+}