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 <assert.h>
  28 #include <sys/mman.h>
  29 #include <string.h>
  30
  31 #include "blktrace.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         assert(CHECK_MAGIC(tp));
  70         assert((tp->magic & 0xff) == SUPPORTED_VERSION);
  71
  72         if (tp->pdu_len) {
  73                 *pdu = malloc(tp->pdu_len);
  74                 memcpy(*pdu, t+1, tp->pdu_len);
  75         }
  76         else
  77                 *pdu = NULL;
  78
  79         return sizeof(*tp) + tp->pdu_len;
  80 }
  81
  82 static int move_map(void)
  83 {
  84         if (cur_map != MAP_FAILED)
  85                 munmap(cur_map, len);
  86
  87         cur_min = (cur & ~(pgsz-1));
  88         len = min_len(DEF_LEN, total_size - cur_min);
  89         if (len < sizeof(*next_t))
  90                 return 0;
  91
  92         cur_map = mmap(NULL, len, PROT_READ, MAP_SHARED, fd,
  93                        cur_min);
  94         if (cur_map == MAP_FAILED) {
  95                 perror("mmap");
  96                 exit(1);
  97         }
  98
  99         cur_max = cur_min + len;
 100         return (cur < cur_max);
 101 }
 102
 103 void setup_ifile(char *fname)
 104 {
 105         struct stat buf;
 106
 107         pgsz = sysconf(_SC_PAGESIZE);
 108
 109         fd = open(fname, O_RDONLY);
 110         if (fd < 0) {
 111                 perror(fname);
 112                 exit(1);
 113         }
 114         if (fstat(fd, &buf) < 0) {
 115                 perror(fname);
 116                 exit(1);
 117         }
 118         total_size = buf.st_size;
 119
 120         if (!move_map())
 121                 exit(0);
 122 }
 123
 124 void cleanup_ifile(void)
 125 {
 126         if (cur_map != MAP_FAILED)
 127                 munmap(cur_map, len);
 128         close(fd);
 129 }
 130
 131 int next_trace(struct blk_io_trace *t, void **pdu)
 132 {
 133         size_t this_len;
 134
 135         if ((cur + 512) > cur_max)
 136                 if (!move_map())
 137                         return 0;
 138
 139         next_t = cur_map + (cur - cur_min);
 140         this_len = convert_to_cpu(next_t, t, pdu);
 141         cur += this_len;
 142
 143         return 1;
 144 }