On Jul 28, 2006, at 6:07 PM, Hollis Blanchard wrote:
As a very brief recap, we're looking at how best to construct the
Not sure we would ever do Virtual IO in the devtree, all that
discovery is so XenStore/Bus right now it may be hard to decouple.
tree when constructing a new DomU.
At the Xen minisummit in Ottawa, Ewan recommended constructing the
device tree in python, since the xend level of the tools has access to
information like total memory size, virtual IO devices, etc.
will be easier to mine information like timebase-frequency from dom0's
device tree (to pass in to domU) from python than from C.
I agree, python should certainly make it easier to "suck up" /proc/
device-tree "nodes" into the devtree.
So I've got some python that can create a flattened tree.
Caution: I say this only because I have yet to see the python
interfaces Hollis is writing.
This could be a lot of work, the devtree is a difficult WOS (Wad O'
Stuff), things like properties that are "backreferences" to nodes
that may or may not have been created yet.
It may be difficult to get this right, we need to be careful how much
we invest in new code to handle this, when perhaps existing tools may
be invested in.
The only catch
is that some information, notably the console_mfn and store_mfn, is
*returned* from libxc to python, so we can't actually insert that
information into the tree from python before calling libxc.
Classically console_mfn, store_mfn are "allocated" from the memory of
the new domain by libxc, by allocated I mean they are "chosen", example:
x86_*: they are the next pages after all images are loaded.
ia64: they are the first few pages of domain memory.
ppc: the last few pages of the RMA
The shared_info page can com from "Xen Space" and the domain is
allowed to map it, on PPC it is always the last page of the RMA.
We make sure that these pages are in the RMA so we can access them in
real mode, particularly the console_mfn and event channel array.
So there is really no reason that the python layer cannot define
these, the current definition libxc definition are a hack anyway.
Once we go beyond RMA we will need to teach the python layers about RMA.
The only real issue is the ramdisk, libxc currently decides where it
is, and you need some rudimentary elf parsing to figure out where to
actually put it, but ultimately its location and size need to be in
We also need to consider that as we hotplug things they will end up
in the the DomU's /proc/device-tree and on reboot, checkpoint or
migration, we will need to make sure that all this information is
preserved and recreated. Whether thats thru another flattened
devtree, or a devtree created from some other Xen specific "state" file.
I see a couple options:
1. Write a bunch of flat tree to have libxc parse and insert /xen/
properties. That could involve refactoring dtc, which may be
or just hacking up our own.
2. Create empty /xen/*_mfn properties in python, and then overwrite
in libxc. Probably easier than 1.
3. Change the libxc interface somehow to allow xend to pass the mfn
parameters to libxc and not the other way around. I haven't
this one yet; I'm not sure if that will work out for x86/ia64.
For completeness, there is a 4th option:
4. Have the python create an ascii file that is the source file
DTS for a tool called the Device Tree Compiler. Then have the python
exec the DTC to create the devtree
The problem with 4 is that it is unclear what the future of the DTC
is, some people in embedded are using it but its not part of any
distro, it does not seem to be embraced by the kexec community and
its yet another orthogonal package we will have to maintain.
Personally, I like the DTC, but until the linuxPPC community is
willing to stand and fully depend on it, I cannot expect the XenPPC
Xen-ppc-devel mailing list