PATCH: 0/10: Merge xenfb & xenconsoled into qemu-dm

286 lines not on this page · raw message

288 lines not on this page · raw message

diff -r 7953164cebb6 tools/ioemu/vl.h
@@ -1118,6 +1118,9 @@ extern void pci_piix4_acpi_init(PCIBus *
 /* pc.c */
 extern QEMUMachine pc_machine;
 extern QEMUMachine isapc_machine;
+#ifdef CONFIG_DM
+extern QEMUMachine xenfv_machine;
+#endif
 extern int fd_bootchk;
 
 void ioport_set_a20(int enable);

231 lines not on this page · raw message

diff -r 327024163186 tools/ioemu/target-i386-dm/helper2.c
@@ -616,7 +616,7 @@ int main_loop(void)
     extern int shutdown_requested;
     extern int suspend_requested;
     CPUState *env = cpu_single_env;
-    int evtchn_fd = xc_evtchn_fd(xce_handle);
+    int evtchn_fd = xce_handle == -1 ? -1 : xc_evtchn_fd(xce_handle);
     char qemu_file[PATH_MAX];
     fd_set fds;
 

@@ -624,7 +624,8 @@ int main_loop(void)
 				       cpu_single_env);
     qemu_mod_timer(buffered_io_timer, qemu_get_clock(rt_clock));
 
-    qemu_set_fd_handler(evtchn_fd, cpu_handle_ioreq, NULL, env);
+    if (evtchn_fd != -1)
+        qemu_set_fd_handler(evtchn_fd, cpu_handle_ioreq, NULL, env);
 
     xenstore_record_dm_state("running");
     while (1) {

diff -r 327024163186 tools/ioemu/vl.c
@@ -182,7 +182,7 @@ extern int vcpus;
 
 int xc_handle;
 
-char domain_name[64] = "Xen-HVM-no-name";
+char domain_name[64] = "Xen-no-name";
 extern int domid;
 
 char vncpasswd[64];

@@ -6651,6 +6651,7 @@ void register_machines(void)
     qemu_register_machine(&isapc_machine);
 #else
     qemu_register_machine(&xenfv_machine);
+    qemu_register_machine(&xenpv_machine);
 #endif
 #elif defined(TARGET_PPC)
     qemu_register_machine(&heathrow_machine);

@@ -7370,7 +7371,7 @@ int main(int argc, char **argv)
                 break;
             case QEMU_OPTION_domainname:
                 snprintf(domain_name, sizeof(domain_name),
-                         "Xen-HVM-%s", optarg);
+                         "Xen-%s", optarg);
                 break;
             case QEMU_OPTION_d:
                 domid = atoi(optarg);

diff -r 327024163186 tools/ioemu/vl.h
@@ -1120,6 +1120,7 @@ extern QEMUMachine isapc_machine;
 extern QEMUMachine isapc_machine;
 #ifdef CONFIG_DM
 extern QEMUMachine xenfv_machine;
+extern QEMUMachine xenpv_machine;
 #endif
 extern int fd_bootchk;
 

106 lines not on this page · raw message

diff -r 327024163186 tools/xenfb/xenfb.h
@@ -25,8 +25,12 @@ void xenfb_teardown(struct xenfb *xenfb)
 
 int xenfb_attach_dom(struct xenfb *xenfb, int domid);
 
+int xenfb_dispatch_store(struct xenfb *xenfb_pub);
+int xenfb_dispatch_channel(struct xenfb *xenfb_pub);
 int xenfb_select_fds(struct xenfb *xenfb, fd_set *readfds);
 int xenfb_poll(struct xenfb *xenfb, fd_set *readfds);
+int xenfb_get_store_fd(struct xenfb *xenfb_pub);
+int xenfb_get_channel_fd(struct xenfb *xenfb_pub);
 
 int xenfb_send_key(struct xenfb *xenfb, bool down, int keycode);
 int xenfb_send_motion(struct xenfb *xenfb, int rel_x, int rel_y);

diff -r 450e0143acaf tools/ioemu/hw/xen_machine_pv.c
@@ -23,7 +23,7 @@
  */
 
 #include "vl.h"
-#include "../../xenfb/xenfb.h"
+#include "xenfb.h"
 #include <linux/input.h>
 
 /* A convenient function for munging pixels between different depths */

825 lines not on this page · raw message

diff -r 450e0143acaf tools/ioemu/hw/xenfb.h
@@ -0,0 +1,39 @@
+#ifndef _XENFB_H_
+#define _XENFB_H_
+
+#include <stdbool.h>
+#include <sys/types.h>
+
+struct xenfb
+{
+	void *pixels;
+
+	int row_stride;
+	int depth;
+	int width;
+	int height;
+	int abs_pointer_wanted;
+
+	void *user_data;
+
+	void (*update)(struct xenfb *xenfb, int x, int y, int width, int height);
+};
+
+struct xenfb *xenfb_new(void);
+void xenfb_delete(struct xenfb *xenfb);
+void xenfb_teardown(struct xenfb *xenfb);
+
+int xenfb_attach_dom(struct xenfb *xenfb, int domid);
+
+int xenfb_dispatch_store(struct xenfb *xenfb_pub);
+int xenfb_dispatch_channel(struct xenfb *xenfb_pub);
+int xenfb_select_fds(struct xenfb *xenfb, fd_set *readfds);
+int xenfb_poll(struct xenfb *xenfb, fd_set *readfds);
+int xenfb_get_store_fd(struct xenfb *xenfb_pub);
+int xenfb_get_channel_fd(struct xenfb *xenfb_pub);
+
+int xenfb_send_key(struct xenfb *xenfb, bool down, int keycode);
+int xenfb_send_motion(struct xenfb *xenfb, int rel_x, int rel_y);
+int xenfb_send_position(struct xenfb *xenfb, int abs_x, int abs_y);
+
+#endif

342 lines not on this page · raw message

522 lines not on this page · raw message

825 lines not on this page · raw message

diff -r 450e0143acaf tools/xenfb/xenfb.h
@@ -1,39 +0,0 @@
-#ifndef _XENFB_H_
-#define _XENFB_H_
-
-#include <stdbool.h>
-#include <sys/types.h>
-
-struct xenfb
-{
-	void *pixels;
-
-	int row_stride;
-	int depth;
-	int width;
-	int height;
-	int abs_pointer_wanted;
-
-	void *user_data;
-
-	void (*update)(struct xenfb *xenfb, int x, int y, int width, int height);
-};
-
-struct xenfb *xenfb_new(void);
-void xenfb_delete(struct xenfb *xenfb);
-void xenfb_teardown(struct xenfb *xenfb);
-
-int xenfb_attach_dom(struct xenfb *xenfb, int domid);
-
-int xenfb_dispatch_store(struct xenfb *xenfb_pub);
-int xenfb_dispatch_channel(struct xenfb *xenfb_pub);
-int xenfb_select_fds(struct xenfb *xenfb, fd_set *readfds);
-int xenfb_poll(struct xenfb *xenfb, fd_set *readfds);
-int xenfb_get_store_fd(struct xenfb *xenfb_pub);
-int xenfb_get_channel_fd(struct xenfb *xenfb_pub);
-
-int xenfb_send_key(struct xenfb *xenfb, bool down, int keycode);
-int xenfb_send_motion(struct xenfb *xenfb, int rel_x, int rel_y);
-int xenfb_send_position(struct xenfb *xenfb, int abs_x, int abs_y);
-
-#endif

diff -r bd1bddd42929 tools/ioemu/hw/xen_machine_pv.c
@@ -136,21 +136,6 @@ void xen_pvfb_invalidate(void *opaque)
 /* Screen dump is not used in Xen, so no need to impl this ? */
 void xen_pvfb_screen_dump(void *opaque, const char *name) { }
 
-void xen_pvfb_dispatch_store(void *opaque) {
-    int ret;
-    if ((ret = xenfb_dispatch_store((struct xenfb *)opaque)) < 0) {
-        fprintf(stderr, "Failure while dispatching store: %d\n", ret);
-        exit(1);
-    }
-}
-
-void xen_pvfb_dispatch_channel(void *opaque) {
-    int ret;
-    if ((ret = xenfb_dispatch_channel((struct xenfb *)opaque)) < 0) {
-        fprintf(stderr, "Failure while dispatching store: %d\n", ret);
-        exit(1);
-    }
-}
 
 /* The Xen PV machine currently provides
  *   - a virtual framebuffer

@@ -165,7 +150,6 @@ static void xen_init_pv(uint64_t ram_siz
 {
     struct xenfb *xenfb;
     extern int domid;
-    int fd;
 
     /* Prepare PVFB state */
     xenfb = xenfb_new();

@@ -197,19 +181,6 @@ static void xen_init_pv(uint64_t ram_siz
                                  xenfb->abs_pointer_wanted,
                                  "Xen PVFB Mouse");
 
-    /* Listen for events from xenstore */
-    fd = xenfb_get_store_fd(xenfb);
-    if (qemu_set_fd_handler2(fd, NULL, xen_pvfb_dispatch_store, NULL, xenfb) < 0) {
-        fprintf(stderr, "Could not register event handler (%s)\n",
-                strerror(errno));
-    }
-
-    /* Listen for events from the event channel */
-    fd = xenfb_get_channel_fd(xenfb);
-    if (qemu_set_fd_handler2(fd, NULL, xen_pvfb_dispatch_channel, NULL, xenfb) < 0) {
-        fprintf(stderr, "Could not register event handler (%s)\n",
-                strerror(errno));
-    }
 
     /* Setup QEMU display */
     dpy_resize(ds, xenfb->width, xenfb->height);

292 lines not on this page · raw message

diff -r bd1bddd42929 tools/ioemu/hw/xenfb.h
@@ -25,13 +25,6 @@ void xenfb_teardown(struct xenfb *xenfb)
 
 int xenfb_attach_dom(struct xenfb *xenfb, int domid);
 
-int xenfb_dispatch_store(struct xenfb *xenfb_pub);
-int xenfb_dispatch_channel(struct xenfb *xenfb_pub);
-int xenfb_select_fds(struct xenfb *xenfb, fd_set *readfds);
-int xenfb_poll(struct xenfb *xenfb, fd_set *readfds);
-int xenfb_get_store_fd(struct xenfb *xenfb_pub);
-int xenfb_get_channel_fd(struct xenfb *xenfb_pub);
-
 int xenfb_send_key(struct xenfb *xenfb, bool down, int keycode);
 int xenfb_send_motion(struct xenfb *xenfb, int rel_x, int rel_y);
 int xenfb_send_position(struct xenfb *xenfb, int abs_x, int abs_y);

diff -r ff7bf037fe82 tools/ioemu/hw/xen_machine_pv.c
@@ -24,117 +24,6 @@
 
 #include "vl.h"
 #include "xenfb.h"
-#include <linux/input.h>
-
-/* A convenient function for munging pixels between different depths */
-#define BLT(SRC_T,DST_T,RLS,GLS,BLS,RRS,GRS,BRS,RM,GM,BM)               \
-    for (line = y ; line < h ; line++) {                                \
-        SRC_T *src = (SRC_T *)(xenfb->pixels + (line*xenfb->row_stride) + (x*xenfb->depth/8)); \
-        DST_T *dst = (DST_T *)(ds->data + (line*ds->linesize) + (x*ds->depth/8)); \
-        int col;                                                        \
-        for (col = x ; col < w ; col++) {                               \
-            *dst = (((*src >> RRS)&RM) << RLS) |                        \
-                (((*src >> GRS)&GM) << GLS) |                           \
-                (((*src >> GRS)&BM) << BLS);                            \
-            src++;                                                      \
-            dst++;                                                      \
-        }                                                               \
-    }
-
-
-/* This copies data from the guest framebuffer region, into QEMU's copy
- * NB. QEMU's copy is stored in the pixel format of a) the local X server (SDL case)
- * or b) the current VNC client pixel format.
- */
-static void xen_pvfb_guest_copy(struct xenfb *xenfb, int x, int y, int w, int h)
-{
-    DisplayState *ds = (DisplayState *)xenfb->user_data;
-    int line;
-
-    if (xenfb->depth == ds->depth) { /* Perfect match can use fast path */
-        for (line = y ; line < (y+h) ; line++) {
-            memcpy(ds->data + (line * ds->linesize) + (x*ds->depth/8),
-                   xenfb->pixels + (line*xenfb->row_stride) + (x*xenfb->depth/8),
-                   w * xenfb->depth/8);
-        }
-    } else { /* Mismatch requires slow pixel munging */
-        if (xenfb->depth == 8) {
-            /* 8 bit source == r:3 g:3 b:2 */
-            if (ds->depth == 16) {
-                BLT(uint8_t, uint16_t,   5, 2, 0,   11, 5, 0,   7, 7, 3);
-            } else if (ds->depth == 32) {
-                BLT(uint8_t, uint32_t,   5, 2, 0,   16, 8, 0,   7, 7, 3);
-            }
-        } else if (xenfb->depth == 16) {
-            /* 16 bit source == r:5 g:6 b:5 */
-            if (ds->depth == 8) {
-                BLT(uint16_t, uint8_t,    11, 5, 0,   5, 2, 0,    31, 63, 31);
-            } else if (ds->depth == 32) {
-                BLT(uint16_t, uint32_t,   11, 5, 0,   16, 8, 0,   31, 63, 31);
-            }
-        } else if (xenfb->depth == 32) {
-            /* 32 bit source == r:8 g:8 b:8 (padding:8) */
-            if (ds->depth == 8) {
-                BLT(uint32_t, uint8_t,    16, 8, 0,   5, 2, 0,    255, 255, 255);
-            } else if (ds->depth == 16) {
-                BLT(uint32_t, uint16_t,   16, 8, 0,   11, 5, 0,   255, 255, 255);
-            }
-        }
-    }
-    dpy_update(ds, x, y, w, h);
-}
-
-
-/* Send a keypress from the client to the guest OS */
-static void xen_pvfb_put_keycode(void *opaque, int keycode)
-{
-    struct xenfb *xenfb = (struct xenfb*)opaque;
-    xenfb_send_key(xenfb, keycode & 0x80 ? 0 : 1, keycode & 0x7f);
-}
-
-/* Send a mouse event from the client to the guest OS */
-static void xen_pvfb_mouse_event(void *opaque,
-                                 int dx, int dy, int dz, int button_state)
-{
-    static int old_state = 0;
-    int i;
-    struct xenfb *xenfb = (struct xenfb*)opaque;
-    DisplayState *ds = (DisplayState *)xenfb->user_data;
-    if (xenfb->abs_pointer_wanted)
-        xenfb_send_position(xenfb,
-                            dx*ds->width/0x7fff,
-                            dy*ds->height/0x7fff);
-    else
-        xenfb_send_motion(xenfb, dx, dy);
-
-	for (i = 0 ; i < 8 ; i++) {
-		int lastDown = old_state & (1 << i);
-		int down = button_state & (1 << i);
-		if (down == lastDown)
-			continue;
-
-		if (xenfb_send_key(xenfb, down, BTN_LEFT+i) < 0)
-			return;
-	}
-    old_state = button_state;
-}
-
-/* QEMU display state changed, so refresh the framebuffer copy */
-void xen_pvfb_update(void *opaque)
-{
-    struct xenfb *xenfb = (struct xenfb *)opaque;
-    xen_pvfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height);
-}
-
-/* QEMU display state changed, so refresh the framebuffer copy */
-void xen_pvfb_invalidate(void *opaque)
-{
-    struct xenfb *xenfb = (struct xenfb *)opaque;
-    xen_pvfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height);
-}
-
-/* Screen dump is not used in Xen, so no need to impl this ? */
-void xen_pvfb_screen_dump(void *opaque, const char *name) { }
 
 
 /* The Xen PV machine currently provides

@@ -160,30 +49,11 @@ static void xen_init_pv(uint64_t ram_siz
     }
 
     /* Talk to the guest */
-    if (xenfb_attach_dom(xenfb, domid) < 0) {
+    if (xenfb_attach_dom(xenfb, domid, ds) < 0) {
         fprintf(stderr, "Could not connect to domain (%s)\n",
                 strerror(errno));
         exit(1);
     }
-    xenfb->update = xen_pvfb_guest_copy;
-    xenfb->user_data = ds;
-
-    /* Tell QEMU to allocate a graphical console */
-    graphic_console_init(ds,
-                         xen_pvfb_update,
-                         xen_pvfb_invalidate,
-                         xen_pvfb_screen_dump,
-                         xenfb);
-
-    /* Register our keyboard & mouse handlers */
-    qemu_add_kbd_event_handler(xen_pvfb_put_keycode, xenfb);
-    qemu_add_mouse_event_handler(xen_pvfb_mouse_event, xenfb,
-                                 xenfb->abs_pointer_wanted,
-                                 "Xen PVFB Mouse");
-
-
-    /* Setup QEMU display */
-    dpy_resize(ds, xenfb->width, xenfb->height);
 }
 
 QEMUMachine xenpv_machine = {

284 lines not on this page · raw message

diff -r ff7bf037fe82 tools/ioemu/hw/xenfb.h
@@ -1,6 +1,7 @@
 #ifndef _XENFB_H_
 #define _XENFB_H_
 
+#include "vl.h"
 #include <stdbool.h>
 #include <sys/types.h>
 

@@ -13,6 +14,7 @@ struct xenfb
 	int width;
 	int height;
 	int abs_pointer_wanted;
+	int button_state;
 
 	void *user_data;
 

@@ -23,10 +25,6 @@ void xenfb_delete(struct xenfb *xenfb);
 void xenfb_delete(struct xenfb *xenfb);
 void xenfb_teardown(struct xenfb *xenfb);
 
-int xenfb_attach_dom(struct xenfb *xenfb, int domid);
-
-int xenfb_send_key(struct xenfb *xenfb, bool down, int keycode);
-int xenfb_send_motion(struct xenfb *xenfb, int rel_x, int rel_y);
-int xenfb_send_position(struct xenfb *xenfb, int abs_x, int abs_y);
+int xenfb_attach_dom(struct xenfb *xenfb, int domid, DisplayState *ds);
 
 #endif

diff -r 82c317f263c2 tools/ioemu/hw/xenfb.c
@@ -22,6 +22,8 @@
 
 // FIXME defend against malicious frontend?
 
+struct xenfb;
+
 struct xenfb_device {
 	const char *devicetype;
 	char nodename[64];	/* backend xenstore dir */

@@ -30,20 +32,33 @@ struct xenfb_device {
 	enum xenbus_state state; /* backend state */
 	void *page;		/* shared page */
 	evtchn_port_t port;
-	struct xenfb_private *xenfb;
+	struct xenfb *xenfb;
 };
 
-struct xenfb_private {
-	struct xenfb pub;
+struct xenfb_data
+{
+	void *pixels;
+	size_t len;
+
+	int row_stride;
+	int depth;
+	int width;
+	int height;
+	int abs_pointer_wanted;
+};
+
+struct xenfb {
+	DisplayState *ds;
 	int evt_xch;		/* event channel driver handle */
 	int xc;			/* hypervisor interface handle */
 	struct xs_handle *xsh;	/* xs daemon handle */
 	struct xenfb_device fb, kbd;
-	size_t fb_len;		/* size of framebuffer */
+	struct xenfb_data data;
 	char protocol[64];	/* frontend protocol */
+	int button_state;
 };
 
-static void xenfb_detach_dom(struct xenfb_private *);
+static void xenfb_detach_dom(struct xenfb *);
 
 static char *xenfb_path_in_dom(struct xs_handle *xsh,
 			       char *buf, size_t size,

@@ -124,7 +139,7 @@ static int xenfb_xs_printf(struct xs_han
 
 static void xenfb_device_init(struct xenfb_device *dev,
 			      const char *type,
-			      struct xenfb_private *xenfb)
+			      struct xenfb *xenfb)
 {
 	dev->devicetype = type;
 	dev->otherend_id = -1;

@@ -132,19 +147,17 @@ static void xenfb_device_init(struct xen
 	dev->xenfb = xenfb;
 }
 
-int xenfb_device_set_domain(struct xenfb_device *dev, int domid)
-{
-	struct xenfb_private *xenfb = dev->xenfb;
-
+static int xenfb_device_set_domain(struct xenfb_device *dev, int domid)
+{
 	dev->otherend_id = domid;
 
-	if (!xenfb_path_in_dom(xenfb->xsh,
+	if (!xenfb_path_in_dom(dev->xenfb->xsh,
 			       dev->otherend, sizeof(dev->otherend),
 			       domid, "device/%s/0", dev->devicetype)) {
 		errno = ENOENT;
 		return -1;
 	}
-	if (!xenfb_path_in_dom(xenfb->xsh,
+	if (!xenfb_path_in_dom(dev->xenfb->xsh,
 			       dev->nodename, sizeof(dev->nodename),
 			       0, "backend/%s/%d/0", dev->devicetype, domid)) {
 		errno = ENOENT;

@@ -156,8 +169,8 @@ int xenfb_device_set_domain(struct xenfb
 
 struct xenfb *xenfb_new(void)
 {
-	struct xenfb_private *xenfb = malloc(sizeof(*xenfb));
 	int serrno;
+	struct xenfb *xenfb = qemu_malloc(sizeof(struct xenfb));
 
 	if (xenfb == NULL)
 		return NULL;

@@ -179,30 +192,26 @@ struct xenfb *xenfb_new(void)
 	if (!xenfb->xsh)
 		goto fail;
 
-	return &xenfb->pub;
+	return xenfb;
 
  fail:
 	serrno = errno;
-	xenfb_delete(&xenfb->pub);
+	xenfb_delete(xenfb);
 	errno = serrno;
 	return NULL;
 }
 
 /* Remove the backend area in xenbus since the framebuffer really is
    going away. */
-void xenfb_teardown(struct xenfb *xenfb_pub)
-{
-       struct xenfb_private *xenfb = (struct xenfb_private *)xenfb_pub;
-
+void xenfb_teardown(struct xenfb *xenfb)
+{
        xs_rm(xenfb->xsh, XBT_NULL, xenfb->fb.nodename);
        xs_rm(xenfb->xsh, XBT_NULL, xenfb->kbd.nodename);
 }
 
 
-void xenfb_delete(struct xenfb *xenfb_pub)
-{
-	struct xenfb_private *xenfb = (struct xenfb_private *)xenfb_pub;
-
+void xenfb_delete(struct xenfb *xenfb)
+{
 	xenfb_detach_dom(xenfb);
 	if (xenfb->xc >= 0)
 		xc_interface_close(xenfb->xc);

@@ -334,7 +343,7 @@ static void xenfb_copy_mfns(int mode, in
 		dst[i] = (mode == 32) ? src32[i] : src64[i];
 }
 
-static int xenfb_map_fb(struct xenfb_private *xenfb, int domid)
+static int xenfb_map_fb(struct xenfb *xenfb, int domid)
 {
 	struct xenfb_page *page = xenfb->fb.page;
 	int n_fbmfns;

@@ -389,7 +398,7 @@ static int xenfb_map_fb(struct xenfb_pri
 #endif
 	}
 
-	n_fbmfns = (xenfb->fb_len + (XC_PAGE_SIZE - 1)) / XC_PAGE_SIZE;
+	n_fbmfns = (xenfb->data.len + (XC_PAGE_SIZE - 1)) / XC_PAGE_SIZE;
 	n_fbdirs = n_fbmfns * mode / 8;
 	n_fbdirs = (n_fbdirs + (XC_PAGE_SIZE - 1)) / XC_PAGE_SIZE;
 

@@ -412,9 +421,9 @@ static int xenfb_map_fb(struct xenfb_pri
 	xenfb_copy_mfns(mode, n_fbmfns, fbmfns, map);
 	munmap(map, n_fbdirs * XC_PAGE_SIZE);
 
-	xenfb->pub.pixels = xc_map_foreign_batch(xenfb->xc, domid,
+	xenfb->data.pixels = xc_map_foreign_batch(xenfb->xc, domid,
 				PROT_READ | PROT_WRITE, fbmfns, n_fbmfns);
-	if (xenfb->pub.pixels == NULL)
+	if (xenfb->data.pixels == NULL)
 		goto out;
 
 	ret = 0; /* all is fine */

@@ -429,7 +438,7 @@ static int xenfb_map_fb(struct xenfb_pri
 
 static int xenfb_bind(struct xenfb_device *dev)
 {
-	struct xenfb_private *xenfb = dev->xenfb;
+	struct xenfb *xenfb = dev->xenfb;
 	unsigned long mfn;
 	evtchn_port_t evtchn;
 

@@ -512,17 +521,74 @@ static void xenfb_dev_fatal(struct xenfb
 }
 
 
-static void xenfb_detach_dom(struct xenfb_private *xenfb)
+static void xenfb_detach_dom(struct xenfb *xenfb)
 {
 	xenfb_unbind(&xenfb->fb);
 	xenfb_unbind(&xenfb->kbd);
-	if (xenfb->pub.pixels) {
-		munmap(xenfb->pub.pixels, xenfb->fb_len);
-		xenfb->pub.pixels = NULL;
-	}
-}
-
-static void xenfb_on_fb_event(struct xenfb_private *xenfb)
+	if (xenfb->data.pixels) {
+		munmap(xenfb->data.pixels, xenfb->data.len);
+		xenfb->data.pixels = NULL;
+	}
+}
+
+/* A convenient function for munging pixels between different depths */
+#define BLT(SRC_T,DST_T,RLS,GLS,BLS,RRS,GRS,BRS,RM,GM,BM)               \
+    for (line = y ; line < h ; line++) {                                \
+        SRC_T *src = (SRC_T *)(xenfb->data.pixels + (line*xenfb->data.row_stride) + (x*xenfb->data.depth/8)); \
+        DST_T *dst = (DST_T *)(xenfb->ds->data + (line*xenfb->ds->linesize) + (x*xenfb->ds->depth/8)); \
+        int col;                                                        \
+        for (col = x ; col < w ; col++) {                               \
+            *dst = (((*src >> RRS)&RM) << RLS) |                        \
+                (((*src >> GRS)&GM) << GLS) |                           \
+                (((*src >> GRS)&BM) << BLS);                            \
+            src++;                                                      \
+            dst++;                                                      \
+        }                                                               \
+    }
+
+
+/* This copies data from the guest framebuffer region, into QEMU's copy
+ * NB. QEMU's copy is stored in the pixel format of a) the local X server (SDL case)
+ * or b) the current VNC client pixel format.
+ */
+static void xenfb_guest_copy(struct xenfb *xenfb, int x, int y, int w, int h)
+{
+    int line;
+
+    if (xenfb->data.depth == xenfb->ds->depth) { /* Perfect match can use fast path */
+        for (line = y ; line < (y+h) ; line++) {
+            memcpy(xenfb->ds->data + (line * xenfb->ds->linesize) + (x*xenfb->ds->depth/8),
+                   xenfb->data.pixels + (line*xenfb->data.row_stride) + (x*xenfb->data.depth/8),
+                   w * xenfb->data.depth/8);
+        }
+    } else { /* Mismatch requires slow pixel munging */
+        if (xenfb->data.depth == 8) {
+            /* 8 bit source == r:3 g:3 b:2 */
+            if (xenfb->ds->depth == 16) {
+                BLT(uint8_t, uint16_t,   5, 2, 0,   11, 5, 0,   7, 7, 3);
+            } else if (xenfb->ds->depth == 32) {
+                BLT(uint8_t, uint32_t,   5, 2, 0,   16, 8, 0,   7, 7, 3);
+            }
+        } else if (xenfb->data.depth == 16) {
+            /* 16 bit source == r:5 g:6 b:5 */
+            if (xenfb->ds->depth == 8) {
+                BLT(uint16_t, uint8_t,    11, 5, 0,   5, 2, 0,    31, 63, 31);
+            } else if (xenfb->ds->depth == 32) {
+                BLT(uint16_t, uint32_t,   11, 5, 0,   16, 8, 0,   31, 63, 31);
+            }
+        } else if (xenfb->data.depth == 32) {
+            /* 32 bit source == r:8 g:8 b:8 (padding:8) */
+            if (xenfb->ds->depth == 8) {
+                BLT(uint32_t, uint8_t,    16, 8, 0,   5, 2, 0,    255, 255, 255);
+            } else if (xenfb->ds->depth == 16) {
+                BLT(uint32_t, uint16_t,   16, 8, 0,   11, 5, 0,   255, 255, 255);
+            }
+        }
+    }
+    dpy_update(xenfb->ds, x, y, w, h);
+}
+
+static void xenfb_on_fb_event(struct xenfb *xenfb)
 {
 	uint32_t prod, cons;
 	struct xenfb_page *page = xenfb->fb.page;

@@ -536,11 +602,10 @@ static void xenfb_on_fb_event(struct xen
 
 		switch (event->type) {
 		case XENFB_TYPE_UPDATE:
-                    if (xenfb->pub.update)
-			xenfb->pub.update(&xenfb->pub,
-					  event->update.x, event->update.y,
-					  event->update.width, event->update.height);
-                    break;
+			xenfb_guest_copy(xenfb,
+					 event->update.x, event->update.y,
+					 event->update.width, event->update.height);
+			break;
 		}
 	}
 	mb();			/* ensure we're done with ring contents */

@@ -548,7 +613,7 @@ static void xenfb_on_fb_event(struct xen
 	xc_evtchn_notify(xenfb->evt_xch, xenfb->fb.port);
 }
 
-static void xenfb_on_kbd_event(struct xenfb_private *xenfb)
+static void xenfb_on_kbd_event(struct xenfb *xenfb)
 {
 	struct xenkbd_page *page = xenfb->kbd.page;
 

@@ -586,7 +651,7 @@ static int xenfb_on_state_change(struct 
 	return 0;
 }
 
-static int xenfb_kbd_event(struct xenfb_private *xenfb,
+static int xenfb_kbd_event(struct xenfb *xenfb,
 			   union xenkbd_in_event *event)
 {
 	uint32_t prod;

@@ -608,9 +673,8 @@ static int xenfb_kbd_event(struct xenfb_
 	return xc_evtchn_notify(xenfb->evt_xch, xenfb->kbd.port);
 }
 
-static int xenfb_send_key(struct xenfb *xenfb_pub, bool down, int keycode)
-{
-	struct xenfb_private *xenfb = (struct xenfb_private *)xenfb_pub;
+static int xenfb_send_key(struct xenfb *xenfb, bool down, int keycode)
+{
 	union xenkbd_in_event event;
 
 	memset(&event, 0, XENKBD_IN_EVENT_SIZE);

@@ -621,9 +685,8 @@ static int xenfb_send_key(struct xenfb *
 	return xenfb_kbd_event(xenfb, &event);
 }
 
-static int xenfb_send_motion(struct xenfb *xenfb_pub, int rel_x, int rel_y)
-{
-	struct xenfb_private *xenfb = (struct xenfb_private *)xenfb_pub;
+static int xenfb_send_motion(struct xenfb *xenfb, int rel_x, int rel_y)
+{
 	union xenkbd_in_event event;
 
 	memset(&event, 0, XENKBD_IN_EVENT_SIZE);

@@ -634,9 +697,8 @@ static int xenfb_send_motion(struct xenf
 	return xenfb_kbd_event(xenfb, &event);
 }
 
-static int xenfb_send_position(struct xenfb *xenfb_pub, int abs_x, int abs_y)
-{
-	struct xenfb_private *xenfb = (struct xenfb_private *)xenfb_pub;
+static int xenfb_send_position(struct xenfb *xenfb, int abs_x, int abs_y)
+{
 	union xenkbd_in_event event;
 
 	memset(&event, 0, XENKBD_IN_EVENT_SIZE);

@@ -660,11 +722,11 @@ static void xenfb_mouse_event(void *opaq
 {
     int i;
     struct xenfb *xenfb = (struct xenfb*)opaque;
-    DisplayState *ds = (DisplayState *)xenfb->user_data;
-    if (xenfb->abs_pointer_wanted)
+
+    if (xenfb->data.abs_pointer_wanted)
 	    xenfb_send_position(xenfb,
-				dx*ds->width/0x7fff,
-				dy*ds->height/0x7fff);
+				dx*xenfb->ds->width/0x7fff,
+				dy*xenfb->ds->height/0x7fff);
     else
 	    xenfb_send_motion(xenfb, dx, dy);
 

@@ -680,76 +742,19 @@ static void xenfb_mouse_event(void *opaq
     xenfb->button_state = button_state;
 }
 
-/* A convenient function for munging pixels between different depths */
-#define BLT(SRC_T,DST_T,RLS,GLS,BLS,RRS,GRS,BRS,RM,GM,BM)               \
-    for (line = y ; line < h ; line++) {                                \
-        SRC_T *src = (SRC_T *)(xenfb->pixels + (line*xenfb->row_stride) + (x*xenfb->depth/8)); \
-        DST_T *dst = (DST_T *)(ds->data + (line*ds->linesize) + (x*ds->depth/8)); \
-        int col;                                                        \
-        for (col = x ; col < w ; col++) {                               \
-            *dst = (((*src >> RRS)&RM) << RLS) |                        \
-                (((*src >> GRS)&GM) << GLS) |                           \
-                (((*src >> GRS)&BM) << BLS);                            \
-            src++;                                                      \
-            dst++;                                                      \
-        }                                                               \
-    }
-
-
-/* This copies data from the guest framebuffer region, into QEMU's copy
- * NB. QEMU's copy is stored in the pixel format of a) the local X server (SDL case)
- * or b) the current VNC client pixel format.
- */
-static void xenfb_guest_copy(struct xenfb *xenfb, int x, int y, int w, int h)
-{
-    DisplayState *ds = (DisplayState *)xenfb->user_data;
-    int line;
-
-    if (xenfb->depth == ds->depth) { /* Perfect match can use fast path */
-        for (line = y ; line < (y+h) ; line++) {
-            memcpy(ds->data + (line * ds->linesize) + (x*ds->depth/8),
-                   xenfb->pixels + (line*xenfb->row_stride) + (x*xenfb->depth/8),
-                   w * xenfb->depth/8);
-        }
-    } else { /* Mismatch requires slow pixel munging */
-        if (xenfb->depth == 8) {
-            /* 8 bit source == r:3 g:3 b:2 */
-            if (ds->depth == 16) {
-                BLT(uint8_t, uint16_t,   5, 2, 0,   11, 5, 0,   7, 7, 3);
-            } else if (ds->depth == 32) {
-                BLT(uint8_t, uint32_t,   5, 2, 0,   16, 8, 0,   7, 7, 3);
-            }
-        } else if (xenfb->depth == 16) {
-            /* 16 bit source == r:5 g:6 b:5 */
-            if (ds->depth == 8) {
-                BLT(uint16_t, uint8_t,    11, 5, 0,   5, 2, 0,    31, 63, 31);
-            } else if (ds->depth == 32) {
-                BLT(uint16_t, uint32_t,   11, 5, 0,   16, 8, 0,   31, 63, 31);
-            }
-        } else if (xenfb->depth == 32) {
-            /* 32 bit source == r:8 g:8 b:8 (padding:8) */
-            if (ds->depth == 8) {
-                BLT(uint32_t, uint8_t,    16, 8, 0,   5, 2, 0,    255, 255, 255);
-            } else if (ds->depth == 16) {
-                BLT(uint32_t, uint16_t,   16, 8, 0,   11, 5, 0,   255, 255, 255);
-            }
-        }
-    }
-    dpy_update(ds, x, y, w, h);
-}
 
 /* QEMU display state changed, so refresh the framebuffer copy */
 static void xenfb_update(void *opaque)
 {
     struct xenfb *xenfb = (struct xenfb *)opaque;
-    xenfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height);
+    xenfb_guest_copy(xenfb, 0, 0, xenfb->data.width, xenfb->data.height);
 }
 
 /* QEMU display state changed, so refresh the framebuffer copy */
 static void xenfb_invalidate(void *opaque)
 {
     struct xenfb *xenfb = (struct xenfb *)opaque;
-    xenfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height);
+    xenfb_guest_copy(xenfb, 0, 0, xenfb->data.width, xenfb->data.height);
 }
 
 /* Screen dump is not used in Xen, so no need to impl this ? */

@@ -757,9 +762,9 @@ static void xenfb_screen_dump(void *opaq
 
 
 
-static void xenfb_dispatch_channel(void *xenfb_pub)
-{
-	struct xenfb_private *xenfb = (struct xenfb_private *)xenfb_pub;
+static void xenfb_dispatch_channel(void *opaque)
+{
+	struct xenfb *xenfb = (struct xenfb *)opaque;
 	evtchn_port_t port;
 	port = xc_evtchn_pending(xenfb->evt_xch);
 	if (port == -1)

@@ -774,9 +779,9 @@ static void xenfb_dispatch_channel(void 
 		exit(1);
 }
 
-static void xenfb_dispatch_store(void *xenfb_pub)
-{
-	struct xenfb_private *xenfb = (struct xenfb_private *)xenfb_pub;
+static void xenfb_dispatch_store(void *opaque)
+{
+	struct xenfb *xenfb = (struct xenfb *)opaque;
 	unsigned dummy;
 	char **vec;
 	int r;

@@ -791,9 +796,8 @@ static void xenfb_dispatch_store(void *x
 }
 
 
-int xenfb_attach_dom(struct xenfb *xenfb_pub, int domid, DisplayState *ds)
-{
-	struct xenfb_private *xenfb = (struct xenfb_private *)xenfb_pub;
+int xenfb_attach_dom(struct xenfb *xenfb, int domid, DisplayState *ds)
+{
 	struct xs_handle *xsh = xenfb->xsh;
 	int val, serrno;
 	struct xenfb_page *fb_page;

@@ -849,12 +853,12 @@ int xenfb_attach_dom(struct xenfb *xenfb
 
 	/* TODO check for permitted ranges */
 	fb_page = xenfb->fb.page;
-	xenfb->pub.depth = fb_page->depth;
-	xenfb->pub.width = fb_page->width;
-	xenfb->pub.height = fb_page->height;
+	xenfb->data.depth = fb_page->depth;
+	xenfb->data.width = fb_page->width;
+	xenfb->data.height = fb_page->height;
 	/* TODO check for consistency with the above */
-	xenfb->fb_len = fb_page->mem_length;
-	xenfb->pub.row_stride = fb_page->line_length;
+	xenfb->data.len = fb_page->mem_length;
+	xenfb->data.row_stride = fb_page->line_length;
 
 	if (xenfb_map_fb(xenfb, domid) < 0)
 		goto error;

@@ -869,7 +873,7 @@ int xenfb_attach_dom(struct xenfb *xenfb
 	if (xenfb_xs_scanf1(xsh, xenfb->kbd.otherend, "request-abs-pointer",
 			    "%d", &val) < 0)
 		val = 0;
-	xenfb->pub.abs_pointer_wanted = val;
+	xenfb->data.abs_pointer_wanted = val;
 
 	/* Listen for events from xenstore */
 	if (qemu_set_fd_handler2(xs_fileno(xenfb->xsh), NULL, xenfb_dispatch_store, NULL, xenfb) < 0)

@@ -882,19 +886,18 @@ int xenfb_attach_dom(struct xenfb *xenfb
 	/* Register our keyboard & mouse handlers */
 	qemu_add_kbd_event_handler(xenfb_put_keycode, xenfb);
 	qemu_add_mouse_event_handler(xenfb_mouse_event, xenfb,
-				     xenfb_pub->abs_pointer_wanted,
+				     xenfb->data.abs_pointer_wanted,
 				     "Xen PVFB Mouse");
 
-	xenfb_pub->update = xenfb_guest_copy;
-	xenfb_pub->user_data = ds;
+	xenfb->ds = ds;
 
 	/* Tell QEMU to allocate a graphical console */
 	graphic_console_init(ds,
 			     xenfb_update,
 			     xenfb_invalidate,
 			     xenfb_screen_dump,
-			     xenfb_pub);
-	dpy_resize(ds, xenfb_pub->width, xenfb_pub->height);
+			     xenfb);
+	dpy_resize(ds, xenfb->data.width, xenfb->data.height);
 
 	return 0;
 

diff -r 82c317f263c2 tools/ioemu/hw/xenfb.h
@@ -5,21 +5,7 @@
 #include <stdbool.h>
 #include <sys/types.h>
 
-struct xenfb
-{
-	void *pixels;
-
-	int row_stride;
-	int depth;
-	int width;
-	int height;
-	int abs_pointer_wanted;
-	int button_state;
-
-	void *user_data;
-
-	void (*update)(struct xenfb *xenfb, int x, int y, int width, int height);
-};
+struct xenfb;
 
 struct xenfb *xenfb_new(void);
 void xenfb_delete(struct xenfb *xenfb);

diff -r 90a6b110dc00 tools/ioemu/hw/xen_machine_pv.c
@@ -41,16 +41,9 @@ static void xen_init_pv(uint64_t ram_siz
     extern int domid;
 
     /* Prepare PVFB state */
-    xenfb = xenfb_new();
+    xenfb = xenfb_new(domid, ds);
     if (xenfb == NULL) {
         fprintf(stderr, "Could not create framebuffer (%s)\n",
-                strerror(errno));
-        exit(1);
-    }
-
-    /* Talk to the guest */
-    if (xenfb_attach_dom(xenfb, domid, ds) < 0) {
-        fprintf(stderr, "Could not connect to domain (%s)\n",
                 strerror(errno));
         exit(1);
     }

768 lines not on this page · raw message

diff -r 90a6b110dc00 tools/ioemu/hw/xenfb.h
@@ -7,10 +7,7 @@
 
 struct xenfb;
 
-struct xenfb *xenfb_new(void);
-void xenfb_delete(struct xenfb *xenfb);
-void xenfb_teardown(struct xenfb *xenfb);
-
-int xenfb_attach_dom(struct xenfb *xenfb, int domid, DisplayState *ds);
+struct xenfb *xenfb_new(int domid, DisplayState *ds);
+void xenfb_shutdown(struct xenfb *xenfb);
 
 #endif

424 lines not on this page · raw message

diff -r 04c80f1aa008 tools/ioemu/hw/xen_console.h
@@ -0,0 +1,25 @@
+/*
+ *  Copyright (C) International Business Machines  Corp., 2005
+ *  Author(s): Anthony Liguori <[email protected]>
+ *
+ *  Copyright (C) Red Hat 2007
+ *
+ *  Xen Console
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; under version 2 of the License.
+ * 
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "vl.h"
+
+extern int xencons_init(int domid, CharDriverState *chr);

diff -r 04c80f1aa008 tools/ioemu/hw/xen_machine_pv.c
@@ -23,6 +23,7 @@
  */
 
 #include "vl.h"
+#include "xen_console.h"
 #include "xenfb.h"
 
 

@@ -39,6 +40,14 @@ static void xen_init_pv(uint64_t ram_siz
 {
     struct xenfb *xenfb;
     extern int domid;
+
+    /* Connect to text console */
+    if (serial_hds[0]) {
+        if (xencons_init(domid, serial_hds[0]) < 0) {
+            fprintf(stderr, "Could not connect to domain console\n");
+            exit(1);
+        }
+    }
 
     /* Prepare PVFB state */
     xenfb = xenfb_new(domid, ds);

diff -r 04c80f1aa008 tools/ioemu/xenstore.c
@@ -17,7 +17,7 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 
-static struct xs_handle *xsh = NULL;
+struct xs_handle *xsh = NULL;
 static char *media_filename[MAX_DISKS + MAX_SCSI_DISKS];
 static QEMUTimer *insert_timer = NULL;
 

diff -r fda4d94ca31d tools/console/daemon/io.c
@@ -1,831 +0,0 @@
-/*
- *  Copyright (C) International Business Machines  Corp., 2005
- *  Author(s): Anthony Liguori <[email protected]>
- *
- *  Xen Console Daemon
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; under version 2 of the License.
- * 
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- * 
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#define _GNU_SOURCE
-
-#include "utils.h"
-#include "io.h"
-#include <xs.h>
-#include <xen/io/console.h>
-#include <xenctrl.h>
-
-#include <malloc.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <string.h>
-#include <sys/select.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <termios.h>
-#include <stdarg.h>
-#include <sys/mman.h>
-
-#define MAX(a, b) (((a) > (b)) ? (a) : (b))
-#define MIN(a, b) (((a) < (b)) ? (a) : (b))
-
-/* Each 10 bits takes ~ 3 digits, plus one, plus one for nul terminator. */
-#define MAX_STRLEN(x) ((sizeof(x) * CHAR_BIT + CHAR_BIT-1) / 10 * 3 + 2)
-
-extern int log_reload;
-extern int log_guest;
-extern int log_hv;
-extern char *log_dir;
-
-static int log_hv_fd = -1;
-static int xc_handle = -1;
-
-struct buffer
-{
-	char *data;
-	size_t consumed;
-	size_t size;
-	size_t capacity;
-	size_t max_capacity;
-};
-
-struct domain
-{
-	int domid;
-	int tty_fd;
-	int log_fd;
-	bool is_dead;
-	struct buffer buffer;
-	struct domain *next;
-	char *conspath;
-	char *serialpath;
-	int use_consolepath;
-	int ring_ref;
-	evtchn_port_t local_port;
-	evtchn_port_t remote_port;
-	int xce_handle;
-	struct xencons_interface *interface;
-};
-
-static struct domain *dom_head;
-
-static void buffer_append(struct domain *dom)
-{
-	struct buffer *buffer = &dom->buffer;
-	XENCONS_RING_IDX cons, prod, size;
-	struct xencons_interface *intf = dom->interface;
-
-	cons = intf->out_cons;
-	prod = intf->out_prod;
-	mb();
-
-	size = prod - cons;
-	if ((size == 0) || (size > sizeof(intf->out)))
-		return;
-
-	if ((buffer->capacity - buffer->size) < size) {
-		buffer->capacity += (size + 1024);
-		buffer->data = realloc(buffer->data, buffer->capacity);
-		if (buffer->data == NULL) {
-			dolog(LOG_ERR, "Memory allocation failed");
-			exit(ENOMEM);
-		}
-	}
-
-	while (cons != prod)
-		buffer->data[buffer->size++] = intf->out[
-			MASK_XENCONS_IDX(cons++, intf->out)];
-
-	mb();
-	intf->out_cons = cons;
-	xc_evtchn_notify(dom->xce_handle, dom->local_port);
-
-	/* Get the data to the logfile as early as possible because if
-	 * no one is listening on the console pty then it will fill up
-	 * and handle_tty_write will stop being called.
-	 */
-	if (dom->log_fd != -1) {
-		int len = write(dom->log_fd,
-				buffer->data + buffer->size - size,
-				size);
-		if (len < 0)
-			dolog(LOG_ERR, "Write to log failed on domain %d: %d (%s)\n",
-			      dom->domid, errno, strerror(errno));
-	}
-
-	if (buffer->max_capacity &&
-	    buffer->size > buffer->max_capacity) {
-		/* Discard the middle of the data. */
-
-		size_t over = buffer->size - buffer->max_capacity;
-		char *maxpos = buffer->data + buffer->max_capacity;
-
-		memmove(maxpos - over, maxpos, over);
-		buffer->data = realloc(buffer->data, buffer->max_capacity);
-		buffer->size = buffer->capacity = buffer->max_capacity;
-
-		if (buffer->consumed > buffer->max_capacity - over)
-			buffer->consumed = buffer->max_capacity - over;
-	}
-}
-
-static bool buffer_empty(struct buffer *buffer)
-{
-	return buffer->size == 0;
-}
-
-static void buffer_advance(struct buffer *buffer, size_t len)
-{
-	buffer->consumed += len;
-	if (buffer->consumed == buffer->size) {
-		buffer->consumed = 0;
-		buffer->size = 0;
-	}
-}
-
-static bool domain_is_valid(int domid)
-{
-	bool ret;
-	xc_dominfo_t info;
-
-	ret = (xc_domain_getinfo(xc, domid, 1, &info) == 1 &&
-	       info.domid == domid);
-		
-	return ret;
-}
-
-static int create_hv_log(void)
-{
-	char logfile[PATH_MAX];
-	int fd;
-	snprintf(logfile, PATH_MAX-1, "%s/hypervisor.log", log_dir);
-	logfile[PATH_MAX-1] = '\0';
-
-	fd = open(logfile, O_WRONLY|O_CREAT|O_APPEND, 0644);
-	if (fd == -1)
-		dolog(LOG_ERR, "Failed to open log %s: %d (%s)",
-		      logfile, errno, strerror(errno));
-	return fd;
-}
-
-static int create_domain_log(struct domain *dom)
-{
-	char logfile[PATH_MAX];
-	char *namepath, *data, *s;
-	int fd;
-	unsigned int len;
-
-	namepath = xs_get_domain_path(xs, dom->domid);
-	s = realloc(namepath, strlen(namepath) + 6);
-	if (s == NULL) {
-		free(namepath);
-		return -1;
-	}
-	namepath = s;
-	strcat(namepath, "/name");
-	data = xs_read(xs, XBT_NULL, namepath, &len);
-	if (!data)
-		return -1;
-	if (!len) {
-		free(data);
-		return -1;
-	}
-
-	snprintf(logfile, PATH_MAX-1, "%s/guest-%s.log", log_dir, data);
-	free(data);
-	logfile[PATH_MAX-1] = '\0';
-
-	fd = open(logfile, O_WRONLY|O_CREAT|O_APPEND, 0644);
-	if (fd == -1)
-		dolog(LOG_ERR, "Failed to open log %s: %d (%s)",
-		      logfile, errno, strerror(errno));
-	return fd;
-}
-
-
-static int domain_create_tty(struct domain *dom)
-{
-	char *path;
-	int master;
-	bool success;
-
-	if ((master = open("/dev/ptmx",O_RDWR|O_NOCTTY)) == -1 ||
-	    grantpt(master) == -1 || unlockpt(master) == -1) {
-		dolog(LOG_ERR, "Failed to create tty for domain-%d",
-		      dom->domid);
-		master = -1;
-	} else {
-		const char *slave = ptsname(master);
-		struct termios term;
-		char *data;
-		unsigned int len;
-
-		if (tcgetattr(master, &term) != -1) {
-			cfmakeraw(&term);
-			tcsetattr(master, TCSAFLUSH, &term);
-		}
-
-		if (dom->use_consolepath) {
-			success = asprintf(&path, "%s/limit", dom->conspath) !=
-				-1;
-			if (!success)
-				goto out;
-			data = xs_read(xs, XBT_NULL, path, &len);
-			if (data) {
-				dom->buffer.max_capacity = strtoul(data, 0, 0);
-				free(data);
-			}
-			free(path);
-		}
-
-		success = asprintf(&path, "%s/limit", dom->serialpath) != -1;
-		if (!success)
-			goto out;
-		data = xs_read(xs, XBT_NULL, path, &len);
-		if (data) {
-			dom->buffer.max_capacity = strtoul(data, 0, 0);
-			free(data);
-		}
-		free(path);
-
-		success = asprintf(&path, "%s/tty", dom->serialpath) != -1;
-		if (!success)
-			goto out;
-		success = xs_write(xs, XBT_NULL, path, slave, strlen(slave));
-		free(path);
-		if (!success)
-			goto out;
-
-		if (dom->use_consolepath) {
-			success = asprintf(&path, "%s/tty", dom->conspath) !=
-				-1;
-			if (!success)
-				goto out;
-			success = xs_write(xs, XBT_NULL, path, slave,
-					   strlen(slave));
-			free(path);
-			if (!success)
-				goto out;
-		}
-
-		if (fcntl(master, F_SETFL, O_NONBLOCK) == -1)
-			goto out;
-	}
-
-	return master;
- out:
-	close(master);
-	return -1;
-}
-
-/* Takes tuples of names, scanf-style args, and void **, NULL terminated. */
-int xs_gather(struct xs_handle *xs, const char *dir, ...)
-{
-	va_list ap;
-	const char *name;
-	char *path;
-	int ret = 0;
-
-	va_start(ap, dir);
-	while (ret == 0 && (name = va_arg(ap, char *)) != NULL) {
-		const char *fmt = va_arg(ap, char *);
-		void *result = va_arg(ap, void *);
-		char *p;
-
-		if (asprintf(&path, "%s/%s", dir, name) == -1) {
-			ret = ENOMEM;
-			break;
-		}
-		p = xs_read(xs, XBT_NULL, path, NULL);
-		free(path);
-		if (p == NULL) {
-			ret = ENOENT;
-			break;
-		}
-		if (fmt) {
-			if (sscanf(p, fmt, result) == 0)
-				ret = EINVAL;
-			free(p);
-		} else
-			*(char **)result = p;
-	}
-	va_end(ap);
-	return ret;
-}
-
-static int domain_create_ring(struct domain *dom)
-{
-	int err, remote_port, ring_ref, rc;
-
-	err = xs_gather(xs, dom->serialpath,
-			"ring-ref", "%u", &ring_ref,
-			"port", "%i", &remote_port,
-			NULL);
-	if (err) {
-		err = xs_gather(xs, dom->conspath,
-				"ring-ref", "%u", &ring_ref,
-				"port", "%i", &remote_port,
-				NULL);
-		if (err)
-			goto out;
-		dom->use_consolepath = 1;
-	} else
-		dom->use_consolepath = 0;
-
-	if ((ring_ref == dom->ring_ref) && (remote_port == dom->remote_port))
-		goto out;
-
-	if (ring_ref != dom->ring_ref) {
-		if (dom->interface != NULL)
-			munmap(dom->interface, getpagesize());
-		dom->interface = xc_map_foreign_range(
-			xc, dom->domid, getpagesize(),
-			PROT_READ|PROT_WRITE,
-			(unsigned long)ring_ref);
-		if (dom->interface == NULL) {
-			err = EINVAL;
-			goto out;
-		}
-		dom->ring_ref = ring_ref;
-	}
-
-	dom->local_port = -1;
-	dom->remote_port = -1;
-	if (dom->xce_handle != -1)
-		xc_evtchn_close(dom->xce_handle);
-
-	/* Opening evtchn independently for each console is a bit
-	 * wasteful, but that's how the code is structured... */
-	dom->xce_handle = xc_evtchn_open();
-	if (dom->xce_handle == -1) {
-		err = errno;
-		goto out;
-	}
- 
-	rc = xc_evtchn_bind_interdomain(dom->xce_handle,
-		dom->domid, remote_port);
-
-	if (rc == -1) {
-		err = errno;
-		xc_evtchn_close(dom->xce_handle);
-		dom->xce_handle = -1;
-		goto out;
-	}
-	dom->local_port = rc;
-	dom->remote_port = remote_port;
-
-	if (dom->tty_fd == -1) {
-		dom->tty_fd = domain_create_tty(dom);
-
-		if (dom->tty_fd == -1) {
-			err = errno;
-			xc_evtchn_close(dom->xce_handle);
-			dom->xce_handle = -1;
-			dom->local_port = -1;
-			dom->remote_port = -1;
-			goto out;
-		}
-	}
-
-	if (log_guest)
-		dom->log_fd = create_domain_log(dom);
-
- out:
-	return err;
-}
-
-static bool watch_domain(struct domain *dom, bool watch)
-{
-	char domid_str[3 + MAX_STRLEN(dom->domid)];
-	bool success;
-
-	sprintf(domid_str, "dom%u", dom->domid);
-	if (watch) {
-		success = xs_watch(xs, dom->serialpath, domid_str);
-		if (success) {
-			success = xs_watch(xs, dom->conspath, domid_str);
-			if (success)
-				domain_create_ring(dom);
-			else
-				xs_unwatch(xs, dom->serialpath, domid_str);
-		}
-	} else {
-		success = xs_unwatch(xs, dom->serialpath, domid_str);
-		success = xs_unwatch(xs, dom->conspath, domid_str);
-	}
-
-	return success;
-}
-
-
-static struct domain *create_domain(int domid)
-{
-	struct domain *dom;
-	char *s;
-
-	dom = (struct domain *)malloc(sizeof(struct domain));
-	if (dom == NULL) {
-		dolog(LOG_ERR, "Out of memory %s:%s():L%d",
-		      __FILE__, __FUNCTION__, __LINE__);
-		exit(ENOMEM);
-	}
-
-	dom->domid = domid;
-
-	dom->serialpath = xs_get_domain_path(xs, dom->domid);
-	s = realloc(dom->serialpath, strlen(dom->serialpath) +
-		    strlen("/serial/0") + 1);
-	if (s == NULL)
-		goto out;
-	dom->serialpath = s;
-	strcat(dom->serialpath, "/serial/0");
-
-	dom->conspath = xs_get_domain_path(xs, dom->domid);
-	s = realloc(dom->conspath, strlen(dom->conspath) +
-		    strlen("/console") + 1);
-	if (s == NULL)
-		goto out;
-	dom->conspath = s;
-	strcat(dom->conspath, "/console");
-
-	dom->tty_fd = -1;
-	dom->log_fd = -1;
-
-	dom->is_dead = false;
-	dom->buffer.data = 0;
-	dom->buffer.consumed = 0;
-	dom->buffer.size = 0;
-	dom->buffer.capacity = 0;
-	dom->buffer.max_capacity = 0;
-	dom->next = NULL;
-
-	dom->ring_ref = -1;
-	dom->local_port = -1;
-	dom->remote_port = -1;
-	dom->interface = NULL;
-	dom->xce_handle = -1;
-
-	if (!watch_domain(dom, true))
-		goto out;
-
-	dom->next = dom_head;
-	dom_head = dom;
-
-	dolog(LOG_DEBUG, "New domain %d", domid);
-
-	return dom;
- out:
-	free(dom->serialpath);
-	free(dom->conspath);
-	free(dom);
-	return NULL;
-}
-
-static struct domain *lookup_domain(int domid)
-{
-	struct domain *dom;
-
-	for (dom = dom_head; dom; dom = dom->next)
-		if (dom->domid == domid)
-			return dom;
-	return NULL;
-}
-
-static void remove_domain(struct domain *dom)
-{
-	struct domain **pp;
-
-	dolog(LOG_DEBUG, "Removing domain-%d", dom->domid);
-
-	for (pp = &dom_head; *pp; pp = &(*pp)->next) {
-		if (dom == *pp) {
-			*pp = dom->next;
-			free(dom);
-			break;
-		}
-	}
-}
-
-static void cleanup_domain(struct domain *d)
-{
-	if (d->tty_fd != -1) {
-		close(d->tty_fd);
-		d->tty_fd = -1;
-	}
-	if (d->log_fd != -1) {
-		close(d->log_fd);
-		d->log_fd = -1;
-	}
-
-	free(d->buffer.data);
-	d->buffer.data = NULL;
-
-	free(d->serialpath);
-	d->serialpath = NULL;
-
-	free(d->conspath);
-	d->conspath = NULL;
-
-	remove_domain(d);
-}
-
-static void shutdown_domain(struct domain *d)
-{
-	d->is_dead = true;
-	watch_domain(d, false);
-	if (d->interface != NULL)
-		munmap(d->interface, getpagesize());
-	d->interface = NULL;
-	if (d->xce_handle != -1)
-		xc_evtchn_close(d->xce_handle);
-	d->xce_handle = -1;
-	cleanup_domain(d);
-}
-
-void enum_domains(void)
-{
-	int domid = 1;
-	xc_dominfo_t dominfo;
-	struct domain *dom;
-
-	while (xc_domain_getinfo(xc, domid, 1, &dominfo) == 1) {
-		dom = lookup_domain(dominfo.domid);
-		if (dominfo.dying) {
-			if (dom)
-				shutdown_domain(dom);
-		} else {
-			if (dom == NULL)
-				create_domain(dominfo.domid);
-		}
-		domid = dominfo.domid + 1;
-	}
-}
-
-static int ring_free_bytes(struct domain *dom)
-{
-	struct xencons_interface *intf = dom->interface;
-	XENCONS_RING_IDX cons, prod, space;
-
-	cons = intf->in_cons;
-	prod = intf->in_prod;
-	mb();
-
-	space = prod - cons;
-	if (space > sizeof(intf->in))
-		return 0; /* ring is screwed: ignore it */
-
-	return (sizeof(intf->in) - space);
-}
-
-static void handle_tty_read(struct domain *dom)
-{
-	ssize_t len = 0;
-	char msg[80];
-	int i;
-	struct xencons_interface *intf = dom->interface;
-	XENCONS_RING_IDX prod;
-
-	len = ring_free_bytes(dom);
-	if (len == 0)
-		return;
-
-	if (len > sizeof(msg))
-		len = sizeof(msg);
-
-	len = read(dom->tty_fd, msg, len);
-	if (len < 1) {
-		close(dom->tty_fd);
-		dom->tty_fd = -1;
-
-		if (domain_is_valid(dom->domid)) {
-			dom->tty_fd = domain_create_tty(dom);
-		} else {
-			shutdown_domain(dom);
-		}
-	} else if (domain_is_valid(dom->domid)) {
-		prod = intf->in_prod;
-		for (i = 0; i < len; i++) {
-			intf->in[MASK_XENCONS_IDX(prod++, intf->in)] =
-				msg[i];
-		}
-		wmb();
-		intf->in_prod = prod;
-		xc_evtchn_notify(dom->xce_handle, dom->local_port);
-	} else {
-		close(dom->tty_fd);
-		dom->tty_fd = -1;
-		shutdown_domain(dom);
-	}
-}
-
-static void handle_tty_write(struct domain *dom)
-{
-	ssize_t len;
-
-	len = write(dom->tty_fd, dom->buffer.data + dom->buffer.consumed,
-		    dom->buffer.size - dom->buffer.consumed);
- 	if (len < 1) {
-		dolog(LOG_DEBUG, "Write failed on domain %d: %zd, %d\n",
-		      dom->domid, len, errno);
-
-		close(dom->tty_fd);
-		dom->tty_fd = -1;
-
-		if (domain_is_valid(dom->domid)) {
-			dom->tty_fd = domain_create_tty(dom);
-		} else {
-			shutdown_domain(dom);
-		}
-	} else {
-		buffer_advance(&dom->buffer, len);
-	}
-}
-
-static void handle_ring_read(struct domain *dom)
-{
-	evtchn_port_t port;
-
-	if ((port = xc_evtchn_pending(dom->xce_handle)) == -1)
-		return;
-
-	buffer_append(dom);
-
-	(void)xc_evtchn_unmask(dom->xce_handle, port);
-}
-
-static void handle_xs(void)
-{
-	char **vec;
-	int domid;
-	struct domain *dom;
-	unsigned int num;
-
-	vec = xs_read_watch(xs, &num);
-	if (!vec)
-		return;
-
-	if (!strcmp(vec[XS_WATCH_TOKEN], "domlist"))
-		enum_domains();
-	else if (sscanf(vec[XS_WATCH_TOKEN], "dom%u", &domid) == 1) {
-		dom = lookup_domain(domid);
-		/* We may get watches firing for domains that have recently
-		   been removed, so dom may be NULL here. */
-		if (dom && dom->is_dead == false)
-			domain_create_ring(dom);
-	}
-
-	free(vec);
-}
-
-static void handle_hv_logs(void)
-{
-	char buffer[1024*16];
-	char *bufptr = buffer;
-	unsigned int size = sizeof(buffer);
-	if (xc_readconsolering(xc_handle, &bufptr, &size, 1) == 0) {
-		int len = write(log_hv_fd, buffer, size);
-		if (len < 0)
-			dolog(LOG_ERR, "Failed to write hypervisor log: %d (%s)",
-			      errno, strerror(errno));
-	}
-}
-
-static void handle_log_reload(void)
-{
-	if (log_guest) {
-		struct domain *d;
-		for (d = dom_head; d; d = d->next) {
-			if (d->log_fd != -1)
-				close(d->log_fd);
-			d->log_fd = create_domain_log(d);
-		}
-	}
-
-	if (log_hv) {
-		if (log_hv_fd != -1)
-			close(log_hv_fd);
-		log_hv_fd = create_hv_log();
-	}
-}
-
-void handle_io(void)
-{
-	fd_set readfds, writefds;
-	int ret;
-
-	if (log_hv) {
-		xc_handle = xc_interface_open();
-		if (xc_handle == -1)
-			dolog(LOG_ERR, "Failed to open xc handle: %d (%s)",
-			      errno, strerror(errno));
-		else
-			log_hv_fd = create_hv_log();
-	}
-
-	for (;;) {
-		struct domain *d, *n;
-		struct timeval timeout = { 1, 0 }; /* Read HV logs every 1 second */
-		int max_fd = -1;
-
-		FD_ZERO(&readfds);
-		FD_ZERO(&writefds);
-
-		FD_SET(xs_fileno(xs), &readfds);
-		max_fd = MAX(xs_fileno(xs), max_fd);
-
-		for (d = dom_head; d; d = d->next) {
-			if (d->xce_handle != -1) {
-				int evtchn_fd = xc_evtchn_fd(d->xce_handle);
-				FD_SET(evtchn_fd, &readfds);
-				max_fd = MAX(evtchn_fd, max_fd);
-			}
-
-			if (d->tty_fd != -1) {
-				if (!d->is_dead && ring_free_bytes(d))
-					FD_SET(d->tty_fd, &readfds);
-
-				if (!buffer_empty(&d->buffer))
-					FD_SET(d->tty_fd, &writefds);
-				max_fd = MAX(d->tty_fd, max_fd);
-			}
-		}
-
-		/* XXX I wish we didn't have to busy wait for hypervisor logs
-		 * but there's no obvious way to get event channel notifications
-		 * for new HV log data as we can with guest */
-		ret = select(max_fd + 1, &readfds, &writefds, 0,
-			     log_hv_fd != -1 ? &timeout : NULL);
-
-		if (log_reload) {
-			handle_log_reload();
-			log_reload = 0;
-		}
-
-		/* Abort if select failed, except for EINTR cases
-		   which indicate a possible log reload */
-		if (ret == -1) {
-			if (errno == EINTR)
-				continue;
-			dolog(LOG_ERR, "Failure in select: %d (%s)",
-			      errno, strerror(errno));
-			break;
-		}
-
-		/* Always process HV logs even if not a timeout */
-		if (log_hv_fd != -1)
-			handle_hv_logs();
-
-		/* Must not check returned FDSET if it was a timeout */
-		if (ret == 0)
-			continue;
-
-		if (FD_ISSET(xs_fileno(xs), &readfds))
-			handle_xs();
-
-		for (d = dom_head; d; d = n) {
-			n = d->next;
-			if (d->xce_handle != -1 &&
-			    FD_ISSET(xc_evtchn_fd(d->xce_handle), &readfds))
-				handle_ring_read(d);
-
-			if (d->tty_fd != -1 && FD_ISSET(d->tty_fd, &readfds))
-				handle_tty_read(d);
-
-			if (d->tty_fd != -1 && FD_ISSET(d->tty_fd, &writefds))
-				handle_tty_write(d);
-
-			if (d->is_dead)
-				cleanup_domain(d);
-		}
-	}
-
-	if (log_hv_fd != -1) {
-		close(log_hv_fd);
-		log_hv_fd = -1;
-	}
-	if (xc_handle != -1) {
-		xc_interface_close(xc_handle);
-		xc_handle = -1;
-	}
-}
-
-/*
- * Local variables:
- *  c-file-style: "linux"
- *  indent-tabs-mode: t
- *  c-indent-level: 8
- *  c-basic-offset: 8
- *  tab-width: 8
- * End:
- */

diff -r fda4d94ca31d tools/console/daemon/io.h
@@ -1,27 +0,0 @@
-/*\
- *  Copyright (C) International Business Machines  Corp., 2005
- *  Author(s): Anthony Liguori <[email protected]>
- *
- *  Xen Console Daemon
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; under version 2 of the License.
- * 
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- * 
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-\*/
-
-#ifndef CONSOLED_IO_H
-#define CONSOLED_IO_H
-
-void enum_domains(void);
-void handle_io(void);
-
-#endif

111 lines not on this page · raw message

diff -r fda4d94ca31d tools/console/daemon/utils.c
@@ -36,7 +36,6 @@
 #include "xenctrl.h"
 #include "utils.h"
 
-struct xs_handle *xs;
 int xc;
 
 static void child_exit(int sig)

@@ -107,37 +106,12 @@ void daemonize(const char *pidfile)
 
 bool xen_setup(void)
 {
-	
-	xs = xs_daemon_open();
-	if (xs == NULL) {
-		dolog(LOG_ERR,
-		      "Failed to contact xenstore (%m).  Is it running?");
-		goto out;
-	}
-
 	xc = xc_interface_open();
 	if (xc == -1) {
 		dolog(LOG_ERR, "Failed to contact hypervisor (%m)");
-		goto out;
-	}
-
-	if (!xs_watch(xs, "@introduceDomain", "domlist")) {
-		dolog(LOG_ERR, "xenstore watch on @introduceDomain fails.");
-		goto out;
-	}
-
-	if (!xs_watch(xs, "@releaseDomain", "domlist")) {
-		dolog(LOG_ERR, "xenstore watch on @releaseDomain fails.");
-		goto out;
+		return false;
 	}
 
 	return true;
-
- out:
-	if (xs)
-		xs_daemon_close(xs);
-	if (xc != -1)
-		xc_interface_close(xc);
-	return false;
 }
 

diff -r fda4d94ca31d tools/console/daemon/utils.h
@@ -25,12 +25,9 @@
 #include <syslog.h>
 #include <stdio.h>
 
-#include "xs.h"
-
 void daemonize(const char *pidfile);
 bool xen_setup(void);
 
-extern struct xs_handle *xs;
 extern int xc;
 
 #if 1

diff -r 7953164cebb6 tools/ioemu/block.c
@@ -56,6 +56,8 @@ static BlockDriverState *bdrv_first;
 static BlockDriverState *bdrv_first;
 static BlockDriver *first_drv;
 
+static BlockDriver *get_bdrv_raw(void);
+
 int path_is_absolute(const char *path)
 {
     const char *p;

@@ -323,6 +325,7 @@ int bdrv_open2(BlockDriverState *bs, con
 {
     int ret, open_flags;
     char tmp_filename[1024];
+    int is_media_inserted;
     char backing_filename[1024];
     
     bs->read_only = 0;

@@ -359,6 +362,10 @@ int bdrv_open2(BlockDriverState *bs, con
     }
 
     pstrcpy(bs->filename, sizeof(bs->filename), filename);
+    if (bs->type == BDRV_TYPE_CDROM && !drv && bs->is_shared) {
+        drv = get_bdrv_raw();
+    }else{
+
     if (flags & BDRV_O_FILE) {
         drv = find_protocol(filename);
         if (!drv)

@@ -370,16 +377,27 @@ int bdrv_open2(BlockDriverState *bs, con
                 return -1;
         }
     }
+
+    }
     bs->drv = drv;
     bs->opaque = qemu_mallocz(drv->instance_size);
     if (bs->opaque == NULL && drv->instance_size > 0)
         return -1;
+    is_media_inserted = 1;
     /* Note: for compatibility, we open disk image files as RDWR, and
        RDONLY as fallback */
     if (!(flags & BDRV_O_FILE))
         open_flags = BDRV_O_RDWR;
     else
         open_flags = flags & ~(BDRV_O_FILE | BDRV_O_SNAPSHOT);
+
+    if (bs->type == BDRV_TYPE_CDROM && bs->is_shared) {
+        if (!bs->is_owner) {
+            bs->total_sectors = 0;
+            return ENOMEDIUM;
+        }
+    }
+
     ret = drv->bdrv_open(bs, filename, open_flags);
     if (ret == -EACCES && !(flags & BDRV_O_FILE)) {
         ret = drv->bdrv_open(bs, filename, BDRV_O_RDONLY);

@@ -391,6 +409,20 @@ int bdrv_open2(BlockDriverState *bs, con
         bs->drv = NULL;
         return ret;
     }
+
+    if (bs->type == BDRV_TYPE_CDROM && ret < 1) {
+        if (!bs->is_owner) {
+            bs->total_sectors = 0;
+            if (errno == ENOMEDIUM )
+                return ENOMEDIUM;
+            else
+                return -1;
+        }
+    }
+
+    if (bs->type == BDRV_TYPE_CDROM && ret == ENOMEDIUM)
+        is_media_inserted = 0;
+
     if (drv->bdrv_getlength) {
         bs->total_sectors = bdrv_getlength(bs) >> SECTOR_BITS;
     }

@@ -413,8 +445,12 @@ int bdrv_open2(BlockDriverState *bs, con
             goto fail;
     }
 
+    if (is_media_inserted)
+        bs->media_changed = 1;
+    else
+        bs->media_changed = 0;
+
     /* call the change callback */
-    bs->media_changed = 1;
     if (bs->change_cb)
         bs->change_cb(bs->change_opaque);
 

@@ -427,19 +463,20 @@ void bdrv_close(BlockDriverState *bs)
         if (bs->backing_hd)
             bdrv_delete(bs->backing_hd);
         bs->drv->bdrv_close(bs);
-        qemu_free(bs->opaque);
+        bs->drv = NULL;
 #ifdef _WIN32
         if (bs->is_temporary) {
             unlink(bs->filename);
         }
 #endif
-        bs->opaque = NULL;
-        bs->drv = NULL;
 
         /* call the change callback */
         bs->media_changed = 1;
         if (bs->change_cb)
             bs->change_cb(bs->change_opaque);
+ 
+        qemu_free(bs->opaque);
+        bs->opaque = NULL;
     }
 }
 

@@ -754,6 +791,28 @@ void bdrv_set_translation_hint(BlockDriv
     bs->translation = translation;
 }
 
+void bdrv_set_shared_owner_hint(BlockDriverState *bs, int is_owner)
+{
+    bs->is_shared = 1;
+    bs->is_owner = is_owner;
+}
+
+void bdrv_change_shared_owner(BlockDriverState *bs, int new_owner_state)
+{
+    if (!bs->is_shared)
+        return;
+
+    if (bs->is_owner == new_owner_state)
+        return;
+
+    bs->is_owner = new_owner_state;
+
+    if (!new_owner_state) {
+        bdrv_close(bs);
+        return;
+    }
+}
+
 void bdrv_get_geometry_hint(BlockDriverState *bs, 
                             int *pcyls, int *pheads, int *psecs)
 {

@@ -770,6 +829,16 @@ int bdrv_get_translation_hint(BlockDrive
 int bdrv_get_translation_hint(BlockDriverState *bs)
 {
     return bs->translation;
+}
+
+int bdrv_is_shared(BlockDriverState *bs)
+{
+    return bs->is_shared;
+}
+
+int bdrv_is_owner(BlockDriverState *bs)
+{
+    return bs->is_owner;
 }
 
 int bdrv_is_removable(BlockDriverState *bs)

@@ -854,6 +923,11 @@ const char *bdrv_get_device_name(BlockDr
 const char *bdrv_get_device_name(BlockDriverState *bs)
 {
     return bs->device_name;
+}
+
+const char *bdrv_get_filename(BlockDriverState *bs)
+{
+    return bs->filename;
 }
 
 void bdrv_flush(BlockDriverState *bs)

@@ -1231,6 +1305,11 @@ static int bdrv_write_em(BlockDriverStat
     return async_ret;
 }
 
+static BlockDriver *get_bdrv_raw(void)
+{
+    return &bdrv_raw ;
+}
+
 void bdrv_init(void)
 {
     bdrv_register(&bdrv_raw);

diff -r 7953164cebb6 tools/ioemu/block_int.h
@@ -87,6 +87,8 @@ struct BlockDriverState {
     int removable; /* if true, the media can be removed */
     int locked;    /* if true, the media cannot temporarily be ejected */
     int encrypted; /* if true, the media is encrypted */
+    int is_shared; /* if true, the media is shared across multiple QEMU instances */
+    int is_owner;  /* if true, the media is sharable and currently owned by this QEMU instance */
     /* event callback when inserting/removing */
     void (*change_cb)(void *opaque);
     void *change_opaque;

297 lines not on this page · raw message

diff -r 7953164cebb6 tools/ioemu/monitor.c
@@ -397,6 +397,40 @@ void do_change(const char *device, const
             term_printf("invalid password\n");
         }
     }
+}
+
+static void do_set_cdrom_owner(const char* new_owner_state_cstr, const char *device)
+{
+    BlockDriverState *bs;
+    int new_owner_state;
+
+    if (!new_owner_state_cstr || !device) {
+        term_printf("[set_cdrom_owner] ERROR : insufficient args (NULL) !?!\n");
+        return;
+    }
+
+    if (sscanf(new_owner_state_cstr, "%d", &new_owner_state) != 1) {
+        term_printf("[set_cdrom_owner] ERROR : bad arg '%s'\n", new_owner_state_cstr);
+        return;
+    }
+
+    if (new_owner_state)    // normalize given input
+        new_owner_state = 1;
+
+    bs = bdrv_find(device);
+    if (!bs) {
+        term_printf("[set_cdrom_owner] ERROR : cdrom device '%s' not found %d\n", device, new_owner_state);
+        return;
+    }
+
+    if (bdrv_is_owner(bs) == new_owner_state) {
+        term_printf("[set_cdrom_owner] IGNORED : no change to ownership %d\n", new_owner_state);
+        return;
+    }
+
+    bdrv_change_shared_owner(bs, new_owner_state);
+
+    term_printf("[set_cdrom_owner] done : (%d)\n", new_owner_state);
 }
 
 static void do_screen_dump(const char *filename)

@@ -1217,7 +1251,10 @@ static term_cmd_t term_cmds[] = {
       "filename", "save screen into PPM image 'filename'" },
     { "log", "s", do_log,
       "item1[,...]", "activate logging of the specified items to '/tmp/qemu.log'" }, 
-#ifndef CONFIG_DM
+#ifdef CONFIG_DM
+    { "set_cdrom_owner", "sB", do_set_cdrom_owner,
+      "<1|0> device", "1 to become the owner and acquire the physical drive or 0 to release it and no longer be the owner" },
+#else
     { "savevm", "s?", do_savevm,
       "tag|id", "save a VM snapshot. If no tag or id are provided, a new snapshot is created" }, 
     { "loadvm", "s", do_loadvm,

diff -r 7953164cebb6 tools/ioemu/vl.c
@@ -6436,6 +6436,7 @@ enum {
     QEMU_OPTION_hdd,
     QEMU_OPTION_cdrom,
 #endif /* !CONFIG_DM */
+    QEMU_OPTION_cdrom_shared_with_eject,
     QEMU_OPTION_boot,
     QEMU_OPTION_snapshot,
 #ifdef TARGET_I386

@@ -6519,6 +6520,7 @@ const QEMUOption qemu_options[] = {
     { "hdd", HAS_ARG, QEMU_OPTION_hdd },
     { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
 #endif /* !CONFIG_DM */
+    { "cdrom-shared-with-eject", 0, QEMU_OPTION_cdrom_shared_with_eject },
     { "boot", HAS_ARG, QEMU_OPTION_boot },
     { "snapshot", 0, QEMU_OPTION_snapshot },
 #ifdef TARGET_I386

@@ -7279,6 +7281,9 @@ int main(int argc, char **argv)
                 }
                 break;
 #endif /* !CONFIG_DM */
+            case QEMU_OPTION_cdrom_shared_with_eject:
+               // XXX Temporarily ignore this option
+               break;
             case QEMU_OPTION_boot:
                 boot_device = strdup(optarg);
                 if (strspn(boot_device, "a"

diff -r 7953164cebb6 tools/ioemu/vl.h
@@ -678,10 +678,14 @@ void bdrv_set_geometry_hint(BlockDriverS
                             int cyls, int heads, int secs);
 void bdrv_set_type_hint(BlockDriverState *bs, int type);
 void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
+void bdrv_set_shared_owner_hint(BlockDriverState *bs, int is_owner);
+void bdrv_change_shared_owner(BlockDriverState *bs, int new_owner_state);
 void bdrv_get_geometry_hint(BlockDriverState *bs, 
                             int *pcyls, int *pheads, int *psecs);
 int bdrv_get_type_hint(BlockDriverState *bs);
 int bdrv_get_translation_hint(BlockDriverState *bs);
+int bdrv_is_shared(BlockDriverState *bs);
+int bdrv_is_owner(BlockDriverState *bs);
 int bdrv_is_removable(BlockDriverState *bs);
 int bdrv_is_read_only(BlockDriverState *bs);
 int bdrv_is_inserted(BlockDriverState *bs);

@@ -700,6 +704,7 @@ void bdrv_iterate_format(void (*it)(void
 void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 
                          void *opaque);
 const char *bdrv_get_device_name(BlockDriverState *bs);
+const char *bdrv_get_filename(BlockDriverState *bs);
 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, 
                           const uint8_t *buf, int nb_sectors);
 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);

diff -r 7953164cebb6 tools/ioemu/xenstore.c
@@ -85,6 +85,7 @@ void xenstore_parse_domain_config(int do
         *dev = NULL, *params = NULL, *type = NULL;
     int i, is_scsi;
     unsigned int len, num, hd_index;
+    int is_cdrom_shared_with_eject, is_cdrom_owner;
 
     for(i = 0; i < MAX_DISKS + MAX_SCSI_DISKS; i++)
         media_filename[i] = NULL;

@@ -166,10 +167,29 @@ void xenstore_parse_domain_config(int do
 
         bs_table[hd_index + (is_scsi ? MAX_DISKS : 0)] = bdrv_new(dev);
         /* check if it is a cdrom */
-        if (type && !strcmp(type, "cdrom")) {
+       if (type && !strcmp(type, "cdrom")) {
+             is_cdrom_shared_with_eject = is_cdrom_owner = 0;
+             /* read the cdrom param is_cdrom_shared_with_eject (if any) */
+             if (pasprintf(&buf, "%s/device/vbd/%s/cdrom-shared-witheject", path, e[i]) == -1)
+                 continue;
+             free(type);
+             type = xs_read(xsh, XBT_NULL, buf, &len);
+             if (type != NULL)
+                 is_cdrom_shared_with_eject = (atoi(type))?1:0;
+             /* read the cdrom param is_cdrom_shared_with_eject (if any) */
+             if (pasprintf(&buf, "%s/device/vbd/%s/cdrom-owner", path, e[i]) == -1)
+                 continue;
+             free(type);
+             type = xs_read(xsh, XBT_NULL, buf, &len);
+             if (type != NULL)
+                 is_cdrom_owner = (atoi(type))?1:0;
+             /* indicate that this device is a cdrom */
             bdrv_set_type_hint(bs_table[hd_index], BDRV_TYPE_CDROM);
-            if (pasprintf(&buf, "%s/params", bpath) != -1)
-                xs_watch(xsh, buf, dev);
+             if (is_cdrom_shared_with_eject)
+                 bdrv_set_shared_owner_hint(bs_table[hd_index], is_cdrom_owner);
+
+             if (pasprintf(&buf, "%s/params", bpath) != -1)
+                  xs_watch(xsh, buf, dev);
         }
         /* open device now if media present */
         if (params[0]) {