sbin/hastctl/hastctl.c

   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 <libutil.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 (%NB)\n", (uintmax_t)res->hr_datasize,
 217             (intmax_t)res->hr_datasize);
 218         printf("    extentsize: %d (%NB)\n", res->hr_extentsize,
 219             (intmax_t)res->hr_extentsize);
 220         printf("    keepdirty: %d\n", res->hr_keepdirty);
 221         printf("    localoff: %ju\n", (uintmax_t)res->hr_localoff);
 222         printf("    resuid: %ju\n", (uintmax_t)res->hr_resuid);
 223         printf("    localcnt: %ju\n", (uintmax_t)res->hr_primary_localcnt);
 224         printf("    remotecnt: %ju\n", (uintmax_t)res->hr_primary_remotecnt);
 225         printf("    prevrole: %s\n", role2str(res->hr_previous_role));
 226
 227         return (0);
 228 }
 229
 230 static void
 231 control_dump(int argc, char *argv[])
 232 {
 233         struct hast_resource *res;
 234         int ec, ret;
 235
 236         /* Dump metadata of the given resource(s). */
 237
 238         ec = 0;
 239         if (argc == 0 || (argc == 1 && strcmp(argv[0], "all") == 0)) {
 240                 TAILQ_FOREACH(res, &cfg->hc_resources, hr_next) {
 241                         ret = dump_one(res);
 242                         if (ret != 0 && ec == 0)
 243                                 ec = ret;
 244                 }
 245         } else {
 246                 int ii;
 247
 248                 for (ii = 0; ii < argc; ii++) {
 249                         TAILQ_FOREACH(res, &cfg->hc_resources, hr_next) {
 250                                 if (strcmp(argv[ii], res->hr_name) == 0)
 251                                         break;
 252                         }
 253                         if (res == NULL) {
 254                                 pjdlog_error("Unknown resource %s.", argv[ii]);
 255                                 if (ec == 0)
 256                                         ec = EX_DATAERR;
 257                                 continue;
 258                         }
 259                         ret = dump_one(res);
 260                         if (ret != 0 && ec == 0)
 261                                 ec = ret;
 262                 }
 263         }
 264         exit(ec);
 265 }
 266
 267 static int
 268 control_set_role(struct nv *nv, const char *newrole)
 269 {
 270         const char *res, *oldrole;
 271         unsigned int ii;
 272         int error, ret;
 273
 274         ret = 0;
 275
 276         for (ii = 0; ; ii++) {
 277                 res = nv_get_string(nv, "resource%u", ii);
 278                 if (res == NULL)
 279                         break;
 280                 pjdlog_prefix_set("[%s] ", res);
 281                 error = nv_get_int16(nv, "error%u", ii);
 282                 if (error != 0) {
 283                         if (ret == 0)
 284                                 ret = error;
 285                         pjdlog_warning("Received error %d from hastd.", error);
 286                         continue;
 287                 }
 288                 oldrole = nv_get_string(nv, "role%u", ii);
 289                 if (strcmp(oldrole, newrole) == 0)
 290                         pjdlog_debug(2, "Role unchanged (%s).", oldrole);
 291                 else {
 292                         pjdlog_debug(1, "Role changed from %s to %s.", oldrole,
 293                             newrole);
 294                 }
 295         }
 296         pjdlog_prefix_set("%s", "");
 297         return (ret);
 298 }
 299
 300 static int
 301 control_status(struct nv *nv)
 302 {
 303         unsigned int ii;
 304         const char *str;
 305         int error, ret;
 306
 307         ret = 0;
 308
 309         for (ii = 0; ; ii++) {
 310                 str = nv_get_string(nv, "resource%u", ii);
 311                 if (str == NULL)
 312                         break;
 313                 printf("%s:\n", str);
 314                 error = nv_get_int16(nv, "error%u", ii);
 315                 if (error != 0) {
 316                         if (ret == 0)
 317                                 ret = error;
 318                         printf("  error: %d\n", error);
 319                         continue;
 320                 }
 321                 printf("  role: %s\n", nv_get_string(nv, "role%u", ii));
 322                 printf("  provname: %s\n",
 323                     nv_get_string(nv, "provname%u", ii));
 324                 printf("  localpath: %s\n",
 325                     nv_get_string(nv, "localpath%u", ii));
 326                 printf("  extentsize: %u (%NB)\n",
 327                     (unsigned int)nv_get_uint32(nv, "extentsize%u", ii),
 328                     (intmax_t)nv_get_uint32(nv, "extentsize%u", ii));
 329                 printf("  keepdirty: %u\n",
 330                     (unsigned int)nv_get_uint32(nv, "keepdirty%u", ii));
 331                 printf("  remoteaddr: %s\n",
 332                     nv_get_string(nv, "remoteaddr%u", ii));
 333                 str = nv_get_string(nv, "sourceaddr%u", ii);
 334                 if (str != NULL)
 335                         printf("  sourceaddr: %s\n", str);
 336                 printf("  replication: %s\n",
 337                     nv_get_string(nv, "replication%u", ii));
 338                 str = nv_get_string(nv, "status%u", ii);
 339                 if (str != NULL)
 340                         printf("  status: %s\n", str);
 341                 printf("  dirty: %ju (%NB)\n",
 342                     (uintmax_t)nv_get_uint64(nv, "dirty%u", ii),
 343                     (intmax_t)nv_get_uint64(nv, "dirty%u", ii));
 344                 printf("  statistics:\n");
 345                 printf("    reads: %ju\n",
 346                     (uint64_t)nv_get_uint64(nv, "stat_read%u", ii));
 347                 printf("    writes: %ju\n",
 348                     (uint64_t)nv_get_uint64(nv, "stat_write%u", ii));
 349                 printf("    deletes: %ju\n",
 350                     (uint64_t)nv_get_uint64(nv, "stat_delete%u", ii));
 351                 printf("    flushes: %ju\n",
 352                     (uint64_t)nv_get_uint64(nv, "stat_flush%u", ii));
 353                 printf("    activemap updates: %ju\n",
 354                     (uint64_t)nv_get_uint64(nv, "stat_activemap_update%u", ii));
 355         }
 356         return (ret);
 357 }
 358
 359 int
 360 main(int argc, char *argv[])
 361 {
 362         struct nv *nv;
 363         int64_t mediasize, extentsize, keepdirty;
 364         int cmd, debug, error, ii;
 365         const char *optstr;
 366
 367         debug = 0;
 368         mediasize = extentsize = keepdirty = 0;
 369
 370         if (argc == 1)
 371                 usage();
 372
 373         if (strcmp(argv[1], "create") == 0) {
 374                 cmd = CMD_CREATE;
 375                 optstr = "c:de:k:m:h";
 376         } else if (strcmp(argv[1], "role") == 0) {
 377                 cmd = CMD_ROLE;
 378                 optstr = "c:dh";
 379         } else if (strcmp(argv[1], "status") == 0) {
 380                 cmd = CMD_STATUS;
 381                 optstr = "c:dh";
 382         } else if (strcmp(argv[1], "dump") == 0) {
 383                 cmd = CMD_DUMP;
 384                 optstr = "c:dh";
 385         } else
 386                 usage();
 387
 388         argc--;
 389         argv++;
 390
 391         for (;;) {
 392                 int ch;
 393
 394                 ch = getopt(argc, argv, optstr);
 395                 if (ch == -1)
 396                         break;
 397                 switch (ch) {
 398                 case 'c':
 399                         cfgpath = optarg;
 400                         break;
 401                 case 'd':
 402                         debug++;
 403                         break;
 404                 case 'e':
 405                         if (expand_number(optarg, &extentsize) < 0)
 406                                 errx(EX_USAGE, "Invalid extentsize");
 407                         break;
 408                 case 'k':
 409                         if (expand_number(optarg, &keepdirty) < 0)
 410                                 errx(EX_USAGE, "Invalid keepdirty");
 411                         break;
 412                 case 'm':
 413                         if (expand_number(optarg, &mediasize) < 0)
 414                                 errx(EX_USAGE, "Invalid mediasize");
 415                         break;
 416                 case 'h':
 417                 default:
 418                         usage();
 419                 }
 420         }
 421         argc -= optind;
 422         argv += optind;
 423
 424         switch (cmd) {
 425         case CMD_CREATE:
 426         case CMD_ROLE:
 427                 if (argc == 0)
 428                         usage();
 429                 break;
 430         }
 431
 432         pjdlog_init(PJDLOG_MODE_STD);
 433         pjdlog_debug_set(debug);
 434
 435         cfg = yy_config_parse(cfgpath, true);
 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 command!");
 480         }
 481
 482         /* Setup control connection... */
 483         if (proto_client(NULL, 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, HAST_TIMEOUT) < 0) {
 490                 pjdlog_exit(EX_OSERR, "Unable to connect to hastd via %s",
 491                     cfg->hc_controladdr);
 492         }
 493
 494         if (drop_privs(NULL) != 0)
 495                 exit(EX_CONFIG);
 496
 497         /* Send the command to the server... */
 498         if (hast_proto_send(NULL, controlconn, nv, NULL, 0) < 0) {
 499                 pjdlog_exit(EX_UNAVAILABLE,
 500                     "Unable to send command to hastd via %s",
 501                     cfg->hc_controladdr);
 502         }
 503         nv_free(nv);
 504         /* ...and receive reply. */
 505         if (hast_proto_recv_hdr(controlconn, &nv) < 0) {
 506                 pjdlog_exit(EX_UNAVAILABLE,
 507                     "cannot receive reply from hastd via %s",
 508                     cfg->hc_controladdr);
 509         }
 510
 511         error = nv_get_int16(nv, "error");
 512         if (error != 0) {
 513                 pjdlog_exitx(EX_SOFTWARE, "Error %d received from hastd.",
 514                     error);
 515         }
 516         nv_set_error(nv, 0);
 517
 518         switch (cmd) {
 519         case CMD_ROLE:
 520                 error = control_set_role(nv, argv[0]);
 521                 break;
 522         case CMD_STATUS:
 523                 error = control_status(nv);
 524                 break;
 525         default:
 526                 assert(!"Impossible command!");
 527         }
 528
 529         exit(error);
 530 }