chardev/char-fe.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 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 #include "qemu/osdep.h"
  25 #include "qemu/error-report.h"
  26 #include "qapi/error.h"
  27 #include "sysemu/replay.h"
  28
  29 #include "chardev/char-fe.h"
  30 #include "chardev/char-io.h"
  31 #include "chardev-internal.h"
  32
  33 int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len)
  34 {
  35     Chardev *s = be->chr;
  36
  37     if (!s) {
  38         return 0;
  39     }
  40
  41     return qemu_chr_write(s, buf, len, false);
  42 }
  43
  44 int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len)
  45 {
  46     Chardev *s = be->chr;
  47
  48     if (!s) {
  49         return 0;
  50     }
  51
  52     return qemu_chr_write(s, buf, len, true);
  53 }
  54
  55 int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len)
  56 {
  57     Chardev *s = be->chr;
  58     int offset = 0;
  59     int res;
  60
  61     if (!s || !CHARDEV_GET_CLASS(s)->chr_sync_read) {
  62         return 0;
  63     }
  64
  65     if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
  66         return replay_char_read_all_load(buf);
  67     }
  68
  69     while (offset < len) {
  70     retry:
  71         res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset,
  72                                                   len - offset);
  73         if (res == -1 && errno == EAGAIN) {
  74             g_usleep(100);
  75             goto retry;
  76         }
  77
  78         if (res == 0) {
  79             break;
  80         }
  81
  82         if (res < 0) {
  83             if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
  84                 replay_char_read_all_save_error(res);
  85             }
  86             return res;
  87         }
  88
  89         offset += res;
  90     }
  91
  92     if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
  93         replay_char_read_all_save_buf(buf, offset);
  94     }
  95     return offset;
  96 }
  97
  98 int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg)
  99 {
 100     Chardev *s = be->chr;
 101     int res;
 102
 103     if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) {
 104         res = -ENOTSUP;
 105     } else {
 106         res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg);
 107     }
 108
 109     return res;
 110 }
 111
 112 int qemu_chr_fe_get_msgfd(CharBackend *be)
 113 {
 114     Chardev *s = be->chr;
 115     int fd;
 116     int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1;
 117     if (s && qemu_chr_replay(s)) {
 118         error_report("Replay: get msgfd is not supported "
 119                      "for serial devices yet");
 120         exit(1);
 121     }
 122     return res;
 123 }
 124
 125 int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len)
 126 {
 127     Chardev *s = be->chr;
 128
 129     if (!s) {
 130         return -1;
 131     }
 132
 133     return CHARDEV_GET_CLASS(s)->get_msgfds ?
 134         CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1;
 135 }
 136
 137 int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num)
 138 {
 139     Chardev *s = be->chr;
 140
 141     if (!s) {
 142         return -1;
 143     }
 144
 145     return CHARDEV_GET_CLASS(s)->set_msgfds ?
 146         CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1;
 147 }
 148
 149 void qemu_chr_fe_accept_input(CharBackend *be)
 150 {
 151     Chardev *s = be->chr;
 152
 153     if (!s) {
 154         return;
 155     }
 156
 157     if (CHARDEV_GET_CLASS(s)->chr_accept_input) {
 158         CHARDEV_GET_CLASS(s)->chr_accept_input(s);
 159     }
 160     qemu_notify_event();
 161 }
 162
 163 void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...)
 164 {
 165     char buf[CHR_READ_BUF_LEN];
 166     va_list ap;
 167     va_start(ap, fmt);
 168     vsnprintf(buf, sizeof(buf), fmt, ap);
 169     /* XXX this blocks entire thread. Rewrite to use
 170      * qemu_chr_fe_write and background I/O callbacks */
 171     qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf));
 172     va_end(ap);
 173 }
 174
 175 Chardev *qemu_chr_fe_get_driver(CharBackend *be)
 176 {
 177     /* this is unsafe for the users that support chardev hotswap */
 178     assert(be->chr_be_change == NULL);
 179     return be->chr;
 180 }
 181
 182 bool qemu_chr_fe_backend_connected(CharBackend *be)
 183 {
 184     return !!be->chr;
 185 }
 186
 187 bool qemu_chr_fe_backend_open(CharBackend *be)
 188 {
 189     return be->chr && be->chr->be_open;
 190 }
 191
 192 bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp)
 193 {
 194     int tag = 0;
 195
 196     if (s) {
 197         if (CHARDEV_IS_MUX(s)) {
 198             MuxChardev *d = MUX_CHARDEV(s);
 199
 200             if (d->mux_cnt >= MAX_MUX) {
 201                 error_setg(errp,
 202                            "too many uses of multiplexed chardev '%s'"
 203                            " (maximum is " stringify(MAX_MUX) ")",
 204                            s->label);
 205                 return false;
 206             }
 207
 208             d->backends[d->mux_cnt] = b;
 209             tag = d->mux_cnt++;
 210         } else if (s->be) {
 211             error_setg(errp, "chardev '%s' is already in use", s->label);
 212             return false;
 213         } else {
 214             s->be = b;
 215         }
 216     }
 217
 218     b->fe_is_open = false;
 219     b->tag = tag;
 220     b->chr = s;
 221     return true;
 222 }
 223
 224 void qemu_chr_fe_deinit(CharBackend *b, bool del)
 225 {
 226     assert(b);
 227
 228     if (b->chr) {
 229         qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, NULL, true);
 230         if (b->chr->be == b) {
 231             b->chr->be = NULL;
 232         }
 233         if (CHARDEV_IS_MUX(b->chr)) {
 234             MuxChardev *d = MUX_CHARDEV(b->chr);
 235             d->backends[b->tag] = NULL;
 236         }
 237         if (del) {
 238             Object *obj = OBJECT(b->chr);
 239             if (obj->parent) {
 240                 object_unparent(obj);
 241             } else {
 242                 object_unref(obj);
 243             }
 244         }
 245         b->chr = NULL;
 246     }
 247 }
 248
 249 void qemu_chr_fe_set_handlers_full(CharBackend *b,
 250                                    IOCanReadHandler *fd_can_read,
 251                                    IOReadHandler *fd_read,
 252                                    IOEventHandler *fd_event,
 253                                    BackendChangeHandler *be_change,
 254                                    void *opaque,
 255                                    GMainContext *context,
 256                                    bool set_open,
 257                                    bool sync_state)
 258 {
 259     Chardev *s;
 260     bool fe_open;
 261
 262     s = b->chr;
 263     if (!s) {
 264         return;
 265     }
 266
 267     if (!opaque && !fd_can_read && !fd_read && !fd_event) {
 268         fe_open = false;
 269         remove_fd_in_watch(s);
 270     } else {
 271         fe_open = true;
 272     }
 273     b->chr_can_read = fd_can_read;
 274     b->chr_read = fd_read;
 275     b->chr_event = fd_event;
 276     b->chr_be_change = be_change;
 277     b->opaque = opaque;
 278
 279     qemu_chr_be_update_read_handlers(s, context);
 280
 281     if (set_open) {
 282         qemu_chr_fe_set_open(b, fe_open);
 283     }
 284
 285     if (fe_open) {
 286         qemu_chr_fe_take_focus(b);
 287         /* We're connecting to an already opened device, so let's make sure we
 288            also get the open event */
 289         if (sync_state && s->be_open) {
 290             qemu_chr_be_event(s, CHR_EVENT_OPENED);
 291         }
 292     }
 293 }
 294
 295 void qemu_chr_fe_set_handlers(CharBackend *b,
 296                               IOCanReadHandler *fd_can_read,
 297                               IOReadHandler *fd_read,
 298                               IOEventHandler *fd_event,
 299                               BackendChangeHandler *be_change,
 300                               void *opaque,
 301                               GMainContext *context,
 302                               bool set_open)
 303 {
 304     qemu_chr_fe_set_handlers_full(b, fd_can_read, fd_read, fd_event, be_change,
 305                                   opaque, context, set_open,
 306                                   true);
 307 }
 308
 309 void qemu_chr_fe_take_focus(CharBackend *b)
 310 {
 311     if (!b->chr) {
 312         return;
 313     }
 314
 315     if (CHARDEV_IS_MUX(b->chr)) {
 316         mux_set_focus(b->chr, b->tag);
 317     }
 318 }
 319
 320 int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp)
 321 {
 322     if (!be->chr) {
 323         error_setg(errp, "missing associated backend");
 324         return -1;
 325     }
 326
 327     return qemu_chr_wait_connected(be->chr, errp);
 328 }
 329
 330 void qemu_chr_fe_set_echo(CharBackend *be, bool echo)
 331 {
 332     Chardev *chr = be->chr;
 333
 334     if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) {
 335         CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo);
 336     }
 337 }
 338
 339 void qemu_chr_fe_set_open(CharBackend *be, bool is_open)
 340 {
 341     Chardev *chr = be->chr;
 342
 343     if (!chr) {
 344         return;
 345     }
 346
 347     if (be->fe_is_open == is_open) {
 348         return;
 349     }
 350     be->fe_is_open = is_open;
 351     if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) {
 352         CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, is_open);
 353     }
 354 }
 355
 356 guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
 357                             FEWatchFunc func, void *user_data)
 358 {
 359     Chardev *s = be->chr;
 360     GSource *src;
 361     guint tag;
 362
 363     if (!s || CHARDEV_GET_CLASS(s)->chr_add_watch == NULL) {
 364         return 0;
 365     }
 366
 367     src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond);
 368     if (!src) {
 369         return 0;
 370     }
 371
 372     g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
 373     tag = g_source_attach(src, s->gcontext);
 374     g_source_unref(src);
 375
 376     return tag;
 377 }
 378
 379 void qemu_chr_fe_disconnect(CharBackend *be)
 380 {
 381     Chardev *chr = be->chr;
 382
 383     if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) {
 384         CHARDEV_GET_CLASS(chr)->chr_disconnect(chr);
 385     }
 386 }