On Wed, Sep 14, 2016 at 7:35 AM, Ronald Rojas <ronlad...@gmail.com> wrote:
> Hi, I'm Ronald Rojas an undergraduate junior studying
> computer science at New York Unversity. I would like
> to apply fo the Xen projects Outreachy Program. After
> looking through the available projects I think I would
> be a good fit for creating the golang bindings for
> libxl. I'm proficient in C , familar with Golang, and
> very comfortable with linux. Would I be able to get a
> bit-sized task for the application process?
Ronald,
Thanks for your interest in the Xen Project! Sorry for the delay in
responding -- somehow your mail either never made it to my personal
inbox or I accidentally deleted it instead of filing it properly. I
saw your question on IRC and now found your mail here on xen-devel.
First, I want to emphasize that Outreachy internships should be
considered a full-time job. As part of the application process you
will be asked to confirm that you will not be taking any classes, nor
have any other significant commitments (such as another job) during
the period of the internship.
Now on to the bite-sized task. We've actually found that one of the
difficult parts of getting going with our project is making sure that
you understand how to get your whole system and environment set up.
And another thing we want to see is to what degree you can balance
figuring things out, finding the answers on the web, and asking for
help when you need it.
So with that in mind, we've started experimenting with tasks which
don't contribute very much to the project directly, but provide a
really solid base of knowledge to do further contributions.
So here's my challenge for you.
-------
OUTCOME
Attached is the very beginnings of a set of golang bindings that I
wrote for a project of my own. They contain an implementation of
Context.Open() and Context.ListCpupool().
Write a simple go program that will list the current cpu pools,
similar to the output of "xl cpupool-list". No need to handle extra
arguments or modify libxl.go (beyond what may be needed to compile it).
Please post a copy of your .go program, along with the results of
output *when more than one VM is running*.
STEPS
1. Set up a system running Linux
If you don't have one, Ubuntu, Fedora, or Debian should all be fine.
2. Download, build, and install the latest development
version of Xen. The following page should be useful:
https://wiki.xenproject.org/wiki/Compiling_Xen_From_Source
I would recommend using "make debball" or "make rpmball" over the
"make install".
3. You'll need to build an image for at least one guest VM.
There are tons of options here, but one really simple thing would be
to follow this HOWTO from a previous OPW intern:
https://umasharma17.wordpress.com/2015/02/13/creating-guests-using-xl-in-xen/
4. Write your go program
The go program will need to Open() the context, then call DomainInfo()
on the target domain ID, and output the required info based on "xl
list".
libxl.go uses cgo to compile a library against C. If you have the
libraries set up properly, the current version should just work.
------
That's it! Remember that the goal of this is to see how well you
balance figuring things out on your own vs asking questions. So try
to figure things out on your own, but when you run into a bit of
difficultly, don't hesitate to ask questions or clarification --
particularly at the beginning.
You can ask questions either here on xen-devel or on the #xendevel or
#xen-opw channels on freenode IRC.
Good luck,
-George
/*
* Copyright (C) 2016 George W. Dunlap, Citrix Systems UK Ltd
*
* 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; version 2 of the
* License only.
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/
package main
/*
#cgo LDFLAGS: -lyajl -lxenlight
#include <libxl.h>
#include <stdlib.h>
*/
import "C"
import (
"unsafe"
"fmt"
"time"
)
type Context struct {
ctx *C.libxl_ctx
}
var Ctx Context
func (Ctx *Context) IsOpen() bool {
return Ctx.ctx != nil
}
func (Ctx *Context) Open() (err error) {
if Ctx.ctx != nil {
return
}
ret := C.libxl_ctx_alloc(unsafe.Pointer(&Ctx.ctx), C.LIBXL_VERSION, 0, nil)
if ret != 0 {
err = fmt.Errorf("Allocating libxl context: %d", ret)
}
return
}
func (Ctx *Context) Close() (err error) {
ret := C.libxl_ctx_free(unsafe.Pointer(Ctx.ctx))
Ctx.ctx = nil
if ret != 0 {
err = fmt.Errorf("Freeing libxl context: %d", ret)
}
return
}
type Domid uint32
type MemKB uint64
// FIXME: Use the idl to generate types
type Dominfo struct {
// FIXME: uuid
Domid Domid
Running bool
Blocked bool
Paused bool
Shutdown bool
Dying bool
Never_stop bool
Shutdown_reason int32 // FIXME shutdown_reason enumeration
Outstanding_memkb MemKB
Current_memkb MemKB
Shared_memkb MemKB
Paged_memkb MemKB
Max_memkb MemKB
Cpu_time time.Duration
Vcpu_max_id uint32
Vcpu_online uint32
Cpupool uint32
Domain_type int32 //FIXME libxl_domain_type enumeration
}
func (Ctx *Context) DomainInfo(Id Domid) (di *Dominfo, err error) {
if Ctx.ctx == nil {
err = fmt.Errorf("Context not opened")
return
}
var cdi C.libxl_dominfo
ret := C.libxl_domain_info(Ctx.ctx, unsafe.Pointer(&cdi), C.uint32_t(Id))
// FIXME: IsDomainNotPresentError
if ret != 0 {
err = fmt.Errorf("libxl_domain_info failed: %d", ret)
return
}
// FIXME -- use introspection to make this more robust
di = &Dominfo{}
di.Domid = Domid(cdi.domid)
di.Running = bool(cdi.running)
di.Blocked = bool(cdi.blocked)
di.Paused = bool(cdi.paused)
di.Shutdown = bool(cdi.shutdown)
di.Dying = bool(cdi.dying)
di.Never_stop = bool(cdi.never_stop)
di.Shutdown_reason = int32(cdi.shutdown_reason)
di.Outstanding_memkb = MemKB(cdi.outstanding_memkb)
di.Current_memkb = MemKB(cdi.current_memkb)
di.Shared_memkb = MemKB(cdi.shared_memkb)
di.Paged_memkb = MemKB(cdi.paged_memkb)
di.Max_memkb = MemKB(cdi.max_memkb)
di.Cpu_time = time.Duration(cdi.cpu_time)
di.Vcpu_max_id = uint32(cdi.vcpu_max_id)
di.Vcpu_online = uint32(cdi.vcpu_online)
di.Cpupool = uint32(cdi.cpupool)
di.Domain_type = int32(cdi.domain_type)
return
}
func (Ctx *Context) DomainUnpause(Id Domid) (err error) {
if Ctx.ctx == nil {
err = fmt.Errorf("Context not opened")
return
}
ret := C.libxl_domain_unpause(Ctx.ctx, C.uint32_t(Id))
if ret != 0 {
err = fmt.Errorf("libxl_domain_unpause failed: %d", ret)
}
return
}
// typedef struct {
// uint32_t size; /* number of bytes in map */
// uint8_t *map;
// } libxl_bitmap;
// void libxl_bitmap_init(libxl_bitmap *map);
// void libxl_bitmap_dispose(libxl_bitmap *map);
// # Consistent with values defined in domctl.h
// # Except unknown which we have made up
// libxl_scheduler = Enumeration("scheduler", [
// (0, "unknown"),
// (4, "sedf"),
// (5, "credit"),
// (6, "credit2"),
// (7, "arinc653"),
// (8, "rtds"),
// ])
type Scheduler int
var (
SchedulerUnknown Scheduler = 0
SchedulerSedf Scheduler = 4
SchedulerCredit Scheduler = 5
SchedulerCredit2 Scheduler = 6
SchedulerArinc653 Scheduler = 7
SchedulerRTDS Scheduler = 8
)
// const char *libxl_scheduler_to_string(libxl_scheduler p);
// int libxl_scheduler_from_string(const char *s, libxl_scheduler *e);
func (s Scheduler) String() (string) {
cs := C.libxl_scheduler_to_string(C.libxl_scheduler(s))
// No need to free const return value
return C.GoString(cs)
}
func SchedulerFromString(name string) (s Scheduler, err error) {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
var cs C.libxl_scheduler
ret := C.libxl_scheduler_from_string(cname, &cs)
if ret != 0 {
err = fmt.Errorf("libxl_scheduler_from_string failed: %d", ret)
return
}
s = Scheduler(cs)
return
}
// libxl_cpupoolinfo = Struct("cpupoolinfo", [
// ("poolid", uint32),
// ("pool_name", string),
// ("sched", libxl_scheduler),
// ("n_dom", uint32),
// ("cpumap", libxl_bitmap)
// ], dir=DIR_OUT)
type CpupoolInfo struct {
PoolId uint32
PoolName string
Scheduler Scheduler
DomainCount int
// Punt on cpumap for now
}
// libxl_cpupoolinfo * libxl_list_cpupool(libxl_ctx*, int *nb_pool_out);
// void libxl_cpupoolinfo_list_free(libxl_cpupoolinfo *list, int nb_pool);
func (Ctx *Context) ListCpupool() (list []CpupoolInfo) {
var nbPool C.int
c_cpupool_list := C.libxl_list_cpupool(Ctx.ctx, &nbPool)
defer C.libxl_cpupoolinfo_list_free(c_cpupool_list, nbPool)
if int(nbPool) == 0 {
return
}
// Magic
cpupoolListSlice := (*[1 << 30]C.libxl_cpupoolinfo)(unsafe.Pointer(c_cpupool_list))[:nbPool:nbPool]
for i := range cpupoolListSlice {
var info CpupoolInfo
info.PoolId = uint32(cpupoolListSlice[i].poolid)
info.PoolName = C.GoString(cpupoolListSlice[i].pool_name)
info.Scheduler = Scheduler(cpupoolListSlice[i].sched)
info.DomainCount = int(cpupoolListSlice[i].n_dom)
list = append(list, info)
}
return
}
func (Ctx *Context) CpupoolFindByName(name string) (info CpupoolInfo, found bool) {
plist := Ctx.ListCpupool()
for i := range plist {
if plist[i].PoolName == name {
found = true
info = plist[i]
return
}
}
return
}
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
