128fb27baSJustin T. Gibbs /* 228fb27baSJustin T. Gibbs * Copyright (c) 1997, 1998 Kenneth D. Merry. 328fb27baSJustin T. Gibbs * All rights reserved. 428fb27baSJustin T. Gibbs * 528fb27baSJustin T. Gibbs * Redistribution and use in source and binary forms, with or without 628fb27baSJustin T. Gibbs * modification, are permitted provided that the following conditions 728fb27baSJustin T. Gibbs * are met: 828fb27baSJustin T. Gibbs * 1. Redistributions of source code must retain the above copyright 928fb27baSJustin T. Gibbs * notice, this list of conditions and the following disclaimer. 1028fb27baSJustin T. Gibbs * 2. Redistributions in binary form must reproduce the above copyright 1128fb27baSJustin T. Gibbs * notice, this list of conditions and the following disclaimer in the 1228fb27baSJustin T. Gibbs * documentation and/or other materials provided with the distribution. 1328fb27baSJustin T. Gibbs * 3. The name of the author may not be used to endorse or promote products 1428fb27baSJustin T. Gibbs * derived from this software without specific prior written permission. 1528fb27baSJustin T. Gibbs * 1628fb27baSJustin T. Gibbs * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1728fb27baSJustin T. Gibbs * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1828fb27baSJustin T. Gibbs * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1928fb27baSJustin T. Gibbs * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 2028fb27baSJustin T. Gibbs * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2128fb27baSJustin T. Gibbs * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2228fb27baSJustin T. Gibbs * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2328fb27baSJustin T. Gibbs * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2428fb27baSJustin T. Gibbs * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2528fb27baSJustin T. Gibbs * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2628fb27baSJustin T. Gibbs * SUCH DAMAGE. 2728fb27baSJustin T. Gibbs * 28eded794aSKenneth D. Merry * $Id: devstat.c,v 1.1 1998/09/15 06:23:21 gibbs Exp $ 2928fb27baSJustin T. Gibbs */ 3028fb27baSJustin T. Gibbs 3128fb27baSJustin T. Gibbs #include <sys/types.h> 3228fb27baSJustin T. Gibbs #include <sys/sysctl.h> 3328fb27baSJustin T. Gibbs #include <sys/errno.h> 3428fb27baSJustin T. Gibbs #include <sys/dkstat.h> 3528fb27baSJustin T. Gibbs 36eded794aSKenneth D. Merry #include <ctype.h> 3728fb27baSJustin T. Gibbs #include <err.h> 3828fb27baSJustin T. Gibbs #include <stdio.h> 3928fb27baSJustin T. Gibbs #include <stdlib.h> 4028fb27baSJustin T. Gibbs #include <string.h> 4128fb27baSJustin T. Gibbs 4228fb27baSJustin T. Gibbs #include "devstat.h" 4328fb27baSJustin T. Gibbs 4428fb27baSJustin T. Gibbs char devstat_errbuf[DEVSTAT_ERRBUF_SIZE]; 4528fb27baSJustin T. Gibbs 4628fb27baSJustin T. Gibbs /* 4728fb27baSJustin T. Gibbs * Table to match descriptive strings with device types. These are in 4828fb27baSJustin T. Gibbs * order from most common to least common to speed search time. 4928fb27baSJustin T. Gibbs */ 5028fb27baSJustin T. Gibbs struct devstat_match_table match_table[] = { 5128fb27baSJustin T. Gibbs {"da", DEVSTAT_TYPE_DIRECT, DEVSTAT_MATCH_TYPE}, 5228fb27baSJustin T. Gibbs {"cd", DEVSTAT_TYPE_CDROM, DEVSTAT_MATCH_TYPE}, 5328fb27baSJustin T. Gibbs {"scsi", DEVSTAT_TYPE_IF_SCSI, DEVSTAT_MATCH_IF}, 5428fb27baSJustin T. Gibbs {"ide", DEVSTAT_TYPE_IF_IDE, DEVSTAT_MATCH_IF}, 5528fb27baSJustin T. Gibbs {"other", DEVSTAT_TYPE_IF_OTHER, DEVSTAT_MATCH_IF}, 5628fb27baSJustin T. Gibbs {"worm", DEVSTAT_TYPE_WORM, DEVSTAT_MATCH_TYPE}, 5728fb27baSJustin T. Gibbs {"sa", DEVSTAT_TYPE_SEQUENTIAL,DEVSTAT_MATCH_TYPE}, 5828fb27baSJustin T. Gibbs {"pass", DEVSTAT_TYPE_PASS, DEVSTAT_MATCH_PASS}, 5928fb27baSJustin T. Gibbs {"optical", DEVSTAT_TYPE_OPTICAL, DEVSTAT_MATCH_TYPE}, 6028fb27baSJustin T. Gibbs {"array", DEVSTAT_TYPE_STORARRAY, DEVSTAT_MATCH_TYPE}, 6128fb27baSJustin T. Gibbs {"changer", DEVSTAT_TYPE_CHANGER, DEVSTAT_MATCH_TYPE}, 6228fb27baSJustin T. Gibbs {"scanner", DEVSTAT_TYPE_SCANNER, DEVSTAT_MATCH_TYPE}, 6328fb27baSJustin T. Gibbs {"printer", DEVSTAT_TYPE_PRINTER, DEVSTAT_MATCH_TYPE}, 6428fb27baSJustin T. Gibbs {"floppy", DEVSTAT_TYPE_FLOPPY, DEVSTAT_MATCH_TYPE}, 6528fb27baSJustin T. Gibbs {"proc", DEVSTAT_TYPE_PROCESSOR, DEVSTAT_MATCH_TYPE}, 6628fb27baSJustin T. Gibbs {"comm", DEVSTAT_TYPE_COMM, DEVSTAT_MATCH_TYPE}, 6728fb27baSJustin T. Gibbs {"enclosure", DEVSTAT_TYPE_ENCLOSURE, DEVSTAT_MATCH_TYPE}, 6828fb27baSJustin T. Gibbs {NULL, 0, 0} 6928fb27baSJustin T. Gibbs }; 7028fb27baSJustin T. Gibbs 7128fb27baSJustin T. Gibbs /* 7228fb27baSJustin T. Gibbs * Local function declarations. 7328fb27baSJustin T. Gibbs */ 7428fb27baSJustin T. Gibbs static int compare_select(const void *arg1, const void *arg2); 7528fb27baSJustin T. Gibbs 7628fb27baSJustin T. Gibbs int 7728fb27baSJustin T. Gibbs getnumdevs(void) 7828fb27baSJustin T. Gibbs { 7928fb27baSJustin T. Gibbs size_t numdevsize; 8028fb27baSJustin T. Gibbs int numdevs; 8128fb27baSJustin T. Gibbs char *func_name = "getnumdevs"; 8228fb27baSJustin T. Gibbs 8328fb27baSJustin T. Gibbs numdevsize = sizeof(int); 8428fb27baSJustin T. Gibbs 8528fb27baSJustin T. Gibbs /* 8628fb27baSJustin T. Gibbs * Find out how many devices we have in the system. 8728fb27baSJustin T. Gibbs */ 8828fb27baSJustin T. Gibbs if (sysctlbyname("kern.devstat.numdevs", &numdevs, 8928fb27baSJustin T. Gibbs &numdevsize, NULL, 0) == -1) { 9028fb27baSJustin T. Gibbs sprintf(devstat_errbuf, "%s: error getting number of devices\n" 9128fb27baSJustin T. Gibbs "%s: %s", func_name, func_name, strerror(errno)); 9228fb27baSJustin T. Gibbs return(-1); 9328fb27baSJustin T. Gibbs } else 9428fb27baSJustin T. Gibbs return(numdevs); 9528fb27baSJustin T. Gibbs } 9628fb27baSJustin T. Gibbs 9728fb27baSJustin T. Gibbs /* 9828fb27baSJustin T. Gibbs * This is an easy way to get the generation number, but the generation is 9928fb27baSJustin T. Gibbs * supplied in a more atmoic manner by the kern.devstat.all sysctl. 10028fb27baSJustin T. Gibbs * Because this generation sysctl is separate from the statistics sysctl, 10128fb27baSJustin T. Gibbs * the device list and the generation could change between the time that 10228fb27baSJustin T. Gibbs * this function is called and the device list is retreived. 10328fb27baSJustin T. Gibbs */ 10428fb27baSJustin T. Gibbs int 10528fb27baSJustin T. Gibbs getgeneration(void) 10628fb27baSJustin T. Gibbs { 10728fb27baSJustin T. Gibbs size_t gensize; 10828fb27baSJustin T. Gibbs int generation; 10928fb27baSJustin T. Gibbs char *func_name = "getgeneration"; 11028fb27baSJustin T. Gibbs 11128fb27baSJustin T. Gibbs gensize = sizeof(int); 11228fb27baSJustin T. Gibbs 11328fb27baSJustin T. Gibbs /* 11428fb27baSJustin T. Gibbs * Get the current generation number. 11528fb27baSJustin T. Gibbs */ 11628fb27baSJustin T. Gibbs if (sysctlbyname("kern.devstat.generation", &generation, 11728fb27baSJustin T. Gibbs &gensize, NULL, 0) == -1) { 11828fb27baSJustin T. Gibbs sprintf(devstat_errbuf,"%s: error getting devstat generation\n" 11928fb27baSJustin T. Gibbs "%s: %s", func_name, func_name, strerror(errno)); 12028fb27baSJustin T. Gibbs return(-1); 12128fb27baSJustin T. Gibbs } else 12228fb27baSJustin T. Gibbs return(generation); 12328fb27baSJustin T. Gibbs } 12428fb27baSJustin T. Gibbs 12528fb27baSJustin T. Gibbs /* 12628fb27baSJustin T. Gibbs * Get the current devstat version. The return value of this function 12728fb27baSJustin T. Gibbs * should be compared with DEVSTAT_VERSION, which is defined in 12828fb27baSJustin T. Gibbs * sys/devicestat.h. This will enable userland programs to determine 12928fb27baSJustin T. Gibbs * whether they are out of sync with the kernel. 13028fb27baSJustin T. Gibbs */ 13128fb27baSJustin T. Gibbs int 13228fb27baSJustin T. Gibbs getversion(void) 13328fb27baSJustin T. Gibbs { 13428fb27baSJustin T. Gibbs size_t versize; 13528fb27baSJustin T. Gibbs int version; 13628fb27baSJustin T. Gibbs char *func_name = "getversion"; 13728fb27baSJustin T. Gibbs 13828fb27baSJustin T. Gibbs versize = sizeof(int); 13928fb27baSJustin T. Gibbs 14028fb27baSJustin T. Gibbs /* 14128fb27baSJustin T. Gibbs * Get the current devstat version. 14228fb27baSJustin T. Gibbs */ 14328fb27baSJustin T. Gibbs if (sysctlbyname("kern.devstat.version", &version, &versize, 14428fb27baSJustin T. Gibbs NULL, 0) == -1) { 14528fb27baSJustin T. Gibbs sprintf(devstat_errbuf, "%s: error getting devstat version\n" 14628fb27baSJustin T. Gibbs "%s: %s", func_name, func_name, strerror(errno)); 14728fb27baSJustin T. Gibbs return(-1); 14828fb27baSJustin T. Gibbs } else 14928fb27baSJustin T. Gibbs return(version); 15028fb27baSJustin T. Gibbs } 15128fb27baSJustin T. Gibbs 15228fb27baSJustin T. Gibbs /* 15328fb27baSJustin T. Gibbs * Check the devstat version we know about against the devstat version the 15428fb27baSJustin T. Gibbs * kernel knows about. If they don't match, print an error into the 15528fb27baSJustin T. Gibbs * devstat error buffer, and return -1. If they match, return 0. 15628fb27baSJustin T. Gibbs */ 15728fb27baSJustin T. Gibbs int 15828fb27baSJustin T. Gibbs checkversion(void) 15928fb27baSJustin T. Gibbs { 16028fb27baSJustin T. Gibbs int retval = 0; 16128fb27baSJustin T. Gibbs int errlen = 0; 16228fb27baSJustin T. Gibbs char *func_name = "checkversion"; 163eded794aSKenneth D. Merry int version; 16428fb27baSJustin T. Gibbs 165eded794aSKenneth D. Merry version = getversion(); 166eded794aSKenneth D. Merry 167eded794aSKenneth D. Merry if (version != DEVSTAT_VERSION) { 168eded794aSKenneth D. Merry int buflen = 0; 16928fb27baSJustin T. Gibbs char tmpstr[256]; 17028fb27baSJustin T. Gibbs 171eded794aSKenneth D. Merry /* 172eded794aSKenneth D. Merry * This is really pretty silly, but basically the idea is 173eded794aSKenneth D. Merry * that if getversion() returns an error (i.e. -1), then it 174eded794aSKenneth D. Merry * has printed an error message in the buffer. Therefore, 175eded794aSKenneth D. Merry * we need to add a \n to the end of that message before we 176eded794aSKenneth D. Merry * print our own message in the buffer. 177eded794aSKenneth D. Merry */ 178eded794aSKenneth D. Merry if (version == -1) { 179eded794aSKenneth D. Merry buflen = strlen(devstat_errbuf); 180eded794aSKenneth D. Merry errlen = snprintf(tmpstr, sizeof(tmpstr), "\n"); 181eded794aSKenneth D. Merry strncat(devstat_errbuf, tmpstr, 182eded794aSKenneth D. Merry DEVSTAT_ERRBUF_SIZE - buflen - 1); 183eded794aSKenneth D. Merry buflen += errlen; 184eded794aSKenneth D. Merry } 185eded794aSKenneth D. Merry 186eded794aSKenneth D. Merry errlen = snprintf(tmpstr, sizeof(tmpstr), 18728fb27baSJustin T. Gibbs "%s: userland devstat version %d is not " 18828fb27baSJustin T. Gibbs "the same as the kernel\n%s: devstat " 18928fb27baSJustin T. Gibbs "version %d\n", func_name, DEVSTAT_VERSION, 190eded794aSKenneth D. Merry func_name, version); 19128fb27baSJustin T. Gibbs 192eded794aSKenneth D. Merry if (version == -1) { 193eded794aSKenneth D. Merry strncat(devstat_errbuf, tmpstr, 194eded794aSKenneth D. Merry DEVSTAT_ERRBUF_SIZE - buflen - 1); 195eded794aSKenneth D. Merry buflen += errlen; 196eded794aSKenneth D. Merry } else 197eded794aSKenneth D. Merry strncpy(devstat_errbuf, tmpstr, DEVSTAT_ERRBUF_SIZE); 198eded794aSKenneth D. Merry 199eded794aSKenneth D. Merry if (version < DEVSTAT_VERSION) 20028fb27baSJustin T. Gibbs snprintf(tmpstr, sizeof(tmpstr), 20128fb27baSJustin T. Gibbs "%s: you really should know better" 20228fb27baSJustin T. Gibbs " than to upgrade your\n%s: " 20328fb27baSJustin T. Gibbs "userland binaries without " 204eded794aSKenneth D. Merry "upgrading your kernel", 20528fb27baSJustin T. Gibbs func_name, func_name); 20628fb27baSJustin T. Gibbs else 20728fb27baSJustin T. Gibbs snprintf(tmpstr, sizeof(tmpstr), 20828fb27baSJustin T. Gibbs "%s: you really should know better" 20928fb27baSJustin T. Gibbs " than to upgrade your kernel " 21028fb27baSJustin T. Gibbs "without\n%s: upgrading your " 211eded794aSKenneth D. Merry "userland binaries", 21228fb27baSJustin T. Gibbs func_name, func_name); 21328fb27baSJustin T. Gibbs 21428fb27baSJustin T. Gibbs strncat(devstat_errbuf, tmpstr, 215eded794aSKenneth D. Merry DEVSTAT_ERRBUF_SIZE - buflen - 1); 21628fb27baSJustin T. Gibbs 21728fb27baSJustin T. Gibbs retval = -1; 21828fb27baSJustin T. Gibbs } 21928fb27baSJustin T. Gibbs 22028fb27baSJustin T. Gibbs return(retval); 22128fb27baSJustin T. Gibbs } 22228fb27baSJustin T. Gibbs 22328fb27baSJustin T. Gibbs /* 22428fb27baSJustin T. Gibbs * Get the current list of devices and statistics, and the current 22528fb27baSJustin T. Gibbs * generation number. 22628fb27baSJustin T. Gibbs * 22728fb27baSJustin T. Gibbs * Return values: 22828fb27baSJustin T. Gibbs * -1 -- error 22928fb27baSJustin T. Gibbs * 0 -- device list is unchanged 23028fb27baSJustin T. Gibbs * 1 -- device list has changed 23128fb27baSJustin T. Gibbs */ 23228fb27baSJustin T. Gibbs int 23328fb27baSJustin T. Gibbs getdevs(struct statinfo *stats) 23428fb27baSJustin T. Gibbs { 23528fb27baSJustin T. Gibbs int error; 23628fb27baSJustin T. Gibbs size_t dssize; 23728fb27baSJustin T. Gibbs int oldnumdevs, oldgeneration; 23828fb27baSJustin T. Gibbs int retval = 0; 23928fb27baSJustin T. Gibbs struct devinfo *dinfo; 24028fb27baSJustin T. Gibbs char *func_name = "getdevs"; 24128fb27baSJustin T. Gibbs 24228fb27baSJustin T. Gibbs dinfo = stats->dinfo; 24328fb27baSJustin T. Gibbs 24428fb27baSJustin T. Gibbs if (dinfo == NULL) { 24528fb27baSJustin T. Gibbs sprintf(devstat_errbuf, "%s: stats->dinfo was NULL", func_name); 24628fb27baSJustin T. Gibbs return(-1); 24728fb27baSJustin T. Gibbs } 24828fb27baSJustin T. Gibbs 24928fb27baSJustin T. Gibbs oldnumdevs = dinfo->numdevs; 25028fb27baSJustin T. Gibbs oldgeneration = dinfo->generation; 25128fb27baSJustin T. Gibbs 25228fb27baSJustin T. Gibbs /* 25328fb27baSJustin T. Gibbs * If this is our first time through, mem_ptr will be null. 25428fb27baSJustin T. Gibbs */ 25528fb27baSJustin T. Gibbs if (dinfo->mem_ptr == NULL) { 25628fb27baSJustin T. Gibbs /* 25728fb27baSJustin T. Gibbs * Get the number of devices. If it's negative, it's an 25828fb27baSJustin T. Gibbs * error. Don't bother setting the error string, since 25928fb27baSJustin T. Gibbs * getnumdevs() has already done that for us. 26028fb27baSJustin T. Gibbs */ 26128fb27baSJustin T. Gibbs if ((dinfo->numdevs = getnumdevs()) < 0) 26228fb27baSJustin T. Gibbs return(-1); 26328fb27baSJustin T. Gibbs 26428fb27baSJustin T. Gibbs /* 26528fb27baSJustin T. Gibbs * The kern.devstat.all sysctl returns the current generation 26628fb27baSJustin T. Gibbs * number, as well as all the devices. So we need four 26728fb27baSJustin T. Gibbs * bytes more. 26828fb27baSJustin T. Gibbs */ 26928fb27baSJustin T. Gibbs dssize =(dinfo->numdevs * sizeof(struct devstat)) + sizeof(int); 27028fb27baSJustin T. Gibbs dinfo->mem_ptr = (u_int8_t *)malloc(dssize); 27128fb27baSJustin T. Gibbs } else 27228fb27baSJustin T. Gibbs dssize =(dinfo->numdevs * sizeof(struct devstat)) + sizeof(int); 27328fb27baSJustin T. Gibbs 27428fb27baSJustin T. Gibbs /* Get the current time when we get the stats */ 27528fb27baSJustin T. Gibbs gettimeofday(&stats->busy_time, NULL); 27628fb27baSJustin T. Gibbs 27728fb27baSJustin T. Gibbs /* 27828fb27baSJustin T. Gibbs * Request all of the devices. We only really allow for one 27928fb27baSJustin T. Gibbs * ENOMEM failure. It would, of course, be possible to just go in 28028fb27baSJustin T. Gibbs * a loop and keep reallocing the device structure until we don't 28128fb27baSJustin T. Gibbs * get ENOMEM back. I'm not sure it's worth it, though. If 28228fb27baSJustin T. Gibbs * devices are being added to the system that quickly, maybe the 28328fb27baSJustin T. Gibbs * user can just wait until all devices are added. 28428fb27baSJustin T. Gibbs */ 28528fb27baSJustin T. Gibbs if ((error = sysctlbyname("kern.devstat.all", dinfo->mem_ptr, 28628fb27baSJustin T. Gibbs &dssize, NULL, 0)) == -1) { 28728fb27baSJustin T. Gibbs /* 28828fb27baSJustin T. Gibbs * If we get ENOMEM back, that means that there are 28928fb27baSJustin T. Gibbs * more devices now, so we need to allocate more 29028fb27baSJustin T. Gibbs * space for the device array. 29128fb27baSJustin T. Gibbs */ 29228fb27baSJustin T. Gibbs if (errno == ENOMEM) { 29328fb27baSJustin T. Gibbs /* 29428fb27baSJustin T. Gibbs * No need to set the error string here, getnumdevs() 29528fb27baSJustin T. Gibbs * will do that if it fails. 29628fb27baSJustin T. Gibbs */ 29728fb27baSJustin T. Gibbs if ((dinfo->numdevs = getnumdevs()) < 0) 29828fb27baSJustin T. Gibbs return(-1); 29928fb27baSJustin T. Gibbs 30028fb27baSJustin T. Gibbs dssize = (dinfo->numdevs * sizeof(struct devstat)) + 30128fb27baSJustin T. Gibbs sizeof(int); 30228fb27baSJustin T. Gibbs dinfo->mem_ptr = (u_int8_t *)realloc(dinfo->mem_ptr, 30328fb27baSJustin T. Gibbs dssize); 30428fb27baSJustin T. Gibbs if ((error = sysctlbyname("kern.devstat.all", 30528fb27baSJustin T. Gibbs dinfo->mem_ptr, &dssize, NULL, 0)) == -1) { 30628fb27baSJustin T. Gibbs sprintf(devstat_errbuf, 30728fb27baSJustin T. Gibbs "%s: error getting device stats\n" 30828fb27baSJustin T. Gibbs "%s: %s", func_name, func_name, 30928fb27baSJustin T. Gibbs strerror(errno)); 31028fb27baSJustin T. Gibbs return(-1); 31128fb27baSJustin T. Gibbs } 31228fb27baSJustin T. Gibbs } else { 31328fb27baSJustin T. Gibbs sprintf(devstat_errbuf, 31428fb27baSJustin T. Gibbs "%s: error getting device stats\n" 31528fb27baSJustin T. Gibbs "%s: %s", func_name, func_name, 31628fb27baSJustin T. Gibbs strerror(errno)); 31728fb27baSJustin T. Gibbs return(-1); 31828fb27baSJustin T. Gibbs } 31928fb27baSJustin T. Gibbs } 32028fb27baSJustin T. Gibbs 32128fb27baSJustin T. Gibbs /* 32228fb27baSJustin T. Gibbs * The sysctl spits out the generation as the first four bytes, 32328fb27baSJustin T. Gibbs * then all of the device statistics structures. 32428fb27baSJustin T. Gibbs */ 32528fb27baSJustin T. Gibbs dinfo->generation = *(int *)dinfo->mem_ptr; 32628fb27baSJustin T. Gibbs 32728fb27baSJustin T. Gibbs /* 32828fb27baSJustin T. Gibbs * If the generation has changed, and if the current number of 32928fb27baSJustin T. Gibbs * devices is not the same as the number of devices recorded in the 33028fb27baSJustin T. Gibbs * devinfo structure, it is likely that the device list has shrunk. 33128fb27baSJustin T. Gibbs * The reason that it is likely that the device list has shrunk in 33228fb27baSJustin T. Gibbs * this case is that if the device list has grown, the sysctl above 33328fb27baSJustin T. Gibbs * will return an ENOMEM error, and we will reset the number of 33428fb27baSJustin T. Gibbs * devices and reallocate the device array. If the second sysctl 33528fb27baSJustin T. Gibbs * fails, we will return an error and therefore never get to this 33628fb27baSJustin T. Gibbs * point. If the device list has shrunk, the sysctl will not 33728fb27baSJustin T. Gibbs * return an error since we have more space allocated than is 33828fb27baSJustin T. Gibbs * necessary. So, in the shrinkage case, we catch it here and 33928fb27baSJustin T. Gibbs * reallocate the array so that we don't use any more space than is 34028fb27baSJustin T. Gibbs * necessary. 34128fb27baSJustin T. Gibbs */ 34228fb27baSJustin T. Gibbs if (oldgeneration != dinfo->generation) { 34328fb27baSJustin T. Gibbs if (getnumdevs() != dinfo->numdevs) { 34428fb27baSJustin T. Gibbs if ((dinfo->numdevs = getnumdevs()) < 0) 34528fb27baSJustin T. Gibbs return(-1); 34628fb27baSJustin T. Gibbs dssize = (dinfo->numdevs * sizeof(struct devstat)) + 34728fb27baSJustin T. Gibbs sizeof(int); 34828fb27baSJustin T. Gibbs dinfo->mem_ptr = (u_int8_t *)realloc(dinfo->mem_ptr, 34928fb27baSJustin T. Gibbs dssize); 35028fb27baSJustin T. Gibbs } 35128fb27baSJustin T. Gibbs retval = 1; 35228fb27baSJustin T. Gibbs } 35328fb27baSJustin T. Gibbs 35428fb27baSJustin T. Gibbs dinfo->devices = (struct devstat *)(dinfo->mem_ptr + sizeof(int)); 35528fb27baSJustin T. Gibbs 35628fb27baSJustin T. Gibbs return(retval); 35728fb27baSJustin T. Gibbs } 35828fb27baSJustin T. Gibbs 35928fb27baSJustin T. Gibbs /* 36028fb27baSJustin T. Gibbs * selectdevs(): 36128fb27baSJustin T. Gibbs * 36228fb27baSJustin T. Gibbs * Devices are selected/deselected based upon the following criteria: 36328fb27baSJustin T. Gibbs * - devices specified by the user on the command line 36428fb27baSJustin T. Gibbs * - devices matching any device type expressions given on the command line 36528fb27baSJustin T. Gibbs * - devices with the highest I/O, if 'top' mode is enabled 36628fb27baSJustin T. Gibbs * - the first n unselected devices in the device list, if maxshowdevs 36728fb27baSJustin T. Gibbs * devices haven't already been selected and if the user has not 36828fb27baSJustin T. Gibbs * specified any devices on the command line and if we're in "add" mode. 36928fb27baSJustin T. Gibbs * 37028fb27baSJustin T. Gibbs * Input parameters: 37128fb27baSJustin T. Gibbs * - device selection list (dev_select) 37228fb27baSJustin T. Gibbs * - current number of devices selected (num_selected) 37328fb27baSJustin T. Gibbs * - total number of devices in the selection list (num_selections) 37428fb27baSJustin T. Gibbs * - devstat generation as of the last time selectdevs() was called 37528fb27baSJustin T. Gibbs * (select_generation) 37628fb27baSJustin T. Gibbs * - current devstat generation (current_generation) 37728fb27baSJustin T. Gibbs * - current list of devices and statistics (devices) 37828fb27baSJustin T. Gibbs * - number of devices in the current device list (numdevs) 37928fb27baSJustin T. Gibbs * - compiled version of the command line device type arguments (matches) 38028fb27baSJustin T. Gibbs * - This is optional. If the number of devices is 0, this will be ignored. 38128fb27baSJustin T. Gibbs * - The matching code pays attention to the current selection mode. So 38228fb27baSJustin T. Gibbs * if you pass in a matching expression, it will be evaluated based 38328fb27baSJustin T. Gibbs * upon the selection mode that is passed in. See below for details. 38428fb27baSJustin T. Gibbs * - number of device type matching expressions (num_matches) 38528fb27baSJustin T. Gibbs * - Set to 0 to disable the matching code. 38628fb27baSJustin T. Gibbs * - list of devices specified on the command line by the user (dev_selections) 38728fb27baSJustin T. Gibbs * - number of devices selected on the command line by the user 38828fb27baSJustin T. Gibbs * (num_dev_selections) 38928fb27baSJustin T. Gibbs * - Our selection mode. There are four different selection modes: 39028fb27baSJustin T. Gibbs * - add mode. (DS_SELECT_ADD) Any devices matching devices explicitly 39128fb27baSJustin T. Gibbs * selected by the user or devices matching a pattern given by the 39228fb27baSJustin T. Gibbs * user will be selected in addition to devices that are already 39328fb27baSJustin T. Gibbs * selected. Additional devices will be selected, up to maxshowdevs 39428fb27baSJustin T. Gibbs * number of devices. 39528fb27baSJustin T. Gibbs * - only mode. (DS_SELECT_ONLY) Only devices matching devices 39628fb27baSJustin T. Gibbs * explicitly given by the user or devices matching a pattern 39728fb27baSJustin T. Gibbs * given by the user will be selected. No other devices will be 39828fb27baSJustin T. Gibbs * selected. 39928fb27baSJustin T. Gibbs * - addonly mode. (DS_SELECT_ADDONLY) This is similar to add and 40028fb27baSJustin T. Gibbs * only. Basically, this will not de-select any devices that are 40128fb27baSJustin T. Gibbs * current selected, as only mode would, but it will also not 40228fb27baSJustin T. Gibbs * gratuitously select up to maxshowdevs devices as add mode would. 40328fb27baSJustin T. Gibbs * - remove mode. (DS_SELECT_REMOVE) Any devices matching devices 40428fb27baSJustin T. Gibbs * explicitly selected by the user or devices matching a pattern 40528fb27baSJustin T. Gibbs * given by the user will be de-selected. 40628fb27baSJustin T. Gibbs * - maximum number of devices we can select (maxshowdevs) 40728fb27baSJustin T. Gibbs * - flag indicating whether or not we're in 'top' mode (perf_select) 40828fb27baSJustin T. Gibbs * 40928fb27baSJustin T. Gibbs * Output data: 41028fb27baSJustin T. Gibbs * - the device selection list may be modified and passed back out 41128fb27baSJustin T. Gibbs * - the number of devices selected and the total number of items in the 41228fb27baSJustin T. Gibbs * device selection list may be changed 41328fb27baSJustin T. Gibbs * - the selection generation may be changed to match the current generation 41428fb27baSJustin T. Gibbs * 41528fb27baSJustin T. Gibbs * Return values: 41628fb27baSJustin T. Gibbs * -1 -- error 41728fb27baSJustin T. Gibbs * 0 -- selected devices are unchanged 41828fb27baSJustin T. Gibbs * 1 -- selected devices changed 41928fb27baSJustin T. Gibbs */ 42028fb27baSJustin T. Gibbs int 42128fb27baSJustin T. Gibbs selectdevs(struct device_selection **dev_select, int *num_selected, 42228fb27baSJustin T. Gibbs int *num_selections, int *select_generation, 42328fb27baSJustin T. Gibbs int current_generation, struct devstat *devices, int numdevs, 42428fb27baSJustin T. Gibbs struct devstat_match *matches, int num_matches, 42528fb27baSJustin T. Gibbs char **dev_selections, int num_dev_selections, 42628fb27baSJustin T. Gibbs devstat_select_mode select_mode, int maxshowdevs, int perf_select) 42728fb27baSJustin T. Gibbs { 42828fb27baSJustin T. Gibbs register int i, j, k; 42928fb27baSJustin T. Gibbs int init_selections = 0, init_selected_var = 0; 43028fb27baSJustin T. Gibbs struct device_selection *old_dev_select = NULL; 43128fb27baSJustin T. Gibbs int old_num_selections = 0, old_num_selected; 43228fb27baSJustin T. Gibbs int selection_number = 0; 43328fb27baSJustin T. Gibbs int changed = 0, found = 0; 43428fb27baSJustin T. Gibbs 43528fb27baSJustin T. Gibbs if ((dev_select == NULL) || (devices == NULL) || (numdevs <= 0)) 43628fb27baSJustin T. Gibbs return(-1); 43728fb27baSJustin T. Gibbs 43828fb27baSJustin T. Gibbs /* 43928fb27baSJustin T. Gibbs * We always want to make sure that we have as many dev_select 44028fb27baSJustin T. Gibbs * entries as there are devices. 44128fb27baSJustin T. Gibbs */ 44228fb27baSJustin T. Gibbs /* 44328fb27baSJustin T. Gibbs * In this case, we haven't selected devices before. 44428fb27baSJustin T. Gibbs */ 44528fb27baSJustin T. Gibbs if (*dev_select == NULL) { 44628fb27baSJustin T. Gibbs *dev_select = (struct device_selection *)malloc(numdevs * 44728fb27baSJustin T. Gibbs sizeof(struct device_selection)); 44828fb27baSJustin T. Gibbs *select_generation = current_generation; 44928fb27baSJustin T. Gibbs init_selections = 1; 45028fb27baSJustin T. Gibbs changed = 1; 45128fb27baSJustin T. Gibbs /* 45228fb27baSJustin T. Gibbs * In this case, we have selected devices before, but the device 45328fb27baSJustin T. Gibbs * list has changed since we last selected devices, so we need to 45428fb27baSJustin T. Gibbs * either enlarge or reduce the size of the device selection list. 45528fb27baSJustin T. Gibbs */ 45628fb27baSJustin T. Gibbs } else if (*num_selections != numdevs) { 45728fb27baSJustin T. Gibbs *dev_select = (struct device_selection *)realloc(*dev_select, 45828fb27baSJustin T. Gibbs numdevs * sizeof(struct device_selection)); 45928fb27baSJustin T. Gibbs *select_generation = current_generation; 46028fb27baSJustin T. Gibbs init_selections = 1; 46128fb27baSJustin T. Gibbs /* 46228fb27baSJustin T. Gibbs * In this case, we've selected devices before, and the selection 46328fb27baSJustin T. Gibbs * list is the same size as it was the last time, but the device 46428fb27baSJustin T. Gibbs * list has changed. 46528fb27baSJustin T. Gibbs */ 46628fb27baSJustin T. Gibbs } else if (*select_generation < current_generation) { 46728fb27baSJustin T. Gibbs *select_generation = current_generation; 46828fb27baSJustin T. Gibbs init_selections = 1; 46928fb27baSJustin T. Gibbs } 47028fb27baSJustin T. Gibbs 47128fb27baSJustin T. Gibbs /* 47228fb27baSJustin T. Gibbs * If we're in "only" mode, we want to clear out the selected 47328fb27baSJustin T. Gibbs * variable since we're going to select exactly what the user wants 47428fb27baSJustin T. Gibbs * this time through. 47528fb27baSJustin T. Gibbs */ 47628fb27baSJustin T. Gibbs if (select_mode == DS_SELECT_ONLY) 47728fb27baSJustin T. Gibbs init_selected_var = 1; 47828fb27baSJustin T. Gibbs 47928fb27baSJustin T. Gibbs /* 48028fb27baSJustin T. Gibbs * In all cases, we want to back up the number of selected devices. 48128fb27baSJustin T. Gibbs * It is a quick and accurate way to determine whether the selected 48228fb27baSJustin T. Gibbs * devices have changed. 48328fb27baSJustin T. Gibbs */ 48428fb27baSJustin T. Gibbs old_num_selected = *num_selected; 48528fb27baSJustin T. Gibbs 48628fb27baSJustin T. Gibbs /* 48728fb27baSJustin T. Gibbs * We want to make a backup of the current selection list if 48828fb27baSJustin T. Gibbs * the list of devices has changed, or if we're in performance 48928fb27baSJustin T. Gibbs * selection mode. In both cases, we don't want to make a backup 49028fb27baSJustin T. Gibbs * if we already know for sure that the list will be different. 49128fb27baSJustin T. Gibbs * This is certainly the case if this is our first time through the 49228fb27baSJustin T. Gibbs * selection code. 49328fb27baSJustin T. Gibbs */ 49428fb27baSJustin T. Gibbs if (((init_selected_var != 0) || (init_selections != 0) 49528fb27baSJustin T. Gibbs || (perf_select != 0)) && (changed == 0)){ 49628fb27baSJustin T. Gibbs old_dev_select = (struct device_selection *)malloc( 49728fb27baSJustin T. Gibbs *num_selections * sizeof(struct device_selection)); 49828fb27baSJustin T. Gibbs old_num_selections = *num_selections; 49928fb27baSJustin T. Gibbs bcopy(*dev_select, old_dev_select, 50028fb27baSJustin T. Gibbs sizeof(struct device_selection) * *num_selections); 50128fb27baSJustin T. Gibbs } 50228fb27baSJustin T. Gibbs 50328fb27baSJustin T. Gibbs if (init_selections != 0) { 50428fb27baSJustin T. Gibbs bzero(*dev_select, sizeof(struct device_selection) * numdevs); 50528fb27baSJustin T. Gibbs 50628fb27baSJustin T. Gibbs for (i = 0; i < numdevs; i++) { 50728fb27baSJustin T. Gibbs (*dev_select)[i].device_number = 50828fb27baSJustin T. Gibbs devices[i].device_number; 50928fb27baSJustin T. Gibbs strncpy((*dev_select)[i].device_name, 51028fb27baSJustin T. Gibbs devices[i].device_name, 51128fb27baSJustin T. Gibbs DEVSTAT_NAME_LEN); 51228fb27baSJustin T. Gibbs (*dev_select)[i].unit_number = devices[i].unit_number; 51328fb27baSJustin T. Gibbs (*dev_select)[i].position = i; 51428fb27baSJustin T. Gibbs } 51528fb27baSJustin T. Gibbs *num_selections = numdevs; 51628fb27baSJustin T. Gibbs } else if (init_selected_var != 0) { 51728fb27baSJustin T. Gibbs for (i = 0; i < numdevs; i++) 51828fb27baSJustin T. Gibbs (*dev_select)[i].selected = 0; 51928fb27baSJustin T. Gibbs } 52028fb27baSJustin T. Gibbs 52128fb27baSJustin T. Gibbs /* we haven't gotten around to selecting anything yet.. */ 52228fb27baSJustin T. Gibbs if ((select_mode == DS_SELECT_ONLY) || (init_selections != 0) 52328fb27baSJustin T. Gibbs || (init_selected_var != 0)) 52428fb27baSJustin T. Gibbs *num_selected = 0; 52528fb27baSJustin T. Gibbs 52628fb27baSJustin T. Gibbs /* 52728fb27baSJustin T. Gibbs * Look through any devices the user specified on the command line 52828fb27baSJustin T. Gibbs * and see if they match known devices. If so, select them. 52928fb27baSJustin T. Gibbs */ 53028fb27baSJustin T. Gibbs for (i = 0; (i < *num_selections) && (num_dev_selections > 0); i++) { 53128fb27baSJustin T. Gibbs char tmpstr[80]; 53228fb27baSJustin T. Gibbs 53328fb27baSJustin T. Gibbs sprintf(tmpstr, "%s%d", (*dev_select)[i].device_name, 53428fb27baSJustin T. Gibbs (*dev_select)[i].unit_number); 53528fb27baSJustin T. Gibbs for (j = 0; j < num_dev_selections; j++) { 53628fb27baSJustin T. Gibbs if (strcmp(tmpstr, dev_selections[j]) == 0) { 53728fb27baSJustin T. Gibbs /* 53828fb27baSJustin T. Gibbs * Here we do different things based on the 53928fb27baSJustin T. Gibbs * mode we're in. If we're in add or 54028fb27baSJustin T. Gibbs * addonly mode, we only select this device 54128fb27baSJustin T. Gibbs * if it hasn't already been selected. 54228fb27baSJustin T. Gibbs * Otherwise, we would be unnecessarily 54328fb27baSJustin T. Gibbs * changing the selection order and 54428fb27baSJustin T. Gibbs * incrementing the selection count. If 54528fb27baSJustin T. Gibbs * we're in only mode, we unconditionally 54628fb27baSJustin T. Gibbs * select this device, since in only mode 54728fb27baSJustin T. Gibbs * any previous selections are erased and 54828fb27baSJustin T. Gibbs * manually specified devices are the first 54928fb27baSJustin T. Gibbs * ones to be selected. If we're in remove 55028fb27baSJustin T. Gibbs * mode, we de-select the specified device and 55128fb27baSJustin T. Gibbs * decrement the selection count. 55228fb27baSJustin T. Gibbs */ 55328fb27baSJustin T. Gibbs switch(select_mode) { 55428fb27baSJustin T. Gibbs case DS_SELECT_ADD: 55528fb27baSJustin T. Gibbs case DS_SELECT_ADDONLY: 55628fb27baSJustin T. Gibbs if ((*dev_select)[i].selected) 55728fb27baSJustin T. Gibbs break; 55828fb27baSJustin T. Gibbs /* FALLTHROUGH */ 55928fb27baSJustin T. Gibbs case DS_SELECT_ONLY: 56028fb27baSJustin T. Gibbs (*dev_select)[i].selected = 56128fb27baSJustin T. Gibbs ++selection_number; 56228fb27baSJustin T. Gibbs (*num_selected)++; 56328fb27baSJustin T. Gibbs break; 56428fb27baSJustin T. Gibbs case DS_SELECT_REMOVE: 56528fb27baSJustin T. Gibbs (*dev_select)[i].selected = 0; 56628fb27baSJustin T. Gibbs (*num_selected)--; 56728fb27baSJustin T. Gibbs /* 56828fb27baSJustin T. Gibbs * This isn't passed back out, we 56928fb27baSJustin T. Gibbs * just use it to keep track of 57028fb27baSJustin T. Gibbs * how many devices we've removed. 57128fb27baSJustin T. Gibbs */ 57228fb27baSJustin T. Gibbs num_dev_selections--; 57328fb27baSJustin T. Gibbs break; 57428fb27baSJustin T. Gibbs } 57528fb27baSJustin T. Gibbs break; 57628fb27baSJustin T. Gibbs } 57728fb27baSJustin T. Gibbs } 57828fb27baSJustin T. Gibbs } 57928fb27baSJustin T. Gibbs 58028fb27baSJustin T. Gibbs /* 58128fb27baSJustin T. Gibbs * Go through the user's device type expressions and select devices 58228fb27baSJustin T. Gibbs * accordingly. We only do this if the number of devices already 58328fb27baSJustin T. Gibbs * selected is less than the maximum number we can show. 58428fb27baSJustin T. Gibbs */ 58528fb27baSJustin T. Gibbs for (i = 0; (i < num_matches) && (*num_selected < maxshowdevs); i++) { 58628fb27baSJustin T. Gibbs /* We should probably indicate some error here */ 58728fb27baSJustin T. Gibbs if ((matches[i].match_fields == DEVSTAT_MATCH_NONE) 58828fb27baSJustin T. Gibbs || (matches[i].num_match_categories <= 0)) 58928fb27baSJustin T. Gibbs continue; 59028fb27baSJustin T. Gibbs 59128fb27baSJustin T. Gibbs for (j = 0; j < numdevs; j++) { 59228fb27baSJustin T. Gibbs int num_match_categories; 59328fb27baSJustin T. Gibbs 59428fb27baSJustin T. Gibbs num_match_categories = matches[i].num_match_categories; 59528fb27baSJustin T. Gibbs 59628fb27baSJustin T. Gibbs /* 59728fb27baSJustin T. Gibbs * Determine whether or not the current device 59828fb27baSJustin T. Gibbs * matches the given matching expression. This if 59928fb27baSJustin T. Gibbs * statement consists of three components: 60028fb27baSJustin T. Gibbs * - the device type check 60128fb27baSJustin T. Gibbs * - the device interface check 60228fb27baSJustin T. Gibbs * - the passthrough check 60328fb27baSJustin T. Gibbs * If a the matching test is successful, it 60428fb27baSJustin T. Gibbs * decrements the number of matching categories, 60528fb27baSJustin T. Gibbs * and if we've reached the last element that 60628fb27baSJustin T. Gibbs * needed to be matched, the if statement succeeds. 60728fb27baSJustin T. Gibbs * 60828fb27baSJustin T. Gibbs */ 60928fb27baSJustin T. Gibbs if ((((matches[i].match_fields & DEVSTAT_MATCH_TYPE)!=0) 61028fb27baSJustin T. Gibbs && ((devices[j].device_type & DEVSTAT_TYPE_MASK) == 61128fb27baSJustin T. Gibbs (matches[i].device_type & DEVSTAT_TYPE_MASK)) 61228fb27baSJustin T. Gibbs &&(((matches[i].match_fields & DEVSTAT_MATCH_PASS)!=0) 61328fb27baSJustin T. Gibbs || (((matches[i].match_fields & 61428fb27baSJustin T. Gibbs DEVSTAT_MATCH_PASS) == 0) 61528fb27baSJustin T. Gibbs && ((devices[j].device_type & 61628fb27baSJustin T. Gibbs DEVSTAT_TYPE_PASS) == 0))) 61728fb27baSJustin T. Gibbs && (--num_match_categories == 0)) 61828fb27baSJustin T. Gibbs || (((matches[i].match_fields & DEVSTAT_MATCH_IF) != 0) 61928fb27baSJustin T. Gibbs && ((devices[j].device_type & DEVSTAT_TYPE_IF_MASK) == 62028fb27baSJustin T. Gibbs (matches[i].device_type & DEVSTAT_TYPE_IF_MASK)) 62128fb27baSJustin T. Gibbs &&(((matches[i].match_fields & DEVSTAT_MATCH_PASS)!=0) 62228fb27baSJustin T. Gibbs || (((matches[i].match_fields & 62328fb27baSJustin T. Gibbs DEVSTAT_MATCH_PASS) == 0) 62428fb27baSJustin T. Gibbs && ((devices[j].device_type & 62528fb27baSJustin T. Gibbs DEVSTAT_TYPE_PASS) == 0))) 62628fb27baSJustin T. Gibbs && (--num_match_categories == 0)) 62728fb27baSJustin T. Gibbs || (((matches[i].match_fields & DEVSTAT_MATCH_PASS)!=0) 62828fb27baSJustin T. Gibbs && ((devices[j].device_type & DEVSTAT_TYPE_PASS) != 0) 62928fb27baSJustin T. Gibbs && (--num_match_categories == 0))) { 63028fb27baSJustin T. Gibbs 63128fb27baSJustin T. Gibbs /* 63228fb27baSJustin T. Gibbs * This is probably a non-optimal solution 63328fb27baSJustin T. Gibbs * to the problem that the devices in the 63428fb27baSJustin T. Gibbs * device list will not be in the same 63528fb27baSJustin T. Gibbs * order as the devices in the selection 63628fb27baSJustin T. Gibbs * array. 63728fb27baSJustin T. Gibbs */ 63828fb27baSJustin T. Gibbs for (k = 0; k < numdevs; k++) { 63928fb27baSJustin T. Gibbs if ((*dev_select)[k].position == j) { 64028fb27baSJustin T. Gibbs found = 1; 64128fb27baSJustin T. Gibbs break; 64228fb27baSJustin T. Gibbs } 64328fb27baSJustin T. Gibbs } 64428fb27baSJustin T. Gibbs 64528fb27baSJustin T. Gibbs /* 64628fb27baSJustin T. Gibbs * There shouldn't be a case where a device 64728fb27baSJustin T. Gibbs * in the device list is not in the 64828fb27baSJustin T. Gibbs * selection list...but it could happen. 64928fb27baSJustin T. Gibbs */ 65028fb27baSJustin T. Gibbs if (found != 1) { 65128fb27baSJustin T. Gibbs fprintf(stderr, "selectdevs: couldn't" 65228fb27baSJustin T. Gibbs " find %s%d in selection " 65328fb27baSJustin T. Gibbs "list\n", 65428fb27baSJustin T. Gibbs devices[j].device_name, 65528fb27baSJustin T. Gibbs devices[j].unit_number); 65628fb27baSJustin T. Gibbs break; 65728fb27baSJustin T. Gibbs } 65828fb27baSJustin T. Gibbs 65928fb27baSJustin T. Gibbs /* 66028fb27baSJustin T. Gibbs * We do different things based upon the 66128fb27baSJustin T. Gibbs * mode we're in. If we're in add or only 66228fb27baSJustin T. Gibbs * mode, we go ahead and select this device 66328fb27baSJustin T. Gibbs * if it hasn't already been selected. If 66428fb27baSJustin T. Gibbs * it has already been selected, we leave 66528fb27baSJustin T. Gibbs * it alone so we don't mess up the 66628fb27baSJustin T. Gibbs * selection ordering. Manually specified 66728fb27baSJustin T. Gibbs * devices have already been selected, and 66828fb27baSJustin T. Gibbs * they have higher priority than pattern 66928fb27baSJustin T. Gibbs * matched devices. If we're in remove 67028fb27baSJustin T. Gibbs * mode, we de-select the given device and 67128fb27baSJustin T. Gibbs * decrement the selected count. 67228fb27baSJustin T. Gibbs */ 67328fb27baSJustin T. Gibbs switch(select_mode) { 67428fb27baSJustin T. Gibbs case DS_SELECT_ADD: 67528fb27baSJustin T. Gibbs case DS_SELECT_ADDONLY: 67628fb27baSJustin T. Gibbs case DS_SELECT_ONLY: 67728fb27baSJustin T. Gibbs if ((*dev_select)[k].selected != 0) 67828fb27baSJustin T. Gibbs break; 67928fb27baSJustin T. Gibbs (*dev_select)[k].selected = 68028fb27baSJustin T. Gibbs ++selection_number; 68128fb27baSJustin T. Gibbs (*num_selected)++; 68228fb27baSJustin T. Gibbs break; 68328fb27baSJustin T. Gibbs case DS_SELECT_REMOVE: 68428fb27baSJustin T. Gibbs (*dev_select)[k].selected = 0; 68528fb27baSJustin T. Gibbs (*num_selected)--; 68628fb27baSJustin T. Gibbs break; 68728fb27baSJustin T. Gibbs } 68828fb27baSJustin T. Gibbs } 68928fb27baSJustin T. Gibbs } 69028fb27baSJustin T. Gibbs } 69128fb27baSJustin T. Gibbs 69228fb27baSJustin T. Gibbs /* 69328fb27baSJustin T. Gibbs * Here we implement "top" mode. Devices are sorted in the 69428fb27baSJustin T. Gibbs * selection array based on two criteria: whether or not they are 69528fb27baSJustin T. Gibbs * selected (not selection number, just the fact that they are 69628fb27baSJustin T. Gibbs * selected!) and the number of bytes in the "bytes" field of the 69728fb27baSJustin T. Gibbs * selection structure. The bytes field generally must be kept up 69828fb27baSJustin T. Gibbs * by the user. In the future, it may be maintained by library 69928fb27baSJustin T. Gibbs * functions, but for now the user has to do the work. 70028fb27baSJustin T. Gibbs * 70128fb27baSJustin T. Gibbs * At first glance, it may seem wrong that we don't go through and 70228fb27baSJustin T. Gibbs * select every device in the case where the user hasn't specified 70328fb27baSJustin T. Gibbs * any devices or patterns. In fact, though, it won't make any 70428fb27baSJustin T. Gibbs * difference in the device sorting. In that particular case (i.e. 70528fb27baSJustin T. Gibbs * when we're in "add" or "only" mode, and the user hasn't 70628fb27baSJustin T. Gibbs * specified anything) the first time through no devices will be 70728fb27baSJustin T. Gibbs * selected, so the only criterion used to sort them will be their 70828fb27baSJustin T. Gibbs * performance. The second time through, and every time thereafter, 70928fb27baSJustin T. Gibbs * all devices will be selected, so again selection won't matter. 71028fb27baSJustin T. Gibbs */ 71128fb27baSJustin T. Gibbs if (perf_select != 0) { 71228fb27baSJustin T. Gibbs 71328fb27baSJustin T. Gibbs /* Sort the device array by throughput */ 71428fb27baSJustin T. Gibbs qsort(*dev_select, *num_selections, 71528fb27baSJustin T. Gibbs sizeof(struct device_selection), 71628fb27baSJustin T. Gibbs compare_select); 71728fb27baSJustin T. Gibbs 71828fb27baSJustin T. Gibbs if (*num_selected == 0) { 71928fb27baSJustin T. Gibbs /* 72028fb27baSJustin T. Gibbs * Here we select every device in the array, if it 72128fb27baSJustin T. Gibbs * isn't already selected. Because the 'selected' 72228fb27baSJustin T. Gibbs * variable in the selection array entries contains 72328fb27baSJustin T. Gibbs * the selection order, the devstats routine can show 72428fb27baSJustin T. Gibbs * the devices that were selected first. 72528fb27baSJustin T. Gibbs */ 72628fb27baSJustin T. Gibbs for (i = 0; i < *num_selections; i++) { 72728fb27baSJustin T. Gibbs if ((*dev_select)[i].selected == 0) { 72828fb27baSJustin T. Gibbs (*dev_select)[i].selected = 72928fb27baSJustin T. Gibbs ++selection_number; 73028fb27baSJustin T. Gibbs (*num_selected)++; 73128fb27baSJustin T. Gibbs } 73228fb27baSJustin T. Gibbs } 73328fb27baSJustin T. Gibbs } else { 73428fb27baSJustin T. Gibbs selection_number = 0; 73528fb27baSJustin T. Gibbs for (i = 0; i < *num_selections; i++) { 73628fb27baSJustin T. Gibbs if ((*dev_select)[i].selected != 0) { 73728fb27baSJustin T. Gibbs (*dev_select)[i].selected = 73828fb27baSJustin T. Gibbs ++selection_number; 73928fb27baSJustin T. Gibbs } 74028fb27baSJustin T. Gibbs } 74128fb27baSJustin T. Gibbs } 74228fb27baSJustin T. Gibbs } 74328fb27baSJustin T. Gibbs 74428fb27baSJustin T. Gibbs /* 74528fb27baSJustin T. Gibbs * If we're in the "add" selection mode and if we haven't already 74628fb27baSJustin T. Gibbs * selected maxshowdevs number of devices, go through the array and 74728fb27baSJustin T. Gibbs * select any unselected devices. If we're in "only" mode, we 74828fb27baSJustin T. Gibbs * obviously don't want to select anything other than what the user 74928fb27baSJustin T. Gibbs * specifies. If we're in "remove" mode, it probably isn't a good 75028fb27baSJustin T. Gibbs * idea to go through and select any more devices, since we might 75128fb27baSJustin T. Gibbs * end up selecting something that the user wants removed. Through 75228fb27baSJustin T. Gibbs * more complicated logic, we could actually figure this out, but 75328fb27baSJustin T. Gibbs * that would probably require combining this loop with the various 75428fb27baSJustin T. Gibbs * selections loops above. 75528fb27baSJustin T. Gibbs */ 75628fb27baSJustin T. Gibbs if ((select_mode == DS_SELECT_ADD) && (*num_selected < maxshowdevs)) { 75728fb27baSJustin T. Gibbs for (i = 0; i < *num_selections; i++) 75828fb27baSJustin T. Gibbs if ((*dev_select)[i].selected == 0) { 75928fb27baSJustin T. Gibbs (*dev_select)[i].selected = ++selection_number; 76028fb27baSJustin T. Gibbs (*num_selected)++; 76128fb27baSJustin T. Gibbs } 76228fb27baSJustin T. Gibbs } 76328fb27baSJustin T. Gibbs 76428fb27baSJustin T. Gibbs /* 76528fb27baSJustin T. Gibbs * Look at the number of devices that have been selected. If it 76628fb27baSJustin T. Gibbs * has changed, set the changed variable. Otherwise, if we've 76728fb27baSJustin T. Gibbs * made a backup of the selection list, compare it to the current 76828fb27baSJustin T. Gibbs * selection list to see if the selected devices have changed. 76928fb27baSJustin T. Gibbs */ 77028fb27baSJustin T. Gibbs if ((changed == 0) && (old_num_selected != *num_selected)) 77128fb27baSJustin T. Gibbs changed = 1; 77228fb27baSJustin T. Gibbs else if ((changed == 0) && (old_dev_select != NULL)) { 77328fb27baSJustin T. Gibbs /* 77428fb27baSJustin T. Gibbs * Now we go through the selection list and we look at 77528fb27baSJustin T. Gibbs * it three different ways. 77628fb27baSJustin T. Gibbs */ 77728fb27baSJustin T. Gibbs for (i = 0; (i < *num_selections) && (changed == 0) && 77828fb27baSJustin T. Gibbs (i < old_num_selections); i++) { 77928fb27baSJustin T. Gibbs /* 78028fb27baSJustin T. Gibbs * If the device at index i in both the new and old 78128fb27baSJustin T. Gibbs * selection arrays has the same device number and 78228fb27baSJustin T. Gibbs * selection status, it hasn't changed. We 78328fb27baSJustin T. Gibbs * continue on to the next index. 78428fb27baSJustin T. Gibbs */ 78528fb27baSJustin T. Gibbs if (((*dev_select)[i].device_number == 78628fb27baSJustin T. Gibbs old_dev_select[i].device_number) 78728fb27baSJustin T. Gibbs && ((*dev_select)[i].selected == 78828fb27baSJustin T. Gibbs old_dev_select[i].selected)) 78928fb27baSJustin T. Gibbs continue; 79028fb27baSJustin T. Gibbs 79128fb27baSJustin T. Gibbs /* 79228fb27baSJustin T. Gibbs * Now, if we're still going through the if 79328fb27baSJustin T. Gibbs * statement, the above test wasn't true. So we 79428fb27baSJustin T. Gibbs * check here to see if the device at index i in 79528fb27baSJustin T. Gibbs * the current array is the same as the device at 79628fb27baSJustin T. Gibbs * index i in the old array. If it is, that means 79728fb27baSJustin T. Gibbs * that its selection number has changed. Set 79828fb27baSJustin T. Gibbs * changed to 1 and exit the loop. 79928fb27baSJustin T. Gibbs */ 80028fb27baSJustin T. Gibbs else if ((*dev_select)[i].device_number == 80128fb27baSJustin T. Gibbs old_dev_select[i].device_number) { 80228fb27baSJustin T. Gibbs changed = 1; 80328fb27baSJustin T. Gibbs break; 80428fb27baSJustin T. Gibbs } 80528fb27baSJustin T. Gibbs /* 80628fb27baSJustin T. Gibbs * If we get here, then the device at index i in 80728fb27baSJustin T. Gibbs * the current array isn't the same device as the 80828fb27baSJustin T. Gibbs * device at index i in the old array. 80928fb27baSJustin T. Gibbs */ 81028fb27baSJustin T. Gibbs else { 81128fb27baSJustin T. Gibbs int found = 0; 81228fb27baSJustin T. Gibbs 81328fb27baSJustin T. Gibbs /* 81428fb27baSJustin T. Gibbs * Search through the old selection array 81528fb27baSJustin T. Gibbs * looking for a device with the same 81628fb27baSJustin T. Gibbs * device number as the device at index i 81728fb27baSJustin T. Gibbs * in the current array. If the selection 81828fb27baSJustin T. Gibbs * status is the same, then we mark it as 81928fb27baSJustin T. Gibbs * found. If the selection status isn't 82028fb27baSJustin T. Gibbs * the same, we break out of the loop. 82128fb27baSJustin T. Gibbs * Since found isn't set, changed will be 82228fb27baSJustin T. Gibbs * set to 1 below. 82328fb27baSJustin T. Gibbs */ 82428fb27baSJustin T. Gibbs for (j = 0; j < old_num_selections; j++) { 82528fb27baSJustin T. Gibbs if (((*dev_select)[i].device_number == 82628fb27baSJustin T. Gibbs old_dev_select[j].device_number) 82728fb27baSJustin T. Gibbs && ((*dev_select)[i].selected == 82828fb27baSJustin T. Gibbs old_dev_select[j].selected)){ 82928fb27baSJustin T. Gibbs found = 1; 83028fb27baSJustin T. Gibbs break; 83128fb27baSJustin T. Gibbs } 83228fb27baSJustin T. Gibbs else if ((*dev_select)[i].device_number 83328fb27baSJustin T. Gibbs == old_dev_select[j].device_number) 83428fb27baSJustin T. Gibbs break; 83528fb27baSJustin T. Gibbs } 83628fb27baSJustin T. Gibbs if (found == 0) 83728fb27baSJustin T. Gibbs changed = 1; 83828fb27baSJustin T. Gibbs } 83928fb27baSJustin T. Gibbs } 84028fb27baSJustin T. Gibbs } 84128fb27baSJustin T. Gibbs if (old_dev_select != NULL) 84228fb27baSJustin T. Gibbs free(old_dev_select); 84328fb27baSJustin T. Gibbs 84428fb27baSJustin T. Gibbs return(changed); 84528fb27baSJustin T. Gibbs } 84628fb27baSJustin T. Gibbs 84728fb27baSJustin T. Gibbs /* 84828fb27baSJustin T. Gibbs * Comparison routine for qsort() above. Note that the comparison here is 84928fb27baSJustin T. Gibbs * backwards -- generally, it should return a value to indicate whether 85028fb27baSJustin T. Gibbs * arg1 is <, =, or > arg2. Instead, it returns the opposite. The reason 85128fb27baSJustin T. Gibbs * it returns the opposite is so that the selection array will be sorted in 85228fb27baSJustin T. Gibbs * order of decreasing performance. We sort on two parameters. The first 85328fb27baSJustin T. Gibbs * sort key is whether or not one or the other of the devices in question 85428fb27baSJustin T. Gibbs * has been selected. If one of them has, and the other one has not, the 85528fb27baSJustin T. Gibbs * selected device is automatically more important than the unselected 85628fb27baSJustin T. Gibbs * device. If neither device is selected, we judge the devices based upon 85728fb27baSJustin T. Gibbs * performance. 85828fb27baSJustin T. Gibbs */ 85928fb27baSJustin T. Gibbs static int 86028fb27baSJustin T. Gibbs compare_select(const void *arg1, const void *arg2) 86128fb27baSJustin T. Gibbs { 86228fb27baSJustin T. Gibbs if ((((struct device_selection *)arg1)->selected) 86328fb27baSJustin T. Gibbs && (((struct device_selection *)arg2)->selected == 0)) 86428fb27baSJustin T. Gibbs return(-1); 86528fb27baSJustin T. Gibbs else if ((((struct device_selection *)arg1)->selected == 0) 86628fb27baSJustin T. Gibbs && (((struct device_selection *)arg2)->selected)) 86728fb27baSJustin T. Gibbs return(1); 86828fb27baSJustin T. Gibbs else if (((struct device_selection *)arg2)->bytes < 86928fb27baSJustin T. Gibbs ((struct device_selection *)arg1)->bytes) 87028fb27baSJustin T. Gibbs return(-1); 87128fb27baSJustin T. Gibbs else if (((struct device_selection *)arg2)->bytes > 87228fb27baSJustin T. Gibbs ((struct device_selection *)arg1)->bytes) 87328fb27baSJustin T. Gibbs return(1); 87428fb27baSJustin T. Gibbs else 87528fb27baSJustin T. Gibbs return(0); 87628fb27baSJustin T. Gibbs } 87728fb27baSJustin T. Gibbs 87828fb27baSJustin T. Gibbs /* 87928fb27baSJustin T. Gibbs * Take a string with the general format "arg1,arg2,arg3", and build a 88028fb27baSJustin T. Gibbs * device matching expression from it. 88128fb27baSJustin T. Gibbs */ 88228fb27baSJustin T. Gibbs int 88328fb27baSJustin T. Gibbs buildmatch(char *match_str, struct devstat_match **matches, int *num_matches) 88428fb27baSJustin T. Gibbs { 88528fb27baSJustin T. Gibbs char *tstr[5]; 88628fb27baSJustin T. Gibbs char **tempstr; 88728fb27baSJustin T. Gibbs int num_args; 88828fb27baSJustin T. Gibbs register int i, j; 88928fb27baSJustin T. Gibbs char *func_name = "buildmatch"; 89028fb27baSJustin T. Gibbs 89128fb27baSJustin T. Gibbs /* We can't do much without a string to parse */ 89228fb27baSJustin T. Gibbs if (match_str == NULL) { 89328fb27baSJustin T. Gibbs sprintf(devstat_errbuf, "%s: no match expression", func_name); 89428fb27baSJustin T. Gibbs return(-1); 89528fb27baSJustin T. Gibbs } 89628fb27baSJustin T. Gibbs 89728fb27baSJustin T. Gibbs /* 89828fb27baSJustin T. Gibbs * Break the (comma delimited) input string out into separate strings. 89928fb27baSJustin T. Gibbs */ 90028fb27baSJustin T. Gibbs for (tempstr = tstr, num_args = 0; 90128fb27baSJustin T. Gibbs (*tempstr = strsep(&match_str, ",")) != NULL && (num_args < 5); 90228fb27baSJustin T. Gibbs num_args++) 90328fb27baSJustin T. Gibbs if (**tempstr != '\0') 90428fb27baSJustin T. Gibbs if (++tempstr >= &tstr[5]) 90528fb27baSJustin T. Gibbs break; 90628fb27baSJustin T. Gibbs 90728fb27baSJustin T. Gibbs /* The user gave us too many type arguments */ 90828fb27baSJustin T. Gibbs if (num_args > 3) { 90928fb27baSJustin T. Gibbs sprintf(devstat_errbuf, "%s: too many type arguments", 91028fb27baSJustin T. Gibbs func_name); 91128fb27baSJustin T. Gibbs return(-1); 91228fb27baSJustin T. Gibbs } 91328fb27baSJustin T. Gibbs 91428fb27baSJustin T. Gibbs /* 91528fb27baSJustin T. Gibbs * Since you can't realloc a pointer that hasn't been malloced 91628fb27baSJustin T. Gibbs * first, we malloc first and then realloc. 91728fb27baSJustin T. Gibbs */ 91828fb27baSJustin T. Gibbs if (*num_matches == 0) 91928fb27baSJustin T. Gibbs *matches = (struct devstat_match *)malloc( 92028fb27baSJustin T. Gibbs sizeof(struct devstat_match)); 92128fb27baSJustin T. Gibbs else 92228fb27baSJustin T. Gibbs *matches = (struct devstat_match *)realloc(*matches, 92328fb27baSJustin T. Gibbs sizeof(struct devstat_match) * (*num_matches + 1)); 92428fb27baSJustin T. Gibbs 92528fb27baSJustin T. Gibbs /* Make sure the current entry is clear */ 92628fb27baSJustin T. Gibbs bzero(&matches[0][*num_matches], sizeof(struct devstat_match)); 92728fb27baSJustin T. Gibbs 92828fb27baSJustin T. Gibbs /* 92928fb27baSJustin T. Gibbs * Step through the arguments the user gave us and build a device 93028fb27baSJustin T. Gibbs * matching expression from them. 93128fb27baSJustin T. Gibbs */ 93228fb27baSJustin T. Gibbs for (i = 0; i < num_args; i++) { 93328fb27baSJustin T. Gibbs char *tempstr2, *tempstr3; 93428fb27baSJustin T. Gibbs 93528fb27baSJustin T. Gibbs /* 93628fb27baSJustin T. Gibbs * Get rid of leading white space. 93728fb27baSJustin T. Gibbs */ 93828fb27baSJustin T. Gibbs tempstr2 = tstr[i]; 93928fb27baSJustin T. Gibbs while (isspace(*tempstr2) && (*tempstr2 != '\0')) 94028fb27baSJustin T. Gibbs tempstr2++; 94128fb27baSJustin T. Gibbs 94228fb27baSJustin T. Gibbs /* 94328fb27baSJustin T. Gibbs * Get rid of trailing white space. 94428fb27baSJustin T. Gibbs */ 94528fb27baSJustin T. Gibbs tempstr3 = &tempstr2[strlen(tempstr2) - 1]; 94628fb27baSJustin T. Gibbs 94728fb27baSJustin T. Gibbs while ((*tempstr3 != '\0') && (tempstr3 > tempstr2) 94828fb27baSJustin T. Gibbs && (isspace(*tempstr3))) { 94928fb27baSJustin T. Gibbs *tempstr3 = '\0'; 95028fb27baSJustin T. Gibbs tempstr3--; 95128fb27baSJustin T. Gibbs } 95228fb27baSJustin T. Gibbs 95328fb27baSJustin T. Gibbs /* 95428fb27baSJustin T. Gibbs * Go through the match table comparing the user's 95528fb27baSJustin T. Gibbs * arguments to known device types, interfaces, etc. 95628fb27baSJustin T. Gibbs */ 95728fb27baSJustin T. Gibbs for (j = 0; match_table[j].match_str != NULL; j++) { 95828fb27baSJustin T. Gibbs /* 95928fb27baSJustin T. Gibbs * We do case-insensitive matching, in case someone 96028fb27baSJustin T. Gibbs * wants to enter "SCSI" instead of "scsi" or 96128fb27baSJustin T. Gibbs * something like that. Only compare as many 96228fb27baSJustin T. Gibbs * characters as are in the string in the match 96328fb27baSJustin T. Gibbs * table. This should help if someone tries to use 96428fb27baSJustin T. Gibbs * a super-long match expression. 96528fb27baSJustin T. Gibbs */ 96628fb27baSJustin T. Gibbs if (strncasecmp(tempstr2, match_table[j].match_str, 96728fb27baSJustin T. Gibbs strlen(match_table[j].match_str)) == 0) { 96828fb27baSJustin T. Gibbs /* 96928fb27baSJustin T. Gibbs * Make sure the user hasn't specified two 97028fb27baSJustin T. Gibbs * items of the same type, like "da" and 97128fb27baSJustin T. Gibbs * "cd". One device cannot be both. 97228fb27baSJustin T. Gibbs */ 97328fb27baSJustin T. Gibbs if (((*matches)[*num_matches].match_fields & 97428fb27baSJustin T. Gibbs match_table[j].match_field) != 0) { 97528fb27baSJustin T. Gibbs sprintf(devstat_errbuf, 97628fb27baSJustin T. Gibbs "%s: cannot have more than " 97728fb27baSJustin T. Gibbs "one match item in a single " 97828fb27baSJustin T. Gibbs "category", func_name); 97928fb27baSJustin T. Gibbs return(-1); 98028fb27baSJustin T. Gibbs } 98128fb27baSJustin T. Gibbs /* 98228fb27baSJustin T. Gibbs * If we've gotten this far, we have a 98328fb27baSJustin T. Gibbs * winner. Set the appropriate fields in 98428fb27baSJustin T. Gibbs * the match entry. 98528fb27baSJustin T. Gibbs */ 98628fb27baSJustin T. Gibbs (*matches)[*num_matches].match_fields |= 98728fb27baSJustin T. Gibbs match_table[j].match_field; 98828fb27baSJustin T. Gibbs (*matches)[*num_matches].device_type |= 98928fb27baSJustin T. Gibbs match_table[j].type; 99028fb27baSJustin T. Gibbs (*matches)[*num_matches].num_match_categories++; 99128fb27baSJustin T. Gibbs break; 99228fb27baSJustin T. Gibbs } 99328fb27baSJustin T. Gibbs } 99428fb27baSJustin T. Gibbs /* 99528fb27baSJustin T. Gibbs * We should have found a match in the above for loop. If 99628fb27baSJustin T. Gibbs * not, that means the user entered an invalid device type 99728fb27baSJustin T. Gibbs * or interface. 99828fb27baSJustin T. Gibbs */ 99928fb27baSJustin T. Gibbs if ((*matches)[*num_matches].num_match_categories != (i + 1)) { 100028fb27baSJustin T. Gibbs sprintf(devstat_errbuf, 100128fb27baSJustin T. Gibbs "%s: unknown match item \"%s\"", func_name, 100228fb27baSJustin T. Gibbs tstr[i]); 100328fb27baSJustin T. Gibbs return(-1); 100428fb27baSJustin T. Gibbs } 100528fb27baSJustin T. Gibbs } 100628fb27baSJustin T. Gibbs 100728fb27baSJustin T. Gibbs (*num_matches)++; 100828fb27baSJustin T. Gibbs 100928fb27baSJustin T. Gibbs return(0); 101028fb27baSJustin T. Gibbs } 101128fb27baSJustin T. Gibbs 101228fb27baSJustin T. Gibbs /* 101328fb27baSJustin T. Gibbs * Compute a number of device statistics. Only one field is mandatory, and 101428fb27baSJustin T. Gibbs * that is "current". Everything else is optional. The caller passes in 101528fb27baSJustin T. Gibbs * pointers to variables to hold the various statistics he desires. If he 101628fb27baSJustin T. Gibbs * doesn't want a particular staistic, he should pass in a NULL pointer. 101728fb27baSJustin T. Gibbs * Return values: 101828fb27baSJustin T. Gibbs * 0 -- success 101928fb27baSJustin T. Gibbs * -1 -- failure 102028fb27baSJustin T. Gibbs */ 102128fb27baSJustin T. Gibbs int 102228fb27baSJustin T. Gibbs compute_stats(struct devstat *current, struct devstat *previous, 102328fb27baSJustin T. Gibbs long double etime, u_int64_t *total_bytes, 102428fb27baSJustin T. Gibbs u_int64_t *total_transfers, u_int64_t *total_blocks, 102528fb27baSJustin T. Gibbs long double *kb_per_transfer, long double *transfers_per_second, 102628fb27baSJustin T. Gibbs long double *mb_per_second, long double *blocks_per_second, 102728fb27baSJustin T. Gibbs long double *ms_per_transaction) 102828fb27baSJustin T. Gibbs { 102928fb27baSJustin T. Gibbs u_int64_t totalbytes, totaltransfers, totalblocks; 103028fb27baSJustin T. Gibbs char *func_name = "compute_stats"; 103128fb27baSJustin T. Gibbs 103228fb27baSJustin T. Gibbs /* 103328fb27baSJustin T. Gibbs * current is the only mandatory field. 103428fb27baSJustin T. Gibbs */ 103528fb27baSJustin T. Gibbs if (current == NULL) { 103628fb27baSJustin T. Gibbs sprintf(devstat_errbuf, "%s: current stats structure was NULL", 103728fb27baSJustin T. Gibbs func_name); 103828fb27baSJustin T. Gibbs return(-1); 103928fb27baSJustin T. Gibbs } 104028fb27baSJustin T. Gibbs 104128fb27baSJustin T. Gibbs totalbytes = (current->bytes_written + current->bytes_read) - 104228fb27baSJustin T. Gibbs ((previous) ? (previous->bytes_written + 104328fb27baSJustin T. Gibbs previous->bytes_read) : 0); 104428fb27baSJustin T. Gibbs 104528fb27baSJustin T. Gibbs if (total_bytes) 104628fb27baSJustin T. Gibbs *total_bytes = totalbytes; 104728fb27baSJustin T. Gibbs 104828fb27baSJustin T. Gibbs totaltransfers = (current->num_reads + 104928fb27baSJustin T. Gibbs current->num_writes + 105028fb27baSJustin T. Gibbs current->num_other) - 105128fb27baSJustin T. Gibbs ((previous) ? 105228fb27baSJustin T. Gibbs (previous->num_reads + 105328fb27baSJustin T. Gibbs previous->num_writes + 105428fb27baSJustin T. Gibbs previous->num_other) : 0); 105528fb27baSJustin T. Gibbs if (total_transfers) 105628fb27baSJustin T. Gibbs *total_transfers = totaltransfers; 105728fb27baSJustin T. Gibbs 105828fb27baSJustin T. Gibbs if (transfers_per_second) { 105928fb27baSJustin T. Gibbs if (etime > 0.0) { 106028fb27baSJustin T. Gibbs *transfers_per_second = totaltransfers; 106128fb27baSJustin T. Gibbs *transfers_per_second /= etime; 106228fb27baSJustin T. Gibbs } else 106328fb27baSJustin T. Gibbs *transfers_per_second = 0.0; 106428fb27baSJustin T. Gibbs } 106528fb27baSJustin T. Gibbs 106628fb27baSJustin T. Gibbs if (kb_per_transfer) { 106728fb27baSJustin T. Gibbs *kb_per_transfer = totalbytes; 106828fb27baSJustin T. Gibbs *kb_per_transfer /= 1024; 106928fb27baSJustin T. Gibbs if (totaltransfers > 0) 107028fb27baSJustin T. Gibbs *kb_per_transfer /= totaltransfers; 107128fb27baSJustin T. Gibbs else 107228fb27baSJustin T. Gibbs *kb_per_transfer = 0.0; 107328fb27baSJustin T. Gibbs } 107428fb27baSJustin T. Gibbs 107528fb27baSJustin T. Gibbs if (mb_per_second) { 107628fb27baSJustin T. Gibbs *mb_per_second = totalbytes; 107728fb27baSJustin T. Gibbs *mb_per_second /= 1024 * 1024; 107828fb27baSJustin T. Gibbs if (etime > 0.0) 107928fb27baSJustin T. Gibbs *mb_per_second /= etime; 108028fb27baSJustin T. Gibbs else 108128fb27baSJustin T. Gibbs *mb_per_second = 0.0; 108228fb27baSJustin T. Gibbs } 108328fb27baSJustin T. Gibbs 108428fb27baSJustin T. Gibbs totalblocks = totalbytes; 108528fb27baSJustin T. Gibbs if (current->block_size > 0) 108628fb27baSJustin T. Gibbs totalblocks /= current->block_size; 108728fb27baSJustin T. Gibbs else 108828fb27baSJustin T. Gibbs totalblocks /= 512; 108928fb27baSJustin T. Gibbs 109028fb27baSJustin T. Gibbs if (total_blocks) 109128fb27baSJustin T. Gibbs *total_blocks = totalblocks; 109228fb27baSJustin T. Gibbs 109328fb27baSJustin T. Gibbs if (blocks_per_second) { 109428fb27baSJustin T. Gibbs *blocks_per_second = totalblocks; 109528fb27baSJustin T. Gibbs if (etime > 0.0) 109628fb27baSJustin T. Gibbs *blocks_per_second /= etime; 109728fb27baSJustin T. Gibbs else 109828fb27baSJustin T. Gibbs *blocks_per_second = 0.0; 109928fb27baSJustin T. Gibbs } 110028fb27baSJustin T. Gibbs 110128fb27baSJustin T. Gibbs if (ms_per_transaction) { 110228fb27baSJustin T. Gibbs if (totaltransfers > 0) { 110328fb27baSJustin T. Gibbs *ms_per_transaction = etime; 110428fb27baSJustin T. Gibbs *ms_per_transaction /= totaltransfers; 110528fb27baSJustin T. Gibbs *ms_per_transaction *= 1000; 110628fb27baSJustin T. Gibbs } else 110728fb27baSJustin T. Gibbs *ms_per_transaction = 0.0; 110828fb27baSJustin T. Gibbs } 110928fb27baSJustin T. Gibbs 111028fb27baSJustin T. Gibbs return(0); 111128fb27baSJustin T. Gibbs } 111228fb27baSJustin T. Gibbs 111328fb27baSJustin T. Gibbs long double 111428fb27baSJustin T. Gibbs compute_etime(struct timeval cur_time, struct timeval prev_time) 111528fb27baSJustin T. Gibbs { 111628fb27baSJustin T. Gibbs struct timeval busy_time; 111728fb27baSJustin T. Gibbs u_int64_t busy_usec; 111828fb27baSJustin T. Gibbs long double etime; 111928fb27baSJustin T. Gibbs 112028fb27baSJustin T. Gibbs timersub(&cur_time, &prev_time, &busy_time); 112128fb27baSJustin T. Gibbs 112228fb27baSJustin T. Gibbs busy_usec = busy_time.tv_sec; 112328fb27baSJustin T. Gibbs busy_usec *= 1000000; 112428fb27baSJustin T. Gibbs busy_usec += busy_time.tv_usec; 112528fb27baSJustin T. Gibbs etime = busy_usec; 112628fb27baSJustin T. Gibbs etime /= 1000000; 112728fb27baSJustin T. Gibbs 112828fb27baSJustin T. Gibbs return(etime); 112928fb27baSJustin T. Gibbs } 1130