ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/libstatgrab/src/libstatgrab/statgrab.h

Comparing projects/libstatgrab/src/libstatgrab/statgrab.h (file contents):
Revision 1.25 by pajs, Sun Jan 25 20:13:57 2004 UTC vs.
Revision 1.56 by tdb, Wed Jul 13 13:01:24 2005 UTC

#	Line 1 | Line 1
1		/*
2	<	* i-scream central monitoring system
2	>	* i-scream libstatgrab
3		* http://www.i-scream.org
4		* Copyright (C) 2000-2004 i-scream
5		*
#	Line 21 | Line 21
21		* $Id$
22		*/
23
24	+	#ifndef STATGRAB_H
25	+	#define STATGRAB_H
26	+
27		#include <sys/types.h>
28
29	<	typedef struct{
30	<	long long user;
31	<	long long kernel;
29	<	long long idle;
30	<	long long iowait;
31	<	long long swap;
32	<	long long nice;
33	<	long long total;
34	<	time_t systime;
35	<	}cpu_states_t;
29	>	/* FIXME typedefs for 32/64-bit types */
30	>	/* FIXME maybe tidy up field names? */
31	>	/* FIXME comments for less obvious fields */
32
33	<	typedef struct{
34	<	float user;
35	<	float kernel;
36	<	float idle;
37	<	float iowait;
38	<	float swap;
39	<	float nice;
33	>	int sg_init(void);
34	>	int sg_drop_privileges(void);
35	>
36	>	typedef enum {
37	>	SG_ERROR_NONE = 0,
38	>	SG_ERROR_ASPRINTF,
39	>	SG_ERROR_DEVSTAT_GETDEVS,
40	>	SG_ERROR_DEVSTAT_SELECTDEVS,
41	>	SG_ERROR_ENOENT,
42	>	SG_ERROR_GETIFADDRS,
43	>	SG_ERROR_GETMNTINFO,
44	>	SG_ERROR_GETPAGESIZE,
45	>	SG_ERROR_KSTAT_DATA_LOOKUP,
46	>	SG_ERROR_KSTAT_LOOKUP,
47	>	SG_ERROR_KSTAT_OPEN,
48	>	SG_ERROR_KSTAT_READ,
49	>	SG_ERROR_KVM_GETSWAPINFO,
50	>	SG_ERROR_KVM_OPENFILES,
51	>	SG_ERROR_MALLOC,
52	>	SG_ERROR_OPEN,
53	>	SG_ERROR_OPENDIR,
54	>	SG_ERROR_PARSE,
55	>	SG_ERROR_SETEGID,
56	>	SG_ERROR_SETEUID,
57	>	SG_ERROR_SETMNTENT,
58	>	SG_ERROR_SOCKET,
59	>	SG_ERROR_SWAPCTL,
60	>	SG_ERROR_SYSCONF,
61	>	SG_ERROR_SYSCTL,
62	>	SG_ERROR_SYSCTLBYNAME,
63	>	SG_ERROR_SYSCTLNAMETOMIB,
64	>	SG_ERROR_UNAME,
65	>	SG_ERROR_UNSUPPORTED,
66	>	SG_ERROR_XSW_VER_MISMATCH,
67	>	SG_ERROR_PSTAT
68	>	} sg_error;
69	>
70	>	void sg_set_error(sg_error code, const char *arg);
71	>	void sg_set_error_with_errno(sg_error code, const char *arg);
72	>	sg_error sg_get_error();
73	>	const char *sg_get_error_arg();
74	>	int sg_get_error_errno();
75	>	const char *sg_str_error(sg_error code);
76	>
77	>	typedef struct {
78	>	char *os_name;
79	>	char *os_release;
80	>	char *os_version;
81	>	char *platform;
82	>	char *hostname;
83	>	time_t uptime;
84	>	} sg_host_info;
85	>
86	>	sg_host_info *sg_get_host_info();
87	>
88	>	typedef struct {
89	>	long long user;
90	>	long long kernel;
91	>	long long idle;
92	>	long long iowait;
93	>	long long swap;
94	>	long long nice;
95	>	long long total;
96	>	time_t systime;
97	>	} sg_cpu_stats;
98	>
99	>	sg_cpu_stats *sg_get_cpu_stats();
100	>	sg_cpu_stats *sg_get_cpu_stats_diff();
101	>
102	>	typedef struct {
103	>	float user;
104	>	float kernel;
105	>	float idle;
106	>	float iowait;
107	>	float swap;
108	>	float nice;
109		time_t time_taken;
110	<	}cpu_percent_t;
110	>	} sg_cpu_percents;
111
112	<	typedef struct{
112	>	sg_cpu_percents *sg_get_cpu_percents();
113	>
114	>	typedef struct {
115		long long total;
116		long long free;
117		long long used;
118		long long cache;
119	<	}mem_stat_t;
119	>	} sg_mem_stats;
120
121	<	typedef struct{
121	>	sg_mem_stats *sg_get_mem_stats();
122	>
123	>	typedef struct {
124		double min1;
125		double min5;
126		double min15;
127	<	}load_stat_t;
127	>	} sg_load_stats;
128
129	<	typedef struct{
129	>	sg_load_stats *sg_get_load_stats();
130	>
131	>	typedef struct {
132		char *name_list;
133		int num_entries;
134	<	}user_stat_t;
134	>	} sg_user_stats;
135
136	<	typedef struct{
136	>	sg_user_stats *sg_get_user_stats();
137	>
138	>	typedef struct {
139		long long total;
140		long long used;
141		long long free;
142	<	}swap_stat_t;
142	>	} sg_swap_stats;
143
144	<	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	<	}general_stat_t;
144	>	sg_swap_stats *sg_get_swap_stats();
145
146		typedef struct {
147	<	char *device_name;
147	>	char *device_name;
148		char *fs_type;
149	<	char *mnt_point;
150	<	long long size;
151	<	long long used;
152	<	long long avail;
153	<	long long total_inodes;
149	>	char *mnt_point;
150	>	long long size;
151	>	long long used;
152	>	long long avail;
153	>	long long total_inodes;
154		long long used_inodes;
155	<	long long free_inodes;
156	<	}disk_stat_t;
155	>	long long free_inodes;
156	>	long long avail_inodes;
157	>	long long io_size;
158	>	long long block_size;
159	>	long long total_blocks;
160	>	long long free_blocks;
161	>	long long used_blocks;
162	>	long long avail_blocks;
163	>	} sg_fs_stats;
164
165	<	typedef struct{
165	>	sg_fs_stats *sg_get_fs_stats(int *entries);
166	>
167	>	int sg_fs_compare_device_name(const void *va, const void *vb);
168	>	int sg_fs_compare_mnt_point(const void *va, const void *vb);
169	>
170	>	typedef struct {
171		char *disk_name;
172		long long read_bytes;
173		long long write_bytes;
174		time_t systime;
175	<	}diskio_stat_t;
175	>	} sg_disk_io_stats;
176
177	<	typedef struct{
178	<	int total;
101	<	int running;
102	<	int sleeping;
103	<	int stopped;
104	<	int zombie;
105	<	}process_stat_t;
177	>	sg_disk_io_stats *sg_get_disk_io_stats(int *entries);
178	>	sg_disk_io_stats *sg_get_disk_io_stats_diff(int *entries);
179
180	<	typedef struct{
180	>	int sg_disk_io_compare_name(const void *va, const void *vb);
181	>
182	>	typedef struct {
183		char *interface_name;
184		long long tx;
185		long long rx;
186	+	long long ipackets;
187	+	long long opackets;
188	+	long long ierrors;
189	+	long long oerrors;
190	+	long long collisions;
191		time_t systime;
192	<	}network_stat_t;
192	>	} sg_network_io_stats;
193
194	<	typedef enum{
195	<	FULL_DUPLEX,
116	<	HALF_DUPLEX,
117	<	NO_DUPLEX
118	<	}duplex;
194	>	sg_network_io_stats *sg_get_network_io_stats(int *entries);
195	>	sg_network_io_stats *sg_get_network_io_stats_diff(int *entries);
196
197	<	typedef struct{
197	>	int sg_network_io_compare_name(const void *va, const void *vb);
198	>
199	>	typedef enum {
200	>	SG_IFACE_DUPLEX_FULL,
201	>	SG_IFACE_DUPLEX_HALF,
202	>	SG_IFACE_DUPLEX_UNKNOWN
203	>	} sg_iface_duplex;
204	>
205	>	typedef struct {
206		char *interface_name;
207		int speed;      /* In megabits/sec */
208	<	duplex dup;
209	<	}network_iface_stat_t;
208	>	sg_iface_duplex duplex;
209	>	#ifdef SG_ENABLE_DEPRECATED
210	>	sg_iface_duplex dup;
211	>	#endif
212	>	int up;
213	>	} sg_network_iface_stats;
214
215	<	typedef struct{
215	>	sg_network_iface_stats *sg_get_network_iface_stats(int *entries);
216	>
217	>	int sg_network_iface_compare_name(const void *va, const void *vb);
218	>
219	>	typedef struct {
220		long long pages_pagein;
221		long long pages_pageout;
222		time_t systime;
223	<	}page_stat_t;
223	>	} sg_page_stats;
224
225	<	cpu_states_t *get_cpu_totals();
226	<	cpu_states_t *get_cpu_diff();
134	<	cpu_percent_t *cpu_percent_usage();
225	>	sg_page_stats *sg_get_page_stats();
226	>	sg_page_stats *sg_get_page_stats_diff();
227
228	<	mem_stat_t *get_memory_stats();
228	>	typedef enum {
229	>	SG_PROCESS_STATE_RUNNING,
230	>	SG_PROCESS_STATE_SLEEPING,
231	>	SG_PROCESS_STATE_STOPPED,
232	>	SG_PROCESS_STATE_ZOMBIE,
233	>	SG_PROCESS_STATE_UNKNOWN
234	>	} sg_process_state;
235
236	<	load_stat_t *get_load_stats();
236	>	typedef struct {
237	>	char *process_name;
238	>	char *proctitle;
239
240	<	user_stat_t *get_user_stats();
240	>	pid_t pid;
241	>	pid_t parent; /* Parent pid */
242	>	pid_t pgid;   /* process id of process group leader */
243
244	<	swap_stat_t *get_swap_stats();
244	>	uid_t uid;
245	>	uid_t euid;
246	>	gid_t gid;
247	>	gid_t egid;
248
249	<	general_stat_t *get_general_stats();
249	>	unsigned long long proc_size; /* in bytes */
250	>	unsigned long long proc_resident; /* in bytes */
251	>	time_t time_spent; /* time running in seconds */
252	>	double cpu_percent;
253	>	int nice;
254	>	sg_process_state state;
255	>	} sg_process_stats;
256
257	<	disk_stat_t *get_disk_stats(int *entries);
147	<	diskio_stat_t *get_diskio_stats(int *entries);
148	<	diskio_stat_t *get_diskio_stats_diff(int *entries);
257	>	sg_process_stats *sg_get_process_stats(int *entries);
258
259	<	process_stat_t *get_process_stats();
259	>	int sg_process_compare_name(const void *va, const void *vb);
260	>	int sg_process_compare_pid(const void *va, const void *vb);
261	>	int sg_process_compare_uid(const void *va, const void *vb);
262	>	int sg_process_compare_gid(const void *va, const void *vb);
263	>	int sg_process_compare_size(const void *va, const void *vb);
264	>	int sg_process_compare_res(const void *va, const void *vb);
265	>	int sg_process_compare_cpu(const void *va, const void *vb);
266	>	int sg_process_compare_time(const void *va, const void *vb);
267
268	<	network_stat_t *get_network_stats(int *entries);
269	<	network_stat_t *get_network_stats_diff(int *entries);
268	>	typedef struct {
269	>	int total;
270	>	int running;
271	>	int sleeping;
272	>	int stopped;
273	>	int zombie;
274	>	} sg_process_count;
275
276	<	network_iface_stat_t *get_network_iface_stats(int *entries);
276	>	sg_process_count *sg_get_process_count();
277
278	<	page_stat_t *get_page_stats();
279	<	page_stat_t *get_page_stats_diff();
278	>	#ifdef SG_ENABLE_DEPRECATED
279	>	#include <statgrab_deprecated.h>
280	>	#endif
281
282	<	int statgrab_init(void);
161	<	int statgrab_drop_privileges(void);
162	<
282	>	#endif

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines