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.41 2004/04/07 19:26:16 tdb Exp $
 */

#include <sys/types.h>

/* FIXME typedefs for 32/64-bit types */
/* FIXME maybe tidy up field names? */
/* FIXME tab/space damage */
/* FIXME prefixes for util functions too */
/* 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_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();

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

Revision:	1.42
Committed:	Wed Apr 7 21:08:40 2004 UTC (20 years, 1 month ago) by tdb
Content type:	text/plain
Branch:	MAIN
Changes since 1.41:	+26 -9 lines
Log Message:	The rest of the error handling stuff (except the vector code). I've been extremely unimaginative with the string names in error.c, but they're all in one place so much easier to tidy up. I'm also beginning to wonder if we actually needed an SG_ERROR_SYSTEM_CALL to indicate some call into the system failed - because the majority of our errors are those :-) Still to do, then: - vector code - better string names in error.c - deal with arg string in some way - make use of the error status in statgrab/saidar/examples
#	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.41 2004/04/07 19:26:16 tdb Exp $
22	*/
23
24	#include <sys/types.h>
25
26	/* FIXME typedefs for 32/64-bit types */
27	/* FIXME maybe tidy up field names? */
28	/* FIXME tab/space damage */
29	/* FIXME prefixes for util functions too */
30	/* FIXME comments for less obvious fields */
31
32	int sg_init(void);
33	int sg_drop_privileges(void);
34
35	typedef enum {
36	SG_ERROR_NONE = 0,
37	SG_ERROR_ASPRINTF,
38	SG_ERROR_DEVSTAT_GETDEVS,
39	SG_ERROR_DEVSTAT_SELECTDEVS,
40	SG_ERROR_ENOENT,
41	SG_ERROR_GETIFADDRS,
42	SG_ERROR_GETMNTINFO,
43	SG_ERROR_GETPAGESIZE,
44	SG_ERROR_KSTAT_DATA_LOOKUP,
45	SG_ERROR_KSTAT_LOOKUP,
46	SG_ERROR_KSTAT_OPEN,
47	SG_ERROR_KSTAT_READ,
48	SG_ERROR_KVM_GETSWAPINFO,
49	SG_ERROR_KVM_OPENFILES,
50	SG_ERROR_MALLOC,
51	SG_ERROR_OPEN,
52	SG_ERROR_OPENDIR,
53	SG_ERROR_PARSE,
54	SG_ERROR_SETEGID,
55	SG_ERROR_SETEUID,
56	SG_ERROR_SETMNTENT,
57	SG_ERROR_SOCKET,
58	SG_ERROR_SWAPCTL,
59	SG_ERROR_SYSCONF,
60	SG_ERROR_SYSCTL,
61	SG_ERROR_SYSCTLBYNAME,
62	SG_ERROR_SYSCTLNAMETOMIB,
63	SG_ERROR_UNAME,
64	SG_ERROR_UNSUPPORTED,
65	SG_ERROR_XSW_VER_MISMATCH
66	} sg_error;
67
68	void sg_set_error(sg_error code, const char *arg);
69	sg_error sg_get_error();
70	const char *sg_str_error(sg_error code);
71
72	typedef struct {
73	char *os_name;
74	char *os_release;
75	char *os_version;
76	char *platform;
77	char *hostname;
78	time_t uptime;
79	} sg_host_info;
80
81	sg_host_info *sg_get_host_info();
82
83	typedef struct {
84	long long user;
85	long long kernel;
86	long long idle;
87	long long iowait;
88	long long swap;
89	long long nice;
90	long long total;
91	time_t systime;
92	} sg_cpu_stats;
93
94	sg_cpu_stats *sg_get_cpu_stats();
95	sg_cpu_stats *sg_get_cpu_stats_diff();
96
97	typedef struct {
98	float user;
99	float kernel;
100	float idle;
101	float iowait;
102	float swap;
103	float nice;
104	time_t time_taken;
105	} sg_cpu_percents;
106
107	sg_cpu_percents *sg_get_cpu_percents();
108
109	typedef struct {
110	long long total;
111	long long free;
112	long long used;
113	long long cache;
114	} sg_mem_stats;
115
116	sg_mem_stats *sg_get_mem_stats();
117
118	typedef struct {
119	double min1;
120	double min5;
121	double min15;
122	} sg_load_stats;
123
124	sg_load_stats *sg_get_load_stats();
125
126	typedef struct {
127	char *name_list;
128	int num_entries;
129	} sg_user_stats;
130
131	sg_user_stats *sg_get_user_stats();
132
133	typedef struct {
134	long long total;
135	long long used;
136	long long free;
137	} sg_swap_stats;
138
139	sg_swap_stats *sg_get_swap_stats();
140
141	typedef struct {
142	char *device_name;
143	char *fs_type;
144	char *mnt_point;
145	long long size;
146	long long used;
147	long long avail;
148	long long total_inodes;
149	long long used_inodes;
150	long long free_inodes;
151	} sg_fs_stats;
152
153	sg_fs_stats sg_get_fs_stats(int entries);
154
155	typedef struct {
156	char *disk_name;
157	long long read_bytes;
158	long long write_bytes;
159	time_t systime;
160	} sg_disk_io_stats;
161
162	sg_disk_io_stats sg_get_disk_io_stats(int entries);
163	sg_disk_io_stats sg_get_disk_io_stats_diff(int entries);
164
165	typedef struct {
166	char *interface_name;
167	long long tx;
168	long long rx;
169	long long ipackets;
170	long long opackets;
171	long long ierrors;
172	long long oerrors;
173	long long collisions;
174	time_t systime;
175	} sg_network_io_stats;
176
177	sg_network_io_stats sg_get_network_io_stats(int entries);
178	sg_network_io_stats sg_get_network_io_stats_diff(int entries);
179
180	typedef enum {
181	SG_IFACE_DUPLEX_FULL,
182	SG_IFACE_DUPLEX_HALF,
183	SG_IFACE_DUPLEX_UNKNOWN
184	} sg_iface_duplex;
185
186	typedef struct {
187	char *interface_name;
188	int speed; /* In megabits/sec */
189	sg_iface_duplex dup;
190	int up;
191	} sg_network_iface_stats;
192
193	sg_network_iface_stats sg_get_network_iface_stats(int entries);
194
195	typedef struct {
196	long long pages_pagein;
197	long long pages_pageout;
198	time_t systime;
199	} sg_page_stats;
200
201	sg_page_stats *sg_get_page_stats();
202	sg_page_stats *sg_get_page_stats_diff();
203
204	typedef enum {
205	SG_PROCESS_STATE_RUNNING,
206	SG_PROCESS_STATE_SLEEPING,
207	SG_PROCESS_STATE_STOPPED,
208	SG_PROCESS_STATE_ZOMBIE,
209	SG_PROCESS_STATE_UNKNOWN
210	} sg_process_state;
211
212	typedef struct {
213	char *process_name;
214	char *proctitle;
215
216	pid_t pid;
217	pid_t parent; /* Parent pid */
218	pid_t pgid; /* process id of process group leader */
219
220	uid_t uid;
221	uid_t euid;
222	gid_t gid;
223	gid_t egid;
224
225	unsigned long long proc_size; /* in bytes */
226	unsigned long long proc_resident; /* in bytes */
227	time_t time_spent; /* time running in seconds */
228	double cpu_percent;
229	int nice;
230	sg_process_state state;
231	} sg_process_stats;
232
233	sg_process_stats sg_get_process_stats(int entries);
234
235	typedef struct {
236	int total;
237	int running;
238	int sleeping;
239	int stopped;
240	int zombie;
241	} sg_process_count;
242
243	sg_process_count *sg_get_process_count();
244
245	#ifdef SG_ENABLE_DEPRECATED
246	#include <statgrab_deprecated.h>
247	#endif
248