scsi/qemu-pr-helper.c

   1 /*
   2  * Privileged helper to handle persistent reservation commands for QEMU
   3  *
   4  * Copyright (C) 2017 Red Hat, Inc. <pbonzini@redhat.com>
   5  *
   6  * Author: Paolo Bonzini <pbonzini@redhat.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; under version 2 of the License.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include <getopt.h>
  23 #include <sys/ioctl.h>
  24 #include <linux/dm-ioctl.h>
  25 #include <scsi/sg.h>
  26
  27 #ifdef CONFIG_LIBCAP
  28 #include <cap-ng.h>
  29 #endif
  30 #include <pwd.h>
  31 #include <grp.h>
  32
  33 #ifdef CONFIG_MPATH
  34 #include <libudev.h>
  35 #include <mpath_cmd.h>
  36 #include <mpath_persist.h>
  37 #endif
  38
  39 #include "qemu-common.h"
  40 #include "qapi/error.h"
  41 #include "qemu/cutils.h"
  42 #include "qemu/main-loop.h"
  43 #include "qemu/module.h"
  44 #include "qemu/error-report.h"
  45 #include "qemu/config-file.h"
  46 #include "qemu/bswap.h"
  47 #include "qemu/log.h"
  48 #include "qemu/systemd.h"
  49 #include "qapi/util.h"
  50 #include "qapi/qmp/qstring.h"
  51 #include "io/channel-socket.h"
  52 #include "trace/control.h"
  53 #include "qemu-version.h"
  54
  55 #include "block/aio.h"
  56 #include "block/thread-pool.h"
  57
  58 #include "scsi/constants.h"
  59 #include "scsi/utils.h"
  60 #include "pr-helper.h"
  61
  62 #define PR_OUT_FIXED_PARAM_SIZE 24
  63
  64 static char *socket_path;
  65 static char *pidfile;
  66 static enum { RUNNING, TERMINATE, TERMINATING } state;
  67 static QIOChannelSocket *server_ioc;
  68 static int server_watch;
  69 static int num_active_sockets = 1;
  70 static int noisy;
  71 static int verbose;
  72
  73 #ifdef CONFIG_LIBCAP
  74 static int uid = -1;
  75 static int gid = -1;
  76 #endif
  77
  78 static void compute_default_paths(void)
  79 {
  80     socket_path = qemu_get_local_state_pathname("run/qemu-pr-helper.sock");
  81     pidfile = qemu_get_local_state_pathname("run/qemu-pr-helper.pid");
  82 }
  83
  84 static void usage(const char *name)
  85 {
  86     (printf) (
  87 "Usage: %s [OPTIONS] FILE\n"
  88 "Persistent Reservation helper program for QEMU\n"
  89 "\n"
  90 "  -h, --help                display this help and exit\n"
  91 "  -V, --version             output version information and exit\n"
  92 "\n"
  93 "  -d, --daemon              run in the background\n"
  94 "  -f, --pidfile=PATH        PID file when running as a daemon\n"
  95 "                            (default '%s')\n"
  96 "  -k, --socket=PATH         path to the unix socket\n"
  97 "                            (default '%s')\n"
  98 "  -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
  99 "                            specify tracing options\n"
 100 #ifdef CONFIG_LIBCAP
 101 "  -u, --user=USER           user to drop privileges to\n"
 102 "  -g, --group=GROUP         group to drop privileges to\n"
 103 #endif
 104 "\n"
 105 QEMU_HELP_BOTTOM "\n"
 106     , name, pidfile, socket_path);
 107 }
 108
 109 static void version(const char *name)
 110 {
 111     printf(
 112 "%s " QEMU_FULL_VERSION "\n"
 113 "Written by Paolo Bonzini.\n"
 114 "\n"
 115 QEMU_COPYRIGHT "\n"
 116 "This is free software; see the source for copying conditions.  There is NO\n"
 117 "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
 118     , name);
 119 }
 120
 121 /* SG_IO support */
 122
 123 typedef struct PRHelperSGIOData {
 124     int fd;
 125     const uint8_t *cdb;
 126     uint8_t *sense;
 127     uint8_t *buf;
 128     int sz;              /* input/output */
 129     int dir;
 130 } PRHelperSGIOData;
 131
 132 static int do_sgio_worker(void *opaque)
 133 {
 134     PRHelperSGIOData *data = opaque;
 135     struct sg_io_hdr io_hdr;
 136     int ret;
 137     int status;
 138     SCSISense sense_code;
 139
 140     memset(data->sense, 0, PR_HELPER_SENSE_SIZE);
 141     memset(&io_hdr, 0, sizeof(io_hdr));
 142     io_hdr.interface_id = 'S';
 143     io_hdr.cmd_len = PR_HELPER_CDB_SIZE;
 144     io_hdr.cmdp = (uint8_t *)data->cdb;
 145     io_hdr.sbp = data->sense;
 146     io_hdr.mx_sb_len = PR_HELPER_SENSE_SIZE;
 147     io_hdr.timeout = 1;
 148     io_hdr.dxfer_direction = data->dir;
 149     io_hdr.dxferp = (char *)data->buf;
 150     io_hdr.dxfer_len = data->sz;
 151     ret = ioctl(data->fd, SG_IO, &io_hdr);
 152     status = sg_io_sense_from_errno(ret < 0 ? errno : 0, &io_hdr,
 153                                     &sense_code);
 154     if (status == GOOD) {
 155         data->sz -= io_hdr.resid;
 156     } else {
 157         data->sz = 0;
 158     }
 159
 160     if (status == CHECK_CONDITION &&
 161         !(io_hdr.driver_status & SG_ERR_DRIVER_SENSE)) {
 162         scsi_build_sense(data->sense, sense_code);
 163     }
 164
 165     return status;
 166 }
 167
 168 static int do_sgio(int fd, const uint8_t *cdb, uint8_t *sense,
 169                     uint8_t *buf, int *sz, int dir)
 170 {
 171     ThreadPool *pool = aio_get_thread_pool(qemu_get_aio_context());
 172     int r;
 173
 174     PRHelperSGIOData data = {
 175         .fd = fd,
 176         .cdb = cdb,
 177         .sense = sense,
 178         .buf = buf,
 179         .sz = *sz,
 180         .dir = dir,
 181     };
 182
 183     r = thread_pool_submit_co(pool, do_sgio_worker, &data);
 184     *sz = data.sz;
 185     return r;
 186 }
 187
 188 /* Device mapper interface */
 189
 190 #ifdef CONFIG_MPATH
 191 #define CONTROL_PATH "/dev/mapper/control"
 192
 193 typedef struct DMData {
 194     struct dm_ioctl dm;
 195     uint8_t data[1024];
 196 } DMData;
 197
 198 static int control_fd;
 199
 200 static void *dm_ioctl(int ioc, struct dm_ioctl *dm)
 201 {
 202     static DMData d;
 203     memcpy(&d.dm, dm, sizeof(d.dm));
 204     QEMU_BUILD_BUG_ON(sizeof(d.data) < sizeof(struct dm_target_spec));
 205
 206     d.dm.version[0] = DM_VERSION_MAJOR;
 207     d.dm.version[1] = 0;
 208     d.dm.version[2] = 0;
 209     d.dm.data_size = 1024;
 210     d.dm.data_start = offsetof(DMData, data);
 211     if (ioctl(control_fd, ioc, &d) < 0) {
 212         return NULL;
 213     }
 214     memcpy(dm, &d.dm, sizeof(d.dm));
 215     return &d.data;
 216 }
 217
 218 static void *dm_dev_ioctl(int fd, int ioc, struct dm_ioctl *dm)
 219 {
 220     struct stat st;
 221     int r;
 222
 223     r = fstat(fd, &st);
 224     if (r < 0) {
 225         perror("fstat");
 226         exit(1);
 227     }
 228
 229     dm->dev = st.st_rdev;
 230     return dm_ioctl(ioc, dm);
 231 }
 232
 233 static void dm_init(void)
 234 {
 235     control_fd = open(CONTROL_PATH, O_RDWR);
 236     if (control_fd < 0) {
 237         perror("Cannot open " CONTROL_PATH);
 238         exit(1);
 239     }
 240     struct dm_ioctl dm = { };
 241     if (!dm_ioctl(DM_VERSION, &dm)) {
 242         perror("ioctl");
 243         exit(1);
 244     }
 245     if (dm.version[0] != DM_VERSION_MAJOR) {
 246         fprintf(stderr, "Unsupported device mapper interface");
 247         exit(1);
 248     }
 249 }
 250
 251 /* Variables required by libmultipath and libmpathpersist.  */
 252 QEMU_BUILD_BUG_ON(PR_HELPER_DATA_SIZE > MPATH_MAX_PARAM_LEN);
 253 static struct config *multipath_conf;
 254 unsigned mpath_mx_alloc_len = PR_HELPER_DATA_SIZE;
 255 int logsink;
 256 struct udev *udev;
 257
 258 extern struct config *get_multipath_config(void);
 259 struct config *get_multipath_config(void)
 260 {
 261     return multipath_conf;
 262 }
 263
 264 extern void put_multipath_config(struct config *conf);
 265 void put_multipath_config(struct config *conf)
 266 {
 267 }
 268
 269 static void multipath_pr_init(void)
 270 {
 271     udev = udev_new();
 272 #ifdef CONFIG_MPATH_NEW_API
 273     multipath_conf = mpath_lib_init();
 274 #else
 275     mpath_lib_init(udev);
 276 #endif
 277 }
 278
 279 static int is_mpath(int fd)
 280 {
 281     struct dm_ioctl dm = { .flags = DM_NOFLUSH_FLAG };
 282     struct dm_target_spec *tgt;
 283
 284     tgt = dm_dev_ioctl(fd, DM_TABLE_STATUS, &dm);
 285     if (!tgt) {
 286         if (errno == ENXIO) {
 287             return 0;
 288         }
 289         perror("ioctl");
 290         exit(EXIT_FAILURE);
 291     }
 292     return !strncmp(tgt->target_type, "multipath", DM_MAX_TYPE_NAME);
 293 }
 294
 295 static SCSISense mpath_generic_sense(int r)
 296 {
 297     switch (r) {
 298     case MPATH_PR_SENSE_NOT_READY:
 299          return SENSE_CODE(NOT_READY);
 300     case MPATH_PR_SENSE_MEDIUM_ERROR:
 301          return SENSE_CODE(READ_ERROR);
 302     case MPATH_PR_SENSE_HARDWARE_ERROR:
 303          return SENSE_CODE(TARGET_FAILURE);
 304     case MPATH_PR_SENSE_ABORTED_COMMAND:
 305          return SENSE_CODE(IO_ERROR);
 306     default:
 307          abort();
 308     }
 309 }
 310
 311 static int mpath_reconstruct_sense(int fd, int r, uint8_t *sense)
 312 {
 313     switch (r) {
 314     case MPATH_PR_SUCCESS:
 315         return GOOD;
 316     case MPATH_PR_SENSE_NOT_READY:
 317     case MPATH_PR_SENSE_MEDIUM_ERROR:
 318     case MPATH_PR_SENSE_HARDWARE_ERROR:
 319     case MPATH_PR_SENSE_ABORTED_COMMAND:
 320         {
 321             /* libmpathpersist ate the exact sense.  Try to find it by
 322              * issuing TEST UNIT READY.
 323              */
 324             uint8_t cdb[6] = { TEST_UNIT_READY };
 325             int sz = 0;
 326             int r = do_sgio(fd, cdb, sense, NULL, &sz, SG_DXFER_NONE);
 327
 328             if (r != GOOD) {
 329                 return r;
 330             }
 331             scsi_build_sense(sense, mpath_generic_sense(r));
 332             return CHECK_CONDITION;
 333         }
 334
 335     case MPATH_PR_SENSE_UNIT_ATTENTION:
 336         /* Congratulations libmpathpersist, you ruined the Unit Attention...
 337          * Return a heavyweight one.
 338          */
 339         scsi_build_sense(sense, SENSE_CODE(SCSI_BUS_RESET));
 340         return CHECK_CONDITION;
 341     case MPATH_PR_SENSE_INVALID_OP:
 342         /* Only one valid sense.  */
 343         scsi_build_sense(sense, SENSE_CODE(INVALID_OPCODE));
 344         return CHECK_CONDITION;
 345     case MPATH_PR_ILLEGAL_REQ:
 346         /* Guess.  */
 347         scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM));
 348         return CHECK_CONDITION;
 349     case MPATH_PR_NO_SENSE:
 350         scsi_build_sense(sense, SENSE_CODE(NO_SENSE));
 351         return CHECK_CONDITION;
 352
 353     case MPATH_PR_RESERV_CONFLICT:
 354         return RESERVATION_CONFLICT;
 355
 356     case MPATH_PR_OTHER:
 357     default:
 358         scsi_build_sense(sense, SENSE_CODE(LUN_COMM_FAILURE));
 359         return CHECK_CONDITION;
 360     }
 361 }
 362
 363 static int multipath_pr_in(int fd, const uint8_t *cdb, uint8_t *sense,
 364                            uint8_t *data, int sz)
 365 {
 366     int rq_servact = cdb[1];
 367     struct prin_resp resp;
 368     size_t written;
 369     int r;
 370
 371     switch (rq_servact) {
 372     case MPATH_PRIN_RKEY_SA:
 373     case MPATH_PRIN_RRES_SA:
 374     case MPATH_PRIN_RCAP_SA:
 375         break;
 376     case MPATH_PRIN_RFSTAT_SA:
 377         /* Nobody implements it anyway, so bail out. */
 378     default:
 379         /* Cannot parse any other output.  */
 380         scsi_build_sense(sense, SENSE_CODE(INVALID_FIELD));
 381         return CHECK_CONDITION;
 382     }
 383
 384     r = mpath_persistent_reserve_in(fd, rq_servact, &resp, noisy, verbose);
 385     if (r == MPATH_PR_SUCCESS) {
 386         switch (rq_servact) {
 387         case MPATH_PRIN_RKEY_SA:
 388         case MPATH_PRIN_RRES_SA: {
 389             struct prin_readdescr *out = &resp.prin_descriptor.prin_readkeys;
 390             assert(sz >= 8);
 391             written = MIN(out->additional_length + 8, sz);
 392             stl_be_p(&data[0], out->prgeneration);
 393             stl_be_p(&data[4], out->additional_length);
 394             memcpy(&data[8], out->key_list, written - 8);
 395             break;
 396         }
 397         case MPATH_PRIN_RCAP_SA: {
 398             struct prin_capdescr *out = &resp.prin_descriptor.prin_readcap;
 399             assert(sz >= 6);
 400             written = 6;
 401             stw_be_p(&data[0], out->length);
 402             data[2] = out->flags[0];
 403             data[3] = out->flags[1];
 404             stw_be_p(&data[4], out->pr_type_mask);
 405             break;
 406         }
 407         default:
 408             scsi_build_sense(sense, SENSE_CODE(INVALID_OPCODE));
 409             return CHECK_CONDITION;
 410         }
 411         assert(written <= sz);
 412         memset(data + written, 0, sz - written);
 413     }
 414
 415     return mpath_reconstruct_sense(fd, r, sense);
 416 }
 417
 418 static int multipath_pr_out(int fd, const uint8_t *cdb, uint8_t *sense,
 419                             const uint8_t *param, int sz)
 420 {
 421     int rq_servact = cdb[1];
 422     int rq_scope = cdb[2] >> 4;
 423     int rq_type = cdb[2] & 0xf;
 424     struct prout_param_descriptor paramp;
 425     char transportids[PR_HELPER_DATA_SIZE];
 426     int r;
 427
 428     if (sz < PR_OUT_FIXED_PARAM_SIZE) {
 429         /* Illegal request, Parameter list length error.  This isn't fatal;
 430          * we have read the data, send an error without closing the socket.
 431          */
 432         scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM_LEN));
 433         return CHECK_CONDITION;
 434     }
 435
 436     switch (rq_servact) {
 437     case MPATH_PROUT_REG_SA:
 438     case MPATH_PROUT_RES_SA:
 439     case MPATH_PROUT_REL_SA:
 440     case MPATH_PROUT_CLEAR_SA:
 441     case MPATH_PROUT_PREE_SA:
 442     case MPATH_PROUT_PREE_AB_SA:
 443     case MPATH_PROUT_REG_IGN_SA:
 444         break;
 445     case MPATH_PROUT_REG_MOV_SA:
 446         /* Not supported by struct prout_param_descriptor.  */
 447     default:
 448         /* Cannot parse any other input.  */
 449         scsi_build_sense(sense, SENSE_CODE(INVALID_FIELD));
 450         return CHECK_CONDITION;
 451     }
 452
 453     /* Convert input data, especially transport IDs, to the structs
 454      * used by libmpathpersist (which, of course, will immediately
 455      * do the opposite).
 456      */
 457     memset(&paramp, 0, sizeof(paramp));
 458     memcpy(&paramp.key, &param[0], 8);
 459     memcpy(&paramp.sa_key, &param[8], 8);
 460     paramp.sa_flags = param[20];
 461     if (sz > PR_OUT_FIXED_PARAM_SIZE) {
 462         size_t transportid_len;
 463         int i, j;
 464         if (sz < PR_OUT_FIXED_PARAM_SIZE + 4) {
 465             scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM_LEN));
 466             return CHECK_CONDITION;
 467         }
 468         transportid_len = ldl_be_p(&param[24]) + PR_OUT_FIXED_PARAM_SIZE + 4;
 469         if (transportid_len > sz) {
 470             scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM));
 471             return CHECK_CONDITION;
 472         }
 473         for (i = PR_OUT_FIXED_PARAM_SIZE + 4, j = 0; i < transportid_len; ) {
 474             struct transportid *id = (struct transportid *) &transportids[j];
 475             int len;
 476
 477             id->format_code = param[i] & 0xc0;
 478             id->protocol_id = param[i] & 0x0f;
 479             switch (param[i] & 0xcf) {
 480             case 0:
 481                 /* FC transport.  */
 482                 if (i + 24 > transportid_len) {
 483                     goto illegal_req;
 484                 }
 485                 memcpy(id->n_port_name, &param[i + 8], 8);
 486                 j += offsetof(struct transportid, n_port_name[8]);
 487                 i += 24;
 488                 break;
 489             case 5:
 490             case 0x45:
 491                 /* iSCSI transport.  */
 492                 len = lduw_be_p(&param[i + 2]);
 493                 if (len > 252 || (len & 3) || i + len + 4 > transportid_len) {
 494                     /* For format code 00, the standard says the maximum is 223
 495                      * plus the NUL terminator.  For format code 01 there is no
 496                      * maximum length, but libmpathpersist ignores the first
 497                      * byte of id->iscsi_name so our maximum is 252.
 498                      */
 499                     goto illegal_req;
 500                 }
 501                 if (memchr(&param[i + 4], 0, len) == NULL) {
 502                     goto illegal_req;
 503                 }
 504                 memcpy(id->iscsi_name, &param[i + 2], len + 2);
 505                 j += offsetof(struct transportid, iscsi_name[len + 2]);
 506                 i += len + 4;
 507                 break;
 508             case 6:
 509                 /* SAS transport.  */
 510                 if (i + 24 > transportid_len) {
 511                     goto illegal_req;
 512                 }
 513                 memcpy(id->sas_address, &param[i + 4], 8);
 514                 j += offsetof(struct transportid, sas_address[8]);
 515                 i += 24;
 516                 break;
 517             default:
 518             illegal_req:
 519                 scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM));
 520                 return CHECK_CONDITION;
 521             }
 522
 523             paramp.trnptid_list[paramp.num_transportid++] = id;
 524         }
 525     }
 526
 527     r = mpath_persistent_reserve_out(fd, rq_servact, rq_scope, rq_type,
 528                                      &paramp, noisy, verbose);
 529     return mpath_reconstruct_sense(fd, r, sense);
 530 }
 531 #endif
 532
 533 static int do_pr_in(int fd, const uint8_t *cdb, uint8_t *sense,
 534                     uint8_t *data, int *resp_sz)
 535 {
 536 #ifdef CONFIG_MPATH
 537     if (is_mpath(fd)) {
 538         /* multipath_pr_in fills the whole input buffer.  */
 539         int r = multipath_pr_in(fd, cdb, sense, data, *resp_sz);
 540         if (r != GOOD) {
 541             *resp_sz = 0;
 542         }
 543         return r;
 544     }
 545 #endif
 546
 547     return do_sgio(fd, cdb, sense, data, resp_sz,
 548                    SG_DXFER_FROM_DEV);
 549 }
 550
 551 static int do_pr_out(int fd, const uint8_t *cdb, uint8_t *sense,
 552                      const uint8_t *param, int sz)
 553 {
 554     int resp_sz;
 555
 556     if ((fcntl(fd, F_GETFL) & O_ACCMODE) == O_RDONLY) {
 557         scsi_build_sense(sense, SENSE_CODE(INVALID_OPCODE));
 558         return CHECK_CONDITION;
 559     }
 560
 561 #ifdef CONFIG_MPATH
 562     if (is_mpath(fd)) {
 563         return multipath_pr_out(fd, cdb, sense, param, sz);
 564     }
 565 #endif
 566
 567     resp_sz = sz;
 568     return do_sgio(fd, cdb, sense, (uint8_t *)param, &resp_sz,
 569                    SG_DXFER_TO_DEV);
 570 }
 571
 572 /* Client */
 573
 574 typedef struct PRHelperClient {
 575     QIOChannelSocket *ioc;
 576     Coroutine *co;
 577     int fd;
 578     uint8_t data[PR_HELPER_DATA_SIZE];
 579 } PRHelperClient;
 580
 581 typedef struct PRHelperRequest {
 582     int fd;
 583     size_t sz;
 584     uint8_t cdb[PR_HELPER_CDB_SIZE];
 585 } PRHelperRequest;
 586
 587 static int coroutine_fn prh_read(PRHelperClient *client, void *buf, int sz,
 588                                  Error **errp)
 589 {
 590     int ret = 0;
 591
 592     while (sz > 0) {
 593         int *fds = NULL;
 594         size_t nfds = 0;
 595         int i;
 596         struct iovec iov;
 597         ssize_t n_read;
 598
 599         iov.iov_base = buf;
 600         iov.iov_len = sz;
 601         n_read = qio_channel_readv_full(QIO_CHANNEL(client->ioc), &iov, 1,
 602                                         &fds, &nfds, errp);
 603
 604         if (n_read == QIO_CHANNEL_ERR_BLOCK) {
 605             qio_channel_yield(QIO_CHANNEL(client->ioc), G_IO_IN);
 606             continue;
 607         }
 608         if (n_read <= 0) {
 609             ret = n_read ? n_read : -1;
 610             goto err;
 611         }
 612
 613         /* Stash one file descriptor per request.  */
 614         if (nfds) {
 615             bool too_many = false;
 616             for (i = 0; i < nfds; i++) {
 617                 if (client->fd == -1) {
 618                     client->fd = fds[i];
 619                 } else {
 620                     close(fds[i]);
 621                     too_many = true;
 622                 }
 623             }
 624             g_free(fds);
 625             if (too_many) {
 626                 ret = -1;
 627                 goto err;
 628             }
 629         }
 630
 631         buf += n_read;
 632         sz -= n_read;
 633     }
 634
 635     return 0;
 636
 637 err:
 638     if (client->fd != -1) {
 639         close(client->fd);
 640         client->fd = -1;
 641     }
 642     return ret;
 643 }
 644
 645 static int coroutine_fn prh_read_request(PRHelperClient *client,
 646                                          PRHelperRequest *req,
 647                                          PRHelperResponse *resp, Error **errp)
 648 {
 649     uint32_t sz;
 650
 651     if (prh_read(client, req->cdb, sizeof(req->cdb), NULL) < 0) {
 652         return -1;
 653     }
 654
 655     if (client->fd == -1) {
 656         error_setg(errp, "No file descriptor in request.");
 657         return -1;
 658     }
 659
 660     if (req->cdb[0] != PERSISTENT_RESERVE_OUT &&
 661         req->cdb[0] != PERSISTENT_RESERVE_IN) {
 662         error_setg(errp, "Invalid CDB, closing socket.");
 663         goto out_close;
 664     }
 665
 666     sz = scsi_cdb_xfer(req->cdb);
 667     if (sz > sizeof(client->data)) {
 668         goto out_close;
 669     }
 670
 671     if (req->cdb[0] == PERSISTENT_RESERVE_OUT) {
 672         if (qio_channel_read_all(QIO_CHANNEL(client->ioc),
 673                                  (char *)client->data, sz,
 674                                  errp) < 0) {
 675             goto out_close;
 676         }
 677     }
 678
 679     req->fd = client->fd;
 680     req->sz = sz;
 681     client->fd = -1;
 682     return sz;
 683
 684 out_close:
 685     close(client->fd);
 686     client->fd = -1;
 687     return -1;
 688 }
 689
 690 static int coroutine_fn prh_write_response(PRHelperClient *client,
 691                                            PRHelperRequest *req,
 692                                            PRHelperResponse *resp, Error **errp)
 693 {
 694     ssize_t r;
 695     size_t sz;
 696
 697     if (req->cdb[0] == PERSISTENT_RESERVE_IN && resp->result == GOOD) {
 698         assert(resp->sz <= req->sz && resp->sz <= sizeof(client->data));
 699     } else {
 700         assert(resp->sz == 0);
 701     }
 702
 703     sz = resp->sz;
 704
 705     resp->result = cpu_to_be32(resp->result);
 706     resp->sz = cpu_to_be32(resp->sz);
 707     r = qio_channel_write_all(QIO_CHANNEL(client->ioc),
 708                               (char *) resp, sizeof(*resp), errp);
 709     if (r < 0) {
 710         return r;
 711     }
 712
 713     r = qio_channel_write_all(QIO_CHANNEL(client->ioc),
 714                               (char *) client->data,
 715                               sz, errp);
 716     return r < 0 ? r : 0;
 717 }
 718
 719 static void coroutine_fn prh_co_entry(void *opaque)
 720 {
 721     PRHelperClient *client = opaque;
 722     Error *local_err = NULL;
 723     uint32_t flags;
 724     int r;
 725
 726     qio_channel_set_blocking(QIO_CHANNEL(client->ioc),
 727                              false, NULL);
 728     qio_channel_attach_aio_context(QIO_CHANNEL(client->ioc),
 729                                    qemu_get_aio_context());
 730
 731     /* A very simple negotiation for future extensibility.  No features
 732      * are defined so write 0.
 733      */
 734     flags = cpu_to_be32(0);
 735     r = qio_channel_write_all(QIO_CHANNEL(client->ioc),
 736                              (char *) &flags, sizeof(flags), NULL);
 737     if (r < 0) {
 738         goto out;
 739     }
 740
 741     r = qio_channel_read_all(QIO_CHANNEL(client->ioc),
 742                              (char *) &flags, sizeof(flags), NULL);
 743     if (be32_to_cpu(flags) != 0 || r < 0) {
 744         goto out;
 745     }
 746
 747     while (atomic_read(&state) == RUNNING) {
 748         PRHelperRequest req;
 749         PRHelperResponse resp;
 750         int sz;
 751
 752         sz = prh_read_request(client, &req, &resp, &local_err);
 753         if (sz < 0) {
 754             break;
 755         }
 756
 757         num_active_sockets++;
 758         if (req.cdb[0] == PERSISTENT_RESERVE_OUT) {
 759             r = do_pr_out(req.fd, req.cdb, resp.sense,
 760                           client->data, sz);
 761             resp.sz = 0;
 762         } else {
 763             resp.sz = sizeof(client->data);
 764             r = do_pr_in(req.fd, req.cdb, resp.sense,
 765                          client->data, &resp.sz);
 766             resp.sz = MIN(resp.sz, sz);
 767         }
 768         num_active_sockets--;
 769         close(req.fd);
 770         if (r == -1) {
 771             break;
 772         }
 773         resp.result = r;
 774
 775         if (prh_write_response(client, &req, &resp, &local_err) < 0) {
 776             break;
 777         }
 778     }
 779
 780     if (local_err) {
 781         if (verbose == 0) {
 782             error_free(local_err);
 783         } else {
 784             error_report_err(local_err);
 785         }
 786     }
 787
 788 out:
 789     qio_channel_detach_aio_context(QIO_CHANNEL(client->ioc));
 790     object_unref(OBJECT(client->ioc));
 791     g_free(client);
 792 }
 793
 794 static gboolean accept_client(QIOChannel *ioc, GIOCondition cond, gpointer opaque)
 795 {
 796     QIOChannelSocket *cioc;
 797     PRHelperClient *prh;
 798
 799     cioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc),
 800                                      NULL);
 801     if (!cioc) {
 802         return TRUE;
 803     }
 804
 805     prh = g_new(PRHelperClient, 1);
 806     prh->ioc = cioc;
 807     prh->fd = -1;
 808     prh->co = qemu_coroutine_create(prh_co_entry, prh);
 809     qemu_coroutine_enter(prh->co);
 810
 811     return TRUE;
 812 }
 813
 814 static void termsig_handler(int signum)
 815 {
 816     atomic_cmpxchg(&state, RUNNING, TERMINATE);
 817     qemu_notify_event();
 818 }
 819
 820 static void close_server_socket(void)
 821 {
 822     assert(server_ioc);
 823
 824     g_source_remove(server_watch);
 825     server_watch = -1;
 826     object_unref(OBJECT(server_ioc));
 827     num_active_sockets--;
 828 }
 829
 830 #ifdef CONFIG_LIBCAP
 831 static int drop_privileges(void)
 832 {
 833     /* clear all capabilities */
 834     capng_clear(CAPNG_SELECT_BOTH);
 835
 836     if (capng_update(CAPNG_ADD, CAPNG_EFFECTIVE | CAPNG_PERMITTED,
 837                      CAP_SYS_RAWIO) < 0) {
 838         return -1;
 839     }
 840
 841 #ifdef CONFIG_MPATH
 842     /* For /dev/mapper/control ioctls */
 843     if (capng_update(CAPNG_ADD, CAPNG_EFFECTIVE | CAPNG_PERMITTED,
 844                      CAP_SYS_ADMIN) < 0) {
 845         return -1;
 846     }
 847 #endif
 848
 849     /* Change user/group id, retaining the capabilities.  Because file descriptors
 850      * are passed via SCM_RIGHTS, we don't need supplementary groups (and in
 851      * fact the helper can run as "nobody").
 852      */
 853     if (capng_change_id(uid != -1 ? uid : getuid(),
 854                         gid != -1 ? gid : getgid(),
 855                         CAPNG_DROP_SUPP_GRP | CAPNG_CLEAR_BOUNDING)) {
 856         return -1;
 857     }
 858
 859     return 0;
 860 }
 861 #endif
 862
 863 int main(int argc, char **argv)
 864 {
 865     const char *sopt = "hVk:f:dT:u:g:vq";
 866     struct option lopt[] = {
 867         { "help", no_argument, NULL, 'h' },
 868         { "version", no_argument, NULL, 'V' },
 869         { "socket", required_argument, NULL, 'k' },
 870         { "pidfile", required_argument, NULL, 'f' },
 871         { "daemon", no_argument, NULL, 'd' },
 872         { "trace", required_argument, NULL, 'T' },
 873         { "user", required_argument, NULL, 'u' },
 874         { "group", required_argument, NULL, 'g' },
 875         { "verbose", no_argument, NULL, 'v' },
 876         { "quiet", no_argument, NULL, 'q' },
 877         { NULL, 0, NULL, 0 }
 878     };
 879     int opt_ind = 0;
 880     int loglevel = 1;
 881     int quiet = 0;
 882     int ch;
 883     Error *local_err = NULL;
 884     char *trace_file = NULL;
 885     bool daemonize = false;
 886     bool pidfile_specified = false;
 887     bool socket_path_specified = false;
 888     unsigned socket_activation;
 889
 890     struct sigaction sa_sigterm;
 891     memset(&sa_sigterm, 0, sizeof(sa_sigterm));
 892     sa_sigterm.sa_handler = termsig_handler;
 893     sigaction(SIGTERM, &sa_sigterm, NULL);
 894     sigaction(SIGINT, &sa_sigterm, NULL);
 895     sigaction(SIGHUP, &sa_sigterm, NULL);
 896
 897     signal(SIGPIPE, SIG_IGN);
 898
 899     error_init(argv[0]);
 900     module_call_init(MODULE_INIT_TRACE);
 901     module_call_init(MODULE_INIT_QOM);
 902     qemu_add_opts(&qemu_trace_opts);
 903     qemu_init_exec_dir(argv[0]);
 904
 905     compute_default_paths();
 906
 907     while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) {
 908         switch (ch) {
 909         case 'k':
 910             g_free(socket_path);
 911             socket_path = g_strdup(optarg);
 912             socket_path_specified = true;
 913             if (socket_path[0] != '/') {
 914                 error_report("socket path must be absolute");
 915                 exit(EXIT_FAILURE);
 916             }
 917             break;
 918         case 'f':
 919             g_free(pidfile);
 920             pidfile = g_strdup(optarg);
 921             pidfile_specified = true;
 922             break;
 923 #ifdef CONFIG_LIBCAP
 924         case 'u': {
 925             unsigned long res;
 926             struct passwd *userinfo = getpwnam(optarg);
 927             if (userinfo) {
 928                 uid = userinfo->pw_uid;
 929             } else if (qemu_strtoul(optarg, NULL, 10, &res) == 0 &&
 930                        (uid_t)res == res) {
 931                 uid = res;
 932             } else {
 933                 error_report("invalid user '%s'", optarg);
 934                 exit(EXIT_FAILURE);
 935             }
 936             break;
 937         }
 938         case 'g': {
 939             unsigned long res;
 940             struct group *groupinfo = getgrnam(optarg);
 941             if (groupinfo) {
 942                 gid = groupinfo->gr_gid;
 943             } else if (qemu_strtoul(optarg, NULL, 10, &res) == 0 &&
 944                        (gid_t)res == res) {
 945                 gid = res;
 946             } else {
 947                 error_report("invalid group '%s'", optarg);
 948                 exit(EXIT_FAILURE);
 949             }
 950             break;
 951         }
 952 #else
 953         case 'u':
 954         case 'g':
 955             error_report("-%c not supported by this %s", ch, argv[0]);
 956             exit(1);
 957 #endif
 958         case 'd':
 959             daemonize = true;
 960             break;
 961         case 'q':
 962             quiet = 1;
 963             break;
 964         case 'v':
 965             ++loglevel;
 966             break;
 967         case 'T':
 968             g_free(trace_file);
 969             trace_file = trace_opt_parse(optarg);
 970             break;
 971         case 'V':
 972             version(argv[0]);
 973             exit(EXIT_SUCCESS);
 974             break;
 975         case 'h':
 976             usage(argv[0]);
 977             exit(EXIT_SUCCESS);
 978             break;
 979         case '?':
 980             error_report("Try `%s --help' for more information.", argv[0]);
 981             exit(EXIT_FAILURE);
 982         }
 983     }
 984
 985     /* set verbosity */
 986     noisy = !quiet && (loglevel >= 3);
 987     verbose = quiet ? 0 : MIN(loglevel, 3);
 988
 989     if (!trace_init_backends()) {
 990         exit(EXIT_FAILURE);
 991     }
 992     trace_init_file(trace_file);
 993     qemu_set_log(LOG_TRACE);
 994
 995 #ifdef CONFIG_MPATH
 996     dm_init();
 997     multipath_pr_init();
 998 #endif
 999
1000     socket_activation = check_socket_activation();
1001     if (socket_activation == 0) {
1002         SocketAddress saddr;
1003         saddr = (SocketAddress){
1004             .type = SOCKET_ADDRESS_TYPE_UNIX,
1005             .u.q_unix.path = socket_path,
1006         };
1007         server_ioc = qio_channel_socket_new();
1008         if (qio_channel_socket_listen_sync(server_ioc, &saddr,
1009                                            1, &local_err) < 0) {
1010             object_unref(OBJECT(server_ioc));
1011             error_report_err(local_err);
1012             return 1;
1013         }
1014     } else {
1015         /* Using socket activation - check user didn't use -p etc. */
1016         if (socket_path_specified) {
1017             error_report("Unix socket can't be set when using socket activation");
1018             exit(EXIT_FAILURE);
1019         }
1020
1021         /* Can only listen on a single socket.  */
1022         if (socket_activation > 1) {
1023             error_report("%s does not support socket activation with LISTEN_FDS > 1",
1024                          argv[0]);
1025             exit(EXIT_FAILURE);
1026         }
1027         server_ioc = qio_channel_socket_new_fd(FIRST_SOCKET_ACTIVATION_FD,
1028                                                &local_err);
1029         if (server_ioc == NULL) {
1030             error_report("Failed to use socket activation: %s",
1031                          error_get_pretty(local_err));
1032             exit(EXIT_FAILURE);
1033         }
1034     }
1035
1036     if (qemu_init_main_loop(&local_err)) {
1037         error_report_err(local_err);
1038         exit(EXIT_FAILURE);
1039     }
1040
1041     server_watch = qio_channel_add_watch(QIO_CHANNEL(server_ioc),
1042                                          G_IO_IN,
1043                                          accept_client,
1044                                          NULL, NULL);
1045
1046     if (daemonize) {
1047         if (daemon(0, 0) < 0) {
1048             error_report("Failed to daemonize: %s", strerror(errno));
1049             exit(EXIT_FAILURE);
1050         }
1051     }
1052
1053     if ((daemonize || pidfile_specified) &&
1054         !qemu_write_pidfile(pidfile, &local_err)) {
1055         error_report_err(local_err);
1056         exit(EXIT_FAILURE);
1057     }
1058
1059 #ifdef CONFIG_LIBCAP
1060     if (drop_privileges() < 0) {
1061         error_report("Failed to drop privileges: %s", strerror(errno));
1062         exit(EXIT_FAILURE);
1063     }
1064 #endif
1065
1066     state = RUNNING;
1067     do {
1068         main_loop_wait(false);
1069         if (state == TERMINATE) {
1070             state = TERMINATING;
1071             close_server_socket();
1072         }
1073     } while (num_active_sockets > 0);
1074
1075     exit(EXIT_SUCCESS);
1076 }