sbin/hammer/cmd_history.c

   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_history.c,v 1.4 2008/06/24 17:40:21 dillon Exp $
  35  */
  36
  37 #include "hammer.h"
  38
  39 typedef struct cmd_attr {
  40         char *path;
  41         int64_t offset;
  42         long length;
  43 } cmd_attr_t;
  44
  45 static void hammer_do_history(const char *path, off_t off, long len);
  46 static int parse_attr(const char *s, cmd_attr_t *ca);
  47 static int parse_attr_path(const char *s, cmd_attr_t *ca);
  48 static void dumpat(const char *path, off_t off, long len);
  49 static const char *timestr32(uint32_t time32);
  50 static __inline int test_strtol(int res, long val);
  51 static __inline int test_strtoll(int res, long long val);
  52
  53 /*
  54  * history <file1> ... <fileN>
  55  */
  56 void
  57 hammer_cmd_history(const char *offset_str, char **av, int ac)
  58 {
  59         int i;
  60         int old_behavior = 0;
  61         cmd_attr_t ca;
  62
  63         bzero(&ca, sizeof(ca));
  64         if (parse_attr(offset_str, &ca) == 0)
  65                 old_behavior = 1;
  66
  67         for (i = 0; i < ac; ++i) {
  68                 if (!old_behavior)
  69                         parse_attr_path(av[i], &ca);
  70                 if (ca.path == NULL)
  71                         ca.path = strdup(av[i]);
  72                 hammer_do_history(ca.path, ca.offset, ca.length);
  73                 free(ca.path);
  74                 ca.path = NULL;
  75         }
  76 }
  77
  78 static
  79 void
  80 hammer_do_history(const char *path, off_t off, long len)
  81 {
  82         struct hammer_ioc_history hist;
  83         const char *status;
  84         int fd;
  85         int i;
  86
  87         printf("%s\t", path);
  88         fd = open(path, O_RDONLY);
  89         if (fd < 0) {
  90                 printf("%s\n", strerror(errno));
  91                 return;
  92         }
  93         bzero(&hist, sizeof(hist));
  94         hist.beg_tid = HAMMER_MIN_TID;
  95         hist.end_tid = HAMMER_MAX_TID;
  96
  97         if (off >= 0) {
  98                 hist.head.flags |= HAMMER_IOC_HISTORY_ATKEY;
  99                 hist.key = off;
 100                 hist.nxt_key = off + 1;
 101         }
 102
 103
 104         if (ioctl(fd, HAMMERIOC_GETHISTORY, &hist) < 0) {
 105                 printf("%s\n", strerror(errno));
 106                 close(fd);
 107                 return;
 108         }
 109         status = ((hist.head.flags & HAMMER_IOC_HISTORY_UNSYNCED) ?
 110                  "dirty" : "clean");
 111         printf("%016jx %s {\n", (uintmax_t)hist.obj_id, status);
 112         for (;;) {
 113                 for (i = 0; i < hist.count; ++i) {
 114                         char *hist_path = NULL;
 115
 116                         asprintf(&hist_path, "%s@@0x%016jx",
 117                                  path, (uintmax_t)hist.hist_ary[i].tid);
 118                         printf("    %016jx %s",
 119                                (uintmax_t)hist.hist_ary[i].tid,
 120                                timestr32(hist.hist_ary[i].time32));
 121                         if (off >= 0) {
 122                                 if (VerboseOpt) {
 123                                         printf(" '");
 124                                         dumpat(hist_path, off, len);
 125                                         printf("'");
 126                                 }
 127                         }
 128                         printf("\n");
 129                         free(hist_path);
 130                 }
 131                 if (hist.head.flags & HAMMER_IOC_HISTORY_EOF)
 132                         break;
 133                 if (hist.head.flags & HAMMER_IOC_HISTORY_NEXT_KEY)
 134                         break;
 135                 if ((hist.head.flags & HAMMER_IOC_HISTORY_NEXT_TID) == 0)
 136                         break;
 137                 hist.beg_tid = hist.nxt_tid;
 138                 if (ioctl(fd, HAMMERIOC_GETHISTORY, &hist) < 0) {
 139                         printf("    error: %s\n", strerror(errno));
 140                         break;
 141                 }
 142         }
 143         printf("}\n");
 144         close(fd);
 145 }
 146
 147 static
 148 int
 149 parse_attr(const char *s, cmd_attr_t *ca)
 150 {
 151         long long offset;
 152         long length;
 153         char *rptr;
 154
 155         ca->offset = -1;  /* Don't use offset as a key */
 156         ca->length = 32;  /* Default dump size */
 157
 158         if (*s != '@')
 159                 return(-1);  /* not parsed */
 160
 161         errno = 0;  /* clear */
 162         offset = strtoll(s + 1, &rptr, 0);
 163         if (test_strtoll(errno, offset)) {
 164                 *rptr = '\0';  /* side effect */
 165                 err(1, "%s", s);
 166                 /* not reached */
 167         }
 168         ca->offset = offset;
 169
 170         if (*rptr == ',') {
 171                 errno = 0;  /* clear */
 172                 length = strtol(rptr + 1, NULL, 0);
 173                 if (test_strtol(errno, length)) {
 174                         err(1, "%s", rptr);
 175                         /* not reached */
 176                 }
 177                 if (length >= 0)
 178                         ca->length = length;
 179         }
 180
 181         return(0);
 182 }
 183
 184 static
 185 int
 186 parse_attr_path(const char *s, cmd_attr_t *ca)
 187 {
 188         int length, ret;
 189         char *p;
 190         struct stat st;
 191
 192         ca->path = NULL;
 193
 194         if (stat(s, &st) == 0)
 195                 return(-1);  /* real path */
 196
 197         p = strstr(s, "@");
 198         if (p == NULL || p == s)
 199                 return(-1);  /* no attr specified */
 200
 201         ret = parse_attr(p, ca);
 202
 203         length = p - s + 1;
 204         ca->path = calloc(1, length);
 205         strncpy(ca->path, s, length - 1);
 206
 207         return(ret);
 208 }
 209
 210 static
 211 void
 212 dumpat(const char *path, off_t off, long len)
 213 {
 214         char buf[1024];
 215         int fd;
 216         int n;
 217         int r;
 218
 219         fd = open(path, O_RDONLY);
 220         if (fd < 0)
 221                 return;
 222         lseek(fd, off, 0);
 223         while (len) {
 224                 n = (len > (int)sizeof(buf)) ? (int)sizeof(buf) : len;
 225                 r = read(fd, buf, n);
 226                 if (r <= 0)
 227                         break;
 228                 len -= r;
 229                 for (n = 0; n < r; ++n) {
 230                         if (isprint(buf[n]))
 231                                 putc(buf[n], stdout);
 232                         else
 233                                 putc('.', stdout);
 234                 }
 235         }
 236         close(fd);
 237 }
 238
 239 /*
 240  * Return a human-readable timestamp
 241  */
 242 static
 243 const char *
 244 timestr32(uint32_t time32)
 245 {
 246         static char timebuf[64];
 247         time_t t = (time_t)time32;
 248         struct tm *tp;
 249
 250         tp = localtime(&t);
 251         strftime(timebuf, sizeof(timebuf), "%d-%b-%Y %H:%M:%S", tp);
 252         return(timebuf);
 253 }
 254
 255 /*
 256  * Return non-zero on either overflow or underflow
 257  */
 258 static __inline
 259 int
 260 test_strtol(int res, long val)
 261 {
 262         return(res == ERANGE && (val == LONG_MIN || val == LONG_MAX));
 263 }
 264
 265 static __inline
 266 int
 267 test_strtoll(int res, long long val)
 268 {
 269         return(res == ERANGE && (val == LLONG_MIN || val == LLONG_MAX));
 270 }