hw/remote/remote-obj.c

   1 /*
   2  * Copyright © 2020, 2021 Oracle and/or its affiliates.
   3  *
   4  * This work is licensed under the terms of the GNU GPL-v2, version 2 or later.
   5  *
   6  * See the COPYING file in the top-level directory.
   7  *
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "qemu-common.h"
  12
  13 #include "qemu/error-report.h"
  14 #include "qemu/notify.h"
  15 #include "qom/object_interfaces.h"
  16 #include "hw/qdev-core.h"
  17 #include "io/channel.h"
  18 #include "hw/qdev-core.h"
  19 #include "hw/remote/machine.h"
  20 #include "io/channel-util.h"
  21 #include "qapi/error.h"
  22 #include "sysemu/sysemu.h"
  23 #include "hw/pci/pci.h"
  24 #include "qemu/sockets.h"
  25 #include "monitor/monitor.h"
  26
  27 #define TYPE_REMOTE_OBJECT "x-remote-object"
  28 OBJECT_DECLARE_TYPE(RemoteObject, RemoteObjectClass, REMOTE_OBJECT)
  29
  30 struct RemoteObjectClass {
  31     ObjectClass parent_class;
  32
  33     unsigned int nr_devs;
  34     unsigned int max_devs;
  35 };
  36
  37 struct RemoteObject {
  38     /* private */
  39     Object parent;
  40
  41     Notifier machine_done;
  42
  43     int32_t fd;
  44     char *devid;
  45
  46     QIOChannel *ioc;
  47
  48     DeviceState *dev;
  49     DeviceListener listener;
  50 };
  51
  52 static void remote_object_set_fd(Object *obj, const char *str, Error **errp)
  53 {
  54     RemoteObject *o = REMOTE_OBJECT(obj);
  55     int fd = -1;
  56
  57     fd = monitor_fd_param(monitor_cur(), str, errp);
  58     if (fd == -1) {
  59         error_prepend(errp, "Could not parse remote object fd %s:", str);
  60         return;
  61     }
  62
  63     if (!fd_is_socket(fd)) {
  64         error_setg(errp, "File descriptor '%s' is not a socket", str);
  65         close(fd);
  66         return;
  67     }
  68
  69     o->fd = fd;
  70 }
  71
  72 static void remote_object_set_devid(Object *obj, const char *str, Error **errp)
  73 {
  74     RemoteObject *o = REMOTE_OBJECT(obj);
  75
  76     g_free(o->devid);
  77
  78     o->devid = g_strdup(str);
  79 }
  80
  81 static void remote_object_unrealize_listener(DeviceListener *listener,
  82                                              DeviceState *dev)
  83 {
  84     RemoteObject *o = container_of(listener, RemoteObject, listener);
  85
  86     if (o->dev == dev) {
  87         object_unref(OBJECT(o));
  88     }
  89 }
  90
  91 static void remote_object_machine_done(Notifier *notifier, void *data)
  92 {
  93     RemoteObject *o = container_of(notifier, RemoteObject, machine_done);
  94     DeviceState *dev = NULL;
  95     QIOChannel *ioc = NULL;
  96     Coroutine *co = NULL;
  97     RemoteCommDev *comdev = NULL;
  98     Error *err = NULL;
  99
 100     dev = qdev_find_recursive(sysbus_get_default(), o->devid);
 101     if (!dev || !object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) {
 102         error_report("%s is not a PCI device", o->devid);
 103         return;
 104     }
 105
 106     ioc = qio_channel_new_fd(o->fd, &err);
 107     if (!ioc) {
 108         error_report_err(err);
 109         return;
 110     }
 111     qio_channel_set_blocking(ioc, false, NULL);
 112
 113     o->dev = dev;
 114
 115     o->listener.unrealize = remote_object_unrealize_listener;
 116     device_listener_register(&o->listener);
 117
 118     /* co-routine should free this. */
 119     comdev = g_new0(RemoteCommDev, 1);
 120     *comdev = (RemoteCommDev) {
 121         .ioc = ioc,
 122         .dev = PCI_DEVICE(dev),
 123     };
 124
 125     co = qemu_coroutine_create(mpqemu_remote_msg_loop_co, comdev);
 126     qemu_coroutine_enter(co);
 127 }
 128
 129 static void remote_object_init(Object *obj)
 130 {
 131     RemoteObjectClass *k = REMOTE_OBJECT_GET_CLASS(obj);
 132     RemoteObject *o = REMOTE_OBJECT(obj);
 133
 134     if (k->nr_devs >= k->max_devs) {
 135         error_report("Reached maximum number of devices: %u", k->max_devs);
 136         return;
 137     }
 138
 139     o->ioc = NULL;
 140     o->fd = -1;
 141     o->devid = NULL;
 142
 143     k->nr_devs++;
 144
 145     o->machine_done.notify = remote_object_machine_done;
 146     qemu_add_machine_init_done_notifier(&o->machine_done);
 147 }
 148
 149 static void remote_object_finalize(Object *obj)
 150 {
 151     RemoteObjectClass *k = REMOTE_OBJECT_GET_CLASS(obj);
 152     RemoteObject *o = REMOTE_OBJECT(obj);
 153
 154     device_listener_unregister(&o->listener);
 155
 156     if (o->ioc) {
 157         qio_channel_shutdown(o->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
 158         qio_channel_close(o->ioc, NULL);
 159     }
 160
 161     object_unref(OBJECT(o->ioc));
 162
 163     k->nr_devs--;
 164     g_free(o->devid);
 165 }
 166
 167 static void remote_object_class_init(ObjectClass *klass, void *data)
 168 {
 169     RemoteObjectClass *k = REMOTE_OBJECT_CLASS(klass);
 170
 171     /*
 172      * Limit number of supported devices to 1. This is done to avoid devices
 173      * from one VM accessing the RAM of another VM. This is done until we
 174      * start using separate address spaces for individual devices.
 175      */
 176     k->max_devs = 1;
 177     k->nr_devs = 0;
 178
 179     object_class_property_add_str(klass, "fd", NULL, remote_object_set_fd);
 180     object_class_property_add_str(klass, "devid", NULL,
 181                                   remote_object_set_devid);
 182 }
 183
 184 static const TypeInfo remote_object_info = {
 185     .name = TYPE_REMOTE_OBJECT,
 186     .parent = TYPE_OBJECT,
 187     .instance_size = sizeof(RemoteObject),
 188     .instance_init = remote_object_init,
 189     .instance_finalize = remote_object_finalize,
 190     .class_size = sizeof(RemoteObjectClass),
 191     .class_init = remote_object_class_init,
 192     .interfaces = (InterfaceInfo[]) {
 193         { TYPE_USER_CREATABLE },
 194         { }
 195     }
 196 };
 197
 198 static void register_types(void)
 199 {
 200     type_register_static(&remote_object_info);
 201 }
 202
 203 type_init(register_types);