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(¶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 | /* FC transport. */ |
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 | /* iSCSI transport. */ |
492 | len = lduw_be_p(¶m[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(¶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 | /* SAS transport. */ |
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 | |
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 | } |
1077 | |