Diff for /qemu/hw/virtio-console.c between versions 1.1.1.4 and 1.1.1.8

version 1.1.1.4, 2018/04/24 18:30:11 version 1.1.1.8, 2018/04/24 19:49:49
Line 11 Line 11
  */   */
   
 #include "qemu-char.h"  #include "qemu-char.h"
   #include "qemu-error.h"
   #include "trace.h"
 #include "virtio-serial.h"  #include "virtio-serial.h"
   
 typedef struct VirtConsole {  typedef struct VirtConsole {
Line 20  typedef struct VirtConsole { Line 22  typedef struct VirtConsole {
   
   
 /* Callback function that's called when the guest sends us data */  /* Callback function that's called when the guest sends us data */
 static void flush_buf(VirtIOSerialPort *port, const uint8_t *buf, size_t len)  static ssize_t flush_buf(VirtIOSerialPort *port, const uint8_t *buf, size_t len)
 {  {
     VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);      VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);
       ssize_t ret;
   
     qemu_chr_write(vcon->chr, buf, len);      if (!vcon->chr) {
           /* If there's no backend, we can just say we consumed all data. */
           return len;
       }
   
       ret = qemu_chr_fe_write(vcon->chr, buf, len);
       trace_virtio_console_flush_buf(port->id, len, ret);
   
       if (ret < 0) {
           /*
            * Ideally we'd get a better error code than just -1, but
            * that's what the chardev interface gives us right now.  If
            * we had a finer-grained message, like -EPIPE, we could close
            * this connection.  Absent such error messages, the most we
            * can do is to return 0 here.
            *
            * This will prevent stray -1 values to go to
            * virtio-serial-bus.c and cause abort()s in
            * do_flush_queued_data().
            */
           ret = 0;
       }
       return ret;
   }
   
   /* Callback function that's called when the guest opens the port */
   static void guest_open(VirtIOSerialPort *port)
   {
       VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);
   
       if (!vcon->chr) {
           return;
       }
       qemu_chr_fe_open(vcon->chr);
   }
   
   /* Callback function that's called when the guest closes the port */
   static void guest_close(VirtIOSerialPort *port)
   {
       VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);
   
       if (!vcon->chr) {
           return;
       }
       qemu_chr_fe_close(vcon->chr);
 }  }
   
 /* Readiness of the guest to accept data on a port */  /* Readiness of the guest to accept data on a port */
Line 40  static void chr_read(void *opaque, const Line 87  static void chr_read(void *opaque, const
 {  {
     VirtConsole *vcon = opaque;      VirtConsole *vcon = opaque;
   
       trace_virtio_console_chr_read(vcon->port.id, size);
     virtio_serial_write(&vcon->port, buf, size);      virtio_serial_write(&vcon->port, buf, size);
 }  }
   
Line 47  static void chr_event(void *opaque, int  Line 95  static void chr_event(void *opaque, int 
 {  {
     VirtConsole *vcon = opaque;      VirtConsole *vcon = opaque;
   
       trace_virtio_console_chr_event(vcon->port.id, event);
     switch (event) {      switch (event) {
     case CHR_EVENT_OPENED: {      case CHR_EVENT_OPENED:
         virtio_serial_open(&vcon->port);          virtio_serial_open(&vcon->port);
         break;          break;
     }  
     case CHR_EVENT_CLOSED:      case CHR_EVENT_CLOSED:
         virtio_serial_close(&vcon->port);          virtio_serial_close(&vcon->port);
         break;          break;
     }      }
 }  }
   
 /* Virtio Console Ports */  static int virtconsole_initfn(VirtIOSerialPort *port)
 static int virtconsole_initfn(VirtIOSerialDevice *dev)  
 {  {
     VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, &dev->qdev);  
     VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);      VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);
       VirtIOSerialPortClass *k = VIRTIO_SERIAL_PORT_GET_CLASS(port);
   
     port->info = dev->info;      if (port->id == 0 && !k->is_console) {
           error_report("Port number 0 on virtio-serial devices reserved for virtconsole devices for backward compatibility.");
     port->is_console = true;          return -1;
       }
   
     if (vcon->chr) {      if (vcon->chr) {
         qemu_chr_add_handlers(vcon->chr, chr_can_read, chr_read, chr_event,          qemu_chr_add_handlers(vcon->chr, chr_can_read, chr_read, chr_event,
                               vcon);                                vcon);
         port->info->have_data = flush_buf;  
     }  
     return 0;  
 }  
   
 static int virtconsole_exitfn(VirtIOSerialDevice *dev)  
 {  
     VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, &dev->qdev);  
     VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);  
   
     if (vcon->chr) {  
         port->info->have_data = NULL;  
         qemu_chr_close(vcon->chr);  
     }      }
   
     return 0;      return 0;
 }  }
   
 static VirtIOSerialPortInfo virtconsole_info = {  static Property virtconsole_properties[] = {
     .qdev.name     = "virtconsole",      DEFINE_PROP_CHR("chardev", VirtConsole, chr),
     .qdev.size     = sizeof(VirtConsole),      DEFINE_PROP_END_OF_LIST(),
     .init          = virtconsole_initfn,  
     .exit          = virtconsole_exitfn,  
     .qdev.props = (Property[]) {  
         DEFINE_PROP_UINT8("is_console", VirtConsole, port.is_console, 1),  
         DEFINE_PROP_UINT32("nr", VirtConsole, port.id, VIRTIO_CONSOLE_BAD_ID),  
         DEFINE_PROP_CHR("chardev", VirtConsole, chr),  
         DEFINE_PROP_STRING("name", VirtConsole, port.name),  
         DEFINE_PROP_END_OF_LIST(),  
     },  
 };  };
   
 static void virtconsole_register(void)  static void virtconsole_class_init(ObjectClass *klass, void *data)
 {  {
     virtio_serial_port_qdev_register(&virtconsole_info);      DeviceClass *dc = DEVICE_CLASS(klass);
 }      VirtIOSerialPortClass *k = VIRTIO_SERIAL_PORT_CLASS(klass);
 device_init(virtconsole_register)  
   
 /* Generic Virtio Serial Ports */      k->is_console = true;
 static int virtserialport_initfn(VirtIOSerialDevice *dev)      k->init = virtconsole_initfn;
 {      k->have_data = flush_buf;
     VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, &dev->qdev);      k->guest_open = guest_open;
     VirtConsole *vcon = DO_UPCAST(VirtConsole, port, port);      k->guest_close = guest_close;
       dc->props = virtconsole_properties;
   }
   
   static TypeInfo virtconsole_info = {
       .name          = "virtconsole",
       .parent        = TYPE_VIRTIO_SERIAL_PORT,
       .instance_size = sizeof(VirtConsole),
       .class_init    = virtconsole_class_init,
   };
   
     port->info = dev->info;  static Property virtserialport_properties[] = {
       DEFINE_PROP_CHR("chardev", VirtConsole, chr),
       DEFINE_PROP_END_OF_LIST(),
   };
   
     if (vcon->chr) {  static void virtserialport_class_init(ObjectClass *klass, void *data)
         qemu_chr_add_handlers(vcon->chr, chr_can_read, chr_read, chr_event,  {
                               vcon);      DeviceClass *dc = DEVICE_CLASS(klass);
         port->info->have_data = flush_buf;      VirtIOSerialPortClass *k = VIRTIO_SERIAL_PORT_CLASS(klass);
     }  
     return 0;  
 }  
   
 static VirtIOSerialPortInfo virtserialport_info = {      k->init = virtconsole_initfn;
     .qdev.name     = "virtserialport",      k->have_data = flush_buf;
     .qdev.size     = sizeof(VirtConsole),      k->guest_open = guest_open;
     .init          = virtserialport_initfn,      k->guest_close = guest_close;
     .exit          = virtconsole_exitfn,      dc->props = virtserialport_properties;
     .qdev.props = (Property[]) {  }
         DEFINE_PROP_UINT32("nr", VirtConsole, port.id, VIRTIO_CONSOLE_BAD_ID),  
         DEFINE_PROP_CHR("chardev", VirtConsole, chr),  static TypeInfo virtserialport_info = {
         DEFINE_PROP_STRING("name", VirtConsole, port.name),      .name          = "virtserialport",
         DEFINE_PROP_END_OF_LIST(),      .parent        = TYPE_VIRTIO_SERIAL_PORT,
     },      .instance_size = sizeof(VirtConsole),
       .class_init    = virtserialport_class_init,
 };  };
   
 static void virtserialport_register(void)  static void virtconsole_register_types(void)
 {  {
     virtio_serial_port_qdev_register(&virtserialport_info);      type_register_static(&virtconsole_info);
       type_register_static(&virtserialport_info);
 }  }
 device_init(virtserialport_register)  
   type_init(virtconsole_register_types)

Removed from v.1.1.1.4  
changed lines
  Added in v.1.1.1.8


unix.superglobalmegacorp.com