1 /* 2 * BUFQUEUES.C 3 * 4 * cc -I/usr/src/sys bufqueues.c -o /usr/local/bin/bufqueues -lkvm 5 * 6 * bufqueues 7 * 8 * Output buf(9) queues usages 9 * 10 * Copyright (c) 2015 The DragonFly Project. All rights reserved. 11 * 12 * This code is derived from software contributed to The DragonFly Project 13 * by Matthew Dillon <dillon@backplane.com> 14 * by Antonio Huete Jimenez <tuxillo@quantumachine.net> 15 * 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions 18 * are met: 19 * 20 * 1. Redistributions of source code must retain the above copyright 21 * notice, this list of conditions and the following disclaimer. 22 * 2. Redistributions in binary form must reproduce the above copyright 23 * notice, this list of conditions and the following disclaimer in 24 * the documentation and/or other materials provided with the 25 * distribution. 26 * 3. Neither the name of The DragonFly Project nor the names of its 27 * contributors may be used to endorse or promote products derived 28 * from this software without specific, prior written permission. 29 * 30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 31 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 32 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 33 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 34 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 35 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 36 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 37 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 38 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 39 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 40 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 41 * SUCH DAMAGE. 42 */ 43 44 #define _KERNEL_STRUCTURES_ 45 #include <sys/param.h> 46 #include <sys/user.h> 47 #include <sys/buf.h> 48 #include <sys/bio.h> 49 #include <sys/queue.h> 50 51 #include <stdio.h> 52 #include <stdlib.h> 53 #include <string.h> 54 #include <stddef.h> 55 #include <fcntl.h> 56 #include <kvm.h> 57 #include <nlist.h> 58 #include <getopt.h> 59 #include <math.h> 60 61 struct nlist Nl[] = { 62 { "_bufpcpu" }, 63 { "_ncpus" }, 64 { "_nbuf" }, 65 { NULL } 66 }; 67 68 TAILQ_HEAD(bqueues, buf); 69 70 /* 71 * Buffer queues. 72 */ 73 enum bufq_type { 74 BQUEUE_NONE, /* not on any queue */ 75 BQUEUE_LOCKED, /* locked buffers */ 76 BQUEUE_CLEAN, /* non-B_DELWRI buffers */ 77 BQUEUE_DIRTY, /* B_DELWRI buffers */ 78 BQUEUE_DIRTY_HW, /* B_DELWRI buffers - heavy weight */ 79 BQUEUE_EMPTYKVA, /* empty buffer headers with KVA assignment */ 80 BQUEUE_EMPTY, /* empty buffer headers */ 81 82 BUFFER_QUEUES /* number of buffer queues */ 83 }; 84 85 struct bufpcpu { 86 struct spinlock spin; 87 struct bqueues bufqueues[BUFFER_QUEUES]; 88 } __cachealign; 89 90 int verboseopt; 91 92 static int kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes, int out); 93 static void scan_queues(kvm_t *kd, int cpu, struct bufpcpu *bqp); 94 static void loaddelay(struct timespec *ts, const char *arg); 95 96 static const char *q2s(int queue); 97 98 /* Globals */ 99 int qcounter[BUFFER_QUEUES]; 100 int failcount; 101 int totalcount; 102 int nbuf; 103 104 int 105 main(int ac, char **av) 106 { 107 const char *corefile = NULL; 108 const char *sysfile = NULL; 109 struct bufpcpu bpcpu; 110 struct timespec delay = { 1, 0 }; 111 kvm_t *kd; 112 int count; 113 int ncpus; 114 int ch; 115 int cpu; 116 117 while ((ch = getopt(ac, av, "M:N:v")) != -1) { 118 switch(ch) { 119 case 'v': 120 ++verboseopt; 121 break; 122 case 'M': 123 corefile = optarg; 124 break; 125 case 'N': 126 sysfile = optarg; 127 break; 128 default: 129 fprintf(stderr, "%s [-M core] [-N system]\n", av[0]); 130 exit(1); 131 } 132 } 133 ac -= optind; 134 av += optind; 135 136 if ((kd = kvm_open(sysfile, corefile, NULL, O_RDONLY, "kvm:")) == NULL) { 137 perror("kvm_open"); 138 exit(1); 139 } 140 if (kvm_nlist(kd, Nl) != 0) { 141 perror("kvm_nlist"); 142 exit(1); 143 } 144 145 if (ac > 0) 146 loaddelay(&delay, av[0]); 147 148 kkread(kd, Nl[1].n_value, &ncpus, sizeof(ncpus), 1); 149 kkread(kd, Nl[2].n_value, &nbuf, sizeof(nbuf), 1); 150 151 for (count = 0; ; ++count) { 152 for (cpu = 0; cpu < ncpus; cpu++) { 153 kkread(kd, Nl[0].n_value + cpu * sizeof(struct bufpcpu), 154 &bpcpu, sizeof(struct bufpcpu), 1); 155 scan_queues(kd, cpu, &bpcpu); 156 } 157 158 if (count && !verboseopt) { 159 if ((count & 15) == 1) 160 printf(" NONE LOCKED CLEAN DIRTY " 161 "DIRTY_HW EMPTYKVA EMPTY OFF-QUEUE KVMFAIL\n"); 162 printf("%6d %7d %6d %6d %9d %9d %6d %10d %7d\n", 163 qcounter[0], qcounter[1], qcounter[2], 164 qcounter[3], qcounter[4], qcounter[5], 165 qcounter[6], (nbuf - totalcount), failcount); 166 } 167 168 /* If in verbose mode only output detailed bufs info once */ 169 if (verboseopt) 170 break; 171 nanosleep(&delay, NULL); 172 bzero(&qcounter, sizeof(qcounter)); 173 totalcount = 0; 174 failcount = 0; 175 } 176 return(0); 177 } 178 179 static const char *q2s(int queue) 180 { 181 switch(queue) { 182 case BQUEUE_NONE: 183 return "NONE"; 184 case BQUEUE_LOCKED: 185 return "LOCKED"; 186 case BQUEUE_CLEAN: 187 return "CLEAN"; 188 case BQUEUE_DIRTY: 189 return "DIRTY"; 190 case BQUEUE_DIRTY_HW: 191 return "DIRTY_HW"; 192 case BQUEUE_EMPTYKVA: 193 return "EMPTYKVA"; 194 case BQUEUE_EMPTY: 195 return "EMPTY"; 196 default: 197 return "INVALID"; 198 } 199 } 200 201 void 202 scan_queues(kvm_t *kd, int cpu, struct bufpcpu *bqp) 203 { 204 struct buf b, *tmp; 205 int q; 206 207 for (q = 0; q < BUFFER_QUEUES; q++) { 208 if (bqp->bufqueues[q].tqh_first == NULL) 209 continue; 210 kkread(kd, (u_long)bqp->bufqueues[q].tqh_first, &b, sizeof(b), 1); 211 tmp = bqp->bufqueues[q].tqh_first; 212 if (tmp != NULL) 213 qcounter[q]++; 214 while (tmp != NULL) { 215 if (verboseopt) 216 printf("cpu=%d queue=%8s buf=%p", cpu, q2s(q), tmp); 217 tmp = b.b_freelist.tqe_next; 218 if (kkread(kd, (u_long)tmp, &b, sizeof(b), 0) == -1) { 219 if (verboseopt) 220 printf(" [F] "); 221 failcount++; 222 } 223 if (verboseopt) 224 printf("\n"); 225 qcounter[q]++; 226 totalcount++; /* All scanned bufs */ 227 } 228 } 229 } 230 231 /* 232 * Convert a delay string (e.g. "0.1") into a timespec. 233 */ 234 static 235 void 236 loaddelay(struct timespec *ts, const char *arg) 237 { 238 double d; 239 240 d = strtod(arg, NULL); 241 if (d < 0.001) 242 d = 0.001; 243 ts->tv_sec = (int)d; 244 ts->tv_nsec = (int)(modf(d, &d) * 1000000000.0); 245 } 246 247 static int 248 kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes, int out) 249 { 250 if (kvm_read(kd, addr, buf, nbytes) != nbytes) { 251 if (out) { 252 perror("kvm_read"); 253 exit(1); 254 } 255 return -1; 256 } 257 return 0; 258 } 259