sys/kern/subr_devstat.c

   1 /*
   2  * Copyright (c) 1997, 1998, 1999 Kenneth D. Merry.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. The name of the author may not be used to endorse or promote products
  14  *    derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/sys/kern/subr_devstat.c,v 1.17.2.2 2000/08/03 00:09:32 ps Exp $
  29  */
  30
  31 #include <sys/param.h>
  32 #include <sys/kernel.h>
  33 #include <sys/systm.h>
  34 #include <sys/buf.h>
  35 #include <sys/sysctl.h>
  36
  37 #include <sys/devicestat.h>
  38
  39 static int devstat_num_devs;
  40 static long devstat_generation;
  41 static int devstat_version = DEVSTAT_VERSION;
  42 static int devstat_current_devnumber;
  43
  44 static STAILQ_HEAD(devstatlist, devstat) device_statq;
  45
  46 /*
  47  * Take a malloced and zeroed devstat structure given to us, fill it in
  48  * and add it to the queue of devices.
  49  */
  50 void
  51 devstat_add_entry(struct devstat *ds, const char *dev_name,
  52                   int unit_number, u_int32_t block_size,
  53                   devstat_support_flags flags,
  54                   devstat_type_flags device_type,
  55                   devstat_priority priority)
  56 {
  57         struct devstatlist *devstat_head;
  58         struct devstat *ds_tmp;
  59
  60         if (ds == NULL)
  61                 return;
  62
  63         if (devstat_num_devs == 0)
  64                 STAILQ_INIT(&device_statq);
  65
  66         devstat_generation++;
  67         devstat_num_devs++;
  68
  69         devstat_head = &device_statq;
  70
  71         /*
  72          * Priority sort.  Each driver passes in its priority when it adds
  73          * its devstat entry.  Drivers are sorted first by priority, and
  74          * then by probe order.
  75          *
  76          * For the first device, we just insert it, since the priority
  77          * doesn't really matter yet.  Subsequent devices are inserted into
  78          * the list using the order outlined above.
  79          */
  80         if (devstat_num_devs == 1)
  81                 STAILQ_INSERT_TAIL(devstat_head, ds, dev_links);
  82         else {
  83                 for (ds_tmp = STAILQ_FIRST(devstat_head); ds_tmp != NULL;
  84                      ds_tmp = STAILQ_NEXT(ds_tmp, dev_links)) {
  85                         struct devstat *ds_next;
  86
  87                         ds_next = STAILQ_NEXT(ds_tmp, dev_links);
  88
  89                         /*
  90                          * If we find a break between higher and lower
  91                          * priority items, and if this item fits in the
  92                          * break, insert it.  This also applies if the
  93                          * "lower priority item" is the end of the list.
  94                          */
  95                         if ((priority <= ds_tmp->priority)
  96                          && ((ds_next == NULL)
  97                            || (priority > ds_next->priority))) {
  98                                 STAILQ_INSERT_AFTER(devstat_head, ds_tmp, ds,
  99                                                     dev_links);
 100                                 break;
 101                         } else if (priority > ds_tmp->priority) {
 102                                 /*
 103                                  * If this is the case, we should be able
 104                                  * to insert ourselves at the head of the
 105                                  * list.  If we can't, something is wrong.
 106                                  */
 107                                 if (ds_tmp == STAILQ_FIRST(devstat_head)) {
 108                                         STAILQ_INSERT_HEAD(devstat_head,
 109                                                            ds, dev_links);
 110                                         break;
 111                                 } else {
 112                                         STAILQ_INSERT_TAIL(devstat_head,
 113                                                            ds, dev_links);
 114                                         printf("devstat_add_entry: HELP! "
 115                                                "sorting problem detected "
 116                                                "for %s%d\n", dev_name,
 117                                                unit_number);
 118                                         break;
 119                                 }
 120                         }
 121                 }
 122         }
 123
 124         ds->device_number = devstat_current_devnumber++;
 125         ds->unit_number = unit_number;
 126         strncpy(ds->device_name, dev_name, DEVSTAT_NAME_LEN);
 127         ds->device_name[DEVSTAT_NAME_LEN - 1] = '\0';
 128         ds->block_size = block_size;
 129         ds->flags = flags;
 130         ds->device_type = device_type;
 131         ds->priority = priority;
 132         getmicrotime(&ds->dev_creation_time);
 133 }
 134
 135 /*
 136  * Remove a devstat structure from the list of devices.
 137  */
 138 void
 139 devstat_remove_entry(struct devstat *ds)
 140 {
 141         struct devstatlist *devstat_head;
 142
 143         if (ds == NULL)
 144                 return;
 145
 146         devstat_generation++;
 147         devstat_num_devs--;
 148
 149         devstat_head = &device_statq;
 150
 151         /* Remove this entry from the devstat queue */
 152         STAILQ_REMOVE(devstat_head, ds, devstat, dev_links);
 153 }
 154
 155 /*
 156  * Record a transaction start.
 157  */
 158 void
 159 devstat_start_transaction(struct devstat *ds)
 160 {
 161         /* sanity check */
 162         if (ds == NULL)
 163                 return;
 164
 165         /*
 166          * We only want to set the start time when we are going from idle
 167          * to busy.  The start time is really the start of the latest busy
 168          * period.
 169          */
 170         if (ds->busy_count == 0)
 171                 getmicrouptime(&ds->start_time);
 172         ds->busy_count++;
 173 }
 174
 175 /*
 176  * Record the ending of a transaction, and incrment the various counters.
 177  */
 178 void
 179 devstat_end_transaction(struct devstat *ds, u_int32_t bytes,
 180                         devstat_tag_type tag_type, devstat_trans_flags flags)
 181 {
 182         struct timeval busy_time;
 183
 184         /* sanity check */
 185         if (ds == NULL)
 186                 return;
 187
 188         getmicrouptime(&ds->last_comp_time);
 189         ds->busy_count--;
 190
 191         /*
 192          * There might be some transactions (DEVSTAT_NO_DATA) that don't
 193          * transfer any data.
 194          */
 195         if (flags == DEVSTAT_READ) {
 196                 ds->bytes_read += bytes;
 197                 ds->num_reads++;
 198         } else if (flags == DEVSTAT_WRITE) {
 199                 ds->bytes_written += bytes;
 200                 ds->num_writes++;
 201         } else if (flags == DEVSTAT_FREE) {
 202                 ds->bytes_freed += bytes;
 203                 ds->num_frees++;
 204         } else
 205                 ds->num_other++;
 206
 207         /*
 208          * Keep a count of the various tag types sent.
 209          */
 210         if ((ds->flags & DEVSTAT_NO_ORDERED_TAGS) == 0 &&
 211             tag_type != DEVSTAT_TAG_NONE)
 212                 ds->tag_types[tag_type]++;
 213
 214         /*
 215          * We only update the busy time when we go idle.  Otherwise, this
 216          * calculation would require many more clock cycles.
 217          */
 218         if (ds->busy_count == 0) {
 219                 /* Calculate how long we were busy */
 220                 busy_time = ds->last_comp_time;
 221                 timevalsub(&busy_time, &ds->start_time);
 222
 223                 /* Add our busy time to the total busy time. */
 224                 timevaladd(&ds->busy_time, &busy_time);
 225         } else if (ds->busy_count < 0)
 226                 printf("devstat_end_transaction: HELP!! busy_count "
 227                        "for %s%d is < 0 (%d)!\n", ds->device_name,
 228                        ds->unit_number, ds->busy_count);
 229 }
 230
 231 void
 232 devstat_end_transaction_buf(struct devstat *ds, struct buf *bp)
 233 {
 234         devstat_trans_flags flg;
 235
 236         if (bp->b_flags & B_FREEBUF)
 237                 flg = DEVSTAT_FREE;
 238         else if (bp->b_flags & B_READ)
 239                 flg = DEVSTAT_READ;
 240         else
 241                 flg = DEVSTAT_WRITE;
 242
 243         devstat_end_transaction(ds, bp->b_bcount - bp->b_resid,
 244                                 (bp->b_flags & B_ORDERED) ?
 245                                 DEVSTAT_TAG_ORDERED : DEVSTAT_TAG_SIMPLE, flg);
 246 }
 247
 248 /*
 249  * This is the sysctl handler for the devstat package.  The data pushed out
 250  * on the kern.devstat.all sysctl variable consists of the current devstat
 251  * generation number, and then an array of devstat structures, one for each
 252  * device in the system.
 253  *
 254  * I'm really not too fond of this method of doing things, but there really
 255  * aren't that many alternatives.  We must have some method of making sure
 256  * that the generation number the user gets corresponds with the data the
 257  * user gets.  If the user makes a separate sysctl call to get the
 258  * generation, and then a sysctl call to get the device statistics, the
 259  * device list could have changed in that brief period of time.  By
 260  * supplying the generation number along with the statistics output, we can
 261  * guarantee that the generation number and the statistics match up.
 262  */
 263 static int
 264 sysctl_devstat(SYSCTL_HANDLER_ARGS)
 265 {
 266         int error, i;
 267         struct devstat *nds;
 268         struct devstatlist *devstat_head;
 269
 270         if (devstat_num_devs == 0)
 271                 return(EINVAL);
 272
 273         error = 0;
 274         devstat_head = &device_statq;
 275
 276         /*
 277          * First push out the generation number.
 278          */
 279         error = SYSCTL_OUT(req, &devstat_generation, sizeof(long));
 280
 281         /*
 282          * Now push out all the devices.
 283          */
 284         for (i = 0, nds = STAILQ_FIRST(devstat_head);
 285             (nds != NULL) && (i < devstat_num_devs) && (error == 0);
 286              nds = STAILQ_NEXT(nds, dev_links), i++)
 287                 error = SYSCTL_OUT(req, nds, sizeof(struct devstat));
 288
 289         return(error);
 290 }
 291
 292 /*
 293  * Sysctl entries for devstat.  The first one is a node that all the rest
 294  * hang off of.
 295  */
 296 SYSCTL_NODE(_kern, OID_AUTO, devstat, CTLFLAG_RD, 0, "Device Statistics");
 297
 298 SYSCTL_PROC(_kern_devstat, OID_AUTO, all, CTLFLAG_RD|CTLTYPE_OPAQUE,
 299     0, 0, sysctl_devstat, "S,devstat", "All devices in the devstat list");
 300 /*
 301  * Export the number of devices in the system so that userland utilities
 302  * can determine how much memory to allocate to hold all the devices.
 303  */
 304 SYSCTL_INT(_kern_devstat, OID_AUTO, numdevs, CTLFLAG_RD,
 305     &devstat_num_devs, 0, "Number of devices in the devstat list");
 306 SYSCTL_LONG(_kern_devstat, OID_AUTO, generation, CTLFLAG_RD,
 307     &devstat_generation, 0, "Devstat list generation");
 308 SYSCTL_INT(_kern_devstat, OID_AUTO, version, CTLFLAG_RD,
 309     &devstat_version, 0, "Devstat list version number");