xref: /freebsd/sbin/hastctl/hastctl.c (revision 7aa383846770374466b1dcb2cefd71bde9acf463)
1 /*-
2  * Copyright (c) 2009-2010 The FreeBSD Foundation
3  * All rights reserved.
4  *
5  * This software was developed by Pawel Jakub Dawidek under sponsorship from
6  * the FreeBSD Foundation.
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  * 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 the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32 
33 #include <sys/param.h>
34 #include <sys/disk.h>
35 #include <sys/ioctl.h>
36 #include <sys/stat.h>
37 #include <sys/sysctl.h>
38 
39 #include <assert.h>
40 #include <err.h>
41 #include <errno.h>
42 #include <fcntl.h>
43 #include <inttypes.h>
44 #include <limits.h>
45 #include <signal.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include <sysexits.h>
50 #include <unistd.h>
51 
52 #include <activemap.h>
53 
54 #include "hast.h"
55 #include "hast_proto.h"
56 #include "metadata.h"
57 #include "nv.h"
58 #include "pjdlog.h"
59 #include "proto.h"
60 #include "subr.h"
61 
62 /* Path to configuration file. */
63 static const char *cfgpath = HAST_CONFIG;
64 /* Hastd configuration. */
65 static struct hastd_config *cfg;
66 /* Control connection. */
67 static struct proto_conn *controlconn;
68 
69 enum {
70 	CMD_INVALID,
71 	CMD_CREATE,
72 	CMD_ROLE,
73 	CMD_STATUS,
74 	CMD_DUMP
75 };
76 
77 static __dead2 void
78 usage(void)
79 {
80 
81 	fprintf(stderr,
82 	    "usage: %s create [-d] [-c config] [-e extentsize] [-k keepdirty]\n"
83 	    "\t\t[-m mediasize] name ...\n",
84 	    getprogname());
85 	fprintf(stderr,
86 	    "       %s role [-d] [-c config] <init | primary | secondary> all | name ...\n",
87 	    getprogname());
88 	fprintf(stderr,
89 	    "       %s status [-d] [-c config] [all | name ...]\n",
90 	    getprogname());
91 	fprintf(stderr,
92 	    "       %s dump [-d] [-c config] [all | name ...]\n",
93 	    getprogname());
94 	exit(EX_USAGE);
95 }
96 
97 static int
98 create_one(struct hast_resource *res, intmax_t mediasize, intmax_t extentsize,
99     intmax_t keepdirty)
100 {
101 	unsigned char *buf;
102 	size_t mapsize;
103 	int ec;
104 
105 	ec = 0;
106 	pjdlog_prefix_set("[%s] ", res->hr_name);
107 
108 	if (provinfo(res, true) < 0) {
109 		ec = EX_NOINPUT;
110 		goto end;
111 	}
112 	if (mediasize == 0)
113 		mediasize = res->hr_local_mediasize;
114 	else if (mediasize > res->hr_local_mediasize) {
115 		pjdlog_error("Provided mediasize is larger than provider %s size.",
116 		    res->hr_localpath);
117 		ec = EX_DATAERR;
118 		goto end;
119 	}
120 	if (!powerof2(res->hr_local_sectorsize)) {
121 		pjdlog_error("Sector size of provider %s is not power of 2 (%u).",
122 		    res->hr_localpath, res->hr_local_sectorsize);
123 		ec = EX_DATAERR;
124 		goto end;
125 	}
126 	if (extentsize == 0)
127 		extentsize = HAST_EXTENTSIZE;
128 	if (extentsize < res->hr_local_sectorsize) {
129 		pjdlog_error("Extent size (%jd) is less than sector size (%u).",
130 		    (intmax_t)extentsize, res->hr_local_sectorsize);
131 		ec = EX_DATAERR;
132 		goto end;
133 	}
134 	if ((extentsize % res->hr_local_sectorsize) != 0) {
135 		pjdlog_error("Extent size (%jd) is not multiple of sector size (%u).",
136 		    (intmax_t)extentsize, res->hr_local_sectorsize);
137 		ec = EX_DATAERR;
138 		goto end;
139 	}
140 	mapsize = activemap_calc_ondisk_size(mediasize - METADATA_SIZE,
141 	    extentsize, res->hr_local_sectorsize);
142 	if (keepdirty == 0)
143 		keepdirty = HAST_KEEPDIRTY;
144 	res->hr_datasize = mediasize - METADATA_SIZE - mapsize;
145 	res->hr_extentsize = extentsize;
146 	res->hr_keepdirty = keepdirty;
147 
148 	res->hr_localoff = METADATA_SIZE + mapsize;
149 
150 	if (metadata_write(res) < 0) {
151 		ec = EX_IOERR;
152 		goto end;
153 	}
154 	buf = calloc(1, mapsize);
155 	if (buf == NULL) {
156 		pjdlog_error("Unable to allocate %zu bytes of memory for initial bitmap.",
157 		    mapsize);
158 		ec = EX_TEMPFAIL;
159 		goto end;
160 	}
161 	if (pwrite(res->hr_localfd, buf, mapsize, METADATA_SIZE) !=
162 	    (ssize_t)mapsize) {
163 		pjdlog_errno(LOG_ERR, "Unable to store initial bitmap on %s",
164 		    res->hr_localpath);
165 		free(buf);
166 		ec = EX_IOERR;
167 		goto end;
168 	}
169 	free(buf);
170 end:
171 	if (res->hr_localfd >= 0)
172 		close(res->hr_localfd);
173 	pjdlog_prefix_set("%s", "");
174 	return (ec);
175 }
176 
177 static void
178 control_create(int argc, char *argv[], intmax_t mediasize, intmax_t extentsize,
179     intmax_t keepdirty)
180 {
181 	struct hast_resource *res;
182 	int ec, ii, ret;
183 
184 	/* Initialize the given resources. */
185 	if (argc < 1)
186 		usage();
187 	ec = 0;
188 	for (ii = 0; ii < argc; ii++) {
189 		TAILQ_FOREACH(res, &cfg->hc_resources, hr_next) {
190 			if (strcmp(argv[ii], res->hr_name) == 0)
191 				break;
192 		}
193 		if (res == NULL) {
194 			pjdlog_error("Unknown resource %s.", argv[ii]);
195 			if (ec == 0)
196 				ec = EX_DATAERR;
197 			continue;
198 		}
199 		ret = create_one(res, mediasize, extentsize, keepdirty);
200 		if (ret != 0 && ec == 0)
201 			ec = ret;
202 	}
203 	exit(ec);
204 }
205 
206 static int
207 dump_one(struct hast_resource *res)
208 {
209 	int ret;
210 
211 	ret = metadata_read(res, false);
212 	if (ret != 0)
213 		return (ret);
214 
215 	printf("resource: %s\n", res->hr_name);
216 	printf("    datasize: %ju\n", (uintmax_t)res->hr_datasize);
217 	printf("    extentsize: %d\n", res->hr_extentsize);
218 	printf("    keepdirty: %d\n", res->hr_keepdirty);
219 	printf("    localoff: %ju\n", (uintmax_t)res->hr_localoff);
220 	printf("    resuid: %ju\n", (uintmax_t)res->hr_resuid);
221 	printf("    localcnt: %ju\n", (uintmax_t)res->hr_primary_localcnt);
222 	printf("    remotecnt: %ju\n", (uintmax_t)res->hr_primary_remotecnt);
223 	printf("    prevrole: %s\n", role2str(res->hr_previous_role));
224 
225 	return (0);
226 }
227 
228 static void
229 control_dump(int argc, char *argv[])
230 {
231 	struct hast_resource *res;
232 	int ec, ret;
233 
234 	/* Dump metadata of the given resource(s). */
235 
236 	ec = 0;
237 	if (argc == 0 || (argc == 1 && strcmp(argv[0], "all") == 0)) {
238 		TAILQ_FOREACH(res, &cfg->hc_resources, hr_next) {
239 			ret = dump_one(res);
240 			if (ret != 0 && ec == 0)
241 				ec = ret;
242 		}
243 	} else {
244 		int ii;
245 
246 		for (ii = 0; ii < argc; ii++) {
247 			TAILQ_FOREACH(res, &cfg->hc_resources, hr_next) {
248 				if (strcmp(argv[ii], res->hr_name) == 0)
249 					break;
250 			}
251 			if (res == NULL) {
252 				pjdlog_error("Unknown resource %s.", argv[ii]);
253 				if (ec == 0)
254 					ec = EX_DATAERR;
255 				continue;
256 			}
257 			ret = dump_one(res);
258 			if (ret != 0 && ec == 0)
259 				ec = ret;
260 		}
261 	}
262 	exit(ec);
263 }
264 
265 static int
266 control_set_role(struct nv *nv, const char *newrole)
267 {
268 	const char *res, *oldrole;
269 	unsigned int ii;
270 	int error, ret;
271 
272 	ret = 0;
273 
274 	for (ii = 0; ; ii++) {
275 		res = nv_get_string(nv, "resource%u", ii);
276 		if (res == NULL)
277 			break;
278 		pjdlog_prefix_set("[%s] ", res);
279 		error = nv_get_int16(nv, "error%u", ii);
280 		if (error != 0) {
281 			if (ret == 0)
282 				ret = error;
283 			pjdlog_warning("Received error %d from hastd.", error);
284 			continue;
285 		}
286 		oldrole = nv_get_string(nv, "role%u", ii);
287 		if (strcmp(oldrole, newrole) == 0)
288 			pjdlog_debug(2, "Role unchanged (%s).", oldrole);
289 		else {
290 			pjdlog_debug(1, "Role changed from %s to %s.", oldrole,
291 			    newrole);
292 		}
293 	}
294 	pjdlog_prefix_set("%s", "");
295 	return (ret);
296 }
297 
298 static int
299 control_status(struct nv *nv)
300 {
301 	unsigned int ii;
302 	const char *str;
303 	int error, ret;
304 
305 	ret = 0;
306 
307 	for (ii = 0; ; ii++) {
308 		str = nv_get_string(nv, "resource%u", ii);
309 		if (str == NULL)
310 			break;
311 		printf("%s:\n", str);
312 		error = nv_get_int16(nv, "error%u", ii);
313 		if (error != 0) {
314 			if (ret == 0)
315 				ret = error;
316 			printf("  error: %d\n", error);
317 			continue;
318 		}
319 		printf("  role: %s\n", nv_get_string(nv, "role%u", ii));
320 		printf("  provname: %s\n",
321 		    nv_get_string(nv, "provname%u", ii));
322 		printf("  localpath: %s\n",
323 		    nv_get_string(nv, "localpath%u", ii));
324 		printf("  extentsize: %u\n",
325 		    (unsigned int)nv_get_uint32(nv, "extentsize%u", ii));
326 		printf("  keepdirty: %u\n",
327 		    (unsigned int)nv_get_uint32(nv, "keepdirty%u", ii));
328 		printf("  remoteaddr: %s\n",
329 		    nv_get_string(nv, "remoteaddr%u", ii));
330 		printf("  replication: %s\n",
331 		    nv_get_string(nv, "replication%u", ii));
332 		str = nv_get_string(nv, "status%u", ii);
333 		if (str != NULL)
334 			printf("  status: %s\n", str);
335 		printf("  dirty: %ju bytes\n",
336 		    (uintmax_t)nv_get_uint64(nv, "dirty%u", ii));
337 	}
338 	return (ret);
339 }
340 
341 static int
342 numfromstr(const char *str, intmax_t *nump)
343 {
344 	intmax_t num;
345 	char *suffix;
346 	int rerrno;
347 
348 	rerrno = errno;
349 	errno = 0;
350 	num = strtoimax(str, &suffix, 0);
351 	if (errno == 0 && *suffix != '\0')
352 		errno = EINVAL;
353 	if (errno != 0)
354 		return (-1);
355 	*nump = num;
356 	errno = rerrno;
357 	return (0);
358 }
359 
360 int
361 main(int argc, char *argv[])
362 {
363 	struct nv *nv;
364 	intmax_t mediasize, extentsize, keepdirty;
365 	int cmd, debug, error, ii;
366 	const char *optstr;
367 
368 	debug = 0;
369 	mediasize = extentsize = keepdirty = 0;
370 
371 	if (argc == 1)
372 		usage();
373 
374 	if (strcmp(argv[1], "create") == 0) {
375 		cmd = CMD_CREATE;
376 		optstr = "c:de:k:m:h";
377 	} else if (strcmp(argv[1], "role") == 0) {
378 		cmd = CMD_ROLE;
379 		optstr = "c:dh";
380 	} else if (strcmp(argv[1], "status") == 0) {
381 		cmd = CMD_STATUS;
382 		optstr = "c:dh";
383 	} else if (strcmp(argv[1], "dump") == 0) {
384 		cmd = CMD_DUMP;
385 		optstr = "c:dh";
386 	} else
387 		usage();
388 
389 	argc--;
390 	argv++;
391 
392 	for (;;) {
393 		int ch;
394 
395 		ch = getopt(argc, argv, optstr);
396 		if (ch == -1)
397 			break;
398 		switch (ch) {
399 		case 'c':
400 			cfgpath = optarg;
401 			break;
402 		case 'd':
403 			debug++;
404 			break;
405 		case 'e':
406 			if (numfromstr(optarg, &extentsize) < 0)
407 				err(1, "Invalid extentsize");
408 			break;
409 		case 'k':
410 			if (numfromstr(optarg, &keepdirty) < 0)
411 				err(1, "Invalid keepdirty");
412 			break;
413 		case 'm':
414 			if (numfromstr(optarg, &mediasize) < 0)
415 				err(1, "Invalid mediasize");
416 			break;
417 		case 'h':
418 		default:
419 			usage();
420 		}
421 	}
422 	argc -= optind;
423 	argv += optind;
424 
425 	switch (cmd) {
426 	case CMD_CREATE:
427 	case CMD_ROLE:
428 		if (argc == 0)
429 			usage();
430 		break;
431 	}
432 
433 	pjdlog_debug_set(debug);
434 
435 	cfg = yy_config_parse(cfgpath);
436 	assert(cfg != NULL);
437 
438 	switch (cmd) {
439 	case CMD_CREATE:
440 		control_create(argc, argv, mediasize, extentsize, keepdirty);
441 		/* NOTREACHED */
442 		assert(!"What are we doing here?!");
443 		break;
444 	case CMD_DUMP:
445 		/* Dump metadata from local component of the given resource. */
446 		control_dump(argc, argv);
447 		/* NOTREACHED */
448 		assert(!"What are we doing here?!");
449 		break;
450 	case CMD_ROLE:
451 		/* Change role for the given resources. */
452 		if (argc < 2)
453 			usage();
454 		nv = nv_alloc();
455 		nv_add_uint8(nv, HASTCTL_CMD_SETROLE, "cmd");
456 		if (strcmp(argv[0], "init") == 0)
457 			nv_add_uint8(nv, HAST_ROLE_INIT, "role");
458 		else if (strcmp(argv[0], "primary") == 0)
459 			nv_add_uint8(nv, HAST_ROLE_PRIMARY, "role");
460 		else if (strcmp(argv[0], "secondary") == 0)
461 			nv_add_uint8(nv, HAST_ROLE_SECONDARY, "role");
462 		else
463 			usage();
464 		for (ii = 0; ii < argc - 1; ii++)
465 			nv_add_string(nv, argv[ii + 1], "resource%d", ii);
466 		break;
467 	case CMD_STATUS:
468 		/* Obtain status of the given resources. */
469 		nv = nv_alloc();
470 		nv_add_uint8(nv, HASTCTL_CMD_STATUS, "cmd");
471 		if (argc == 0)
472 			nv_add_string(nv, "all", "resource%d", 0);
473 		else {
474 			for (ii = 0; ii < argc; ii++)
475 				nv_add_string(nv, argv[ii], "resource%d", ii);
476 		}
477 		break;
478 	default:
479 		assert(!"Impossible role!");
480 	}
481 
482 	/* Setup control connection... */
483 	if (proto_client(cfg->hc_controladdr, &controlconn) < 0) {
484 		pjdlog_exit(EX_OSERR,
485 		    "Unable to setup control connection to %s",
486 		    cfg->hc_controladdr);
487 	}
488 	/* ...and connect to hastd. */
489 	if (proto_connect(controlconn) < 0) {
490 		pjdlog_exit(EX_OSERR, "Unable to connect to hastd via %s",
491 		    cfg->hc_controladdr);
492 	}
493 	/* Send the command to the server... */
494 	if (hast_proto_send(NULL, controlconn, nv, NULL, 0) < 0) {
495 		pjdlog_exit(EX_UNAVAILABLE,
496 		    "Unable to send command to hastd via %s",
497 		    cfg->hc_controladdr);
498 	}
499 	nv_free(nv);
500 	/* ...and receive reply. */
501 	if (hast_proto_recv(NULL, controlconn, &nv, NULL, 0) < 0) {
502 		pjdlog_exit(EX_UNAVAILABLE,
503 		    "cannot receive reply from hastd via %s",
504 		    cfg->hc_controladdr);
505 	}
506 
507 	error = nv_get_int16(nv, "error");
508 	if (error != 0) {
509 		pjdlog_exitx(EX_SOFTWARE, "Error %d received from hastd.",
510 		    error);
511 	}
512 	nv_set_error(nv, 0);
513 
514 	switch (cmd) {
515 	case CMD_ROLE:
516 		error = control_set_role(nv, argv[0]);
517 		break;
518 	case CMD_STATUS:
519 		error = control_status(nv);
520 		break;
521 	default:
522 		assert(!"Impossible role!");
523 	}
524 
525 	exit(error);
526 }
527