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_NG 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_NG 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_NG 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 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 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 g_autofree struct prout_param_descriptor *paramp = NULL; 425 char transportids[PR_HELPER_DATA_SIZE]; 426 int r; 427 428 paramp = g_malloc0(sizeof(struct prout_param_descriptor) 429 + sizeof(struct transportid *) * MPATH_MX_TIDS); 430 431 if (sz < PR_OUT_FIXED_PARAM_SIZE) { 432 /* Illegal request, Parameter list length error. This isn't fatal; 433 * we have read the data, send an error without closing the socket. 434 */ 435 scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM_LEN)); 436 return CHECK_CONDITION; 437 } 438 439 switch (rq_servact) { 440 case MPATH_PROUT_REG_SA: 441 case MPATH_PROUT_RES_SA: 442 case MPATH_PROUT_REL_SA: 443 case MPATH_PROUT_CLEAR_SA: 444 case MPATH_PROUT_PREE_SA: 445 case MPATH_PROUT_PREE_AB_SA: 446 case MPATH_PROUT_REG_IGN_SA: 447 break; 448 case MPATH_PROUT_REG_MOV_SA: 449 /* Not supported by struct prout_param_descriptor. */ 450 default: 451 /* Cannot parse any other input. */ 452 scsi_build_sense(sense, SENSE_CODE(INVALID_FIELD)); 453 return CHECK_CONDITION; 454 } 455 456 /* Convert input data, especially transport IDs, to the structs 457 * used by libmpathpersist (which, of course, will immediately 458 * do the opposite). 459 */ 460 memcpy(¶mp->key, ¶m[0], 8); 461 memcpy(¶mp->sa_key, ¶m[8], 8); 462 paramp->sa_flags = param[20]; 463 if (sz > PR_OUT_FIXED_PARAM_SIZE) { 464 size_t transportid_len; 465 int i, j; 466 if (sz < PR_OUT_FIXED_PARAM_SIZE + 4) { 467 scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM_LEN)); 468 return CHECK_CONDITION; 469 } 470 transportid_len = ldl_be_p(¶m[24]) + PR_OUT_FIXED_PARAM_SIZE + 4; 471 if (transportid_len > sz) { 472 scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM)); 473 return CHECK_CONDITION; 474 } 475 for (i = PR_OUT_FIXED_PARAM_SIZE + 4, j = 0; i < transportid_len; ) { 476 struct transportid *id = (struct transportid *) &transportids[j]; 477 int len; 478 479 id->format_code = param[i] & 0xc0; 480 id->protocol_id = param[i] & 0x0f; 481 switch (param[i] & 0xcf) { 482 case 0: 483 /* FC transport. */ 484 if (i + 24 > transportid_len) { 485 goto illegal_req; 486 } 487 memcpy(id->n_port_name, ¶m[i + 8], 8); 488 j += offsetof(struct transportid, n_port_name[8]); 489 i += 24; 490 break; 491 case 5: 492 case 0x45: 493 /* iSCSI transport. */ 494 len = lduw_be_p(¶m[i + 2]); 495 if (len > 252 || (len & 3) || i + len + 4 > transportid_len) { 496 /* For format code 00, the standard says the maximum is 223 497 * plus the NUL terminator. For format code 01 there is no 498 * maximum length, but libmpathpersist ignores the first 499 * byte of id->iscsi_name so our maximum is 252. 500 */ 501 goto illegal_req; 502 } 503 if (memchr(¶m[i + 4], 0, len) == NULL) { 504 goto illegal_req; 505 } 506 memcpy(id->iscsi_name, ¶m[i + 2], len + 2); 507 j += offsetof(struct transportid, iscsi_name[len + 2]); 508 i += len + 4; 509 break; 510 case 6: 511 /* SAS transport. */ 512 if (i + 24 > transportid_len) { 513 goto illegal_req; 514 } 515 memcpy(id->sas_address, ¶m[i + 4], 8); 516 j += offsetof(struct transportid, sas_address[8]); 517 i += 24; 518 break; 519 default: 520 illegal_req: 521 scsi_build_sense(sense, SENSE_CODE(INVALID_PARAM)); 522 return CHECK_CONDITION; 523 } 524 525 assert(paramp->num_transportid < MPATH_MX_TIDS); 526 paramp->trnptid_list[paramp->num_transportid++] = id; 527 } 528 } 529 530 r = mpath_persistent_reserve_out(fd, rq_servact, rq_scope, rq_type, 531 paramp, noisy, verbose); 532 return mpath_reconstruct_sense(fd, r, sense); 533 } 534 #endif 535 536 static int do_pr_in(int fd, const uint8_t *cdb, uint8_t *sense, 537 uint8_t *data, int *resp_sz) 538 { 539 #ifdef CONFIG_MPATH 540 if (is_mpath(fd)) { 541 /* multipath_pr_in fills the whole input buffer. */ 542 int r = multipath_pr_in(fd, cdb, sense, data, *resp_sz); 543 if (r != GOOD) { 544 *resp_sz = 0; 545 } 546 return r; 547 } 548 #endif 549 550 return do_sgio(fd, cdb, sense, data, resp_sz, 551 SG_DXFER_FROM_DEV); 552 } 553 554 static int do_pr_out(int fd, const uint8_t *cdb, uint8_t *sense, 555 const uint8_t *param, int sz) 556 { 557 int resp_sz; 558 559 if ((fcntl(fd, F_GETFL) & O_ACCMODE) == O_RDONLY) { 560 scsi_build_sense(sense, SENSE_CODE(INVALID_OPCODE)); 561 return CHECK_CONDITION; 562 } 563 564 #ifdef CONFIG_MPATH 565 if (is_mpath(fd)) { 566 return multipath_pr_out(fd, cdb, sense, param, sz); 567 } 568 #endif 569 570 resp_sz = sz; 571 return do_sgio(fd, cdb, sense, (uint8_t *)param, &resp_sz, 572 SG_DXFER_TO_DEV); 573 } 574 575 /* Client */ 576 577 typedef struct PRHelperClient { 578 QIOChannelSocket *ioc; 579 Coroutine *co; 580 int fd; 581 uint8_t data[PR_HELPER_DATA_SIZE]; 582 } PRHelperClient; 583 584 typedef struct PRHelperRequest { 585 int fd; 586 size_t sz; 587 uint8_t cdb[PR_HELPER_CDB_SIZE]; 588 } PRHelperRequest; 589 590 static int coroutine_fn prh_read(PRHelperClient *client, void *buf, int sz, 591 Error **errp) 592 { 593 int ret = 0; 594 595 while (sz > 0) { 596 int *fds = NULL; 597 size_t nfds = 0; 598 int i; 599 struct iovec iov; 600 ssize_t n_read; 601 602 iov.iov_base = buf; 603 iov.iov_len = sz; 604 n_read = qio_channel_readv_full(QIO_CHANNEL(client->ioc), &iov, 1, 605 &fds, &nfds, errp); 606 607 if (n_read == QIO_CHANNEL_ERR_BLOCK) { 608 qio_channel_yield(QIO_CHANNEL(client->ioc), G_IO_IN); 609 continue; 610 } 611 if (n_read <= 0) { 612 ret = n_read ? n_read : -1; 613 goto err; 614 } 615 616 /* Stash one file descriptor per request. */ 617 if (nfds) { 618 bool too_many = false; 619 for (i = 0; i < nfds; i++) { 620 if (client->fd == -1) { 621 client->fd = fds[i]; 622 } else { 623 close(fds[i]); 624 too_many = true; 625 } 626 } 627 g_free(fds); 628 if (too_many) { 629 ret = -1; 630 goto err; 631 } 632 } 633 634 buf += n_read; 635 sz -= n_read; 636 } 637 638 return 0; 639 640 err: 641 if (client->fd != -1) { 642 close(client->fd); 643 client->fd = -1; 644 } 645 return ret; 646 } 647 648 static int coroutine_fn prh_read_request(PRHelperClient *client, 649 PRHelperRequest *req, 650 PRHelperResponse *resp, Error **errp) 651 { 652 uint32_t sz; 653 654 if (prh_read(client, req->cdb, sizeof(req->cdb), NULL) < 0) { 655 return -1; 656 } 657 658 if (client->fd == -1) { 659 error_setg(errp, "No file descriptor in request."); 660 return -1; 661 } 662 663 if (req->cdb[0] != PERSISTENT_RESERVE_OUT && 664 req->cdb[0] != PERSISTENT_RESERVE_IN) { 665 error_setg(errp, "Invalid CDB, closing socket."); 666 goto out_close; 667 } 668 669 sz = scsi_cdb_xfer(req->cdb); 670 if (sz > sizeof(client->data)) { 671 goto out_close; 672 } 673 674 if (req->cdb[0] == PERSISTENT_RESERVE_OUT) { 675 if (qio_channel_read_all(QIO_CHANNEL(client->ioc), 676 (char *)client->data, sz, 677 errp) < 0) { 678 goto out_close; 679 } 680 } 681 682 req->fd = client->fd; 683 req->sz = sz; 684 client->fd = -1; 685 return sz; 686 687 out_close: 688 close(client->fd); 689 client->fd = -1; 690 return -1; 691 } 692 693 static int coroutine_fn prh_write_response(PRHelperClient *client, 694 PRHelperRequest *req, 695 PRHelperResponse *resp, Error **errp) 696 { 697 ssize_t r; 698 size_t sz; 699 700 if (req->cdb[0] == PERSISTENT_RESERVE_IN && resp->result == GOOD) { 701 assert(resp->sz <= req->sz && resp->sz <= sizeof(client->data)); 702 } else { 703 assert(resp->sz == 0); 704 } 705 706 sz = resp->sz; 707 708 resp->result = cpu_to_be32(resp->result); 709 resp->sz = cpu_to_be32(resp->sz); 710 r = qio_channel_write_all(QIO_CHANNEL(client->ioc), 711 (char *) resp, sizeof(*resp), errp); 712 if (r < 0) { 713 return r; 714 } 715 716 r = qio_channel_write_all(QIO_CHANNEL(client->ioc), 717 (char *) client->data, 718 sz, errp); 719 return r < 0 ? r : 0; 720 } 721 722 static void coroutine_fn prh_co_entry(void *opaque) 723 { 724 PRHelperClient *client = opaque; 725 Error *local_err = NULL; 726 uint32_t flags; 727 int r; 728 729 qio_channel_set_blocking(QIO_CHANNEL(client->ioc), 730 false, NULL); 731 qio_channel_attach_aio_context(QIO_CHANNEL(client->ioc), 732 qemu_get_aio_context()); 733 734 /* A very simple negotiation for future extensibility. No features 735 * are defined so write 0. 736 */ 737 flags = cpu_to_be32(0); 738 r = qio_channel_write_all(QIO_CHANNEL(client->ioc), 739 (char *) &flags, sizeof(flags), NULL); 740 if (r < 0) { 741 goto out; 742 } 743 744 r = qio_channel_read_all(QIO_CHANNEL(client->ioc), 745 (char *) &flags, sizeof(flags), NULL); 746 if (be32_to_cpu(flags) != 0 || r < 0) { 747 goto out; 748 } 749 750 while (qatomic_read(&state) == RUNNING) { 751 PRHelperRequest req; 752 PRHelperResponse resp; 753 int sz; 754 755 sz = prh_read_request(client, &req, &resp, &local_err); 756 if (sz < 0) { 757 break; 758 } 759 760 num_active_sockets++; 761 if (req.cdb[0] == PERSISTENT_RESERVE_OUT) { 762 r = do_pr_out(req.fd, req.cdb, resp.sense, 763 client->data, sz); 764 resp.sz = 0; 765 } else { 766 resp.sz = sizeof(client->data); 767 r = do_pr_in(req.fd, req.cdb, resp.sense, 768 client->data, &resp.sz); 769 resp.sz = MIN(resp.sz, sz); 770 } 771 num_active_sockets--; 772 close(req.fd); 773 if (r == -1) { 774 break; 775 } 776 resp.result = r; 777 778 if (prh_write_response(client, &req, &resp, &local_err) < 0) { 779 break; 780 } 781 } 782 783 if (local_err) { 784 if (verbose == 0) { 785 error_free(local_err); 786 } else { 787 error_report_err(local_err); 788 } 789 } 790 791 out: 792 qio_channel_detach_aio_context(QIO_CHANNEL(client->ioc)); 793 object_unref(OBJECT(client->ioc)); 794 g_free(client); 795 } 796 797 static gboolean accept_client(QIOChannel *ioc, GIOCondition cond, gpointer opaque) 798 { 799 QIOChannelSocket *cioc; 800 PRHelperClient *prh; 801 802 cioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc), 803 NULL); 804 if (!cioc) { 805 return TRUE; 806 } 807 808 prh = g_new(PRHelperClient, 1); 809 prh->ioc = cioc; 810 prh->fd = -1; 811 prh->co = qemu_coroutine_create(prh_co_entry, prh); 812 qemu_coroutine_enter(prh->co); 813 814 return TRUE; 815 } 816 817 static void termsig_handler(int signum) 818 { 819 qatomic_cmpxchg(&state, RUNNING, TERMINATE); 820 qemu_notify_event(); 821 } 822 823 static void close_server_socket(void) 824 { 825 assert(server_ioc); 826 827 g_source_remove(server_watch); 828 server_watch = -1; 829 object_unref(OBJECT(server_ioc)); 830 num_active_sockets--; 831 } 832 833 #ifdef CONFIG_LIBCAP_NG 834 static int drop_privileges(void) 835 { 836 /* clear all capabilities */ 837 capng_clear(CAPNG_SELECT_BOTH); 838 839 if (capng_update(CAPNG_ADD, CAPNG_EFFECTIVE | CAPNG_PERMITTED, 840 CAP_SYS_RAWIO) < 0) { 841 return -1; 842 } 843 844 #ifdef CONFIG_MPATH 845 /* For /dev/mapper/control ioctls */ 846 if (capng_update(CAPNG_ADD, CAPNG_EFFECTIVE | CAPNG_PERMITTED, 847 CAP_SYS_ADMIN) < 0) { 848 return -1; 849 } 850 #endif 851 852 /* Change user/group id, retaining the capabilities. Because file descriptors 853 * are passed via SCM_RIGHTS, we don't need supplementary groups (and in 854 * fact the helper can run as "nobody"). 855 */ 856 if (capng_change_id(uid != -1 ? uid : getuid(), 857 gid != -1 ? gid : getgid(), 858 CAPNG_DROP_SUPP_GRP | CAPNG_CLEAR_BOUNDING)) { 859 return -1; 860 } 861 862 return 0; 863 } 864 #endif 865 866 int main(int argc, char **argv) 867 { 868 const char *sopt = "hVk:f:dT:u:g:vq"; 869 struct option lopt[] = { 870 { "help", no_argument, NULL, 'h' }, 871 { "version", no_argument, NULL, 'V' }, 872 { "socket", required_argument, NULL, 'k' }, 873 { "pidfile", required_argument, NULL, 'f' }, 874 { "daemon", no_argument, NULL, 'd' }, 875 { "trace", required_argument, NULL, 'T' }, 876 { "user", required_argument, NULL, 'u' }, 877 { "group", required_argument, NULL, 'g' }, 878 { "verbose", no_argument, NULL, 'v' }, 879 { "quiet", no_argument, NULL, 'q' }, 880 { NULL, 0, NULL, 0 } 881 }; 882 int opt_ind = 0; 883 int loglevel = 1; 884 int quiet = 0; 885 int ch; 886 Error *local_err = NULL; 887 bool daemonize = false; 888 bool pidfile_specified = false; 889 bool socket_path_specified = false; 890 unsigned socket_activation; 891 892 struct sigaction sa_sigterm; 893 memset(&sa_sigterm, 0, sizeof(sa_sigterm)); 894 sa_sigterm.sa_handler = termsig_handler; 895 sigaction(SIGTERM, &sa_sigterm, NULL); 896 sigaction(SIGINT, &sa_sigterm, NULL); 897 sigaction(SIGHUP, &sa_sigterm, NULL); 898 899 signal(SIGPIPE, SIG_IGN); 900 901 error_init(argv[0]); 902 module_call_init(MODULE_INIT_TRACE); 903 module_call_init(MODULE_INIT_QOM); 904 qemu_add_opts(&qemu_trace_opts); 905 qemu_init_exec_dir(argv[0]); 906 907 compute_default_paths(); 908 909 while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) { 910 switch (ch) { 911 case 'k': 912 g_free(socket_path); 913 socket_path = g_strdup(optarg); 914 socket_path_specified = true; 915 if (socket_path[0] != '/') { 916 error_report("socket path must be absolute"); 917 exit(EXIT_FAILURE); 918 } 919 break; 920 case 'f': 921 g_free(pidfile); 922 pidfile = g_strdup(optarg); 923 pidfile_specified = true; 924 break; 925 #ifdef CONFIG_LIBCAP_NG 926 case 'u': { 927 unsigned long res; 928 struct passwd *userinfo = getpwnam(optarg); 929 if (userinfo) { 930 uid = userinfo->pw_uid; 931 } else if (qemu_strtoul(optarg, NULL, 10, &res) == 0 && 932 (uid_t)res == res) { 933 uid = res; 934 } else { 935 error_report("invalid user '%s'", optarg); 936 exit(EXIT_FAILURE); 937 } 938 break; 939 } 940 case 'g': { 941 unsigned long res; 942 struct group *groupinfo = getgrnam(optarg); 943 if (groupinfo) { 944 gid = groupinfo->gr_gid; 945 } else if (qemu_strtoul(optarg, NULL, 10, &res) == 0 && 946 (gid_t)res == res) { 947 gid = res; 948 } else { 949 error_report("invalid group '%s'", optarg); 950 exit(EXIT_FAILURE); 951 } 952 break; 953 } 954 #else 955 case 'u': 956 case 'g': 957 error_report("-%c not supported by this %s", ch, argv[0]); 958 exit(1); 959 #endif 960 case 'd': 961 daemonize = true; 962 break; 963 case 'q': 964 quiet = 1; 965 break; 966 case 'v': 967 ++loglevel; 968 break; 969 case 'T': 970 trace_opt_parse(optarg); 971 break; 972 case 'V': 973 version(argv[0]); 974 exit(EXIT_SUCCESS); 975 break; 976 case 'h': 977 usage(argv[0]); 978 exit(EXIT_SUCCESS); 979 break; 980 case '?': 981 error_report("Try `%s --help' for more information.", argv[0]); 982 exit(EXIT_FAILURE); 983 } 984 } 985 986 /* set verbosity */ 987 noisy = !quiet && (loglevel >= 3); 988 verbose = quiet ? 0 : MIN(loglevel, 3); 989 990 if (!trace_init_backends()) { 991 exit(EXIT_FAILURE); 992 } 993 trace_init_file(); 994 qemu_set_log(LOG_TRACE); 995 996 #ifdef CONFIG_MPATH 997 dm_init(); 998 multipath_pr_init(); 999 #endif 1000 1001 socket_activation = check_socket_activation(); 1002 if (socket_activation == 0) { 1003 SocketAddress saddr; 1004 saddr = (SocketAddress){ 1005 .type = SOCKET_ADDRESS_TYPE_UNIX, 1006 .u.q_unix.path = socket_path, 1007 }; 1008 server_ioc = qio_channel_socket_new(); 1009 if (qio_channel_socket_listen_sync(server_ioc, &saddr, 1010 1, &local_err) < 0) { 1011 object_unref(OBJECT(server_ioc)); 1012 error_report_err(local_err); 1013 return 1; 1014 } 1015 } else { 1016 /* Using socket activation - check user didn't use -p etc. */ 1017 if (socket_path_specified) { 1018 error_report("Unix socket can't be set when using socket activation"); 1019 exit(EXIT_FAILURE); 1020 } 1021 1022 /* Can only listen on a single socket. */ 1023 if (socket_activation > 1) { 1024 error_report("%s does not support socket activation with LISTEN_FDS > 1", 1025 argv[0]); 1026 exit(EXIT_FAILURE); 1027 } 1028 server_ioc = qio_channel_socket_new_fd(FIRST_SOCKET_ACTIVATION_FD, 1029 &local_err); 1030 if (server_ioc == NULL) { 1031 error_reportf_err(local_err, 1032 "Failed to use socket activation: "); 1033 exit(EXIT_FAILURE); 1034 } 1035 } 1036 1037 if (qemu_init_main_loop(&local_err)) { 1038 error_report_err(local_err); 1039 exit(EXIT_FAILURE); 1040 } 1041 1042 server_watch = qio_channel_add_watch(QIO_CHANNEL(server_ioc), 1043 G_IO_IN, 1044 accept_client, 1045 NULL, NULL); 1046 1047 if (daemonize) { 1048 if (daemon(0, 0) < 0) { 1049 error_report("Failed to daemonize: %s", strerror(errno)); 1050 exit(EXIT_FAILURE); 1051 } 1052 } 1053 1054 if ((daemonize || pidfile_specified) && 1055 !qemu_write_pidfile(pidfile, &local_err)) { 1056 error_report_err(local_err); 1057 exit(EXIT_FAILURE); 1058 } 1059 1060 #ifdef CONFIG_LIBCAP_NG 1061 if (drop_privileges() < 0) { 1062 error_report("Failed to drop privileges: %s", strerror(errno)); 1063 exit(EXIT_FAILURE); 1064 } 1065 #endif 1066 1067 state = RUNNING; 1068 do { 1069 main_loop_wait(false); 1070 if (state == TERMINATE) { 1071 state = TERMINATING; 1072 close_server_socket(); 1073 } 1074 } while (num_active_sockets > 0); 1075 1076 exit(EXIT_SUCCESS); 1077 } 1078