sys/geom/eli/g_eli_ctl.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2005-2011 Pawel Jakub Dawidek <pawel@dawidek.net>
   5  * All rights reserved.
   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  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/kernel.h>
  35 #include <sys/module.h>
  36 #include <sys/lock.h>
  37 #include <sys/mutex.h>
  38 #include <sys/bio.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/malloc.h>
  41 #include <sys/kthread.h>
  42 #include <sys/proc.h>
  43 #include <sys/sched.h>
  44 #include <sys/uio.h>
  45
  46 #include <vm/uma.h>
  47
  48 #include <geom/geom.h>
  49 #include <geom/geom_dbg.h>
  50 #include <geom/eli/g_eli.h>
  51
  52 MALLOC_DECLARE(M_ELI);
  53
  54 static void
  55 g_eli_ctl_attach(struct gctl_req *req, struct g_class *mp)
  56 {
  57         struct g_eli_metadata md;
  58         struct g_provider *pp;
  59         u_char *key, mkey[G_ELI_DATAIVKEYLEN];
  60         int *nargs, *detach, *readonly, *dryrunp;
  61         int keysize, error, nkey, dryrun, dummy;
  62         intmax_t *valp;
  63
  64         g_topology_assert();
  65
  66         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
  67         if (nargs == NULL) {
  68                 gctl_error(req, "No '%s' argument.", "nargs");
  69                 return;
  70         }
  71         if (*nargs != 1) {
  72                 gctl_error(req, "Invalid number of arguments.");
  73                 return;
  74         }
  75
  76         detach = gctl_get_paraml(req, "detach", sizeof(*detach));
  77         if (detach == NULL) {
  78                 gctl_error(req, "No '%s' argument.", "detach");
  79                 return;
  80         }
  81
  82         /* "keyno" is optional for backward compatibility */
  83         nkey = -1;
  84         valp = gctl_get_param(req, "keyno", &dummy);
  85         if (valp != NULL) {
  86                 valp = gctl_get_paraml(req, "keyno", sizeof(*valp));
  87                 if (valp != NULL)
  88                         nkey = *valp;
  89         }
  90         if (nkey < -1 || nkey >= G_ELI_MAXMKEYS) {
  91                 gctl_error(req, "Invalid '%s' argument.", "keyno");
  92                 return;
  93         }
  94
  95         readonly = gctl_get_paraml(req, "readonly", sizeof(*readonly));
  96         if (readonly == NULL) {
  97                 gctl_error(req, "No '%s' argument.", "readonly");
  98                 return;
  99         }
 100
 101         /* "dryrun" is optional for backward compatibility */
 102         dryrun = 0;
 103         dryrunp = gctl_get_param(req, "dryrun", &dummy);
 104         if (dryrunp != NULL) {
 105                 dryrunp = gctl_get_paraml(req, "dryrun", sizeof(*dryrunp));
 106                 if (dryrunp != NULL)
 107                         dryrun = *dryrunp;
 108         }
 109
 110         if (*detach && *readonly) {
 111                 gctl_error(req, "Options -d and -r are mutually exclusive.");
 112                 return;
 113         }
 114
 115         pp = gctl_get_provider(req, "arg0");
 116         if (pp == NULL)
 117                 return;
 118         error = g_eli_read_metadata(mp, pp, &md);
 119         if (error != 0) {
 120                 gctl_error(req, "Cannot read metadata from %s (error=%d).",
 121                     pp->name, error);
 122                 return;
 123         }
 124         if (md.md_keys == 0x00) {
 125                 explicit_bzero(&md, sizeof(md));
 126                 gctl_error(req, "No valid keys on %s.", pp->name);
 127                 return;
 128         }
 129         if (!eli_metadata_crypto_supported(&md)) {
 130                 explicit_bzero(&md, sizeof(md));
 131                 gctl_error(req, "Invalid or unsupported algorithms.");
 132                 return;
 133         }
 134
 135         key = gctl_get_param(req, "key", &keysize);
 136         if (key == NULL || keysize != G_ELI_USERKEYLEN) {
 137                 explicit_bzero(&md, sizeof(md));
 138                 gctl_error(req, "No '%s' argument.", "key");
 139                 return;
 140         }
 141
 142         if (nkey == -1)
 143                 error = g_eli_mkey_decrypt_any(&md, key, mkey, &nkey);
 144         else
 145                 error = g_eli_mkey_decrypt(&md, key, mkey, nkey);
 146         explicit_bzero(key, keysize);
 147         if (error == -1) {
 148                 explicit_bzero(&md, sizeof(md));
 149                 gctl_error(req, "Wrong key for %s.", pp->name);
 150                 return;
 151         } else if (error > 0) {
 152                 explicit_bzero(&md, sizeof(md));
 153                 gctl_error(req, "Cannot decrypt Master Key for %s (error=%d).",
 154                     pp->name, error);
 155                 return;
 156         }
 157         G_ELI_DEBUG(1, "Using Master Key %u for %s.", nkey, pp->name);
 158
 159         if (*detach)
 160                 md.md_flags |= G_ELI_FLAG_WO_DETACH;
 161         if (*readonly)
 162                 md.md_flags |= G_ELI_FLAG_RO;
 163         if (!dryrun)
 164                 g_eli_create(req, mp, pp, &md, mkey, nkey);
 165         explicit_bzero(mkey, sizeof(mkey));
 166         explicit_bzero(&md, sizeof(md));
 167 }
 168
 169 static struct g_eli_softc *
 170 g_eli_find_device(struct g_class *mp, const char *prov)
 171 {
 172         struct g_eli_softc *sc;
 173         struct g_geom *gp;
 174         struct g_provider *pp;
 175         struct g_consumer *cp;
 176
 177         if (strncmp(prov, _PATH_DEV, strlen(_PATH_DEV)) == 0)
 178                 prov += strlen(_PATH_DEV);
 179         LIST_FOREACH(gp, &mp->geom, geom) {
 180                 sc = gp->softc;
 181                 if (sc == NULL)
 182                         continue;
 183                 pp = LIST_FIRST(&gp->provider);
 184                 if (pp != NULL && strcmp(pp->name, prov) == 0)
 185                         return (sc);
 186                 cp = LIST_FIRST(&gp->consumer);
 187                 if (cp != NULL && cp->provider != NULL &&
 188                     strcmp(cp->provider->name, prov) == 0) {
 189                         return (sc);
 190                 }
 191         }
 192         return (NULL);
 193 }
 194
 195 static void
 196 g_eli_ctl_detach(struct gctl_req *req, struct g_class *mp)
 197 {
 198         struct g_eli_softc *sc;
 199         int *force, *last, *nargs, error;
 200         const char *prov;
 201         char param[16];
 202         int i;
 203
 204         g_topology_assert();
 205
 206         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
 207         if (nargs == NULL) {
 208                 gctl_error(req, "No '%s' argument.", "nargs");
 209                 return;
 210         }
 211         if (*nargs <= 0) {
 212                 gctl_error(req, "Missing device(s).");
 213                 return;
 214         }
 215         force = gctl_get_paraml(req, "force", sizeof(*force));
 216         if (force == NULL) {
 217                 gctl_error(req, "No '%s' argument.", "force");
 218                 return;
 219         }
 220         last = gctl_get_paraml(req, "last", sizeof(*last));
 221         if (last == NULL) {
 222                 gctl_error(req, "No '%s' argument.", "last");
 223                 return;
 224         }
 225
 226         for (i = 0; i < *nargs; i++) {
 227                 snprintf(param, sizeof(param), "arg%d", i);
 228                 prov = gctl_get_asciiparam(req, param);
 229                 if (prov == NULL) {
 230                         gctl_error(req, "No 'arg%d' argument.", i);
 231                         return;
 232                 }
 233                 sc = g_eli_find_device(mp, prov);
 234                 if (sc == NULL) {
 235                         gctl_error(req, "No such device: %s.", prov);
 236                         return;
 237                 }
 238                 if (*last) {
 239                         sc->sc_flags |= G_ELI_FLAG_RW_DETACH;
 240                         sc->sc_geom->access = g_eli_access;
 241                 } else {
 242                         error = g_eli_destroy(sc, *force ? TRUE : FALSE);
 243                         if (error != 0) {
 244                                 gctl_error(req,
 245                                     "Cannot destroy device %s (error=%d).",
 246                                     sc->sc_name, error);
 247                                 return;
 248                         }
 249                 }
 250         }
 251 }
 252
 253 static void
 254 g_eli_ctl_onetime(struct gctl_req *req, struct g_class *mp)
 255 {
 256         struct g_eli_metadata md;
 257         struct g_provider *pp;
 258         const char *name;
 259         intmax_t *keylen, *sectorsize;
 260         u_char mkey[G_ELI_DATAIVKEYLEN];
 261         int *nargs, *detach, *noautoresize, *notrim;
 262
 263         g_topology_assert();
 264         bzero(&md, sizeof(md));
 265
 266         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
 267         if (nargs == NULL) {
 268                 gctl_error(req, "No '%s' argument.", "nargs");
 269                 return;
 270         }
 271         if (*nargs != 1) {
 272                 gctl_error(req, "Invalid number of arguments.");
 273                 return;
 274         }
 275
 276         strlcpy(md.md_magic, G_ELI_MAGIC, sizeof(md.md_magic));
 277         md.md_version = G_ELI_VERSION;
 278         md.md_flags |= G_ELI_FLAG_ONETIME;
 279         md.md_flags |= G_ELI_FLAG_AUTORESIZE;
 280
 281         detach = gctl_get_paraml(req, "detach", sizeof(*detach));
 282         if (detach != NULL && *detach)
 283                 md.md_flags |= G_ELI_FLAG_WO_DETACH;
 284         noautoresize = gctl_get_paraml(req, "noautoresize",
 285             sizeof(*noautoresize));
 286         if (noautoresize != NULL && *noautoresize)
 287                 md.md_flags &= ~G_ELI_FLAG_AUTORESIZE;
 288         notrim = gctl_get_paraml(req, "notrim", sizeof(*notrim));
 289         if (notrim != NULL && *notrim)
 290                 md.md_flags |= G_ELI_FLAG_NODELETE;
 291
 292         md.md_ealgo = CRYPTO_ALGORITHM_MIN - 1;
 293         name = gctl_get_asciiparam(req, "aalgo");
 294         if (name == NULL) {
 295                 gctl_error(req, "No '%s' argument.", "aalgo");
 296                 return;
 297         }
 298         if (*name != '\0') {
 299                 md.md_aalgo = g_eli_str2aalgo(name);
 300                 if (md.md_aalgo >= CRYPTO_ALGORITHM_MIN &&
 301                     md.md_aalgo <= CRYPTO_ALGORITHM_MAX) {
 302                         md.md_flags |= G_ELI_FLAG_AUTH;
 303                 } else {
 304                         /*
 305                          * For backward compatibility, check if the -a option
 306                          * was used to provide encryption algorithm.
 307                          */
 308                         md.md_ealgo = g_eli_str2ealgo(name);
 309                         if (md.md_ealgo < CRYPTO_ALGORITHM_MIN ||
 310                             md.md_ealgo > CRYPTO_ALGORITHM_MAX) {
 311                                 gctl_error(req,
 312                                     "Invalid authentication algorithm.");
 313                                 return;
 314                         } else {
 315                                 gctl_error(req, "warning: The -e option, not "
 316                                     "the -a option is now used to specify "
 317                                     "encryption algorithm to use.");
 318                         }
 319                 }
 320         }
 321
 322         if (md.md_ealgo < CRYPTO_ALGORITHM_MIN ||
 323             md.md_ealgo > CRYPTO_ALGORITHM_MAX) {
 324                 name = gctl_get_asciiparam(req, "ealgo");
 325                 if (name == NULL) {
 326                         gctl_error(req, "No '%s' argument.", "ealgo");
 327                         return;
 328                 }
 329                 md.md_ealgo = g_eli_str2ealgo(name);
 330                 if (md.md_ealgo < CRYPTO_ALGORITHM_MIN ||
 331                     md.md_ealgo > CRYPTO_ALGORITHM_MAX) {
 332                         gctl_error(req, "Invalid encryption algorithm.");
 333                         return;
 334                 }
 335         }
 336
 337         keylen = gctl_get_paraml(req, "keylen", sizeof(*keylen));
 338         if (keylen == NULL) {
 339                 gctl_error(req, "No '%s' argument.", "keylen");
 340                 return;
 341         }
 342         md.md_keylen = g_eli_keylen(md.md_ealgo, *keylen);
 343         if (md.md_keylen == 0) {
 344                 gctl_error(req, "Invalid '%s' argument.", "keylen");
 345                 return;
 346         }
 347
 348         /* Not important here. */
 349         md.md_provsize = 0;
 350         /* Not important here. */
 351         bzero(md.md_salt, sizeof(md.md_salt));
 352
 353         md.md_keys = 0x01;
 354         arc4rand(mkey, sizeof(mkey), 0);
 355
 356         /* Not important here. */
 357         bzero(md.md_hash, sizeof(md.md_hash));
 358
 359         pp = gctl_get_provider(req, "arg0");
 360         if (pp == NULL)
 361                 return;
 362
 363         sectorsize = gctl_get_paraml(req, "sectorsize", sizeof(*sectorsize));
 364         if (sectorsize == NULL) {
 365                 gctl_error(req, "No '%s' argument.", "sectorsize");
 366                 return;
 367         }
 368         if (*sectorsize == 0)
 369                 md.md_sectorsize = pp->sectorsize;
 370         else {
 371                 if (*sectorsize < 0 || (*sectorsize % pp->sectorsize) != 0) {
 372                         gctl_error(req, "Invalid sector size.");
 373                         return;
 374                 }
 375                 if (*sectorsize > PAGE_SIZE) {
 376                         gctl_error(req, "warning: Using sectorsize bigger than "
 377                             "the page size!");
 378                 }
 379                 md.md_sectorsize = *sectorsize;
 380         }
 381
 382         g_eli_create(req, mp, pp, &md, mkey, -1);
 383         explicit_bzero(mkey, sizeof(mkey));
 384         explicit_bzero(&md, sizeof(md));
 385 }
 386
 387 static void
 388 g_eli_ctl_configure(struct gctl_req *req, struct g_class *mp)
 389 {
 390         struct g_eli_softc *sc;
 391         struct g_eli_metadata md;
 392         struct g_provider *pp;
 393         struct g_consumer *cp;
 394         char param[16];
 395         const char *prov;
 396         u_char *sector;
 397         int *nargs, *boot, *noboot, *trim, *notrim, *geliboot, *nogeliboot;
 398         int *displaypass, *nodisplaypass, *autoresize, *noautoresize;
 399         int zero, error, changed;
 400         u_int i;
 401
 402         g_topology_assert();
 403
 404         changed = 0;
 405         zero = 0;
 406
 407         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
 408         if (nargs == NULL) {
 409                 gctl_error(req, "No '%s' argument.", "nargs");
 410                 return;
 411         }
 412         if (*nargs <= 0) {
 413                 gctl_error(req, "Missing device(s).");
 414                 return;
 415         }
 416
 417         boot = gctl_get_paraml(req, "boot", sizeof(*boot));
 418         if (boot == NULL)
 419                 boot = &zero;
 420         noboot = gctl_get_paraml(req, "noboot", sizeof(*noboot));
 421         if (noboot == NULL)
 422                 noboot = &zero;
 423         if (*boot && *noboot) {
 424                 gctl_error(req, "Options -b and -B are mutually exclusive.");
 425                 return;
 426         }
 427         if (*boot || *noboot)
 428                 changed = 1;
 429
 430         trim = gctl_get_paraml(req, "trim", sizeof(*trim));
 431         if (trim == NULL)
 432                 trim = &zero;
 433         notrim = gctl_get_paraml(req, "notrim", sizeof(*notrim));
 434         if (notrim == NULL)
 435                 notrim = &zero;
 436         if (*trim && *notrim) {
 437                 gctl_error(req, "Options -t and -T are mutually exclusive.");
 438                 return;
 439         }
 440         if (*trim || *notrim)
 441                 changed = 1;
 442
 443         geliboot = gctl_get_paraml(req, "geliboot", sizeof(*geliboot));
 444         if (geliboot == NULL)
 445                 geliboot = &zero;
 446         nogeliboot = gctl_get_paraml(req, "nogeliboot", sizeof(*nogeliboot));
 447         if (nogeliboot == NULL)
 448                 nogeliboot = &zero;
 449         if (*geliboot && *nogeliboot) {
 450                 gctl_error(req, "Options -g and -G are mutually exclusive.");
 451                 return;
 452         }
 453         if (*geliboot || *nogeliboot)
 454                 changed = 1;
 455
 456         displaypass = gctl_get_paraml(req, "displaypass", sizeof(*displaypass));
 457         if (displaypass == NULL)
 458                 displaypass = &zero;
 459         nodisplaypass = gctl_get_paraml(req, "nodisplaypass", sizeof(*nodisplaypass));
 460         if (nodisplaypass == NULL)
 461                 nodisplaypass = &zero;
 462         if (*displaypass && *nodisplaypass) {
 463                 gctl_error(req, "Options -d and -D are mutually exclusive.");
 464                 return;
 465         }
 466         if (*displaypass || *nodisplaypass)
 467                 changed = 1;
 468
 469         autoresize = gctl_get_paraml(req, "autoresize", sizeof(*autoresize));
 470         if (autoresize == NULL)
 471                 autoresize = &zero;
 472         noautoresize = gctl_get_paraml(req, "noautoresize",
 473             sizeof(*noautoresize));
 474         if (noautoresize == NULL)
 475                 noautoresize = &zero;
 476         if (*autoresize && *noautoresize) {
 477                 gctl_error(req, "Options -r and -R are mutually exclusive.");
 478                 return;
 479         }
 480         if (*autoresize || *noautoresize)
 481                 changed = 1;
 482
 483         if (!changed) {
 484                 gctl_error(req, "No option given.");
 485                 return;
 486         }
 487
 488         for (i = 0; i < *nargs; i++) {
 489                 snprintf(param, sizeof(param), "arg%d", i);
 490                 prov = gctl_get_asciiparam(req, param);
 491                 if (prov == NULL) {
 492                         gctl_error(req, "No 'arg%d' argument.", i);
 493                         return;
 494                 }
 495                 sc = g_eli_find_device(mp, prov);
 496                 if (sc == NULL) {
 497                         /*
 498                          * We ignore not attached providers, userland part will
 499                          * take care of them.
 500                          */
 501                         G_ELI_DEBUG(1, "Skipping configuration of not attached "
 502                             "provider %s.", prov);
 503                         continue;
 504                 }
 505                 if (sc->sc_flags & G_ELI_FLAG_RO) {
 506                         gctl_error(req, "Cannot change configuration of "
 507                             "read-only provider %s.", prov);
 508                         continue;
 509                 }
 510
 511                 if (*boot && (sc->sc_flags & G_ELI_FLAG_BOOT)) {
 512                         G_ELI_DEBUG(1, "BOOT flag already configured for %s.",
 513                             prov);
 514                         continue;
 515                 } else if (*noboot && !(sc->sc_flags & G_ELI_FLAG_BOOT)) {
 516                         G_ELI_DEBUG(1, "BOOT flag not configured for %s.",
 517                             prov);
 518                         continue;
 519                 }
 520
 521                 if (*notrim && (sc->sc_flags & G_ELI_FLAG_NODELETE)) {
 522                         G_ELI_DEBUG(1, "TRIM disable flag already configured for %s.",
 523                             prov);
 524                         continue;
 525                 } else if (*trim && !(sc->sc_flags & G_ELI_FLAG_NODELETE)) {
 526                         G_ELI_DEBUG(1, "TRIM disable flag not configured for %s.",
 527                             prov);
 528                         continue;
 529                 }
 530
 531                 if (*geliboot && (sc->sc_flags & G_ELI_FLAG_GELIBOOT)) {
 532                         G_ELI_DEBUG(1, "GELIBOOT flag already configured for %s.",
 533                             prov);
 534                         continue;
 535                 } else if (*nogeliboot && !(sc->sc_flags & G_ELI_FLAG_GELIBOOT)) {
 536                         G_ELI_DEBUG(1, "GELIBOOT flag not configured for %s.",
 537                             prov);
 538                         continue;
 539                 }
 540
 541                 if (*displaypass && (sc->sc_flags & G_ELI_FLAG_GELIDISPLAYPASS)) {
 542                         G_ELI_DEBUG(1, "GELIDISPLAYPASS flag already configured for %s.",
 543                             prov);
 544                         continue;
 545                 } else if (*nodisplaypass &&
 546                     !(sc->sc_flags & G_ELI_FLAG_GELIDISPLAYPASS)) {
 547                         G_ELI_DEBUG(1, "GELIDISPLAYPASS flag not configured for %s.",
 548                             prov);
 549                         continue;
 550                 }
 551
 552                 if (*autoresize && (sc->sc_flags & G_ELI_FLAG_AUTORESIZE)) {
 553                         G_ELI_DEBUG(1, "AUTORESIZE flag already configured for %s.",
 554                             prov);
 555                         continue;
 556                 } else if (*noautoresize &&
 557                     !(sc->sc_flags & G_ELI_FLAG_AUTORESIZE)) {
 558                         G_ELI_DEBUG(1, "AUTORESIZE flag not configured for %s.",
 559                             prov);
 560                         continue;
 561                 }
 562
 563                 if (!(sc->sc_flags & G_ELI_FLAG_ONETIME)) {
 564                         /*
 565                          * ONETIME providers don't write metadata to
 566                          * disk, so don't try reading it.  This means
 567                          * we're bit-flipping uninitialized memory in md
 568                          * below, but that's OK; we don't do anything
 569                          * with it later.
 570                          */
 571                         cp = LIST_FIRST(&sc->sc_geom->consumer);
 572                         pp = cp->provider;
 573                         error = g_eli_read_metadata(mp, pp, &md);
 574                         if (error != 0) {
 575                             gctl_error(req,
 576                                 "Cannot read metadata from %s (error=%d).",
 577                                 prov, error);
 578                             continue;
 579                         }
 580                 }
 581
 582                 if (*boot) {
 583                         md.md_flags |= G_ELI_FLAG_BOOT;
 584                         sc->sc_flags |= G_ELI_FLAG_BOOT;
 585                 } else if (*noboot) {
 586                         md.md_flags &= ~G_ELI_FLAG_BOOT;
 587                         sc->sc_flags &= ~G_ELI_FLAG_BOOT;
 588                 }
 589
 590                 if (*notrim) {
 591                         md.md_flags |= G_ELI_FLAG_NODELETE;
 592                         sc->sc_flags |= G_ELI_FLAG_NODELETE;
 593                 } else if (*trim) {
 594                         md.md_flags &= ~G_ELI_FLAG_NODELETE;
 595                         sc->sc_flags &= ~G_ELI_FLAG_NODELETE;
 596                 }
 597
 598                 if (*geliboot) {
 599                         md.md_flags |= G_ELI_FLAG_GELIBOOT;
 600                         sc->sc_flags |= G_ELI_FLAG_GELIBOOT;
 601                 } else if (*nogeliboot) {
 602                         md.md_flags &= ~G_ELI_FLAG_GELIBOOT;
 603                         sc->sc_flags &= ~G_ELI_FLAG_GELIBOOT;
 604                 }
 605
 606                 if (*displaypass) {
 607                         md.md_flags |= G_ELI_FLAG_GELIDISPLAYPASS;
 608                         sc->sc_flags |= G_ELI_FLAG_GELIDISPLAYPASS;
 609                 } else if (*nodisplaypass) {
 610                         md.md_flags &= ~G_ELI_FLAG_GELIDISPLAYPASS;
 611                         sc->sc_flags &= ~G_ELI_FLAG_GELIDISPLAYPASS;
 612                 }
 613
 614                 if (*autoresize) {
 615                         md.md_flags |= G_ELI_FLAG_AUTORESIZE;
 616                         sc->sc_flags |= G_ELI_FLAG_AUTORESIZE;
 617                 } else if (*noautoresize) {
 618                         md.md_flags &= ~G_ELI_FLAG_AUTORESIZE;
 619                         sc->sc_flags &= ~G_ELI_FLAG_AUTORESIZE;
 620                 }
 621
 622                 if (sc->sc_flags & G_ELI_FLAG_ONETIME) {
 623                         /* There's no metadata on disk so we are done here. */
 624                         continue;
 625                 }
 626
 627                 sector = malloc(pp->sectorsize, M_ELI, M_WAITOK | M_ZERO);
 628                 eli_metadata_encode(&md, sector);
 629                 error = g_write_data(cp, pp->mediasize - pp->sectorsize, sector,
 630                     pp->sectorsize);
 631                 if (error != 0) {
 632                         gctl_error(req,
 633                             "Cannot store metadata on %s (error=%d).",
 634                             prov, error);
 635                 }
 636                 explicit_bzero(&md, sizeof(md));
 637                 zfree(sector, M_ELI);
 638         }
 639 }
 640
 641 static void
 642 g_eli_ctl_setkey(struct gctl_req *req, struct g_class *mp)
 643 {
 644         struct g_eli_softc *sc;
 645         struct g_eli_metadata md;
 646         struct g_provider *pp;
 647         struct g_consumer *cp;
 648         const char *name;
 649         u_char *key, *mkeydst, *sector;
 650         intmax_t *valp;
 651         int keysize, nkey, error;
 652
 653         g_topology_assert();
 654
 655         name = gctl_get_asciiparam(req, "arg0");
 656         if (name == NULL) {
 657                 gctl_error(req, "No 'arg%u' argument.", 0);
 658                 return;
 659         }
 660         key = gctl_get_param(req, "key", &keysize);
 661         if (key == NULL || keysize != G_ELI_USERKEYLEN) {
 662                 gctl_error(req, "No '%s' argument.", "key");
 663                 return;
 664         }
 665         sc = g_eli_find_device(mp, name);
 666         if (sc == NULL) {
 667                 gctl_error(req, "Provider %s is invalid.", name);
 668                 return;
 669         }
 670         if (sc->sc_flags & G_ELI_FLAG_RO) {
 671                 gctl_error(req, "Cannot change keys for read-only provider.");
 672                 return;
 673         }
 674         cp = LIST_FIRST(&sc->sc_geom->consumer);
 675         pp = cp->provider;
 676
 677         error = g_eli_read_metadata(mp, pp, &md);
 678         if (error != 0) {
 679                 gctl_error(req, "Cannot read metadata from %s (error=%d).",
 680                     name, error);
 681                 return;
 682         }
 683
 684         valp = gctl_get_paraml(req, "keyno", sizeof(*valp));
 685         if (valp == NULL) {
 686                 gctl_error(req, "No '%s' argument.", "keyno");
 687                 return;
 688         }
 689         if (*valp != -1)
 690                 nkey = *valp;
 691         else
 692                 nkey = sc->sc_nkey;
 693         if (nkey < 0 || nkey >= G_ELI_MAXMKEYS) {
 694                 gctl_error(req, "Invalid '%s' argument.", "keyno");
 695                 return;
 696         }
 697
 698         valp = gctl_get_paraml(req, "iterations", sizeof(*valp));
 699         if (valp == NULL) {
 700                 gctl_error(req, "No '%s' argument.", "iterations");
 701                 return;
 702         }
 703         /* Check if iterations number should and can be changed. */
 704         if (*valp != -1 && md.md_iterations == -1) {
 705                 md.md_iterations = *valp;
 706         } else if (*valp != -1 && *valp != md.md_iterations) {
 707                 if (bitcount32(md.md_keys) != 1) {
 708                         gctl_error(req, "To be able to use '-i' option, only "
 709                             "one key can be defined.");
 710                         return;
 711                 }
 712                 if (md.md_keys != (1 << nkey)) {
 713                         gctl_error(req, "Only already defined key can be "
 714                             "changed when '-i' option is used.");
 715                         return;
 716                 }
 717                 md.md_iterations = *valp;
 718         }
 719
 720         mkeydst = md.md_mkeys + nkey * G_ELI_MKEYLEN;
 721         md.md_keys |= (1 << nkey);
 722
 723         bcopy(sc->sc_mkey, mkeydst, sizeof(sc->sc_mkey));
 724
 725         /* Encrypt Master Key with the new key. */
 726         error = g_eli_mkey_encrypt(md.md_ealgo, key, md.md_keylen, mkeydst);
 727         explicit_bzero(key, keysize);
 728         if (error != 0) {
 729                 explicit_bzero(&md, sizeof(md));
 730                 gctl_error(req, "Cannot encrypt Master Key (error=%d).", error);
 731                 return;
 732         }
 733
 734         sector = malloc(pp->sectorsize, M_ELI, M_WAITOK | M_ZERO);
 735         /* Store metadata with fresh key. */
 736         eli_metadata_encode(&md, sector);
 737         explicit_bzero(&md, sizeof(md));
 738         error = g_write_data(cp, pp->mediasize - pp->sectorsize, sector,
 739             pp->sectorsize);
 740         zfree(sector, M_ELI);
 741         if (error != 0) {
 742                 gctl_error(req, "Cannot store metadata on %s (error=%d).",
 743                     pp->name, error);
 744                 return;
 745         }
 746         G_ELI_DEBUG(1, "Key %u changed on %s.", nkey, pp->name);
 747 }
 748
 749 static void
 750 g_eli_ctl_delkey(struct gctl_req *req, struct g_class *mp)
 751 {
 752         struct g_eli_softc *sc;
 753         struct g_eli_metadata md;
 754         struct g_provider *pp;
 755         struct g_consumer *cp;
 756         const char *name;
 757         u_char *mkeydst, *sector;
 758         intmax_t *valp;
 759         size_t keysize;
 760         int error, nkey, *all, *force;
 761         u_int i;
 762
 763         g_topology_assert();
 764
 765         nkey = 0;       /* fixes causeless gcc warning */
 766
 767         name = gctl_get_asciiparam(req, "arg0");
 768         if (name == NULL) {
 769                 gctl_error(req, "No 'arg%u' argument.", 0);
 770                 return;
 771         }
 772         sc = g_eli_find_device(mp, name);
 773         if (sc == NULL) {
 774                 gctl_error(req, "Provider %s is invalid.", name);
 775                 return;
 776         }
 777         if (sc->sc_flags & G_ELI_FLAG_RO) {
 778                 gctl_error(req, "Cannot delete keys for read-only provider.");
 779                 return;
 780         }
 781         cp = LIST_FIRST(&sc->sc_geom->consumer);
 782         pp = cp->provider;
 783
 784         error = g_eli_read_metadata(mp, pp, &md);
 785         if (error != 0) {
 786                 gctl_error(req, "Cannot read metadata from %s (error=%d).",
 787                     name, error);
 788                 return;
 789         }
 790
 791         all = gctl_get_paraml(req, "all", sizeof(*all));
 792         if (all == NULL) {
 793                 gctl_error(req, "No '%s' argument.", "all");
 794                 return;
 795         }
 796
 797         if (*all) {
 798                 mkeydst = md.md_mkeys;
 799                 keysize = sizeof(md.md_mkeys);
 800         } else {
 801                 force = gctl_get_paraml(req, "force", sizeof(*force));
 802                 if (force == NULL) {
 803                         gctl_error(req, "No '%s' argument.", "force");
 804                         return;
 805                 }
 806
 807                 valp = gctl_get_paraml(req, "keyno", sizeof(*valp));
 808                 if (valp == NULL) {
 809                         gctl_error(req, "No '%s' argument.", "keyno");
 810                         return;
 811                 }
 812                 if (*valp != -1)
 813                         nkey = *valp;
 814                 else
 815                         nkey = sc->sc_nkey;
 816                 if (nkey < 0 || nkey >= G_ELI_MAXMKEYS) {
 817                         gctl_error(req, "Invalid '%s' argument.", "keyno");
 818                         return;
 819                 }
 820                 if (!(md.md_keys & (1 << nkey)) && !*force) {
 821                         gctl_error(req, "Master Key %u is not set.", nkey);
 822                         return;
 823                 }
 824                 md.md_keys &= ~(1 << nkey);
 825                 if (md.md_keys == 0 && !*force) {
 826                         gctl_error(req, "This is the last Master Key. Use '-f' "
 827                             "flag if you really want to remove it.");
 828                         return;
 829                 }
 830                 mkeydst = md.md_mkeys + nkey * G_ELI_MKEYLEN;
 831                 keysize = G_ELI_MKEYLEN;
 832         }
 833
 834         sector = malloc(pp->sectorsize, M_ELI, M_WAITOK | M_ZERO);
 835         for (i = 0; i <= g_eli_overwrites; i++) {
 836                 if (i == g_eli_overwrites)
 837                         explicit_bzero(mkeydst, keysize);
 838                 else
 839                         arc4rand(mkeydst, keysize, 0);
 840                 /* Store metadata with destroyed key. */
 841                 eli_metadata_encode(&md, sector);
 842                 error = g_write_data(cp, pp->mediasize - pp->sectorsize, sector,
 843                     pp->sectorsize);
 844                 if (error != 0) {
 845                         G_ELI_DEBUG(0, "Cannot store metadata on %s "
 846                             "(error=%d).", pp->name, error);
 847                 }
 848                 /*
 849                  * Flush write cache so we don't overwrite data N times in cache
 850                  * and only once on disk.
 851                  */
 852                 (void)g_io_flush(cp);
 853         }
 854         explicit_bzero(&md, sizeof(md));
 855         zfree(sector, M_ELI);
 856         if (*all)
 857                 G_ELI_DEBUG(1, "All keys removed from %s.", pp->name);
 858         else
 859                 G_ELI_DEBUG(1, "Key %d removed from %s.", nkey, pp->name);
 860 }
 861
 862 static void
 863 g_eli_suspend_one(struct g_eli_softc *sc, struct gctl_req *req)
 864 {
 865         struct g_eli_worker *wr;
 866
 867         g_topology_assert();
 868
 869         KASSERT(sc != NULL, ("NULL sc"));
 870
 871         if (sc->sc_flags & G_ELI_FLAG_ONETIME) {
 872                 gctl_error(req,
 873                     "Device %s is using one-time key, suspend not supported.",
 874                     sc->sc_name);
 875                 return;
 876         }
 877
 878         mtx_lock(&sc->sc_queue_mtx);
 879         if (sc->sc_flags & G_ELI_FLAG_SUSPEND) {
 880                 mtx_unlock(&sc->sc_queue_mtx);
 881                 gctl_error(req, "Device %s already suspended.",
 882                     sc->sc_name);
 883                 return;
 884         }
 885         sc->sc_flags |= G_ELI_FLAG_SUSPEND;
 886         wakeup(sc);
 887         for (;;) {
 888                 LIST_FOREACH(wr, &sc->sc_workers, w_next) {
 889                         if (wr->w_active)
 890                                 break;
 891                 }
 892                 if (wr == NULL)
 893                         break;
 894                 /* Not all threads suspended. */
 895                 msleep(&sc->sc_workers, &sc->sc_queue_mtx, PRIBIO,
 896                     "geli:suspend", 0);
 897         }
 898         /*
 899          * Clear sensitive data on suspend, they will be recovered on resume.
 900          */
 901         explicit_bzero(sc->sc_mkey, sizeof(sc->sc_mkey));
 902         g_eli_key_destroy(sc);
 903         explicit_bzero(sc->sc_akey, sizeof(sc->sc_akey));
 904         explicit_bzero(&sc->sc_akeyctx, sizeof(sc->sc_akeyctx));
 905         explicit_bzero(sc->sc_ivkey, sizeof(sc->sc_ivkey));
 906         explicit_bzero(&sc->sc_ivctx, sizeof(sc->sc_ivctx));
 907         mtx_unlock(&sc->sc_queue_mtx);
 908         G_ELI_DEBUG(0, "Device %s has been suspended.", sc->sc_name);
 909 }
 910
 911 static void
 912 g_eli_ctl_suspend(struct gctl_req *req, struct g_class *mp)
 913 {
 914         struct g_eli_softc *sc;
 915         int *all, *nargs;
 916
 917         g_topology_assert();
 918
 919         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
 920         if (nargs == NULL) {
 921                 gctl_error(req, "No '%s' argument.", "nargs");
 922                 return;
 923         }
 924         all = gctl_get_paraml(req, "all", sizeof(*all));
 925         if (all == NULL) {
 926                 gctl_error(req, "No '%s' argument.", "all");
 927                 return;
 928         }
 929         if (!*all && *nargs == 0) {
 930                 gctl_error(req, "Too few arguments.");
 931                 return;
 932         }
 933
 934         if (*all) {
 935                 struct g_geom *gp, *gp2;
 936
 937                 LIST_FOREACH_SAFE(gp, &mp->geom, geom, gp2) {
 938                         sc = gp->softc;
 939                         if (sc->sc_flags & G_ELI_FLAG_ONETIME) {
 940                                 G_ELI_DEBUG(0,
 941                                     "Device %s is using one-time key, suspend not supported, skipping.",
 942                                     sc->sc_name);
 943                                 continue;
 944                         }
 945                         g_eli_suspend_one(sc, req);
 946                 }
 947         } else {
 948                 const char *prov;
 949                 char param[16];
 950                 int i;
 951
 952                 for (i = 0; i < *nargs; i++) {
 953                         snprintf(param, sizeof(param), "arg%d", i);
 954                         prov = gctl_get_asciiparam(req, param);
 955                         if (prov == NULL) {
 956                                 G_ELI_DEBUG(0, "No 'arg%d' argument.", i);
 957                                 continue;
 958                         }
 959
 960                         sc = g_eli_find_device(mp, prov);
 961                         if (sc == NULL) {
 962                                 G_ELI_DEBUG(0, "No such provider: %s.", prov);
 963                                 continue;
 964                         }
 965                         g_eli_suspend_one(sc, req);
 966                 }
 967         }
 968 }
 969
 970 static void
 971 g_eli_ctl_resume(struct gctl_req *req, struct g_class *mp)
 972 {
 973         struct g_eli_metadata md;
 974         struct g_eli_softc *sc;
 975         struct g_provider *pp;
 976         struct g_consumer *cp;
 977         const char *name;
 978         u_char *key, mkey[G_ELI_DATAIVKEYLEN];
 979         int *nargs, keysize, error;
 980         u_int nkey;
 981
 982         g_topology_assert();
 983
 984         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
 985         if (nargs == NULL) {
 986                 gctl_error(req, "No '%s' argument.", "nargs");
 987                 return;
 988         }
 989         if (*nargs != 1) {
 990                 gctl_error(req, "Invalid number of arguments.");
 991                 return;
 992         }
 993
 994         name = gctl_get_asciiparam(req, "arg0");
 995         if (name == NULL) {
 996                 gctl_error(req, "No 'arg%u' argument.", 0);
 997                 return;
 998         }
 999         key = gctl_get_param(req, "key", &keysize);
1000         if (key == NULL || keysize != G_ELI_USERKEYLEN) {
1001                 gctl_error(req, "No '%s' argument.", "key");
1002                 return;
1003         }
1004         sc = g_eli_find_device(mp, name);
1005         if (sc == NULL) {
1006                 gctl_error(req, "Provider %s is invalid.", name);
1007                 return;
1008         }
1009         cp = LIST_FIRST(&sc->sc_geom->consumer);
1010         pp = cp->provider;
1011         error = g_eli_read_metadata(mp, pp, &md);
1012         if (error != 0) {
1013                 gctl_error(req, "Cannot read metadata from %s (error=%d).",
1014                     name, error);
1015                 return;
1016         }
1017         if (md.md_keys == 0x00) {
1018                 explicit_bzero(&md, sizeof(md));
1019                 gctl_error(req, "No valid keys on %s.", pp->name);
1020                 return;
1021         }
1022
1023         error = g_eli_mkey_decrypt_any(&md, key, mkey, &nkey);
1024         explicit_bzero(key, keysize);
1025         if (error == -1) {
1026                 explicit_bzero(&md, sizeof(md));
1027                 gctl_error(req, "Wrong key for %s.", pp->name);
1028                 return;
1029         } else if (error > 0) {
1030                 explicit_bzero(&md, sizeof(md));
1031                 gctl_error(req, "Cannot decrypt Master Key for %s (error=%d).",
1032                     pp->name, error);
1033                 return;
1034         }
1035         G_ELI_DEBUG(1, "Using Master Key %u for %s.", nkey, pp->name);
1036
1037         mtx_lock(&sc->sc_queue_mtx);
1038         if (!(sc->sc_flags & G_ELI_FLAG_SUSPEND))
1039                 gctl_error(req, "Device %s is not suspended.", name);
1040         else {
1041                 /* Restore sc_mkey, sc_ekeys, sc_akey and sc_ivkey. */
1042                 g_eli_mkey_propagate(sc, mkey);
1043                 sc->sc_flags &= ~G_ELI_FLAG_SUSPEND;
1044                 G_ELI_DEBUG(1, "Resumed %s.", pp->name);
1045                 wakeup(sc);
1046         }
1047         mtx_unlock(&sc->sc_queue_mtx);
1048         explicit_bzero(mkey, sizeof(mkey));
1049         explicit_bzero(&md, sizeof(md));
1050 }
1051
1052 static int
1053 g_eli_kill_one(struct g_eli_softc *sc)
1054 {
1055         struct g_provider *pp;
1056         struct g_consumer *cp;
1057         int error = 0;
1058
1059         g_topology_assert();
1060
1061         if (sc == NULL)
1062                 return (ENOENT);
1063
1064         pp = LIST_FIRST(&sc->sc_geom->provider);
1065         g_error_provider(pp, ENXIO);
1066
1067         cp = LIST_FIRST(&sc->sc_geom->consumer);
1068         pp = cp->provider;
1069
1070         if (sc->sc_flags & G_ELI_FLAG_RO) {
1071                 G_ELI_DEBUG(0, "WARNING: Metadata won't be erased on read-only "
1072                     "provider: %s.", pp->name);
1073         } else {
1074                 u_char *sector;
1075                 u_int i;
1076                 int err;
1077
1078                 sector = malloc(pp->sectorsize, M_ELI, M_WAITOK);
1079                 for (i = 0; i <= g_eli_overwrites; i++) {
1080                         if (i == g_eli_overwrites)
1081                                 bzero(sector, pp->sectorsize);
1082                         else
1083                                 arc4rand(sector, pp->sectorsize, 0);
1084                         err = g_write_data(cp, pp->mediasize - pp->sectorsize,
1085                             sector, pp->sectorsize);
1086                         if (err != 0) {
1087                                 G_ELI_DEBUG(0, "Cannot erase metadata on %s "
1088                                     "(error=%d).", pp->name, err);
1089                                 if (error == 0)
1090                                         error = err;
1091                         }
1092                         /*
1093                          * Flush write cache so we don't overwrite data N times
1094                          * in cache and only once on disk.
1095                          */
1096                         (void)g_io_flush(cp);
1097                 }
1098                 free(sector, M_ELI);
1099         }
1100         if (error == 0)
1101                 G_ELI_DEBUG(0, "%s has been killed.", pp->name);
1102         g_eli_destroy(sc, TRUE);
1103         return (error);
1104 }
1105
1106 static void
1107 g_eli_ctl_kill(struct gctl_req *req, struct g_class *mp)
1108 {
1109         int *all, *nargs;
1110         int error;
1111
1112         g_topology_assert();
1113
1114         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
1115         if (nargs == NULL) {
1116                 gctl_error(req, "No '%s' argument.", "nargs");
1117                 return;
1118         }
1119         all = gctl_get_paraml(req, "all", sizeof(*all));
1120         if (all == NULL) {
1121                 gctl_error(req, "No '%s' argument.", "all");
1122                 return;
1123         }
1124         if (!*all && *nargs == 0) {
1125                 gctl_error(req, "Too few arguments.");
1126                 return;
1127         }
1128
1129         if (*all) {
1130                 struct g_geom *gp, *gp2;
1131
1132                 LIST_FOREACH_SAFE(gp, &mp->geom, geom, gp2) {
1133                         error = g_eli_kill_one(gp->softc);
1134                         if (error != 0)
1135                                 gctl_error(req, "Not fully done.");
1136                 }
1137         } else {
1138                 struct g_eli_softc *sc;
1139                 const char *prov;
1140                 char param[16];
1141                 int i;
1142
1143                 for (i = 0; i < *nargs; i++) {
1144                         snprintf(param, sizeof(param), "arg%d", i);
1145                         prov = gctl_get_asciiparam(req, param);
1146                         if (prov == NULL) {
1147                                 G_ELI_DEBUG(0, "No 'arg%d' argument.", i);
1148                                 continue;
1149                         }
1150
1151                         sc = g_eli_find_device(mp, prov);
1152                         if (sc == NULL) {
1153                                 G_ELI_DEBUG(0, "No such provider: %s.", prov);
1154                                 continue;
1155                         }
1156                         error = g_eli_kill_one(sc);
1157                         if (error != 0)
1158                                 gctl_error(req, "Not fully done.");
1159                 }
1160         }
1161 }
1162
1163 void
1164 g_eli_config(struct gctl_req *req, struct g_class *mp, const char *verb)
1165 {
1166         uint32_t *version;
1167
1168         g_topology_assert();
1169
1170         version = gctl_get_paraml(req, "version", sizeof(*version));
1171         if (version == NULL) {
1172                 gctl_error(req, "No '%s' argument.", "version");
1173                 return;
1174         }
1175         while (*version != G_ELI_VERSION) {
1176                 if (G_ELI_VERSION == G_ELI_VERSION_06 &&
1177                     *version == G_ELI_VERSION_05) {
1178                         /* Compatible. */
1179                         break;
1180                 }
1181                 if (G_ELI_VERSION == G_ELI_VERSION_07 &&
1182                     (*version == G_ELI_VERSION_05 ||
1183                      *version == G_ELI_VERSION_06)) {
1184                         /* Compatible. */
1185                         break;
1186                 }
1187                 gctl_error(req, "Userland and kernel parts are out of sync.");
1188                 return;
1189         }
1190
1191         if (strcmp(verb, "attach") == 0)
1192                 g_eli_ctl_attach(req, mp);
1193         else if (strcmp(verb, "detach") == 0 || strcmp(verb, "stop") == 0)
1194                 g_eli_ctl_detach(req, mp);
1195         else if (strcmp(verb, "onetime") == 0)
1196                 g_eli_ctl_onetime(req, mp);
1197         else if (strcmp(verb, "configure") == 0)
1198                 g_eli_ctl_configure(req, mp);
1199         else if (strcmp(verb, "setkey") == 0)
1200                 g_eli_ctl_setkey(req, mp);
1201         else if (strcmp(verb, "delkey") == 0)
1202                 g_eli_ctl_delkey(req, mp);
1203         else if (strcmp(verb, "suspend") == 0)
1204                 g_eli_ctl_suspend(req, mp);
1205         else if (strcmp(verb, "resume") == 0)
1206                 g_eli_ctl_resume(req, mp);
1207         else if (strcmp(verb, "kill") == 0)
1208                 g_eli_ctl_kill(req, mp);
1209         else
1210                 gctl_error(req, "Unknown verb.");
1211 }