This is libgtop2.info, produced by makeinfo version 6.3 from

libgtop2.texi.

INFO-DIR-SECTION Libraries:

START-INFO-DIR-ENTRY

* LibGTop2: (libgtop2).			Library to get system specific data

					such as cpu and memory usage, active

					processes

END-INFO-DIR-ENTRY

This is the LibGTop Reference Manual version 2.38.0 (last modified 27

November 2016).

   Copyright 1999 Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this

manual provided the copyright notice and this permission notice are

preserved on all copies.

   Permission is granted to copy and distribute modified versions of

this manual under the conditions for verbatim copying, provided also

that the sections entitled "Copying" and "GNU General Public License"

are included exactly as in the original, and provided that the entire

resulting derived work is distributed under the terms of a permission

notice identical to this one.

   Permission is granted to copy and distribute translations of this

manual into another language, under the above conditions for modified

versions, except that this permission notice may be stated in a

translation approved by the Free Software Foundation.

?

File: libgtop2.info,  Node: Top,  Next: About,  Prev: (dir),  Up: (dir)

* Menu:

* About::                       About LibGTop

* White Paper::                 LibGTop White Paper

* Reference Manual::            LibGTop Reference Manual

 -- The Detailed Node Listing --

About LibGTop

* Availability::                Where to get LibGTop

* Supported Platforms::         Supported Platforms

* Mailing List::                Helping with LibGTop development

* Thanks::                      People who contributed to LibGTop

LibGTop White Paper

* Introduction::                Introduction

* Overview::                    Overview

Overview

* Interface Design::            Things that need to be considered

* Server Implementation::       The LibGTop "server"

LibGTop Reference Manual

* System Dependent::            System Dependent Functions.

* Common Functions::            Common Functions.

* Library Functions::           Library Functions.

System Dependent Functions

* glibtop_cpu::                 CPU Usage.

* glibtop_mem::                 Memory Usage.

* glibtop_swap::                Swap Usage.

* glibtop_uptime::              System Uptime.

* glibtop_loadavg::             Load Average.

* glibtop_proclist::            Process List.

* glibtop_proc_state::          Process State.

* glibtop_proc_uid::            Process UID and TTY Information.

* glibtop_proc_mem::            Process Memory Information.

* glibtop_proc_time::           Process Time Information.

* glibtop_proc_signal::         Process Signal Information.

* glibtop_proc_kernel::         Process Kernel Data Information.

* glibtop_proc_segment::        Process Segment Information.

* glibtop_proc_args::           Process Arguments.

* glibtop_proc_map::            Process Memory Maps.

* glibtop_netload::             Network Load.

* glibtop_ppp::                 PPP Usage.

Common Functions

* glibtop_mountlist::           Mount List.

* glibtop_fsusage::             File System Usage.

Library Functions

* glibtop_init::                Server Initialization.

* glibtop_sysdeps::             Server Sysdeps.

* Library Parameters::          Library Parameters.

?

File: libgtop2.info,  Node: About,  Next: White Paper,  Prev: Top,  Up: Top

1 About LibGTop

***************

LibGTop is a library to get system specific data such as CPU and Memory

Usage and information about running Processes.

   On Systems like Solaris or Digital Unix where you need special

privileges to get those data, it uses a setuid/setgid server to do so.

   Even if LibGTop is a part of the GNOME desktop environment

(<http://www.gnome.org>), the main interface of LibGTop is totally

independent from any particular desktop environment, so you can also use

it as a standalone library in any piece of GPLed software.

* Menu:

* Availability::                Where to get LibGTop

* Supported Platforms::         Supported Platforms

* Mailing List::                Helping with LibGTop development

* Thanks::                      People who contributed to LibGTop

?

File: libgtop2.info,  Node: Availability,  Next: Supported Platforms,  Prev: About,  Up: About

1.1 Availability

================

The master source of LibGTop is the GNOME CVS tree (see

<http://www.gnome.org> for details), but you can also get the latest

release tarballs from

     <ftp://ftp.gnome.org/pub/GNOME/sources/libgtop/>

or any of its mirror sites.

   The latest stable version of LibGTop is 1.0.12 which is also the one

that comes together with GNOME 1.0.  It belongs to 'LIBGTOP_STABLE_1_0'

branch in CVS. Actual development occurs in the 'libgtop-GNOME-2-0-port'

which is currently versioned 1.90.0.

?

File: libgtop2.info,  Node: Supported Platforms,  Next: Mailing List,  Prev: Availability,  Up: About

1.2 Supported Platforms

=======================

The stable branch currently supports the following platforms:

   * All versions of Linux

     LibGTop was tested under Linux 2.0.x and 2.2.x on the ix86 and the

     alpha, but it should also work without problems on SparcLinux or

     Linux 2.4.x.

     Note: I'm speaking of the Linux kernel here, not the GNU/Linux

     operating system.

   * FreeBSD, NetBSD and OpenBSD

     LibGTop was tested under FreeBSD 2.2.6 and 3.0, NetBSD 1.3.2 and

     OpenBSD 2.4.  Support for NetBSD 1.4 was added in LibGTop 1.0.2.

   The platforms listed above are known to be stable and working.

However, if you're using the latest development version, you can use it

on the following platforms as well:

   * BSD/OS

     There is a port for BSD/OS (aka BSDI) 2.x and 3.x from Timur

     Bakeyev which should also work with 4.x.  This isn't tested very

     well, but it should be working.

   * Digital Unix

     There is some basic support for Digital Unix (formerly DEC OSF/1)

     V3.2C, but this may still be a bit unstable.  I'm currently working

     on this port as time permits so it should be fully supported soon.

   * Solaris

     The Solaris port currently works on Solaris 7 and maybe also on

     other releases.  Thanks a lot to Drazen Kacar and everyone who

     helped working on this port.  They have really done excellent work

     here and I'm pretty sure that this port will be fully functional on

     most Solaris versions in near future.

?

File: libgtop2.info,  Node: Mailing List,  Next: Thanks,  Prev: Supported Platforms,  Up: About

1.3 Mailing List

================

There is a <libgtop-devel-list@egroups.com> mailing list for people who

want to help with the development of LibGTop.

   It is meant as a low-traffic, but high content-list where we can

discuss technical details such as adding new sysdeps ports etc.

   Especially, I'd like to see people with a deeper knowledge of

operating systems internals joining my list so we can discuss technical

details of the sysdeps code.

   It is *not* for users that want to know how to compile LibGTop etc.

   You can subscribe to this mailing list and view the mailing list

archives on the LibGTop Page at

<http://www.home-of-linux.org/gnome/libgtop>.

?

File: libgtop2.info,  Node: Thanks,  Prev: Mailing List,  Up: About

1.4 Thanks

==========

At the place I'd like to thank the following people who contributed to

LibGTop (listed in chronological order):

   * Sebastian Wilhelmi who had the initial idea of LibGTop and helped

     me a lot in the early beginning.

   * Josh Sled for the initial FreeBSD port.

   * Jeremy Lea for his BSD patches.

   * Timur Bakeyev for the BSDI port.

   * Drazen Kacar and the other people on the LibGTop development

     mailing list for the Solaris port.

   * Kevin Vandersloot for the effort to port to GNOME 2.0.

   * All people sending me patches, having good ideas, ...

   * Everyone I have forgotten in this list ...

?

File: libgtop2.info,  Node: White Paper,  Next: Reference Manual,  Prev: About,  Up: Top

2 LibGTop White Paper

*********************

* Menu:

* Introduction::                Introduction

* Overview::                    Overview

?

File: libgtop2.info,  Node: Introduction,  Next: Overview,  Prev: White Paper,  Up: White Paper

2.1 Introduction

================

Many modern UNIX systems like Solaris, BSD or Digitial Unix only allow

priviledged processes to read information like CPU and Memory Usage or

information about running processes.

   * BSD, for instance, doesn't have any other way to get those data

     than reading directly from '/dev/kmem' and you need to be in the

     'kmem' group to be able to read this.

   * Other systems, like Digital Unix, allow all users to get things

     like CPU and Memory statistics, but only root may read information

     about any process other than the current one (you may not even get

     information about your own processes if you're not root).

   * Linux has a very nice '/proc' filesystem, but reading and parsing

     '/proc' is very slow and inefficient.

   * Solaris is a bit better, but you still need to be in the 'sys'

     group or even root to get some data.

   Because of this system utilities like 'ps', 'uptime' or 'top' often

are setgid kmem or setuid root.  Usually, they're also very specific to

the system they're written for and not easily portable to other systems

without a lot of work.

   This, of cause, becomes a problem for graphical tools like 'gtop' -

making a GTK+ program setgid or even setuid would be a security hole as

big as you can drive the entire X11 source code through.  For the GNOME

project, we also needed some kind of library which provides all the

required information in a portable since there's more than just one

single program that wants to use them - for instance 'gtop' and the

'multiload', 'cpumemusage' and 'netload' panel applets.

?

File: libgtop2.info,  Node: Overview,  Prev: Introduction,  Up: White Paper

2.2 Overview

============

This section should give you a short overview on how LibGTop was

developed, which things needed to be considered and how it works.

* Menu:

* Interface Design::            Things that need to be considered

* Server Implementation::       The LibGTop "server"

?

File: libgtop2.info,  Node: Interface Design,  Next: Server Implementation,  Prev: Overview,  Up: Overview

2.2.1 Interface Design

----------------------

At the very beginning, it was necessary to collect all the data the

library part should provide and put them into some C structures.  This

was not that easiy as it might sound since LibGTop should be portable to

any modern UNIX system with a common library part on all those systems,

but the data that should be returned vary from system to system.  For

instance some systems support shared memory, but some others may not.

   The header files where we define these C structures (which are

system-independent) are shared between client and server.  This way we

can call the system dependent code directly where we do not need any

special privileges to do so.

   All of those structures contain a 'flags' member which is interpreted

as a bit mask and tells the caller of the library functions which of the

fields in the returned structure are valid and which are not.

?

File: libgtop2.info,  Node: Server Implementation,  Prev: Interface Design,  Up: Overview

2.2.2 Server Implementation

---------------------------

The LibGTop "server" is a setgid/setuid binary which contains all the

system dependent code which needs special privileges.  It is only build

if it's required on the current system (for instance, the Linux kernel

provides all the required data via its '/proc' filesystem so we do not

need the server at all) and it only contains the "features" which need

privileges.

   Whenever we do not need any privileges to get all the data for some

of the requested structures (here called "features") the library calls

the sysdeps code directly rather than using the server.

?

File: libgtop2.info,  Node: Reference Manual,  Prev: White Paper,  Up: Top

3 LibGTop Reference Manual

**************************

* Menu:

* System Dependent::            System Dependent Functions.

* Common Functions::            Common Functions.

* Library Functions::           Library Functions.

?

File: libgtop2.info,  Node: System Dependent,  Next: Common Functions,  Prev: Reference Manual,  Up: Reference Manual

3.1 System Dependent Functions

==============================

* Menu:

* glibtop_cpu::                 CPU Usage.

* glibtop_mem::                 Memory Usage.

* glibtop_swap::                Swap Usage.

* glibtop_uptime::              System Uptime.

* glibtop_loadavg::             Load Average.

* glibtop_proclist::            Process List.

* glibtop_proc_state::          Process State.

* glibtop_proc_uid::            Process UID and TTY Information.

* glibtop_proc_mem::            Process Memory Information.

* glibtop_proc_time::           Process Time Information.

* glibtop_proc_signal::         Process Signal Information.

* glibtop_proc_kernel::         Process Kernel Data Information.

* glibtop_proc_segment::        Process Segment Information.

* glibtop_proc_args::           Process Arguments.

* glibtop_proc_map::            Process Memory Maps.

* glibtop_netload::             Network Load.

* glibtop_ppp::                 PPP Usage.

?

File: libgtop2.info,  Node: glibtop_cpu,  Next: glibtop_mem,  Prev: System Dependent,  Up: System Dependent

3.1.1 CPU Usage

---------------

Library function 'glibtop_get_cpu':

     void glibtop_get_cpu (glibtop_cpu *buf);

     void glibtop_get_cpu_l (glibtop *server, glibtop_cpu *buf);

   Declaration of 'glibtop_cpu' in '<glibtop/cpu.h>':

     typedef struct _glibtop_cpu     glibtop_cpu;

     struct _glibtop_cpu

     {

         guint64   flags,

             total,

             user,

             nice,

             sys,

             idle,

             iowait,

             irq,

             softirq,

             frequency,

             xcpu_total [GLIBTOP_NCPU],

             xcpu_user [GLIBTOP_NCPU],

             xcpu_nice [GLIBTOP_NCPU],

             xcpu_sys  [GLIBTOP_NCPU],

             xcpu_idle [GLIBTOP_NCPU],

             xcpu_iowait [GLIBTOP_NCPU],

             xcpu_irq [GLIBTOP_NCPU],

             xcpu_softirq [GLIBTOP_NCPU],

             xcpu_flags;

     };

   All CPU units are measured in "jiffies" which are normally 1/100th of

a second (in which case 'frequency' equals 100), but can also be in any

other unit.  To get seconds, divide them by 'frequency'.

'total'

     Number of clock ticks since system boot.

'user'

     Number of clock ticks the system spent in user mode.

'nice'

     Number of clock ticks the system spent in user mode (nice).

'sys'

     Number of clock ticks the system spent in system mode.

'idle'

     Number of clock ticks the system spent in the idle task.

'iowait'

     Number of clock ticks the system spent waiting for I/O to complete.

'irq'

     Number of clock ticks the system spent servicing interrupts.

'softirq'

     Number of clock ticks the system spent servicing softirqs.

'frequency'

     Tick frequency (default is 100).

   The 'xcpu_' values are for SMP systems - they are the same than

'total', 'user', 'nice', 'sys', 'idle', 'iowait', 'irq' and 'softirq'

except that they are arrays of 'GLIBTOP_NCPU' (defined in

'<glibtop/cpu.h>') elements and contain one value for each CPU in the

system.

'xcpu_flags'

     This is interpreted as a bit-field: on systems like Solaris, not

     all CPUs need to be running all the time, so we set the

     corresponding bit for each CPU that is currently running.

   Please note that all of the cpu values are absolute values measured

in certain units (to get seconds, divide them by 'frequency') since

system boot.  To get percentual values, you need to call 'glibtop_cpu',

save the result, wait some time and then call it again and divide the

differences of the two values by the time you have waited.

?

File: libgtop2.info,  Node: glibtop_mem,  Next: glibtop_swap,  Prev: glibtop_cpu,  Up: System Dependent

3.1.2 Memory Usage

------------------

Library function 'glibtop_get_mem':

     void glibtop_get_mem (glibtop_mem *buf);

     void glibtop_get_mem_l (glibtop *server, glibtop_mem *buf);

   Declaration of 'glibtop_mem' in '<glibtop/mem.h>':

     typedef struct _glibtop_mem     glibtop_mem;

     struct _glibtop_mem

     {

         guint64   flags,

             total,

             used,

             free,

             shared,

             buffer,

             cached,

             user,

             locked;

     };

   Unless explicitly stated otherwise, all memory units are in bytes.

'total'

     Total physical memory.

'used'

     Used memory size.

'free'

     Free memory size.

'shared'

     Shared memory size.

     This are both segments that are 'mmap()'ed with 'MAP_SHARED' and

     IPC Shared Memory segments.

'buffer'

     Size of buffers.

'cached'

     Size of cached memory.

'user'

     Memory used from user processes.

     This is normally 'total - free - shared - buffer - cached'.

'locked'

     Memory in locked segments.

?

File: libgtop2.info,  Node: glibtop_swap,  Next: glibtop_uptime,  Prev: glibtop_mem,  Up: System Dependent

3.1.3 Swap Usage

----------------

Library function 'glibtop_get_swap':

     void glibtop_get_swap (glibtop_swap *buf);

     void glibtop_get_swap_l (glibtop *server, glibtop_swap *buf);

   Declaration of 'glibtop_swap' in '<glibtop/swap.h>':

     typedef struct _glibtop_swap    glibtop_swap;

     struct _glibtop_swap

     {

         guint64   flags,

             total,

             used,

             free,

             pagein,

             pageout;

     };

   The following units are in bytes.

'total'

     Total swap space in the system.

'used'

     Used swap space.

'free'

     Free swap space.

   You can use 'pagein' and 'pageout' to get some measure about how much

the system is swapping at the moment.  They're increased each time a

page is swapped in or out, so you need to save this values, wait a

little bit, get them again and then compare the two results to find out

how much the system swapped in the meantime.

'pagein'

     Total number of swap pages that have been brought in since system

     boot

'pageout'

     Total number of swap pages that have been brought out since system

     boot

?

File: libgtop2.info,  Node: glibtop_uptime,  Next: glibtop_loadavg,  Prev: glibtop_swap,  Up: System Dependent

3.1.4 Uptime

------------

Library function 'glibtop_get_uptime':

     void glibtop_get_uptime (glibtop_uptime *buf);

     void glibtop_get_uptime_l (glibtop *server, glibtop_uptime *buf);

   Declaration of 'glibtop_uptime' in '<glibtop/uptime.h>':

     typedef struct _glibtop_uptime  glibtop_uptime;

     struct _glibtop_uptime

     {

         guint64 flags;

         double uptime,

             idletime;

         guint64 boot_time;

     };

   When porting LibGTop to a new system, you only need to implement

'uptime' and 'idletime' if there's a faster or better way to obtain them

as using 'glibtop_cpu' for it.  Look at 'sysdeps/freebsd/uptime.c' for

an example on how to obtain them using 'glibtop_cpu'.

'uptime'

     Time in seconds since system boot.

'idletime'

     Time in seconds the system spent in the idle task since system

     boot.

   The following one was from a request on the 'linux-kernel' mailing

list; on a laptop with advanced power management 'glibtop_cpu.total' may

not reflect the correct boot time of the system if the power was turned

off by means of APM in the meantime.

'boot_time'

     Time of last system boot in seconds since the epoch.

?

File: libgtop2.info,  Node: glibtop_loadavg,  Next: glibtop_proclist,  Prev: glibtop_uptime,  Up: System Dependent

3.1.5 Load Average

------------------

Library function 'glibtop_get_loadavg':

     void glibtop_get_loadavg (glibtop_loadavg *buf);

     void glibtop_get_loadavg_l (glibtop *server, glibtop_loadavg *buf);

   Declaration of 'glibtop_loadavg' in '<glibtop/loadavg.h>':

     typedef struct _glibtop_loadavg glibtop_loadavg;

     struct _glibtop_loadavg

     {

         guint64 flags;

         double loadavg [3];

         guint64 nr_running,

             nr_tasks,

             last_pid;

     };

'loadavg'

     Number of jobs running simultaneously averaged over 1, 5 and 15

     minutes.

   The following fields are Linux specific and deprecated.  You don't

need to implement them when porting LibGTop to a new system as they may

be removed in a future version.

'nr_running'

     Number of tasks currently running.

'nr_tasks'

     Total number of tasks.

'last_pid'

     Last PID.

?

File: libgtop2.info,  Node: glibtop_proclist,  Next: glibtop_proc_state,  Prev: glibtop_loadavg,  Up: System Dependent

3.1.6 Process List

------------------

Library function 'glibtop_get_proclist':

     unsigned *

     glibtop_get_proclist (glibtop_proclist *buf,

                           gint64 which, gint64 arg);

     unsigned *

     glibtop_get_proclist_l (glibtop *server, glibtop_proclist *buf,

                             gint64 which, gint64 arg);

   Constants for the 'which' argument:

     #define GLIBTOP_KERN_PROC_ALL           0

     #define GLIBTOP_KERN_PROC_PID           1

     #define GLIBTOP_KERN_PROC_PGRP          2

     #define GLIBTOP_KERN_PROC_SESSION       3

     #define GLIBTOP_KERN_PROC_TTY           4

     #define GLIBTOP_KERN_PROC_UID           5

     #define GLIBTOP_KERN_PROC_RUID          6

     #define GLIBTOP_KERN_PROC_MASK          15

     #define GLIBTOP_EXCLUDE_IDLE            0x1000

     #define GLIBTOP_EXCLUDE_SYSTEM          0x2000

     #define GLIBTOP_EXCLUDE_NOTTY           0x4000

   Declaration of 'glibtop_proclist' in '<glibtop/proclist.h>':

     typedef struct _glibtop_proclist        glibtop_proclist;

     struct _glibtop_proclist

     {

         guint64   flags,

             number,

             total,

             size;

     };

   This function returns a list of all or a selected subset of all

running processes.  You can use the 'which' and 'arg' arguments to

specify which processes should be returned.

   You can use the following values for the 'which' argument:

'GLIBTOP_KERN_PROC_ALL'

     Return information about all processes (the 'arg' argument is

     ignored).

'GLIBTOP_KERN_PROC_PID'

     Return information about all process with the pid PID which is

     passed in 'arg'.  You can use this to find out whether some process

     still exists.

'GLIBTOP_KERN_PROC_PGRP'

     Return all processes in process group PGRP which is passed in

     'arg'.

'GLIBTOP_KERN_PROC_SESSION'

     Return all processes in session SESSION which is passed in 'arg'.

'GLIBTOP_KERN_PROC_TTY'

     Return all processes which have the controlling tty TTY which is

     passed in 'arg' (TTY is interpreted as device number).

'GLIBTOP_KERN_PROC_UID'

     Return all processes with effective uid UID which is passed in

     'arg'.

'GLIBTOP_KERN_PROC_RUID'

     Return all processes with real uid RUID which is passed in 'arg'.

   You can alter the list of returned processes by using a binary OR of

'which' and the following constants:

'GLIBTOP_EXCLUDE_IDLE'

     Exclude idle processes.

'GLIBTOP_EXCLUDE_SYSTEM'

     Exclude system processes.

'GLIBTOP_EXCLUDE_NOTTY'

     Exclude processes without a controlling terminal.

   The return value of 'glibtop_get_proclist' is either 'NULL' on error

or a 'unsigned *' list of pids.  Additionally, the following fields of

'glibtop_proclist' are set:

'number'

     Number of entries in the returned list.

'total'

     Total size of the returned list (this equals 'number * size').

'size'

     Size of a single entry in the returned list (this equals 'sizeof

     (unsigned)').

   The returned list is allocated using 'g_malloc' and must be freed

using 'g_free' to avoid a memory leak.

?

File: libgtop2.info,  Node: glibtop_proc_state,  Next: glibtop_proc_uid,  Prev: glibtop_proclist,  Up: System Dependent

3.1.7 Process State

-------------------

Library function 'glibtop_get_proc_state':

     void

     glibtop_get_proc_state (glibtop_proc_state *buf, pid_t pid);

     void

     glibtop_get_proc_state_l (glibtop *server, glibtop_proc_state *buf,

                               pid_t pid);

   Declaration of 'glibtop_proc_state' in '<glibtop/procstate.h>':

     typedef struct _glibtop_proc_state      glibtop_proc_state;

     struct _glibtop_proc_state

     {

         guint64 flags;

         char cmd[40];

         char state;

         int uid,

             gid,

             ruid,

             rgid;

         int has_cpu,

             processor,

             last_processor;

     };

'cmd'

     Basename of the executable file in the call to 'exec'.

'state'

     Process state ('R' = running, 'S' = sleeping, 'D' =

     uninterruptible, 'Z' = zombie, 'T' = stopped, 'I' = idle).

     This was changed to an 'unsigned' bitfield in LibGTop 1.1.x where

     there are also some constants for it.

   When porting LibGTop, please _try hard_ to implement the following

fields.  For security reasons, it is *very important* that you *only*

set the 'flags' bits for those fields if their *values are correct*.

'uid'

     Effective UID of the process.

'gid'

     Effective GID of the process.

'ruid'

     Real UID of the process.

'rgid'

     Read GID of the process.

   The following fields are for SMP systems:

'has_cpu'

     This is either 0 or 1 depending on whether the process currently

     has a CPU or not.

'processor'

     This is the processor id of the CPU this process is currently

     running on (which can be used as index in the 'xcpu_' fields of

     'glibtop_cpu' for instance; since zero is a valid processor id, you

     must check 'has_cpu' in this case to find out whether the process

     really has a CPU).

'last_processor'

     The is the processor id of the CPU the process was last running on.

'GLIBTOP_PROCESS_RUNNING'

     The process is currently running.

'GLIBTOP_PROCESS_INTERRUPTIBLE'

     The process is currently in an interruptible sleep.

'GLIBTOP_PROCESS_UNINTERRUPTIBLE'

     The process is currently in uninterruptible sleep (the so-called

     "disk sleep").

'GLIBTOP_PROCESS_ZOMBIE'

     The process is a zombie.

'GLIBTOP_PROCESS_STOPPED'

     The process is currently stopped (received 'SIGSTOP' or attached to

     a debugger).

'GLIBTOP_PROCESS_SWAPPING'

     The process is currently swapping.

?

File: libgtop2.info,  Node: glibtop_proc_uid,  Next: glibtop_proc_mem,  Prev: glibtop_proc_state,  Up: System Dependent

3.1.8 Process UID and TTY information

-------------------------------------

Library function 'glibtop_get_proc_uid':

     void

     glibtop_get_proc_uid (glibtop_proc_uid *buf, pid_t pid);

     void

     glibtop_get_proc_uid_l (glibtop *server, glibtop_proc_uid *buf,

                             pid_t pid);

   Declaration of 'glibtop_proc_uid' in '<glibtop/procuid.h>':

     typedef struct _glibtop_proc_uid        glibtop_proc_uid;

     struct _glibtop_proc_uid

     {

         guint64 flags;

         int uid,

             euid,

             gid,

             egid,

             suid,

             sgid,

             fsuid,

             fsgid,

             pid,

             ppid,

             pgrp,

             session,

             tty,

             tpgid,

             priority,

             nice,

             ngroups,

             groups [GLIBTOP_MAX_GROUPS];

     };