1 /* $NetBSD: bufcache.c,v 1.25 2012/11/23 15:35:57 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 1999 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Simon Burge. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 __RCSID("$NetBSD: bufcache.c,v 1.25 2012/11/23 15:35:57 christos Exp $"); 35 #endif /* not lint */ 36 37 #include <sys/param.h> 38 #include <sys/buf.h> 39 #include <sys/mount.h> 40 #include <sys/sysctl.h> 41 #include <sys/vnode.h> 42 43 #include <uvm/uvm_extern.h> 44 45 #include <err.h> 46 #include <errno.h> 47 #include <inttypes.h> 48 #include <math.h> 49 #include <stdlib.h> 50 #include <string.h> 51 #include <unistd.h> 52 #include <stdbool.h> 53 54 #include <miscfs/specfs/specdev.h> 55 56 #include "systat.h" 57 #include "extern.h" 58 59 #define VCACHE_SIZE 50 60 #define PAGEINFO_ROWS 5 61 62 struct vcache { 63 int vc_age; 64 struct vnode *vc_addr; 65 struct vnode vc_node; 66 }; 67 68 struct ml_entry { 69 u_int ml_count; 70 u_long ml_size; 71 u_long ml_valid; 72 struct mount *ml_addr; 73 LIST_ENTRY(ml_entry) ml_entries; 74 struct mount ml_mount; 75 }; 76 77 static struct vcache vcache[VCACHE_SIZE]; 78 static LIST_HEAD(mount_list, ml_entry) mount_list; 79 80 static uint64_t bufmem; 81 static u_int nbuf, pgwidth, kbwidth; 82 static struct uvmexp_sysctl uvmexp; 83 84 static void vc_init(void); 85 static void ml_init(void); 86 static struct vnode *vc_lookup(struct vnode *); 87 static struct mount *ml_lookup(struct mount *, int, int); 88 static void fetchuvmexp(void); 89 90 91 WINDOW * 92 openbufcache(void) 93 { 94 95 return (subwin(stdscr, -1, 0, 5, 0)); 96 } 97 98 void 99 closebufcache(WINDOW *w) 100 { 101 102 if (w == NULL) 103 return; 104 wclear(w); 105 wrefresh(w); 106 delwin(w); 107 ml_init(); /* Clear out mount list */ 108 } 109 110 void 111 labelbufcache(void) 112 { 113 int i; 114 115 for (i = 0; i <= PAGEINFO_ROWS; i++) { 116 wmove(wnd, i, 0); 117 wclrtoeol(wnd); 118 } 119 mvwaddstr(wnd, PAGEINFO_ROWS + 1, 0, "File System Bufs used" 120 " % kB in use % Bufsize kB % Util %"); 121 wclrtoeol(wnd); 122 } 123 124 void 125 showbufcache(void) 126 { 127 int tbuf, i, lastrow; 128 double tvalid, tsize; 129 struct ml_entry *ml; 130 size_t len; 131 132 len = sizeof(bufmem); 133 if (sysctlbyname("vm.bufmem", &bufmem, &len, NULL, 0)) 134 error("can't get \"vm.bufmmem\": %s", strerror(errno)); 135 136 mvwprintw(wnd, 0, 0, 137 " %*d metadata buffers using %*"PRIu64" kBytes of " 138 "memory (%2.0f%%).", 139 pgwidth, nbuf, kbwidth, bufmem / 1024, 140 ((bufmem * 100.0) + 0.5) / getpagesize() / uvmexp.npages); 141 wclrtoeol(wnd); 142 mvwprintw(wnd, 1, 0, 143 " %*" PRIu64 " pages for cached file data using %*" 144 PRIu64 " kBytes of memory (%2.0f%%).", 145 pgwidth, uvmexp.filepages, 146 kbwidth, uvmexp.filepages * getpagesize() / 1024, 147 (uvmexp.filepages * 100 + 0.5) / uvmexp.npages); 148 wclrtoeol(wnd); 149 mvwprintw(wnd, 2, 0, 150 " %*" PRIu64 " pages for executables using %*" 151 PRIu64 " kBytes of memory (%2.0f%%).", 152 pgwidth, uvmexp.execpages, 153 kbwidth, uvmexp.execpages * getpagesize() / 1024, 154 (uvmexp.execpages * 100 + 0.5) / uvmexp.npages); 155 wclrtoeol(wnd); 156 mvwprintw(wnd, 3, 0, 157 " %*" PRIu64 " pages for anon (non-file) data %*" 158 PRIu64 " kBytes of memory (%2.0f%%).", 159 pgwidth, uvmexp.anonpages, 160 kbwidth, uvmexp.anonpages * getpagesize() / 1024, 161 (uvmexp.anonpages * 100 + 0.5) / uvmexp.npages); 162 wclrtoeol(wnd); 163 mvwprintw(wnd, 4, 0, 164 " %*" PRIu64 " free pages %*" 165 PRIu64 " kBytes of memory (%2.0f%%).", 166 pgwidth, uvmexp.free, 167 kbwidth, uvmexp.free * getpagesize() / 1024, 168 (uvmexp.free * 100 + 0.5) / uvmexp.npages); 169 wclrtoeol(wnd); 170 171 if (nbuf == 0 || bufmem == 0) { 172 wclrtobot(wnd); 173 return; 174 } 175 176 tbuf = 0; 177 tvalid = tsize = 0; 178 lastrow = PAGEINFO_ROWS + 2; /* Leave room for header. */ 179 for (i = lastrow, ml = LIST_FIRST(&mount_list); ml != NULL; 180 i++, ml = LIST_NEXT(ml, ml_entries)) { 181 182 int cnt = ml->ml_count; 183 double v = ml->ml_valid; 184 double s = ml->ml_size; 185 186 /* Display in window if enough room. */ 187 if (i < getmaxy(wnd) - 2) { 188 mvwprintw(wnd, i, 0, "%-20.20s", ml->ml_addr == NULL ? 189 "NULL" : ml->ml_mount.mnt_stat.f_mntonname); 190 wprintw(wnd, 191 " %6d %3d %8ld %3.0f %8ld %3.0f %3.0f", 192 cnt, (100 * cnt) / nbuf, 193 (long)(v/1024), 100 * v / bufmem, 194 (long)(s/1024), 100 * s / bufmem, 195 100 * v / s); 196 wclrtoeol(wnd); 197 lastrow = i; 198 } 199 200 /* Update statistics. */ 201 tbuf += cnt; 202 tvalid += v; 203 tsize += s; 204 } 205 206 wclrtobot(wnd); 207 mvwprintw(wnd, lastrow + 2, 0, 208 "%-20s %6d %3d %8ld %3.0f %8ld %3.0f %3.0f", 209 "Total:", tbuf, (100 * tbuf) / nbuf, 210 (long)(tvalid/1024), 100 * tvalid / bufmem, 211 (long)(tsize/1024), 100 * tsize / bufmem, 212 tsize != 0 ? ((100 * tvalid) / tsize) : 0); 213 } 214 215 int 216 initbufcache(void) 217 { 218 fetchuvmexp(); 219 pgwidth = (int)(floor(log10((double)uvmexp.npages)) + 1); 220 kbwidth = (int)(floor(log10(uvmexp.npages * getpagesize() / 1024.0)) + 221 1); 222 223 return(1); 224 } 225 226 static void 227 fetchuvmexp(void) 228 { 229 int mib[2]; 230 size_t size; 231 232 /* Re-read pages used for vnodes & executables */ 233 size = sizeof(uvmexp); 234 mib[0] = CTL_VM; 235 mib[1] = VM_UVMEXP2; 236 if (sysctl(mib, 2, &uvmexp, &size, NULL, 0) < 0) { 237 error("can't get uvmexp: %s\n", strerror(errno)); 238 memset(&uvmexp, 0, sizeof(uvmexp)); 239 } 240 } 241 242 void 243 fetchbufcache(void) 244 { 245 int count; 246 struct buf_sysctl *bp, *buffers; 247 struct vnode *vn; 248 struct mount *mt; 249 struct ml_entry *ml; 250 int mib[6]; 251 size_t size; 252 int extraslop = 0; 253 254 /* Re-read pages used for vnodes & executables */ 255 fetchuvmexp(); 256 257 /* Initialise vnode cache and mount list. */ 258 vc_init(); 259 ml_init(); 260 261 /* Get metadata buffers */ 262 size = 0; 263 buffers = NULL; 264 mib[0] = CTL_KERN; 265 mib[1] = KERN_BUF; 266 mib[2] = KERN_BUF_ALL; 267 mib[3] = KERN_BUF_ALL; 268 mib[4] = (int)sizeof(struct buf_sysctl); 269 mib[5] = INT_MAX; /* we want them all */ 270 again: 271 if (sysctl(mib, 6, NULL, &size, NULL, 0) < 0) { 272 error("can't get buffers size: %s\n", strerror(errno)); 273 return; 274 } 275 if (size == 0) 276 return; 277 278 size += extraslop * sizeof(struct buf_sysctl); 279 buffers = malloc(size); 280 if (buffers == NULL) { 281 error("can't allocate buffers: %s\n", strerror(errno)); 282 return; 283 } 284 if (sysctl(mib, 6, buffers, &size, NULL, 0) < 0) { 285 free(buffers); 286 if (extraslop == 0) { 287 extraslop = 100; 288 goto again; 289 } 290 error("can't get buffers: %s\n", strerror(errno)); 291 return; 292 } 293 294 nbuf = size / sizeof(struct buf_sysctl); 295 for (bp = buffers; bp < buffers + nbuf; bp++) { 296 if (UINT64TOPTR(bp->b_vp) != NULL) { 297 struct mount *mp; 298 vn = vc_lookup(UINT64TOPTR(bp->b_vp)); 299 if (vn == NULL) 300 break; 301 302 mp = vn->v_mount; 303 /* 304 * References to mounted-on vnodes should be 305 * counted towards the mounted filesystem. 306 */ 307 if (vn->v_type == VBLK && vn->v_specnode != NULL) { 308 specnode_t sn; 309 specdev_t sd; 310 if (!KREAD(vn->v_specnode, &sn, sizeof(sn))) 311 continue; 312 if (!KREAD(sn.sn_dev, &sd, sizeof(sd))) 313 continue; 314 if (sd.sd_mountpoint) 315 mp = sd.sd_mountpoint; 316 } 317 if (mp != NULL) 318 mt = ml_lookup(mp, 319 bp->b_bufsize, 320 bp->b_bcount); 321 } 322 } 323 324 /* simple sort - there's not that many entries */ 325 do { 326 if ((ml = LIST_FIRST(&mount_list)) == NULL || 327 LIST_NEXT(ml, ml_entries) == NULL) 328 break; 329 330 count = 0; 331 for (ml = LIST_FIRST(&mount_list); ml != NULL; 332 ml = LIST_NEXT(ml, ml_entries)) { 333 if (LIST_NEXT(ml, ml_entries) == NULL) 334 break; 335 if (ml->ml_count < LIST_NEXT(ml, ml_entries)->ml_count) { 336 ml = LIST_NEXT(ml, ml_entries); 337 LIST_REMOVE(ml, ml_entries); 338 LIST_INSERT_HEAD(&mount_list, ml, ml_entries); 339 count++; 340 } 341 } 342 } while (count != 0); 343 344 free(buffers); 345 } 346 347 static void 348 vc_init(void) 349 { 350 int i; 351 352 /* vc_addr == NULL for unused cache entry. */ 353 for (i = 0; i < VCACHE_SIZE; i++) 354 vcache[i].vc_addr = NULL; 355 } 356 357 static void 358 ml_init(void) 359 { 360 struct ml_entry *ml; 361 362 /* Throw out the current mount list and start again. */ 363 while ((ml = LIST_FIRST(&mount_list)) != NULL) { 364 LIST_REMOVE(ml, ml_entries); 365 free(ml); 366 } 367 } 368 369 370 static struct vnode * 371 vc_lookup(struct vnode *vaddr) 372 { 373 struct vnode *ret; 374 size_t i, oldest; 375 376 ret = NULL; 377 oldest = 0; 378 for (i = 0; i < VCACHE_SIZE; i++) { 379 if (vcache[i].vc_addr == NULL) 380 break; 381 vcache[i].vc_age++; 382 if (vcache[i].vc_age < vcache[oldest].vc_age) 383 oldest = i; 384 if (vcache[i].vc_addr == vaddr) { 385 vcache[i].vc_age = 0; 386 ret = &vcache[i].vc_node; 387 } 388 } 389 390 /* Find an entry in the cache? */ 391 if (ret != NULL) 392 return(ret); 393 394 /* Go past the end of the cache? */ 395 if (i >= VCACHE_SIZE) 396 i = oldest; 397 398 /* Read in new vnode and reset age counter. */ 399 if (KREAD(vaddr, &vcache[i].vc_node, sizeof(struct vnode)) == 0) 400 return NULL; 401 vcache[i].vc_addr = vaddr; 402 vcache[i].vc_age = 0; 403 404 return(&vcache[i].vc_node); 405 } 406 407 static struct mount * 408 ml_lookup(struct mount *maddr, int size, int valid) 409 { 410 struct ml_entry *ml; 411 412 for (ml = LIST_FIRST(&mount_list); ml != NULL; 413 ml = LIST_NEXT(ml, ml_entries)) 414 if (ml->ml_addr == maddr) { 415 ml->ml_count++; 416 ml->ml_size += size; 417 ml->ml_valid += valid; 418 if (ml->ml_addr == NULL) 419 return(NULL); 420 else 421 return(&ml->ml_mount); 422 } 423 424 if ((ml = malloc(sizeof(struct ml_entry))) == NULL) { 425 error("out of memory"); 426 die(0); 427 } 428 LIST_INSERT_HEAD(&mount_list, ml, ml_entries); 429 ml->ml_count = 1; 430 ml->ml_size = size; 431 ml->ml_valid = valid; 432 ml->ml_addr = maddr; 433 if (maddr == NULL) 434 return(NULL); 435 436 KREAD(maddr, &ml->ml_mount, sizeof(struct mount)); 437 return(&ml->ml_mount); 438 } 439