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                 err(1, "%s", s);
 164         }
 165         ca->offset = offset;
 166
 167         if (*rptr == ',') {
 168                 errno = 0;  /* clear */
 169                 length = strtol(rptr + 1, NULL, 0);
 170                 if (test_strtol(errno, length))
 171                         err(1, "%s", rptr);
 172                 if (length >= 0)
 173                         ca->length = length;
 174         }
 175
 176         return(0);
 177 }
 178
 179 static int
 180 parse_attr_path(const char *s, cmd_attr_t *ca)
 181 {
 182         int length, ret;
 183         char *p;
 184         struct stat st;
 185
 186         ca->path = NULL;
 187
 188         if (stat(s, &st) == 0)
 189                 return(-1);  /* real path */
 190
 191         p = strstr(s, "@");
 192         if (p == NULL || p == s)
 193                 return(-1);  /* no attr specified */
 194
 195         ret = parse_attr(p, ca);
 196
 197         length = p - s + 1;
 198         ca->path = calloc(1, length);
 199         strncpy(ca->path, s, length - 1);
 200
 201         return(ret);
 202 }
 203
 204 static void
 205 dumpat(const char *path, off_t off, long len)
 206 {
 207         char buf[1024];
 208         int fd;
 209         int n;
 210         int r;
 211
 212         fd = open(path, O_RDONLY);
 213         if (fd < 0)
 214                 return;
 215         lseek(fd, off, 0);
 216         while (len) {
 217                 n = (len > (int)sizeof(buf)) ? (int)sizeof(buf) : len;
 218                 r = read(fd, buf, n);
 219                 if (r <= 0)
 220                         break;
 221                 len -= r;
 222                 for (n = 0; n < r; ++n) {
 223                         if (isprint(buf[n]))
 224                                 putc(buf[n], stdout);
 225                         else
 226                                 putc('.', stdout);
 227                 }
 228         }
 229         close(fd);
 230 }
 231
 232 /*
 233  * Return a human-readable timestamp
 234  */
 235 static const char *
 236 timestr32(uint32_t time32)
 237 {
 238         static char timebuf[64];
 239         time_t t = (time_t)time32;
 240         struct tm *tp;
 241
 242         tp = localtime(&t);
 243         strftime(timebuf, sizeof(timebuf), "%d-%b-%Y %H:%M:%S", tp);
 244         return(timebuf);
 245 }
 246
 247 /*
 248  * Return non-zero on either overflow or underflow
 249  */
 250 static __inline int
 251 test_strtol(int res, long val)
 252 {
 253         return(res == ERANGE && (val == LONG_MIN || val == LONG_MAX));
 254 }
 255
 256 static __inline int
 257 test_strtoll(int res, long long val)
 258 {
 259         return(res == ERANGE && (val == LLONG_MIN || val == LLONG_MAX));
 260 }