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_show.c,v 1.18 2008/10/09 04:20:59 dillon Exp $ 35 */ 36 37 #include "hammer.h" 38 39 #define FLAG_TOOFARLEFT 0x0001 40 #define FLAG_TOOFARRIGHT 0x0002 41 #define FLAG_BADTYPE 0x0004 42 #define FLAG_BADCHILDPARENT 0x0008 43 44 static void print_btree_node(hammer_off_t node_offset, int depth, int spike, 45 hammer_base_elm_t left_bound, 46 hammer_base_elm_t right_bound); 47 static const char *check_data_crc(hammer_btree_elm_t elm); 48 static void print_record(hammer_btree_elm_t elm); 49 static void print_btree_elm(hammer_btree_elm_t elm, int i, u_int8_t type, 50 int flags, const char *label); 51 static int print_elm_flags(hammer_node_ondisk_t node, hammer_off_t node_offset, 52 hammer_btree_elm_t elm, u_int8_t btype, 53 hammer_base_elm_t left_bound, 54 hammer_base_elm_t right_bound); 55 static void print_bigblock_fill(hammer_off_t offset); 56 57 void 58 hammer_cmd_show(hammer_off_t node_offset, int depth, 59 hammer_base_elm_t left_bound, hammer_base_elm_t right_bound) 60 { 61 struct volume_info *volume; 62 63 if (node_offset == (hammer_off_t)-1) { 64 volume = get_volume(RootVolNo); 65 node_offset = volume->ondisk->vol0_btree_root; 66 if (QuietOpt < 3) { 67 printf("Volume header\trecords=%lld next_tid=%016llx\n", 68 volume->ondisk->vol0_stat_records, 69 volume->ondisk->vol0_next_tid); 70 } 71 rel_volume(volume); 72 } 73 printf("show %016llx depth %d\n", node_offset, depth); 74 print_btree_node(node_offset, depth, 0, left_bound, right_bound); 75 print_btree_node(node_offset, depth, 1, left_bound, right_bound); 76 } 77 78 static void 79 print_btree_node(hammer_off_t node_offset, int depth, int spike, 80 hammer_base_elm_t left_bound, hammer_base_elm_t right_bound) 81 { 82 struct buffer_info *buffer = NULL; 83 hammer_node_ondisk_t node; 84 hammer_btree_elm_t elm; 85 int i; 86 int flags; 87 int maxcount; 88 char badc; 89 90 node = get_node(node_offset, &buffer); 91 92 if (crc32(&node->crc + 1, HAMMER_BTREE_CRCSIZE) == node->crc) 93 badc = ' '; 94 else 95 badc = 'B'; 96 97 if (spike == 0) { 98 printf("%c NODE %016llx cnt=%d p=%016llx " 99 "type=%c depth=%d", 100 badc, 101 node_offset, node->count, node->parent, 102 (node->type ? node->type : '?'), depth); 103 printf(" mirror %016llx", node->mirror_tid); 104 if (QuietOpt < 3) { 105 printf(" fill="); 106 print_bigblock_fill(node_offset); 107 } 108 printf(" {\n"); 109 110 maxcount = (node->type == HAMMER_BTREE_TYPE_INTERNAL) ? 111 HAMMER_BTREE_INT_ELMS : HAMMER_BTREE_LEAF_ELMS; 112 113 for (i = 0; i < node->count && i < maxcount; ++i) { 114 elm = &node->elms[i]; 115 flags = print_elm_flags(node, node_offset, 116 elm, elm->base.btype, 117 left_bound, right_bound); 118 print_btree_elm(elm, i, node->type, flags, "ELM"); 119 } 120 if (node->type == HAMMER_BTREE_TYPE_INTERNAL) { 121 elm = &node->elms[i]; 122 flags = print_elm_flags(node, node_offset, 123 elm, 'I', 124 left_bound, right_bound); 125 print_btree_elm(elm, i, node->type, flags, "RBN"); 126 } 127 printf(" }\n"); 128 } 129 130 for (i = 0; i < node->count; ++i) { 131 elm = &node->elms[i]; 132 133 switch(node->type) { 134 case HAMMER_BTREE_TYPE_INTERNAL: 135 if (elm->internal.subtree_offset) { 136 print_btree_node(elm->internal.subtree_offset, 137 depth + 1, spike, 138 &elm[0].base, &elm[1].base); 139 } 140 break; 141 default: 142 break; 143 } 144 } 145 rel_buffer(buffer); 146 } 147 148 static 149 void 150 print_btree_elm(hammer_btree_elm_t elm, int i, u_int8_t type, 151 int flags, const char *label) 152 { 153 char flagstr[8] = { 0, '-', '-', '-', '-', '-', '-', 0 }; 154 155 flagstr[0] = flags ? 'B' : 'G'; 156 if (flags & FLAG_TOOFARLEFT) 157 flagstr[2] = 'L'; 158 if (flags & FLAG_TOOFARRIGHT) 159 flagstr[3] = 'R'; 160 if (flags & FLAG_BADTYPE) 161 flagstr[4] = 'T'; 162 if (flags & FLAG_BADCHILDPARENT) 163 flagstr[4] = 'C'; 164 165 printf("%s\t%s %2d %c ", 166 flagstr, label, i, 167 (elm->base.btype ? elm->base.btype : '?')); 168 printf("obj=%016llx key=%016llx lo=%08x rt=%02x ot=%02x\n", 169 elm->base.obj_id, 170 elm->base.key, 171 elm->base.localization, 172 elm->base.rec_type, 173 elm->base.obj_type); 174 printf("\t %c tids %016llx:%016llx ", 175 (elm->base.delete_tid ? 'd' : ' '), 176 elm->base.create_tid, 177 elm->base.delete_tid); 178 179 switch(type) { 180 case HAMMER_BTREE_TYPE_INTERNAL: 181 printf("suboff=%016llx", elm->internal.subtree_offset); 182 if (QuietOpt < 3) 183 printf(" mirror %016llx", elm->internal.mirror_tid); 184 break; 185 case HAMMER_BTREE_TYPE_LEAF: 186 switch(elm->base.btype) { 187 case HAMMER_BTREE_TYPE_RECORD: 188 printf("\n%s\t ", check_data_crc(elm)); 189 printf("dataoff=%016llx/%d", 190 elm->leaf.data_offset, elm->leaf.data_len); 191 if (QuietOpt < 3) { 192 printf(" crc=%04x", elm->leaf.data_crc); 193 printf("\n\t fills="); 194 print_bigblock_fill(elm->leaf.data_offset); 195 } 196 if (QuietOpt < 2) 197 print_record(elm); 198 break; 199 } 200 break; 201 default: 202 break; 203 } 204 printf("\n"); 205 } 206 207 static 208 int 209 print_elm_flags(hammer_node_ondisk_t node, hammer_off_t node_offset, 210 hammer_btree_elm_t elm, u_int8_t btype, 211 hammer_base_elm_t left_bound, hammer_base_elm_t right_bound) 212 { 213 int flags = 0; 214 215 switch(node->type) { 216 case HAMMER_BTREE_TYPE_INTERNAL: 217 if (elm->internal.subtree_offset) { 218 struct buffer_info *buffer = NULL; 219 hammer_node_ondisk_t subnode; 220 221 subnode = get_node(elm->internal.subtree_offset, 222 &buffer); 223 if (subnode->parent != node_offset) 224 flags |= FLAG_BADCHILDPARENT; 225 rel_buffer(buffer); 226 } 227 228 switch(btype) { 229 case HAMMER_BTREE_TYPE_INTERNAL: 230 if (left_bound == NULL || right_bound == NULL) 231 break; 232 if (hammer_btree_cmp(&elm->base, left_bound) < 0) 233 flags |= FLAG_TOOFARLEFT; 234 if (hammer_btree_cmp(&elm->base, right_bound) > 0) 235 flags |= FLAG_TOOFARRIGHT; 236 break; 237 case HAMMER_BTREE_TYPE_LEAF: 238 if (left_bound == NULL || right_bound == NULL) 239 break; 240 if (hammer_btree_cmp(&elm->base, left_bound) < 0) 241 flags |= FLAG_TOOFARLEFT; 242 if (hammer_btree_cmp(&elm->base, right_bound) >= 0) 243 flags |= FLAG_TOOFARRIGHT; 244 break; 245 default: 246 flags |= FLAG_BADTYPE; 247 break; 248 } 249 break; 250 case HAMMER_BTREE_TYPE_LEAF: 251 switch(btype) { 252 case HAMMER_BTREE_TYPE_RECORD: 253 if (left_bound == NULL || right_bound == NULL) 254 break; 255 if (hammer_btree_cmp(&elm->base, left_bound) < 0) 256 flags |= FLAG_TOOFARLEFT; 257 if (hammer_btree_cmp(&elm->base, right_bound) >= 0) 258 flags |= FLAG_TOOFARRIGHT; 259 break; 260 default: 261 flags |= FLAG_BADTYPE; 262 break; 263 } 264 break; 265 default: 266 flags |= FLAG_BADTYPE; 267 break; 268 } 269 return(flags); 270 } 271 272 static 273 void 274 print_bigblock_fill(hammer_off_t offset) 275 { 276 struct hammer_blockmap_layer1 layer1; 277 struct hammer_blockmap_layer2 layer2; 278 int fill; 279 280 blockmap_lookup(offset, &layer1, &layer2); 281 fill = layer2.bytes_free * 100 / HAMMER_LARGEBLOCK_SIZE; 282 fill = 100 - fill; 283 284 printf("z%d:%lld=%d%%", 285 HAMMER_ZONE_DECODE(offset), 286 (offset & ~HAMMER_OFF_ZONE_MASK) / HAMMER_LARGEBLOCK_SIZE, 287 fill 288 ); 289 } 290 291 /* 292 * Check the generic crc on a data element. Inodes record types are 293 * special in that some of their fields are not CRCed. 294 */ 295 static 296 const char * 297 check_data_crc(hammer_btree_elm_t elm) 298 { 299 struct buffer_info *data_buffer; 300 hammer_off_t data_offset; 301 int32_t data_len; 302 int32_t len; 303 u_int32_t crc; 304 char *ptr; 305 306 data_offset = elm->leaf.data_offset; 307 data_len = elm->leaf.data_len; 308 data_buffer = NULL; 309 if (data_offset == 0 || data_len == 0) 310 return("Z"); 311 312 crc = 0; 313 while (data_len) { 314 ptr = get_buffer_data(data_offset, &data_buffer, 0); 315 len = HAMMER_BUFSIZE - ((int)data_offset & HAMMER_BUFMASK); 316 if (len > data_len) 317 len = (int)data_len; 318 if (elm->leaf.base.rec_type == HAMMER_RECTYPE_INODE && 319 data_len == sizeof(struct hammer_inode_data)) { 320 crc = crc32_ext(ptr, HAMMER_INODE_CRCSIZE, crc); 321 } else { 322 crc = crc32_ext(ptr, len, crc); 323 } 324 data_len -= len; 325 data_offset += len; 326 } 327 if (data_buffer) 328 rel_buffer(data_buffer); 329 if (crc == elm->leaf.data_crc) 330 return(""); 331 return("B"); 332 } 333 334 static 335 void 336 print_record(hammer_btree_elm_t elm) 337 { 338 struct buffer_info *data_buffer; 339 hammer_off_t data_offset; 340 int32_t data_len; 341 hammer_data_ondisk_t data; 342 343 data_offset = elm->leaf.data_offset; 344 data_len = elm->leaf.data_len; 345 data_buffer = NULL; 346 347 if (data_offset) 348 data = get_buffer_data(data_offset, &data_buffer, 0); 349 else 350 data = NULL; 351 352 switch(elm->leaf.base.rec_type) { 353 case HAMMER_RECTYPE_INODE: 354 printf("\n%17s", ""); 355 printf("size=%lld nlinks=%lld", 356 data->inode.size, data->inode.nlinks); 357 if (QuietOpt < 1) { 358 printf(" mode=%05o uflags=%08x\n", 359 data->inode.mode, 360 data->inode.uflags); 361 printf("%17s", ""); 362 printf("ctime=%016llx pobjid=%016llx obj_type=%d\n", 363 data->inode.ctime, data->inode.parent_obj_id, 364 data->inode.obj_type); 365 printf("%17s", ""); 366 printf("mtime=%016llx", data->inode.mtime); 367 } 368 break; 369 case HAMMER_RECTYPE_DIRENTRY: 370 printf("\n%17s", ""); 371 data_len -= HAMMER_ENTRY_NAME_OFF; 372 printf("dir-entry ino=%016llx lo=%08x name=\"%*.*s\"", 373 data->entry.obj_id, 374 data->entry.localization, 375 data_len, data_len, data->entry.name); 376 break; 377 case HAMMER_RECTYPE_FIX: 378 switch(elm->leaf.base.key) { 379 case HAMMER_FIXKEY_SYMLINK: 380 data_len -= HAMMER_SYMLINK_NAME_OFF; 381 printf("\n%17s", ""); 382 printf("symlink=\"%*.*s\"", data_len, data_len, 383 data->symlink.name); 384 break; 385 default: 386 break; 387 } 388 break; 389 default: 390 break; 391 } 392 if (data_buffer) 393 rel_buffer(data_buffer); 394 } 395 396