qemu/scsi/qemu-pr-helper.c
<<
>>
Prefs
   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
  64static char *socket_path;
  65static char *pidfile;
  66static enum { RUNNING, TERMINATE, TERMINATING } state;
  67static QIOChannelSocket *server_ioc;
  68static int server_watch;
  69static int num_active_sockets = 1;
  70static int noisy;
  71static int verbose;
  72
  73#ifdef CONFIG_LIBCAP
  74static int uid = -1;
  75static int gid = -1;
  76#endif
  77
  78static 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
  84static 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"
 105QEMU_HELP_BOTTOM "\n"
 106    , name, pidfile, socket_path);
 107}
 108
 109static void version(const char *name)
 110{
 111    printf(
 112"%s " QEMU_FULL_VERSION "\n"
 113"Written by Paolo Bonzini.\n"
 114"\n"
 115QEMU_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
 123typedef 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
 132static 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
 168static 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
 193typedef struct DMData {
 194    struct dm_ioctl dm;
 195    uint8_t data[1024];
 196} DMData;
 197
 198static int control_fd;
 199
 200static 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
 218static 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
 233static 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.  */
 252QEMU_BUILD_BUG_ON(PR_HELPER_DATA_SIZE > MPATH_MAX_PARAM_LEN);
 253static struct config *multipath_conf;
 254unsigned mpath_mx_alloc_len = PR_HELPER_DATA_SIZE;
 255int logsink;
 256struct udev *udev;
 257
 258extern struct config *get_multipath_config(void);
 259struct config *get_multipath_config(void)
 260{
 261    return multipath_conf;
 262}
 263
 264extern void put_multipath_config(struct config *conf);
 265void put_multipath_config(struct config *conf)
 266{
 267}
 268
 269static 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
 279static 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
 295static 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
 311static 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 ret = do_sgio(fd, cdb, sense, NULL, &sz, SG_DXFER_NONE);
 327
 328            if (ret != GOOD) {
 329                return ret;
 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
 363static 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
 418static 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
 533static 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
 551static 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
 574typedef struct PRHelperClient {
 575    QIOChannelSocket *ioc;
 576    Coroutine *co;
 577    int fd;
 578    uint8_t data[PR_HELPER_DATA_SIZE];
 579} PRHelperClient;
 580
 581typedef struct PRHelperRequest {
 582    int fd;
 583    size_t sz;
 584    uint8_t cdb[PR_HELPER_CDB_SIZE];
 585} PRHelperRequest;
 586
 587static 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
 637err:
 638    if (client->fd != -1) {
 639        close(client->fd);
 640        client->fd = -1;
 641    }
 642    return ret;
 643}
 644
 645static 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
 684out_close:
 685    close(client->fd);
 686    client->fd = -1;
 687    return -1;
 688}
 689
 690static 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
 719static 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
 788out:
 789    qio_channel_detach_aio_context(QIO_CHANNEL(client->ioc));
 790    object_unref(OBJECT(client->ioc));
 791    g_free(client);
 792}
 793
 794static 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
 814static void termsig_handler(int signum)
 815{
 816    atomic_cmpxchg(&state, RUNNING, TERMINATE);
 817    qemu_notify_event();
 818}
 819
 820static 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
 831static 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
 863int 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}
1077