]>
Commit | Line | Data |
---|---|---|
b855f8d1 PB |
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 | ||
fe8fc5ae PB |
33 | #ifdef CONFIG_MPATH |
34 | #include <libudev.h> | |
35 | #include <mpath_cmd.h> | |
36 | #include <mpath_persist.h> | |
37 | #endif | |
38 | ||
a8d25326 | 39 | #include "qemu-common.h" |
b855f8d1 | 40 | #include "qapi/error.h" |
b855f8d1 PB |
41 | #include "qemu/cutils.h" |
42 | #include "qemu/main-loop.h" | |
0b8fa32f | 43 | #include "qemu/module.h" |
b855f8d1 PB |
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; | |
fe8fc5ae | 70 | static int noisy; |
b855f8d1 PB |
71 | static int verbose; |
72 | ||
73 | #ifdef CONFIG_LIBCAP | |
74 | static int uid = -1; | |
75 | static int gid = -1; | |
76 | #endif | |
77 | ||
50fa3325 PB |
78 | static void compute_default_paths(void) |
79 | { | |
2729d79d MP |
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"); | |
50fa3325 PB |
82 | } |
83 | ||
b855f8d1 PB |
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( | |
7e563bfb | 112 | "%s " QEMU_FULL_VERSION "\n" |
b855f8d1 PB |
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 | ||
b855f8d1 PB |
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 | ||
fe8fc5ae PB |
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 | } | |
039d4e3d | 240 | struct dm_ioctl dm = { }; |
fe8fc5ae PB |
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); | |
b3f1c8c4 | 253 | static struct config *multipath_conf; |
fe8fc5ae PB |
254 | unsigned mpath_mx_alloc_len = PR_HELPER_DATA_SIZE; |
255 | int logsink; | |
b3f1c8c4 | 256 | struct udev *udev; |
fe8fc5ae | 257 | |
b3f1c8c4 PB |
258 | extern struct config *get_multipath_config(void); |
259 | struct config *get_multipath_config(void) | |
fe8fc5ae | 260 | { |
b3f1c8c4 PB |
261 | return multipath_conf; |
262 | } | |
fe8fc5ae | 263 | |
b3f1c8c4 PB |
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 | { | |
fe8fc5ae | 271 | udev = udev_new(); |
1b0578f5 | 272 | #ifdef CONFIG_MPATH_NEW_API |
b3f1c8c4 | 273 | multipath_conf = mpath_lib_init(); |
1b0578f5 MOA |
274 | #else |
275 | mpath_lib_init(udev); | |
276 | #endif | |
fe8fc5ae PB |
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 | ||
a4a9b6ea PB |
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 | ||
fe8fc5ae PB |
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; | |
a4a9b6ea PB |
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; | |
fe8fc5ae PB |
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 | ||
ee8c13b8 PB |
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 | ||
fe8fc5ae PB |
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); | |
a4a9b6ea | 460 | paramp.sa_flags = param[20]; |
fe8fc5ae PB |
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; | |
a4a9b6ea PB |
489 | case 5: |
490 | case 0x45: | |
fe8fc5ae PB |
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 | ||
b855f8d1 PB |
533 | static int do_pr_in(int fd, const uint8_t *cdb, uint8_t *sense, |
534 | uint8_t *data, int *resp_sz) | |
535 | { | |
fe8fc5ae PB |
536 | #ifdef CONFIG_MPATH |
537 | if (is_mpath(fd)) { | |
538 | /* multipath_pr_in fills the whole input buffer. */ | |
86933b4e PB |
539 | int r = multipath_pr_in(fd, cdb, sense, data, *resp_sz); |
540 | if (r != GOOD) { | |
541 | *resp_sz = 0; | |
542 | } | |
543 | return r; | |
fe8fc5ae PB |
544 | } |
545 | #endif | |
546 | ||
b855f8d1 PB |
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 | { | |
fe8fc5ae | 554 | int resp_sz; |
ee8c13b8 PB |
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 | ||
fe8fc5ae PB |
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; | |
b855f8d1 PB |
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 | } | |
b855f8d1 PB |
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 | ||
ee8c13b8 PB |
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; | |
b855f8d1 | 772 | } |
ee8c13b8 | 773 | resp.result = r; |
b855f8d1 PB |
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 | ||
b855f8d1 PB |
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 | ||
fe8fc5ae PB |
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 | ||
b855f8d1 PB |
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 | { | |
f8e1a989 | 865 | const char *sopt = "hVk:f:dT:u:g:vq"; |
b855f8d1 PB |
866 | struct option lopt[] = { |
867 | { "help", no_argument, NULL, 'h' }, | |
868 | { "version", no_argument, NULL, 'V' }, | |
869 | { "socket", required_argument, NULL, 'k' }, | |
f8e1a989 | 870 | { "pidfile", required_argument, NULL, 'f' }, |
b855f8d1 PB |
871 | { "daemon", no_argument, NULL, 'd' }, |
872 | { "trace", required_argument, NULL, 'T' }, | |
873 | { "user", required_argument, NULL, 'u' }, | |
874 | { "group", required_argument, NULL, 'g' }, | |
fe8fc5ae | 875 | { "verbose", no_argument, NULL, 'v' }, |
b855f8d1 PB |
876 | { "quiet", no_argument, NULL, 'q' }, |
877 | { NULL, 0, NULL, 0 } | |
878 | }; | |
879 | int opt_ind = 0; | |
fe8fc5ae | 880 | int loglevel = 1; |
b855f8d1 PB |
881 | int quiet = 0; |
882 | int ch; | |
883 | Error *local_err = NULL; | |
884 | char *trace_file = NULL; | |
885 | bool daemonize = false; | |
bd6b1c83 | 886 | bool pidfile_specified = false; |
2729d79d | 887 | bool socket_path_specified = false; |
b855f8d1 PB |
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 | ||
f5852efa | 899 | error_init(argv[0]); |
b855f8d1 PB |
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 | ||
2729d79d | 905 | compute_default_paths(); |
b855f8d1 PB |
906 | |
907 | while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) { | |
908 | switch (ch) { | |
909 | case 'k': | |
2729d79d MP |
910 | g_free(socket_path); |
911 | socket_path = g_strdup(optarg); | |
912 | socket_path_specified = true; | |
b855f8d1 PB |
913 | if (socket_path[0] != '/') { |
914 | error_report("socket path must be absolute"); | |
915 | exit(EXIT_FAILURE); | |
916 | } | |
917 | break; | |
918 | case 'f': | |
f8e1a989 MP |
919 | g_free(pidfile); |
920 | pidfile = g_strdup(optarg); | |
bd6b1c83 | 921 | pidfile_specified = true; |
b855f8d1 PB |
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; | |
fe8fc5ae PB |
964 | case 'v': |
965 | ++loglevel; | |
966 | break; | |
b855f8d1 PB |
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 */ | |
fe8fc5ae PB |
986 | noisy = !quiet && (loglevel >= 3); |
987 | verbose = quiet ? 0 : MIN(loglevel, 3); | |
b855f8d1 PB |
988 | |
989 | if (!trace_init_backends()) { | |
990 | exit(EXIT_FAILURE); | |
991 | } | |
992 | trace_init_file(trace_file); | |
993 | qemu_set_log(LOG_TRACE); | |
994 | ||
fe8fc5ae PB |
995 | #ifdef CONFIG_MPATH |
996 | dm_init(); | |
997 | multipath_pr_init(); | |
998 | #endif | |
999 | ||
b855f8d1 PB |
1000 | socket_activation = check_socket_activation(); |
1001 | if (socket_activation == 0) { | |
1002 | SocketAddress saddr; | |
b855f8d1 PB |
1003 | saddr = (SocketAddress){ |
1004 | .type = SOCKET_ADDRESS_TYPE_UNIX, | |
2729d79d | 1005 | .u.q_unix.path = socket_path, |
b855f8d1 PB |
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 | } | |
b855f8d1 PB |
1013 | } else { |
1014 | /* Using socket activation - check user didn't use -p etc. */ | |
2729d79d MP |
1015 | if (socket_path_specified) { |
1016 | error_report("Unix socket can't be set when using socket activation"); | |
b855f8d1 PB |
1017 | exit(EXIT_FAILURE); |
1018 | } | |
1019 | ||
1020 | /* Can only listen on a single socket. */ | |
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 | } | |
b855f8d1 PB |
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 | ||
b855f8d1 PB |
1045 | if (daemonize) { |
1046 | if (daemon(0, 0) < 0) { | |
1047 | error_report("Failed to daemonize: %s", strerror(errno)); | |
1048 | exit(EXIT_FAILURE); | |
1049 | } | |
b855f8d1 PB |
1050 | } |
1051 | ||
9e6bdef2 MAL |
1052 | if ((daemonize || pidfile_specified) && |
1053 | !qemu_write_pidfile(pidfile, &local_err)) { | |
1054 | error_report_err(local_err); | |
1055 | exit(EXIT_FAILURE); | |
1056 | } | |
bd6b1c83 | 1057 | |
8dc0bf26 MP |
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 | ||
b855f8d1 PB |
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 | } |