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