ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/libstatgrab/src/libstatgrab/statgrab.h
(Generate patch)

Comparing projects/libstatgrab/src/libstatgrab/statgrab.h (file contents):
Revision 1.32 by tdb, Sat Apr 3 22:59:30 2004 UTC vs.
Revision 1.57 by tdb, Sat Sep 24 13:29:22 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_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 < }cpu_percent_t;
121 > } sg_cpu_percents;
122  
123 < typedef struct{
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 < }mem_stat_t;
130 > } sg_mem_stats;
131  
132 < typedef struct{
132 > sg_mem_stats *sg_get_mem_stats();
133 >
134 > typedef struct {
135          double min1;
136          double min5;
137          double min15;
138 < }load_stat_t;
138 > } sg_load_stats;
139  
140 < typedef struct{
140 > sg_load_stats *sg_get_load_stats();
141 >
142 > typedef struct {
143          char *name_list;
144          int num_entries;
145 < }user_stat_t;
145 > } sg_user_stats;
146  
147 < typedef struct{
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 < }swap_stat_t;
153 > } sg_swap_stats;
154  
155 < 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;
155 > sg_swap_stats *sg_get_swap_stats();
156  
157   typedef struct {
158 <        char *device_name;
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;
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 < }disk_stat_t;
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 < typedef struct{
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 < }diskio_stat_t;
186 > } sg_disk_io_stats;
187  
188 < typedef struct{
189 <        int total;
101 <        int running;
102 <        int sleeping;
103 <        int stopped;
104 <        int zombie;
105 < }process_stat_t;
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 < typedef struct{
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;
# Line 114 | Line 200 | typedef struct{
200          long long oerrors;
201          long long collisions;
202          time_t systime;
203 < }network_stat_t;
203 > } sg_network_io_stats;
204  
205 < typedef enum{
206 <        FULL_DUPLEX,
121 <        HALF_DUPLEX,
122 <        UNKNOWN_DUPLEX
123 < }statgrab_duplex;
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 < typedef struct{
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 <        statgrab_duplex dup;    
219 >        sg_iface_duplex duplex;
220 > #ifdef SG_ENABLE_DEPRECATED
221 >        sg_iface_duplex dup;
222 > #endif
223          int up;
224 < }network_iface_stat_t;
224 > } sg_network_iface_stats;
225  
226 < typedef struct{
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 < }page_stat_t;
234 > } sg_page_stats;
235  
236 < typedef enum{
237 <        RUNNING,
140 <        SLEEPING,
141 <        STOPPED,
142 <        ZOMBIE,
143 <        UNKNOWN
144 < }process_status;
236 > sg_page_stats *sg_get_page_stats();
237 > sg_page_stats *sg_get_page_stats_diff();
238  
239 < typedef struct{
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  
# Line 151 | Line 252 | typedef struct{
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 <        process_status state;
274 < }proc_state_t;
273 >        sg_process_state state;
274 > } sg_process_stats;
275  
276 < int get_proc_snapshot(proc_state_t **proc_state);
276 > sg_process_stats *sg_get_process_stats(int *entries);
277  
278 < cpu_states_t *get_cpu_totals();
279 < cpu_states_t *get_cpu_diff();
280 < cpu_percent_t *cpu_percent_usage();
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 < mem_stat_t *get_memory_stats();
287 > typedef struct {
288 >        int total;
289 >        int running;
290 >        int sleeping;
291 >        int stopped;
292 >        int zombie;
293 > } sg_process_count;
294  
295 < load_stat_t *get_load_stats();
295 > sg_process_count *sg_get_process_count();
296  
297 < user_stat_t *get_user_stats();
297 > #ifdef SG_ENABLE_DEPRECATED
298 > #include <statgrab_deprecated.h>
299 > #endif
300  
301 < swap_stat_t *get_swap_stats();
180 <
181 < general_stat_t *get_general_stats();
182 <
183 < disk_stat_t *get_disk_stats(int *entries);
184 < diskio_stat_t *get_diskio_stats(int *entries);
185 < diskio_stat_t *get_diskio_stats_diff(int *entries);
186 <
187 < process_stat_t *get_process_stats();
188 <
189 < network_stat_t *get_network_stats(int *entries);
190 < network_stat_t *get_network_stats_diff(int *entries);
191 <
192 < network_iface_stat_t *get_network_iface_stats(int *entries);
193 <
194 < page_stat_t *get_page_stats();
195 < page_stat_t *get_page_stats_diff();
196 <
197 < int statgrab_init(void);
198 < int statgrab_drop_privileges(void);
199 <
301 > #endif

Diff Legend

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