1 #include <u.h>
2 #include <kvm.h>
3 #include <nlist.h>
4 #include <sys/types.h>
5 #include <sys/protosw.h>
6 #include <sys/socket.h>
7 #include <sys/sysctl.h>
8 #include <sys/time.h>
9 #include <sys/dkstat.h>
10 #include <net/if.h>
11 #include <net/if_var.h>
12 #include <net/if_dl.h>
13 #include <net/if_types.h>
14 #include <machine/apm_bios.h>
15 #include <sys/ioctl.h>
16 #include <limits.h>
17 #include <libc.h>
18 #include <bio.h>
19 #include "dat.h"
20 
21 /* XXX: #if __FreeBSD_version */
22 
23 void xapm(int);
24 void xloadavg(int);
25 void xcpu(int);
26 void xswap(int);
27 void xsysctl(int);
28 void xnet(int);
29 void xkvm(int);
30 
31 void (*statfn[])(int) =
32 {
33 	xkvm,
34 	xapm,
35 	xloadavg,
36 	xswap,
37 	xcpu,
38 	xsysctl,
39 	xnet,
40 	0
41 };
42 
43 static kvm_t *kvm;
44 
45 static struct nlist nl[] = {
46 	{ "_ifnet" },
47 	{ "_cp_time" },
48 	{ "" },
49 };
50 
51 void
52 kvminit(void)
53 {
54 	char buf[_POSIX2_LINE_MAX];
55 
56 	if(kvm)
57 		return;
58 	kvm = kvm_openfiles(nil, nil, nil, OREAD, buf);
59 	if(kvm == nil)
60 		return;
61 	if(kvm_nlist(kvm, nl) < 0 || nl[0].n_type == 0){
62 		kvm = nil;
63 		return;
64 	}
65 }
66 
67 void
68 xkvm(int first)
69 {
70 	if(first)
71 		kvminit();
72 }
73 
74 int
75 kread(ulong addr, char *buf, int size)
76 {
77 	if(kvm_read(kvm, addr, buf, size) != size){
78 		memset(buf, 0, size);
79 		return -1;
80 	}
81 	return size;
82 }
83 
84 void
85 xnet(int first)
86 {
87 	ulong out, in, outb, inb, err;
88 	static ulong ifnetaddr;
89 	ulong addr;
90 	struct ifnet ifnet;
91 	struct ifnethead ifnethead;
92 	char name[16];
93 
94 	if(first)
95 		return;
96 
97 	if(ifnetaddr == 0){
98 		ifnetaddr = nl[0].n_value;
99 		if(ifnetaddr == 0)
100 			return;
101 	}
102 
103 	if(kread(ifnetaddr, (char*)&ifnethead, sizeof ifnethead) < 0)
104 		return;
105 
106 	out = in = outb = inb = err = 0;
107 	addr = (ulong)TAILQ_FIRST(&ifnethead);
108 	while(addr){
109 #if __FreeBSD_version < 500000
110 		if(kread(addr, (char*)&ifnet, sizeof ifnet) < 0
111 		|| kread((ulong)ifnet.if_name, name, 16) < 0)
112 			return;
113 #else
114 		if(kread(addr, (char*)&ifnet, sizeof ifnet) < 0
115 		|| kread((ulong)ifnet.if_dname, name, 16) < 0)
116 			return;
117 #endif
118 		name[15] = 0;
119 		addr = (ulong)TAILQ_NEXT(&ifnet, if_link);
120 		out += ifnet.if_opackets;
121 		in += ifnet.if_ipackets;
122 		outb += ifnet.if_obytes;
123 		inb += ifnet.if_ibytes;
124 		err += ifnet.if_oerrors+ifnet.if_ierrors;
125 	}
126 	Bprint(&bout, "etherin %lud 1000\n", in);
127 	Bprint(&bout, "etherout %lud 1000\n", out);
128 	Bprint(&bout, "etherinb %lud 1000000\n", inb);
129 	Bprint(&bout, "etheroutb %lud 1000000\n", outb);
130 	Bprint(&bout, "ethererr %lud 1000\n", err);
131 	Bprint(&bout, "ether %lud 1000\n", in+out);
132 	Bprint(&bout, "etherb %lud 1000000\n", inb+outb);
133 }
134 
135 #if __FreeBSD_version >= 500000
136 int
137 xacpi(int first)
138 {
139 	int rv;
140 	int val, len;
141 
142 	len = sizeof(val);
143 	rv = sysctlbyname("hw.acpi.battery.life", &val, &len, nil, 0);
144 	if(rv != 0)
145 		return -1;
146 	Bprint(&bout, "battery =%d 100\n", val);
147 	return 0;
148 }
149 #else
150 int
151 xacpi(int first)
152 {
153 	return -1;
154 }
155 #endif
156 
157 void
158 xapm(int first)
159 {
160 	static int fd;
161 	struct apm_info ai;
162 
163 	if(first){
164 		xacpi(first);
165 		fd = open("/dev/apm", OREAD);
166 		return;
167 	}
168 
169 	if(xacpi(0) >= 0)
170 		return;
171 
172 	if(ioctl(fd, APMIO_GETINFO, &ai) < 0)
173 		return;
174 
175 	if(ai.ai_batt_life <= 100)
176 		Bprint(&bout, "battery =%d 100\n", ai.ai_batt_life);
177 }
178 
179 int
180 rsys(char *name, char *buf, int len)
181 {
182 	size_t l;
183 
184 	l = len;
185 	if(sysctlbyname(name, buf, &l, nil, 0) < 0)
186 		return -1;
187 	buf[l] = 0;
188 	return l;
189 }
190 
191 vlong
192 isys(char *name)
193 {
194 	ulong u;
195 	size_t l;
196 
197 	l = sizeof u;
198 	if(sysctlbyname(name, &u, &l, nil, 0) < 0)
199 		return -1;
200 	return u;
201 }
202 
203 void
204 xsysctl(int first)
205 {
206 	static int pgsize;
207 
208 	if(first){
209 		pgsize = isys("vm.stats.vm.v_page_size");
210 		if(pgsize == 0)
211 			pgsize = 4096;
212 	}
213 
214 	Bprint(&bout, "mem =%lld %lld\n", 
215 		isys("vm.stats.vm.v_active_count")*pgsize, 
216 		isys("vm.stats.vm.v_page_count")*pgsize);
217 	Bprint(&bout, "context %lld 1000\n", isys("vm.stats.sys.v_swtch"));
218 	Bprint(&bout, "syscall %lld 1000\n", isys("vm.stats.sys.v_syscall"));
219 	Bprint(&bout, "intr %lld 1000\n", isys("vm.stats.sys.v_intr")+isys("vm.stats.sys.v_trap"));
220 	Bprint(&bout, "fault %lld 1000\n", isys("vm.stats.vm.v_vm_faults"));
221 	Bprint(&bout, "fork %lld 1000\n", isys("vm.stats.vm.v_forks")
222 		+isys("vm.stats.vm.v_rforks")
223 		+isys("vm.stats.vm.v_vforks"));
224 }
225 
226 void
227 xcpu(int first)
228 {
229 	static int stathz;
230 	ulong x[20];
231 	struct clockinfo *ci;
232 	int n;
233 
234 	if(first){
235 		if(rsys("kern.clockrate", (char*)&x, sizeof x) < sizeof ci)
236 			stathz = 128;
237 		else{
238 			ci = (struct clockinfo*)x;
239 			stathz = ci->stathz;
240 		}
241 		return;
242 	}
243 
244 	if((n=rsys("kern.cp_time", (char*)x, sizeof x)) < 5*sizeof(ulong))
245 		return;
246 
247 	Bprint(&bout, "user %lud %d\n", x[CP_USER]+x[CP_NICE], stathz);
248 	Bprint(&bout, "sys %lud %d\n", x[CP_SYS], stathz);
249 	Bprint(&bout, "cpu %lud %d\n", x[CP_USER]+x[CP_NICE]+x[CP_SYS], stathz);
250 	Bprint(&bout, "idle %lud %d\n", x[CP_IDLE], stathz);
251 }
252 
253 void
254 xloadavg(int first)
255 {
256 	double l[3];
257 
258 	if(first)
259 		return;
260 
261 	if(getloadavg(l, 3) < 0)
262 		return;
263 	Bprint(&bout, "load =%d 1000\n", (int)(l[0]*1000.0));
264 }
265 
266 void
267 xswap(int first)
268 {
269 	static struct kvm_swap s;
270 	static ulong pgin, pgout;
271 	int i, o;
272 	static int pgsize;
273 
274 	if(first){
275 		pgsize = getpagesize();
276 		if(pgsize == 0)
277 			pgsize = 4096;
278 		return;
279 	}
280 
281 	if(kvm == nil)
282 		return;
283 
284 	i = isys("vm.stats.vm.v_swappgsin");
285 	o = isys("vm.stats.vm.v_swappgsout");
286 	if(i != pgin || o != pgout){
287 		pgin = i;
288 		pgout = o;
289 		kvm_getswapinfo(kvm, &s, 1, 0);
290 	}
291 
292 
293 	Bprint(&bout, "swap =%lld %lld\n", s.ksw_used*(vlong)pgsize, s.ksw_total*(vlong)pgsize);
294 }
295