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