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.37 2004/04/06 22:09:22 ats 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_MALLOC_FAILED
} 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.38
Committed:	Wed Apr 7 09:44:08 2004 UTC (20 years, 1 month ago) by tdb
Content type:	text/plain
Branch:	MAIN
Changes since 1.37:	+3 -2 lines
Log Message:	Add sg_realloc, and a macro fo sg_malloc.
#	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.37 2004/04/06 22:09:22 ats 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_MALLOC_FAILED
38	} sg_error;
39
40	void sg_set_error(sg_error code, const char *arg);
41	sg_error sg_get_error();
42	const char *sg_str_error(sg_error code);
43
44	typedef struct {
45	char *os_name;
46	char *os_release;
47	char *os_version;
48	char *platform;
49	char *hostname;
50	time_t uptime;
51	} sg_host_info;
52
53	sg_host_info *sg_get_host_info();
54
55	typedef struct {
56	long long user;
57	long long kernel;
58	long long idle;
59	long long iowait;
60	long long swap;
61	long long nice;
62	long long total;
63	time_t systime;
64	} sg_cpu_stats;
65
66	sg_cpu_stats *sg_get_cpu_stats();
67	sg_cpu_stats *sg_get_cpu_stats_diff();
68
69	typedef struct {
70	float user;
71	float kernel;
72	float idle;
73	float iowait;
74	float swap;
75	float nice;
76	time_t time_taken;
77	} sg_cpu_percents;
78
79	sg_cpu_percents *sg_get_cpu_percents();
80
81	typedef struct {
82	long long total;
83	long long free;
84	long long used;
85	long long cache;
86	} sg_mem_stats;
87
88	sg_mem_stats *sg_get_mem_stats();
89
90	typedef struct {
91	double min1;
92	double min5;
93	double min15;
94	} sg_load_stats;
95
96	sg_load_stats *sg_get_load_stats();
97
98	typedef struct {
99	char *name_list;
100	int num_entries;
101	} sg_user_stats;
102
103	sg_user_stats *sg_get_user_stats();
104
105	typedef struct {
106	long long total;
107	long long used;
108	long long free;
109	} sg_swap_stats;
110
111	sg_swap_stats *sg_get_swap_stats();
112
113	typedef struct {
114	char *device_name;
115	char *fs_type;
116	char *mnt_point;
117	long long size;
118	long long used;
119	long long avail;
120	long long total_inodes;
121	long long used_inodes;
122	long long free_inodes;
123	} sg_fs_stats;
124
125	sg_fs_stats sg_get_fs_stats(int entries);
126
127	typedef struct {
128	char *disk_name;
129	long long read_bytes;
130	long long write_bytes;
131	time_t systime;
132	} sg_disk_io_stats;
133
134	sg_disk_io_stats sg_get_disk_io_stats(int entries);
135	sg_disk_io_stats sg_get_disk_io_stats_diff(int entries);
136
137	typedef struct {
138	char *interface_name;
139	long long tx;
140	long long rx;
141	long long ipackets;
142	long long opackets;
143	long long ierrors;
144	long long oerrors;
145	long long collisions;
146	time_t systime;
147	} sg_network_io_stats;
148
149	sg_network_io_stats sg_get_network_io_stats(int entries);
150	sg_network_io_stats sg_get_network_io_stats_diff(int entries);
151
152	typedef enum {
153	SG_IFACE_DUPLEX_FULL,
154	SG_IFACE_DUPLEX_HALF,
155	SG_IFACE_DUPLEX_UNKNOWN
156	} sg_iface_duplex;
157
158	typedef struct {
159	char *interface_name;
160	int speed; /* In megabits/sec */
161	sg_iface_duplex dup;
162	int up;
163	} sg_network_iface_stats;
164
165	sg_network_iface_stats sg_get_network_iface_stats(int entries);
166
167	typedef struct {
168	long long pages_pagein;
169	long long pages_pageout;
170	time_t systime;
171	} sg_page_stats;
172
173	sg_page_stats *sg_get_page_stats();
174	sg_page_stats *sg_get_page_stats_diff();
175
176	typedef enum {
177	SG_PROCESS_STATE_RUNNING,
178	SG_PROCESS_STATE_SLEEPING,
179	SG_PROCESS_STATE_STOPPED,
180	SG_PROCESS_STATE_ZOMBIE,
181	SG_PROCESS_STATE_UNKNOWN
182	} sg_process_state;
183
184	typedef struct {
185	char *process_name;
186	char *proctitle;
187
188	pid_t pid;
189	pid_t parent; /* Parent pid */
190	pid_t pgid; /* process id of process group leader */
191
192	uid_t uid;
193	uid_t euid;
194	gid_t gid;
195	gid_t egid;
196
197	unsigned long long proc_size; /* in bytes */
198	unsigned long long proc_resident; /* in bytes */
199	time_t time_spent; /* time running in seconds */
200	double cpu_percent;
201	int nice;
202	sg_process_state state;
203	} sg_process_stats;
204
205	sg_process_stats sg_get_process_stats(int entries);
206
207	typedef struct {
208	int total;
209	int running;
210	int sleeping;
211	int stopped;
212	int zombie;
213	} sg_process_count;
214
215	sg_process_count *sg_get_process_count();
216
217	#ifdef SG_ENABLE_DEPRECATED
218	#include <statgrab_deprecated.h>
219	#endif
220