Initialize the xenstore MFN for VMX domains

Signed-off-by: Arun Sharma <arun.sharma@intel.com>
Signed-off-by: Christian Limpach <Christian.Limpach@cl.cam.ac.uk>

tools/python/xen/lowlevel/xc/xc.c

@@ -297,22 +297,23 @@ static PyObject *pyxc_vmx_build(PyObject *self,
     u32   dom;
     char *image, *ramdisk = NULL, *cmdline = "";
     PyObject *memmap;
-    int   control_evtchn, flags = 0;
+    int   control_evtchn, store_evtchn;
+    int flags = 0, vcpus = 1;
     int numItems, i;
     int memsize;
     struct mem_map mem_map;
+    unsigned long store_mfn = 0;
 
-    static char *kwd_list[] = { "dom", "control_evtchn",
-                                "memsize",
-                                "image", "memmap",
+    static char *kwd_list[] = { "dom", "control_evtchn", "store_evtchn",
+                                "memsize", "image", "memmap",
 				"ramdisk", "cmdline", "flags",
-                                NULL };
+				"vcpus", NULL };
 
-    if ( !PyArg_ParseTupleAndKeywords(args, kwds, "iiisO!|ssi", kwd_list, 
-                                      &dom, &control_evtchn, 
+    if ( !PyArg_ParseTupleAndKeywords(args, kwds, "iiiisO!|ssii", kwd_list, 
+                                      &dom, &control_evtchn, &store_evtchn,
                                       &memsize,
                                       &image, &PyList_Type, &memmap,
-				      &ramdisk, &cmdline, &flags) )
+				      &ramdisk, &cmdline, &flags, &vcpus) )
         return NULL;
 
     memset(&mem_map, 0, sizeof(mem_map));
@@ -321,7 +322,6 @@ static PyObject *pyxc_vmx_build(PyObject *self,
     /* get the number of lines passed to us */
     numItems = PyList_Size(memmap) - 1;	/* removing the line 
 					   containing "memmap" */
-    printf ("numItems: %d\n", numItems);
     mem_map.nr_map = numItems;
    
     /* should raise an error here. */
@@ -365,11 +365,11 @@ static PyObject *pyxc_vmx_build(PyObject *self,
     }
 
     if ( xc_vmx_build(xc->xc_handle, dom, memsize, image, &mem_map,
-                        ramdisk, cmdline, control_evtchn, flags) != 0 )
+                        ramdisk, cmdline, control_evtchn, flags,
+                        vcpus, store_evtchn, &store_mfn) != 0 )
         return PyErr_SetFromErrno(xc_error);
     
-    Py_INCREF(zero);
-    return zero;
+    return Py_BuildValue("{s:i}", "store_mfn", store_mfn);
 }
 
 static PyObject *pyxc_bvtsched_global_set(PyObject *self,

tools/python/xen/xend/image.py

@@ -274,14 +274,24 @@ class VmxImageHandler(ImageHandler):
         # Create an event channel
         self.device_channel = channel.eventChannel(0, self.vm.getDomain())
         log.info("VMX device model port: %d", self.device_channel.port2)
-        return xc.vmx_build(dom            = self.vm.getDomain(),
+        if self.vm.store_channel:
+            store_evtchn = self.vm.store_channel.port2
+        else:
+            store_evtchn = 0
+        ret = xc.vmx_build(dom            = self.vm.getDomain(),
                             image          = self.kernel,
                             control_evtchn = self.device_channel.port2,
+                            store_evtchn   = store_evtchn,
                             memsize        = self.vm.memory,
                             memmap         = self.memmap_value,
                             cmdline        = self.cmdline,
                             ramdisk        = self.ramdisk,
-                            flags          = self.flags)
+                            flags          = self.flags,
+                            vcpus          = self.vm.vcpus)
+        if isinstance(ret, dict):
+            self.vm.store_mfn = ret.get('store_mfn')
+            return 0
+        return ret
 
     def parseMemmap(self):
         self.memmap = sxp.child_value(self.vm.config, "memmap")
@@ -387,7 +397,9 @@ class VmxImageHandler(ImageHandler):
         (pid, status) = os.waitpid(self.pid, 0)
 
     def getDomainMemory(self, mem_mb):
-        return (mem_mb * 1024) + self.getPageTableSize(mem_mb)
+        # for ioreq_t and xenstore
+        static_pages = 2
+        return (mem_mb * 1024) + self.getPageTableSize(mem_mb) + 4 * static_pages
             
     def getPageTableSize(self, mem_mb):
         """Return the size of memory needed for 1:1 page tables for physical