xref: /qemu/monitor/fds.c (revision 83ecdb18) 
1 /*
2  * QEMU monitor file descriptor passing
3  *
4  * Copyright (c) 2003-2004 Fabrice Bellard
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 
25 #include "qemu/osdep.h"
26 #include "monitor-internal.h"
27 #include "qapi/error.h"
28 #include "qapi/qapi-commands-misc.h"
29 #include "qapi/qmp/qerror.h"
30 #include "qemu/ctype.h"
31 #include "qemu/cutils.h"
32 #include "sysemu/runstate.h"
33 
34 /* file descriptors passed via SCM_RIGHTS */
35 typedef struct mon_fd_t mon_fd_t;
36 struct mon_fd_t {
37     char *name;
38     int fd;
39     QLIST_ENTRY(mon_fd_t) next;
40 };
41 
42 /* file descriptor associated with a file descriptor set */
43 typedef struct MonFdsetFd MonFdsetFd;
44 struct MonFdsetFd {
45     int fd;
46     bool removed;
47     char *opaque;
48     QLIST_ENTRY(MonFdsetFd) next;
49 };
50 
51 /* file descriptor set containing fds passed via SCM_RIGHTS */
52 typedef struct MonFdset MonFdset;
53 struct MonFdset {
54     int64_t id;
55     QLIST_HEAD(, MonFdsetFd) fds;
56     QLIST_HEAD(, MonFdsetFd) dup_fds;
57     QLIST_ENTRY(MonFdset) next;
58 };
59 
60 /* Protects mon_fdsets */
61 static QemuMutex mon_fdsets_lock;
62 static QLIST_HEAD(, MonFdset) mon_fdsets;
63 
64 static bool monitor_add_fd(Monitor *mon, int fd, const char *fdname, Error **errp)
65 {
66     mon_fd_t *monfd;
67 
68     if (qemu_isdigit(fdname[0])) {
69         close(fd);
70         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
71                    "a name not starting with a digit");
72         return false;
73     }
74 
75     /* See close() call below. */
76     qemu_mutex_lock(&mon->mon_lock);
77     QLIST_FOREACH(monfd, &mon->fds, next) {
78         int tmp_fd;
79 
80         if (strcmp(monfd->name, fdname) != 0) {
81             continue;
82         }
83 
84         tmp_fd = monfd->fd;
85         monfd->fd = fd;
86         qemu_mutex_unlock(&mon->mon_lock);
87         /* Make sure close() is outside critical section */
88         close(tmp_fd);
89         return true;
90     }
91 
92     monfd = g_new0(mon_fd_t, 1);
93     monfd->name = g_strdup(fdname);
94     monfd->fd = fd;
95 
96     QLIST_INSERT_HEAD(&mon->fds, monfd, next);
97     qemu_mutex_unlock(&mon->mon_lock);
98     return true;
99 }
100 
101 #ifdef CONFIG_POSIX
102 void qmp_getfd(const char *fdname, Error **errp)
103 {
104     Monitor *cur_mon = monitor_cur();
105     int fd;
106 
107     fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
108     if (fd == -1) {
109         error_setg(errp, "No file descriptor supplied via SCM_RIGHTS");
110         return;
111     }
112 
113     monitor_add_fd(cur_mon, fd, fdname, errp);
114 }
115 #endif
116 
117 void qmp_closefd(const char *fdname, Error **errp)
118 {
119     Monitor *cur_mon = monitor_cur();
120     mon_fd_t *monfd;
121     int tmp_fd;
122 
123     qemu_mutex_lock(&cur_mon->mon_lock);
124     QLIST_FOREACH(monfd, &cur_mon->fds, next) {
125         if (strcmp(monfd->name, fdname) != 0) {
126             continue;
127         }
128 
129         QLIST_REMOVE(monfd, next);
130         tmp_fd = monfd->fd;
131         g_free(monfd->name);
132         g_free(monfd);
133         qemu_mutex_unlock(&cur_mon->mon_lock);
134         /* Make sure close() is outside critical section */
135         close(tmp_fd);
136         return;
137     }
138 
139     qemu_mutex_unlock(&cur_mon->mon_lock);
140     error_setg(errp, "File descriptor named '%s' not found", fdname);
141 }
142 
143 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
144 {
145     mon_fd_t *monfd;
146 
147     QEMU_LOCK_GUARD(&mon->mon_lock);
148     QLIST_FOREACH(monfd, &mon->fds, next) {
149         int fd;
150 
151         if (strcmp(monfd->name, fdname) != 0) {
152             continue;
153         }
154 
155         fd = monfd->fd;
156         assert(fd >= 0);
157 
158         /* caller takes ownership of fd */
159         QLIST_REMOVE(monfd, next);
160         g_free(monfd->name);
161         g_free(monfd);
162 
163         return fd;
164     }
165 
166     error_setg(errp, "File descriptor named '%s' has not been found", fdname);
167     return -1;
168 }
169 
170 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
171 {
172     MonFdsetFd *mon_fdset_fd;
173     MonFdsetFd *mon_fdset_fd_next;
174 
175     QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
176         if ((mon_fdset_fd->removed ||
177                 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
178                 runstate_is_running()) {
179             close(mon_fdset_fd->fd);
180             g_free(mon_fdset_fd->opaque);
181             QLIST_REMOVE(mon_fdset_fd, next);
182             g_free(mon_fdset_fd);
183         }
184     }
185 
186     if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
187         QLIST_REMOVE(mon_fdset, next);
188         g_free(mon_fdset);
189     }
190 }
191 
192 void monitor_fdsets_cleanup(void)
193 {
194     MonFdset *mon_fdset;
195     MonFdset *mon_fdset_next;
196 
197     QEMU_LOCK_GUARD(&mon_fdsets_lock);
198     QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
199         monitor_fdset_cleanup(mon_fdset);
200     }
201 }
202 
203 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id,
204                       const char *opaque, Error **errp)
205 {
206     int fd;
207     Monitor *mon = monitor_cur();
208     AddfdInfo *fdinfo;
209 
210     fd = qemu_chr_fe_get_msgfd(&mon->chr);
211     if (fd == -1) {
212         error_setg(errp, "No file descriptor supplied via SCM_RIGHTS");
213         goto error;
214     }
215 
216     fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id, opaque, errp);
217     if (fdinfo) {
218         return fdinfo;
219     }
220 
221 error:
222     if (fd != -1) {
223         close(fd);
224     }
225     return NULL;
226 }
227 
228 #ifdef WIN32
229 void qmp_get_win32_socket(const char *infos, const char *fdname, Error **errp)
230 {
231     g_autofree WSAPROTOCOL_INFOW *info = NULL;
232     gsize len;
233     SOCKET sk;
234     int fd;
235 
236     info = (void *)g_base64_decode(infos, &len);
237     if (len != sizeof(*info)) {
238         error_setg(errp, "Invalid WSAPROTOCOL_INFOW value");
239         return;
240     }
241 
242     sk = WSASocketW(FROM_PROTOCOL_INFO,
243                     FROM_PROTOCOL_INFO,
244                     FROM_PROTOCOL_INFO,
245                     info, 0, 0);
246     if (sk == INVALID_SOCKET) {
247         error_setg_win32(errp, WSAGetLastError(), "Couldn't import socket");
248         return;
249     }
250 
251     fd = _open_osfhandle(sk, _O_BINARY);
252     if (fd < 0) {
253         error_setg_errno(errp, errno, "Failed to associate a FD with the SOCKET");
254         closesocket(sk);
255         return;
256     }
257 
258     monitor_add_fd(monitor_cur(), fd, fdname, errp);
259 }
260 #endif
261 
262 
263 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
264 {
265     MonFdset *mon_fdset;
266     MonFdsetFd *mon_fdset_fd;
267     char fd_str[60];
268 
269     QEMU_LOCK_GUARD(&mon_fdsets_lock);
270     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
271         if (mon_fdset->id != fdset_id) {
272             continue;
273         }
274         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
275             if (has_fd) {
276                 if (mon_fdset_fd->fd != fd) {
277                     continue;
278                 }
279                 mon_fdset_fd->removed = true;
280                 break;
281             } else {
282                 mon_fdset_fd->removed = true;
283             }
284         }
285         if (has_fd && !mon_fdset_fd) {
286             goto error;
287         }
288         monitor_fdset_cleanup(mon_fdset);
289         return;
290     }
291 
292 error:
293     if (has_fd) {
294         snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
295                  fdset_id, fd);
296     } else {
297         snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
298     }
299     error_setg(errp, "File descriptor named '%s' not found", fd_str);
300 }
301 
302 FdsetInfoList *qmp_query_fdsets(Error **errp)
303 {
304     MonFdset *mon_fdset;
305     MonFdsetFd *mon_fdset_fd;
306     FdsetInfoList *fdset_list = NULL;
307 
308     QEMU_LOCK_GUARD(&mon_fdsets_lock);
309     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
310         FdsetInfo *fdset_info = g_malloc0(sizeof(*fdset_info));
311 
312         fdset_info->fdset_id = mon_fdset->id;
313 
314         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
315             FdsetFdInfo *fdsetfd_info;
316 
317             fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
318             fdsetfd_info->fd = mon_fdset_fd->fd;
319             fdsetfd_info->opaque = g_strdup(mon_fdset_fd->opaque);
320 
321             QAPI_LIST_PREPEND(fdset_info->fds, fdsetfd_info);
322         }
323 
324         QAPI_LIST_PREPEND(fdset_list, fdset_info);
325     }
326 
327     return fdset_list;
328 }
329 
330 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
331                                 const char *opaque, Error **errp)
332 {
333     MonFdset *mon_fdset = NULL;
334     MonFdsetFd *mon_fdset_fd;
335     AddfdInfo *fdinfo;
336 
337     QEMU_LOCK_GUARD(&mon_fdsets_lock);
338     if (has_fdset_id) {
339         QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
340             /* Break if match found or match impossible due to ordering by ID */
341             if (fdset_id <= mon_fdset->id) {
342                 if (fdset_id < mon_fdset->id) {
343                     mon_fdset = NULL;
344                 }
345                 break;
346             }
347         }
348     }
349 
350     if (mon_fdset == NULL) {
351         int64_t fdset_id_prev = -1;
352         MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
353 
354         if (has_fdset_id) {
355             if (fdset_id < 0) {
356                 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
357                            "a non-negative value");
358                 return NULL;
359             }
360             /* Use specified fdset ID */
361             QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
362                 mon_fdset_cur = mon_fdset;
363                 if (fdset_id < mon_fdset_cur->id) {
364                     break;
365                 }
366             }
367         } else {
368             /* Use first available fdset ID */
369             QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
370                 mon_fdset_cur = mon_fdset;
371                 if (fdset_id_prev == mon_fdset_cur->id - 1) {
372                     fdset_id_prev = mon_fdset_cur->id;
373                     continue;
374                 }
375                 break;
376             }
377         }
378 
379         mon_fdset = g_malloc0(sizeof(*mon_fdset));
380         if (has_fdset_id) {
381             mon_fdset->id = fdset_id;
382         } else {
383             mon_fdset->id = fdset_id_prev + 1;
384         }
385 
386         /* The fdset list is ordered by fdset ID */
387         if (!mon_fdset_cur) {
388             QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
389         } else if (mon_fdset->id < mon_fdset_cur->id) {
390             QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
391         } else {
392             QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
393         }
394     }
395 
396     mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
397     mon_fdset_fd->fd = fd;
398     mon_fdset_fd->removed = false;
399     mon_fdset_fd->opaque = g_strdup(opaque);
400     QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
401 
402     fdinfo = g_malloc0(sizeof(*fdinfo));
403     fdinfo->fdset_id = mon_fdset->id;
404     fdinfo->fd = mon_fdset_fd->fd;
405 
406     return fdinfo;
407 }
408 
409 int monitor_fdset_dup_fd_add(int64_t fdset_id, int flags)
410 {
411 #ifdef _WIN32
412     return -ENOENT;
413 #else
414     MonFdset *mon_fdset;
415 
416     QEMU_LOCK_GUARD(&mon_fdsets_lock);
417     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
418         MonFdsetFd *mon_fdset_fd;
419         MonFdsetFd *mon_fdset_fd_dup;
420         int fd = -1;
421         int dup_fd;
422         int mon_fd_flags;
423 
424         if (mon_fdset->id != fdset_id) {
425             continue;
426         }
427 
428         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
429             mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
430             if (mon_fd_flags == -1) {
431                 return -1;
432             }
433 
434             if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
435                 fd = mon_fdset_fd->fd;
436                 break;
437             }
438         }
439 
440         if (fd == -1) {
441             errno = EACCES;
442             return -1;
443         }
444 
445         dup_fd = qemu_dup_flags(fd, flags);
446         if (dup_fd == -1) {
447             return -1;
448         }
449 
450         mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
451         mon_fdset_fd_dup->fd = dup_fd;
452         QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
453         return dup_fd;
454     }
455 
456     errno = ENOENT;
457     return -1;
458 #endif
459 }
460 
461 static int64_t monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
462 {
463     MonFdset *mon_fdset;
464     MonFdsetFd *mon_fdset_fd_dup;
465 
466     QEMU_LOCK_GUARD(&mon_fdsets_lock);
467     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
468         QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
469             if (mon_fdset_fd_dup->fd == dup_fd) {
470                 if (remove) {
471                     QLIST_REMOVE(mon_fdset_fd_dup, next);
472                     g_free(mon_fdset_fd_dup);
473                     if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
474                         monitor_fdset_cleanup(mon_fdset);
475                     }
476                     return -1;
477                 } else {
478                     return mon_fdset->id;
479                 }
480             }
481         }
482     }
483 
484     return -1;
485 }
486 
487 int64_t monitor_fdset_dup_fd_find(int dup_fd)
488 {
489     return monitor_fdset_dup_fd_find_remove(dup_fd, false);
490 }
491 
492 void monitor_fdset_dup_fd_remove(int dup_fd)
493 {
494     monitor_fdset_dup_fd_find_remove(dup_fd, true);
495 }
496 
497 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
498 {
499     int fd;
500 
501     if (!qemu_isdigit(fdname[0]) && mon) {
502         fd = monitor_get_fd(mon, fdname, errp);
503     } else {
504         fd = qemu_parse_fd(fdname);
505         if (fd < 0) {
506             error_setg(errp, "Invalid file descriptor number '%s'",
507                        fdname);
508         }
509     }
510 
511     return fd;
512 }
513 
514 static void __attribute__((__constructor__)) monitor_fds_init(void)
515 {
516     qemu_mutex_init(&mon_fdsets_lock);
517 }
518