src/libstatgrab/statgrab.h

/*
 * i-scream libstatgrab
 * http://www.i-scream.org
 * Copyright (C) 2000-2004 i-scream
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 * 02111-1307 USA
 *
 * $Id: statgrab.h,v 1.44 2004/04/07 21:20:28 ats Exp $
 */

#include <sys/types.h>

/* FIXME typedefs for 32/64-bit types */
/* FIXME maybe tidy up field names? */
/* FIXME comments for less obvious fields */

int sg_init(void);
int sg_drop_privileges(void);

typedef enum {
        SG_ERROR_NONE = 0,
        SG_ERROR_ASPRINTF,
        SG_ERROR_DEVSTAT_GETDEVS,
        SG_ERROR_DEVSTAT_SELECTDEVS,
        SG_ERROR_ENOENT,
        SG_ERROR_GETIFADDRS,
        SG_ERROR_GETMNTINFO,
        SG_ERROR_GETPAGESIZE,
        SG_ERROR_KSTAT_DATA_LOOKUP,
        SG_ERROR_KSTAT_LOOKUP,
        SG_ERROR_KSTAT_OPEN,
        SG_ERROR_KSTAT_READ,
        SG_ERROR_KVM_GETSWAPINFO,
        SG_ERROR_KVM_OPENFILES,
        SG_ERROR_MALLOC,
        SG_ERROR_OPEN,
        SG_ERROR_OPENDIR,
        SG_ERROR_PARSE,
        SG_ERROR_SETEGID,
        SG_ERROR_SETEUID,
        SG_ERROR_SETMNTENT,
        SG_ERROR_SOCKET,
        SG_ERROR_SWAPCTL,
        SG_ERROR_SYSCONF,
        SG_ERROR_SYSCTL,
        SG_ERROR_SYSCTLBYNAME,
        SG_ERROR_SYSCTLNAMETOMIB,
        SG_ERROR_UNAME,
        SG_ERROR_UNSUPPORTED,
        SG_ERROR_XSW_VER_MISMATCH
} sg_error;

void sg_set_error(sg_error code, const char *arg);
sg_error sg_get_error();
const char *sg_get_error_arg();
const char *sg_str_error(sg_error code);

typedef struct {
        char *os_name;
        char *os_release;
        char *os_version;
        char *platform;
        char *hostname;
        time_t uptime;
} sg_host_info;

sg_host_info *sg_get_host_info();

typedef struct {
        long long user;
        long long kernel;
        long long idle;
        long long iowait;
        long long swap;
        long long nice;
        long long total;
        time_t systime;
} sg_cpu_stats;

sg_cpu_stats *sg_get_cpu_stats();
sg_cpu_stats *sg_get_cpu_stats_diff();

typedef struct {
        float user;
        float kernel;
        float idle;
        float iowait;
        float swap;
        float nice;
        time_t time_taken;
} sg_cpu_percents;

sg_cpu_percents *sg_get_cpu_percents();

typedef struct {
        long long total;
        long long free;
        long long used;
        long long cache;
} sg_mem_stats;

sg_mem_stats *sg_get_mem_stats();

typedef struct {
        double min1;
        double min5;
        double min15;
} sg_load_stats;

sg_load_stats *sg_get_load_stats();

typedef struct {
        char *name_list;
        int num_entries;
} sg_user_stats;

sg_user_stats *sg_get_user_stats();

typedef struct {
        long long total;
        long long used;
        long long free;
} sg_swap_stats;

sg_swap_stats *sg_get_swap_stats();

typedef struct {
        char *device_name;
        char *fs_type;
        char *mnt_point;
        long long size;
        long long used;
        long long avail;
        long long total_inodes;
        long long used_inodes;
        long long free_inodes;
} sg_fs_stats;

sg_fs_stats *sg_get_fs_stats(int *entries);

typedef struct {
        char *disk_name;
        long long read_bytes;
        long long write_bytes;
        time_t systime;
} sg_disk_io_stats;

sg_disk_io_stats *sg_get_disk_io_stats(int *entries);
sg_disk_io_stats *sg_get_disk_io_stats_diff(int *entries);

typedef struct {
        char *interface_name;
        long long tx;
        long long rx;
        long long ipackets;
        long long opackets;
        long long ierrors;
        long long oerrors;
        long long collisions;
        time_t systime;
} sg_network_io_stats;

sg_network_io_stats *sg_get_network_io_stats(int *entries);
sg_network_io_stats *sg_get_network_io_stats_diff(int *entries);

typedef enum {
        SG_IFACE_DUPLEX_FULL,
        SG_IFACE_DUPLEX_HALF,
        SG_IFACE_DUPLEX_UNKNOWN
} sg_iface_duplex;

typedef struct {
        char *interface_name;
        int speed;      /* In megabits/sec */
        sg_iface_duplex dup;
        int up;
} sg_network_iface_stats;

sg_network_iface_stats *sg_get_network_iface_stats(int *entries);

typedef struct {
        long long pages_pagein;
        long long pages_pageout;
        time_t systime;
} sg_page_stats;

sg_page_stats *sg_get_page_stats();
sg_page_stats *sg_get_page_stats_diff();

typedef enum {
        SG_PROCESS_STATE_RUNNING,
        SG_PROCESS_STATE_SLEEPING,
        SG_PROCESS_STATE_STOPPED,
        SG_PROCESS_STATE_ZOMBIE,
        SG_PROCESS_STATE_UNKNOWN
} sg_process_state;

typedef struct {
        char *process_name;
        char *proctitle;

        pid_t pid;
        pid_t parent; /* Parent pid */
        pid_t pgid;   /* process id of process group leader */

        uid_t uid;
        uid_t euid;
        gid_t gid;
        gid_t egid;

        unsigned long long proc_size; /* in bytes */
        unsigned long long proc_resident; /* in bytes */
        time_t time_spent; /* time running in seconds */
        double cpu_percent;
        int nice;
        sg_process_state state;
} sg_process_stats;

sg_process_stats *sg_get_process_stats(int *entries);

typedef struct {
        int total;
        int running;
        int sleeping;
        int stopped;
        int zombie;
} sg_process_count;

sg_process_count *sg_get_process_count();

typedef enum {
        SG_PS_PID,
        SG_PS_UID,
        SG_PS_GID,
        SG_PS_SIZE,
        SG_PS_RES,
        SG_PS_CPU,
        SG_PS_TIME
} sg_sort_method;

void sg_sort(sg_process_stats *ps, int num_ps, sg_sort_method sm);

int sg_compare_pid(const void *va, const void *vb);
int sg_compare_uid(const void *va, const void *vb);
int sg_compare_gid(const void *va, const void *vb);
int sg_compare_size(const void *va, const void *vb);
int sg_compare_res(const void *va, const void *vb);
int sg_compare_cpu(const void *va, const void *vb);
int sg_compare_time(const void *va, const void *vb);


#ifdef SG_ENABLE_DEPRECATED
#include <statgrab_deprecated.h>
#endif

Revision:	1.45
Committed:	Thu Apr 8 11:26:42 2004 UTC (20 years, 1 month ago) by pajs
Content type:	text/plain
Branch:	MAIN
Changes since 1.44:	+22 -1 lines
Log Message:	Added some generic sorting methods for process_stats.
#	User	Rev	Content
1	tdb	1.22	/*
2	tdb	1.34	* i-scream libstatgrab
3	tdb	1.13	* http://www.i-scream.org
4	tdb	1.22	* Copyright (C) 2000-2004 i-scream
5	pajs	1.1	*
6	tdb	1.22	* This library is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public
8			* License as published by the Free Software Foundation; either
9			* version 2.1 of the License, or (at your option) any later version.
10	pajs	1.1	*
11	tdb	1.22	* This library is distributed in the hope that it will be useful,
12	pajs	1.1	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	tdb	1.22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* Lesser General Public License for more details.
15	pajs	1.1	*
16	tdb	1.22	* You should have received a copy of the GNU Lesser General Public
17			* License along with this library; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19			* 02111-1307 USA
20	tdb	1.23	*
21	pajs	1.45	* $Id: statgrab.h,v 1.44 2004/04/07 21:20:28 ats Exp $
22	pajs	1.1	*/
23
24	pajs	1.21	#include <sys/types.h>
25
26	ats	1.33	/* FIXME typedefs for 32/64-bit types */
27			/* FIXME maybe tidy up field names? */
28			/* FIXME comments for less obvious fields */
29
30			int sg_init(void);
31			int sg_drop_privileges(void);
32	tdb	1.36
33			typedef enum {
34	tdb	1.38	SG_ERROR_NONE = 0,
35	tdb	1.42	SG_ERROR_ASPRINTF,
36			SG_ERROR_DEVSTAT_GETDEVS,
37			SG_ERROR_DEVSTAT_SELECTDEVS,
38			SG_ERROR_ENOENT,
39			SG_ERROR_GETIFADDRS,
40			SG_ERROR_GETMNTINFO,
41			SG_ERROR_GETPAGESIZE,
42			SG_ERROR_KSTAT_DATA_LOOKUP,
43			SG_ERROR_KSTAT_LOOKUP,
44			SG_ERROR_KSTAT_OPEN,
45			SG_ERROR_KSTAT_READ,
46			SG_ERROR_KVM_GETSWAPINFO,
47			SG_ERROR_KVM_OPENFILES,
48	tdb	1.39	SG_ERROR_MALLOC,
49			SG_ERROR_OPEN,
50	tdb	1.42	SG_ERROR_OPENDIR,
51	tdb	1.41	SG_ERROR_PARSE,
52	tdb	1.42	SG_ERROR_SETEGID,
53			SG_ERROR_SETEUID,
54	tdb	1.41	SG_ERROR_SETMNTENT,
55	tdb	1.42	SG_ERROR_SOCKET,
56			SG_ERROR_SWAPCTL,
57			SG_ERROR_SYSCONF,
58			SG_ERROR_SYSCTL,
59			SG_ERROR_SYSCTLBYNAME,
60			SG_ERROR_SYSCTLNAMETOMIB,
61			SG_ERROR_UNAME,
62			SG_ERROR_UNSUPPORTED,
63			SG_ERROR_XSW_VER_MISMATCH
64	tdb	1.36	} sg_error;
65
66			void sg_set_error(sg_error code, const char *arg);
67			sg_error sg_get_error();
68	ats	1.43	const char *sg_get_error_arg();
69	ats	1.37	const char *sg_str_error(sg_error code);
70	ats	1.33
71			typedef struct {
72			char *os_name;
73			char *os_release;
74			char *os_version;
75			char *platform;
76			char *hostname;
77			time_t uptime;
78			} sg_host_info;
79
80			sg_host_info *sg_get_host_info();
81
82			typedef struct {
83	tdb	1.39	long long user;
84			long long kernel;
85			long long idle;
86			long long iowait;
87			long long swap;
88			long long nice;
89			long long total;
90			time_t systime;
91	ats	1.33	} sg_cpu_stats;
92	pajs	1.1
93	ats	1.33	sg_cpu_stats *sg_get_cpu_stats();
94			sg_cpu_stats *sg_get_cpu_stats_diff();
95
96			typedef struct {
97	tdb	1.39	float user;
98			float kernel;
99			float idle;
100			float iowait;
101			float swap;
102			float nice;
103	pajs	1.1	time_t time_taken;
104	ats	1.33	} sg_cpu_percents;
105
106			sg_cpu_percents *sg_get_cpu_percents();
107	pajs	1.1
108	ats	1.33	typedef struct {
109	pajs	1.1	long long total;
110			long long free;
111			long long used;
112			long long cache;
113	ats	1.33	} sg_mem_stats;
114
115			sg_mem_stats *sg_get_mem_stats();
116	pajs	1.1
117	ats	1.33	typedef struct {
118	pajs	1.1	double min1;
119			double min5;
120			double min15;
121	ats	1.33	} sg_load_stats;
122
123			sg_load_stats *sg_get_load_stats();
124	pajs	1.1
125	ats	1.33	typedef struct {
126	pajs	1.8	char *name_list;
127	pajs	1.1	int num_entries;
128	ats	1.33	} sg_user_stats;
129
130			sg_user_stats *sg_get_user_stats();
131	pajs	1.1
132	ats	1.33	typedef struct {
133	pajs	1.1	long long total;
134			long long used;
135			long long free;
136	ats	1.33	} sg_swap_stats;
137	pajs	1.1
138	ats	1.33	sg_swap_stats *sg_get_swap_stats();
139	pajs	1.1
140			typedef struct {
141	tdb	1.39	char *device_name;
142	pajs	1.1	char *fs_type;
143	tdb	1.39	char *mnt_point;
144			long long size;
145			long long used;
146			long long avail;
147			long long total_inodes;
148	pajs	1.1	long long used_inodes;
149	tdb	1.39	long long free_inodes;
150	ats	1.33	} sg_fs_stats;
151
152			sg_fs_stats sg_get_fs_stats(int entries);
153	pajs	1.1
154	ats	1.33	typedef struct {
155	pajs	1.4	char *disk_name;
156			long long read_bytes;
157			long long write_bytes;
158			time_t systime;
159	ats	1.33	} sg_disk_io_stats;
160	pajs	1.4
161	ats	1.33	sg_disk_io_stats sg_get_disk_io_stats(int entries);
162			sg_disk_io_stats sg_get_disk_io_stats_diff(int entries);
163	pajs	1.1
164	ats	1.33	typedef struct {
165	pajs	1.1	char *interface_name;
166			long long tx;
167			long long rx;
168	tdb	1.28	long long ipackets;
169			long long opackets;
170			long long ierrors;
171			long long oerrors;
172			long long collisions;
173	pajs	1.1	time_t systime;
174	ats	1.33	} sg_network_io_stats;
175
176			sg_network_io_stats sg_get_network_io_stats(int entries);
177			sg_network_io_stats sg_get_network_io_stats_diff(int entries);
178	pajs	1.24
179	ats	1.33	typedef enum {
180			SG_IFACE_DUPLEX_FULL,
181			SG_IFACE_DUPLEX_HALF,
182			SG_IFACE_DUPLEX_UNKNOWN
183			} sg_iface_duplex;
184	pajs	1.24
185	ats	1.33	typedef struct {
186	pajs	1.24	char *interface_name;
187			int speed; /* In megabits/sec */
188	ats	1.33	sg_iface_duplex dup;
189	pajs	1.27	int up;
190	ats	1.33	} sg_network_iface_stats;
191
192			sg_network_iface_stats sg_get_network_iface_stats(int entries);
193	pajs	1.1
194	ats	1.33	typedef struct {
195	pajs	1.2	long long pages_pagein;
196			long long pages_pageout;
197	pajs	1.1	time_t systime;
198	ats	1.33	} sg_page_stats;
199
200			sg_page_stats *sg_get_page_stats();
201			sg_page_stats *sg_get_page_stats_diff();
202	pajs	1.29
203	ats	1.33	typedef enum {
204			SG_PROCESS_STATE_RUNNING,
205			SG_PROCESS_STATE_SLEEPING,
206			SG_PROCESS_STATE_STOPPED,
207			SG_PROCESS_STATE_ZOMBIE,
208			SG_PROCESS_STATE_UNKNOWN
209			} sg_process_state;
210	pajs	1.30
211	ats	1.33	typedef struct {
212	pajs	1.29	char *process_name;
213			char *proctitle;
214
215			pid_t pid;
216			pid_t parent; /* Parent pid */
217			pid_t pgid; /* process id of process group leader */
218
219			uid_t uid;
220			uid_t euid;
221			gid_t gid;
222			gid_t egid;
223
224			unsigned long long proc_size; /* in bytes */
225			unsigned long long proc_resident; /* in bytes */
226	tdb	1.31	time_t time_spent; /* time running in seconds */
227	pajs	1.29	double cpu_percent;
228			int nice;
229	ats	1.33	sg_process_state state;
230			} sg_process_stats;
231	pajs	1.29
232	ats	1.33	sg_process_stats sg_get_process_stats(int entries);
233	pajs	1.1
234	ats	1.33	typedef struct {
235			int total;
236			int running;
237			int sleeping;
238			int stopped;
239			int zombie;
240			} sg_process_count;
241	pajs	1.14
242	ats	1.33	sg_process_count *sg_get_process_count();
243	pajs	1.45
244			typedef enum {
245			SG_PS_PID,
246			SG_PS_UID,
247			SG_PS_GID,
248			SG_PS_SIZE,
249			SG_PS_RES,
250			SG_PS_CPU,
251			SG_PS_TIME
252			} sg_sort_method;
253
254			void sg_sort(sg_process_stats *ps, int num_ps, sg_sort_method sm);
255
256			int sg_compare_pid(const void va, const void vb);
257			int sg_compare_uid(const void va, const void vb);
258			int sg_compare_gid(const void va, const void vb);
259			int sg_compare_size(const void va, const void vb);
260			int sg_compare_res(const void va, const void vb);
261			int sg_compare_cpu(const void va, const void vb);
262			int sg_compare_time(const void va, const void vb);
263
264	tdb	1.35
265			#ifdef SG_ENABLE_DEPRECATED
266			#include <statgrab_deprecated.h>
267			#endif
268	ats	1.18