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.54 2004/11/01 18:30:17 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_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_PSTAT
} 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;
} 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 */

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

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.55
Committed:	Wed Jul 13 09:31:54 2005 UTC (18 years, 10 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
Changes since 1.54:	+4 -1 lines
Log Message:	Change the name of the duplex value from "dup" to "duplex". This will break the ABI, but we're changing the fs stats anyway. The API change is minimal, so hopefully won't affect too many people.
#	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.54 2004/11/01 18:30:17 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_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	} sg_cpu_percents;
111
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	} sg_mem_stats;
120
121	sg_mem_stats *sg_get_mem_stats();
122
123	typedef struct {
124	double min1;
125	double min5;
126	double min15;
127	} sg_load_stats;
128
129	sg_load_stats *sg_get_load_stats();
130
131	typedef struct {
132	char *name_list;
133	int num_entries;
134	} sg_user_stats;
135
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	} sg_swap_stats;
143
144	sg_swap_stats *sg_get_swap_stats();
145
146	typedef struct {
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;
154	long long used_inodes;
155	long long free_inodes;
156	} sg_fs_stats;
157
158	sg_fs_stats sg_get_fs_stats(int entries);
159
160	int sg_fs_compare_device_name(const void va, const void vb);
161	int sg_fs_compare_mnt_point(const void va, const void vb);
162
163	typedef struct {
164	char *disk_name;
165	long long read_bytes;
166	long long write_bytes;
167	time_t systime;
168	} sg_disk_io_stats;
169
170	sg_disk_io_stats sg_get_disk_io_stats(int entries);
171	sg_disk_io_stats sg_get_disk_io_stats_diff(int entries);
172
173	int sg_disk_io_compare_name(const void va, const void vb);
174
175	typedef struct {
176	char *interface_name;
177	long long tx;
178	long long rx;
179	long long ipackets;
180	long long opackets;
181	long long ierrors;
182	long long oerrors;
183	long long collisions;
184	time_t systime;
185	} sg_network_io_stats;
186
187	sg_network_io_stats sg_get_network_io_stats(int entries);
188	sg_network_io_stats sg_get_network_io_stats_diff(int entries);
189
190	int sg_network_io_compare_name(const void va, const void vb);
191
192	typedef enum {
193	SG_IFACE_DUPLEX_FULL,
194	SG_IFACE_DUPLEX_HALF,
195	SG_IFACE_DUPLEX_UNKNOWN
196	} sg_iface_duplex;
197
198	typedef struct {
199	char *interface_name;
200	int speed; /* In megabits/sec */
201	sg_iface_duplex duplex;
202	#ifdef SG_ENABLE_DEPRECATED
203	sg_iface_duplex dup;
204	#endif
205	int up;
206	} sg_network_iface_stats;
207
208	sg_network_iface_stats sg_get_network_iface_stats(int entries);
209
210	int sg_network_iface_compare_name(const void va, const void vb);
211
212	typedef struct {
213	long long pages_pagein;
214	long long pages_pageout;
215	time_t systime;
216	} sg_page_stats;
217
218	sg_page_stats *sg_get_page_stats();
219	sg_page_stats *sg_get_page_stats_diff();
220
221	typedef enum {
222	SG_PROCESS_STATE_RUNNING,
223	SG_PROCESS_STATE_SLEEPING,
224	SG_PROCESS_STATE_STOPPED,
225	SG_PROCESS_STATE_ZOMBIE,
226	SG_PROCESS_STATE_UNKNOWN
227	} sg_process_state;
228
229	typedef struct {
230	char *process_name;
231	char *proctitle;
232
233	pid_t pid;
234	pid_t parent; /* Parent pid */
235	pid_t pgid; /* process id of process group leader */
236
237	uid_t uid;
238	uid_t euid;
239	gid_t gid;
240	gid_t egid;
241
242	unsigned long long proc_size; /* in bytes */
243	unsigned long long proc_resident; /* in bytes */
244	time_t time_spent; /* time running in seconds */
245	double cpu_percent;
246	int nice;
247	sg_process_state state;
248	} sg_process_stats;
249
250	sg_process_stats sg_get_process_stats(int entries);
251
252	int sg_process_compare_name(const void va, const void vb);
253	int sg_process_compare_pid(const void va, const void vb);
254	int sg_process_compare_uid(const void va, const void vb);
255	int sg_process_compare_gid(const void va, const void vb);
256	int sg_process_compare_size(const void va, const void vb);
257	int sg_process_compare_res(const void va, const void vb);
258	int sg_process_compare_cpu(const void va, const void vb);
259	int sg_process_compare_time(const void va, const void vb);
260
261	typedef struct {
262	int total;
263	int running;
264	int sleeping;
265	int stopped;
266	int zombie;
267	} sg_process_count;
268
269	sg_process_count *sg_get_process_count();
270
271	#ifdef SG_ENABLE_DEPRECATED
272	#include <statgrab_deprecated.h>
273	#endif
274
275	#endif