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 static void hammer_do_history(const char *path, off_t off, int len);
  40 static void dumpat(const char *path, off_t off, int len);
  41 static const char *timestr32(u_int32_t time32);
  42
  43 /*
  44  * history <file1> ... <fileN>
  45  */
  46 void
  47 hammer_cmd_history(const char *offset_str, char **av, int ac)
  48 {
  49         off_t off;
  50         int i = 0;
  51         int len;
  52         char *rptr;
  53
  54         len = 32;
  55         if (*offset_str == '@') {
  56                 off = strtoll(offset_str + 1, &rptr, 0);
  57                 if (*rptr == ',')
  58                         len = strtol(rptr + 1, NULL, 0);
  59                 i = 1;
  60         } else {
  61                 off = -1;
  62         }
  63
  64         for (; i < ac; ++i)
  65                 hammer_do_history(av[i], off, len);
  66 }
  67
  68 static void
  69 hammer_do_history(const char *path, off_t off, int len)
  70 {
  71         struct hammer_ioc_history hist;
  72         const char *status;
  73         int fd;
  74         int i;
  75
  76         printf("%s\t", path);
  77         fd = open(path, O_RDONLY);
  78         if (fd < 0) {
  79                 printf("%s\n", strerror(errno));
  80                 return;
  81         }
  82         bzero(&hist, sizeof(hist));
  83         hist.beg_tid = HAMMER_MIN_TID;
  84         hist.end_tid = HAMMER_MAX_TID;
  85
  86         if (off >= 0) {
  87                 hist.head.flags |= HAMMER_IOC_HISTORY_ATKEY;
  88                 hist.key = off;
  89                 hist.nxt_key = off + 1;
  90         }
  91
  92
  93         if (ioctl(fd, HAMMERIOC_GETHISTORY, &hist) < 0) {
  94                 printf("%s\n", strerror(errno));
  95                 close(fd);
  96                 return;
  97         }
  98         status = ((hist.head.flags & HAMMER_IOC_HISTORY_UNSYNCED) ?
  99                  "dirty" : "clean");
 100         printf("%016jx %s {\n", (uintmax_t)hist.obj_id, status);
 101         for (;;) {
 102                 for (i = 0; i < hist.count; ++i) {
 103                         char *hist_path = NULL;
 104
 105                         asprintf(&hist_path, "%s@@0x%016jx",
 106                                  path, (uintmax_t)hist.hist_ary[i].tid);
 107                         printf("    %016jx %s",
 108                                (uintmax_t)hist.hist_ary[i].tid,
 109                                timestr32(hist.hist_ary[i].time32));
 110                         if (off >= 0) {
 111                                 if (VerboseOpt) {
 112                                         printf(" '");
 113                                         dumpat(hist_path, off, len);
 114                                         printf("'");
 115                                 }
 116                         }
 117                         printf("\n");
 118                         free(hist_path);
 119                 }
 120                 if (hist.head.flags & HAMMER_IOC_HISTORY_EOF)
 121                         break;
 122                 if (hist.head.flags & HAMMER_IOC_HISTORY_NEXT_KEY)
 123                         break;
 124                 if ((hist.head.flags & HAMMER_IOC_HISTORY_NEXT_TID) == 0)
 125                         break;
 126                 hist.beg_tid = hist.nxt_tid;
 127                 if (ioctl(fd, HAMMERIOC_GETHISTORY, &hist) < 0) {
 128                         printf("    error: %s\n", strerror(errno));
 129                         break;
 130                 }
 131         }
 132         printf("}\n");
 133         close(fd);
 134 }
 135
 136 static void
 137 dumpat(const char *path, off_t off, int len)
 138 {
 139         char buf[1024];
 140         int fd;
 141         int n;
 142         int r;
 143
 144         fd = open(path, O_RDONLY);
 145         if (fd < 0)
 146                 return;
 147         lseek(fd, off, 0);
 148         while (len) {
 149                 n = (len > (int)sizeof(buf)) ? (int)sizeof(buf) : len;
 150                 r = read(fd, buf, n);
 151                 if (r <= 0)
 152                         break;
 153                 len -= r;
 154                 for (n = 0; n < r; ++n) {
 155                         if (isprint(buf[n]))
 156                                 putc(buf[n], stdout);
 157                         else
 158                                 putc('.', stdout);
 159                 }
 160         }
 161 }
 162
 163 /*
 164  * Return a human-readable timestamp
 165  */
 166 static const char *
 167 timestr32(u_int32_t time32)
 168 {
 169         static char timebuf[64];
 170         time_t t = (time_t)time32;
 171         struct tm *tp;
 172
 173         tp = localtime(&t);
 174         strftime(timebuf, sizeof(timebuf), "%d-%b-%Y %H:%M:%S", tp);
 175         return(timebuf);
 176 }