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