1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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
122
123typedef struct PRHelperSGIOData {
124 int fd;
125 const uint8_t *cdb;
126 uint8_t *sense;
127 uint8_t *buf;
128 int sz;
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
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
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
322
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
337
338
339 scsi_build_sense(sense, SENSE_CODE(SCSI_BUS_RESET));
340 return CHECK_CONDITION;
341 case MPATH_PR_SENSE_INVALID_OP:
342
343 scsi_build_sense(sense, SENSE_CODE(INVALID_OPCODE));
344 return CHECK_CONDITION;
345 case MPATH_PR_ILLEGAL_REQ:
346
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
378 default:
379
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
430
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
447 default:
448
449 scsi_build_sense(sense, SENSE_CODE(INVALID_FIELD));
450 return CHECK_CONDITION;
451 }
452
453
454
455
456
457 memset(¶mp, 0, sizeof(paramp));
458 memcpy(¶mp.key, ¶m[0], 8);
459 memcpy(¶mp.sa_key, ¶m[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(¶m[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
482 if (i + 24 > transportid_len) {
483 goto illegal_req;
484 }
485 memcpy(id->n_port_name, ¶m[i + 8], 8);
486 j += offsetof(struct transportid, n_port_name[8]);
487 i += 24;
488 break;
489 case 5:
490 case 0x45:
491
492 len = lduw_be_p(¶m[i + 2]);
493 if (len > 252 || (len & 3) || i + len + 4 > transportid_len) {
494
495
496
497
498
499 goto illegal_req;
500 }
501 if (memchr(¶m[i + 4], 0, len) == NULL) {
502 goto illegal_req;
503 }
504 memcpy(id->iscsi_name, ¶m[i + 2], len + 2);
505 j += offsetof(struct transportid, iscsi_name[len + 2]);
506 i += len + 4;
507 break;
508 case 6:
509
510 if (i + 24 > transportid_len) {
511 goto illegal_req;
512 }
513 memcpy(id->sas_address, ¶m[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 ¶mp, 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
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
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
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
732
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
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
843 if (capng_update(CAPNG_ADD, CAPNG_EFFECTIVE | CAPNG_PERMITTED,
844 CAP_SYS_ADMIN) < 0) {
845 return -1;
846 }
847#endif
848
849
850
851
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
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, &local_err) < 0) {
1009 object_unref(OBJECT(server_ioc));
1010 error_report_err(local_err);
1011 return 1;
1012 }
1013 } else {
1014
1015 if (socket_path_specified) {
1016 error_report("Unix socket can't be set when using socket activation");
1017 exit(EXIT_FAILURE);
1018 }
1019
1020
1021 if (socket_activation > 1) {
1022 error_report("%s does not support socket activation with LISTEN_FDS > 1",
1023 argv[0]);
1024 exit(EXIT_FAILURE);
1025 }
1026 server_ioc = qio_channel_socket_new_fd(FIRST_SOCKET_ACTIVATION_FD,
1027 &local_err);
1028 if (server_ioc == NULL) {
1029 error_report("Failed to use socket activation: %s",
1030 error_get_pretty(local_err));
1031 exit(EXIT_FAILURE);
1032 }
1033 }
1034
1035 if (qemu_init_main_loop(&local_err)) {
1036 error_report_err(local_err);
1037 exit(EXIT_FAILURE);
1038 }
1039
1040 server_watch = qio_channel_add_watch(QIO_CHANNEL(server_ioc),
1041 G_IO_IN,
1042 accept_client,
1043 NULL, NULL);
1044
1045 if (daemonize) {
1046 if (daemon(0, 0) < 0) {
1047 error_report("Failed to daemonize: %s", strerror(errno));
1048 exit(EXIT_FAILURE);
1049 }
1050 }
1051
1052 if ((daemonize || pidfile_specified) &&
1053 !qemu_write_pidfile(pidfile, &local_err)) {
1054 error_report_err(local_err);
1055 exit(EXIT_FAILURE);
1056 }
1057
1058#ifdef CONFIG_LIBCAP
1059 if (drop_privileges() < 0) {
1060 error_report("Failed to drop privileges: %s", strerror(errno));
1061 exit(EXIT_FAILURE);
1062 }
1063#endif
1064
1065 state = RUNNING;
1066 do {
1067 main_loop_wait(false);
1068 if (state == TERMINATE) {
1069 state = TERMINATING;
1070 close_server_socket();
1071 }
1072 } while (num_active_sockets > 0);
1073
1074 exit(EXIT_SUCCESS);
1075}
1076
