xref: /dragonfly/sbin/hammer/misc.c (revision e98bdfd3) 
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/misc.c,v 1.5 2008/06/26 04:07:57 dillon Exp $
35  */
36 
37 #include "hammer.h"
38 
39 const char *ScoreBoardFile;
40 
41 /*
42  * (taken from /usr/src/sys/vfs/hammer/hammer_btree.c)
43  *
44  * Compare two B-Tree elements, return -N, 0, or +N (e.g. similar to strcmp).
45  *
46  * Note that for this particular function a return value of -1, 0, or +1
47  * can denote a match if delete_tid is otherwise discounted.  A delete_tid
48  * of zero is considered to be 'infinity' in comparisons.
49  *
50  * See also hammer_rec_rb_compare() and hammer_rec_cmp() in hammer_object.c.
51  */
52 int
53 hammer_btree_cmp(hammer_base_elm_t key1, hammer_base_elm_t key2)
54 {
55 	if (key1->localization < key2->localization)
56 		return(-5);
57 	if (key1->localization > key2->localization)
58 		return(5);
59 
60 	if (key1->obj_id < key2->obj_id)
61 		return(-4);
62 	if (key1->obj_id > key2->obj_id)
63 		return(4);
64 
65 	if (key1->rec_type < key2->rec_type)
66 		return(-3);
67 	if (key1->rec_type > key2->rec_type)
68 		return(3);
69 
70 	if (key1->key < key2->key)
71 		return(-2);
72 	if (key1->key > key2->key)
73 		return(2);
74 
75 	if (key1->create_tid == 0) {
76 		if (key2->create_tid == 0)
77 			return(0);
78 		return(1);
79 	}
80 	if (key2->create_tid == 0)
81 		return(-1);
82 	if (key1->create_tid < key2->create_tid)
83 		return(-1);
84 	if (key1->create_tid > key2->create_tid)
85 		return(1);
86 	return(0);
87 }
88 
89 void
90 hammer_key_beg_init(hammer_base_elm_t base)
91 {
92 	bzero(base, sizeof(*base));
93 
94 	base->localization = HAMMER_MIN_LOCALIZATION;
95 	base->obj_id = HAMMER_MIN_OBJID;
96 	base->key = HAMMER_MIN_KEY;
97 	base->create_tid = 1;
98 	base->rec_type = HAMMER_MIN_RECTYPE;
99 }
100 
101 void
102 hammer_key_end_init(hammer_base_elm_t base)
103 {
104 	bzero(base, sizeof(*base));
105 
106 	base->localization = HAMMER_MAX_LOCALIZATION;
107 	base->obj_id = HAMMER_MAX_OBJID;
108 	base->key = HAMMER_MAX_KEY;
109 	base->create_tid = HAMMER_MAX_TID;
110 	base->rec_type = HAMMER_MAX_RECTYPE;
111 }
112 
113 int
114 hammer_crc_test_leaf(void *data, hammer_btree_leaf_elm_t leaf)
115 {
116 	hammer_crc_t crc;
117 
118 	if (leaf->data_len == 0) {
119 		crc = 0;
120 	} else {
121 		switch(leaf->base.rec_type) {
122 		case HAMMER_RECTYPE_INODE:
123 			if (leaf->data_len != sizeof(struct hammer_inode_data))
124 				return(0);
125 			crc = crc32(data, HAMMER_INODE_CRCSIZE);
126 			break;
127 		default:
128 			crc = crc32(data, leaf->data_len);
129 			break;
130 		}
131 	}
132 	return (leaf->data_crc == crc);
133 }
134 
135 void
136 score_printf(size_t i, size_t w, const char *ctl, ...)
137 {
138 	va_list va;
139 	size_t n;
140 	static size_t SSize;
141 	static int SFd = -1;
142 	static char ScoreBuf[1024];
143 
144 	if (ScoreBoardFile == NULL)
145 		return;
146 	assert(i + w < sizeof(ScoreBuf));
147 	if (SFd < 0) {
148 		SFd = open(ScoreBoardFile, O_RDWR|O_CREAT|O_TRUNC, 0644);
149 		if (SFd < 0)
150 			return;
151 		SSize = 0;
152 	}
153 	for (n = 0; n < i; ++n) {
154 		if (ScoreBuf[n] == 0)
155 			ScoreBuf[n] = ' ';
156 	}
157 	va_start(va, ctl);
158 	vsnprintf(ScoreBuf + i, w - 1, ctl, va);
159 	va_end(va);
160 	n = strlen(ScoreBuf + i);
161 	while (n < w - 1) {
162 		ScoreBuf[i + n] = ' ';
163 		++n;
164 	}
165 	ScoreBuf[i + n] = '\n';
166 	if (SSize < i + w)
167 		SSize = i + w;
168 	pwrite(SFd, ScoreBuf, SSize, 0);
169 }
170 
171 void
172 hammer_check_restrict(const char *filesystem)
173 {
174 	size_t rlen;
175 	int atslash;
176 
177 	if (RestrictTarget == NULL)
178 		return;
179 	rlen = strlen(RestrictTarget);
180 	if (strncmp(filesystem, RestrictTarget, rlen) != 0) {
181 		fprintf(stderr, "hammer-remote: restricted target\n");
182 		exit(1);
183 	}
184 	atslash = 1;
185 	while (filesystem[rlen]) {
186 		if (atslash &&
187 		    filesystem[rlen] == '.' &&
188 		    filesystem[rlen+1] == '.') {
189 			fprintf(stderr, "hammer-remote: '..' not allowed\n");
190 			exit(1);
191 		}
192 		if (filesystem[rlen] == '/')
193 			atslash = 1;
194 		else
195 			atslash = 0;
196 		++rlen;
197 	}
198 }
199 
200 int
201 getyn(void)
202 {
203 	char buf[256];
204 	int len;
205 
206 	if (fgets(buf, sizeof(buf), stdin) == NULL)
207 		return(0);
208 	len = strlen(buf);
209 	while (len && (buf[len-1] == '\n' || buf[len-1] == '\r'))
210 		--len;
211 	buf[len] = 0;
212 	if (strcmp(buf, "y") == 0 ||
213 	    strcmp(buf, "yes") == 0 ||
214 	    strcmp(buf, "Y") == 0 ||
215 	    strcmp(buf, "YES") == 0) {
216 		return(1);
217 	}
218 	return(0);
219 }
220 
221 int
222 hammer_fs_to_vol(const char *fs, struct hammer_ioc_volume_list *p)
223 {
224 	struct hammer_ioc_volume_list ioc;
225 	int fd;
226 
227 	fd = open(fs, O_RDONLY);
228 	if (fd < 0) {
229 		perror("open");
230 		return(-1);
231 	}
232 
233 	bzero(&ioc, sizeof(ioc));
234 	ioc.nvols = HAMMER_MAX_VOLUMES;
235 	ioc.vols = malloc(ioc.nvols * sizeof(*ioc.vols));
236 	if (ioc.vols == NULL) {
237 		perror("malloc");
238 		close(fd);
239 		return(-1);
240 	}
241 
242 	if (ioctl(fd, HAMMERIOC_LIST_VOLUMES, &ioc) < 0) {
243 		perror("ioctl");
244 		close(fd);
245 		free(ioc.vols);
246 		return(-1);
247 	}
248 
249 	bcopy(&ioc, p, sizeof(ioc));
250 	close(fd);
251 
252 	return(0);
253 }
254 
255 int
256 hammer_fs_to_rootvol(const char *fs, char *buf, int len)
257 {
258 	struct hammer_ioc_volume_list ioc;
259 	int i;
260 
261 	if (hammer_fs_to_vol(fs, &ioc) == -1)
262 		return(-1);
263 
264 	for (i = 0; i < ioc.nvols; i++) {
265 		if (ioc.vols[i].vol_no == HAMMER_ROOT_VOLNO) {
266 			strlcpy(buf, ioc.vols[i].device_name, len);
267 			break;
268 		}
269 	}
270 	assert(i != ioc.nvols);  /* root volume must exist */
271 
272 	free(ioc.vols);
273 	return(0);
274 }
275 
276 /*
277  * Functions and data structure for zone statistics
278  */
279 /*
280  * Each layer1 needs ((2^19) / 64) = 8192 uint64_t.
281  */
282 #define HAMMER_LAYER1_UINT64 8192
283 #define HAMMER_LAYER1_BYTES (HAMMER_LAYER1_UINT64 * sizeof(uint64_t))
284 
285 static int *l1_max = NULL;
286 static uint64_t **l1_bits = NULL;
287 
288 static __inline
289 int
290 hammer_set_layer_bits(uint64_t *bits, int i)
291 {
292 	int q, r;
293 
294 	q = i >> 6;
295 	r = i & ((1 << 6) - 1);
296 
297 	bits += q;
298 	if (!((*bits) & ((uint64_t)1 << r))) {
299 		(*bits) |= ((uint64_t)1 << r);
300 		return(1);
301 	}
302 	return(0);  /* already seen this block */
303 }
304 
305 static
306 void
307 hammer_extend_layer1_bits(int vol, int newsiz, int oldsiz)
308 {
309 	uint64_t *p;
310 
311 	assert(newsiz > oldsiz);
312 	assert(newsiz > 0 && oldsiz >= 0);
313 
314 	p = l1_bits[vol];
315 	if (p == NULL)
316 		p = malloc(HAMMER_LAYER1_BYTES * newsiz);
317 	else
318 		p = realloc(p, HAMMER_LAYER1_BYTES * newsiz);
319 	if (p == NULL)
320 		err(1, "alloc");
321 	l1_bits[vol] = p;
322 
323 	p += HAMMER_LAYER1_UINT64 * oldsiz;
324 	bzero((void*)p, HAMMER_LAYER1_BYTES * (newsiz - oldsiz));
325 }
326 
327 static
328 void
329 hammer_dump_layer1_bits(void)
330 {
331 	int i, j, n;
332 
333 	assert(l1_bits);
334 	printf("Layer1 bitmaps\n");
335 
336 	for (i = 0; i < HAMMER_MAX_VOLUMES; i++) {
337 		if (l1_max[i] != -1) {
338 			printf("volume=%d %p\n", i, l1_bits[i]);
339 			n = (l1_max[i] + 1) * HAMMER_LAYER1_UINT64;
340 			for (j = 0; j < n; j++) {
341 				printf("\tblock[%d][%d]=0x%016lX\n",
342 					i, j << 6, *(l1_bits[i] + j));
343 			}
344 		}
345 	}
346 }
347 
348 struct zone_stat*
349 hammer_init_zone_stat(void)
350 {
351 	return calloc(HAMMER_MAX_ZONES, sizeof(struct zone_stat));
352 }
353 
354 struct zone_stat*
355 hammer_init_zone_stat_bits(void)
356 {
357 	int i;
358 
359 	l1_max = calloc(HAMMER_MAX_VOLUMES, sizeof(int));
360 	if (l1_max == NULL)
361 		err(1, "calloc");
362 
363 	l1_bits = calloc(HAMMER_MAX_VOLUMES, sizeof(uint64_t*));
364 	if (l1_bits == NULL)
365 		err(1, "calloc");
366 
367 	for (i = 0; i < HAMMER_MAX_VOLUMES; i++) {
368 		l1_max[i] = -1;  /* +1 needs to be 0 */
369 		l1_bits[i] = NULL;
370 	}
371 	return(hammer_init_zone_stat());
372 }
373 
374 void
375 hammer_cleanup_zone_stat(struct zone_stat *stats)
376 {
377 	int i;
378 
379 	if (l1_bits) {
380 		if (DebugOpt)
381 			hammer_dump_layer1_bits();
382 		for (i = 0; i < HAMMER_MAX_VOLUMES; i++) {
383 			free(l1_bits[i]);
384 			l1_bits[i] = NULL;
385 		}
386 	}
387 
388 	free(l1_bits);
389 	l1_bits = NULL;
390 
391 	free(l1_max);
392 	l1_max = NULL;
393 
394 	free(stats);
395 }
396 
397 static
398 void
399 _hammer_add_zone_stat(struct zone_stat *stats, int zone,
400 			hammer_off_t bytes, int new_block, int new_item)
401 {
402 	struct zone_stat *sp = stats + zone;
403 
404 	if (new_block)
405 		sp->blocks++;
406 	if (new_item)
407 		sp->items++;
408 	sp->used += bytes;
409 }
410 
411 void
412 hammer_add_zone_stat(struct zone_stat *stats, hammer_off_t offset,
413 			hammer_off_t bytes)
414 {
415 	int zone, vol, i, j, new_block;
416 	uint64_t *p;
417 
418 	offset &= ~HAMMER_BIGBLOCK_MASK64;
419 	zone = HAMMER_ZONE_DECODE(offset);
420 	vol = HAMMER_VOL_DECODE(offset);
421 
422 	offset &= HAMMER_OFF_SHORT_MASK;  /* cut off volume bits from layer1 */
423 	i = HAMMER_BLOCKMAP_LAYER1_INDEX(offset);
424 	j = HAMMER_BLOCKMAP_LAYER2_INDEX(offset);
425 
426 	if (i > l1_max[vol]) {
427 		assert(i < 1024);  /* XXX hardcoded */
428 		hammer_extend_layer1_bits(vol, i + 1, l1_max[vol] + 1);
429 		l1_max[vol] = i;
430 	}
431 
432 	p = l1_bits[vol] + i * HAMMER_LAYER1_UINT64;
433 	new_block = hammer_set_layer_bits(p, j);
434 	_hammer_add_zone_stat(stats, zone, bytes, new_block, 1);
435 }
436 
437 /*
438  * If the same layer2 is used more than once the result will be wrong.
439  */
440 void
441 hammer_add_zone_stat_layer2(struct zone_stat *stats,
442 			struct hammer_blockmap_layer2 *layer2)
443 {
444 	_hammer_add_zone_stat(stats, layer2->zone,
445 		HAMMER_BIGBLOCK_SIZE - layer2->bytes_free, 1, 0);
446 }
447 
448 void
449 hammer_print_zone_stat(const struct zone_stat *stats)
450 {
451 	int i;
452 	double per;
453 	hammer_off_t total_blocks = 0;
454 	hammer_off_t total_items = 0;
455 	hammer_off_t total_used = 0;
456 	const struct zone_stat *p = stats;
457 
458 	printf("HAMMER zone statistics\n");
459 	printf("\tzone #  blocks       items              used[B]             used[%%]\n");
460 
461 	for (i = 0; i < HAMMER_MAX_ZONES; i++) {
462 		if (p->blocks)
463 			per = ((double)(p->used * 100)) /
464 				(p->blocks * HAMMER_BIGBLOCK_SIZE);
465 		else
466 			per = 0;
467 		printf("\tzone %-2d %-12ju %-18ju %-19ju %g\n",
468 			i, p->blocks, p->items, p->used, per);
469 		total_blocks += p->blocks;
470 		total_items += p->items;
471 		total_used += p->used;
472 		p++;
473 	}
474 
475 	/*
476 	 * Remember that zone0 is always 0% used and zone15 is
477 	 * always 100% used.
478 	 */
479 	if (total_blocks)
480 		per = ((double)(total_used * 100)) /
481 			(total_blocks * HAMMER_BIGBLOCK_SIZE);
482 	else
483 		per = 0;
484 
485 	printf("\t----------------------------------------------------------------------\n");
486 	printf("\ttotal   %-12ju %-18ju %-19ju %g\n",
487 		(uintmax_t)total_blocks, (uintmax_t)total_items,
488 		(uintmax_t)total_used, per);
489 }
490