btt/mmap.c

   1 /*
   2  * blktrace output analysis: generate a timeline & gather statistics
   3  *
   4  * Copyright (C) 2006 Alan D. Brunelle <Alan.Brunelle@hp.com>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <unistd.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <sys/mman.h>
  28 #include <string.h>
  29
  30 #include "blktrace.h"
  31 #include "globals.h"
  32
  33 #define DEF_LEN (16 * 1024 * 1024)
  34
  35 static int fd;
  36 static void *cur_map = MAP_FAILED;
  37 static off_t cur_min, cur, cur_max, total_size;
  38 static size_t len;
  39 static struct blk_io_trace *next_t;
  40 static long pgsz;
  41
  42 int data_is_native = -1;
  43
  44 static inline size_t min_len(size_t a, size_t b) { return a < b ? a : b; }
  45
  46 static inline size_t convert_to_cpu(struct blk_io_trace *t,
  47                                     struct blk_io_trace *tp,
  48                                     void **pdu)
  49 {
  50         if (data_is_native == -1)
  51                 check_data_endianness(t->magic);
  52
  53         if (data_is_native)
  54                 memcpy(tp, t, sizeof(*tp));
  55         else {
  56                 tp->magic       = be32_to_cpu(t->magic);
  57                 tp->sequence    = be32_to_cpu(t->sequence);
  58                 tp->time        = be64_to_cpu(t->time);
  59                 tp->sector      = be64_to_cpu(t->sector);
  60                 tp->bytes       = be32_to_cpu(t->bytes);
  61                 tp->action      = be32_to_cpu(t->action);
  62                 tp->pid         = be32_to_cpu(t->pid);
  63                 tp->device      = be32_to_cpu(t->device);
  64                 tp->cpu         = be16_to_cpu(t->cpu);
  65                 tp->error       = be16_to_cpu(t->error);
  66                 tp->pdu_len     = be16_to_cpu(t->pdu_len);
  67         }
  68
  69         if (tp->pdu_len) {
  70                 *pdu = malloc(tp->pdu_len);
  71                 memcpy(*pdu, t+1, tp->pdu_len);
  72         }
  73         else
  74                 *pdu = NULL;
  75
  76         return sizeof(*tp) + tp->pdu_len;
  77 }
  78
  79 static int move_map(void)
  80 {
  81         if (cur_map != MAP_FAILED)
  82                 munmap(cur_map, len);
  83
  84         cur_min = (cur & ~(pgsz-1));
  85         len = min_len(DEF_LEN, total_size - cur_min);
  86         if (len < sizeof(*next_t))
  87                 return 0;
  88
  89         cur_map = mmap(NULL, len, PROT_READ, MAP_SHARED, fd,
  90                        cur_min);
  91         if (cur_map == MAP_FAILED) {
  92                 perror("mmap");
  93                 exit(1);
  94         }
  95
  96         cur_max = cur_min + len;
  97         return (cur < cur_max);
  98 }
  99
 100 void setup_ifile(char *fname)
 101 {
 102         struct stat buf;
 103
 104         pgsz = sysconf(_SC_PAGESIZE);
 105
 106         fd = my_open(fname, O_RDONLY);
 107         if (fd < 0) {
 108                 perror(fname);
 109                 exit(1);
 110         }
 111         if (fstat(fd, &buf) < 0) {
 112                 perror(fname);
 113                 exit(1);
 114         }
 115         total_size = buf.st_size;
 116
 117         if (!move_map())
 118                 exit(0);
 119 }
 120
 121 void cleanup_ifile(void)
 122 {
 123         if (cur_map != MAP_FAILED)
 124                 munmap(cur_map, len);
 125         close(fd);
 126 }
 127
 128 int next_trace(struct blk_io_trace *t, void **pdu)
 129 {
 130         size_t this_len;
 131
 132         if ((cur + 512) > cur_max)
 133                 if (!move_map())
 134                         return 0;
 135
 136         next_t = cur_map + (cur - cur_min);
 137         this_len = convert_to_cpu(next_t, t, pdu);
 138         cur += this_len;
 139
 140         return 1;
 141 }
 142
 143 double pct_done(void)
 144 {
 145         return 100.0 * ((double)cur / (double)total_size);
 146 }