xref: /openbmc/qemu/hw/char/xen_console.c (revision 0a81424d)
1 /*
2  *  Copyright (C) International Business Machines  Corp., 2005
3  *  Author(s): Anthony Liguori <aliguori@us.ibm.com>
4  *
5  *  Copyright (C) Red Hat 2007
6  *
7  *  Xen Console
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; under version 2 of the License.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *  GNU General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License along
19  *  with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21 
22 #include "qemu/osdep.h"
23 #include "qemu/cutils.h"
24 #include <sys/select.h>
25 #include <termios.h>
26 
27 #include "qapi/error.h"
28 #include "sysemu/sysemu.h"
29 #include "chardev/char-fe.h"
30 #include "hw/xen/xen-backend.h"
31 #include "hw/xen/xen-bus-helper.h"
32 #include "hw/qdev-properties.h"
33 #include "hw/qdev-properties-system.h"
34 #include "hw/xen/interface/io/console.h"
35 #include "hw/xen/interface/io/xs_wire.h"
36 #include "hw/xen/interface/grant_table.h"
37 #include "hw/i386/kvm/xen_primary_console.h"
38 #include "trace.h"
39 
40 struct buffer {
41     uint8_t *data;
42     size_t consumed;
43     size_t size;
44     size_t capacity;
45     size_t max_capacity;
46 };
47 
48 struct XenConsole {
49     struct XenDevice  xendev;  /* must be first */
50     XenEventChannel   *event_channel;
51     int               dev;
52     struct buffer     buffer;
53     char              *fe_path;
54     unsigned int      ring_ref;
55     void              *sring;
56     CharBackend       chr;
57     int               backlog;
58 };
59 typedef struct XenConsole XenConsole;
60 
61 #define TYPE_XEN_CONSOLE_DEVICE "xen-console"
OBJECT_DECLARE_SIMPLE_TYPE(XenConsole,XEN_CONSOLE_DEVICE)62 OBJECT_DECLARE_SIMPLE_TYPE(XenConsole, XEN_CONSOLE_DEVICE)
63 
64 static bool buffer_append(XenConsole *con)
65 {
66     struct buffer *buffer = &con->buffer;
67     XENCONS_RING_IDX cons, prod, size;
68     struct xencons_interface *intf = con->sring;
69 
70     cons = intf->out_cons;
71     prod = intf->out_prod;
72     xen_mb();
73 
74     size = prod - cons;
75     if ((size == 0) || (size > sizeof(intf->out)))
76         return false;
77 
78     if ((buffer->capacity - buffer->size) < size) {
79         buffer->capacity += (size + 1024);
80         buffer->data = g_realloc(buffer->data, buffer->capacity);
81     }
82 
83     while (cons != prod)
84         buffer->data[buffer->size++] = intf->out[
85             MASK_XENCONS_IDX(cons++, intf->out)];
86 
87     xen_mb();
88     intf->out_cons = cons;
89     xen_device_notify_event_channel(XEN_DEVICE(con), con->event_channel, NULL);
90 
91     if (buffer->max_capacity &&
92         buffer->size > buffer->max_capacity) {
93         /* Discard the middle of the data. */
94 
95         size_t over = buffer->size - buffer->max_capacity;
96         uint8_t *maxpos = buffer->data + buffer->max_capacity;
97 
98         memmove(maxpos - over, maxpos, over);
99         buffer->data = g_realloc(buffer->data, buffer->max_capacity);
100         buffer->size = buffer->capacity = buffer->max_capacity;
101 
102         if (buffer->consumed > buffer->max_capacity - over)
103             buffer->consumed = buffer->max_capacity - over;
104     }
105     return true;
106 }
107 
buffer_advance(struct buffer * buffer,size_t len)108 static void buffer_advance(struct buffer *buffer, size_t len)
109 {
110     buffer->consumed += len;
111     if (buffer->consumed == buffer->size) {
112         buffer->consumed = 0;
113         buffer->size = 0;
114     }
115 }
116 
ring_free_bytes(XenConsole * con)117 static int ring_free_bytes(XenConsole *con)
118 {
119     struct xencons_interface *intf = con->sring;
120     XENCONS_RING_IDX cons, prod, space;
121 
122     cons = intf->in_cons;
123     prod = intf->in_prod;
124     xen_mb();
125 
126     space = prod - cons;
127     if (space > sizeof(intf->in))
128         return 0; /* ring is screwed: ignore it */
129 
130     return (sizeof(intf->in) - space);
131 }
132 
xencons_can_receive(void * opaque)133 static int xencons_can_receive(void *opaque)
134 {
135     XenConsole *con = opaque;
136     return ring_free_bytes(con);
137 }
138 
xencons_receive(void * opaque,const uint8_t * buf,int len)139 static void xencons_receive(void *opaque, const uint8_t *buf, int len)
140 {
141     XenConsole *con = opaque;
142     struct xencons_interface *intf = con->sring;
143     XENCONS_RING_IDX prod;
144     int i, max;
145 
146     max = ring_free_bytes(con);
147     /* The can_receive() func limits this, but check again anyway */
148     if (max < len)
149         len = max;
150 
151     prod = intf->in_prod;
152     for (i = 0; i < len; i++) {
153         intf->in[MASK_XENCONS_IDX(prod++, intf->in)] =
154             buf[i];
155     }
156     xen_wmb();
157     intf->in_prod = prod;
158     xen_device_notify_event_channel(XEN_DEVICE(con), con->event_channel, NULL);
159 }
160 
xencons_send(XenConsole * con)161 static bool xencons_send(XenConsole *con)
162 {
163     ssize_t len, size;
164 
165     size = con->buffer.size - con->buffer.consumed;
166     if (qemu_chr_fe_backend_connected(&con->chr)) {
167         len = qemu_chr_fe_write(&con->chr,
168                                 con->buffer.data + con->buffer.consumed,
169                                 size);
170     } else {
171         len = size;
172     }
173     if (len < 1) {
174         if (!con->backlog) {
175             con->backlog = 1;
176         }
177     } else {
178         buffer_advance(&con->buffer, len);
179         if (con->backlog && len == size) {
180             con->backlog = 0;
181         }
182     }
183     return len > 0;
184 }
185 
186 /* -------------------------------------------------------------------- */
187 
con_event(void * _xendev)188 static bool con_event(void *_xendev)
189 {
190     XenConsole *con = XEN_CONSOLE_DEVICE(_xendev);
191     bool done_something;
192 
193     if (xen_device_backend_get_state(&con->xendev) != XenbusStateConnected) {
194         return false;
195     }
196 
197     done_something = buffer_append(con);
198 
199     if (con->buffer.size - con->buffer.consumed) {
200         done_something |= xencons_send(con);
201     }
202     return done_something;
203 }
204 
205 /* -------------------------------------------------------------------- */
206 
xen_console_connect(XenDevice * xendev,Error ** errp)207 static bool xen_console_connect(XenDevice *xendev, Error **errp)
208 {
209     ERRP_GUARD();
210     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
211     unsigned int port, limit;
212 
213     if (xen_device_frontend_scanf(xendev, "ring-ref", "%u",
214                                   &con->ring_ref) != 1) {
215         error_setg(errp, "failed to read ring-ref");
216         return false;
217     }
218 
219     if (xen_device_frontend_scanf(xendev, "port", "%u", &port) != 1) {
220         error_setg(errp, "failed to read remote port");
221         return false;
222     }
223 
224     if (xen_device_frontend_scanf(xendev, "limit", "%u", &limit) == 1) {
225         con->buffer.max_capacity = limit;
226     }
227 
228     con->event_channel = xen_device_bind_event_channel(xendev, port,
229                                                        con_event,
230                                                        con,
231                                                        errp);
232     if (!con->event_channel) {
233         return false;
234     }
235 
236     switch (con->dev) {
237     case 0:
238         /*
239          * The primary console is special. For real Xen the ring-ref is
240          * actually a GFN which needs to be mapped as foreignmem.
241          */
242         if (xen_mode != XEN_EMULATE) {
243             xen_pfn_t mfn = (xen_pfn_t)con->ring_ref;
244             con->sring = qemu_xen_foreignmem_map(xendev->frontend_id, NULL,
245                                                  PROT_READ | PROT_WRITE,
246                                                  1, &mfn, NULL);
247             if (!con->sring) {
248                 error_setg(errp, "failed to map console page");
249                 return false;
250             }
251             break;
252         }
253 
254         /*
255          * For Xen emulation, we still follow the convention of ring-ref
256          * holding the GFN, but we map the fixed GNTTAB_RESERVED_CONSOLE
257          * grant ref because there is no implementation of foreignmem
258          * operations for emulated mode. The emulation code which handles
259          * the guest-side page and event channel also needs to be informed
260          * of the backend event channel port, in order to reconnect to it
261          * after a soft reset.
262          */
263         xen_primary_console_set_be_port(
264             xen_event_channel_get_local_port(con->event_channel));
265         con->ring_ref = GNTTAB_RESERVED_CONSOLE;
266         /* fallthrough */
267     default:
268         con->sring = xen_device_map_grant_refs(xendev,
269                                                &con->ring_ref, 1,
270                                                PROT_READ | PROT_WRITE,
271                                                errp);
272         if (!con->sring) {
273             error_prepend(errp, "failed to map console grant ref: ");
274             return false;
275         }
276         break;
277     }
278 
279     trace_xen_console_connect(con->dev, con->ring_ref, port,
280                               con->buffer.max_capacity);
281 
282     qemu_chr_fe_set_handlers(&con->chr, xencons_can_receive,
283                              xencons_receive, NULL, NULL, con, NULL,
284                              true);
285     return true;
286 }
287 
xen_console_disconnect(XenDevice * xendev,Error ** errp)288 static void xen_console_disconnect(XenDevice *xendev, Error **errp)
289 {
290     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
291 
292     trace_xen_console_disconnect(con->dev);
293 
294     qemu_chr_fe_set_handlers(&con->chr, NULL, NULL, NULL, NULL,
295                              con, NULL, true);
296 
297     if (con->event_channel) {
298         xen_device_unbind_event_channel(xendev, con->event_channel,
299                                         errp);
300         con->event_channel = NULL;
301 
302         if (xen_mode == XEN_EMULATE && !con->dev) {
303             xen_primary_console_set_be_port(0);
304         }
305     }
306 
307     if (con->sring) {
308         if (!con->dev && xen_mode != XEN_EMULATE) {
309             qemu_xen_foreignmem_unmap(con->sring, 1);
310         } else {
311             xen_device_unmap_grant_refs(xendev, con->sring,
312                                         &con->ring_ref, 1, errp);
313         }
314         con->sring = NULL;
315     }
316 }
317 
xen_console_frontend_changed(XenDevice * xendev,enum xenbus_state frontend_state,Error ** errp)318 static void xen_console_frontend_changed(XenDevice *xendev,
319                                          enum xenbus_state frontend_state,
320                                          Error **errp)
321 {
322     ERRP_GUARD();
323     enum xenbus_state backend_state = xen_device_backend_get_state(xendev);
324 
325     switch (frontend_state) {
326     case XenbusStateInitialised:
327     case XenbusStateConnected:
328         if (backend_state == XenbusStateConnected) {
329             break;
330         }
331 
332         xen_console_disconnect(xendev, errp);
333         if (*errp) {
334             break;
335         }
336 
337         if (!xen_console_connect(xendev, errp)) {
338             xen_device_backend_set_state(xendev, XenbusStateClosing);
339             break;
340         }
341 
342         xen_device_backend_set_state(xendev, XenbusStateConnected);
343         break;
344 
345     case XenbusStateClosing:
346         xen_device_backend_set_state(xendev, XenbusStateClosing);
347         break;
348 
349     case XenbusStateClosed:
350     case XenbusStateUnknown:
351         xen_console_disconnect(xendev, errp);
352         if (*errp) {
353             break;
354         }
355 
356         xen_device_backend_set_state(xendev, XenbusStateClosed);
357         break;
358 
359     default:
360         break;
361     }
362 }
363 
xen_console_get_name(XenDevice * xendev,Error ** errp)364 static char *xen_console_get_name(XenDevice *xendev, Error **errp)
365 {
366     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
367 
368     if (con->dev == -1) {
369         XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
370         char fe_path[XENSTORE_ABS_PATH_MAX + 1];
371         int idx = (xen_mode == XEN_EMULATE) ? 0 : 1;
372         char *value;
373 
374         /* Theoretically we could go up to INT_MAX here but that's overkill */
375         while (idx < 100) {
376             if (!idx) {
377                 snprintf(fe_path, sizeof(fe_path),
378                          "/local/domain/%u/console", xendev->frontend_id);
379             } else {
380                 snprintf(fe_path, sizeof(fe_path),
381                          "/local/domain/%u/device/console/%u",
382                          xendev->frontend_id, idx);
383             }
384             value = qemu_xen_xs_read(xenbus->xsh, XBT_NULL, fe_path, NULL);
385             if (!value) {
386                 if (errno == ENOENT) {
387                     con->dev = idx;
388                     goto found;
389                 }
390                 error_setg(errp, "cannot read %s: %s", fe_path,
391                            strerror(errno));
392                 return NULL;
393             }
394             free(value);
395             idx++;
396         }
397         error_setg(errp, "cannot find device index for console device");
398         return NULL;
399     }
400  found:
401     return g_strdup_printf("%u", con->dev);
402 }
403 
xen_console_unrealize(XenDevice * xendev)404 static void xen_console_unrealize(XenDevice *xendev)
405 {
406     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
407 
408     trace_xen_console_unrealize(con->dev);
409 
410     /* Disconnect from the frontend in case this has not already happened */
411     xen_console_disconnect(xendev, NULL);
412 
413     qemu_chr_fe_deinit(&con->chr, false);
414 }
415 
xen_console_realize(XenDevice * xendev,Error ** errp)416 static void xen_console_realize(XenDevice *xendev, Error **errp)
417 {
418     ERRP_GUARD();
419     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
420     Chardev *cs = qemu_chr_fe_get_driver(&con->chr);
421     unsigned int u;
422 
423     if (!cs) {
424         error_setg(errp, "no backing character device");
425         return;
426     }
427 
428     if (con->dev == -1) {
429         error_setg(errp, "no device index provided");
430         return;
431     }
432 
433     /*
434      * The Xen primary console is special. The ring-ref is actually a GFN to
435      * be mapped directly as foreignmem (not a grant ref), and the guest port
436      * was allocated *for* the guest by the toolstack. The guest gets these
437      * through HVMOP_get_param and can use the console long before it's got
438      * XenStore up and running. We cannot create those for a true Xen guest,
439      * but we can for Xen emulation.
440      */
441     if (!con->dev) {
442         if (xen_mode == XEN_EMULATE) {
443             xen_primary_console_create();
444         } else if (xen_device_frontend_scanf(xendev, "ring-ref", "%u", &u)
445                    != 1 ||
446                    xen_device_frontend_scanf(xendev, "port", "%u", &u) != 1) {
447             error_setg(errp, "cannot create primary Xen console");
448             return;
449         }
450     }
451 
452     trace_xen_console_realize(con->dev, object_get_typename(OBJECT(cs)));
453 
454     if (CHARDEV_IS_PTY(cs)) {
455         /* Strip the leading 'pty:' */
456         xen_device_frontend_printf(xendev, "tty", "%s", cs->filename + 4);
457     }
458 
459     /* No normal PV driver initialization for the primary console under Xen */
460     if (!con->dev && xen_mode != XEN_EMULATE) {
461         xen_console_connect(xendev, errp);
462     }
463 }
464 
console_frontend_path(struct qemu_xs_handle * xenstore,unsigned int dom_id,unsigned int dev)465 static char *console_frontend_path(struct qemu_xs_handle *xenstore,
466                                    unsigned int dom_id, unsigned int dev)
467 {
468     if (!dev) {
469         return g_strdup_printf("/local/domain/%u/console", dom_id);
470     } else {
471         return g_strdup_printf("/local/domain/%u/device/console/%u", dom_id,
472                                dev);
473     }
474 }
475 
xen_console_get_frontend_path(XenDevice * xendev,Error ** errp)476 static char *xen_console_get_frontend_path(XenDevice *xendev, Error **errp)
477 {
478     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
479     XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
480     char *ret = console_frontend_path(xenbus->xsh, xendev->frontend_id,
481                                       con->dev);
482 
483     if (!ret) {
484         error_setg(errp, "failed to create frontend path");
485     }
486     return ret;
487 }
488 
489 
490 static Property xen_console_properties[] = {
491     DEFINE_PROP_CHR("chardev", XenConsole, chr),
492     DEFINE_PROP_INT32("idx", XenConsole, dev, -1),
493     DEFINE_PROP_END_OF_LIST(),
494 };
495 
xen_console_class_init(ObjectClass * class,void * data)496 static void xen_console_class_init(ObjectClass *class, void *data)
497 {
498     DeviceClass *dev_class = DEVICE_CLASS(class);
499     XenDeviceClass *xendev_class = XEN_DEVICE_CLASS(class);
500 
501     xendev_class->backend = "console";
502     xendev_class->device = "console";
503     xendev_class->get_name = xen_console_get_name;
504     xendev_class->realize = xen_console_realize;
505     xendev_class->frontend_changed = xen_console_frontend_changed;
506     xendev_class->unrealize = xen_console_unrealize;
507     xendev_class->get_frontend_path = xen_console_get_frontend_path;
508 
509     device_class_set_props(dev_class, xen_console_properties);
510 }
511 
512 static const TypeInfo xen_console_type_info = {
513     .name = TYPE_XEN_CONSOLE_DEVICE,
514     .parent = TYPE_XEN_DEVICE,
515     .instance_size = sizeof(XenConsole),
516     .class_init = xen_console_class_init,
517 };
518 
xen_console_register_types(void)519 static void xen_console_register_types(void)
520 {
521     type_register_static(&xen_console_type_info);
522 }
523 
type_init(xen_console_register_types)524 type_init(xen_console_register_types)
525 
526 /* Called to instantiate a XenConsole when the backend is detected. */
527 static void xen_console_device_create(XenBackendInstance *backend,
528                                       QDict *opts, Error **errp)
529 {
530     ERRP_GUARD();
531     XenBus *xenbus = xen_backend_get_bus(backend);
532     const char *name = xen_backend_get_name(backend);
533     unsigned long number;
534     char *fe = NULL, *type = NULL, *output = NULL;
535     char label[32];
536     XenDevice *xendev = NULL;
537     XenConsole *con;
538     Chardev *cd = NULL;
539     struct qemu_xs_handle *xsh = xenbus->xsh;
540 
541     if (qemu_strtoul(name, NULL, 10, &number) || number > INT_MAX) {
542         error_setg(errp, "failed to parse name '%s'", name);
543         goto fail;
544     }
545 
546     trace_xen_console_device_create(number);
547 
548     fe = console_frontend_path(xsh, xen_domid, number);
549     if (fe == NULL) {
550         error_setg(errp, "failed to generate frontend path");
551         goto fail;
552     }
553 
554     if (xs_node_scanf(xsh, XBT_NULL, fe, "type", errp, "%ms", &type) != 1) {
555         error_prepend(errp, "failed to read console device type: ");
556         goto fail;
557     }
558 
559     if (strcmp(type, "ioemu")) {
560         error_setg(errp, "declining to handle console type '%s'",
561                    type);
562         goto fail;
563     }
564 
565     xendev = XEN_DEVICE(qdev_new(TYPE_XEN_CONSOLE_DEVICE));
566     con = XEN_CONSOLE_DEVICE(xendev);
567 
568     con->dev = number;
569 
570     snprintf(label, sizeof(label), "xencons%ld", number);
571 
572     if (xs_node_scanf(xsh, XBT_NULL, fe, "output", NULL, "%ms", &output) == 1) {
573         /*
574          * FIXME: sure we want to support implicit
575          * muxed monitors here?
576          */
577         cd = qemu_chr_new_mux_mon(label, output, NULL);
578         if (!cd) {
579             error_setg(errp, "console: No valid chardev found at '%s': ",
580                        output);
581             goto fail;
582         }
583     } else if (number) {
584         cd = serial_hd(number);
585         if (!cd) {
586             error_prepend(errp, "console: No serial device #%ld found: ",
587                           number);
588             goto fail;
589         }
590     } else {
591         /* No 'output' node on primary console: use null. */
592         cd = qemu_chr_new(label, "null", NULL);
593         if (!cd) {
594             error_setg(errp, "console: failed to create null device");
595             goto fail;
596         }
597     }
598 
599     if (!qemu_chr_fe_init(&con->chr, cd, errp)) {
600         error_prepend(errp, "console: failed to initialize backing chardev: ");
601         goto fail;
602     }
603 
604     if (qdev_realize_and_unref(DEVICE(xendev), BUS(xenbus), errp)) {
605         xen_backend_set_device(backend, xendev);
606         goto done;
607     }
608 
609     error_prepend(errp, "realization of console device %lu failed: ",
610                   number);
611 
612  fail:
613     if (xendev) {
614         object_unparent(OBJECT(xendev));
615     }
616  done:
617     g_free(fe);
618     free(type);
619     free(output);
620 }
621 
xen_console_device_destroy(XenBackendInstance * backend,Error ** errp)622 static void xen_console_device_destroy(XenBackendInstance *backend,
623                                        Error **errp)
624 {
625     ERRP_GUARD();
626     XenDevice *xendev = xen_backend_get_device(backend);
627     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
628 
629     trace_xen_console_device_destroy(con->dev);
630 
631     object_unparent(OBJECT(xendev));
632 }
633 
634 static const XenBackendInfo xen_console_backend_info  = {
635     .type = "console",
636     .create = xen_console_device_create,
637     .destroy = xen_console_device_destroy,
638 };
639 
xen_console_register_backend(void)640 static void xen_console_register_backend(void)
641 {
642     xen_backend_register(&xen_console_backend_info);
643 }
644 
645 xen_backend_init(xen_console_register_backend);
646