src/libstatgrab/memory_stats.c

/*
 * i-scream central monitoring system
 * 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: memory_stats.c,v 1.19 2004/01/19 16:49:21 tdb Exp $
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "statgrab.h"
#include "tools.h"
#ifdef SOLARIS
#include <unistd.h>
#include <kstat.h>
#endif
#if defined(LINUX) || defined(CYGWIN)
#include <stdio.h>
#include <string.h>
#endif
#ifdef FREEBSD
#include <sys/types.h>
#include <sys/sysctl.h>
#include <unistd.h>
#endif
#ifdef OPENBSD
#include <stdlib.h>
#include <sys/param.h>
#include <sys/sysctl.h>
#include <uvm/uvm.h>
#endif

mem_stat_t *get_memory_stats(){

        static mem_stat_t mem_stat;

#ifdef SOLARIS
        kstat_ctl_t *kc;
        kstat_t *ksp;
        kstat_named_t *kn;
        long totalmem;
        int pagesize;
#endif
#if defined(LINUX) || defined(CYGWIN)
        char *line_ptr;
        unsigned long long value;
        FILE *f;
#endif
#ifdef FREEBSD
        int mib[2];
        u_long physmem;
        size_t size;
        u_int free_count;
        u_int cache_count;
        u_int inactive_count;
        int pagesize;
#endif
#if defined(NETBSD) || defined(OPENBSD)
        struct uvmexp *uvm;
#endif
#ifdef OPENBSD
        int mib[2];
        size_t size;
#endif

#ifdef SOLARIS
        if((pagesize=sysconf(_SC_PAGESIZE)) == -1){
                return NULL;    
        }

        if((totalmem=sysconf(_SC_PHYS_PAGES)) == -1){
                return NULL;
        }

        if ((kc = kstat_open()) == NULL) {
                return NULL;
        }
        if((ksp=kstat_lookup(kc, "unix", 0, "system_pages")) == NULL){
                return NULL;
        }
        if (kstat_read(kc, ksp, 0) == -1) {
                return NULL;
        }
        if((kn=kstat_data_lookup(ksp, "freemem")) == NULL){
                return NULL;
        }
        kstat_close(kc);

        mem_stat.total = (long long)totalmem * (long long)pagesize;
        mem_stat.free = ((long long)kn->value.ul) * (long long)pagesize;
        mem_stat.used = mem_stat.total - mem_stat.free;
#endif

#if defined(LINUX) || defined(CYGWIN)
        if ((f = fopen("/proc/meminfo", "r")) == NULL) {
                return NULL;
        }

        while ((line_ptr = f_read_line(f, "")) != NULL) {
                if (sscanf(line_ptr, "%*s %llu kB", &value) != 1) {
                        continue;
                }
                value *= 1024;

                if (strncmp(line_ptr, "MemTotal:", 9) == 0) {
                        mem_stat.total = value;
                } else if (strncmp(line_ptr, "MemFree:", 8) == 0) {
                        mem_stat.free = value;
                } else if (strncmp(line_ptr, "Cached:", 7) == 0) {
                        mem_stat.cache = value;
                }
        }

        fclose(f);
        mem_stat.used = mem_stat.total - mem_stat.free;
#endif

#ifdef FREEBSD
        /* Returns bytes */
        mib[0] = CTL_HW;
        mib[1] = HW_PHYSMEM;
        size = sizeof physmem;
        if (sysctl(mib, 2, &physmem, &size, NULL, 0) < 0) {
                return NULL;
        }
        mem_stat.total = physmem;

        /*returns pages*/
        size = sizeof free_count;
        if (sysctlbyname("vm.stats.vm.v_free_count", &free_count, &size, NULL, 0) < 0){
                return NULL;
        }

        size = sizeof inactive_count;
        if (sysctlbyname("vm.stats.vm.v_inactive_count", &inactive_count , &size, NULL, 0) < 0){
                return NULL;
        }

        size = sizeof cache_count;
        if (sysctlbyname("vm.stats.vm.v_cache_count", &cache_count, &size, NULL, 0) < 0){
                return NULL;
        }

        /* Because all the vm.stats returns pages, I need to get the page size.
         * After that I then need to multiple the anything that used vm.stats to
         * get the system statistics by pagesize 
         */
        if ((pagesize=getpagesize()) == -1){
                return NULL;
        }

        mem_stat.cache=cache_count*pagesize;

        /* Of couse nothing is ever that simple :) And I have inactive pages to
         * deal with too. So I'm going to add them to free memory :)
         */
        mem_stat.free=(free_count*pagesize)+(inactive_count*pagesize);
        mem_stat.used=physmem-mem_stat.free;
#endif

#ifdef NETBSD
        if ((uvm = get_uvmexp()) == NULL) {
                return NULL;
        }
#endif
#ifdef OPENBSD
        mib[0] = CTL_VM;
        mib[1] = VM_UVMEXP;

        if (sysctl(mib, 2, NULL, &size, NULL, 0) < 0) {
                return NULL;
        }

        uvm = malloc(size);
        if (uvm == NULL) {
                return NULL;
        }

        if (sysctl(mib, 2, uvm, &size, NULL, 0) < 0) {
                return NULL;
        }
#endif
#if defined(NETBSD) || defined(OPENBSD)
        mem_stat.total = uvm->pagesize * uvm->npages;
#ifdef NETBSD
        mem_stat.cache = uvm->pagesize * (uvm->filepages + uvm->execpages);
#else
        mem_stat.cache = 0;
#endif
        mem_stat.free = uvm->pagesize * (uvm->free + uvm->inactive);
        mem_stat.used = mem_stat.total - mem_stat.free;
#endif

#ifdef OPENBSD
        free(uvm);
#endif

        return &mem_stat;
}
Revision:	1.20
Committed:	Thu Feb 12 23:04:52 2004 UTC (20 years, 3 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
Changes since 1.19:	+39 -2 lines
Log Message:	Add preliminary support for OpenBSD (tested on 3.3). All works apart from Disk IO stats - currently the disks are not named correctly. The fix for this is probably to use KVM. Mostly similar to the NetBSD code, the notable exception being the uvm stuff. In NetBSD there's a function to get it, in OpenBSD sysctl is needed to get hold of it.
#	Content
1	/*
2	* i-scream central monitoring system
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: memory_stats.c,v 1.19 2004/01/19 16:49:21 tdb Exp $
22	*/
23
24	#ifdef HAVE_CONFIG_H
25	#include "config.h"
26	#endif
27
28	#include "statgrab.h"
29	#include "tools.h"
30	#ifdef SOLARIS
31	#include <unistd.h>
32	#include <kstat.h>
33	#endif
34	#if defined(LINUX) \|\| defined(CYGWIN)
35	#include <stdio.h>
36	#include <string.h>
37	#endif
38	#ifdef FREEBSD
39	#include <sys/types.h>
40	#include <sys/sysctl.h>
41	#include <unistd.h>
42	#endif
43	#ifdef OPENBSD
44	#include <stdlib.h>
45	#include <sys/param.h>
46	#include <sys/sysctl.h>
47	#include <uvm/uvm.h>
48	#endif
49
50	mem_stat_t *get_memory_stats(){
51
52	static mem_stat_t mem_stat;
53
54	#ifdef SOLARIS
55	kstat_ctl_t *kc;
56	kstat_t *ksp;
57	kstat_named_t *kn;
58	long totalmem;
59	int pagesize;
60	#endif
61	#if defined(LINUX) \|\| defined(CYGWIN)
62	char *line_ptr;
63	unsigned long long value;
64	FILE *f;
65	#endif
66	#ifdef FREEBSD
67	int mib[2];
68	u_long physmem;
69	size_t size;
70	u_int free_count;
71	u_int cache_count;
72	u_int inactive_count;
73	int pagesize;
74	#endif
75	#if defined(NETBSD) \|\| defined(OPENBSD)
76	struct uvmexp *uvm;
77	#endif
78	#ifdef OPENBSD
79	int mib[2];
80	size_t size;
81	#endif
82
83	#ifdef SOLARIS
84	if((pagesize=sysconf(_SC_PAGESIZE)) == -1){
85	return NULL;
86	}
87
88	if((totalmem=sysconf(_SC_PHYS_PAGES)) == -1){
89	return NULL;
90	}
91
92	if ((kc = kstat_open()) == NULL) {
93	return NULL;
94	}
95	if((ksp=kstat_lookup(kc, "unix", 0, "system_pages")) == NULL){
96	return NULL;
97	}
98	if (kstat_read(kc, ksp, 0) == -1) {
99	return NULL;
100	}
101	if((kn=kstat_data_lookup(ksp, "freemem")) == NULL){
102	return NULL;
103	}
104	kstat_close(kc);
105
106	mem_stat.total = (long long)totalmem * (long long)pagesize;
107	mem_stat.free = ((long long)kn->value.ul) * (long long)pagesize;
108	mem_stat.used = mem_stat.total - mem_stat.free;
109	#endif
110
111	#if defined(LINUX) \|\| defined(CYGWIN)
112	if ((f = fopen("/proc/meminfo", "r")) == NULL) {
113	return NULL;
114	}
115
116	while ((line_ptr = f_read_line(f, "")) != NULL) {
117	if (sscanf(line_ptr, "%*s %llu kB", &value) != 1) {
118	continue;
119	}
120	value *= 1024;
121
122	if (strncmp(line_ptr, "MemTotal:", 9) == 0) {
123	mem_stat.total = value;
124	} else if (strncmp(line_ptr, "MemFree:", 8) == 0) {
125	mem_stat.free = value;
126	} else if (strncmp(line_ptr, "Cached:", 7) == 0) {
127	mem_stat.cache = value;
128	}
129	}
130
131	fclose(f);
132	mem_stat.used = mem_stat.total - mem_stat.free;
133	#endif
134
135	#ifdef FREEBSD
136	/* Returns bytes */
137	mib[0] = CTL_HW;
138	mib[1] = HW_PHYSMEM;
139	size = sizeof physmem;
140	if (sysctl(mib, 2, &physmem, &size, NULL, 0) < 0) {
141	return NULL;
142	}
143	mem_stat.total = physmem;
144
145	/returns pages/
146	size = sizeof free_count;
147	if (sysctlbyname("vm.stats.vm.v_free_count", &free_count, &size, NULL, 0) < 0){
148	return NULL;
149	}
150
151	size = sizeof inactive_count;
152	if (sysctlbyname("vm.stats.vm.v_inactive_count", &inactive_count , &size, NULL, 0) < 0){
153	return NULL;
154	}
155
156	size = sizeof cache_count;
157	if (sysctlbyname("vm.stats.vm.v_cache_count", &cache_count, &size, NULL, 0) < 0){
158	return NULL;
159	}
160
161	/* Because all the vm.stats returns pages, I need to get the page size.
162	* After that I then need to multiple the anything that used vm.stats to
163	* get the system statistics by pagesize
164	*/
165	if ((pagesize=getpagesize()) == -1){
166	return NULL;
167	}
168
169	mem_stat.cache=cache_count*pagesize;
170
171	/* Of couse nothing is ever that simple :) And I have inactive pages to
172	* deal with too. So I'm going to add them to free memory :)
173	*/
174	mem_stat.free=(free_countpagesize)+(inactive_countpagesize);
175	mem_stat.used=physmem-mem_stat.free;
176	#endif
177
178	#ifdef NETBSD
179	if ((uvm = get_uvmexp()) == NULL) {
180	return NULL;
181	}
182	#endif
183	#ifdef OPENBSD
184	mib[0] = CTL_VM;
185	mib[1] = VM_UVMEXP;
186
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)
201	mem_stat.total = uvm->pagesize * uvm->npages;
202	#ifdef NETBSD
203	mem_stat.cache = uvm->pagesize * (uvm->filepages + uvm->execpages);
204	#else
205	mem_stat.cache = 0;
206	#endif
207	mem_stat.free = uvm->pagesize * (uvm->free + uvm->inactive);
208	mem_stat.used = mem_stat.total - mem_stat.free;
209	#endif
210
211	#ifdef OPENBSD
212	free(uvm);
213	#endif
214
215	return &mem_stat;
216	}