1 /* $NetBSD: bufcache.c,v 1.22 2008/04/28 20:24:15 martin 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.22 2008/04/28 20:24:15 martin 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 nlist namelist[] = { 78 #define X_BUFMEM 0 79 { .n_name = "_bufmem" }, 80 { .n_name = NULL }, 81 }; 82 83 static struct vcache vcache[VCACHE_SIZE]; 84 static LIST_HEAD(mount_list, ml_entry) mount_list; 85 86 static u_long bufmem; 87 static u_int nbuf, pgwidth, kbwidth; 88 static struct uvmexp_sysctl uvmexp; 89 90 static void vc_init(void); 91 static void ml_init(void); 92 static struct vnode *vc_lookup(struct vnode *); 93 static struct mount *ml_lookup(struct mount *, int, int); 94 static void fetchuvmexp(void); 95 96 97 WINDOW * 98 openbufcache(void) 99 { 100 101 return (subwin(stdscr, -1, 0, 5, 0)); 102 } 103 104 void 105 closebufcache(WINDOW *w) 106 { 107 108 if (w == NULL) 109 return; 110 wclear(w); 111 wrefresh(w); 112 delwin(w); 113 ml_init(); /* Clear out mount list */ 114 } 115 116 void 117 labelbufcache(void) 118 { 119 int i; 120 121 for (i = 0; i <= PAGEINFO_ROWS; i++) { 122 wmove(wnd, i, 0); 123 wclrtoeol(wnd); 124 } 125 mvwaddstr(wnd, PAGEINFO_ROWS + 1, 0, "File System Bufs used" 126 " % kB in use % Bufsize kB % Util %"); 127 wclrtoeol(wnd); 128 } 129 130 void 131 showbufcache(void) 132 { 133 int tbuf, i, lastrow; 134 double tvalid, tsize; 135 struct ml_entry *ml; 136 137 NREAD(X_BUFMEM, &bufmem, sizeof(bufmem)); 138 139 mvwprintw(wnd, 0, 0, 140 " %*d metadata buffers using %*ld kBytes of " 141 "memory (%2.0f%%).", 142 pgwidth, nbuf, kbwidth, bufmem / 1024, 143 ((bufmem * 100.0) + 0.5) / getpagesize() / uvmexp.npages); 144 wclrtoeol(wnd); 145 mvwprintw(wnd, 1, 0, 146 " %*" PRIu64 " pages for cached file data using %*" 147 PRIu64 " kBytes of memory (%2.0f%%).", 148 pgwidth, uvmexp.filepages, 149 kbwidth, uvmexp.filepages * getpagesize() / 1024, 150 (uvmexp.filepages * 100 + 0.5) / uvmexp.npages); 151 wclrtoeol(wnd); 152 mvwprintw(wnd, 2, 0, 153 " %*" PRIu64 " pages for executables using %*" 154 PRIu64 " kBytes of memory (%2.0f%%).", 155 pgwidth, uvmexp.execpages, 156 kbwidth, uvmexp.execpages * getpagesize() / 1024, 157 (uvmexp.execpages * 100 + 0.5) / uvmexp.npages); 158 wclrtoeol(wnd); 159 mvwprintw(wnd, 3, 0, 160 " %*" PRIu64 " pages for anon (non-file) data %*" 161 PRIu64 " kBytes of memory (%2.0f%%).", 162 pgwidth, uvmexp.anonpages, 163 kbwidth, uvmexp.anonpages * getpagesize() / 1024, 164 (uvmexp.anonpages * 100 + 0.5) / uvmexp.npages); 165 wclrtoeol(wnd); 166 mvwprintw(wnd, 4, 0, 167 " %*" PRIu64 " free pages %*" 168 PRIu64 " kBytes of memory (%2.0f%%).", 169 pgwidth, uvmexp.free, 170 kbwidth, uvmexp.free * getpagesize() / 1024, 171 (uvmexp.free * 100 + 0.5) / uvmexp.npages); 172 wclrtoeol(wnd); 173 174 if (nbuf == 0 || bufmem == 0) { 175 wclrtobot(wnd); 176 return; 177 } 178 179 tbuf = 0; 180 tvalid = tsize = 0; 181 lastrow = PAGEINFO_ROWS + 2; /* Leave room for header. */ 182 for (i = lastrow, ml = LIST_FIRST(&mount_list); ml != NULL; 183 i++, ml = LIST_NEXT(ml, ml_entries)) { 184 185 int cnt = ml->ml_count; 186 double v = ml->ml_valid; 187 double s = ml->ml_size; 188 189 /* Display in window if enough room. */ 190 if (i < getmaxy(wnd) - 2) { 191 mvwprintw(wnd, i, 0, "%-20.20s", ml->ml_addr == NULL ? 192 "NULL" : ml->ml_mount.mnt_stat.f_mntonname); 193 wprintw(wnd, 194 " %6d %3d %8ld %3.0f %8ld %3.0f %3.0f", 195 cnt, (100 * cnt) / nbuf, 196 (long)(v/1024), 100 * v / bufmem, 197 (long)(s/1024), 100 * s / bufmem, 198 100 * v / s); 199 wclrtoeol(wnd); 200 lastrow = i; 201 } 202 203 /* Update statistics. */ 204 tbuf += cnt; 205 tvalid += v; 206 tsize += s; 207 } 208 209 wclrtobot(wnd); 210 mvwprintw(wnd, lastrow + 2, 0, 211 "%-20s %6d %3d %8ld %3.0f %8ld %3.0f %3.0f", 212 "Total:", tbuf, (100 * tbuf) / nbuf, 213 (long)(tvalid/1024), 100 * tvalid / bufmem, 214 (long)(tsize/1024), 100 * tsize / bufmem, 215 tsize != 0 ? ((100 * tvalid) / tsize) : 0); 216 } 217 218 int 219 initbufcache(void) 220 { 221 if (namelist[0].n_type == 0) { 222 if (kvm_nlist(kd, namelist)) { 223 nlisterr(namelist); 224 return(0); 225 } 226 } 227 228 fetchuvmexp(); 229 pgwidth = (int)(floor(log10((double)uvmexp.npages)) + 1); 230 kbwidth = (int)(floor(log10(uvmexp.npages * getpagesize() / 1024.0)) + 231 1); 232 233 return(1); 234 } 235 236 static void 237 fetchuvmexp(void) 238 { 239 int mib[2]; 240 size_t size; 241 242 /* Re-read pages used for vnodes & executables */ 243 size = sizeof(uvmexp); 244 mib[0] = CTL_VM; 245 mib[1] = VM_UVMEXP2; 246 if (sysctl(mib, 2, &uvmexp, &size, NULL, 0) < 0) { 247 error("can't get uvmexp: %s\n", strerror(errno)); 248 memset(&uvmexp, 0, sizeof(uvmexp)); 249 } 250 } 251 252 void 253 fetchbufcache(void) 254 { 255 int count; 256 struct buf_sysctl *bp, *buffers; 257 struct vnode *vn; 258 struct mount *mt; 259 struct ml_entry *ml; 260 int mib[6]; 261 size_t size; 262 int extraslop = 0; 263 264 /* Re-read pages used for vnodes & executables */ 265 fetchuvmexp(); 266 267 /* Initialise vnode cache and mount list. */ 268 vc_init(); 269 ml_init(); 270 271 /* Get metadata buffers */ 272 size = 0; 273 buffers = NULL; 274 mib[0] = CTL_KERN; 275 mib[1] = KERN_BUF; 276 mib[2] = KERN_BUF_ALL; 277 mib[3] = KERN_BUF_ALL; 278 mib[4] = (int)sizeof(struct buf_sysctl); 279 mib[5] = INT_MAX; /* we want them all */ 280 again: 281 if (sysctl(mib, 6, NULL, &size, NULL, 0) < 0) { 282 error("can't get buffers size: %s\n", strerror(errno)); 283 return; 284 } 285 if (size == 0) 286 return; 287 288 size += extraslop * sizeof(struct buf_sysctl); 289 buffers = malloc(size); 290 if (buffers == NULL) { 291 error("can't allocate buffers: %s\n", strerror(errno)); 292 return; 293 } 294 if (sysctl(mib, 6, buffers, &size, NULL, 0) < 0) { 295 free(buffers); 296 if (extraslop == 0) { 297 extraslop = 100; 298 goto again; 299 } 300 error("can't get buffers: %s\n", strerror(errno)); 301 return; 302 } 303 304 nbuf = size / sizeof(struct buf_sysctl); 305 for (bp = buffers; bp < buffers + nbuf; bp++) { 306 if (UINT64TOPTR(bp->b_vp) != NULL) { 307 struct mount *mp; 308 vn = vc_lookup(UINT64TOPTR(bp->b_vp)); 309 if (vn == NULL) 310 break; 311 312 mp = vn->v_mount; 313 /* 314 * References to mounted-on vnodes should be 315 * counted towards the mounted filesystem. 316 */ 317 if (vn->v_type == VBLK && vn->v_specnode != NULL) { 318 specnode_t sn; 319 specdev_t sd; 320 if (!KREAD(vn->v_specnode, &sn, sizeof(sn))) 321 continue; 322 if (!KREAD(sn.sn_dev, &sd, sizeof(sd))) 323 continue; 324 if (sd.sd_mountpoint) 325 mp = sd.sd_mountpoint; 326 } 327 if (mp != NULL) 328 mt = ml_lookup(mp, 329 bp->b_bufsize, 330 bp->b_bcount); 331 } 332 } 333 334 /* simple sort - there's not that many entries */ 335 do { 336 if ((ml = LIST_FIRST(&mount_list)) == NULL || 337 LIST_NEXT(ml, ml_entries) == NULL) 338 break; 339 340 count = 0; 341 for (ml = LIST_FIRST(&mount_list); ml != NULL; 342 ml = LIST_NEXT(ml, ml_entries)) { 343 if (LIST_NEXT(ml, ml_entries) == NULL) 344 break; 345 if (ml->ml_count < LIST_NEXT(ml, ml_entries)->ml_count) { 346 ml = LIST_NEXT(ml, ml_entries); 347 LIST_REMOVE(ml, ml_entries); 348 LIST_INSERT_HEAD(&mount_list, ml, ml_entries); 349 count++; 350 } 351 } 352 } while (count != 0); 353 354 free(buffers); 355 } 356 357 static void 358 vc_init(void) 359 { 360 int i; 361 362 /* vc_addr == NULL for unused cache entry. */ 363 for (i = 0; i < VCACHE_SIZE; i++) 364 vcache[i].vc_addr = NULL; 365 } 366 367 static void 368 ml_init(void) 369 { 370 struct ml_entry *ml; 371 372 /* Throw out the current mount list and start again. */ 373 while ((ml = LIST_FIRST(&mount_list)) != NULL) { 374 LIST_REMOVE(ml, ml_entries); 375 free(ml); 376 } 377 } 378 379 380 static struct vnode * 381 vc_lookup(struct vnode *vaddr) 382 { 383 struct vnode *ret; 384 size_t i, oldest; 385 386 ret = NULL; 387 oldest = 0; 388 for (i = 0; i < VCACHE_SIZE; i++) { 389 if (vcache[i].vc_addr == NULL) 390 break; 391 vcache[i].vc_age++; 392 if (vcache[i].vc_age < vcache[oldest].vc_age) 393 oldest = i; 394 if (vcache[i].vc_addr == vaddr) { 395 vcache[i].vc_age = 0; 396 ret = &vcache[i].vc_node; 397 } 398 } 399 400 /* Find an entry in the cache? */ 401 if (ret != NULL) 402 return(ret); 403 404 /* Go past the end of the cache? */ 405 if (i >= VCACHE_SIZE) 406 i = oldest; 407 408 /* Read in new vnode and reset age counter. */ 409 if (KREAD(vaddr, &vcache[i].vc_node, sizeof(struct vnode)) == 0) 410 return NULL; 411 vcache[i].vc_addr = vaddr; 412 vcache[i].vc_age = 0; 413 414 return(&vcache[i].vc_node); 415 } 416 417 static struct mount * 418 ml_lookup(struct mount *maddr, int size, int valid) 419 { 420 struct ml_entry *ml; 421 422 for (ml = LIST_FIRST(&mount_list); ml != NULL; 423 ml = LIST_NEXT(ml, ml_entries)) 424 if (ml->ml_addr == maddr) { 425 ml->ml_count++; 426 ml->ml_size += size; 427 ml->ml_valid += valid; 428 if (ml->ml_addr == NULL) 429 return(NULL); 430 else 431 return(&ml->ml_mount); 432 } 433 434 if ((ml = malloc(sizeof(struct ml_entry))) == NULL) { 435 error("out of memory"); 436 die(0); 437 } 438 LIST_INSERT_HEAD(&mount_list, ml, ml_entries); 439 ml->ml_count = 1; 440 ml->ml_size = size; 441 ml->ml_valid = valid; 442 ml->ml_addr = maddr; 443 if (maddr == NULL) 444 return(NULL); 445 446 KREAD(maddr, &ml->ml_mount, sizeof(struct mount)); 447 return(&ml->ml_mount); 448 } 449