sbin/hammer2: Whitespace cleanups/etc for cmd_debug.c
[dragonfly.git] / sbin / hammer2 / cmd_debug.c
1 /*
2  * Copyright (c) 2011-2012 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@dragonflybsd.org>
6  * by Venkatesh Srinivas <vsrinivas@dragonflybsd.org>
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  * 3. Neither the name of The DragonFly Project nor the names of its
19  *    contributors may be used to endorse or promote products derived
20  *    from this software without specific, prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35
36 #include "hammer2.h"
37
38 static int show_tab = 2;
39
40 static void shell_msghandler(dmsg_msg_t *msg, int unmanaged);
41 static void shell_ttymsg(dmsg_iocom_t *iocom);
42 static void CountFreeBlocks(hammer2_bmap_data_t *bmap,
43                 hammer2_off_t *accum16, hammer2_off_t *accum64);
44
45 /************************************************************************
46  *                                  SHELL                               *
47  ************************************************************************/
48
49 int
50 cmd_shell(const char *hostname)
51 {
52         dmsg_master_service_info_t *info;
53         pthread_t thread;
54         int fd;
55
56         fd = dmsg_connect(hostname);
57         if (fd < 0)
58                 return 1;
59
60         info = malloc(sizeof(*info));
61         bzero(info, sizeof(*info));
62         info->fd = fd;
63         info->detachme = 0;
64         info->usrmsg_callback = shell_msghandler;
65         info->altmsg_callback = shell_ttymsg;
66         info->label = strdup("debug");
67         pthread_create(&thread, NULL, dmsg_master_service, info);
68         pthread_join(thread, NULL);
69
70         return 0;
71 }
72
73 #if 0
74 int
75 cmd_shell(const char *hostname)
76 {
77         struct dmsg_iocom iocom;
78         dmsg_msg_t *msg;
79         int fd;
80
81         /*
82          * Connect to the target
83          */
84         fd = dmsg_connect(hostname);
85         if (fd < 0)
86                 return 1;
87
88         /*
89          * Initialize the session and transmit an empty DMSG_DBG_SHELL
90          * to cause the remote end to generate a prompt.
91          */
92         dmsg_iocom_init(&iocom, fd, 0,
93                         NULL,
94                         shell_rcvmsg,
95                         hammer2_shell_parse,
96                         shell_ttymsg);
97         fcntl(0, F_SETFL, O_NONBLOCK);
98         printf("debug: connected\n");
99
100         msg = dmsg_msg_alloc(&iocom.state0, 0, DMSG_DBG_SHELL, NULL, NULL);
101         dmsg_msg_write(msg);
102         dmsg_iocom_core(&iocom);
103         fprintf(stderr, "debug: disconnected\n");
104         close(fd);
105         return 0;
106 }
107 #endif
108
109 /*
110  * Debug session front-end
111  *
112  * Callback from dmsg_iocom_core() when messages might be present
113  * on the socket.
114  */
115 static
116 void
117 shell_msghandler(dmsg_msg_t *msg, int unmanaged)
118 {
119         dmsg_msg_t *nmsg;
120
121         switch(msg->tcmd) {
122 #if 0
123         case DMSG_LNK_ERROR:
124         case DMSG_LNK_ERROR | DMSGF_REPLY:
125                 /*
126                  * One-way non-transactional LNK_ERROR messages typically
127                  * indicate a connection failure.  Error code 0 is used by
128                  * the debug shell to indicate no more results from last cmd.
129                  */
130                 if (msg->any.head.error) {
131                         fprintf(stderr, "Stream failure: %s\n",
132                                 dmsg_msg_str(msg));
133                 } else {
134                         write(1, "debug> ", 7);
135                 }
136                 break;
137         case DMSG_LNK_ERROR | DMSGF_DELETE:
138                 /* ignore termination of LNK_CONN */
139                 break;
140 #endif
141         case DMSG_DBG_SHELL:
142                 /*
143                  * We send the commands, not accept them.
144                  * (one-way message, not transactional)
145                  */
146                 if (unmanaged)
147                         dmsg_msg_reply(msg, DMSG_ERR_NOSUPP);
148                 break;
149         case DMSG_DBG_SHELL | DMSGF_REPLY:
150                 /*
151                  * A reply from the remote is data we copy to stdout.
152                  * (one-way message, not transactional)
153                  */
154                 if (msg->aux_size) {
155                         msg->aux_data[msg->aux_size - 1] = 0;
156                         write(1, msg->aux_data, strlen(msg->aux_data));
157                 }
158                 break;
159 #if 1
160         case DMSG_LNK_CONN | DMSGF_CREATE:
161                 fprintf(stderr, "Debug Shell received LNK_CONN\n");
162                 nmsg = dmsg_msg_alloc(&msg->state->iocom->state0, 0,
163                                       DMSG_DBG_SHELL,
164                                       NULL, NULL);
165                 dmsg_msg_write(nmsg);
166                 dmsg_msg_reply(msg, DMSG_ERR_NOSUPP);
167                 break;
168         case DMSG_LNK_CONN | DMSGF_DELETE:
169                 break;
170 #endif
171         default:
172                 /*
173                  * Ignore any unknown messages, Terminate any unknown
174                  * transactions with an error.
175                  */
176                 fprintf(stderr, "Unknown message: %s\n", dmsg_msg_str(msg));
177                 if (unmanaged) {
178                         if (msg->any.head.cmd & DMSGF_CREATE)
179                                 dmsg_msg_reply(msg, DMSG_ERR_NOSUPP);
180                         if (msg->any.head.cmd & DMSGF_DELETE)
181                                 dmsg_msg_reply(msg, DMSG_ERR_NOSUPP);
182                 }
183                 break;
184         }
185 }
186
187 /*
188  * Debug session front-end
189  */
190 static
191 void
192 shell_ttymsg(dmsg_iocom_t *iocom)
193 {
194         dmsg_state_t *pstate;
195         dmsg_msg_t *msg;
196         char buf[256];
197         char *cmd;
198         size_t len;
199
200         if (fgets(buf, sizeof(buf), stdin) != NULL) {
201                 if (buf[0] == '@') {
202                         pstate = dmsg_findspan(strtok(buf + 1, " \t\n"));
203                         cmd = strtok(NULL, "\n");
204                 } else {
205                         pstate = &iocom->state0;
206                         cmd = strtok(buf, "\n");
207                 }
208                 if (cmd && pstate) {
209                         len = strlen(cmd) + 1;
210                         msg = dmsg_msg_alloc(pstate, len, DMSG_DBG_SHELL,
211                                              NULL, NULL);
212                         bcopy(cmd, msg->aux_data, len);
213                         dmsg_msg_write(msg);
214                 } else if (cmd) {
215                         fprintf(stderr, "@msgid not found\n");
216                 } else {
217                         /*
218                          * This should cause the remote end to generate
219                          * a debug> prompt (and thus shows that there is
220                          * connectivity).
221                          */
222                         msg = dmsg_msg_alloc(pstate, 0, DMSG_DBG_SHELL,
223                                              NULL, NULL);
224                         dmsg_msg_write(msg);
225                 }
226         } else if (feof(stdin)) {
227                 /*
228                  * Set EOF flag without setting any error code for normal
229                  * EOF.
230                  */
231                 iocom->flags |= DMSG_IOCOMF_EOF;
232         } else {
233                 clearerr(stdin);
234         }
235 }
236
237 /*
238  * Debug session back-end (on remote side)
239  */
240 static void shell_span(dmsg_msg_t *msg, char *cmdbuf);
241 static void shell_ping(dmsg_msg_t *msg, char *cmdbuf);
242
243 void
244 hammer2_shell_parse(dmsg_msg_t *msg, int unmanaged)
245 {
246         dmsg_iocom_t *iocom = msg->state->iocom;
247         char *cmdbuf;
248         char *cmdp;
249         uint32_t cmd;
250
251         /*
252          * Filter on debug shell commands and ping responses only
253          */
254         cmd = msg->any.head.cmd;
255         if ((cmd & DMSGF_CMDSWMASK) == (DMSG_LNK_PING | DMSGF_REPLY)) {
256                 dmsg_printf(iocom, "ping reply\n");
257                 return;
258         }
259
260         if ((cmd & DMSGF_PROTOS) != DMSG_PROTO_DBG) {
261                 if (unmanaged)
262                         dmsg_msg_reply(msg, DMSG_ERR_NOSUPP);
263                 return;
264         }
265         if ((cmd & DMSGF_CMDSWMASK) != DMSG_DBG_SHELL) {
266                 if (unmanaged)
267                         dmsg_msg_reply(msg, DMSG_ERR_NOSUPP);
268                 return;
269         }
270
271         /*
272          * Debug shell command
273          */
274         cmdbuf = msg->aux_data;
275         cmdp = strsep(&cmdbuf, " \t");
276
277         if (cmdp == NULL || *cmdp == 0) {
278                 ;
279         } else if (strcmp(cmdp, "ping") == 0) {
280                 shell_ping(msg, cmdbuf);
281         } else if (strcmp(cmdp, "span") == 0) {
282                 shell_span(msg, cmdbuf);
283         } else if (strcmp(cmdp, "tree") == 0) {
284                 dmsg_shell_tree(iocom, cmdbuf); /* dump spanning tree */
285         } else if (strcmp(cmdp, "help") == 0 || strcmp(cmdp, "?") == 0) {
286                 dmsg_printf(iocom, "help            Command help\n");
287                 dmsg_printf(iocom, "span <host>     Span to target host\n");
288                 dmsg_printf(iocom, "tree            Dump spanning tree\n");
289                 dmsg_printf(iocom, "@span <cmd>     Issue via circuit\n");
290         } else {
291                 dmsg_printf(iocom, "Unrecognized command: %s\n", cmdp);
292         }
293         dmsg_printf(iocom, "debug> ");
294 }
295
296 static void
297 shell_ping(dmsg_msg_t *msg, char *cmdbuf __unused)
298 {
299         dmsg_iocom_t *iocom = msg->state->iocom;
300         dmsg_msg_t *m2;
301
302         dmsg_printf(iocom, "sending ping\n");
303         m2 = dmsg_msg_alloc(msg->state, 0, DMSG_LNK_PING, NULL, NULL);
304         dmsg_msg_write(m2);
305 }
306
307 static void
308 shell_span(dmsg_msg_t *msg, char *cmdbuf)
309 {
310         dmsg_iocom_t *iocom = msg->state->iocom;
311         dmsg_master_service_info_t *info;
312         const char *hostname = strsep(&cmdbuf, " \t");
313         pthread_t thread;
314         int fd;
315
316         /*
317          * Connect to the target
318          */
319         if (hostname == NULL) {
320                 fd = -1;
321         } else {
322                 fd = dmsg_connect(hostname);
323         }
324
325         /*
326          * Start master service
327          */
328         if (fd < 0) {
329                 dmsg_printf(iocom, "Connection to %s failed\n", hostname);
330         } else {
331                 dmsg_printf(iocom, "Connected to %s\n", hostname);
332
333                 info = malloc(sizeof(*info));
334                 bzero(info, sizeof(*info));
335                 info->fd = fd;
336                 info->detachme = 1;
337                 info->usrmsg_callback = hammer2_shell_parse;
338                 info->label = strdup("client");
339
340                 pthread_create(&thread, NULL, dmsg_master_service, info);
341                 /*pthread_join(thread, &res);*/
342         }
343 }
344
345 /************************************************************************
346  *                              DEBUGSPAN                               *
347  ************************************************************************
348  *
349  * Connect to the target manually (not via the cluster list embedded in
350  * a hammer2 filesystem) and initiate the SPAN protocol.
351  */
352 int
353 cmd_debugspan(const char *hostname)
354 {
355         pthread_t thread;
356         int fd;
357         void *res;
358
359         /*
360          * Connect to the target
361          */
362         fd = dmsg_connect(hostname);
363         if (fd < 0)
364                 return 1;
365
366         printf("debugspan: connected to %s, starting CONN/SPAN\n", hostname);
367         pthread_create(&thread, NULL,
368                        dmsg_master_service, (void *)(intptr_t)fd);
369         pthread_join(thread, &res);
370         return(0);
371 }
372
373 /************************************************************************
374  *                                  SHOW                                *
375  ************************************************************************/
376
377 static void show_bref(hammer2_volume_data_t *voldata, int fd, int tab,
378                         int bi, hammer2_blockref_t *bref,
379                         int dofreemap, int norecurse);
380 static void tabprintf(int tab, const char *ctl, ...);
381
382 static int64_t TotalFreeAccum16;
383 static int64_t TotalFreeAccum64;
384
385 int
386 cmd_show(const char *devpath, int dofreemap)
387 {
388         hammer2_blockref_t broot;
389         hammer2_blockref_t best;
390         hammer2_media_data_t media;
391         int fd;
392         int i;
393         int best_i;
394         char *env;
395
396         TotalFreeAccum16 = 0;   /* includes TotalFreeAccum64 */
397         TotalFreeAccum64 = 0;
398
399         env = getenv("HAMMER2_SHOW_TAB");
400         if (env != NULL) {
401                 show_tab = (int)strtol(env, NULL, 0);
402                 if (errno || show_tab < 0 || show_tab > 8)
403                         show_tab = 2;
404         }
405
406         fd = open(devpath, O_RDONLY);
407         if (fd < 0) {
408                 perror("open");
409                 return 1;
410         }
411
412         /*
413          * Show the tree using the best volume header.
414          * -vvv will show the tree for all four volume headers.
415          */
416         best_i = -1;
417         bzero(&best, sizeof(best));
418         for (i = 0; i < HAMMER2_NUM_VOLHDRS; ++i) {
419                 bzero(&broot, sizeof(broot));
420                 broot.type = dofreemap ?
421                     HAMMER2_BREF_TYPE_FREEMAP : HAMMER2_BREF_TYPE_VOLUME;
422                 broot.data_off = (i * HAMMER2_ZONE_BYTES64) | HAMMER2_PBUFRADIX;
423                 lseek(fd, broot.data_off & ~HAMMER2_OFF_MASK_RADIX, 0);
424                 if (read(fd, &media, HAMMER2_PBUFSIZE) ==
425                     (ssize_t)HAMMER2_PBUFSIZE) {
426                         broot.mirror_tid = media.voldata.mirror_tid;
427                         if (best_i < 0 || best.mirror_tid < broot.mirror_tid) {
428                                 best_i = i;
429                                 best = broot;
430                         }
431                         if (VerboseOpt >= 3)
432                                 show_bref(&media.voldata, fd, 0, i, &broot,
433                                     dofreemap, 0);
434                 }
435         }
436         if (VerboseOpt < 3)
437                 show_bref(&media.voldata, fd, 0, best_i, &best, dofreemap, 0);
438         close(fd);
439
440         if (dofreemap && VerboseOpt < 3) {
441                 printf("Total free storage: %6.3fGB (%6.3fGB in 64KB chunks)\n",
442                        (double)TotalFreeAccum16 / (1024.0 * 1024.0 * 1024.0),
443                        (double)TotalFreeAccum64 / (1024.0 * 1024.0 * 1024.0));
444         }
445
446         return 0;
447 }
448
449 static void
450 show_bref(hammer2_volume_data_t *voldata, int fd, int tab,
451           int bi, hammer2_blockref_t *bref, int dofreemap, int norecurse)
452 {
453         hammer2_media_data_t media;
454         hammer2_blockref_t *bscan;
455         int bcount;
456         int i;
457         int didnl;
458         int namelen;
459         int obrace = 1;
460         int failed;
461         size_t bytes;
462         const char *type_str;
463         char *str = NULL;
464         uint32_t cv;
465         uint64_t cv64;
466
467         switch(bref->type) {
468         case HAMMER2_BREF_TYPE_EMPTY:
469                 type_str = "empty";
470                 break;
471         case HAMMER2_BREF_TYPE_DIRENT:
472                 type_str = "dirent";
473                 break;
474         case HAMMER2_BREF_TYPE_INODE:
475                 type_str = "inode";
476                 break;
477         case HAMMER2_BREF_TYPE_INDIRECT:
478                 type_str = "indblk";
479                 break;
480         case HAMMER2_BREF_TYPE_DATA:
481                 type_str = "data";
482                 break;
483         case HAMMER2_BREF_TYPE_VOLUME:
484                 type_str = "volume";
485                 break;
486         case HAMMER2_BREF_TYPE_FREEMAP:
487                 type_str = "freemap";
488                 break;
489         case HAMMER2_BREF_TYPE_FREEMAP_NODE:
490                 type_str = "fmapnode";
491                 break;
492         case HAMMER2_BREF_TYPE_FREEMAP_LEAF:
493                 type_str = "fbitmap";
494                 break;
495         default:
496                 type_str = "unknown";
497                 break;
498         }
499
500         tabprintf(tab,
501                   "%s.%-3d %016jx %016jx/%-2d "
502                   "mir=%016jx mod=%016jx leafcnt=%d ",
503                   type_str, bi, (intmax_t)bref->data_off,
504                   (intmax_t)bref->key, (intmax_t)bref->keybits,
505                   (intmax_t)bref->mirror_tid, (intmax_t)bref->modify_tid,
506                   bref->leaf_count);
507         tab += show_tab;
508         if (bref->flags)
509                 printf("flags=%02x ", bref->flags);
510         if (bref->type == HAMMER2_BREF_TYPE_FREEMAP_NODE ||
511             bref->type == HAMMER2_BREF_TYPE_FREEMAP_LEAF) {
512                 printf("bigmask=%08x avail=%ld ",
513                         bref->check.freemap.bigmask, bref->check.freemap.avail);
514         }
515
516         bytes = (bref->data_off & HAMMER2_OFF_MASK_RADIX);
517         if (bytes)
518                 bytes = (size_t)1 << bytes;
519         if (bytes) {
520                 hammer2_off_t io_off;
521                 hammer2_off_t io_base;
522                 size_t io_bytes;
523                 size_t boff;
524
525                 io_off = bref->data_off & ~HAMMER2_OFF_MASK_RADIX;
526                 io_base = io_off & ~(hammer2_off_t)(HAMMER2_MINIOSIZE - 1);
527                 boff = io_off - io_base;
528
529                 io_bytes = HAMMER2_MINIOSIZE;
530                 while (io_bytes + boff < bytes)
531                         io_bytes <<= 1;
532
533                 if (io_bytes > sizeof(media)) {
534                         printf("(bad block size %zd)\n", bytes);
535                         return;
536                 }
537                 if (bref->type != HAMMER2_BREF_TYPE_DATA || VerboseOpt >= 1) {
538                         lseek(fd, io_base, 0);
539                         if (read(fd, &media, io_bytes) != (ssize_t)io_bytes) {
540                                 printf("(media read failed)\n");
541                                 return;
542                         }
543                         if (boff)
544                                 bcopy((char *)&media + boff, &media, bytes);
545                 }
546         }
547
548         bscan = NULL;
549         bcount = 0;
550         didnl = 1;
551         namelen = 0;
552         failed = 0;
553
554         /*
555          * Check data integrity in verbose mode, otherwise we are just doing
556          * a quick meta-data scan.  Meta-data integrity is always checked.
557          * (Also see the check above that ensures the media data is loaded,
558          * otherwise there's no data to check!).
559          *
560          * WARNING! bref->check state may be used for other things when
561          *          bref has no data (bytes == 0).
562          */
563         if (bytes &&
564             (bref->type != HAMMER2_BREF_TYPE_DATA || VerboseOpt >= 1)) {
565                 switch(HAMMER2_DEC_CHECK(bref->methods)) {
566                 case HAMMER2_CHECK_NONE:
567                         printf("(meth %02x) ", bref->methods);
568                         break;
569                 case HAMMER2_CHECK_DISABLED:
570                         printf("(meth %02x) ", bref->methods);
571                         break;
572                 case HAMMER2_CHECK_ISCSI32:
573                         cv = hammer2_icrc32(&media, bytes);
574                         if (bref->check.iscsi32.value != cv) {
575                                 printf("(icrc %02x:%08x/%08x failed) ",
576                                        bref->methods,
577                                        bref->check.iscsi32.value,
578                                        cv);
579                                 failed = 1;
580                         } else {
581                                 printf("(meth %02x, iscsi32=%08x) ",
582                                        bref->methods, cv);
583                         }
584                         break;
585                 case HAMMER2_CHECK_XXHASH64:
586                         cv64 = XXH64(&media, bytes, XXH_HAMMER2_SEED);
587                         if (bref->check.xxhash64.value != cv64) {
588                                 printf("(xxhash64 %02x:%016jx/%016jx failed) ",
589                                        bref->methods,
590                                        bref->check.xxhash64.value,
591                                        cv64);
592                                 failed = 1;
593                         } else {
594                                 printf("(meth %02x, xxh=%016jx) ",
595                                        bref->methods, cv64);
596                         }
597                         break;
598                 case HAMMER2_CHECK_SHA192:
599                         printf("(meth %02x) ", bref->methods);
600                         break;
601                 case HAMMER2_CHECK_FREEMAP:
602                         cv = hammer2_icrc32(&media, bytes);
603                         if (bref->check.freemap.icrc32 != cv) {
604                                 printf("(fcrc %02x:%08x/%08x failed) ",
605                                         bref->methods,
606                                         bref->check.freemap.icrc32,
607                                         cv);
608                                 failed = 1;
609                         } else {
610                                 printf("(meth %02x, fcrc=%08x) ",
611                                         bref->methods, cv);
612                         }
613                         break;
614                 }
615         }
616
617         switch(bref->type) {
618         case HAMMER2_BREF_TYPE_INODE:
619                 if (!(media.ipdata.meta.op_flags & HAMMER2_OPFLAG_DIRECTDATA)) {
620                         bscan = &media.ipdata.u.blockset.blockref[0];
621                         bcount = HAMMER2_SET_COUNT;
622                 }
623                 break;
624         case HAMMER2_BREF_TYPE_INDIRECT:
625                 bscan = &media.npdata[0];
626                 bcount = bytes / sizeof(hammer2_blockref_t);
627                 break;
628         case HAMMER2_BREF_TYPE_VOLUME:
629                 bscan = &media.voldata.sroot_blockset.blockref[0];
630                 bcount = HAMMER2_SET_COUNT;
631                 break;
632         case HAMMER2_BREF_TYPE_FREEMAP:
633                 bscan = &media.voldata.freemap_blockset.blockref[0];
634                 bcount = HAMMER2_SET_COUNT;
635                 break;
636         case HAMMER2_BREF_TYPE_FREEMAP_NODE:
637                 bscan = &media.npdata[0];
638                 bcount = bytes / sizeof(hammer2_blockref_t);
639                 break;
640         }
641
642         if (QuietOpt > 0) {
643                 obrace = 0;
644                 printf("\n");
645                 goto skip_data;
646         }
647
648         switch(bref->type) {
649         case HAMMER2_BREF_TYPE_EMPTY:
650                 obrace = 0;
651                 break;
652         case HAMMER2_BREF_TYPE_DIRENT:
653                 printf("{\n");
654                 if (bref->embed.dirent.namlen <= sizeof(bref->check.buf)) {
655                         tabprintf(tab, "filename \"%*.*s\"\n",
656                                 bref->embed.dirent.namlen,
657                                 bref->embed.dirent.namlen,
658                                 bref->check.buf);
659                 } else {
660                         tabprintf(tab, "filename \"%*.*s\"\n",
661                                 bref->embed.dirent.namlen,
662                                 bref->embed.dirent.namlen,
663                                 media.buf);
664                 }
665                 tabprintf(tab, "inum 0x%016jx\n",
666                           (uintmax_t)bref->embed.dirent.inum);
667                 tabprintf(tab, "type     %s\n",
668                           hammer2_iptype_to_str(bref->embed.dirent.type));
669                 break;
670         case HAMMER2_BREF_TYPE_INODE:
671                 printf("{\n");
672                 namelen = media.ipdata.meta.name_len;
673                 if (namelen > HAMMER2_INODE_MAXNAME)
674                         namelen = 0;
675                 tabprintf(tab, "filename \"%*.*s\"\n",
676                           namelen, namelen, media.ipdata.filename);
677                 tabprintf(tab, "version  %d\n", media.ipdata.meta.version);
678                 tabprintf(tab, "pfs_st   %d\n", media.ipdata.meta.pfs_subtype);
679                 tabprintf(tab, "uflags   0x%08x\n",
680                           media.ipdata.meta.uflags);
681                 if (media.ipdata.meta.rmajor || media.ipdata.meta.rminor) {
682                         tabprintf(tab, "rmajor   %d\n",
683                                   media.ipdata.meta.rmajor);
684                         tabprintf(tab, "rminor   %d\n",
685                                   media.ipdata.meta.rminor);
686                 }
687                 tabprintf(tab, "ctime    %s\n",
688                           hammer2_time64_to_str(media.ipdata.meta.ctime, &str));
689                 tabprintf(tab, "mtime    %s\n",
690                           hammer2_time64_to_str(media.ipdata.meta.mtime, &str));
691                 tabprintf(tab, "atime    %s\n",
692                           hammer2_time64_to_str(media.ipdata.meta.atime, &str));
693                 tabprintf(tab, "btime    %s\n",
694                           hammer2_time64_to_str(media.ipdata.meta.btime, &str));
695                 tabprintf(tab, "uid      %s\n",
696                           hammer2_uuid_to_str(&media.ipdata.meta.uid, &str));
697                 tabprintf(tab, "gid      %s\n",
698                           hammer2_uuid_to_str(&media.ipdata.meta.gid, &str));
699                 tabprintf(tab, "type     %s\n",
700                           hammer2_iptype_to_str(media.ipdata.meta.type));
701                 tabprintf(tab, "opflgs   0x%02x\n",
702                           media.ipdata.meta.op_flags);
703                 tabprintf(tab, "capflgs  0x%04x\n",
704                           media.ipdata.meta.cap_flags);
705                 tabprintf(tab, "mode     %-7o\n",
706                           media.ipdata.meta.mode);
707                 tabprintf(tab, "inum     0x%016jx\n",
708                           media.ipdata.meta.inum);
709                 tabprintf(tab, "size     %ju ",
710                           (uintmax_t)media.ipdata.meta.size);
711                 if (media.ipdata.meta.op_flags & HAMMER2_OPFLAG_DIRECTDATA &&
712                     media.ipdata.meta.size <= HAMMER2_EMBEDDED_BYTES)
713                         printf("(embedded data)\n");
714                 else
715                         printf("\n");
716                 tabprintf(tab, "nlinks   %ju\n",
717                           (uintmax_t)media.ipdata.meta.nlinks);
718                 tabprintf(tab, "iparent  0x%016jx\n",
719                           (uintmax_t)media.ipdata.meta.iparent);
720                 tabprintf(tab, "name_key 0x%016jx\n",
721                           (uintmax_t)media.ipdata.meta.name_key);
722                 tabprintf(tab, "name_len %u\n",
723                           media.ipdata.meta.name_len);
724                 tabprintf(tab, "ncopies  %u\n",
725                           media.ipdata.meta.ncopies);
726                 tabprintf(tab, "compalg  %u\n",
727                           media.ipdata.meta.comp_algo);
728                 tabprintf(tab, "target_t %u\n",
729                           media.ipdata.meta.target_type);
730                 tabprintf(tab, "checkalg %u\n",
731                           media.ipdata.meta.check_algo);
732                 if ((media.ipdata.meta.op_flags & HAMMER2_OPFLAG_PFSROOT) ||
733                     media.ipdata.meta.pfs_type == HAMMER2_PFSTYPE_SUPROOT) {
734                         tabprintf(tab, "pfs_nmas %u\n",
735                                   media.ipdata.meta.pfs_nmasters);
736                         tabprintf(tab, "pfs_type %u (%s)\n",
737                                   media.ipdata.meta.pfs_type,
738                                   hammer2_pfstype_to_str(media.ipdata.meta.pfs_type));
739                         tabprintf(tab, "pfs_inum 0x%016jx\n",
740                                   (uintmax_t)media.ipdata.meta.pfs_inum);
741                         tabprintf(tab, "pfs_clid %s\n",
742                                   hammer2_uuid_to_str(&media.ipdata.meta.pfs_clid,
743                                                       &str));
744                         tabprintf(tab, "pfs_fsid %s\n",
745                                   hammer2_uuid_to_str(&media.ipdata.meta.pfs_fsid,
746                                                       &str));
747                         tabprintf(tab, "pfs_lsnap_tid 0x%016jx\n",
748                                   (uintmax_t)media.ipdata.meta.pfs_lsnap_tid);
749                 }
750                 tabprintf(tab, "data_quota  %ju\n",
751                           (uintmax_t)media.ipdata.meta.data_quota);
752                 tabprintf(tab, "data_count  %ju\n",
753                           (uintmax_t)bref->embed.stats.data_count);
754                 tabprintf(tab, "inode_quota %ju\n",
755                           (uintmax_t)media.ipdata.meta.inode_quota);
756                 tabprintf(tab, "inode_count %ju\n",
757                           (uintmax_t)bref->embed.stats.inode_count);
758                 break;
759         case HAMMER2_BREF_TYPE_INDIRECT:
760                 didnl = 1;
761                 printf("{\n");
762                 tabprintf(tab, "count %d\n", bcount);
763                 break;
764         case HAMMER2_BREF_TYPE_DATA:
765                 printf("\n");
766                 obrace = 0;
767                 break;
768         case HAMMER2_BREF_TYPE_VOLUME:
769                 printf("mirror_tid=%016jx freemap_tid=%016jx ",
770                         media.voldata.mirror_tid,
771                         media.voldata.freemap_tid);
772                 printf("{\n");
773                 break;
774         case HAMMER2_BREF_TYPE_FREEMAP:
775                 printf("mirror_tid=%016jx freemap_tid=%016jx ",
776                         media.voldata.mirror_tid,
777                         media.voldata.freemap_tid);
778                 printf("{\n");
779                 break;
780         case HAMMER2_BREF_TYPE_FREEMAP_LEAF:
781                 printf("{\n");
782                 for (i = 0; i < HAMMER2_FREEMAP_COUNT; ++i) {
783                         hammer2_off_t data_off = bref->key +
784                                 i * 256 * HAMMER2_FREEMAP_BLOCK_SIZE;
785 #if HAMMER2_BMAP_ELEMENTS != 8
786 #error "cmd_debug.c: HAMMER2_BMAP_ELEMENTS expected to be 8"
787 #endif
788                         tabprintf(tab + 4, "%016jx %04d.%04x (avail=%7d) "
789                                   "%016jx %016jx %016jx %016jx "
790                                   "%016jx %016jx %016jx %016jx\n",
791                                   data_off, i, media.bmdata[i].class,
792                                   media.bmdata[i].avail,
793                                   media.bmdata[i].bitmapq[0],
794                                   media.bmdata[i].bitmapq[1],
795                                   media.bmdata[i].bitmapq[2],
796                                   media.bmdata[i].bitmapq[3],
797                                   media.bmdata[i].bitmapq[4],
798                                   media.bmdata[i].bitmapq[5],
799                                   media.bmdata[i].bitmapq[6],
800                                   media.bmdata[i].bitmapq[7]);
801                         if (data_off >= voldata->aux_end &&
802                             data_off < voldata->volu_size) {
803                                 CountFreeBlocks(&media.bmdata[i],
804                                                 &TotalFreeAccum16,
805                                                 &TotalFreeAccum64);
806                         }
807                 }
808                 tabprintf(tab, "}\n");
809                 break;
810         case HAMMER2_BREF_TYPE_FREEMAP_NODE:
811                 printf("{\n");
812                 tabprintf(tab, "count %d\n", bcount);
813                 break;
814         default:
815                 printf("\n");
816                 obrace = 0;
817                 break;
818         }
819         if (str)
820                 free(str);
821
822 skip_data:
823         /*
824          * Recurse if norecurse == 0.  If the CRC failed, pass norecurse = 1.
825          * That is, if an indirect or inode fails we still try to list its
826          * direct children to help with debugging, but go no further than
827          * that because they are probably garbage.
828          */
829         for (i = 0; norecurse == 0 && i < bcount; ++i) {
830                 if (bscan[i].type != HAMMER2_BREF_TYPE_EMPTY) {
831                         if (didnl == 0) {
832                                 printf("\n");
833                                 didnl = 1;
834                         }
835                         show_bref(voldata, fd, tab, i, &bscan[i], dofreemap,
836                                   failed);
837                 }
838         }
839         tab -= show_tab;
840         if (obrace) {
841                 if (bref->type == HAMMER2_BREF_TYPE_INODE)
842                         tabprintf(tab, "} (%s.%d, \"%*.*s\")\n",
843                                   type_str, bi, namelen, namelen,
844                                   media.ipdata.filename);
845                 else
846                         tabprintf(tab, "} (%s.%d)\n", type_str,bi);
847         }
848 }
849
850 static
851 void
852 CountFreeBlocks(hammer2_bmap_data_t *bmap,
853                 hammer2_off_t *accum16, hammer2_off_t *accum64)
854 {
855         int i;
856         int j;
857
858         for (i = 0; i < 8; ++i) {
859                 uint64_t bm = bmap->bitmapq[i];
860                 uint64_t mask;
861
862                 mask = 0x03;
863                 for (j = 0; j < 64; j += 2) {
864                         if ((bm & mask) == 0)
865                                 *accum16 += 16384;
866                 }
867                 mask = 0xFF;
868                 for (j = 0; j < 64; j += 8) {
869                         if ((bm & mask) == 0)
870                                 *accum64 += 65536;
871                 }
872         }
873 }
874
875 int
876 cmd_hash(int ac, const char **av)
877 {
878         int i;
879
880         for (i = 0; i < ac; ++i) {
881                 printf("%016jx %s\n", dirhash(av[i], strlen(av[i])), av[i]);
882         }
883         return(0);
884 }
885
886 int
887 cmd_dhash(int ac, const char **av)
888 {
889         char buf[1024];         /* 1K extended directory record */
890         uint64_t hash;
891         int i;
892
893         for (i = 0; i < ac; ++i) {
894                 bzero(buf, sizeof(buf));
895                 snprintf(buf, sizeof(buf), "%s", av[i]);
896                 hash = XXH64(buf, sizeof(buf), XXH_HAMMER2_SEED);
897                 printf("%016jx %s\n", hash, av[i]);
898         }
899         return(0);
900 }
901
902 int
903 cmd_dumpchain(const char *path, u_int flags)
904 {
905         int dummy = (int)flags;
906         int fd;
907
908         fd = open(path, O_RDONLY);
909         if (fd >= 0) {
910                 ioctl(fd, HAMMER2IOC_DEBUG_DUMP, &dummy);
911                 close(fd);
912         } else {
913                 fprintf(stderr, "unable to open %s\n", path);
914         }
915         return 0;
916 }
917
918
919 static
920 void
921 tabprintf(int tab, const char *ctl, ...)
922 {
923         va_list va;
924
925         printf("%*.*s", tab, tab, "");
926         va_start(va, ctl);
927         vprintf(ctl, va);
928         va_end(va);
929 }