1 /* 2 * Copyright (c) 2008 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@backplane.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * $DragonFly: src/sbin/hammer/cmd_stats.c,v 1.3 2008/07/14 20:28:07 dillon Exp $ 35 */ 36 37 #include <math.h> 38 39 #include "hammer.h" 40 41 static void loaddelay(struct timespec *ts, const char *arg); 42 43 #define bstats_title \ 44 " elements iterations lookups inserts deletes splits" 45 #define iostats_title \ 46 " file-rd file-wr dev-read dev-write ino_rops ino_wops ino_flush commit undo" 47 48 static __inline 49 void 50 print_bstats(const struct libhammer_btree_stats *p1, 51 const struct libhammer_btree_stats *p2) 52 { 53 printf("%10jd %10jd %10jd %10jd %10jd %10jd", 54 (intmax_t)(p1->elements - p2->elements), 55 (intmax_t)(p1->iterations - p2->iterations), 56 (intmax_t)(p1->lookups - p2->lookups), 57 (intmax_t)(p1->inserts - p2->inserts), 58 (intmax_t)(p1->deletes - p2->deletes), 59 (intmax_t)(p1->splits - p2->splits)); 60 /* no trailing \n */ 61 } 62 63 static __inline 64 void 65 print_iostats(const struct libhammer_io_stats *p1, 66 const struct libhammer_io_stats *p2) 67 { 68 printf("%9jd %9jd %9jd %9jd %9jd %9jd %9jd %9jd %9jd", 69 (intmax_t)(p1->file_reads - p2->file_reads), 70 (intmax_t)(p1->file_writes - p2->file_writes), 71 (intmax_t)(p1->dev_reads - p2->dev_reads), 72 (intmax_t)(p1->dev_writes - p2->dev_writes), 73 (intmax_t)(p1->file_iop_reads - p2->file_iop_reads), 74 (intmax_t)(p1->file_iop_writes - p2->file_iop_writes), 75 (intmax_t)(p1->inode_flushes - p2->inode_flushes), 76 (intmax_t)(p1->commits - p2->commits), 77 (intmax_t)(p1->undo - p2->undo)); 78 /* no trailing \n */ 79 } 80 81 void 82 hammer_cmd_bstats(char **av, int ac) 83 { 84 struct libhammer_btree_stats bs, bsc; 85 struct timespec delay = { 1, 0 }; 86 int count; 87 88 if (ac > 0) 89 loaddelay(&delay, av[0]); 90 91 bzero(&bsc, sizeof(bsc)); 92 for (count = 0; ; ++count) { 93 if (libhammer_btree_stats(&bs) < 0) 94 err(1, "Failed to get information from HAMMER sysctls"); 95 if (count) { 96 if ((count & 15) == 1) 97 printf(bstats_title"\n"); 98 print_bstats(&bs, &bsc); 99 printf("\n"); 100 } 101 bcopy(&bs, &bsc, sizeof(bs)); 102 nanosleep(&delay, NULL); 103 } 104 } 105 106 void 107 hammer_cmd_iostats(char **av, int ac) 108 { 109 struct libhammer_io_stats ios, iosc; 110 struct timespec delay = { 1, 0 }; 111 int count; 112 113 if (ac > 0) 114 loaddelay(&delay, av[0]); 115 116 bzero(&iosc, sizeof(iosc)); 117 for (count = 0; ; ++count) { 118 if (libhammer_io_stats(&ios) < 0) 119 err(1, "Failed to get information from HAMMER sysctls"); 120 if (count) { 121 if ((count & 15) == 1) 122 printf(iostats_title"\n"); 123 print_iostats(&ios, &iosc); 124 printf("\n"); 125 } 126 nanosleep(&delay, NULL); 127 bcopy(&ios, &iosc, sizeof(ios)); 128 } 129 } 130 131 void 132 hammer_cmd_stats(char **av, int ac) 133 { 134 struct libhammer_btree_stats bs, bsc; 135 struct libhammer_io_stats ios, iosc; 136 struct timespec delay = { 1, 0 }; 137 int count; 138 139 if (ac > 0) 140 loaddelay(&delay, av[0]); 141 142 bzero(&bsc, sizeof(bsc)); 143 bzero(&iosc, sizeof(iosc)); 144 145 for (count = 0; ; ++count) { 146 if (libhammer_btree_stats(&bs) || libhammer_io_stats(&ios)) 147 err(1, "Failed to get information from HAMMER sysctls"); 148 if (count) { 149 if ((count & 15) == 1) { 150 printf(bstats_title"\t"iostats_title"\n"); 151 } 152 print_bstats(&bs, &bsc); 153 printf("\t"); 154 print_iostats(&ios, &iosc); 155 printf("\n"); 156 } 157 bcopy(&bs, &bsc, sizeof(bs)); 158 bcopy(&ios, &iosc, sizeof(ios)); 159 nanosleep(&delay, NULL); 160 } 161 } 162 163 /* 164 * Convert a delay string (e.g. "0.1") into a timespec. 165 */ 166 static 167 void 168 loaddelay(struct timespec *ts, const char *arg) 169 { 170 double d; 171 172 d = strtod(arg, NULL); 173 if (d < 0.001) 174 d = 0.001; 175 ts->tv_sec = (int)d; 176 ts->tv_nsec = (int)(modf(d, &d) * 1000000000.0); 177 } 178