sbin/hammer2: Whitespace cleanups/etc for cmd_debug.c
[dragonfly.git] / sbin / hammer2 / cmd_debug.c
CommitLineData
9ab15106
MD
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
8ca87c4c 38static int show_tab = 2;
bd878fc9 39
1b8eded1 40static void shell_msghandler(dmsg_msg_t *msg, int unmanaged);
0c3a8cd0 41static void shell_ttymsg(dmsg_iocom_t *iocom);
5c37bf12
MD
42static void CountFreeBlocks(hammer2_bmap_data_t *bmap,
43 hammer2_off_t *accum16, hammer2_off_t *accum64);
bd878fc9
MD
44
45/************************************************************************
46 * SHELL *
47 ************************************************************************/
9ab15106 48
1b8eded1
MD
49int
50cmd_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;
1b8eded1
MD
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
9ab15106 74int
bd878fc9 75cmd_shell(const char *hostname)
9ab15106 76{
0c3a8cd0
MD
77 struct dmsg_iocom iocom;
78 dmsg_msg_t *msg;
9ab15106
MD
79 int fd;
80
9ab15106
MD
81 /*
82 * Connect to the target
83 */
0c3a8cd0 84 fd = dmsg_connect(hostname);
02454b3e
MD
85 if (fd < 0)
86 return 1;
9ab15106
MD
87
88 /*
1b8eded1
MD
89 * Initialize the session and transmit an empty DMSG_DBG_SHELL
90 * to cause the remote end to generate a prompt.
9ab15106 91 */
11f7caf4
MD
92 dmsg_iocom_init(&iocom, fd, 0,
93 NULL,
94 shell_rcvmsg,
95 hammer2_shell_parse,
96 shell_ttymsg);
02454b3e 97 fcntl(0, F_SETFL, O_NONBLOCK);
9ab15106
MD
98 printf("debug: connected\n");
99
1b8eded1 100 msg = dmsg_msg_alloc(&iocom.state0, 0, DMSG_DBG_SHELL, NULL, NULL);
0c3a8cd0
MD
101 dmsg_msg_write(msg);
102 dmsg_iocom_core(&iocom);
9ab15106
MD
103 fprintf(stderr, "debug: disconnected\n");
104 close(fd);
105 return 0;
106}
1b8eded1 107#endif
9ab15106
MD
108
109/*
1b8eded1
MD
110 * Debug session front-end
111 *
0c3a8cd0 112 * Callback from dmsg_iocom_core() when messages might be present
9ab15106
MD
113 * on the socket.
114 */
115static
116void
1b8eded1 117shell_msghandler(dmsg_msg_t *msg, int unmanaged)
9ab15106 118{
1b8eded1
MD
119 dmsg_msg_t *nmsg;
120
063639ba 121 switch(msg->tcmd) {
1b8eded1 122#if 0
5bc5bca2
MD
123 case DMSG_LNK_ERROR:
124 case DMSG_LNK_ERROR | DMSGF_REPLY:
81666e1b
MD
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 */
5903497c 130 if (msg->any.head.error) {
81666e1b 131 fprintf(stderr, "Stream failure: %s\n",
0c3a8cd0 132 dmsg_msg_str(msg));
5903497c
MD
133 } else {
134 write(1, "debug> ", 7);
9ab15106 135 }
5903497c 136 break;
5bc5bca2 137 case DMSG_LNK_ERROR | DMSGF_DELETE:
81666e1b
MD
138 /* ignore termination of LNK_CONN */
139 break;
1b8eded1 140#endif
5bc5bca2 141 case DMSG_DBG_SHELL:
5903497c
MD
142 /*
143 * We send the commands, not accept them.
81666e1b 144 * (one-way message, not transactional)
5903497c 145 */
1b8eded1
MD
146 if (unmanaged)
147 dmsg_msg_reply(msg, DMSG_ERR_NOSUPP);
5903497c 148 break;
5bc5bca2 149 case DMSG_DBG_SHELL | DMSGF_REPLY:
5903497c
MD
150 /*
151 * A reply from the remote is data we copy to stdout.
81666e1b 152 * (one-way message, not transactional)
5903497c
MD
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;
1b8eded1 159#if 1
5bc5bca2 160 case DMSG_LNK_CONN | DMSGF_CREATE:
1b8eded1
MD
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);
0c3a8cd0 166 dmsg_msg_reply(msg, DMSG_ERR_NOSUPP);
81666e1b 167 break;
5bc5bca2 168 case DMSG_LNK_CONN | DMSGF_DELETE:
81666e1b 169 break;
1b8eded1 170#endif
5903497c 171 default:
81666e1b
MD
172 /*
173 * Ignore any unknown messages, Terminate any unknown
174 * transactions with an error.
175 */
0c3a8cd0 176 fprintf(stderr, "Unknown message: %s\n", dmsg_msg_str(msg));
1b8eded1
MD
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 }
5903497c 183 break;
9ab15106
MD
184 }
185}
186
1b8eded1
MD
187/*
188 * Debug session front-end
189 */
9ab15106
MD
190static
191void
0c3a8cd0 192shell_ttymsg(dmsg_iocom_t *iocom)
9ab15106 193{
1b8eded1 194 dmsg_state_t *pstate;
0c3a8cd0 195 dmsg_msg_t *msg;
9ab15106 196 char buf[256];
1b8eded1 197 char *cmd;
9ab15106
MD
198 size_t len;
199
200 if (fgets(buf, sizeof(buf), stdin) != NULL) {
1b8eded1
MD
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 }
02454b3e 226 } else if (feof(stdin)) {
9ab15106
MD
227 /*
228 * Set EOF flag without setting any error code for normal
229 * EOF.
230 */
0c3a8cd0 231 iocom->flags |= DMSG_IOCOMF_EOF;
02454b3e
MD
232 } else {
233 clearerr(stdin);
9ab15106
MD
234 }
235}
236
1b8eded1
MD
237/*
238 * Debug session back-end (on remote side)
239 */
240static void shell_span(dmsg_msg_t *msg, char *cmdbuf);
5ab1caed 241static void shell_ping(dmsg_msg_t *msg, char *cmdbuf);
81666e1b 242
11f7caf4 243void
b53e7c4f 244hammer2_shell_parse(dmsg_msg_t *msg, int unmanaged)
9ab15106 245{
1b8eded1 246 dmsg_iocom_t *iocom = msg->state->iocom;
b53e7c4f
MD
247 char *cmdbuf;
248 char *cmdp;
249 uint32_t cmd;
9ab15106 250
b53e7c4f 251 /*
5ab1caed 252 * Filter on debug shell commands and ping responses only
b53e7c4f
MD
253 */
254 cmd = msg->any.head.cmd;
5ab1caed
MD
255 if ((cmd & DMSGF_CMDSWMASK) == (DMSG_LNK_PING | DMSGF_REPLY)) {
256 dmsg_printf(iocom, "ping reply\n");
257 return;
258 }
259
b53e7c4f
MD
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 */
b53e7c4f
MD
274 cmdbuf = msg->aux_data;
275 cmdp = strsep(&cmdbuf, " \t");
276
277 if (cmdp == NULL || *cmdp == 0) {
9ab15106 278 ;
5ab1caed
MD
279 } else if (strcmp(cmdp, "ping") == 0) {
280 shell_ping(msg, cmdbuf);
b53e7c4f 281 } else if (strcmp(cmdp, "span") == 0) {
1b8eded1 282 shell_span(msg, cmdbuf);
b53e7c4f 283 } else if (strcmp(cmdp, "tree") == 0) {
1b8eded1 284 dmsg_shell_tree(iocom, cmdbuf); /* dump spanning tree */
b53e7c4f 285 } else if (strcmp(cmdp, "help") == 0 || strcmp(cmdp, "?") == 0) {
1b8eded1
MD
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");
81666e1b 290 } else {
1b8eded1 291 dmsg_printf(iocom, "Unrecognized command: %s\n", cmdp);
81666e1b 292 }
1b8eded1 293 dmsg_printf(iocom, "debug> ");
81666e1b 294}
02454b3e 295
5ab1caed
MD
296static void
297shell_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
81666e1b 307static void
1b8eded1 308shell_span(dmsg_msg_t *msg, char *cmdbuf)
81666e1b 309{
1b8eded1 310 dmsg_iocom_t *iocom = msg->state->iocom;
ddfbb283 311 dmsg_master_service_info_t *info;
81666e1b
MD
312 const char *hostname = strsep(&cmdbuf, " \t");
313 pthread_t thread;
314 int fd;
02454b3e 315
81666e1b
MD
316 /*
317 * Connect to the target
318 */
319 if (hostname == NULL) {
320 fd = -1;
321 } else {
0c3a8cd0 322 fd = dmsg_connect(hostname);
81666e1b
MD
323 }
324
325 /*
326 * Start master service
327 */
328 if (fd < 0) {
1b8eded1 329 dmsg_printf(iocom, "Connection to %s failed\n", hostname);
9ab15106 330 } else {
1b8eded1 331 dmsg_printf(iocom, "Connected to %s\n", hostname);
ddfbb283
MD
332
333 info = malloc(sizeof(*info));
334 bzero(info, sizeof(*info));
335 info->fd = fd;
336 info->detachme = 1;
b53e7c4f 337 info->usrmsg_callback = hammer2_shell_parse;
c3711753 338 info->label = strdup("client");
ddfbb283
MD
339
340 pthread_create(&thread, NULL, dmsg_master_service, info);
81666e1b 341 /*pthread_join(thread, &res);*/
9ab15106
MD
342 }
343}
344
02454b3e
MD
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 */
352int
353cmd_debugspan(const char *hostname)
354{
355 pthread_t thread;
356 int fd;
357 void *res;
358
359 /*
360 * Connect to the target
361 */
0c3a8cd0 362 fd = dmsg_connect(hostname);
02454b3e
MD
363 if (fd < 0)
364 return 1;
365
366 printf("debugspan: connected to %s, starting CONN/SPAN\n", hostname);
0c3a8cd0
MD
367 pthread_create(&thread, NULL,
368 dmsg_master_service, (void *)(intptr_t)fd);
02454b3e
MD
369 pthread_join(thread, &res);
370 return(0);
371}
372
bd878fc9
MD
373/************************************************************************
374 * SHOW *
375 ************************************************************************/
376
5c37bf12
MD
377static void show_bref(hammer2_volume_data_t *voldata, int fd, int tab,
378 int bi, hammer2_blockref_t *bref,
62a2c422 379 int dofreemap, int norecurse);
bd878fc9
MD
380static void tabprintf(int tab, const char *ctl, ...);
381
79e82fbc
TK
382static int64_t TotalFreeAccum16;
383static int64_t TotalFreeAccum64;
5c37bf12 384
bd878fc9 385int
78ac5385 386cmd_show(const char *devpath, int dofreemap)
bd878fc9
MD
387{
388 hammer2_blockref_t broot;
351eb452
MD
389 hammer2_blockref_t best;
390 hammer2_media_data_t media;
bd878fc9 391 int fd;
9061bde5 392 int i;
351eb452 393 int best_i;
8ca87c4c 394 char *env;
bd878fc9 395
5c37bf12
MD
396 TotalFreeAccum16 = 0; /* includes TotalFreeAccum64 */
397 TotalFreeAccum64 = 0;
8ca87c4c
TK
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
bd878fc9
MD
406 fd = open(devpath, O_RDONLY);
407 if (fd < 0) {
408 perror("open");
409 return 1;
410 }
351eb452
MD
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));
95d182da 418 for (i = 0; i < HAMMER2_NUM_VOLHDRS; ++i) {
9061bde5 419 bzero(&broot, sizeof(broot));
208afee5
TK
420 broot.type = dofreemap ?
421 HAMMER2_BREF_TYPE_FREEMAP : HAMMER2_BREF_TYPE_VOLUME;
79e82fbc 422 broot.data_off = (i * HAMMER2_ZONE_BYTES64) | HAMMER2_PBUFRADIX;
351eb452
MD
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)
79e82fbc
TK
432 show_bref(&media.voldata, fd, 0, i, &broot,
433 dofreemap, 0);
351eb452 434 }
9061bde5 435 }
351eb452 436 if (VerboseOpt < 3)
5c37bf12 437 show_bref(&media.voldata, fd, 0, best_i, &best, dofreemap, 0);
bd878fc9
MD
438 close(fd);
439
5c37bf12 440 if (dofreemap && VerboseOpt < 3) {
7350c065 441 printf("Total free storage: %6.3fGB (%6.3fGB in 64KB chunks)\n",
5c37bf12
MD
442 (double)TotalFreeAccum16 / (1024.0 * 1024.0 * 1024.0),
443 (double)TotalFreeAccum64 / (1024.0 * 1024.0 * 1024.0));
444 }
445
bd878fc9
MD
446 return 0;
447}
448
449static void
5c37bf12
MD
450show_bref(hammer2_volume_data_t *voldata, int fd, int tab,
451 int bi, hammer2_blockref_t *bref, int dofreemap, int norecurse)
bd878fc9
MD
452{
453 hammer2_media_data_t media;
454 hammer2_blockref_t *bscan;
455 int bcount;
456 int i;
457 int didnl;
ad7cf8ea 458 int namelen;
bd878fc9 459 int obrace = 1;
62a2c422 460 int failed;
bd878fc9
MD
461 size_t bytes;
462 const char *type_str;
463 char *str = NULL;
5a790ddf 464 uint32_t cv;
7d565a4f 465 uint64_t cv64;
bd878fc9
MD
466
467 switch(bref->type) {
468 case HAMMER2_BREF_TYPE_EMPTY:
469 type_str = "empty";
470 break;
da0cdd33
MD
471 case HAMMER2_BREF_TYPE_DIRENT:
472 type_str = "dirent";
473 break;
bd878fc9
MD
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;
78ac5385
MD
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;
bd878fc9
MD
495 default:
496 type_str = "unknown";
497 break;
498 }
499
4e0d25fd
MD
500 tabprintf(tab,
501 "%s.%-3d %016jx %016jx/%-2d "
502 "mir=%016jx mod=%016jx leafcnt=%d ",
79e82fbc
TK
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);
8ca87c4c 507 tab += show_tab;
22dffc51
MD
508 if (bref->flags)
509 printf("flags=%02x ", bref->flags);
65cacacf
MD
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 }
bd878fc9 515
da0cdd33
MD
516 bytes = (bref->data_off & HAMMER2_OFF_MASK_RADIX);
517 if (bytes)
518 bytes = (size_t)1 << bytes;
519 if (bytes) {
78ac5385
MD
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);
78ac5385
MD
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);
bd878fc9
MD
535 return;
536 }
78ac5385
MD
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 }
bd878fc9
MD
546 }
547
548 bscan = NULL;
549 bcount = 0;
78ac5385 550 didnl = 1;
1fca819a 551 namelen = 0;
62a2c422 552 failed = 0;
bd878fc9 553
5a790ddf
MD
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!).
da0cdd33
MD
559 *
560 * WARNING! bref->check state may be used for other things when
561 * bref has no data (bytes == 0).
5a790ddf 562 */
da0cdd33
MD
563 if (bytes &&
564 (bref->type != HAMMER2_BREF_TYPE_DATA || VerboseOpt >= 1)) {
5a790ddf
MD
565 switch(HAMMER2_DEC_CHECK(bref->methods)) {
566 case HAMMER2_CHECK_NONE:
8adee7de
MD
567 printf("(meth %02x) ", bref->methods);
568 break;
569 case HAMMER2_CHECK_DISABLED:
570 printf("(meth %02x) ", bref->methods);
5a790ddf
MD
571 break;
572 case HAMMER2_CHECK_ISCSI32:
573 cv = hammer2_icrc32(&media, bytes);
574 if (bref->check.iscsi32.value != cv) {
8b2625c5 575 printf("(icrc %02x:%08x/%08x failed) ",
5a790ddf
MD
576 bref->methods,
577 bref->check.iscsi32.value,
578 cv);
62a2c422 579 failed = 1;
8adee7de 580 } else {
8b2625c5
MD
581 printf("(meth %02x, iscsi32=%08x) ",
582 bref->methods, cv);
5a790ddf
MD
583 }
584 break;
7d565a4f
MD
585 case HAMMER2_CHECK_XXHASH64:
586 cv64 = XXH64(&media, bytes, XXH_HAMMER2_SEED);
587 if (bref->check.xxhash64.value != cv64) {
8b2625c5 588 printf("(xxhash64 %02x:%016jx/%016jx failed) ",
7d565a4f
MD
589 bref->methods,
590 bref->check.xxhash64.value,
591 cv64);
62a2c422 592 failed = 1;
7d565a4f 593 } else {
8b2625c5
MD
594 printf("(meth %02x, xxh=%016jx) ",
595 bref->methods, cv64);
7d565a4f 596 }
5a790ddf
MD
597 break;
598 case HAMMER2_CHECK_SHA192:
8adee7de 599 printf("(meth %02x) ", bref->methods);
5a790ddf
MD
600 break;
601 case HAMMER2_CHECK_FREEMAP:
602 cv = hammer2_icrc32(&media, bytes);
603 if (bref->check.freemap.icrc32 != cv) {
8b2625c5 604 printf("(fcrc %02x:%08x/%08x failed) ",
5a790ddf
MD
605 bref->methods,
606 bref->check.freemap.icrc32,
607 cv);
62a2c422 608 failed = 1;
8adee7de 609 } else {
8b2625c5
MD
610 printf("(meth %02x, fcrc=%08x) ",
611 bref->methods, cv);
5a790ddf
MD
612 }
613 break;
614 }
615 }
616
dd5e52ca
TK
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
bd878fc9
MD
648 switch(bref->type) {
649 case HAMMER2_BREF_TYPE_EMPTY:
650 obrace = 0;
651 break;
da0cdd33
MD
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",
79e82fbc 666 (uintmax_t)bref->embed.dirent.inum);
da0cdd33
MD
667 tabprintf(tab, "type %s\n",
668 hammer2_iptype_to_str(bref->embed.dirent.type));
669 break;
bd878fc9
MD
670 case HAMMER2_BREF_TYPE_INODE:
671 printf("{\n");
b0f58de8 672 namelen = media.ipdata.meta.name_len;
ad7cf8ea
MD
673 if (namelen > HAMMER2_INODE_MAXNAME)
674 namelen = 0;
675 tabprintf(tab, "filename \"%*.*s\"\n",
676 namelen, namelen, media.ipdata.filename);
b0f58de8 677 tabprintf(tab, "version %d\n", media.ipdata.meta.version);
12404a28 678 tabprintf(tab, "pfs_st %d\n", media.ipdata.meta.pfs_subtype);
bd878fc9 679 tabprintf(tab, "uflags 0x%08x\n",
b0f58de8
MD
680 media.ipdata.meta.uflags);
681 if (media.ipdata.meta.rmajor || media.ipdata.meta.rminor) {
bd878fc9 682 tabprintf(tab, "rmajor %d\n",
b0f58de8 683 media.ipdata.meta.rmajor);
bd878fc9 684 tabprintf(tab, "rminor %d\n",
b0f58de8 685 media.ipdata.meta.rminor);
bd878fc9
MD
686 }
687 tabprintf(tab, "ctime %s\n",
b0f58de8 688 hammer2_time64_to_str(media.ipdata.meta.ctime, &str));
bd878fc9 689 tabprintf(tab, "mtime %s\n",
b0f58de8 690 hammer2_time64_to_str(media.ipdata.meta.mtime, &str));
bd878fc9 691 tabprintf(tab, "atime %s\n",
b0f58de8 692 hammer2_time64_to_str(media.ipdata.meta.atime, &str));
bd878fc9 693 tabprintf(tab, "btime %s\n",
b0f58de8 694 hammer2_time64_to_str(media.ipdata.meta.btime, &str));
bd878fc9 695 tabprintf(tab, "uid %s\n",
b0f58de8 696 hammer2_uuid_to_str(&media.ipdata.meta.uid, &str));
bd878fc9 697 tabprintf(tab, "gid %s\n",
b0f58de8 698 hammer2_uuid_to_str(&media.ipdata.meta.gid, &str));
da0cdd33
MD
699 tabprintf(tab, "type %s\n",
700 hammer2_iptype_to_str(media.ipdata.meta.type));
bd878fc9 701 tabprintf(tab, "opflgs 0x%02x\n",
b0f58de8 702 media.ipdata.meta.op_flags);
bd878fc9 703 tabprintf(tab, "capflgs 0x%04x\n",
b0f58de8 704 media.ipdata.meta.cap_flags);
bd878fc9 705 tabprintf(tab, "mode %-7o\n",
b0f58de8 706 media.ipdata.meta.mode);
bd878fc9 707 tabprintf(tab, "inum 0x%016jx\n",
b0f58de8 708 media.ipdata.meta.inum);
12404a28 709 tabprintf(tab, "size %ju ",
b0f58de8 710 (uintmax_t)media.ipdata.meta.size);
12404a28
TK
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");
bd878fc9 716 tabprintf(tab, "nlinks %ju\n",
b0f58de8 717 (uintmax_t)media.ipdata.meta.nlinks);
bd878fc9 718 tabprintf(tab, "iparent 0x%016jx\n",
b0f58de8 719 (uintmax_t)media.ipdata.meta.iparent);
bd878fc9 720 tabprintf(tab, "name_key 0x%016jx\n",
b0f58de8 721 (uintmax_t)media.ipdata.meta.name_key);
bd878fc9 722 tabprintf(tab, "name_len %u\n",
b0f58de8 723 media.ipdata.meta.name_len);
bd878fc9 724 tabprintf(tab, "ncopies %u\n",
b0f58de8 725 media.ipdata.meta.ncopies);
bd878fc9 726 tabprintf(tab, "compalg %u\n",
b0f58de8 727 media.ipdata.meta.comp_algo);
12404a28
TK
728 tabprintf(tab, "target_t %u\n",
729 media.ipdata.meta.target_type);
8adee7de 730 tabprintf(tab, "checkalg %u\n",
b0f58de8 731 media.ipdata.meta.check_algo);
b7add675
MD
732 if ((media.ipdata.meta.op_flags & HAMMER2_OPFLAG_PFSROOT) ||
733 media.ipdata.meta.pfs_type == HAMMER2_PFSTYPE_SUPROOT) {
12404a28
TK
734 tabprintf(tab, "pfs_nmas %u\n",
735 media.ipdata.meta.pfs_nmasters);
bd878fc9 736 tabprintf(tab, "pfs_type %u (%s)\n",
b0f58de8
MD
737 media.ipdata.meta.pfs_type,
738 hammer2_pfstype_to_str(media.ipdata.meta.pfs_type));
bd878fc9 739 tabprintf(tab, "pfs_inum 0x%016jx\n",
b0f58de8 740 (uintmax_t)media.ipdata.meta.pfs_inum);
8c280d5d 741 tabprintf(tab, "pfs_clid %s\n",
b0f58de8 742 hammer2_uuid_to_str(&media.ipdata.meta.pfs_clid,
bd878fc9
MD
743 &str));
744 tabprintf(tab, "pfs_fsid %s\n",
b0f58de8 745 hammer2_uuid_to_str(&media.ipdata.meta.pfs_fsid,
bd878fc9 746 &str));
7866a0e7
MD
747 tabprintf(tab, "pfs_lsnap_tid 0x%016jx\n",
748 (uintmax_t)media.ipdata.meta.pfs_lsnap_tid);
bd878fc9
MD
749 }
750 tabprintf(tab, "data_quota %ju\n",
b0f58de8 751 (uintmax_t)media.ipdata.meta.data_quota);
bd878fc9 752 tabprintf(tab, "data_count %ju\n",
da0cdd33 753 (uintmax_t)bref->embed.stats.data_count);
bd878fc9 754 tabprintf(tab, "inode_quota %ju\n",
b0f58de8 755 (uintmax_t)media.ipdata.meta.inode_quota);
bd878fc9 756 tabprintf(tab, "inode_count %ju\n",
da0cdd33 757 (uintmax_t)bref->embed.stats.inode_count);
bd878fc9
MD
758 break;
759 case HAMMER2_BREF_TYPE_INDIRECT:
bd878fc9
MD
760 didnl = 1;
761 printf("{\n");
12404a28 762 tabprintf(tab, "count %d\n", bcount);
bd878fc9
MD
763 break;
764 case HAMMER2_BREF_TYPE_DATA:
79e82fbc
TK
765 printf("\n");
766 obrace = 0;
bd878fc9
MD
767 break;
768 case HAMMER2_BREF_TYPE_VOLUME:
50456506
MD
769 printf("mirror_tid=%016jx freemap_tid=%016jx ",
770 media.voldata.mirror_tid,
10136ab6 771 media.voldata.freemap_tid);
208afee5
TK
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);
78ac5385
MD
778 printf("{\n");
779 break;
780 case HAMMER2_BREF_TYPE_FREEMAP_LEAF:
93f3933a
MD
781 printf("{\n");
782 for (i = 0; i < HAMMER2_FREEMAP_COUNT; ++i) {
79e82fbc
TK
783 hammer2_off_t data_off = bref->key +
784 i * 256 * HAMMER2_FREEMAP_BLOCK_SIZE;
5cebbe36
MD
785#if HAMMER2_BMAP_ELEMENTS != 8
786#error "cmd_debug.c: HAMMER2_BMAP_ELEMENTS expected to be 8"
787#endif
8b2625c5 788 tabprintf(tab + 4, "%016jx %04d.%04x (avail=%7d) "
5cebbe36
MD
789 "%016jx %016jx %016jx %016jx "
790 "%016jx %016jx %016jx %016jx\n",
79e82fbc 791 data_off, i, media.bmdata[i].class,
93f3933a 792 media.bmdata[i].avail,
5cebbe36
MD
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]);
5c37bf12
MD
801 if (data_off >= voldata->aux_end &&
802 data_off < voldata->volu_size) {
803 CountFreeBlocks(&media.bmdata[i],
804 &TotalFreeAccum16,
805 &TotalFreeAccum64);
806 }
78ac5385 807 }
93f3933a 808 tabprintf(tab, "}\n");
78ac5385
MD
809 break;
810 case HAMMER2_BREF_TYPE_FREEMAP_NODE:
bd878fc9 811 printf("{\n");
12404a28 812 tabprintf(tab, "count %d\n", bcount);
bd878fc9
MD
813 break;
814 default:
78ac5385
MD
815 printf("\n");
816 obrace = 0;
bd878fc9
MD
817 break;
818 }
819 if (str)
820 free(str);
62a2c422 821
dd5e52ca 822skip_data:
62a2c422
MD
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) {
bd878fc9
MD
830 if (bscan[i].type != HAMMER2_BREF_TYPE_EMPTY) {
831 if (didnl == 0) {
832 printf("\n");
833 didnl = 1;
834 }
79e82fbc
TK
835 show_bref(voldata, fd, tab, i, &bscan[i], dofreemap,
836 failed);
bd878fc9
MD
837 }
838 }
8ca87c4c 839 tab -= show_tab;
bd878fc9
MD
840 if (obrace) {
841 if (bref->type == HAMMER2_BREF_TYPE_INODE)
1fca819a 842 tabprintf(tab, "} (%s.%d, \"%*.*s\")\n",
79e82fbc
TK
843 type_str, bi, namelen, namelen,
844 media.ipdata.filename);
bd878fc9
MD
845 else
846 tabprintf(tab, "} (%s.%d)\n", type_str,bi);
847 }
848}
849
5c37bf12
MD
850static
851void
852CountFreeBlocks(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
775153c2
MD
875int
876cmd_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
0c41f055
MD
886int
887cmd_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
8f579e46 902int
40498d1c 903cmd_dumpchain(const char *path, u_int flags)
8f579e46 904{
40498d1c 905 int dummy = (int)flags;
8f579e46
MD
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
775153c2 918
bd878fc9
MD
919static
920void
921tabprintf(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}