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.56 2005/07/13 13:01:24 tdb Exp $
 */

#ifndef STATGRAB_H
#define STATGRAB_H

#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_snapshot();
int sg_shutdown();
int sg_drop_privileges(void);

typedef enum {
        SG_ERROR_NONE = 0,
        SG_ERROR_ASPRINTF,
        SG_ERROR_DEVICES,
        SG_ERROR_DEVSTAT_GETDEVS,
        SG_ERROR_DEVSTAT_SELECTDEVS,
        SG_ERROR_DISKINFO,
        SG_ERROR_ENOENT,
        SG_ERROR_GETIFADDRS,
        SG_ERROR_GETMNTINFO,
        SG_ERROR_GETPAGESIZE,
        SG_ERROR_HOST,
        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_MEMSTATUS,
        SG_ERROR_OPEN,
        SG_ERROR_OPENDIR,
        SG_ERROR_PARSE,
        SG_ERROR_PDHADD,
        SG_ERROR_PDHCOLLECT,
        SG_ERROR_PDHOPEN,
        SG_ERROR_PDHREAD,
        SG_ERROR_PERMISSION,
        SG_ERROR_PSTAT,
        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);
void sg_set_error_with_errno(sg_error code, const char *arg);
sg_error sg_get_error();
const char *sg_get_error_arg();
int sg_get_error_errno();
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;
        long long avail_inodes;
        long long io_size;
        long long block_size;
        long long total_blocks;
        long long free_blocks;
        long long used_blocks;
        long long avail_blocks;
} sg_fs_stats;

sg_fs_stats *sg_get_fs_stats(int *entries);

int sg_fs_compare_device_name(const void *va, const void *vb);
int sg_fs_compare_mnt_point(const void *va, const void *vb);

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);

int sg_disk_io_compare_name(const void *va, const void *vb);

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);

int sg_network_io_compare_name(const void *va, const void *vb);

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 duplex;
#ifdef SG_ENABLE_DEPRECATED
        sg_iface_duplex dup;
#endif
        int up;
} sg_network_iface_stats;

sg_network_iface_stats *sg_get_network_iface_stats(int *entries);

int sg_network_iface_compare_name(const void *va, const void *vb);

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 */

/* Windows does not have uid_t or gid_t types */
#ifndef WIN32
        uid_t uid;
        uid_t euid;
        gid_t gid;
        gid_t egid;
#else
        int uid;
        int euid;
        int gid;
        int egid;
#endif

        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);

int sg_process_compare_name(const void *va, const void *vb);
int sg_process_compare_pid(const void *va, const void *vb);
int sg_process_compare_uid(const void *va, const void *vb);
int sg_process_compare_gid(const void *va, const void *vb);
int sg_process_compare_size(const void *va, const void *vb);
int sg_process_compare_res(const void *va, const void *vb);
int sg_process_compare_cpu(const void *va, const void *vb);
int sg_process_compare_time(const void *va, const void *vb);

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

sg_process_count *sg_get_process_count();

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

#endif
Revision:	1.57
Committed:	Sat Sep 24 13:29:22 2005 UTC (18 years, 8 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
Changes since 1.56:	+22 -3 lines
Log Message:	Add WIN32 support via MINGW. We'll need to add stuff to the README file about what this requires to build. All the hard work done by: skel
#	Content
1	/*
2	* i-scream libstatgrab
3	* http://www.i-scream.org
4	* Copyright (C) 2000-2004 i-scream
5	*
6	* 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	*
11	* This library is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	* Lesser General Public License for more details.
15	*
16	* 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	*
21	* $Id: statgrab.h,v 1.56 2005/07/13 13:01:24 tdb Exp $
22	*/
23
24	#ifndef STATGRAB_H
25	#define STATGRAB_H
26
27	#include <sys/types.h>
28
29	/* FIXME typedefs for 32/64-bit types */
30	/* FIXME maybe tidy up field names? */
31	/* FIXME comments for less obvious fields */
32
33	int sg_init(void);
34	int sg_snapshot();
35	int sg_shutdown();
36	int sg_drop_privileges(void);
37
38	typedef enum {
39	SG_ERROR_NONE = 0,
40	SG_ERROR_ASPRINTF,
41	SG_ERROR_DEVICES,
42	SG_ERROR_DEVSTAT_GETDEVS,
43	SG_ERROR_DEVSTAT_SELECTDEVS,
44	SG_ERROR_DISKINFO,
45	SG_ERROR_ENOENT,
46	SG_ERROR_GETIFADDRS,
47	SG_ERROR_GETMNTINFO,
48	SG_ERROR_GETPAGESIZE,
49	SG_ERROR_HOST,
50	SG_ERROR_KSTAT_DATA_LOOKUP,
51	SG_ERROR_KSTAT_LOOKUP,
52	SG_ERROR_KSTAT_OPEN,
53	SG_ERROR_KSTAT_READ,
54	SG_ERROR_KVM_GETSWAPINFO,
55	SG_ERROR_KVM_OPENFILES,
56	SG_ERROR_MALLOC,
57	SG_ERROR_MEMSTATUS,
58	SG_ERROR_OPEN,
59	SG_ERROR_OPENDIR,
60	SG_ERROR_PARSE,
61	SG_ERROR_PDHADD,
62	SG_ERROR_PDHCOLLECT,
63	SG_ERROR_PDHOPEN,
64	SG_ERROR_PDHREAD,
65	SG_ERROR_PERMISSION,
66	SG_ERROR_PSTAT,
67	SG_ERROR_SETEGID,
68	SG_ERROR_SETEUID,
69	SG_ERROR_SETMNTENT,
70	SG_ERROR_SOCKET,
71	SG_ERROR_SWAPCTL,
72	SG_ERROR_SYSCONF,
73	SG_ERROR_SYSCTL,
74	SG_ERROR_SYSCTLBYNAME,
75	SG_ERROR_SYSCTLNAMETOMIB,
76	SG_ERROR_UNAME,
77	SG_ERROR_UNSUPPORTED,
78	SG_ERROR_XSW_VER_MISMATCH
79	} sg_error;
80
81	void sg_set_error(sg_error code, const char *arg);
82	void sg_set_error_with_errno(sg_error code, const char *arg);
83	sg_error sg_get_error();
84	const char *sg_get_error_arg();
85	int sg_get_error_errno();
86	const char *sg_str_error(sg_error code);
87
88	typedef struct {
89	char *os_name;
90	char *os_release;
91	char *os_version;
92	char *platform;
93	char *hostname;
94	time_t uptime;
95	} sg_host_info;
96
97	sg_host_info *sg_get_host_info();
98
99	typedef struct {
100	long long user;
101	long long kernel;
102	long long idle;
103	long long iowait;
104	long long swap;
105	long long nice;
106	long long total;
107	time_t systime;
108	} sg_cpu_stats;
109
110	sg_cpu_stats *sg_get_cpu_stats();
111	sg_cpu_stats *sg_get_cpu_stats_diff();
112
113	typedef struct {
114	float user;
115	float kernel;
116	float idle;
117	float iowait;
118	float swap;
119	float nice;
120	time_t time_taken;
121	} sg_cpu_percents;
122
123	sg_cpu_percents *sg_get_cpu_percents();
124
125	typedef struct {
126	long long total;
127	long long free;
128	long long used;
129	long long cache;
130	} sg_mem_stats;
131
132	sg_mem_stats *sg_get_mem_stats();
133
134	typedef struct {
135	double min1;
136	double min5;
137	double min15;
138	} sg_load_stats;
139
140	sg_load_stats *sg_get_load_stats();
141
142	typedef struct {
143	char *name_list;
144	int num_entries;
145	} sg_user_stats;
146
147	sg_user_stats *sg_get_user_stats();
148
149	typedef struct {
150	long long total;
151	long long used;
152	long long free;
153	} sg_swap_stats;
154
155	sg_swap_stats *sg_get_swap_stats();
156
157	typedef struct {
158	char *device_name;
159	char *fs_type;
160	char *mnt_point;
161	long long size;
162	long long used;
163	long long avail;
164	long long total_inodes;
165	long long used_inodes;
166	long long free_inodes;
167	long long avail_inodes;
168	long long io_size;
169	long long block_size;
170	long long total_blocks;
171	long long free_blocks;
172	long long used_blocks;
173	long long avail_blocks;
174	} sg_fs_stats;
175
176	sg_fs_stats sg_get_fs_stats(int entries);
177
178	int sg_fs_compare_device_name(const void va, const void vb);
179	int sg_fs_compare_mnt_point(const void va, const void vb);
180
181	typedef struct {
182	char *disk_name;
183	long long read_bytes;
184	long long write_bytes;
185	time_t systime;
186	} sg_disk_io_stats;
187
188	sg_disk_io_stats sg_get_disk_io_stats(int entries);
189	sg_disk_io_stats sg_get_disk_io_stats_diff(int entries);
190
191	int sg_disk_io_compare_name(const void va, const void vb);
192
193	typedef struct {
194	char *interface_name;
195	long long tx;
196	long long rx;
197	long long ipackets;
198	long long opackets;
199	long long ierrors;
200	long long oerrors;
201	long long collisions;
202	time_t systime;
203	} sg_network_io_stats;
204
205	sg_network_io_stats sg_get_network_io_stats(int entries);
206	sg_network_io_stats sg_get_network_io_stats_diff(int entries);
207
208	int sg_network_io_compare_name(const void va, const void vb);
209
210	typedef enum {
211	SG_IFACE_DUPLEX_FULL,
212	SG_IFACE_DUPLEX_HALF,
213	SG_IFACE_DUPLEX_UNKNOWN
214	} sg_iface_duplex;
215
216	typedef struct {
217	char *interface_name;
218	int speed; /* In megabits/sec */
219	sg_iface_duplex duplex;
220	#ifdef SG_ENABLE_DEPRECATED
221	sg_iface_duplex dup;
222	#endif
223	int up;
224	} sg_network_iface_stats;
225
226	sg_network_iface_stats sg_get_network_iface_stats(int entries);
227
228	int sg_network_iface_compare_name(const void va, const void vb);
229
230	typedef struct {
231	long long pages_pagein;
232	long long pages_pageout;
233	time_t systime;
234	} sg_page_stats;
235
236	sg_page_stats *sg_get_page_stats();
237	sg_page_stats *sg_get_page_stats_diff();
238
239	typedef enum {
240	SG_PROCESS_STATE_RUNNING,
241	SG_PROCESS_STATE_SLEEPING,
242	SG_PROCESS_STATE_STOPPED,
243	SG_PROCESS_STATE_ZOMBIE,
244	SG_PROCESS_STATE_UNKNOWN
245	} sg_process_state;
246
247	typedef struct {
248	char *process_name;
249	char *proctitle;
250
251	pid_t pid;
252	pid_t parent; /* Parent pid */
253	pid_t pgid; /* process id of process group leader */
254
255	/* Windows does not have uid_t or gid_t types */
256	#ifndef WIN32
257	uid_t uid;
258	uid_t euid;
259	gid_t gid;
260	gid_t egid;
261	#else
262	int uid;
263	int euid;
264	int gid;
265	int egid;
266	#endif
267
268	unsigned long long proc_size; /* in bytes */
269	unsigned long long proc_resident; /* in bytes */
270	time_t time_spent; /* time running in seconds */
271	double cpu_percent;
272	int nice;
273	sg_process_state state;
274	} sg_process_stats;
275
276	sg_process_stats sg_get_process_stats(int entries);
277
278	int sg_process_compare_name(const void va, const void vb);
279	int sg_process_compare_pid(const void va, const void vb);
280	int sg_process_compare_uid(const void va, const void vb);
281	int sg_process_compare_gid(const void va, const void vb);
282	int sg_process_compare_size(const void va, const void vb);
283	int sg_process_compare_res(const void va, const void vb);
284	int sg_process_compare_cpu(const void va, const void vb);
285	int sg_process_compare_time(const void va, const void vb);
286
287	typedef struct {
288	int total;
289	int running;
290	int sleeping;
291	int stopped;
292	int zombie;
293	} sg_process_count;
294
295	sg_process_count *sg_get_process_count();
296
297	#ifdef SG_ENABLE_DEPRECATED
298	#include <statgrab_deprecated.h>
299	#endif
300
301	#endif