sbin/ggate/ggatel/ggatel.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2004 Pawel Jakub Dawidek <pjd@FreeBSD.org>
   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  * $FreeBSD$
  29  */
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <stdint.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #include <string.h>
  37 #include <err.h>
  38 #include <errno.h>
  39 #include <assert.h>
  40 #include <sys/param.h>
  41 #include <sys/time.h>
  42 #include <sys/bio.h>
  43 #include <sys/disk.h>
  44 #include <sys/ioctl.h>
  45 #include <sys/stat.h>
  46 #include <sys/syslog.h>
  47
  48 #include <geom/gate/g_gate.h>
  49 #include "ggate.h"
  50
  51
  52 static enum { UNSET, CREATE, DESTROY, LIST, RESCUE } action = UNSET;
  53
  54 static const char *path = NULL;
  55 static int unit = G_GATE_UNIT_AUTO;
  56 static unsigned flags = 0;
  57 static int force = 0;
  58 static unsigned sectorsize = 0;
  59 static unsigned timeout = G_GATE_TIMEOUT;
  60
  61 static void
  62 usage(void)
  63 {
  64
  65         fprintf(stderr, "usage: %s create [-v] [-o <ro|wo|rw>] "
  66             "[-s sectorsize] [-t timeout] [-u unit] <path>\n", getprogname());
  67         fprintf(stderr, "       %s rescue [-v] [-o <ro|wo|rw>] <-u unit> "
  68             "<path>\n", getprogname());
  69         fprintf(stderr, "       %s destroy [-f] <-u unit>\n", getprogname());
  70         fprintf(stderr, "       %s list [-v] [-u unit]\n", getprogname());
  71         exit(EXIT_FAILURE);
  72 }
  73
  74 static int
  75 g_gate_openflags(unsigned ggflags)
  76 {
  77
  78         if ((ggflags & G_GATE_FLAG_READONLY) != 0)
  79                 return (O_RDONLY);
  80         else if ((ggflags & G_GATE_FLAG_WRITEONLY) != 0)
  81                 return (O_WRONLY);
  82         return (O_RDWR);
  83 }
  84
  85 static void
  86 g_gatel_serve(int fd)
  87 {
  88         struct g_gate_ctl_io ggio;
  89         size_t bsize;
  90
  91         if (g_gate_verbose == 0) {
  92                 if (daemon(0, 0) == -1) {
  93                         g_gate_destroy(unit, 1);
  94                         err(EXIT_FAILURE, "Cannot daemonize");
  95                 }
  96         }
  97         g_gate_log(LOG_DEBUG, "Worker created: %u.", getpid());
  98         ggio.gctl_version = G_GATE_VERSION;
  99         ggio.gctl_unit = unit;
 100         bsize = sectorsize;
 101         ggio.gctl_data = malloc(bsize);
 102         for (;;) {
 103                 int error;
 104 once_again:
 105                 ggio.gctl_length = bsize;
 106                 ggio.gctl_error = 0;
 107                 g_gate_ioctl(G_GATE_CMD_START, &ggio);
 108                 error = ggio.gctl_error;
 109                 switch (error) {
 110                 case 0:
 111                         break;
 112                 case ECANCELED:
 113                         /* Exit gracefully. */
 114                         free(ggio.gctl_data);
 115                         g_gate_close_device();
 116                         close(fd);
 117                         exit(EXIT_SUCCESS);
 118                 case ENOMEM:
 119                         /* Buffer too small. */
 120                         assert(ggio.gctl_cmd == BIO_DELETE ||
 121                             ggio.gctl_cmd == BIO_WRITE);
 122                         ggio.gctl_data = realloc(ggio.gctl_data,
 123                             ggio.gctl_length);
 124                         if (ggio.gctl_data != NULL) {
 125                                 bsize = ggio.gctl_length;
 126                                 goto once_again;
 127                         }
 128                         /* FALLTHROUGH */
 129                 case ENXIO:
 130                 default:
 131                         g_gate_xlog("ioctl(/dev/%s): %s.", G_GATE_CTL_NAME,
 132                             strerror(error));
 133                 }
 134
 135                 error = 0;
 136                 switch (ggio.gctl_cmd) {
 137                 case BIO_READ:
 138                         if ((size_t)ggio.gctl_length > bsize) {
 139                                 ggio.gctl_data = realloc(ggio.gctl_data,
 140                                     ggio.gctl_length);
 141                                 if (ggio.gctl_data != NULL)
 142                                         bsize = ggio.gctl_length;
 143                                 else
 144                                         error = ENOMEM;
 145                         }
 146                         if (error == 0) {
 147                                 if (pread(fd, ggio.gctl_data, ggio.gctl_length,
 148                                     ggio.gctl_offset) == -1) {
 149                                         error = errno;
 150                                 }
 151                         }
 152                         break;
 153                 case BIO_DELETE:
 154                 case BIO_WRITE:
 155                         if (pwrite(fd, ggio.gctl_data, ggio.gctl_length,
 156                             ggio.gctl_offset) == -1) {
 157                                 error = errno;
 158                         }
 159                         break;
 160                 default:
 161                         error = EOPNOTSUPP;
 162                 }
 163
 164                 ggio.gctl_error = error;
 165                 g_gate_ioctl(G_GATE_CMD_DONE, &ggio);
 166         }
 167 }
 168
 169 static void
 170 g_gatel_create(void)
 171 {
 172         struct g_gate_ctl_create ggioc;
 173         int fd;
 174
 175         fd = open(path, g_gate_openflags(flags) | O_DIRECT | O_FSYNC);
 176         if (fd == -1)
 177                 err(EXIT_FAILURE, "Cannot open %s", path);
 178         memset(&ggioc, 0, sizeof(ggioc));
 179         ggioc.gctl_version = G_GATE_VERSION;
 180         ggioc.gctl_unit = unit;
 181         ggioc.gctl_mediasize = g_gate_mediasize(fd);
 182         if (sectorsize == 0)
 183                 sectorsize = g_gate_sectorsize(fd);
 184         ggioc.gctl_sectorsize = sectorsize;
 185         ggioc.gctl_timeout = timeout;
 186         ggioc.gctl_flags = flags;
 187         ggioc.gctl_maxcount = 0;
 188         strlcpy(ggioc.gctl_info, path, sizeof(ggioc.gctl_info));
 189         g_gate_ioctl(G_GATE_CMD_CREATE, &ggioc);
 190         if (unit == -1)
 191                 printf("%s%u\n", G_GATE_PROVIDER_NAME, ggioc.gctl_unit);
 192         unit = ggioc.gctl_unit;
 193         g_gatel_serve(fd);
 194 }
 195
 196 static void
 197 g_gatel_rescue(void)
 198 {
 199         struct g_gate_ctl_cancel ggioc;
 200         int fd;
 201
 202         fd = open(path, g_gate_openflags(flags));
 203         if (fd == -1)
 204                 err(EXIT_FAILURE, "Cannot open %s", path);
 205
 206         ggioc.gctl_version = G_GATE_VERSION;
 207         ggioc.gctl_unit = unit;
 208         ggioc.gctl_seq = 0;
 209         g_gate_ioctl(G_GATE_CMD_CANCEL, &ggioc);
 210
 211         g_gatel_serve(fd);
 212 }
 213
 214 int
 215 main(int argc, char *argv[])
 216 {
 217
 218         if (argc < 2)
 219                 usage();
 220         if (strcasecmp(argv[1], "create") == 0)
 221                 action = CREATE;
 222         else if (strcasecmp(argv[1], "rescue") == 0)
 223                 action = RESCUE;
 224         else if (strcasecmp(argv[1], "destroy") == 0)
 225                 action = DESTROY;
 226         else if (strcasecmp(argv[1], "list") == 0)
 227                 action = LIST;
 228         else
 229                 usage();
 230         argc -= 1;
 231         argv += 1;
 232         for (;;) {
 233                 int ch;
 234
 235                 ch = getopt(argc, argv, "fo:s:t:u:v");
 236                 if (ch == -1)
 237                         break;
 238                 switch (ch) {
 239                 case 'f':
 240                         if (action != DESTROY)
 241                                 usage();
 242                         force = 1;
 243                         break;
 244                 case 'o':
 245                         if (action != CREATE && action != RESCUE)
 246                                 usage();
 247                         if (strcasecmp("ro", optarg) == 0)
 248                                 flags = G_GATE_FLAG_READONLY;
 249                         else if (strcasecmp("wo", optarg) == 0)
 250                                 flags = G_GATE_FLAG_WRITEONLY;
 251                         else if (strcasecmp("rw", optarg) == 0)
 252                                 flags = 0;
 253                         else {
 254                                 errx(EXIT_FAILURE,
 255                                     "Invalid argument for '-o' option.");
 256                         }
 257                         break;
 258                 case 's':
 259                         if (action != CREATE)
 260                                 usage();
 261                         errno = 0;
 262                         sectorsize = strtoul(optarg, NULL, 10);
 263                         if (sectorsize == 0 && errno != 0)
 264                                 errx(EXIT_FAILURE, "Invalid sectorsize.");
 265                         break;
 266                 case 't':
 267                         if (action != CREATE)
 268                                 usage();
 269                         errno = 0;
 270                         timeout = strtoul(optarg, NULL, 10);
 271                         if (timeout == 0 && errno != 0)
 272                                 errx(EXIT_FAILURE, "Invalid timeout.");
 273                         break;
 274                 case 'u':
 275                         errno = 0;
 276                         unit = strtol(optarg, NULL, 10);
 277                         if (unit == 0 && errno != 0)
 278                                 errx(EXIT_FAILURE, "Invalid unit number.");
 279                         break;
 280                 case 'v':
 281                         if (action == DESTROY)
 282                                 usage();
 283                         g_gate_verbose++;
 284                         break;
 285                 default:
 286                         usage();
 287                 }
 288         }
 289         argc -= optind;
 290         argv += optind;
 291
 292         switch (action) {
 293         case CREATE:
 294                 if (argc != 1)
 295                         usage();
 296                 g_gate_load_module();
 297                 g_gate_open_device();
 298                 path = argv[0];
 299                 g_gatel_create();
 300                 break;
 301         case RESCUE:
 302                 if (argc != 1)
 303                         usage();
 304                 if (unit == -1) {
 305                         fprintf(stderr, "Required unit number.\n");
 306                         usage();
 307                 }
 308                 g_gate_open_device();
 309                 path = argv[0];
 310                 g_gatel_rescue();
 311                 break;
 312         case DESTROY:
 313                 if (unit == -1) {
 314                         fprintf(stderr, "Required unit number.\n");
 315                         usage();
 316                 }
 317                 g_gate_verbose = 1;
 318                 g_gate_open_device();
 319                 g_gate_destroy(unit, force);
 320                 break;
 321         case LIST:
 322                 g_gate_list(unit, g_gate_verbose);
 323                 break;
 324         case UNSET:
 325         default:
 326                 usage();
 327         }
 328         g_gate_close_device();
 329         exit(EXIT_SUCCESS);
 330 }