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

Comparing projects/libstatgrab/src/libstatgrab/memory_stats.c (file contents):
Revision 1.20 by tdb, Thu Feb 12 23:04:52 2004 UTC vs.
Revision 1.29 by ats, Sun Jul 18 21:31:32 2004 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 35 | Line 35
35   #include <stdio.h>
36   #include <string.h>
37   #endif
38 < #ifdef FREEBSD
38 > #if defined(FREEBSD) || defined(DFBSD)
39   #include <sys/types.h>
40   #include <sys/sysctl.h>
41   #include <unistd.h>
42   #endif
43 < #ifdef OPENBSD
44 < #include <stdlib.h>
43 > #if defined(NETBSD) || defined(OPENBSD)
44   #include <sys/param.h>
45 < #include <sys/sysctl.h>
45 > #include <sys/time.h>
46   #include <uvm/uvm.h>
47   #endif
48  
49 < mem_stat_t *get_memory_stats(){
49 > sg_mem_stats *sg_get_mem_stats(){
50  
51 <        static mem_stat_t mem_stat;
51 >        static sg_mem_stats mem_stat;
52  
53   #ifdef SOLARIS
54          kstat_ctl_t *kc;
# Line 63 | Line 62 | mem_stat_t *get_memory_stats(){
62          unsigned long long value;
63          FILE *f;
64   #endif
65 < #ifdef FREEBSD
65 > #if defined(FREEBSD) || defined(DFBSD)
66          int mib[2];
67          u_long physmem;
68          size_t size;
# Line 75 | Line 74 | mem_stat_t *get_memory_stats(){
74   #if defined(NETBSD) || defined(OPENBSD)
75          struct uvmexp *uvm;
76   #endif
78 – #ifdef OPENBSD
79 –        int mib[2];
80 –        size_t size;
81 – #endif
77  
78   #ifdef SOLARIS
79          if((pagesize=sysconf(_SC_PAGESIZE)) == -1){
80 +                sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
81                  return NULL;    
82          }
83  
84          if((totalmem=sysconf(_SC_PHYS_PAGES)) == -1){
85 +                sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PHYS_PAGES");
86                  return NULL;
87          }
88  
89          if ((kc = kstat_open()) == NULL) {
90 +                sg_set_error(SG_ERROR_KSTAT_OPEN, NULL);
91                  return NULL;
92          }
93          if((ksp=kstat_lookup(kc, "unix", 0, "system_pages")) == NULL){
94 +                sg_set_error(SG_ERROR_KSTAT_LOOKUP, "unix,0,system_pages");
95                  return NULL;
96          }
97          if (kstat_read(kc, ksp, 0) == -1) {
98 +                sg_set_error(SG_ERROR_KSTAT_READ, NULL);
99                  return NULL;
100          }
101          if((kn=kstat_data_lookup(ksp, "freemem")) == NULL){
102 +                sg_set_error(SG_ERROR_KSTAT_DATA_LOOKUP, "freemem");
103                  return NULL;
104          }
105 <        kstat_close(kc);
105 >        kstat_close(kc);
106  
107          mem_stat.total = (long long)totalmem * (long long)pagesize;
108          mem_stat.free = ((long long)kn->value.ul) * (long long)pagesize;
# Line 110 | Line 111 | mem_stat_t *get_memory_stats(){
111  
112   #if defined(LINUX) || defined(CYGWIN)
113          if ((f = fopen("/proc/meminfo", "r")) == NULL) {
114 +                sg_set_error_with_errno(SG_ERROR_OPEN, "/proc/meminfo");
115                  return NULL;
116          }
117  
118 <        while ((line_ptr = f_read_line(f, "")) != NULL) {
118 >        while ((line_ptr = sg_f_read_line(f, "")) != NULL) {
119                  if (sscanf(line_ptr, "%*s %llu kB", &value) != 1) {
120                          continue;
121                  }
# Line 132 | Line 134 | mem_stat_t *get_memory_stats(){
134          mem_stat.used = mem_stat.total - mem_stat.free;
135   #endif
136  
137 < #ifdef FREEBSD
137 > #if defined(FREEBSD) || defined(DFBSD)
138          /* Returns bytes */
139          mib[0] = CTL_HW;
140          mib[1] = HW_PHYSMEM;
141          size = sizeof physmem;
142          if (sysctl(mib, 2, &physmem, &size, NULL, 0) < 0) {
143 +                sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_HW.HW_PHYSMEM");
144                  return NULL;
145          }
146          mem_stat.total = physmem;
147  
148          /*returns pages*/
149          size = sizeof free_count;
150 <        if (sysctlbyname("vm.stats.vm.v_free_count", &free_count, &size, NULL, 0) < 0){
150 >        if (sysctlbyname("vm.stats.vm.v_free_count", &free_count, &size, NULL, 0) < 0){
151 >                sg_set_error_with_errno(SG_ERROR_SYSCTLBYNAME,
152 >                                        "vm.stats.vm.v_free_count");
153                  return NULL;
154 <        }
154 >        }
155  
156          size = sizeof inactive_count;
157 <        if (sysctlbyname("vm.stats.vm.v_inactive_count", &inactive_count , &size, NULL, 0) < 0){
157 >        if (sysctlbyname("vm.stats.vm.v_inactive_count", &inactive_count , &size, NULL, 0) < 0){
158 >                sg_set_error_with_errno(SG_ERROR_SYSCTLBYNAME,
159 >                                        "vm.stats.vm.v_inactive_count");
160                  return NULL;
161 <        }
161 >        }
162  
163          size = sizeof cache_count;
164 <        if (sysctlbyname("vm.stats.vm.v_cache_count", &cache_count, &size, NULL, 0) < 0){
164 >        if (sysctlbyname("vm.stats.vm.v_cache_count", &cache_count, &size, NULL, 0) < 0){
165 >                sg_set_error_with_errno(SG_ERROR_SYSCTLBYNAME,
166 >                                        "vm.stats.vm.v_cache_count");
167                  return NULL;
168 <        }
168 >        }
169  
170          /* Because all the vm.stats returns pages, I need to get the page size.
171 <         * After that I then need to multiple the anything that used vm.stats to
171 >         * After that I then need to multiple the anything that used vm.stats to
172           * get the system statistics by pagesize
173           */
174 <        if ((pagesize=getpagesize()) == -1){
166 <                return NULL;
167 <        }
168 <
174 >        pagesize = getpagesize();
175          mem_stat.cache=cache_count*pagesize;
176  
177          /* Of couse nothing is ever that simple :) And I have inactive pages to
# Line 175 | Line 181 | mem_stat_t *get_memory_stats(){
181          mem_stat.used=physmem-mem_stat.free;
182   #endif
183  
184 < #ifdef NETBSD
185 <        if ((uvm = get_uvmexp()) == NULL) {
184 > #if defined(NETBSD) || defined(OPENBSD)
185 >        if ((uvm = sg_get_uvmexp()) == NULL) {
186                  return NULL;
187          }
182 – #endif
183 – #ifdef OPENBSD
184 –        mib[0] = CTL_VM;
185 –        mib[1] = VM_UVMEXP;
188  
187 –        if (sysctl(mib, 2, NULL, &size, NULL, 0) < 0) {
188 –                return NULL;
189 –        }
190 –
191 –        uvm = malloc(size);
192 –        if (uvm == NULL) {
193 –                return NULL;
194 –        }
195 –
196 –        if (sysctl(mib, 2, uvm, &size, NULL, 0) < 0) {
197 –                return NULL;
198 –        }
199 – #endif
200 – #if defined(NETBSD) || defined(OPENBSD)
189          mem_stat.total = uvm->pagesize * uvm->npages;
190   #ifdef NETBSD
191          mem_stat.cache = uvm->pagesize * (uvm->filepages + uvm->execpages);
192   #else
193 +        /* Can't find cache memory on OpenBSD */
194          mem_stat.cache = 0;
195   #endif
196          mem_stat.free = uvm->pagesize * (uvm->free + uvm->inactive);
197          mem_stat.used = mem_stat.total - mem_stat.free;
209 – #endif
210 –
211 – #ifdef OPENBSD
212 –        free(uvm);
198   #endif
199  
200          return &mem_stat;

Diff Legend

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