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                         printf("\n");
 127                         free(hist_path);
 128                 }
 129                 if (hist.head.flags & HAMMER_IOC_HISTORY_EOF)
 130                         break;
 131                 if (hist.head.flags & HAMMER_IOC_HISTORY_NEXT_KEY)
 132                         break;
 133                 if ((hist.head.flags & HAMMER_IOC_HISTORY_NEXT_TID) == 0)
 134                         break;
 135                 hist.beg_tid = hist.nxt_tid;
 136                 if (ioctl(fd, HAMMERIOC_GETHISTORY, &hist) < 0) {
 137                         printf("    error: %s\n", strerror(errno));
 138                         break;
 139                 }
 140         }
 141         printf("}\n");
 142         close(fd);
 143 }
 144
 145 static int
 146 parse_attr(const char *s, cmd_attr_t *ca)
 147 {
 148         long long offset;
 149         long length;
 150         char *rptr;
 151
 152         ca->offset = -1;  /* Don't use offset as a key */
 153         ca->length = 32;  /* Default dump size */
 154
 155         if (*s != '@')
 156                 return(-1);  /* not parsed */
 157
 158         errno = 0;  /* clear */
 159         offset = strtoll(s + 1, &rptr, 0);
 160         if (test_strtoll(errno, offset)) {
 161                 *rptr = '\0';  /* side effect */
 162                 err(1, "%s", s);
 163         }
 164         ca->offset = offset;
 165
 166         if (*rptr == ',') {
 167                 errno = 0;  /* clear */
 168                 length = strtol(rptr + 1, NULL, 0);
 169                 if (test_strtol(errno, length))
 170                         err(1, "%s", rptr);
 171                 if (length >= 0)
 172                         ca->length = length;
 173         }
 174
 175         return(0);
 176 }
 177
 178 static int
 179 parse_attr_path(const char *s, cmd_attr_t *ca)
 180 {
 181         int length, ret;
 182         char *p;
 183         struct stat st;
 184
 185         ca->path = NULL;
 186
 187         if (stat(s, &st) == 0)
 188                 return(-1);  /* real path */
 189
 190         p = strstr(s, "@");
 191         if (p == NULL || p == s)
 192                 return(-1);  /* no attr specified */
 193
 194         ret = parse_attr(p, ca);
 195
 196         length = p - s + 1;
 197         ca->path = calloc(1, length);
 198         strncpy(ca->path, s, length - 1);
 199
 200         return(ret);
 201 }
 202
 203 static void
 204 dumpat(const char *path, off_t off, long len)
 205 {
 206         char buf[1024];
 207         int fd;
 208         int n;
 209         int r;
 210
 211         fd = open(path, O_RDONLY);
 212         if (fd < 0)
 213                 return;
 214         lseek(fd, off, 0);
 215         while (len) {
 216                 n = (len > (int)sizeof(buf)) ? (int)sizeof(buf) : len;
 217                 r = read(fd, buf, n);
 218                 if (r <= 0)
 219                         break;
 220                 len -= r;
 221                 for (n = 0; n < r; ++n) {
 222                         if (isprint(buf[n]))
 223                                 putc(buf[n], stdout);
 224                         else
 225                                 putc('.', stdout);
 226                 }
 227         }
 228         close(fd);
 229 }
 230
 231 /*
 232  * Return a human-readable timestamp
 233  */
 234 static const char *
 235 timestr32(uint32_t time32)
 236 {
 237         static char timebuf[64];
 238         time_t t = (time_t)time32;
 239         struct tm *tp;
 240
 241         tp = localtime(&t);
 242         strftime(timebuf, sizeof(timebuf), "%d-%b-%Y %H:%M:%S", tp);
 243         return(timebuf);
 244 }
 245
 246 /*
 247  * Return non-zero on either overflow or underflow
 248  */
 249 static __inline int
 250 test_strtol(int res, long val)
 251 {
 252         return(res == ERANGE && (val == LONG_MIN || val == LONG_MAX));
 253 }
 254
 255 static __inline int
 256 test_strtoll(int res, long long val)
 257 {
 258         return(res == ERANGE && (val == LLONG_MIN || val == LLONG_MAX));
 259 }