Reduce domid to 32 bits only -- more than enough.
if len( sys.argv ) > 2 and re.match('\d+$', sys.argv[2]):
- dom = long(sys.argv[2])
+ dom = int(sys.argv[2])
if cmd == 'stop':
rc = xc.domain_stop( dom=dom )
int xc_interface_close(int xc_handle);
typedef struct {
- u64 domid;
+ u32 domid;
unsigned int cpu;
int has_cpu;
int stopped;
unsigned int mem_kb,
const char *name,
int cpu,
- u64 *pdomid);
+ u32 *pdomid);
int xc_domain_start(int xc_handle,
- u64 domid);
+ u32 domid);
int xc_domain_stop(int xc_handle,
- u64 domid);
+ u32 domid);
int xc_domain_destroy(int xc_handle,
- u64 domid,
+ u32 domid,
int force);
int xc_domain_pincpu(int xc_handle,
- u64 domid,
+ u32 domid,
int cpu);
int xc_domain_getinfo(int xc_handle,
- u64 first_domid,
+ u32 first_domid,
unsigned int max_doms,
xc_dominfo_t *info);
int xc_shadow_control(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int sop,
unsigned long *dirty_bitmap,
unsigned long pages,
#define XCFLAGS_DEBUG 4
int xc_linux_save(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int flags,
int (*writerfn)(void *, const void *, size_t),
void *writerst );
int xc_linux_restore(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int flags,
int (*readerfn)(void *, void *, size_t),
void *readerst,
- u64 *pdomid);
+ u32 *pdomid);
int xc_linux_build(int xc_handle,
- u64 domid,
+ u32 domid,
const char *image_name,
const char *ramdisk_name,
const char *cmdline,
unsigned int control_evtchn);
int xc_netbsd_build(int xc_handle,
- u64 domid,
+ u32 domid,
const char *image_name,
const char *cmdline,
unsigned int control_evtchn);
unsigned long ctx_allow);
int xc_bvtsched_domain_set(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned long mcuadv,
unsigned long warp,
unsigned long warpl,
unsigned long *ctx_allow);
int xc_bvtsched_domain_get(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned long *mcuadv,
unsigned long *warp,
unsigned long *warpl,
unsigned long *warpu);
int xc_atropos_domain_set(int xc_handle,
- u64 domid,
+ u32 domid,
u64 period, u64 slice, u64 latency,
int xtratime);
int xc_atropos_domain_get(int xc_handle,
- u64 domid,
+ u32 domid,
u64* period, u64 *slice, u64 *latency,
int *xtratime);
} xc_vif_stats_t;
int xc_vif_scheduler_set(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int vifid,
xc_vif_sched_params_t *params);
int xc_vif_scheduler_get(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int vifid,
xc_vif_sched_params_t *params);
int xc_vif_stats_get(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int vifid,
xc_vif_stats_t *stats);
typedef struct {
-#define XC_VBDDOM_PROBE_ALL (~0ULL)
- u64 domid;
+#define XC_VBDDOM_PROBE_ALL (0x7FFFFFFFU)
+ u32 domid;
unsigned short vbdid;
#define XC_VBDF_WRITEABLE (1<<0)
unsigned long flags;
} xc_physinfo_t;
int xc_vbd_create(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned short vbdid,
int writeable);
int xc_vbd_destroy(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned short vbdid);
int xc_vbd_grow(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned short vbdid,
xc_vbdextent_t *extent);
int xc_vbd_shrink(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned short vbdid);
int xc_vbd_setextents(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned short vbdid,
unsigned int nr_extents,
xc_vbdextent_t *extents);
int xc_vbd_getextents(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned short vbdid,
unsigned int max_extents,
xc_vbdextent_t *extents,
int *writeable);
int xc_vbd_probe(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int max_vbds,
xc_vbd_t *vbds);
-#define DOMID_SELF (~1ULL)
+#define DOMID_SELF (0x7FFFFFFEU)
typedef struct {
#define EVTCHNSTAT_closed 0 /* Chennel is not in use. */
int status;
union {
struct {
- u64 dom;
+ u32 dom;
int port;
} interdomain;
int pirq;
} xc_evtchn_status_t;
int xc_evtchn_bind_interdomain(int xc_handle,
- u64 dom1, /* may be DOMID_SELF */
- u64 dom2, /* may be DOMID_SELF */
+ u32 dom1, /* may be DOMID_SELF */
+ u32 dom2, /* may be DOMID_SELF */
int *port1,
int *port2);
int xc_evtchn_close(int xc_handle,
- u64 dom, /* may be DOMID_SELF */
+ u32 dom, /* may be DOMID_SELF */
int port);
int xc_evtchn_send(int xc_handle,
int local_port);
int xc_evtchn_status(int xc_handle,
- u64 dom, /* may be DOMID_SELF */
+ u32 dom, /* may be DOMID_SELF */
int port,
xc_evtchn_status_t *status);
int xc_physdev_pci_access_modify(int xc_handle,
- u64 domid,
+ u32 domid,
int bus,
int dev,
int func,
xc_physinfo_t *info);
int xc_domain_setname(int xc_handle,
- u64 domid,
+ u32 domid,
char *name);
int xc_domain_setinitialmem(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int initial_memkb);
int xc_domain_setmaxmem(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int max_memkb);
#include "xc_private.h"
int xc_atropos_domain_set(int xc_handle,
- u64 domid, u64 period, u64 slice, u64 latency,
+ u32 domid, u64 period, u64 slice, u64 latency,
int xtratime)
{
dom0_op_t op;
return do_dom0_op(xc_handle, &op);
}
-int xc_atropos_domain_get(int xc_handle, u64 domid, u64 *period,
+int xc_atropos_domain_get(int xc_handle, u32 domid, u64 *period,
u64 *slice, u64 *latency, int *xtratime)
{
dom0_op_t op;
}
int xc_bvtsched_global_get(int xc_handle,
- unsigned long *ctx_allow)
+ unsigned long *ctx_allow)
{
dom0_op_t op;
int ret;
}
int xc_bvtsched_domain_set(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned long mcuadv,
unsigned long warp,
unsigned long warpl,
int xc_bvtsched_domain_get(int xc_handle,
- u64 domid,
- unsigned long *mcuadv,
- unsigned long *warp,
+ u32 domid,
+ unsigned long *mcuadv,
+ unsigned long *warp,
unsigned long *warpl,
unsigned long *warpu)
{
int xc_domain_create(int xc_handle,
unsigned int mem_kb,
const char *name,
- int cpu,
- u64 *pdomid)
+ int cpu,
+ u32 *pdomid)
{
int err;
dom0_op_t op;
op.u.createdomain.cpu = cpu;
if ( (err = do_dom0_op(xc_handle, &op)) == 0 )
- *pdomid = (u64)op.u.createdomain.domain;
+ *pdomid = (u32)op.u.createdomain.domain;
return err;
}
int xc_domain_start(int xc_handle,
- u64 domid)
+ u32 domid)
{
dom0_op_t op;
op.cmd = DOM0_STARTDOMAIN;
int xc_domain_stop(int xc_handle,
- u64 domid)
+ u32 domid)
{
dom0_op_t op;
op.cmd = DOM0_STOPDOMAIN;
op.u.stopdomain.domain = (domid_t)domid;
- op.u.stopdomain.sync = 0; // async
+ op.u.stopdomain.sync = 0; /* async */
return do_dom0_op(xc_handle, &op);
}
int xc_domain_destroy(int xc_handle,
- u64 domid,
+ u32 domid,
int force)
{
dom0_op_t op;
}
int xc_domain_pincpu(int xc_handle,
- u64 domid,
+ u32 domid,
int cpu)
{
dom0_op_t op;
int xc_domain_getinfo(int xc_handle,
- u64 first_domid,
+ u32 first_domid,
unsigned int max_doms,
xc_dominfo_t *info)
{
unsigned int nr_doms;
- u64 next_domid = first_domid;
+ u32 next_domid = first_domid;
dom0_op_t op;
for ( nr_doms = 0; nr_doms < max_doms; nr_doms++ )
{
op.cmd = DOM0_GETDOMAININFO;
op.u.getdomaininfo.domain = (domid_t)next_domid;
- op.u.getdomaininfo.ctxt = NULL; // no exec context info, thanks.
+ op.u.getdomaininfo.ctxt = NULL; /* no exec context info, thanks. */
if ( do_dom0_op(xc_handle, &op) < 0 )
break;
- info->domid = (u64)op.u.getdomaininfo.domain;
+ info->domid = (u32)op.u.getdomaininfo.domain;
info->cpu = op.u.getdomaininfo.processor;
info->has_cpu = op.u.getdomaininfo.has_cpu;
info->stopped = (op.u.getdomaininfo.state == DOMSTATE_STOPPED);
strncpy(info->name, op.u.getdomaininfo.name, XC_DOMINFO_MAXNAME);
info->name[XC_DOMINFO_MAXNAME-1] = '\0';
- next_domid = (u64)op.u.getdomaininfo.domain + 1;
+ next_domid = (u32)op.u.getdomaininfo.domain + 1;
info++;
}
}
int xc_shadow_control(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int sop,
- unsigned long *dirty_bitmap,
- unsigned long pages,
- unsigned long *fault_count,
- unsigned long *dirty_count)
+ unsigned long *dirty_bitmap,
+ unsigned long pages,
+ unsigned long *fault_count,
+ unsigned long *dirty_count)
{
int rc;
dom0_op_t op;
rc = do_dom0_op(xc_handle, &op);
- if(fault_count) *fault_count = op.u.shadow_control.fault_count;
- if(dirty_count) *dirty_count = op.u.shadow_control.dirty_count;
+ if ( fault_count )
+ *fault_count = op.u.shadow_control.fault_count;
+ if ( dirty_count )
+ *dirty_count = op.u.shadow_control.dirty_count;
- if ( rc == 0 )
- return op.u.shadow_control.pages;
- else
- return rc;
+ return (rc == 0) ? op.u.shadow_control.pages : rc;
}
int xc_domain_setname(int xc_handle,
- u64 domid,
- char *name)
+ u32 domid,
+ char *name)
{
dom0_op_t op;
op.cmd = DOM0_SETDOMAINNAME;
}
int xc_domain_setinitialmem(int xc_handle,
- u64 domid,
- unsigned int initial_memkb)
+ u32 domid,
+ unsigned int initial_memkb)
{
dom0_op_t op;
op.cmd = DOM0_SETDOMAININITIALMEM;
}
int xc_domain_setmaxmem(int xc_handle,
- u64 domid,
- unsigned int max_memkb)
+ u32 domid,
+ unsigned int max_memkb)
{
dom0_op_t op;
op.cmd = DOM0_SETDOMAINMAXMEM;
}
int xc_evtchn_bind_interdomain(int xc_handle,
- u64 dom1,
- u64 dom2,
+ u32 dom1,
+ u32 dom2,
int *port1,
int *port2)
{
int xc_evtchn_close(int xc_handle,
- u64 dom,
+ u32 dom,
int port)
{
evtchn_op_t op;
int xc_evtchn_status(int xc_handle,
- u64 dom,
+ u32 dom,
int port,
xc_evtchn_status_t *status)
{
switch ( status->status = op.u.status.status )
{
case EVTCHNSTAT_interdomain:
- status->u.interdomain.dom = (u64)op.u.status.u.interdomain.dom;
+ status->u.interdomain.dom = (u32)op.u.status.u.interdomain.dom;
status->u.interdomain.port = op.u.status.u.interdomain.port;
break;
case EVTCHNSTAT_pirq:
static int loadelfimage(char *elfbase, int pmh, unsigned long *parray,
unsigned long vstart);
-static long get_tot_pages(int xc_handle, u64 domid)
+static long get_tot_pages(int xc_handle, u32 domid)
{
dom0_op_t op;
op.cmd = DOM0_GETDOMAININFO;
}
static int get_pfn_list(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned long *pfn_buf,
unsigned long max_pfns)
{
}
static int setup_guestos(int xc_handle,
- u64 dom,
+ u32 dom,
char *image, unsigned long image_size,
gzFile initrd_gfd, unsigned long initrd_len,
unsigned long nr_pages,
unsigned long *pvsi, unsigned long *pvke,
- full_execution_context_t *ctxt,
+ full_execution_context_t *ctxt,
const char *cmdline,
unsigned long shared_info_frame,
unsigned int control_evtchn)
}
int xc_linux_build(int xc_handle,
- u64 domid,
+ u32 domid,
const char *image_name,
const char *ramdisk_name,
const char *cmdline,
op.u.getdomaininfo.domain = (domid_t)domid;
op.u.getdomaininfo.ctxt = ctxt;
if ( (do_dom0_op(xc_handle, &op) < 0) ||
- ((u64)op.u.getdomaininfo.domain != domid) )
+ ((u32)op.u.getdomaininfo.domain != domid) )
{
PERROR("Could not get info on domain");
goto error_out;
} while ( 0 )
static int get_pfn_list(int xc_handle,
- u64 domain_id,
+ u32 domain_id,
unsigned long *pfn_buf,
unsigned long max_pfns)
{
int xc_linux_restore(int xc_handle,
- u64 dom,
+ u32 dom,
unsigned int flags,
- int (*readerfn)(void *, void *, size_t),
- void *readerst,
- u64 *pdomid)
+ int (*readerfn)(void *, void *, size_t),
+ void *readerst,
+ u32 *pdomid)
{
dom0_op_t op;
int rc = 1, i, j, n, k;
if ( mlock(&ctxt, sizeof(ctxt) ) )
{
/* needed for when we do the build dom0 op,
- but might as well do early */
+ but might as well do early */
PERROR("Unable to mlock ctxt");
return 1;
}
region_mfn = calloc(1, 4 * MAX_BATCH_SIZE);
if ( (pfn_to_mfn_table == NULL) || (pfn_type == NULL) ||
- (region_mfn == NULL) )
+ (region_mfn == NULL) )
{
errno = ENOMEM;
goto out;
/* Set the domain's initial memory allocation
to that from the restore file */
- if ( xc_domain_setinitialmem( xc_handle, dom, nr_pfns * (PAGE_SIZE / 1024)) )
+ if ( xc_domain_setinitialmem(xc_handle, dom,
+ nr_pfns * (PAGE_SIZE / 1024)) )
{
ERROR("Could not set domain initial memory");
goto out;
n=0;
while(1)
{
- int j;
- unsigned long region_pfn_type[MAX_BATCH_SIZE];
+ int j;
+ unsigned long region_pfn_type[MAX_BATCH_SIZE];
this_pc = (n * 100) / nr_pfns;
if ( (this_pc - prev_pc) >= 5 )
goto out;
}
- DPRINTF("batch %d\n",j);
-
- if (j == -1)
- {
- verify = 1;
- printf("Entering page verify mode\n");
- continue;
- }
-
- if (j == 0)
- {
- break; // our work here is done
- }
-
- if( j > MAX_BATCH_SIZE )
- {
- ERROR("Max batch size exceeded. Giving up.");
- goto out;
- }
-
+ DPRINTF("batch %d\n",j);
+
+ if ( j == -1 )
+ {
+ verify = 1;
+ printf("Entering page verify mode\n");
+ continue;
+ }
+
+ if ( j == 0 )
+ break; /* our work here is done */
+
+ if( j > MAX_BATCH_SIZE )
+ {
+ ERROR("Max batch size exceeded. Giving up.");
+ goto out;
+ }
+
if ( (*readerfn)(readerst, region_pfn_type, j*sizeof(unsigned long)) )
{
ERROR("Error when reading from state file");
goto out;
}
- for(i=0;i<j;i++)
- {
+ for(i=0;i<j;i++)
+ {
if ( (region_pfn_type[i] & LTAB_MASK) == XTAB)
- region_mfn[i] = 0; // we know map will fail, but don't care
- else
- {
- pfn = region_pfn_type[i] & ~LTAB_MASK;
- region_mfn[i] = pfn_to_mfn_table[pfn];
- }
- }
-
- if ( (region_base = mfn_mapper_map_batch( xc_handle, dom,
- PROT_WRITE,
- region_mfn,
- j )) == 0)
- {
- PERROR("map batch failed");
- goto out;
- }
-
- for(i=0;i<j;i++)
- {
- unsigned long *ppage;
-
- pfn = region_pfn_type[i] & ~LTAB_MASK;
+ {
+ region_mfn[i] = 0; /* we know map will fail, but don't care */
+ }
+ else
+ {
+ pfn = region_pfn_type[i] & ~LTAB_MASK;
+ region_mfn[i] = pfn_to_mfn_table[pfn];
+ }
+ }
+
+ if ( (region_base = mfn_mapper_map_batch( xc_handle, dom,
+ PROT_WRITE,
+ region_mfn,
+ j )) == 0)
+ {
+ PERROR("map batch failed");
+ goto out;
+ }
+
+ for(i=0;i<j;i++)
+ {
+ unsigned long *ppage;
+
+ pfn = region_pfn_type[i] & ~LTAB_MASK;
if ( (region_pfn_type[i] & LTAB_MASK) == XTAB)
- continue;
+ continue;
if (pfn>nr_pfns)
- {
- ERROR("pfn out of range");
- goto out;
- }
-
- region_pfn_type[i] &= LTAB_MASK;
-
- pfn_type[pfn] = region_pfn_type[i];
-
- mfn = pfn_to_mfn_table[pfn];
-
- if ( verify )
- ppage = (unsigned long*) buf; // debug case
- else
- ppage = (unsigned long*) (region_base + i*PAGE_SIZE);
-
- if ( (*readerfn)(readerst, ppage, PAGE_SIZE) )
- {
- ERROR("Error when reading from state file");
- goto out;
- }
-
- switch( region_pfn_type[i] )
- {
- case 0:
- break;
-
- case L1TAB:
- {
- for ( k = 0; k < 1024; k++ )
- {
- if ( ppage[k] & _PAGE_PRESENT )
- {
- xpfn = ppage[k] >> PAGE_SHIFT;
-
- if ( xpfn >= nr_pfns )
- {
- ERROR("Frame number in type %d page table is out of range. i=%d k=%d pfn=0x%x nr_pfns=%d",region_pfn_type[i]>>28,i,k,xpfn,nr_pfns);
- goto out;
- }
-
- ppage[k] &= (PAGE_SIZE - 1) & ~(_PAGE_GLOBAL | _PAGE_PAT);
- ppage[k] |= pfn_to_mfn_table[xpfn] << PAGE_SHIFT;
- }
- }
- }
- break;
-
- case L2TAB:
- {
- for ( k = 0; k < (HYPERVISOR_VIRT_START>>L2_PAGETABLE_SHIFT); k++ )
- {
- if ( ppage[k] & _PAGE_PRESENT )
- {
- xpfn = ppage[k] >> PAGE_SHIFT;
-
- if ( xpfn >= nr_pfns )
- {
- ERROR("Frame number in type %d page table is out of range. i=%d k=%d pfn=%d nr_pfns=%d",region_pfn_type[i]>>28,i,k,xpfn,nr_pfns);
-
- goto out;
- }
-
- ppage[k] &= (PAGE_SIZE - 1) & ~(_PAGE_GLOBAL | _PAGE_PSE);
- ppage[k] |= pfn_to_mfn_table[xpfn] << PAGE_SHIFT;
- }
- }
- }
- break;
-
- default:
- ERROR("Bogus page type %x page table is out of range. i=%d nr_pfns=%d",region_pfn_type[i],i,nr_pfns);
- goto out;
-
- } // end of page type switch statement
-
- if ( verify )
- {
- int res = memcmp(buf, (region_base + i*PAGE_SIZE), PAGE_SIZE );
- if (res)
- {
- int v;
- printf("************** pfn=%x type=%x gotcs=%08lx actualcs=%08lx\n",pfn,pfn_type[pfn],csum_page(region_base + i*PAGE_SIZE),csum_page(buf));
- for(v=0;v<4;v++)
- {
- unsigned long * p = (unsigned long *) (region_base + i*PAGE_SIZE);
- if ( buf[v] != p[v] )
- printf(" %d: %08lx %08lx\n",
- v, buf[v], p[v] );
- }
-
- }
- }
-
- if ( add_mmu_update(xc_handle, mmu,
- (mfn<<PAGE_SHIFT) | MMU_MACHPHYS_UPDATE, pfn) )
- {
- printf("machpys mfn=%ld pfn=%ld\n",mfn,pfn);
- goto out;
- }
-
- } // end of 'batch' for loop
-
- munmap( region_base, j*PAGE_SIZE );
- n+=j; // crude stats
+ {
+ ERROR("pfn out of range");
+ goto out;
+ }
+
+ region_pfn_type[i] &= LTAB_MASK;
+
+ pfn_type[pfn] = region_pfn_type[i];
+
+ mfn = pfn_to_mfn_table[pfn];
+
+ if ( verify )
+ ppage = (unsigned long*) buf; /* debug case */
+ else
+ ppage = (unsigned long*) (region_base + i*PAGE_SIZE);
+
+ if ( (*readerfn)(readerst, ppage, PAGE_SIZE) )
+ {
+ ERROR("Error when reading from state file");
+ goto out;
+ }
+
+ switch( region_pfn_type[i] )
+ {
+ case 0:
+ break;
+
+ case L1TAB:
+ {
+ for ( k = 0; k < 1024; k++ )
+ {
+ if ( ppage[k] & _PAGE_PRESENT )
+ {
+ xpfn = ppage[k] >> PAGE_SHIFT;
+
+ if ( xpfn >= nr_pfns )
+ {
+ ERROR("Frame number in type %d page table is "
+ "out of range. i=%d k=%d pfn=0x%x "
+ "nr_pfns=%d", region_pfn_type[i]>>28, i,
+ k, xpfn,nr_pfns);
+ goto out;
+ }
+
+ ppage[k] &= (PAGE_SIZE - 1) &
+ ~(_PAGE_GLOBAL | _PAGE_PAT);
+ ppage[k] |= pfn_to_mfn_table[xpfn] << PAGE_SHIFT;
+ }
+ }
+ }
+ break;
+
+ case L2TAB:
+ {
+ for ( k = 0;
+ k < (HYPERVISOR_VIRT_START>>L2_PAGETABLE_SHIFT);
+ k++ )
+ {
+ if ( ppage[k] & _PAGE_PRESENT )
+ {
+ xpfn = ppage[k] >> PAGE_SHIFT;
+
+ if ( xpfn >= nr_pfns )
+ {
+ ERROR("Frame number in type %d page table is "
+ "out of range. i=%d k=%d pfn=%d nr_pfns=%d",
+ region_pfn_type[i]>>28, i, k, xpfn, nr_pfns);
+
+ goto out;
+ }
+
+ ppage[k] &= (PAGE_SIZE - 1) &
+ ~(_PAGE_GLOBAL | _PAGE_PSE);
+ ppage[k] |= pfn_to_mfn_table[xpfn] << PAGE_SHIFT;
+ }
+ }
+ }
+ break;
+
+ default:
+ ERROR("Bogus page type %x page table is out of range."
+ " i=%d nr_pfns=%d", region_pfn_type[i], i, nr_pfns);
+ goto out;
+
+ } /* end of page type switch statement */
+
+ if ( verify )
+ {
+ int res = memcmp(buf, (region_base + i*PAGE_SIZE), PAGE_SIZE );
+ if (res)
+ {
+ int v;
+ printf("************** pfn=%x type=%x gotcs=%08lx "
+ "actualcs=%08lx\n", pfn, pfn_type[pfn],
+ csum_page(region_base + i*PAGE_SIZE),
+ csum_page(buf));
+ for ( v = 0; v < 4; v++ )
+ {
+ unsigned long *p = (unsigned long *)
+ (region_base + i*PAGE_SIZE);
+ if ( buf[v] != p[v] )
+ printf(" %d: %08lx %08lx\n",
+ v, buf[v], p[v] );
+ }
+ }
+ }
+
+ if ( add_mmu_update(xc_handle, mmu,
+ (mfn<<PAGE_SHIFT) | MMU_MACHPHYS_UPDATE, pfn) )
+ {
+ printf("machpys mfn=%ld pfn=%ld\n",mfn,pfn);
+ goto out;
+ }
+
+ } /* end of 'batch' for loop */
+ munmap( region_base, j*PAGE_SIZE );
+ n+=j; /* crude stats */
}
printf("Received all pages\n");
(pfn_to_mfn_table[i]<<PAGE_SHIFT) |
MMU_EXTENDED_COMMAND,
MMUEXT_PIN_L1_TABLE) )
- {
- printf("ERR pin L1 pfn=%lx mfn=%lx\n",
- i, pfn_to_mfn_table[i]);
+ {
+ printf("ERR pin L1 pfn=%lx mfn=%lx\n",
+ i, pfn_to_mfn_table[i]);
goto out;
- }
+ }
}
else if ( pfn_type[i] == L2TAB )
{
(pfn_to_mfn_table[i]<<PAGE_SHIFT) |
MMU_EXTENDED_COMMAND,
MMUEXT_PIN_L2_TABLE) )
- {
- printf("ERR pin L2 pfn=%lx mfn=%lx\n",
- i, pfn_to_mfn_table[i]);
+ {
+ printf("ERR pin L2 pfn=%lx mfn=%lx\n",
+ i, pfn_to_mfn_table[i]);
goto out;
- }
+ }
}
}
if ( (pfn >= nr_pfns) || (pfn_type[pfn] != L2TAB) )
{
printf("PT base is bad. pfn=%d nr=%d type=%08lx %08lx\n",
- pfn, nr_pfns, pfn_type[pfn], L2TAB);
+ pfn, nr_pfns, pfn_type[pfn], L2TAB);
ERROR("PT base is bad.");
goto out;
}
/* clear any pending events and the selector */
memset( &(((shared_info_t *)shared_info)->evtchn_pending[0]),
- 0, sizeof (((shared_info_t *)shared_info)->evtchn_pending)+
- sizeof(((shared_info_t *)shared_info)->evtchn_pending_sel) );
+ 0, sizeof (((shared_info_t *)shared_info)->evtchn_pending)+
+ sizeof(((shared_info_t *)shared_info)->evtchn_pending_sel) );
/* Copy saved contents of shared-info page. No checking needed. */
ppage = map_pfn_writeable(pm_handle, shared_info_frame);
/* Uncanonicalise the pfn-to-mfn table frame-number list. */
for ( i = 0; i < (nr_pfns+1023)/1024; i++ )
{
- unsigned long pfn, mfn;
+ unsigned long pfn, mfn;
pfn = pfn_to_mfn_frame_list[i];
if ( (pfn >= nr_pfns) || (pfn_type[pfn] != NOTAB) )
ERROR("PFN-to-MFN frame number is bad");
goto out;
}
- mfn = pfn_to_mfn_table[pfn];
- pfn_to_mfn_frame_list[i] = mfn;
+ mfn = pfn_to_mfn_table[pfn];
+ pfn_to_mfn_frame_list[i] = mfn;
}
- if ( (live_pfn_to_mfn_table = mfn_mapper_map_batch( xc_handle, dom,
- PROT_WRITE,
- pfn_to_mfn_frame_list,
- (nr_pfns+1023)/1024 )) == 0 )
+ if ( (live_pfn_to_mfn_table =
+ mfn_mapper_map_batch(xc_handle, dom,
+ PROT_WRITE,
+ pfn_to_mfn_frame_list,
+ (nr_pfns+1023)/1024 )) == 0 )
{
ERROR("Couldn't map pfn_to_mfn table");
goto out;
}
memcpy( live_pfn_to_mfn_table, pfn_to_mfn_table,
- nr_pfns*sizeof(unsigned long) );
+ nr_pfns*sizeof(unsigned long) );
munmap( live_pfn_to_mfn_table, ((nr_pfns+1023)/1024)*PAGE_SIZE );
if( rc == 0 )
{
- /* Success: print the domain id. */
- verbose_printf("DOM=%llu\n", dom);
- return 0;
+ /* Success: print the domain id. */
+ verbose_printf("DOM=%u\n", dom);
+ return 0;
}
out:
- if ( rc != 0 ) // destroy if something went wrong
+ if ( rc != 0 )
{
if ( dom != 0 )
{
- xc_domain_destroy( xc_handle, dom, 1 );
+ xc_domain_destroy( xc_handle, dom, 1 );
}
}
(live_pfn_to_mfn_table[live_mfn_to_pfn_table[_mfn]] == (_mfn)) ) || \
\
(live_mfn_to_pfn_table[_mfn] >= 0x80000000 && \
- live_mfn_to_pfn_table[_mfn] <= 0x80000003 ) || \
- live_pfn_to_mfn_table[live_mfn_to_pfn_table[_mfn]] == 0x80000004 ) )
+ live_mfn_to_pfn_table[_mfn] <= 0x80000003 ) || \
+ live_pfn_to_mfn_table[live_mfn_to_pfn_table[_mfn]] == 0x80000004 ) )
/* Returns TRUE if MFN is successfully converted to a PFN. */
#define translate_mfn_to_pfn(_pmfn) \
static inline int test_bit ( int nr, volatile void * addr)
{
return ( ((unsigned long*)addr)[nr/(sizeof(unsigned long)*8)] >>
- (nr % (sizeof(unsigned long)*8) ) ) & 1;
+ (nr % (sizeof(unsigned long)*8) ) ) & 1;
}
static inline void clear_bit ( int nr, volatile void * addr)
{
((unsigned long*)addr)[nr/(sizeof(unsigned long)*8)] &=
- ~(1 << (nr % (sizeof(unsigned long)*8) ) );
+ ~(1 << (nr % (sizeof(unsigned long)*8) ) );
}
static inline void set_bit ( int nr, volatile void * addr)
{
((unsigned long*)addr)[nr/(sizeof(unsigned long)*8)] |=
- (1 << (nr % (sizeof(unsigned long)*8) ) );
+ (1 << (nr % (sizeof(unsigned long)*8) ) );
}
/*
* hweightN: returns the hamming weight (i.e. the number
static inline unsigned int hweight32(unsigned int w)
{
- unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555);
- res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
- res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F);
- res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF);
- return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF);
+ unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555);
+ res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
+ res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F);
+ res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF);
+ return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF);
}
static inline int count_bits ( int nr, volatile void *addr)
{
int i, count = 0;
unsigned long *p = (unsigned long *)addr;
- // we know the array is padded to unsigned long
+ /* we know the array is padded to unsigned long */
for(i=0;i<nr/(sizeof(unsigned long)*8);i++,p++)
- count += hweight32( *p );
+ count += hweight32( *p );
return count;
}
do
{
- i = ( ( i>>(order_nr-10)) | ( i<<10 ) ) &
- ((1<<order_nr)-1);
+ i = ( ( i>>(order_nr-10)) | ( i<<10 ) ) &
+ ((1<<order_nr)-1);
}
- while ( i >= nr ); // this won't ever loop if nr is a power of 2
+ while ( i >= nr ); /* this won't ever loop if nr is a power of 2 */
return i;
}
static long long tvdelta( struct timeval *new, struct timeval *old )
{
return ((new->tv_sec - old->tv_sec)*1000000 ) +
- (new->tv_usec - old->tv_usec);
+ (new->tv_usec - old->tv_usec);
}
-static int track_cpu_usage( int xc_handle, u64 domid, int faults,
- int pages_sent, int pages_dirtied, int print )
+static int track_cpu_usage( int xc_handle, u32 domid, int faults,
+ int pages_sent, int pages_dirtied, int print )
{
static struct timeval wall_last;
static long long d0_cpu_last;
d0_cpu_now = xc_domain_get_cpu_usage( xc_handle, 0 )/1000;
d1_cpu_now = xc_domain_get_cpu_usage( xc_handle, domid )/1000;
- if ( d0_cpu_now == -1 || d1_cpu_now == -1 )
+ if ( d0_cpu_now == -1 || d1_cpu_now == -1 )
{
- printf("ARRHHH!!\n");
+ printf("ARRHHH!!\n");
}
wall_delta = tvdelta(&wall_now,&wall_last)/1000;
d1_cpu_delta = (d1_cpu_now - d1_cpu_last)/1000;
if(print)
- printf("delta %lldms, dom0 %d%%, target %d%%, sent %dMb/s, dirtied %dMb/s\n",
- wall_delta,
- (int)((d0_cpu_delta*100)/wall_delta),
- (int)((d1_cpu_delta*100)/wall_delta),
- (int)((pages_sent*PAGE_SIZE*8)/(wall_delta*1000)),
- (int)((pages_dirtied*PAGE_SIZE*8)/(wall_delta*1000))
- );
+ printf("delta %lldms, dom0 %d%%, target %d%%, "
+ "sent %dMb/s, dirtied %dMb/s\n",
+ wall_delta,
+ (int)((d0_cpu_delta*100)/wall_delta),
+ (int)((d1_cpu_delta*100)/wall_delta),
+ (int)((pages_sent*PAGE_SIZE*8)/(wall_delta*1000)),
+ (int)((pages_dirtied*PAGE_SIZE*8)/(wall_delta*1000))
+ );
d0_cpu_last = d0_cpu_now;
d1_cpu_last = d1_cpu_now;
- wall_last = wall_now;
+ wall_last = wall_now;
return 0;
}
int xc_linux_save(int xc_handle,
- u64 domid,
- unsigned int flags,
- int (*writerfn)(void *, const void *, size_t),
- void *writerst )
+ u32 domid,
+ unsigned int flags,
+ int (*writerfn)(void *, const void *, size_t),
+ void *writerst )
{
dom0_op_t op;
int rc = 1, i, j, k, last_iter, iter = 0;
unsigned long dirtied_this_iter, faults_this_iter;
/* Important tuning parameters */
- int max_iters = 29; // limit us to 30 times round loop
- int max_factor = 3; // never send more than 3x nr_pfns
+ int max_iters = 29; /* limit us to 30 times round loop */
+ int max_factor = 3; /* never send more than 3x nr_pfns */
/* The new domain's shared-info frame number. */
unsigned long shared_info_frame;
if ( xc_domain_stop_sync( xc_handle, domid, &op, &ctxt ) )
{
- PERROR("Could not sync stop domain");
- goto out;
+ PERROR("Could not sync stop domain");
+ goto out;
}
memcpy(name, op.u.getdomaininfo.name, sizeof(name));
/* Map the suspend-record MFN to pin it. The page must be owned by
domid for this to succeed. */
p_srec = mfn_mapper_map_single(xc_handle, domid,
- sizeof(*p_srec), PROT_READ,
- ctxt.cpu_ctxt.esi );
+ sizeof(*p_srec), PROT_READ,
+ ctxt.cpu_ctxt.esi );
if (!p_srec)
{
/* the pfn_to_mfn_frame_list fits in a single page */
live_pfn_to_mfn_frame_list =
- mfn_mapper_map_single(xc_handle, domid,
- PAGE_SIZE, PROT_READ,
- p_srec->pfn_to_mfn_frame_list );
+ mfn_mapper_map_single(xc_handle, domid,
+ PAGE_SIZE, PROT_READ,
+ p_srec->pfn_to_mfn_frame_list );
if (!live_pfn_to_mfn_frame_list)
{
/* Track the mfn_to_pfn table down from the domains PT */
{
- unsigned long *pgd;
- unsigned long mfn_to_pfn_table_start_mfn;
+ unsigned long *pgd;
+ unsigned long mfn_to_pfn_table_start_mfn;
- pgd = mfn_mapper_map_single(xc_handle, domid,
- PAGE_SIZE, PROT_READ,
- ctxt.pt_base>>PAGE_SHIFT);
+ pgd = mfn_mapper_map_single(xc_handle, domid,
+ PAGE_SIZE, PROT_READ,
+ ctxt.pt_base>>PAGE_SHIFT);
- mfn_to_pfn_table_start_mfn =
- pgd[HYPERVISOR_VIRT_START>>L2_PAGETABLE_SHIFT]>>PAGE_SHIFT;
+ mfn_to_pfn_table_start_mfn =
+ pgd[HYPERVISOR_VIRT_START>>L2_PAGETABLE_SHIFT]>>PAGE_SHIFT;
- live_mfn_to_pfn_table =
- mfn_mapper_map_single(xc_handle, ~0ULL,
- PAGE_SIZE*1024, PROT_READ,
- mfn_to_pfn_table_start_mfn );
+ live_mfn_to_pfn_table =
+ mfn_mapper_map_single(xc_handle, DOMID_SELF,
+ PAGE_SIZE*1024, PROT_READ,
+ mfn_to_pfn_table_start_mfn );
}
/* Map all the frames of the pfn->mfn table. For migrate to succeed,
from a safety POV anyhow. */
live_pfn_to_mfn_table = mfn_mapper_map_batch( xc_handle, domid,
- PROT_READ,
- live_pfn_to_mfn_frame_list,
- (nr_pfns+1023)/1024 );
+ PROT_READ,
+ live_pfn_to_mfn_frame_list,
+ (nr_pfns+1023)/1024 );
if( !live_pfn_to_mfn_table )
{
PERROR("Couldn't map pfn_to_mfn table");
if( live )
{
- if ( xc_shadow_control( xc_handle, domid,
- DOM0_SHADOW_CONTROL_OP_ENABLE_LOGDIRTY,
- NULL, 0, NULL, NULL ) < 0 )
- {
- ERROR("Couldn't enable shadow mode");
- goto out;
- }
-
- if ( xc_domain_start( xc_handle, domid ) < 0 )
- {
- ERROR("Couldn't restart domain");
- goto out;
- }
-
- last_iter = 0;
- sent_last_iter = 1<<20; // 4GB's worth of pages
+ if ( xc_shadow_control( xc_handle, domid,
+ DOM0_SHADOW_CONTROL_OP_ENABLE_LOGDIRTY,
+ NULL, 0, NULL, NULL ) < 0 )
+ {
+ ERROR("Couldn't enable shadow mode");
+ goto out;
+ }
+
+ if ( xc_domain_start( xc_handle, domid ) < 0 )
+ {
+ ERROR("Couldn't restart domain");
+ goto out;
+ }
+
+ last_iter = 0;
+ sent_last_iter = 1<<20; /* 4GB's worth of pages */
}
else
- last_iter = 1;
+ last_iter = 1;
/* Setup to_send bitmap */
{
- int sz = (nr_pfns/8) + 8; // includes slop at end of array
-
- to_send = malloc( sz );
- to_fix = calloc( 1, sz );
- to_skip = malloc( sz );
-
- if (!to_send || !to_fix || !to_skip)
- {
- ERROR("Couldn't allocate to_send array");
- goto out;
- }
-
- memset( to_send, 0xff, sz );
-
- if ( mlock( to_send, sz ) )
- {
- PERROR("Unable to mlock to_send");
- return 1;
- }
-
- /* (to fix is local only) */
-
- if ( mlock( to_skip, sz ) )
- {
- PERROR("Unable to mlock to_skip");
- return 1;
- }
+ int sz = (nr_pfns/8) + 8; /* includes slop at end of array */
+
+ to_send = malloc( sz );
+ to_fix = calloc( 1, sz );
+ to_skip = malloc( sz );
+
+ if (!to_send || !to_fix || !to_skip)
+ {
+ ERROR("Couldn't allocate to_send array");
+ goto out;
+ }
+
+ memset( to_send, 0xff, sz );
+
+ if ( mlock( to_send, sz ) )
+ {
+ PERROR("Unable to mlock to_send");
+ return 1;
+ }
+
+ /* (to fix is local only) */
+
+ if ( mlock( to_skip, sz ) )
+ {
+ PERROR("Unable to mlock to_skip");
+ return 1;
+ }
}
/* calculate the power of 2 order of nr_pfns, e.g.
- 15->4 16->4 17->5 */
+ 15->4 16->4 17->5 */
for( i=nr_pfns-1, order_nr=0; i ; i>>=1, order_nr++ );
-printf("nr_pfns=%d order_nr=%d\n",nr_pfns, order_nr);
+ printf("nr_pfns=%d order_nr=%d\n",nr_pfns, order_nr);
/* We want zeroed memory so use calloc rather than malloc. */
pfn_type = calloc(BATCH_SIZE, sizeof(unsigned long));
if ( mlock( pfn_type, BATCH_SIZE * sizeof(unsigned long) ) )
{
- ERROR("Unable to mlock");
- goto out;
+ ERROR("Unable to mlock");
+ goto out;
}
{
mfn = live_pfn_to_mfn_table[i];
- if( (live_mfn_to_pfn_table[mfn] != i) && (mfn != 0x80000004) )
- printf("i=0x%x mfn=%x live_mfn_to_pfn_table=%x\n",
- i,mfn,live_mfn_to_pfn_table[mfn]);
+ if( (live_mfn_to_pfn_table[mfn] != i) && (mfn != 0x80000004) )
+ printf("i=0x%x mfn=%x live_mfn_to_pfn_table=%x\n",
+ i,mfn,live_mfn_to_pfn_table[mfn]);
}
#endif
/* Map the shared info frame */
live_shinfo = mfn_mapper_map_single(xc_handle, domid,
- PAGE_SIZE, PROT_READ,
- shared_info_frame);
+ PAGE_SIZE, PROT_READ,
+ shared_info_frame);
if (!live_shinfo)
{
while(1)
{
- unsigned int prev_pc, sent_this_iter, N, batch;
-
- iter++;
- sent_this_iter = 0;
- skip_this_iter = 0;
- prev_pc = 0;
- N=0;
-
- verbose_printf("Saving memory pages: iter %d 0%%", iter);
-
- while( N < nr_pfns )
- {
- unsigned int this_pc = (N * 100) / nr_pfns;
-
- if ( (this_pc - prev_pc) >= 5 )
- {
- verbose_printf("\b\b\b\b%3d%%", this_pc);
- prev_pc = this_pc;
- }
-
- /* slightly wasteful to peek the whole array evey time,
- but this is fast enough for the moment. */
-
- if ( !last_iter &&
- xc_shadow_control(xc_handle, domid,
- DOM0_SHADOW_CONTROL_OP_PEEK,
- to_skip, nr_pfns, NULL, NULL) != nr_pfns )
- {
- ERROR("Error peeking shadow bitmap");
- goto out;
- }
-
-
- /* load pfn_type[] with the mfn of all the pages we're doing in
- this batch. */
-
- for( batch = 0; batch < BATCH_SIZE && N < nr_pfns ; N++ )
- {
- int n = permute(N, nr_pfns, order_nr );
-
- if(0 && debug)
- fprintf(stderr,"%d pfn= %08lx mfn= %08lx %d [mfn]= %08lx\n",
- iter, n, live_pfn_to_mfn_table[n],
- test_bit(n,to_send),
- live_mfn_to_pfn_table[live_pfn_to_mfn_table[n]&0xFFFFF]);
-
- if (!last_iter && test_bit(n, to_send) && test_bit(n, to_skip))
- skip_this_iter++; // stats keeping
-
- if (! ( (test_bit(n, to_send) && !test_bit(n, to_skip)) ||
- (test_bit(n, to_send) && last_iter) ||
- (test_bit(n, to_fix) && last_iter) ) )
- continue;
-
- /* we get here if:
- 1. page is marked to_send & hasn't already been re-dirtied
- 2. (ignore to_skip in last iteration)
- 3. add in pages that still need fixup (net bufs)
- */
-
- pfn_batch[batch] = n;
- pfn_type[batch] = live_pfn_to_mfn_table[n];
-
- if( pfn_type[batch] == 0x80000004 )
- {
- /* not currently in pusedo-physical map -- set bit
- in to_fix that we must send this page in last_iter
- unless its sent sooner anyhow */
-
- set_bit( n, to_fix );
- if( iter>1 )
- DDPRINTF("Urk! netbuf race: iter %d, pfn %lx. mfn %lx\n",
- iter,n,pfn_type[batch]);
- continue;
- }
-
- if ( last_iter && test_bit(n, to_fix ) && !test_bit(n, to_send ))
- {
- needed_to_fix++;
- DPRINTF("Fix! iter %d, pfn %lx. mfn %lx\n",
- iter,n,pfn_type[batch]);
- }
-
- clear_bit( n, to_fix );
-
- batch++;
- }
-
- DDPRINTF("batch %d:%d (n=%d)\n",iter,batch,n);
-
- if(batch == 0) goto skip; // vanishingly unlikely...
-
- if ( (region_base = mfn_mapper_map_batch( xc_handle, domid,
- PROT_READ,
- pfn_type,
- batch )) == 0)
- {
- PERROR("map batch failed");
- goto out;
- }
-
- if ( get_pfn_type_batch(xc_handle, domid, batch, pfn_type) )
- {
- ERROR("get_pfn_type_batch failed");
- goto out;
- }
-
- for( j = 0; j < batch; j++ )
- {
- if( (pfn_type[j] & LTAB_MASK) == XTAB)
- {
- DDPRINTF("type fail: page %i mfn %08lx\n",j,pfn_type[j]);
- continue;
- }
-
- if(0 && debug)
- fprintf(stderr,"%d pfn= %08lx mfn= %08lx [mfn]= %08lx sum= %08lx\n",
- iter,
- (pfn_type[j] & LTAB_MASK) | pfn_batch[j],
- pfn_type[j],
- live_mfn_to_pfn_table[pfn_type[j]&(~LTAB_MASK)],
- csum_page(region_base + (PAGE_SIZE*j))
- );
-
- /* canonicalise mfn->pfn */
- pfn_type[j] = (pfn_type[j] & LTAB_MASK) |
- pfn_batch[j];
- //live_mfn_to_pfn_table[pfn_type[j]&~LTAB_MASK];
-
- }
-
-
- if ( (*writerfn)(writerst, &batch, sizeof(int) ) )
- {
- ERROR("Error when writing to state file (2)");
- goto out;
- }
-
- if ( (*writerfn)(writerst, pfn_type, sizeof(unsigned long)*j ) )
- {
- ERROR("Error when writing to state file (3)");
- goto out;
- }
-
- /* entering this loop, pfn_type is now in pfns (Not mfns) */
- for( j = 0; j < batch; j++ )
- {
- /* write out pages in batch */
-
- if( (pfn_type[j] & LTAB_MASK) == XTAB)
- {
- DDPRINTF("SKIP BOGUS page %i mfn %08lx\n",j,pfn_type[j]);
- continue;
- }
-
- if ( ((pfn_type[j] & LTAB_MASK) == L1TAB) ||
- ((pfn_type[j] & LTAB_MASK) == L2TAB) )
- {
-
- memcpy(page, region_base + (PAGE_SIZE*j), PAGE_SIZE);
-
- for ( k = 0;
- k < (((pfn_type[j] & LTAB_MASK) == L2TAB) ?
- (HYPERVISOR_VIRT_START >> L2_PAGETABLE_SHIFT) : 1024);
- k++ )
- {
- unsigned long pfn;
-
- if ( !(page[k] & _PAGE_PRESENT) ) continue;
- mfn = page[k] >> PAGE_SHIFT;
- pfn = live_mfn_to_pfn_table[mfn];
-
- if ( !MFN_IS_IN_PSEUDOPHYS_MAP(mfn) )
- {
- // I don't think this should ever happen
-
- printf("FNI %d : [%08lx,%d] pte=%08lx, mfn=%08lx, pfn=%08lx [mfn]=%08lx\n",
- j, pfn_type[j], k,
- page[k], mfn, live_mfn_to_pfn_table[mfn],
- (live_mfn_to_pfn_table[mfn]<nr_pfns)?
- live_pfn_to_mfn_table[live_mfn_to_pfn_table[mfn]]: 0xdeadbeef);
-
- pfn = 0; // be suspicious, very suspicious
-
- //goto out; // let's try our luck
-
-
- }
- page[k] &= PAGE_SIZE - 1;
- page[k] |= pfn << PAGE_SHIFT;
-
-#if 0
- printf("L%d i=%d pfn=%d mfn=%d k=%d pte=%08lx xpfn=%d\n",
- pfn_type[j]>>28,
- j,i,mfn,k,page[k],page[k]>>PAGE_SHIFT);
-#endif
-
- } /* end of page table rewrite for loop */
-
- if ( (*writerfn)(writerst, page, PAGE_SIZE) )
- {
- ERROR("Error when writing to state file (4)");
- goto out;
- }
-
- } /* end of it's a PT page */
- else
- { /* normal page */
-
- if ( (*writerfn)(writerst, region_base + (PAGE_SIZE*j), PAGE_SIZE) )
- {
- ERROR("Error when writing to state file (5)");
- goto out;
- }
- }
- } /* end of the write out for this batch */
-
- sent_this_iter += batch;
-
- } /* end of this while loop for this iteration */
-
- munmap(region_base, batch*PAGE_SIZE);
+ unsigned int prev_pc, sent_this_iter, N, batch;
+
+ iter++;
+ sent_this_iter = 0;
+ skip_this_iter = 0;
+ prev_pc = 0;
+ N=0;
+
+ verbose_printf("Saving memory pages: iter %d 0%%", iter);
+
+ while( N < nr_pfns )
+ {
+ unsigned int this_pc = (N * 100) / nr_pfns;
+
+ if ( (this_pc - prev_pc) >= 5 )
+ {
+ verbose_printf("\b\b\b\b%3d%%", this_pc);
+ prev_pc = this_pc;
+ }
+
+ /* slightly wasteful to peek the whole array evey time,
+ but this is fast enough for the moment. */
+
+ if ( !last_iter &&
+ xc_shadow_control(xc_handle, domid,
+ DOM0_SHADOW_CONTROL_OP_PEEK,
+ to_skip, nr_pfns, NULL, NULL) != nr_pfns )
+ {
+ ERROR("Error peeking shadow bitmap");
+ goto out;
+ }
+
+
+ /* load pfn_type[] with the mfn of all the pages we're doing in
+ this batch. */
+
+ for( batch = 0; batch < BATCH_SIZE && N < nr_pfns ; N++ )
+ {
+ int n = permute(N, nr_pfns, order_nr );
+
+ if(0 && debug)
+ fprintf(stderr,"%d pfn= %08lx mfn= %08lx %d "
+ "[mfn]= %08lx\n",
+ iter, n, live_pfn_to_mfn_table[n],
+ test_bit(n,to_send),
+ live_mfn_to_pfn_table[
+ live_pfn_to_mfn_table[n]&0xFFFFF]);
+
+ if (!last_iter && test_bit(n, to_send) && test_bit(n, to_skip))
+ skip_this_iter++; /* stats keeping */
+
+ if (! ( (test_bit(n, to_send) && !test_bit(n, to_skip)) ||
+ (test_bit(n, to_send) && last_iter) ||
+ (test_bit(n, to_fix) && last_iter) ) )
+ continue;
+
+ /* we get here if:
+ 1. page is marked to_send & hasn't already been re-dirtied
+ 2. (ignore to_skip in last iteration)
+ 3. add in pages that still need fixup (net bufs)
+ */
+
+ pfn_batch[batch] = n;
+ pfn_type[batch] = live_pfn_to_mfn_table[n];
+
+ if( pfn_type[batch] == 0x80000004 )
+ {
+ /* not currently in pusedo-physical map -- set bit
+ in to_fix that we must send this page in last_iter
+ unless its sent sooner anyhow */
+
+ set_bit( n, to_fix );
+ if( iter>1 )
+ DDPRINTF("Urk! netbuf race: iter %d, pfn %lx."
+ " mfn %lx\n",
+ iter,n,pfn_type[batch]);
+ continue;
+ }
+
+ if ( last_iter && test_bit(n, to_fix) &&
+ !test_bit(n, to_send) )
+ {
+ needed_to_fix++;
+ DPRINTF("Fix! iter %d, pfn %lx. mfn %lx\n",
+ iter,n,pfn_type[batch]);
+ }
+
+ clear_bit( n, to_fix );
+
+ batch++;
+ }
+
+ DDPRINTF("batch %d:%d (n=%d)\n",iter,batch,n);
+
+ if ( batch == 0 )
+ goto skip; /* very unlikely */
+
+ if ( (region_base = mfn_mapper_map_batch(xc_handle, domid,
+ PROT_READ,
+ pfn_type,
+ batch)) == 0 )
+ {
+ PERROR("map batch failed");
+ goto out;
+ }
+
+ if ( get_pfn_type_batch(xc_handle, domid, batch, pfn_type) )
+ {
+ ERROR("get_pfn_type_batch failed");
+ goto out;
+ }
+
+ for ( j = 0; j < batch; j++ )
+ {
+ if ( (pfn_type[j] & LTAB_MASK) == XTAB )
+ {
+ DDPRINTF("type fail: page %i mfn %08lx\n",j,pfn_type[j]);
+ continue;
+ }
+
+ if ( 0 && debug )
+ fprintf(stderr,"%d pfn= %08lx mfn= %08lx "
+ "[mfn]= %08lx sum= %08lx\n",
+ iter,
+ (pfn_type[j] & LTAB_MASK) | pfn_batch[j],
+ pfn_type[j],
+ live_mfn_to_pfn_table[pfn_type[j]&(~LTAB_MASK)],
+ csum_page(region_base + (PAGE_SIZE*j))
+ );
+
+ /* canonicalise mfn->pfn */
+ pfn_type[j] = (pfn_type[j] & LTAB_MASK) |
+ pfn_batch[j];
+ }
+
+
+ if ( (*writerfn)(writerst, &batch, sizeof(int) ) )
+ {
+ ERROR("Error when writing to state file (2)");
+ goto out;
+ }
+
+ if ( (*writerfn)(writerst, pfn_type, sizeof(unsigned long)*j ) )
+ {
+ ERROR("Error when writing to state file (3)");
+ goto out;
+ }
+
+ /* entering this loop, pfn_type is now in pfns (Not mfns) */
+ for( j = 0; j < batch; j++ )
+ {
+ /* write out pages in batch */
+
+ if( (pfn_type[j] & LTAB_MASK) == XTAB)
+ {
+ DDPRINTF("SKIP BOGUS page %i mfn %08lx\n",j,pfn_type[j]);
+ continue;
+ }
+
+ if ( ((pfn_type[j] & LTAB_MASK) == L1TAB) ||
+ ((pfn_type[j] & LTAB_MASK) == L2TAB) )
+ {
+
+ memcpy(page, region_base + (PAGE_SIZE*j), PAGE_SIZE);
+
+ for ( k = 0;
+ k < (((pfn_type[j] & LTAB_MASK) == L2TAB) ?
+ (HYPERVISOR_VIRT_START >> L2_PAGETABLE_SHIFT) :
+ 1024);
+ k++ )
+ {
+ unsigned long pfn;
+
+ if ( !(page[k] & _PAGE_PRESENT) ) continue;
+ mfn = page[k] >> PAGE_SHIFT;
+ pfn = live_mfn_to_pfn_table[mfn];
+
+ if ( !MFN_IS_IN_PSEUDOPHYS_MAP(mfn) )
+ {
+ /* I don't think this should ever happen */
+ printf("FNI %d : [%08lx,%d] pte=%08lx, "
+ "mfn=%08lx, pfn=%08lx [mfn]=%08lx\n",
+ j, pfn_type[j], k,
+ page[k], mfn, live_mfn_to_pfn_table[mfn],
+ (live_mfn_to_pfn_table[mfn]<nr_pfns)?
+ live_pfn_to_mfn_table[
+ live_mfn_to_pfn_table[mfn]]:0xdeadbeef);
+ pfn = 0; /* be suspicious, very suspicious */
+ }
+ page[k] &= PAGE_SIZE - 1;
+ page[k] |= pfn << PAGE_SHIFT;
+ } /* end of page table rewrite for loop */
+
+ if ( (*writerfn)(writerst, page, PAGE_SIZE) )
+ {
+ ERROR("Error when writing to state file (4)");
+ goto out;
+ }
+
+ } /* end of it's a PT page */
+ else
+ { /* normal page */
+
+ if ( (*writerfn)(writerst, region_base + (PAGE_SIZE*j),
+ PAGE_SIZE) )
+ {
+ ERROR("Error when writing to state file (5)");
+ goto out;
+ }
+ }
+ } /* end of the write out for this batch */
+
+ sent_this_iter += batch;
+
+ } /* end of this while loop for this iteration */
+
+ munmap(region_base, batch*PAGE_SIZE);
skip:
- total_sent += sent_this_iter;
+ total_sent += sent_this_iter;
- verbose_printf("\r %d: sent %d, skipped %d, ",
- iter, sent_this_iter, skip_this_iter );
+ verbose_printf("\r %d: sent %d, skipped %d, ",
+ iter, sent_this_iter, skip_this_iter );
- if ( last_iter )
- {
- track_cpu_usage( xc_handle, domid, 0, sent_this_iter, 0, 1);
+ if ( last_iter )
+ {
+ track_cpu_usage( xc_handle, domid, 0, sent_this_iter, 0, 1);
- verbose_printf("Total pages sent= %d (%.2fx)\n",
- total_sent, ((float)total_sent)/nr_pfns );
- verbose_printf("(of which %d were fixups)\n", needed_to_fix );
- }
+ verbose_printf("Total pages sent= %d (%.2fx)\n",
+ total_sent, ((float)total_sent)/nr_pfns );
+ verbose_printf("(of which %d were fixups)\n", needed_to_fix );
+ }
- if ( debug && last_iter )
- {
- int minusone = -1;
- memset( to_send, 0xff, nr_pfns/8 );
- debug = 0;
- printf("Entering debug resend-all mode\n");
+ if ( debug && last_iter )
+ {
+ int minusone = -1;
+ memset( to_send, 0xff, nr_pfns/8 );
+ debug = 0;
+ printf("Entering debug resend-all mode\n");
- /* send "-1" to put receiver into debug mode */
- if ( (*writerfn)(writerst, &minusone, sizeof(int)) )
- {
- ERROR("Error when writing to state file (6)");
- goto out;
- }
-
- continue;
- }
-
- if ( last_iter )
- break;
-
- if ( live )
- {
- if (
- // ( sent_this_iter > (sent_last_iter * 0.95) ) ||
- (iter >= max_iters) ||
- (sent_this_iter+skip_this_iter < 50) ||
- (total_sent > nr_pfns*max_factor) )
- {
- DPRINTF("Start last iteration\n");
- last_iter = 1;
-
- xc_domain_stop_sync( xc_handle, domid, &op, NULL );
-
- }
-
- if ( xc_shadow_control( xc_handle, domid,
- DOM0_SHADOW_CONTROL_OP_CLEAN2,
- to_send, nr_pfns, &faults_this_iter,
- &dirtied_this_iter) != nr_pfns )
- {
- ERROR("Error flushing shadow PT");
- goto out;
- }
-
- sent_last_iter = sent_this_iter;
-
- //dirtied_this_iter = count_bits( nr_pfns, to_send );
- track_cpu_usage( xc_handle, domid, faults_this_iter,
- sent_this_iter, dirtied_this_iter, 1);
-
- }
+ /* send "-1" to put receiver into debug mode */
+ if ( (*writerfn)(writerst, &minusone, sizeof(int)) )
+ {
+ ERROR("Error when writing to state file (6)");
+ goto out;
+ }
+
+ continue;
+ }
+ if ( last_iter )
+ break;
+
+ if ( live )
+ {
+ if ( (iter >= max_iters) ||
+ (sent_this_iter+skip_this_iter < 50) ||
+ (total_sent > nr_pfns*max_factor) )
+ {
+ DPRINTF("Start last iteration\n");
+ last_iter = 1;
+
+ xc_domain_stop_sync( xc_handle, domid, &op, NULL );
+
+ }
+
+ if ( xc_shadow_control( xc_handle, domid,
+ DOM0_SHADOW_CONTROL_OP_CLEAN2,
+ to_send, nr_pfns, &faults_this_iter,
+ &dirtied_this_iter) != nr_pfns )
+ {
+ ERROR("Error flushing shadow PT");
+ goto out;
+ }
+
+ sent_last_iter = sent_this_iter;
+
+ /* dirtied_this_iter = count_bits( nr_pfns, to_send ); */
+ track_cpu_usage( xc_handle, domid, faults_this_iter,
+ sent_this_iter, dirtied_this_iter, 1);
+
+ }
} /* end of while 1 */
/* Zero terminate */
if ( (*writerfn)(writerst, &rc, sizeof(int)) )
{
- ERROR("Error when writing to state file (6)");
- goto out;
+ ERROR("Error when writing to state file (6)");
+ goto out;
}
/* Get the final execution context */
op.u.getdomaininfo.domain = (domid_t)domid;
op.u.getdomaininfo.ctxt = &ctxt;
if ( (do_dom0_op(xc_handle, &op) < 0) ||
- ((u64)op.u.getdomaininfo.domain != domid) )
+ ((u32)op.u.getdomaininfo.domain != domid) )
{
- PERROR("Could not get info on domain");
- goto out;
+ PERROR("Could not get info on domain");
+ goto out;
}
/* Canonicalise the suspend-record frame number. */
ERROR("PT base is not in range of pseudophys map");
goto out;
}
- ctxt.pt_base = live_mfn_to_pfn_table[ctxt.pt_base >> PAGE_SHIFT] << PAGE_SHIFT;
+ ctxt.pt_base = live_mfn_to_pfn_table[ctxt.pt_base >> PAGE_SHIFT] <<
+ PAGE_SHIFT;
- if ( (*writerfn)(writerst, &ctxt, sizeof(ctxt)) ||
- (*writerfn)(writerst, live_shinfo, PAGE_SIZE) )
+ if ( (*writerfn)(writerst, &ctxt, sizeof(ctxt)) ||
+ (*writerfn)(writerst, live_shinfo, PAGE_SIZE) )
{
ERROR("Error when writing to state file (1)");
goto out;
}
munmap(live_shinfo, PAGE_SIZE);
-out:
-
+ out:
if ( pfn_type != NULL )
free(pfn_type);
}
-#define CONSOLE_RING_CLEAR 1
+#define CONSOLE_RING_CLEAR 1
int xc_readconsolering(int xc_handle,
char *str,
int xc_physinfo(int xc_handle,
- xc_physinfo_t *put_info)
+ xc_physinfo_t *put_info)
{
int ret;
dom0_op_t op;
#define L1_PROT (_PAGE_PRESENT|_PAGE_RW|_PAGE_ACCESSED)
#define L2_PROT (_PAGE_PRESENT|_PAGE_RW|_PAGE_ACCESSED|_PAGE_DIRTY|_PAGE_USER)
-static long get_tot_pages(int xc_handle, u64 domid)
+static long get_tot_pages(int xc_handle, u32 domid)
{
dom0_op_t op;
op.cmd = DOM0_GETDOMAININFO;
}
static int get_pfn_list(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned long *pfn_buf,
unsigned long max_pfns)
{
}
static int setup_guestos(int xc_handle,
- u64 dom,
+ u32 dom,
gzFile kernel_gfd,
unsigned long tot_pages,
unsigned long *virt_startinfo_addr,
unsigned long *virt_load_addr,
- full_execution_context_t *ctxt,
+ full_execution_context_t *ctxt,
const char *cmdline,
unsigned long shared_info_frame,
unsigned int control_evtchn)
}
int xc_netbsd_build(int xc_handle,
- u64 domid,
+ u32 domid,
const char *image_name,
const char *cmdline,
unsigned int control_evtchn)
op.u.getdomaininfo.domain = (domid_t)domid;
op.u.getdomaininfo.ctxt = ctxt;
if ( (do_dom0_op(xc_handle, &op) < 0) ||
- ((u64)op.u.getdomaininfo.domain != domid) )
+ ((u32)op.u.getdomaininfo.domain != domid) )
{
PERROR("Could not get info on domain");
goto error_out;
#include "xc_private.h"
int xc_physdev_pci_access_modify(int xc_handle,
- u64 domid,
+ u32 domid,
int bus,
int dev,
int func,
{
int fd = open("/dev/mem", O_RDWR);
if ( fd >= 0 )
- {
- (void)ioctl(fd, _IO('M', 1), (unsigned long)(domid>> 0)); /* low */
- (void)ioctl(fd, _IO('M', 2), (unsigned long)(domid>>32)); /* high */
- }
+ (void)ioctl(fd, _IO('M', 1), (unsigned long)domid);
return fd;
}
/*******************/
void * mfn_mapper_map_batch(int xc_handle, domid_t dom, int prot,
- unsigned long *arr, int num )
+ unsigned long *arr, int num )
{
privcmd_mmapbatch_t ioctlx;
void *addr;
addr = mmap( NULL, num*PAGE_SIZE, prot, MAP_SHARED, xc_handle, 0 );
if (addr)
{
- ioctlx.num=num;
- ioctlx.dom=dom;
- ioctlx.addr=(unsigned long)addr;
- ioctlx.arr=arr;
- if ( ioctl( xc_handle, IOCTL_PRIVCMD_MMAPBATCH, &ioctlx ) <0 )
- {
- perror("XXXXXXXX");
- munmap(addr, num*PAGE_SIZE);
- return 0;
- }
+ ioctlx.num=num;
+ ioctlx.dom=dom;
+ ioctlx.addr=(unsigned long)addr;
+ ioctlx.arr=arr;
+ if ( ioctl( xc_handle, IOCTL_PRIVCMD_MMAPBATCH, &ioctlx ) < 0 )
+ {
+ perror("XXXXXXXX");
+ munmap(addr, num*PAGE_SIZE);
+ return 0;
+ }
}
return addr;
/*******************/
void * mfn_mapper_map_single(int xc_handle, domid_t dom,
- int size, int prot,
- unsigned long mfn )
+ int size, int prot,
+ unsigned long mfn )
{
privcmd_mmap_t ioctlx;
privcmd_mmap_entry_t entry;
addr = mmap( NULL, size, prot, MAP_SHARED, xc_handle, 0 );
if (addr)
{
- ioctlx.num=1;
- ioctlx.dom=dom;
- ioctlx.entry=&entry;
- entry.va=(unsigned long) addr;
- entry.mfn=mfn;
- entry.npages=(size+PAGE_SIZE-1)>>PAGE_SHIFT;
- if ( ioctl( xc_handle, IOCTL_PRIVCMD_MMAP, &ioctlx ) <0 )
- {
- munmap(addr, size);
- return 0;
- }
+ ioctlx.num=1;
+ ioctlx.dom=dom;
+ ioctlx.entry=&entry;
+ entry.va=(unsigned long) addr;
+ entry.mfn=mfn;
+ entry.npages=(size+PAGE_SIZE-1)>>PAGE_SHIFT;
+ if ( ioctl( xc_handle, IOCTL_PRIVCMD_MMAP, &ioctlx ) <0 )
+ {
+ munmap(addr, size);
+ return 0;
+ }
}
return addr;
}
/* NB: arr must be mlock'ed */
int get_pfn_type_batch(int xc_handle,
- u64 dom, int num, unsigned long *arr)
+ u32 dom, int num, unsigned long *arr)
{
dom0_op_t op;
op.cmd = DOM0_GETPAGEFRAMEINFO2;
#define GETPFN_ERR (~0U)
unsigned int get_pfn_type(int xc_handle,
- unsigned long mfn,
- u64 dom)
+ unsigned long mfn,
+ u32 dom)
{
dom0_op_t op;
op.cmd = DOM0_GETPAGEFRAMEINFO;
/*******************/
-#define FIRST_MMU_UPDATE 2
+#define FIRST_MMU_UPDATE 1
static int flush_mmu_updates(int xc_handle, mmu_t *mmu)
{
/* The first two requests set the correct subject domain (PTS and GPS). */
mmu->updates[0].val = (unsigned long)(mmu->subject<<16) & ~0xFFFFUL;
mmu->updates[0].ptr = (unsigned long)(mmu->subject<< 0) & ~0xFFFFUL;
- mmu->updates[1].val = (unsigned long)(mmu->subject>>16) & ~0xFFFFUL;
- mmu->updates[1].ptr = (unsigned long)(mmu->subject>>32) & ~0xFFFFUL;
mmu->updates[0].ptr |= MMU_EXTENDED_COMMAND;
- mmu->updates[0].val |= MMUEXT_SET_SUBJECTDOM_L;
- mmu->updates[1].ptr |= MMU_EXTENDED_COMMAND;
- mmu->updates[1].val |= MMUEXT_SET_SUBJECTDOM_H | SET_PAGETABLE_SUBJECTDOM;
+ mmu->updates[0].val |= MMUEXT_SET_SUBJECTDOM | SET_PAGETABLE_SUBJECTDOM;
hypercall.op = __HYPERVISOR_mmu_update;
hypercall.arg[0] = (unsigned long)mmu->updates;
/* this function is a hack until we get proper synchronous domain stop */
int xc_domain_stop_sync( int xc_handle, domid_t domid,
- dom0_op_t *op, full_execution_context_t *ctxt)
+ dom0_op_t *op, full_execution_context_t *ctxt)
{
int i;
printf("Sleep:");
- for(i=0;;i++)
+ for( i = 0; ; i++ )
{
- op->cmd = DOM0_STOPDOMAIN;
- op->u.stopdomain.domain = (domid_t)domid;
- op->u.stopdomain.sync = 1;
- do_dom0_op(xc_handle, op);
- /* can't trust return code due to sync stop hack :-(( */
+ op->cmd = DOM0_STOPDOMAIN;
+ op->u.stopdomain.domain = (domid_t)domid;
+ op->u.stopdomain.sync = 1;
+ do_dom0_op(xc_handle, op);
+ /* can't trust return code due to sync stop hack :-(( */
-
op->cmd = DOM0_GETDOMAININFO;
op->u.getdomaininfo.domain = (domid_t)domid;
op->u.getdomaininfo.ctxt = ctxt;
if ( (do_dom0_op(xc_handle, op) < 0) ||
- ((u64)op->u.getdomaininfo.domain != domid) )
+ ((u32)op->u.getdomaininfo.domain != domid) )
{
PERROR("Could not get info on domain");
goto out;
}
if ( op->u.getdomaininfo.state == DOMSTATE_STOPPED )
- {
- printf("Domain %lld stopped\n",domid);
+ {
+ printf("Domain %u stopped\n",domid);
return 0;
- }
-
- printf(".");
-
- //usleep(1000);
+ }
+
+ printf(".");
}
printf("\n");
-out:
+ out:
return -1;
}
op.u.getdomaininfo.domain = (domid_t)domid;
op.u.getdomaininfo.ctxt = NULL;
if ( (do_dom0_op(xc_handle, &op) < 0) ||
- ((u64)op.u.getdomaininfo.domain != domid) )
+ ((u32)op.u.getdomaininfo.domain != domid) )
{
- PERROR("Could not get info on domain");
- return -1;
+ PERROR("Could not get info on domain");
+ return -1;
}
return op.u.getdomaininfo.cpu_time;
}
/**********************************************************************/
-// this is shared between save and restore, and may be useful.
-
-unsigned long csum_page ( void * page )
+/* This is shared between save and restore, and may generally be useful. */
+unsigned long csum_page (void * page)
{
int i;
unsigned long *p = page;
unsigned long long sum=0;
- for (i=0;i<PAGE_SIZE/sizeof(unsigned long);i++)
- {
- sum += p[i];
- }
+ for ( i = 0; i < (PAGE_SIZE/sizeof(unsigned long)); i++ )
+ sum += p[i];
return sum ^ (sum>>32);
}
#include "xc_private.h"
int xc_vbd_create(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned short vbdid,
int writeable)
{
int xc_vbd_destroy(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned short vbdid)
{
block_io_op_t op;
int xc_vbd_grow(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned short vbdid,
xc_vbdextent_t *extent)
{
int xc_vbd_shrink(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned short vbdid)
{
block_io_op_t op;
int xc_vbd_setextents(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned short vbdid,
unsigned int nr_extents,
xc_vbdextent_t *extents)
int xc_vbd_getextents(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned short vbdid,
unsigned int max_extents,
xc_vbdextent_t *extents,
int xc_vbd_probe(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int max_vbds,
xc_vbd_t *vbds)
{
if ( !(xdi->disks[i].info & XD_FLAG_VIRT) )
continue;
- vbds[j].domid = (u64)xdi->disks[i].domain;
+ vbds[j].domid = (u32)xdi->disks[i].domain;
vbds[j].vbdid = xdi->disks[i].device;
vbds[j].flags = (xdi->disks[i].info & XD_FLAG_RO) ?
0 : XC_VBDF_WRITEABLE;
#include "xc_private.h"
int xc_vif_scheduler_set(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int vifid,
xc_vif_sched_params_t *params)
{
int xc_vif_scheduler_get(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int vifid,
xc_vif_sched_params_t *params)
{
int xc_vif_stats_get(int xc_handle,
- u64 domid,
+ u32 domid,
unsigned int vifid,
xc_vif_stats_t *stats)
{
unsigned int mem_kb = 0;
char *name = "(anon)";
int cpu = -1;
- u64 dom;
+ u32 dom;
int ret;
static char *kwd_list[] = { "mem_kb", "name", "cpu", NULL };
if ( (ret = xc_domain_create(xc->xc_handle, mem_kb, name, cpu, &dom)) < 0 )
return PyErr_SetFromErrno(xc_error);
- return PyLong_FromUnsignedLongLong(dom);
+ return PyInt_FromLong(dom);
}
static PyObject *pyxc_domain_start(PyObject *self,
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
static char *kwd_list[] = { "dom", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "L", kwd_list, &dom) )
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "i", kwd_list, &dom) )
return NULL;
if ( xc_domain_start(xc->xc_handle, dom) != 0 )
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
static char *kwd_list[] = { "dom", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "L", kwd_list, &dom) )
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "i", kwd_list, &dom) )
return NULL;
if ( xc_domain_stop(xc->xc_handle, dom) != 0 )
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
int force = 0;
static char *kwd_list[] = { "dom", "force", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "L|i", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "i|i", kwd_list,
&dom, &force) )
return NULL;
}
static PyObject *pyxc_domain_pincpu(PyObject *self,
- PyObject *args,
- PyObject *kwds)
+ PyObject *args,
+ PyObject *kwds)
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
int cpu = -1;
static char *kwd_list[] = { "dom", "cpu", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "L|i", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "i|i", kwd_list,
&dom, &cpu) )
return NULL;
XcObject *xc = (XcObject *)self;
PyObject *list;
- u64 first_dom = 0;
+ u32 first_dom = 0;
int max_doms = 1024, nr_doms, i;
xc_dominfo_t *info;
static char *kwd_list[] = { "first_dom", "max_doms", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "|Li", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwd_list,
&first_dom, &max_doms) )
return NULL;
{
PyList_SetItem(
list, i,
- Py_BuildValue("{s:L,s:i,s:i,s:i,s:l,s:L,s:s,s:l}",
+ Py_BuildValue("{s:i,s:i,s:i,s:i,s:l,s:L,s:s,s:l}",
"dom", info[i].domid,
"cpu", info[i].cpu,
"running", info[i].has_cpu,
"cpu_time", info[i].cpu_time,
"name", info[i].name,
"maxmem_kb",info[i].max_memkb
- ));
+ ));
}
free(info);
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
char *state_file;
int progress = 1, live = -1, debug = 0;
unsigned int flags = 0;
- static char *kwd_list[] = { "dom", "state_file", "progress", "live", "debug", NULL };
+ static char *kwd_list[] = { "dom", "state_file", "progress",
+ "live", "debug", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Ls|iii", kwd_list,
- &dom, &state_file, &progress, &live, &debug) )
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "is|iii", kwd_list,
+ &dom, &state_file, &progress,
+ &live, &debug) )
return NULL;
if (progress) flags |= XCFLAGS_VERBOSE;
if ( strncmp(state_file,"tcp:", strlen("tcp:")) == 0 )
{
#define max_namelen 64
- char server[max_namelen];
- char *port_s;
- int port=777;
- int sd = -1;
- struct hostent *h;
- struct sockaddr_in s;
- int sockbufsize;
- int rc = -1;
-
- int writerfn(void *fd, const void *buf, size_t count)
- {
- int tot = 0, rc;
- do {
- rc = write( (int) fd, ((char*)buf)+tot, count-tot );
- if ( rc < 0 ) { perror("WRITE"); return rc; };
- tot += rc;
- }
- while ( tot < count );
- return 0;
- }
-
- if (live == -1) flags |= XCFLAGS_LIVE; // default to live for tcp
-
- strncpy( server, state_file+strlen("tcp://"), max_namelen);
- server[max_namelen-1]='\0';
- if ( (port_s = strchr(server,':')) != NULL )
- {
- *port_s = '\0';
- port = atoi(port_s+1);
- }
-
- printf("X server=%s port=%d\n",server,port);
-
- h = gethostbyname(server);
- sd = socket (AF_INET,SOCK_STREAM,0);
- if ( sd < 0 )
+ char server[max_namelen];
+ char *port_s;
+ int port=777;
+ int sd = -1;
+ struct hostent *h;
+ struct sockaddr_in s;
+ int sockbufsize;
+ int rc = -1;
+
+ int writerfn(void *fd, const void *buf, size_t count)
+ {
+ int tot = 0, rc;
+ do {
+ rc = write( (int) fd, ((char*)buf)+tot, count-tot );
+ if ( rc < 0 ) { perror("WRITE"); return rc; };
+ tot += rc;
+ }
+ while ( tot < count );
+ return 0;
+ }
+
+ if (live == -1) flags |= XCFLAGS_LIVE; /* default to live for tcp */
+
+ strncpy( server, state_file+strlen("tcp://"), max_namelen);
+ server[max_namelen-1]='\0';
+ if ( (port_s = strchr(server,':')) != NULL )
+ {
+ *port_s = '\0';
+ port = atoi(port_s+1);
+ }
+
+ printf("X server=%s port=%d\n",server,port);
+
+ h = gethostbyname(server);
+ sd = socket (AF_INET,SOCK_STREAM,0);
+ if ( sd < 0 )
+ goto serr;
+ s.sin_family = AF_INET;
+ bcopy ( h->h_addr, &(s.sin_addr.s_addr), h->h_length);
+ s.sin_port = htons(port);
+ if ( connect(sd, (struct sockaddr *) &s, sizeof(s)) )
goto serr;
- s.sin_family = AF_INET;
- bcopy ( h->h_addr, &(s.sin_addr.s_addr), h->h_length);
- s.sin_port = htons(port);
- if ( connect(sd, (struct sockaddr *) &s, sizeof(s)) )
- goto serr;
-
- sockbufsize=128*1024;
- if ( setsockopt(sd, SOL_SOCKET, SO_SNDBUF,
+
+ sockbufsize=128*1024;
+ if ( setsockopt(sd, SOL_SOCKET, SO_SNDBUF,
&sockbufsize, sizeof sockbufsize) < 0 )
- goto serr;
+ goto serr;
- if ( xc_linux_save(xc->xc_handle, dom, flags,
+ if ( xc_linux_save(xc->xc_handle, dom, flags,
writerfn, (void*)sd) == 0 )
- {
- if ( read( sd, &rc, sizeof(int) ) != sizeof(int) )
- goto serr;
-
- if ( rc == 0 )
- {
- printf("Migration succesful -- destroy local copy\n");
- xc_domain_destroy( xc->xc_handle, dom, 1 );
- close(sd);
- Py_INCREF(zero);
- return zero;
- }
- else
- errno = rc;
- }
+ {
+ if ( read( sd, &rc, sizeof(int) ) != sizeof(int) )
+ goto serr;
+
+ if ( rc == 0 )
+ {
+ printf("Migration succesful -- destroy local copy\n");
+ xc_domain_destroy( xc->xc_handle, dom, 1 );
+ close(sd);
+ Py_INCREF(zero);
+ return zero;
+ }
+ else
+ errno = rc;
+ }
serr:
- printf("Migration failed -- restart local copy\n");
- xc_domain_start( xc->xc_handle, dom );
- PyErr_SetFromErrno(xc_error);
- if ( sd >= 0 ) close(sd);
- return NULL;
+ printf("Migration failed -- restart local copy\n");
+ xc_domain_start( xc->xc_handle, dom );
+ PyErr_SetFromErrno(xc_error);
+ if ( sd >= 0 ) close(sd);
+ return NULL;
}
else
{
- int fd = -1;
- gzFile gfd = NULL;
-
- int writerfn(void *fd, const void *buf, size_t count)
- {
- int rc;
- while ( ((rc = gzwrite( (gzFile*)fd, (void*)buf, count)) == -1) &&
- (errno = EINTR) )
- continue;
- return ! (rc == count);
- }
-
- if (strncmp(state_file,"file:",strlen("file:")) == 0)
- state_file += strlen("file:");
-
- if ( (fd = open(state_file, O_CREAT|O_EXCL|O_WRONLY, 0644)) == -1 )
- {
- perror("Could not open file for writing");
- goto err;
- }
-
- /*
- * Compression rate 1: we want speed over compression.
- * We're mainly going for those zero pages, after all.
- */
-
- if ( (gfd = gzdopen(fd, "wb1")) == NULL )
- {
- perror("Could not allocate compression state for state file");
- close(fd);
- goto err;
- }
-
-
- if ( xc_linux_save(xc->xc_handle, dom, flags, writerfn, gfd) == 0 )
- {
- /* kill domain. We don't want to do this for checkpointing, but
- if we don't do it here I think people will hurt themselves
- by accident... */
- xc_domain_destroy( xc->xc_handle, dom, 1 );
- gzclose(gfd);
- close(fd);
-
- Py_INCREF(zero);
- return zero;
- }
+ int fd = -1;
+ gzFile gfd = NULL;
+
+ int writerfn(void *fd, const void *buf, size_t count)
+ {
+ int rc;
+ while ( ((rc = gzwrite( (gzFile*)fd, (void*)buf, count)) == -1) &&
+ (errno = EINTR) )
+ continue;
+ return ! (rc == count);
+ }
+
+ if (strncmp(state_file,"file:",strlen("file:")) == 0)
+ state_file += strlen("file:");
+
+ if ( (fd = open(state_file, O_CREAT|O_EXCL|O_WRONLY, 0644)) == -1 )
+ {
+ perror("Could not open file for writing");
+ goto err;
+ }
+
+ /*
+ * Compression rate 1: we want speed over compression.
+ * We're mainly going for those zero pages, after all.
+ */
+
+ if ( (gfd = gzdopen(fd, "wb1")) == NULL )
+ {
+ perror("Could not allocate compression state for state file");
+ close(fd);
+ goto err;
+ }
+
+
+ if ( xc_linux_save(xc->xc_handle, dom, flags, writerfn, gfd) == 0 )
+ {
+ /* kill domain. We don't want to do this for checkpointing, but
+ if we don't do it here I think people will hurt themselves
+ by accident... */
+ xc_domain_destroy( xc->xc_handle, dom, 1 );
+ gzclose(gfd);
+ close(fd);
+
+ Py_INCREF(zero);
+ return zero;
+ }
err:
- PyErr_SetFromErrno(xc_error);
- if ( gfd != NULL )
+ PyErr_SetFromErrno(xc_error);
+ if ( gfd != NULL )
gzclose(gfd);
- if ( fd >= 0 )
+ if ( fd >= 0 )
close(fd);
- unlink(state_file);
- return NULL;
+ unlink(state_file);
+ return NULL;
}
}
char *state_file;
int progress = 1;
- u64 dom;
+ u32 dom;
unsigned int flags = 0;
static char *kwd_list[] = { "dom", "state_file", "progress", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Ls|i", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "is|i", kwd_list,
&dom, &state_file, &progress) )
return NULL;
if ( strncmp(state_file,"tcp:", strlen("tcp:")) == 0 )
{
#define max_namelen 64
- char server[max_namelen];
- char *port_s;
- int port=777;
- int ld = -1, sd = -1;
- struct hostent *h;
- struct sockaddr_in s, d, p;
- socklen_t dlen, plen;
- int sockbufsize;
- int on = 1, rc = -1;
-
- int readerfn(void *fd, void *buf, size_t count)
- {
- int rc, tot = 0;
- do {
- rc = read( (int) fd, ((char*)buf)+tot, count-tot );
- if ( rc < 0 ) { perror("READ"); return rc; }
- if ( rc == 0 ) { printf("read: need %d, tot=%d got zero\n",count-tot,tot); return -1; }
- tot += rc;
- }
+ char server[max_namelen];
+ char *port_s;
+ int port=777;
+ int ld = -1, sd = -1;
+ struct hostent *h;
+ struct sockaddr_in s, d, p;
+ socklen_t dlen, plen;
+ int sockbufsize;
+ int on = 1, rc = -1;
+
+ int readerfn(void *fd, void *buf, size_t count)
+ {
+ int rc, tot = 0;
+ do {
+ rc = read( (int) fd, ((char*)buf)+tot, count-tot );
+ if ( rc < 0 ) { perror("READ"); return rc; }
+ if ( rc == 0 ) { printf("read: need %d, tot=%d got zero\n",
+ count-tot, tot); return -1; }
+ tot += rc;
+ }
while ( tot < count );
- return 0;
- }
-
- strncpy( server, state_file+strlen("tcp://"), max_namelen);
- server[max_namelen-1]='\0';
- if ( (port_s = strchr(server,':')) != NULL )
- {
- *port_s = '\0';
- port = atoi(port_s+1);
- }
-
- printf("X server=%s port=%d\n",server,port);
-
- h = gethostbyname(server);
- ld = socket (AF_INET,SOCK_STREAM,0);
- if ( ld < 0 ) goto serr;
- s.sin_family = AF_INET;
- //bcopy ( h->h_addr, &(s.sin_addr.s_addr), h->h_length);
- s.sin_addr.s_addr = htonl(INADDR_ANY);
- s.sin_port = htons(port);
-
- if ( setsockopt(ld, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) < 0 )
- goto serr;
-
- if ( bind(ld, (struct sockaddr *) &s, sizeof(s)) )
- goto serr;
-
- if ( listen(ld, 1) )
- goto serr;
-
- dlen=sizeof(struct sockaddr);
- if ( (sd = accept(ld, (struct sockaddr *) &d, &dlen )) < 0 )
- goto serr;
+ return 0;
+ }
+
+ strncpy( server, state_file+strlen("tcp://"), max_namelen);
+ server[max_namelen-1]='\0';
+ if ( (port_s = strchr(server,':')) != NULL )
+ {
+ *port_s = '\0';
+ port = atoi(port_s+1);
+ }
+
+ printf("X server=%s port=%d\n",server,port);
+
+ h = gethostbyname(server);
+ ld = socket (AF_INET,SOCK_STREAM,0);
+ if ( ld < 0 ) goto serr;
+ s.sin_family = AF_INET;
+ s.sin_addr.s_addr = htonl(INADDR_ANY);
+ s.sin_port = htons(port);
+
+ if ( setsockopt(ld, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) < 0 )
+ goto serr;
+
+ if ( bind(ld, (struct sockaddr *) &s, sizeof(s)) )
+ goto serr;
+
+ if ( listen(ld, 1) )
+ goto serr;
+
+ dlen=sizeof(struct sockaddr);
+ if ( (sd = accept(ld, (struct sockaddr *) &d, &dlen )) < 0 )
+ goto serr;
plen = sizeof(p);
- if ( getpeername(sd, (struct sockaddr_in *) &p,
+ if ( getpeername(sd, (struct sockaddr_in *) &p,
&plen) < 0 )
- goto serr;
+ goto serr;
- printf("Accepted connection from %s\n", inet_ntoa(p.sin_addr));
-
- sockbufsize=128*1024;
- if ( setsockopt(sd, SOL_SOCKET, SO_SNDBUF, &sockbufsize,
+ printf("Accepted connection from %s\n", inet_ntoa(p.sin_addr));
+
+ sockbufsize=128*1024;
+ if ( setsockopt(sd, SOL_SOCKET, SO_SNDBUF, &sockbufsize,
sizeof sockbufsize) < 0 )
- goto serr;
+ goto serr;
- rc = xc_linux_restore(xc->xc_handle, dom, flags,
+ rc = xc_linux_restore(xc->xc_handle, dom, flags,
readerfn, (void*)sd, &dom);
- write( sd, &rc, sizeof(int) );
+ write( sd, &rc, sizeof(int) );
- if (rc == 0)
- {
- close(sd);
- Py_INCREF(zero);
- return zero;
- }
- errno = rc;
+ if (rc == 0)
+ {
+ close(sd);
+ Py_INCREF(zero);
+ return zero;
+ }
+ errno = rc;
serr:
- PyErr_SetFromErrno(xc_error);
- if ( ld >= 0 ) close(ld);
- if ( sd >= 0 ) close(sd);
- return NULL;
+ PyErr_SetFromErrno(xc_error);
+ if ( ld >= 0 ) close(ld);
+ if ( sd >= 0 ) close(sd);
+ return NULL;
}
else
{
- int fd = -1;
- gzFile gfd = NULL;
-
- int readerfn(void *fd, void *buf, size_t count)
- {
- int rc;
- while ( ((rc = gzread( (gzFile*)fd, (void*)buf, count)) == -1) &&
- (errno = EINTR) )
- continue;
- return ! (rc == count);
- }
-
- if ( strncmp(state_file,"file:",strlen("file:")) == 0 )
- state_file += strlen("file:");
-
- if ( (fd = open(state_file, O_RDONLY)) == -1 )
- {
- perror("Could not open file for writing");
- goto err;
- }
-
- /*
- * Compression rate 1: we want speed over compression.
- * We're mainly going for those zero pages, after all.
- */
-
- if ( (gfd = gzdopen(fd, "rb")) == NULL )
- {
- perror("Could not allocate compression state for state file");
- close(fd);
- goto err;
- }
-
-
- if ( xc_linux_restore(xc->xc_handle, dom, flags,
+ int fd = -1;
+ gzFile gfd = NULL;
+
+ int readerfn(void *fd, void *buf, size_t count)
+ {
+ int rc;
+ while ( ((rc = gzread( (gzFile*)fd, (void*)buf, count)) == -1) &&
+ (errno = EINTR) )
+ continue;
+ return ! (rc == count);
+ }
+
+ if ( strncmp(state_file,"file:",strlen("file:")) == 0 )
+ state_file += strlen("file:");
+
+ if ( (fd = open(state_file, O_RDONLY)) == -1 )
+ {
+ perror("Could not open file for writing");
+ goto err;
+ }
+
+ /*
+ * Compression rate 1: we want speed over compression.
+ * We're mainly going for those zero pages, after all.
+ */
+ if ( (gfd = gzdopen(fd, "rb")) == NULL )
+ {
+ perror("Could not allocate compression state for state file");
+ close(fd);
+ goto err;
+ }
+
+
+ if ( xc_linux_restore(xc->xc_handle, dom, flags,
readerfn, gfd, &dom) == 0 )
- {
- gzclose(gfd);
- close(fd);
+ {
+ gzclose(gfd);
+ close(fd);
- Py_INCREF(zero);
- return zero;
- }
+ Py_INCREF(zero);
+ return zero;
+ }
err:
- PyErr_SetFromErrno(xc_error);
- if ( gfd != NULL ) gzclose(gfd);
- if ( fd >= 0 ) close(fd);
- return NULL;
+ PyErr_SetFromErrno(xc_error);
+ if ( gfd != NULL ) gzclose(gfd);
+ if ( fd >= 0 ) close(fd);
+ return NULL;
}
}
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
char *image, *ramdisk = NULL, *cmdline = "";
int control_evtchn;
static char *kwd_list[] = { "dom", "control_evtchn",
"image", "ramdisk", "cmdline", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Lis|ss", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "iis|ss", kwd_list,
&dom, &control_evtchn,
&image, &ramdisk, &cmdline) )
return NULL;
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
char *image, *ramdisk = NULL, *cmdline = "";
int control_evtchn;
static char *kwd_list[] = { "dom", "control_evtchn",
"image", "ramdisk", "cmdline", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Lis|ssi", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "iis|ssi", kwd_list,
&dom, &control_evtchn,
&image, &ramdisk, &cmdline) )
return NULL;
}
static PyObject *pyxc_bvtsched_global_get(PyObject *self,
- PyObject *args,
- PyObject *kwds)
+ PyObject *args,
+ PyObject *kwds)
{
XcObject *xc = (XcObject *)self;
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
unsigned long mcuadv, warp, warpl, warpu;
static char *kwd_list[] = { "dom", "mcuadv", "warp", "warpl",
"warpu", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Lllll", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "illll", kwd_list,
&dom, &mcuadv, &warp, &warpl, &warpu) )
return NULL;
PyObject *kwds)
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
unsigned long mcuadv, warp, warpl, warpu;
static char *kwd_list[] = { "dom", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "L", kwd_list, &dom) )
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "i", kwd_list, &dom) )
return NULL;
if ( xc_bvtsched_domain_get(xc->xc_handle, dom, &mcuadv, &warp,
&warpl, &warpu) != 0 )
return PyErr_SetFromErrno(xc_error);
- return Py_BuildValue("{s:L,s:l,s:l,s:l,s:l}",
+ return Py_BuildValue("{s:i,s:l,s:l,s:l,s:l}",
"domain", dom,
"mcuadv", mcuadv,
"warp", warp,
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
unsigned int vif;
xc_vif_sched_params_t sched = { 0, 0 };
static char *kwd_list[] = { "dom", "vif", "credit_bytes",
"credit_usecs", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Li|ll", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "ii|ll", kwd_list,
&dom, &vif,
&sched.credit_bytes,
&sched.credit_usec) )
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
unsigned int vif;
xc_vif_sched_params_t sched;
static char *kwd_list[] = { "dom", "vif", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Li", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "ii", kwd_list,
&dom, &vif) )
return NULL;
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
unsigned int vif;
xc_vif_stats_t stats;
static char *kwd_list[] = { "dom", "vif", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Li", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "ii", kwd_list,
&dom, &vif) )
return NULL;
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
unsigned int vbd;
int writeable;
static char *kwd_list[] = { "dom", "vbd", "writeable", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Lii", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "iii", kwd_list,
&dom, &vbd, &writeable) )
return NULL;
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
unsigned int vbd;
static char *kwd_list[] = { "dom", "vbd", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Li", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "ii", kwd_list,
&dom, &vbd) )
return NULL;
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
unsigned int vbd;
xc_vbdextent_t extent;
static char *kwd_list[] = { "dom", "vbd", "device",
"start_sector", "nr_sectors", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "LiiLL", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "iiiLL", kwd_list,
&dom, &vbd,
&extent.real_device,
&extent.start_sector,
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
unsigned int vbd;
static char *kwd_list[] = { "dom", "vbd", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Li", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "ii", kwd_list,
&dom, &vbd) )
return NULL;
XcObject *xc = (XcObject *)self;
PyObject *list, *dict, *obj;
- u64 dom;
+ u32 dom;
unsigned int vbd;
xc_vbdextent_t *extents = NULL;
int i, nr_extents;
static char *kwd_list[] = { "dom", "vbd", "extents", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "LiO", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "iiO", kwd_list,
&dom, &vbd, &list) )
return NULL;
XcObject *xc = (XcObject *)self;
PyObject *list;
- u64 dom;
+ u32 dom;
unsigned int vbd;
xc_vbdextent_t *extents;
int i, nr_extents;
static char *kwd_list[] = { "dom", "vbd", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Li", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "ii", kwd_list,
&dom, &vbd) )
return NULL;
XcObject *xc = (XcObject *)self;
PyObject *list;
- u64 dom = XC_VBDDOM_PROBE_ALL;
+ u32 dom = XC_VBDDOM_PROBE_ALL;
unsigned int max_vbds = 1024;
xc_vbd_t *info;
int nr_vbds, i;
static char *kwd_list[] = { "dom", "max_vbds", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "|Li", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwd_list,
&dom, &max_vbds) )
return NULL;
{
PyList_SetItem(
list, i,
- Py_BuildValue("{s:L,s:i,s:i,s:L}",
+ Py_BuildValue("{s:i,s:i,s:i,s:L}",
"dom", info[i].domid,
"vbd", info[i].vbdid,
"writeable", !!(info[i].flags & XC_VBDF_WRITEABLE),
{
XcObject *xc = (XcObject *)self;
- u64 dom1 = DOMID_SELF, dom2 = DOMID_SELF;
+ u32 dom1 = DOMID_SELF, dom2 = DOMID_SELF;
int port1, port2;
static char *kwd_list[] = { "dom1", "dom2", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "|LL", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwd_list,
&dom1, &dom2) )
return NULL;
{
XcObject *xc = (XcObject *)self;
- u64 dom = DOMID_SELF;
+ u32 dom = DOMID_SELF;
int port;
static char *kwd_list[] = { "port", "dom", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "i|L", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "i|i", kwd_list,
&port, &dom) )
return NULL;
XcObject *xc = (XcObject *)self;
PyObject *dict;
- u64 dom = DOMID_SELF;
+ u32 dom = DOMID_SELF;
int port, ret;
xc_evtchn_status_t status;
static char *kwd_list[] = { "port", "dom", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "i|L", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "i|i", kwd_list,
&port, &dom) )
return NULL;
"status", "unbound");
break;
case EVTCHNSTAT_interdomain:
- dict = Py_BuildValue("{s:s,s:L,s:i}",
+ dict = Py_BuildValue("{s:s,s:i,s:i}",
"status", "interdomain",
"dom", status.u.interdomain.dom,
"port", status.u.interdomain.port);
PyObject *kwds)
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
int bus, dev, func, enable, ret;
static char *kwd_list[] = { "dom", "bus", "dev", "func", "enable", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Liiii", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "iiiii", kwd_list,
&dom, &bus, &dev, &func, &enable) )
return NULL;
}
static PyObject *pyxc_physinfo(PyObject *self,
- PyObject *args,
- PyObject *kwds)
+ PyObject *args,
+ PyObject *kwds)
{
XcObject *xc = (XcObject *)self;
xc_physinfo_t info;
PyObject *kwds)
{
XcObject *xc = (XcObject *)self;
- u64 domid;
+ u32 domid;
u64 period, slice, latency;
int xtratime;
static char *kwd_list[] = { "dom", "period", "slice", "latency",
- "xtratime", NULL };
+ "xtratime", NULL };
- if( !PyArg_ParseTupleAndKeywords(args, kwds, "LLLLi", kwd_list, &domid,
+ if( !PyArg_ParseTupleAndKeywords(args, kwds, "iLLLi", kwd_list, &domid,
&period, &slice, &latency, &xtratime) )
return NULL;
if ( xc_atropos_domain_set(xc->xc_handle, domid, period, slice,
- latency, xtratime) != 0 )
+ latency, xtratime) != 0 )
return PyErr_SetFromErrno(xc_error);
Py_INCREF(zero);
PyObject *kwds)
{
XcObject *xc = (XcObject *)self;
- u64 domid;
+ u32 domid;
u64 period, slice, latency;
int xtratime;
static char *kwd_list[] = { "dom", NULL };
- if( !PyArg_ParseTupleAndKeywords(args, kwds, "L", kwd_list, &domid) )
+ if( !PyArg_ParseTupleAndKeywords(args, kwds, "i", kwd_list, &domid) )
return NULL;
if ( xc_atropos_domain_get( xc->xc_handle, domid, &period,
&slice, &latency, &xtratime ) )
return PyErr_SetFromErrno(xc_error);
- return Py_BuildValue("{s:L,s:L,s:L,s:L,s:i}",
+ return Py_BuildValue("{s:i,s:L,s:L,s:L,s:i}",
"domain", domid,
"period", period,
"slice", slice,
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
int op=0;
static char *kwd_list[] = { "dom", "op", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "L|i", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "i|i", kwd_list,
&dom, &op) )
return NULL;
PyObject *kwds)
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
char *name;
static char *kwd_list[] = { "dom", "name", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Ls", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "is", kwd_list,
&dom, &name) )
return NULL;
}
static PyObject *pyxc_domain_setmaxmem(PyObject *self,
- PyObject *args,
- PyObject *kwds)
+ PyObject *args,
+ PyObject *kwds)
{
XcObject *xc = (XcObject *)self;
- u64 dom;
+ u32 dom;
unsigned long max_memkb;
static char *kwd_list[] = { "dom", "max_memkb", NULL };
- if ( !PyArg_ParseTupleAndKeywords(args, kwds, "Li", kwd_list,
+ if ( !PyArg_ParseTupleAndKeywords(args, kwds, "ii", kwd_list,
&dom, &max_memkb) )
return NULL;
"Create a new domain.\n"
" mem_kb [int, 65536]: Memory allocation, in kilobytes.\n"
" name [str, '(anon)']: Informative textual name.\n\n"
- "Returns: [long] new domain identifier; -1 on error.\n" },
+ "Returns: [int] new domain identifier; -1 on error.\n" },
{ "domain_start",
(PyCFunction)pyxc_domain_start,
METH_VARARGS | METH_KEYWORDS, "\n"
"Start execution of a domain.\n"
- " dom [long]: Identifier of domain to be started.\n\n"
+ " dom [int]: Identifier of domain to be started.\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
{ "domain_stop",
(PyCFunction)pyxc_domain_stop,
METH_VARARGS | METH_KEYWORDS, "\n"
"Stop execution of a domain.\n"
- " dom [long]: Identifier of domain to be stopped.\n\n"
+ " dom [int]: Identifier of domain to be stopped.\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
{ "domain_destroy",
(PyCFunction)pyxc_domain_destroy,
METH_VARARGS | METH_KEYWORDS, "\n"
"Destroy a domain.\n"
- " dom [long]: Identifier of domain to be destroyed.\n"
+ " dom [int]: Identifier of domain to be destroyed.\n"
" force [int, 0]: Bool - force immediate destruction?\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
(PyCFunction)pyxc_domain_pincpu,
METH_VARARGS | METH_KEYWORDS, "\n"
"Pin a domain to a specified CPU.\n"
- " dom [long]: Identifier of domain to be pinned.\n"
+ " dom [int]: Identifier of domain to be pinned.\n"
" cpu [int, -1]: CPU to pin to, or -1 to unpin\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
(PyCFunction)pyxc_domain_getinfo,
METH_VARARGS | METH_KEYWORDS, "\n"
"Get information regarding a set of domains, in increasing id order.\n"
- " first_dom [long, 0]: First domain to retrieve info about.\n"
+ " first_dom [int, 0]: First domain to retrieve info about.\n"
" max_doms [int, 1024]: Maximum number of domains to retrieve info"
" about.\n\n"
"Returns: [list of dicts] if list length is less than 'max_doms'\n"
" parameter then there was an error, or the end of the\n"
" domain-id space was reached.\n"
- " dom [long]: Identifier of domain to which this info pertains\n"
+ " dom [int]: Identifier of domain to which this info pertains\n"
" cpu [int]: CPU to which this domain is bound\n"
" running [int]: Bool - is the domain currently running?\n"
" stopped [int]: Bool - is the domain suspended?\n"
(PyCFunction)pyxc_linux_save,
METH_VARARGS | METH_KEYWORDS, "\n"
"Save the CPU and memory state of a Linux guest OS.\n"
- " dom [long]: Identifier of domain to be saved.\n"
+ " dom [int]: Identifier of domain to be saved.\n"
" state_file [str]: Name of state file. Must not currently exist.\n"
" progress [int, 1]: Bool - display a running progress indication?\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
"Restore the CPU and memory state of a Linux guest OS.\n"
" state_file [str]: Name of state file. Must not currently exist.\n"
" progress [int, 1]: Bool - display a running progress indication?\n\n"
- "Returns: [long] new domain identifier on success; -1 on error.\n" },
+ "Returns: [int] new domain identifier on success; -1 on error.\n" },
{ "linux_build",
(PyCFunction)pyxc_linux_build,
METH_VARARGS | METH_KEYWORDS, "\n"
"Build a new Linux guest OS.\n"
- " dom [long]: Identifier of domain to build into.\n"
+ " dom [int]: Identifier of domain to build into.\n"
" image [str]: Name of kernel image file. May be gzipped.\n"
" ramdisk [str, n/a]: Name of ramdisk file, if any.\n"
" cmdline [str, n/a]: Kernel parameters, if any.\n\n"
(PyCFunction)pyxc_netbsd_build,
METH_VARARGS | METH_KEYWORDS, "\n"
"Build a new NetBSD guest OS.\n"
- " dom [long]: Identifier of domain to build into.\n"
+ " dom [int]: Identifier of domain to build into.\n"
" image [str]: Name of kernel image file. May be gzipped.\n"
" cmdline [str, n/a]: Kernel parameters, if any.\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
(PyCFunction)pyxc_bvtsched_domain_set,
METH_VARARGS | METH_KEYWORDS, "\n"
"Set per-domain tuning parameters for Borrowed Virtual Time scheduler.\n"
- " dom [long]: Identifier of domain to be tuned.\n"
- " mcuadv [int]: Proportional to the inverse of the domain's weight.\n"
- " warp [int]: How far to warp domain's EVT on unblock.\n"
- " warpl [int]: How long the domain can run warped.\n"
- " warpu [int]: How long before the domain can warp again.\n\n"
+ " dom [int]: Identifier of domain to be tuned.\n"
+ " mcuadv [int]: Proportional to the inverse of the domain's weight.\n"
+ " warp [int]: How far to warp domain's EVT on unblock.\n"
+ " warpl [int]: How long the domain can run warped.\n"
+ " warpu [int]: How long before the domain can warp again.\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
{ "bvtsched_domain_get",
(PyCFunction)pyxc_bvtsched_domain_get,
METH_KEYWORDS, "\n"
"Get per-domain tuning parameters under the BVT scheduler.\n"
- " dom [long]: Identifier of domain to be queried.\n"
+ " dom [int]: Identifier of domain to be queried.\n"
"Returns [dict]:\n"
- " domain [long]: Domain ID.\n"
+ " domain [int]: Domain ID.\n"
" mcuadv [long]: MCU Advance.\n"
" warp [long]: Warp.\n"
" warpu [long]: Unwarp requirement.\n"
(PyCFunction)pyxc_atropos_domain_set,
METH_KEYWORDS, "\n"
"Set the scheduling parameters for a domain when running with Atropos.\n"
- " dom [long]: domain to set\n"
+ " dom [int]: domain to set\n"
" period [long]: domain's scheduling period\n"
" slice [long]: domain's slice per period\n"
" latency [long]: wakeup latency hint\n"
METH_KEYWORDS, "\n"
"Get the current scheduling parameters for a domain when running with\n"
"the Atropos scheduler."
- " dom [long]: domain to query\n"
+ " dom [int]: domain to query\n"
"Returns: [dict]\n"
- " domain [long]: domain ID\n"
+ " domain [int]: domain ID\n"
" period [long]: scheduler period\n"
" slice [long]: CPU reservation per period\n"
" latency [long]: unblocking latency hint\n"
(PyCFunction)pyxc_vif_scheduler_set,
METH_VARARGS | METH_KEYWORDS, "\n"
"Set per-network-interface scheduling parameters.\n"
- " dom [long]: Identifier of domain to be adjusted.\n"
+ " dom [int]: Identifier of domain to be adjusted.\n"
" vif [int]: Identifier of VIF to be adjusted.\n"
" credit_bytes [int, 0]: Tx bytes permitted each interval.\n"
" credit_usecs [int, 0]: Interval, in usecs. 0 == no scheduling.\n\n"
(PyCFunction)pyxc_vif_scheduler_get,
METH_VARARGS | METH_KEYWORDS, "\n"
"Query the per-network-interface scheduling parameters.\n"
- " dom [long]: Identifier of domain to be queried.\n"
- " vif [int]: Identifier of VIF to be queried.\n\n"
+ " dom [int]: Identifier of domain to be queried.\n"
+ " vif [int]: Identifier of VIF to be queried.\n\n"
"Returns: [dict] dictionary is empty on failure.\n"
" credit_bytes [int]: Tx bytes permitted each interval.\n"
" credit_usecs [int]: Interval, in usecs. 0 == no scheduling.\n" },
(PyCFunction)pyxc_vif_stats_get,
METH_VARARGS | METH_KEYWORDS, "\n"
"Query the per-network-interface statistics.\n"
- " dom [long]: Identifier of domain to be queried.\n"
+ " dom [int]: Identifier of domain to be queried.\n"
" vif [int]: Identifier of VIF to be queried.\n\n"
"Returns: [dict] dictionary is empty on failure.\n"
" tx_bytes [long]: Bytes transmitted.\n"
(PyCFunction)pyxc_vbd_create,
METH_VARARGS | METH_KEYWORDS, "\n"
"Create a new virtual block device associated with a given domain.\n"
- " dom [long]: Identifier of domain to get a new VBD.\n"
+ " dom [int]: Identifier of domain to get a new VBD.\n"
" vbd [int]: Identifier for new VBD.\n"
" writeable [int]: Bool - is the new VBD writeable?\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
(PyCFunction)pyxc_vbd_destroy,
METH_VARARGS | METH_KEYWORDS, "\n"
"Destroy a virtual block device.\n"
- " dom [long]: Identifier of domain containing the VBD.\n"
+ " dom [int]: Identifier of domain containing the VBD.\n"
" vbd [int]: Identifier of the VBD.\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
(PyCFunction)pyxc_vbd_grow,
METH_VARARGS | METH_KEYWORDS, "\n"
"Grow a virtual block device by appending a new extent.\n"
- " dom [long]: Identifier of domain containing the VBD.\n"
+ " dom [int]: Identifier of domain containing the VBD.\n"
" vbd [int]: Identifier of the VBD.\n"
" device [int]: Identifier of the real underlying block device.\n"
" start_sector [long]: Real start sector of this extent.\n"
(PyCFunction)pyxc_vbd_shrink,
METH_VARARGS | METH_KEYWORDS, "\n"
"Shrink a virtual block device by deleting its final extent.\n"
- " dom [long]: Identifier of domain containing the VBD.\n"
+ " dom [int]: Identifier of domain containing the VBD.\n"
" vbd [int]: Identifier of the VBD.\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
(PyCFunction)pyxc_vbd_setextents,
METH_VARARGS | METH_KEYWORDS, "\n"
"Set all the extent information for a virtual block device.\n"
- " dom [long]: Identifier of domain containing the VBD.\n"
+ " dom [int]: Identifier of domain containing the VBD.\n"
" vbd [int]: Identifier of the VBD.\n"
" extents [list of dicts]: Per-extent information.\n"
" device [int]: Id of the real underlying block device.\n"
(PyCFunction)pyxc_vbd_getextents,
METH_VARARGS | METH_KEYWORDS, "\n"
"Get info on all the extents in a virtual block device.\n"
- " dom [long]: Identifier of domain containing the VBD.\n"
+ " dom [int]: Identifier of domain containing the VBD.\n"
" vbd [int]: Identifier of the VBD.\n\n"
"Returns: [list of dicts] per-extent information; empty on error.\n"
" device [int]: Identifier of the real underlying block device.\n"
(PyCFunction)pyxc_vbd_probe,
METH_VARARGS | METH_KEYWORDS, "\n"
"Get information regarding extant virtual block devices.\n"
- " dom [long, ALL]: Domain to query (default is to query all).\n"
+ " dom [int, ALL]: Domain to query (default is to query all).\n"
" max_vbds [int, 1024]: Maximum VBDs to query.\n\n"
"Returns: [list of dicts] if list length is less than 'max_vbds'\n"
" parameter then there was an error, or there were fewer vbds.\n"
- " dom [long]: Domain containing this VBD.\n"
+ " dom [int]: Domain containing this VBD.\n"
" vbd [int]: Domain-specific identifier of this VBD.\n"
" writeable [int]: Bool - is this VBD writeable?\n"
" nr_sectors [long]: Size of this VBD, in 512-byte sectors.\n" },
(PyCFunction)pyxc_evtchn_bind_interdomain,
METH_VARARGS | METH_KEYWORDS, "\n"
"Open an event channel between two domains.\n"
- " dom1 [long, SELF]: First domain to be connected.\n"
- " dom2 [long, SELF]: Second domain to be connected.\n\n"
+ " dom1 [int, SELF]: First domain to be connected.\n"
+ " dom2 [int, SELF]: Second domain to be connected.\n\n"
"Returns: [dict] dictionary is empty on failure.\n"
" port1 [int]: Port-id for endpoint at dom1.\n"
" port2 [int]: Port-id for endpoint at dom2.\n" },
(PyCFunction)pyxc_evtchn_close,
METH_VARARGS | METH_KEYWORDS, "\n"
"Close an event channel.\n"
- " dom [long, SELF]: Dom-id of one endpoint of the channel.\n"
- " port [int]: Port-id of one endpoint of the channel.\n\n"
+ " dom [int, SELF]: Dom-id of one endpoint of the channel.\n"
+ " port [int]: Port-id of one endpoint of the channel.\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
{ "evtchn_send",
(PyCFunction)pyxc_evtchn_status,
METH_VARARGS | METH_KEYWORDS, "\n"
"Query the status of an event channel.\n"
- " dom [long, SELF]: Dom-id of one endpoint of the channel.\n"
- " port [int]: Port-id of one endpoint of the channel.\n\n"
+ " dom [int, SELF]: Dom-id of one endpoint of the channel.\n"
+ " port [int]: Port-id of one endpoint of the channel.\n\n"
"Returns: [dict] dictionary is empty on failure.\n"
" status [str]: 'closed', 'unbound', 'interdomain', 'pirq',"
" or 'virq'.\n"
"The following are returned if 'status' is 'interdomain':\n"
- " dom [long]: Dom-id of remote endpoint.\n"
- " port [int]: Port-id of remote endpoint.\n"
+ " dom [int]: Dom-id of remote endpoint.\n"
+ " port [int]: Port-id of remote endpoint.\n"
"The following are returned if 'status' is 'pirq' or 'virq':\n"
- " irq [int]: IRQ number.\n" },
+ " irq [int]: IRQ number.\n" },
{ "physdev_pci_access_modify",
(PyCFunction)pyxc_physdev_pci_access_modify,
METH_VARARGS | METH_KEYWORDS, "\n"
"Allow a domain access to a PCI device\n"
- " dom [long]: Identifier of domain to be allowed access.\n"
- " bus [int]: PCI bus\n"
- " dev [int]: PCI slot\n"
- " func [int]: PCI function\n"
- " enable [int]: Non-zero means enable access; else disable access\n\n"
+ " dom [int]: Identifier of domain to be allowed access.\n"
+ " bus [int]: PCI bus\n"
+ " dev [int]: PCI slot\n"
+ " func [int]: PCI function\n"
+ " enable [int]: Non-zero means enable access; else disable access\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
{ "readconsolering",
(PyCFunction)pyxc_shadow_control,
METH_VARARGS | METH_KEYWORDS, "\n"
"Set parameter for shadow pagetable interface\n"
- " dom [long]: Identifier of domain.\n"
+ " dom [int]: Identifier of domain.\n"
" op [int, 0]: operation\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
(PyCFunction)pyxc_domain_setname,
METH_VARARGS | METH_KEYWORDS, "\n"
"Set domain informative textual name\n"
- " dom [long]: Identifier of domain.\n"
+ " dom [int]: Identifier of domain.\n"
" name [str]: Text string.\n\n"
"Returns: [int] 0 on success; -1 on error.\n" },
(PyCFunction)pyxc_domain_setname,
METH_VARARGS | METH_KEYWORDS, "\n"
"Set a domain's memory limit\n"
- " dom [long]: Identifier of domain.\n"
+ " dom [int]: Identifier of domain.\n"
" max_memkb [long]: .\n"
"Returns: [int] 0 on success; -1 on error.\n" },
if ( (xc->xc_handle = xc_interface_open()) == -1 )
{
PyObject_Del((PyObject *)xc);
- return PyErr_SetFromErrno(xc_error);
+ return PyErr_SetFromErrno(xc_error);
}
return (PyObject *)xc;
rsp = { 'success': True }
xend.main.send_management_response(rsp, xend.blkif.pendaddr)
elif subtype == CMSG_BLKIF_BE_CONNECT:
- (dom,hnd,evtchn,frame,st) = struct.unpack("QIILI", msg.get_payload())
+ (dom,hnd,evtchn,frame,st) = struct.unpack("IIILI", msg.get_payload())
blkif = interface.list[xend.main.port_from_dom(dom).local_port]
msg = xend.utils.message(CMSG_BLKIF_FE, \
CMSG_BLKIF_FE_INTERFACE_STATUS_CHANGED, 0)
msg.append_payload(struct.pack("III",0,2,blkif.evtchn['port2']))
blkif.ctrlif_tx_req(xend.main.port_list[blkif.key], msg)
elif subtype == CMSG_BLKIF_BE_VBD_CREATE:
- (dom,hnd,vdev,ro,st) = struct.unpack("QIHII", msg.get_payload())
+ (dom,hnd,vdev,ro,st) = struct.unpack("IIHII", msg.get_payload())
blkif = interface.list[xend.main.port_from_dom(dom).local_port]
(pdev, start_sect, nr_sect, readonly) = blkif.devices[vdev]
msg = xend.utils.message(CMSG_BLKIF_BE, CMSG_BLKIF_BE_VBD_GROW, 0)
- msg.append_payload(struct.pack("QIHHHQQI",dom,0,vdev,0, \
+ msg.append_payload(struct.pack("IIHHHQQI",dom,0,vdev,0, \
pdev,start_sect,nr_sect,0))
backend_tx_req(msg)
elif subtype == CMSG_BLKIF_BE_VBD_GROW:
self.pendmsg = None
interface.list[key] = self
msg = xend.utils.message(CMSG_BLKIF_BE, CMSG_BLKIF_BE_CREATE, 0)
- msg.append_payload(struct.pack("QII",dom,0,0))
+ msg.append_payload(struct.pack("III",dom,0,0))
xend.blkif.pendaddr = xend.main.mgmt_req_addr
backend_tx_req(msg)
return False
self.devices[vdev] = (pdev, start_sect, nr_sect, readonly)
msg = xend.utils.message(CMSG_BLKIF_BE, CMSG_BLKIF_BE_VBD_CREATE, 0)
- msg.append_payload(struct.pack("QIHII",self.dom,0,vdev,readonly,0))
+ msg.append_payload(struct.pack("IIHII",self.dom,0,vdev,readonly,0))
xend.blkif.pendaddr = xend.main.mgmt_req_addr
backend_tx_req(msg)
return True
def destroy(self):
del interface.list[self.key]
msg = xend.utils.message(CMSG_BLKIF_BE, CMSG_BLKIF_BE_DESTROY, 0)
- msg.append_payload(struct.pack("QII",self.dom,0,0))
+ msg.append_payload(struct.pack("III",self.dom,0,0))
backend_tx_req(msg)
self.evtchn = xc.evtchn_bind_interdomain(dom1=0,dom2=self.dom)
msg = xend.utils.message(CMSG_BLKIF_BE, \
CMSG_BLKIF_BE_CONNECT, 0)
- msg.append_payload(struct.pack("QIILI",self.dom,0, \
+ msg.append_payload(struct.pack("IIILI",self.dom,0, \
self.evtchn['port1'],frame,0))
backend_tx_req(msg)
xend.main.send_management_response(rsp, xend.netif.pendaddr)
elif subtype == CMSG_NETIF_BE_CONNECT:
(dom,hnd,evtchn,tx_frame,rx_frame,st) = \
- struct.unpack("QIILLI", msg.get_payload())
+ struct.unpack("IIILLI", msg.get_payload())
netif = interface.list[xend.main.port_from_dom(dom).local_port]
msg = xend.utils.message(CMSG_NETIF_FE, \
CMSG_NETIF_FE_INTERFACE_STATUS_CHANGED, 0)
interface.list[key] = self
msg = xend.utils.message(CMSG_NETIF_BE, CMSG_NETIF_BE_CREATE, 0)
- msg.append_payload(struct.pack("QIBBBBBBBBI",dom,0, \
+ msg.append_payload(struct.pack("IIBBBBBBBBI",dom,0, \
self.mac[0],self.mac[1], \
self.mac[2],self.mac[3], \
self.mac[4],self.mac[5], \
def destroy(self):
del interface.list[self.key]
msg = xend.utils.message(CMSG_NETIF_BE, CMSG_NETIF_BE_DESTROY, 0)
- msg.append_payload(struct.pack("QII",self.dom,0,0))
+ msg.append_payload(struct.pack("III",self.dom,0,0))
backend_tx_req(msg)
self.evtchn = xc.evtchn_bind_interdomain(dom1=0,dom2=self.dom)
msg = xend.utils.message(CMSG_NETIF_BE, \
CMSG_NETIF_BE_CONNECT, 0)
- msg.append_payload(struct.pack("QIILLI",self.dom,0, \
+ msg.append_payload(struct.pack("IIILLI",self.dom,0, \
self.evtchn['port1'],tx_frame, \
rx_frame,0))
backend_tx_req(msg)
PyObject_HEAD;
int mem_fd;
int xc_handle;
- u64 remote_dom;
+ u32 remote_dom;
int local_port, remote_port;
control_if_t *interface;
CONTROL_RING_IDX tx_req_cons, tx_resp_prod;
static PyObject *xu_port_new(PyObject *self, PyObject *args)
{
xu_port_object *xup;
- u64 dom;
+ u32 dom;
int port1, port2;
xc_dominfo_t info;
- if ( !PyArg_ParseTuple(args, "L", &dom) )
+ if ( !PyArg_ParseTuple(args, "i", &dom) )
return NULL;
xup = PyObject_New(xu_port_object, &xu_port_type);
}
/* Set the General-Purpose Subject whose page frame will be mapped. */
- (void)ioctl(xup->mem_fd, _IO('M', 1), (unsigned long)(dom>> 0)); /* low */
- (void)ioctl(xup->mem_fd, _IO('M', 2), (unsigned long)(dom>>32)); /* high */
+ (void)ioctl(xup->mem_fd, _IO('M', 1), (unsigned long)dom);
if ( (xup->xc_handle = xc_interface_open()) == -1 )
{
goto fail2;
}
- if ( dom == 0ULL )
+ if ( dom == 0 )
{
/*
* The control-interface event channel for DOM0 is already set up.
if ( strcmp(name, "remote_port") == 0 )
return PyInt_FromLong(xup->remote_port);
if ( strcmp(name, "remote_dom") == 0 )
- return PyLong_FromUnsignedLongLong(xup->remote_dom);
+ return PyInt_FromLong(xup->remote_dom);
return Py_FindMethod(xu_port_methods, obj, name);
}
{
xu_port_object *xup = (xu_port_object *)self;
unmap_control_interface(xup->mem_fd, xup->interface);
- if ( xup->remote_dom != 0ULL )
+ if ( xup->remote_dom != 0 )
(void)xc_evtchn_close(xup->xc_handle, DOMID_SELF, xup->local_port);
(void)xc_interface_close(xup->xc_handle);
(void)close(xup->mem_fd);
static void read_msr_for(void *unused)
{
if (((1 << current->processor) & msr_cpu_mask))
- rdmsr(msr_addr, msr_lo, msr_hi);
+ rdmsr(msr_addr, msr_lo, msr_hi);
}
return -EACCES;
}
- TRACE_5D( TRC_DOM0OP_ENTER_BASE + op->cmd,
- 0, op->u.dummy[0], op->u.dummy[1], op->u.dummy[2], op->u.dummy[3] );
+ TRACE_5D(TRC_DOM0OP_ENTER_BASE + op->cmd,
+ 0, op->u.dummy[0], op->u.dummy[1],
+ op->u.dummy[2], op->u.dummy[3] );
switch ( op->cmd )
{
case DOM0_STOPDOMAIN:
{
ret = stop_other_domain(op->u.stopdomain.domain);
-
- /* This is grim, but helps for live migrate. It's also unsafe
- in the strict sense as we're not explicitly setting a
- timeout, but dom0 is bound to have other timers going off to
- wake us back up.
- We go to sleep so that the other domain can stop quicker, hence
- we have less total down time in a migrate.
- */
- if( ret == 0 && op->u.stopdomain.sync == 1 )
- {
- extern long do_block( void );
- do_block(); // Yuk...
- }
+
+ /*
+ * This is grim, but helps for live migrate. It's also unsafe
+ * in the strict sense as we're not explicitly setting a
+ * timeout, but dom0 is bound to have other timers going off to
+ * wake us back up.
+ * We go to sleep so that the other domain can stop quicker, hence
+ * we have less total down time in a migrate.
+ */
+ if( ret == 0 && op->u.stopdomain.sync == 1 )
+ {
+ extern long do_block( void );
+ do_block(); /* Yuk... */
+ }
}
break;
domid_t dom;
ret = -ENOMEM;
- spin_lock(&domnr_lock);
- dom = ++domnr;
- spin_unlock(&domnr_lock);
+ /* Search for an unused domain identifier. */
+ for ( ; ; )
+ {
+ spin_lock(&domnr_lock);
+ /* Wrap the roving counter when we reach first special value. */
+ if ( (dom = ++domnr) == DOMID_SELF )
+ dom = domnr = 1;
+ spin_unlock(&domnr_lock);
+
+ if ( (p = find_domain_by_id(dom)) == NULL )
+ break;
+ put_task_struct(p);
+ }
- if (op->u.createdomain.cpu == -1 )
- pro = (unsigned int)dom % smp_num_cpus;
- else
- pro = op->u.createdomain.cpu % smp_num_cpus;
+ if (op->u.createdomain.cpu == -1 )
+ pro = (unsigned int)dom % smp_num_cpus;
+ else
+ pro = op->u.createdomain.cpu % smp_num_cpus;
p = do_createdomain(dom, pro);
if ( p == NULL )
break;
- if ( op->u.createdomain.name[0] )
+ if ( op->u.createdomain.name[0] )
{
strncpy(p->name, op->u.createdomain.name, MAX_DOMAIN_NAME);
p->name[MAX_DOMAIN_NAME - 1] = '\0';
- }
+ }
ret = alloc_new_dom_mem(p, op->u.createdomain.memory_kb);
if ( ret != 0 )
else
{
/* Pause domain if necessary. */
- if( !(p->state & TASK_STOPPED) && !(p->state & TASK_PAUSED) )
+ if( !(p->state & TASK_STOPPED) &&
+ !(p->state & TASK_PAUSED) )
{
sched_pause_sync(p);
we_paused = 1;
ret = 0;
}
put_task_struct(p);
- }
+ }
}
}
break;
for_each_domain ( p )
{
if ( p->domain >= op->u.getdomaininfo.domain )
- break;
+ break;
}
if ( p == NULL )
{
ret = -ESRCH;
- goto gdi_out;
+ goto gdi_out;
}
else
{
if ( p->state == TASK_STOPPED && op->u.getdomaininfo.ctxt )
{
- full_execution_context_t *c=NULL;
+ full_execution_context_t *c=NULL;
- if ( (c = kmalloc(sizeof(*c), GFP_KERNEL)) == NULL )
- {
- ret= -ENOMEM;
- goto gdi_out;
- }
+ if ( (c = kmalloc(sizeof(*c), GFP_KERNEL)) == NULL )
+ {
+ ret= -ENOMEM;
+ goto gdi_out;
+ }
rmb(); /* Ensure that we see saved register state. */
c->flags = 0;
c->failsafe_callback_eip =
p->failsafe_address;
- if( copy_to_user(op->u.getdomaininfo.ctxt, c, sizeof(*c)) )
- {
- ret = -EINVAL;
- }
+ if( copy_to_user(op->u.getdomaininfo.ctxt, c, sizeof(*c)) )
+ {
+ ret = -EINVAL;
+ }
- if (c) kfree(c);
+ if (c) kfree(c);
}
}
- if ( copy_to_user(u_dom0_op, op, sizeof(*op)) )
- ret = -EINVAL;
+ if ( copy_to_user(u_dom0_op, op, sizeof(*op)) )
+ ret = -EINVAL;
gdi_out:
read_unlock_irqrestore(&tasklist_lock, flags);
case DOM0_MSR:
{
if ( op->u.msr.write )
- {
+ {
msr_cpu_mask = op->u.msr.cpu_mask;
msr_addr = op->u.msr.msr;
msr_lo = op->u.msr.in1;
msr_hi = op->u.msr.in2;
smp_call_function(write_msr_for, NULL, 1, 1);
write_msr_for(NULL);
- }
+ }
else
- {
+ {
msr_cpu_mask = op->u.msr.cpu_mask;
msr_addr = op->u.msr.msr;
smp_call_function(read_msr_for, NULL, 1, 1);
op->u.msr.out1 = msr_lo;
op->u.msr.out2 = msr_hi;
copy_to_user(u_dom0_op, op, sizeof(*op));
- }
+ }
ret = 0;
}
break;
case DOM0_GETTBUFS:
{
ret = get_tb_info(&op->u.gettbufs);
- copy_to_user(u_dom0_op, op, sizeof(*op));
+ copy_to_user(u_dom0_op, op, sizeof(*op));
}
break;
#endif
case DOM0_READCONSOLE:
{
ret = read_console_ring(op->u.readconsole.str,
- op->u.readconsole.count,
- op->u.readconsole.cmd);
+ op->u.readconsole.count,
+ op->u.readconsole.cmd);
}
break;
case DOM0_SHADOW_CONTROL:
{
- struct task_struct *p;
- ret = -ESRCH;
- p = find_domain_by_id( op->u.shadow_control.domain );
- if ( p )
- {
+ struct task_struct *p;
+ ret = -ESRCH;
+ p = find_domain_by_id( op->u.shadow_control.domain );
+ if ( p )
+ {
ret = shadow_mode_control(p, &op->u.shadow_control );
- put_task_struct(p);
- copy_to_user(u_dom0_op, op, sizeof(*op));
- }
+ put_task_struct(p);
+ copy_to_user(u_dom0_op, op, sizeof(*op));
+ }
}
break;
case DOM0_SETDOMAINNAME:
{
- struct task_struct *p;
- p = find_domain_by_id( op->u.setdomainname.domain );
- if ( p )
- {
- strncpy(p->name, op->u.setdomainname.name, MAX_DOMAIN_NAME);
- put_task_struct(p);
- }
- else
- ret = -ESRCH;
+ struct task_struct *p;
+ p = find_domain_by_id( op->u.setdomainname.domain );
+ if ( p )
+ {
+ strncpy(p->name, op->u.setdomainname.name, MAX_DOMAIN_NAME);
+ put_task_struct(p);
+ }
+ else
+ ret = -ESRCH;
}
break;
case DOM0_SETDOMAININITIALMEM:
{
- struct task_struct *p;
- ret = -ESRCH;
- p = find_domain_by_id( op->u.setdomaininitialmem.domain );
- if ( p )
- {
- /* should only be used *before* domain is built. */
+ struct task_struct *p;
+ ret = -ESRCH;
+ p = find_domain_by_id( op->u.setdomaininitialmem.domain );
+ if ( p )
+ {
+ /* should only be used *before* domain is built. */
if ( ! test_bit(PF_CONSTRUCTED, &p->flags) )
- ret = alloc_new_dom_mem(
- p, op->u.setdomaininitialmem.initial_memkb );
- else
- ret = -EINVAL;
- put_task_struct(p);
- }
+ ret = alloc_new_dom_mem(
+ p, op->u.setdomaininitialmem.initial_memkb );
+ else
+ ret = -EINVAL;
+ put_task_struct(p);
+ }
}
break;
case DOM0_SETDOMAINMAXMEM:
{
- struct task_struct *p;
- p = find_domain_by_id( op->u.setdomainmaxmem.domain );
- if ( p )
- {
- p->max_pages =
- (op->u.setdomainmaxmem.max_memkb+PAGE_SIZE-1)>> PAGE_SHIFT;
- put_task_struct(p);
- }
- else
- ret = -ESRCH;
+ struct task_struct *p;
+ p = find_domain_by_id( op->u.setdomainmaxmem.domain );
+ if ( p )
+ {
+ p->max_pages =
+ (op->u.setdomainmaxmem.max_memkb+PAGE_SIZE-1)>> PAGE_SHIFT;
+ put_task_struct(p);
+ }
+ else
+ ret = -ESRCH;
}
break;
case DOM0_GETPAGEFRAMEINFO2:
{
#define GPF2_BATCH 128
- int n,j;
+ int n,j;
int num = op->u.getpageframeinfo2.num;
domid_t dom = op->u.getpageframeinfo2.domain;
- unsigned long *s_ptr = (unsigned long*) op->u.getpageframeinfo2.array;
+ unsigned long *s_ptr = (unsigned long*) op->u.getpageframeinfo2.array;
struct task_struct *p;
- unsigned long l_arr[GPF2_BATCH];
+ unsigned long l_arr[GPF2_BATCH];
ret = -ESRCH;
- if ( unlikely((p = find_domain_by_id(dom)) == NULL) )
- break;
-
- if ( unlikely(num>1024) )
- {
- ret = -E2BIG;
- break;
- }
-
- ret = 0;
- for(n=0;n<num;)
- {
- int k = ((num-n)>GPF2_BATCH)?GPF2_BATCH:(num-n);
-
- if( copy_from_user( l_arr, &s_ptr[n], k*sizeof(unsigned long) ) )
- {
- ret = -EINVAL;
- break;
- }
-
- for(j=0;j<k;j++)
- {
- struct pfn_info *page;
- unsigned long mfn = l_arr[j];
-
- if ( unlikely(mfn >= max_page) )
- goto e2_err;
-
- page = &frame_table[mfn];
-
- if ( likely(get_page(page, p)) )
- {
- unsigned long type = 0;
- switch( page->type_and_flags & PGT_type_mask )
- {
- case PGT_l1_page_table:
- type = L1TAB;
- break;
- case PGT_l2_page_table:
- type = L2TAB;
- break;
- case PGT_l3_page_table:
- type = L3TAB;
- break;
- case PGT_l4_page_table:
- type = L4TAB;
- break;
- }
- l_arr[j] |= type;
- put_page(page);
- }
- else
- {
- e2_err:
- l_arr[j] |= XTAB;
- }
-
- }
-
- if( copy_to_user( &s_ptr[n], l_arr, k*sizeof(unsigned long) ) )
- {
- ret = -EINVAL;
- break;
- }
-
- n+=j;
- }
-
- put_task_struct(p);
+ if ( unlikely((p = find_domain_by_id(dom)) == NULL) )
+ break;
+
+ if ( unlikely(num>1024) )
+ {
+ ret = -E2BIG;
+ break;
+ }
+
+ ret = 0;
+ for(n=0;n<num;)
+ {
+ int k = ((num-n)>GPF2_BATCH)?GPF2_BATCH:(num-n);
+
+ if( copy_from_user( l_arr, &s_ptr[n], k*sizeof(unsigned long) ) )
+ {
+ ret = -EINVAL;
+ break;
+ }
+
+ for(j=0;j<k;j++)
+ {
+ struct pfn_info *page;
+ unsigned long mfn = l_arr[j];
+
+ if ( unlikely(mfn >= max_page) )
+ goto e2_err;
+
+ page = &frame_table[mfn];
+
+ if ( likely(get_page(page, p)) )
+ {
+ unsigned long type = 0;
+ switch( page->type_and_flags & PGT_type_mask )
+ {
+ case PGT_l1_page_table:
+ type = L1TAB;
+ break;
+ case PGT_l2_page_table:
+ type = L2TAB;
+ break;
+ case PGT_l3_page_table:
+ type = L3TAB;
+ break;
+ case PGT_l4_page_table:
+ type = L4TAB;
+ break;
+ }
+ l_arr[j] |= type;
+ put_page(page);
+ }
+ else
+ {
+ e2_err:
+ l_arr[j] |= XTAB;
+ }
+
+ }
+
+ if( copy_to_user( &s_ptr[n], l_arr, k*sizeof(unsigned long) ) )
+ {
+ ret = -EINVAL;
+ break;
+ }
+
+ n+=j;
+ }
+
+ put_task_struct(p);
}
break;
}
- TRACE_5D( TRC_DOM0OP_LEAVE_BASE + op->cmd, ret,
- op->u.dummy[0], op->u.dummy[1], op->u.dummy[2], op->u.dummy[3] );
+ TRACE_5D(TRC_DOM0OP_LEAVE_BASE + op->cmd, ret,
+ op->u.dummy[0], op->u.dummy[1], op->u.dummy[2], op->u.dummy[3]);
return ret;
if ( unlikely(mpfn >= max_page) )
{
- DPRINTK("Domain %llu page number out of range (%08lx>=%08lx)\n",
+ DPRINTK("Domain %u page number out of range (%08lx>=%08lx)\n",
p->domain, mpfn, max_page);
rc = -EINVAL;
break;
page = &frame_table[mpfn];
if ( unlikely(!get_page(page, p)) )
{
- DPRINTK("Bad page free for domain %llu\n", p->domain);
+ DPRINTK("Bad page free for domain %u\n", p->domain);
rc = -EINVAL;
break;
}
}
/* We use a large intermediate to avoid overflow in sprintf. */
- sprintf(buf, "Domain-%llu", dom_id);
+ sprintf(buf, "Domain-%u", dom_id);
strncpy(p->name, buf, MAX_DOMAIN_NAME);
p->name[MAX_DOMAIN_NAME-1] = '\0';
p->shared_info = (void *)get_free_page(GFP_KERNEL);
memset(p->shared_info, 0, PAGE_SIZE);
SHARE_PFN_WITH_DOMAIN(virt_to_page(p->shared_info), p);
-
- machine_to_phys_mapping[virt_to_phys(p->shared_info) >> PAGE_SHIFT] =
- 0x80000000UL; // set m2p table to magic marker (helps debug)
+ machine_to_phys_mapping[virt_to_phys(p->shared_info) >>
+ PAGE_SHIFT] = 0x80000000UL; /* debug */
p->mm.perdomain_pt = (l1_pgentry_t *)get_free_page(GFP_KERNEL);
memset(p->mm.perdomain_pt, 0, PAGE_SIZE);
-
- machine_to_phys_mapping[virt_to_phys(p->mm.perdomain_pt) >> PAGE_SHIFT] =
- 0x0fffdeadUL; // set m2p table to magic marker (helps debug)
+ machine_to_phys_mapping[virt_to_phys(p->mm.perdomain_pt) >>
+ PAGE_SHIFT] = 0x0fffdeadUL; /* debug */
init_blkdev_info(p);
p = plast->next_list;
while ( p != NULL )
{
- if ( p->create_time > plast->create_time )
- plast = p;
+ if ( p->create_time > plast->create_time )
+ plast = p;
p = p->next_list;
}
get_task_struct(plast);
void kill_domain_with_errmsg(const char *err)
{
- printk("DOM%llu FATAL ERROR: %s\n", current->domain, err);
+ printk("DOM%u FATAL ERROR: %s\n", current->domain, err);
kill_domain();
}
if ( !sched_rem_domain(p) )
return;
- DPRINTK("Killing domain %llu\n", p->domain);
+ DPRINTK("Killing domain %u\n", p->domain);
unlink_blkdev_info(p);
/* OK, this is grim, but helps speed up live migrate. When a domain stops,
kick Dom0 */
{
- struct task_struct *p;
- guest_schedule_to_run( p = find_domain_by_id(0ULL) );
- put_task_struct(p);
+ struct task_struct *p;
+ guest_schedule_to_run( p = find_domain_by_id(0ULL) );
+ put_task_struct(p);
}
__enter_scheduler();
spin_lock(&p->page_list_lock);
if ( unlikely(p->tot_pages >= p->max_pages) )
{
- DPRINTK("Over-allocation for domain %llu: %u >= %u\n",
+ DPRINTK("Over-allocation for domain %u: %u >= %u\n",
p->domain, p->tot_pages, p->max_pages);
spin_unlock(&p->page_list_lock);
goto free_and_exit;
if ( !(page->count_and_flags & PGC_zombie) )
{
page->tlbflush_timestamp = tlbflush_clock;
- if ( likely(p != NULL) )
- {
+ if ( likely(p != NULL) )
+ {
page->u.cpu_mask = 1 << p->processor;
spin_lock(&p->page_list_lock);
- list_del(&page->list);
- p->tot_pages--;
- spin_unlock(&p->page_list_lock);
- }
+ list_del(&page->list);
+ p->tot_pages--;
+ spin_unlock(&p->page_list_lock);
+ }
}
page->count_and_flags = 0;
return -ENOMEM;
}
- /* initialise to machine_to_phys_mapping table to likely pfn */
- machine_to_phys_mapping[page-frame_table] = alloc_pfns;
+ /* initialise to machine_to_phys_mapping table to likely pfn */
+ machine_to_phys_mapping[page-frame_table] = alloc_pfns;
#ifndef NDEBUG
- {
- // initialise with magic marker if in DEBUG mode
- void * a = map_domain_mem( (page-frame_table)<<PAGE_SHIFT );
- memset( a, 0x80 | (char) p->domain, PAGE_SIZE );
- unmap_domain_mem( a );
- }
+ {
+ /* Initialise with magic marker if in DEBUG mode. */
+
void * a = map_domain_mem( (page-frame_table)<<PAGE_SHIFT );
+ memset( a, 0x80 | (char) p->domain, PAGE_SIZE );
+ unmap_domain_mem( a );
+ }
#endif
}
ASSERT(p->state == TASK_DYING);
ASSERT(!p->has_cpu);
- DPRINTK("Releasing task %llu\n", p->domain);
+ DPRINTK("Releasing task %u\n", p->domain);
/*
* This frees up blkdev rings and vbd-access lists. Totally safe since
full_execution_context_t *c;
if ( (c = kmalloc(sizeof(*c), GFP_KERNEL)) == NULL )
- return -ENOMEM;
+ return -ENOMEM;
if ( test_bit(PF_CONSTRUCTED, &p->flags) )
{
rc = -EINVAL;
- goto out;
+ goto out;
}
if ( copy_from_user(c, builddomain->ctxt, sizeof(*c)) )
set_bit(PF_CONSTRUCTED, &p->flags);
-out:
+ out:
if (c) kfree(c);
return rc;
if ( (ehdr->e_phoff + (ehdr->e_phnum * ehdr->e_phentsize)) > elfsize )
{
- printk("ELF program headers extend beyond end of image.\n");
+ printk("ELF program headers extend beyond end of image.\n");
return -EINVAL;
}
if ( (ehdr->e_shoff + (ehdr->e_shnum * ehdr->e_shentsize)) > elfsize )
{
- printk("ELF section headers extend beyond end of image.\n");
+ printk("ELF section headers extend beyond end of image.\n");
return -EINVAL;
}
{
phdr = (Elf_Phdr *)(elfbase + ehdr->e_phoff + (h*ehdr->e_phentsize));
if ( !is_loadable_phdr(phdr) )
- continue;
+ continue;
if ( phdr->p_filesz != 0 )
memcpy((char *)phdr->p_vaddr, elfbase + phdr->p_offset,
phdr->p_filesz);
if ( initrd_len != 0 )
{
- si->mod_start = vinitrd_start;
- si->mod_len = initrd_len;
- printk("Initrd len 0x%lx, start at 0x%08lx\n",
- si->mod_len, si->mod_start);
+ si->mod_start = vinitrd_start;
+ si->mod_len = initrd_len;
+ printk("Initrd len 0x%lx, start at 0x%08lx\n",
+ si->mod_len, si->mod_start);
}
dst = si->cmd_line;
char *str;
if ( key_table[key].handler != NULL )
- printk("Warning: overwriting handler for key 0x%x\n", key);
+ printk("Warning: overwriting handler for key 0x%x\n", key);
key_table[key].handler = handler;
str = key_table[key].desc;
for ( i = 0; i < STR_MAX; i++ )
{
- if ( *desc != '\0' )
- *str++ = *desc++;
- else
+ if ( *desc != '\0' )
+ *str++ = *desc++;
+ else
break;
}
if ( i == STR_MAX )
- key_table[key].desc[STR_MAX-1] = '\0';
+ key_table[key].desc[STR_MAX-1] = '\0';
}
key_handler *get_key_handler(u_char key)
printk("'%c' pressed -> showing installed handlers\n", key);
for ( i = 0; i < KEY_MAX; i++ )
- if ( key_table[i].handler != NULL )
- printk(" key '%c' (ascii '%02x') => %s\n",
- (i<33 || i>126)?(' '):(i),i,
- key_table[i].desc);
+ if ( key_table[i].handler != NULL )
+ printk(" key '%c' (ascii '%02x') => %s\n",
+ (i<33 || i>126)?(' '):(i),i,
+ key_table[i].desc);
}
for_each_domain ( p )
{
- printk("Xen: DOM %llu, CPU %d [has=%c], state = ",
+ printk("Xen: DOM %u, CPU %d [has=%c], state = ",
p->domain, p->processor, p->has_cpu ? 'T':'F');
sched_prn_state(p ->state);
- printk(", hyp_events = %08x\n", p->hyp_events);
+ printk(", hyp_events = %08x\n", p->hyp_events);
s = p->shared_info;
printk("Guest: upcall_pend = %02x, upcall_mask = %02x\n",
s->vcpu_data[0].evtchn_upcall_pending,
/* first initialize key handler table */
for ( i = 0; i < KEY_MAX; i++ )
- key_table[i].handler = (key_handler *)NULL;
-
+ key_table[i].handler = (key_handler *)NULL;
+
/* setup own handlers */
add_key_handler('d', dump_registers, "dump registers");
add_key_handler('h', show_handlers, "show this message");
#include <asm/ldt.h>
#ifndef NDEBUG
-#define MEM_LOG(_f, _a...) \
- printk("DOM%llu: (file=memory.c, line=%d) " _f "\n", \
+#define MEM_LOG(_f, _a...) \
+ printk("DOM%u: (file=memory.c, line=%d) " _f "\n", \
current->domain , __LINE__ , ## _a )
#else
#define MEM_LOG(_f, _a...) ((void)0)
#define DOP_RELOAD_LDT (1<<1) /* Reload the LDT shadow mapping. */
unsigned long deferred_ops;
unsigned long cr0;
- domid_t subject_id;
/* General-Purpose Subject, Page-Table Subject */
struct task_struct *gps, *pts;
} percpu_info[NR_CPUS] __cacheline_aligned;
mfn < virt_to_phys((void *)RDWR_MPT_VIRT_END)>>PAGE_SHIFT;
mfn++ )
{
- frame_table[mfn].count_and_flags = 1 | PGC_allocated;
- frame_table[mfn].type_and_flags = 1 | PGT_gdt_page; /* non-RW type */
- frame_table[mfn].u.domain = &idle0_task;
+ frame_table[mfn].count_and_flags = 1 | PGC_allocated;
+ frame_table[mfn].type_and_flags = 1 | PGT_gdt_page; /* non-RW type */
+ frame_table[mfn].u.domain = &idle0_task;
}
}
if ( unlikely(!pfn_is_ram(pfn)) )
{
if ( IS_PRIV(current) )
- return 1;
+ return 1;
- if ( IS_CAPABLE_PHYSDEV(current) )
+ if ( IS_CAPABLE_PHYSDEV(current) )
return domain_iomem_in_pfn(current, pfn);
MEM_LOG("Non-privileged attempt to map I/O space %08lx", pfn);
unsigned long old_base_pfn;
struct pfn_info *page = &frame_table[pfn];
struct task_struct *p = current, *q;
+ domid_t domid;
switch ( cmd )
{
break;
}
- case MMUEXT_SET_SUBJECTDOM_L:
- percpu_info[cpu].subject_id = (domid_t)((ptr&~0xFFFF)|(val>>16));
- break;
-
- case MMUEXT_SET_SUBJECTDOM_H:
- percpu_info[cpu].subject_id |=
- ((domid_t)((ptr&~0xFFFF)|(val>>16)))<<32;
+ case MMUEXT_SET_SUBJECTDOM:
+ domid = ((domid_t)((ptr&~0xFFFF)|(val>>16)));
if ( !IS_PRIV(p) )
{
- MEM_LOG("Dom %llu has no privilege to set subject domain",
+ MEM_LOG("Dom %u has no privilege to set subject domain",
p->domain);
okay = 0;
}
{
if ( percpu_info[cpu].gps != NULL )
put_task_struct(percpu_info[cpu].gps);
- percpu_info[cpu].gps = find_domain_by_id(
- percpu_info[cpu].subject_id);
+ percpu_info[cpu].gps = find_domain_by_id(domid);
percpu_info[cpu].pts = (val & SET_PAGETABLE_SUBJECTDOM) ?
percpu_info[cpu].gps : NULL;
if ( percpu_info[cpu].gps == NULL )
{
- MEM_LOG("Unknown domain '%llu'", percpu_info[cpu].subject_id);
+ MEM_LOG("Unknown domain '%u'", domid);
okay = 0;
}
}
case MMUEXT_REASSIGN_PAGE:
if ( unlikely(!IS_PRIV(p)) )
{
- MEM_LOG("Dom %llu has no privilege to reassign page ownership",
+ MEM_LOG("Dom %u has no privilege to reassign page ownership",
p->domain);
okay = 0;
}
machine_to_phys_mapping[pfn] = req.val;
okay = 1;
- /* if in log dirty shadow mode, mark the corresponding
- psuedo-physical page as dirty */
- if( unlikely(current->mm.shadow_mode == SHM_logdirty) )
- mark_dirty( ¤t->mm, pfn );
+ /*
+ * If in log-dirty mode, mark the corresponding pseudo-physical
+ * page as dirty.
+ */
+ if( unlikely(current->mm.shadow_mode == SHM_logdirty) )
+ mark_dirty( ¤t->mm, pfn );
put_page(&frame_table[pfn]);
break;
}
if ( unlikely(success_count != NULL) )
- put_user(count, success_count);
+ put_user(count, success_count);
return rc;
}
percpu_info[cpu].gps = p = find_domain_by_id(domid);
if ( unlikely(p == NULL) )
{
- MEM_LOG("Unknown domain '%llu'", domid);
+ MEM_LOG("Unknown domain '%u'", domid);
return -ESRCH;
}
if ( r->src_dom == VIF_SPECIAL )
printk("=] src_dom/idx : %s\n", idx_to_name(r->src_idx));
else
- printk("=] src_dom/idx : %llu/%u\n", r->src_dom, r->src_idx);
+ printk("=] src_dom/idx : %u/%u\n", r->src_dom, r->src_idx);
if ( r->dst_dom == VIF_SPECIAL )
printk("=] dst_dom/idx : %s\n", idx_to_name(r->dst_idx));
else
- printk("=] dst_dom/idx : %llu/%u\n", r->dst_dom, r->dst_idx);
+ printk("=] dst_dom/idx : %u/%u\n", r->dst_dom, r->dst_idx);
printk("=] action : %u\n", r->action);
}
return target;
drop:
- printk("VIF%llu/%u: pkt to drop!\n",
- src_dom, src_idx);
+ DPRINTK("VIF%u/%u: pkt to drop!\n", src_dom, src_idx);
return VIF_DROP;
}
* this will allow all processes in that domain access to those
* ports as well. This will do for now, since driver domains don't
* run untrusted processes! */
- INFO("Giving domain %llu IO resources (%lx - %lx) "
+ INFO("Giving domain %u IO resources (%lx - %lx) "
"for device %s\n", dom, r->start, r->end, pdev->slot_name);
for ( j = r->start; j < r->end + 1; j++ )
{
}
/* rights to IO memory regions are checked when the domain maps them */
- }
+ }
out:
put_task_struct(p);
return rc;
int ret = 0;
struct list_head *l;
- VERBOSE_INFO("Checking if physdev-capable domain %llu needs access to "
+ VERBOSE_INFO("Checking if physdev-capable domain %u needs access to "
"pfn %08lx\n", p->domain, pfn);
spin_lock(&p->pcidev_lock);
spin_unlock(&p->pcidev_lock);
- VERBOSE_INFO("Domain %llu %s mapping of pfn %08lx\n",
+ VERBOSE_INFO("Domain %u %s mapping of pfn %08lx\n",
p->domain, ret ? "allowed" : "disallowed", pfn);
return ret;
* to work out the length of the io region a device probe typically does:
* 1) a = read_base_addr_reg()
* 2) write_base_addr_reg(0xffffffff)
- * 3) b = read_base_addr_reg() // device zeros lower bits
- * 4) write_base_addr_reg(a) // restore original value
+ * 3) b = read_base_addr_reg() [device zeros lower bits]
+ * 4) write_base_addr_reg(a) [restore original value]
* this function fakes out step 2-4. *no* writes are made to the device.
*
* phys_dev_t contains a bit field (a bit for each base address register).
/* We could set *val to some value but the guest may well be in trouble
* anyway if this write fails. Hopefully the printk will give us a
* clue what went wrong. */
- printk("Guest %llu attempting sub-dword %s to BASE_ADDRESS %d\n",
+ printk("Guest %u attempting sub-dword %s to BASE_ADDRESS %d\n",
pdev->owner->domain, (acc == ACC_READ) ? "read" : "write", idx);
return -EPERM;
cur_sdom->min_slice = newtime - time;
DOM_INFO(cur_sdom)->reason = reason;
- TRACE_2D(0, (cur_sdom->domain >> 32), ((u32)cur_sdom->domain));
+ TRACE_1D(0, cur_sdom->domain);
return ret;
}
struct bvt_dom_info *inf = BVT_INFO(p);
-
- printk("Get domain %lld bvt mcu_adv=%ld, warp=%ld, warpl=%ld, warpu=%ld\n",
- p->domain, inf->mcu_advance, inf->warp,
- inf->warpl, inf->warpu );
+ DPRINTK("Get domain %u bvt mcu_adv=%ld, warp=%ld, "
+ "warpl=%ld, warpu=%ld\n",
+ p->domain, inf->mcu_advance, inf->warp,
+ inf->warpl, inf->warpu );
/* Sanity -- this can avoid divide-by-zero. */
if ( mcu_adv == 0 )
inf->warpl = warpl;
inf->warpu = warpu;
- printk("Set domain %lld bvt mcu_adv=%ld, warp=%ld, warpl=%ld, warpu=%ld\n",
- p->domain, inf->mcu_advance, inf->warp,
- inf->warpl, inf->warpu );
+ DPRINTK("Set domain %u bvt mcu_adv=%ld, warp=%ld, "
+ "warpl=%ld, warpu=%ld\n",
+ p->domain, inf->mcu_advance, inf->warp,
+ inf->warpl, inf->warpu );
spin_unlock_irqrestore(&schedule_lock[p->processor], flags);
}
case SCHEDOP_exit:
{
- DPRINTK("DOM%llu killed itself!\n", current->domain);
+ DPRINTK("DOM%u killed itself!\n", current->domain);
DPRINTK(" EIP == %08lx\n", get_execution_context()->eip);
kill_domain();
break;
case SCHEDOP_stop:
{
- DPRINTK("DOM%llu stopped itself!\n", current->domain);
+ DPRINTK("DOM%u stopped itself!\n", current->domain);
DPRINTK(" EIP == %08lx\n", get_execution_context()->eip);
stop_domain();
break;
(unsigned long) queue->next, (unsigned long) queue->prev);
list_for_each (list, queue) {
p = list_entry(list, struct task_struct, run_list);
- printk("%3d: %llu has=%c ", loop++, p->domain, p->has_cpu ? 'T':'F');
+ printk("%3d: %u has=%c ", loop++, p->domain, p->has_cpu ? 'T':'F');
SCHED_OP(dump_runq_el, p);
printk("c=0x%X%08X\n", (u32)(p->cpu_time>>32), (u32)p->cpu_time);
printk(" l: %lx n: %lx p: %lx\n",
read_lock_irqsave(&tasklist_lock, flags);
for_each_domain ( p )
{
- printk("Domain: %llu\n", p->domain);
+ printk("Domain: %u\n", p->domain);
blk_ring = p->blk_ring_base;
printk(" req_prod:0x%08x, req_cons:0x%08x resp_prod:0x%08x/"
"0x%08x on_list=%d\n",
if ( unlikely((p = find_domain_by_id(create->domain)) == NULL) )
{
- DPRINTK("vbd_create attempted for non-existent domain %llu\n",
+ DPRINTK("vbd_create attempted for non-existent domain %u\n",
create->domain);
return -EINVAL;
}
if ( unlikely((p = find_domain_by_id(grow->domain)) == NULL) )
{
- DPRINTK("vbd_grow: attempted for non-existent domain %llu\n",
+ DPRINTK("vbd_grow: attempted for non-existent domain %u\n",
grow->domain);
return -EINVAL;
}
if ( (p = find_domain_by_id(shrink->domain)) == NULL )
{
- DPRINTK("vbd_shrink attempted for non-existent domain %llu\n",
+ DPRINTK("vbd_shrink attempted for non-existent domain %u\n",
shrink->domain);
return -EINVAL;
}
if ( (p = find_domain_by_id(setextents->domain)) == NULL )
{
- DPRINTK("vbd_setextents attempted for non-existent domain %llu\n",
+ DPRINTK("vbd_setextents attempted for non-existent domain %u\n",
setextents->domain);
return -EINVAL;
}
if ( (p = find_domain_by_id(delete->domain)) == NULL )
{
- DPRINTK("vbd_delete attempted for non-existent domain %llu\n",
+ DPRINTK("vbd_delete attempted for non-existent domain %u\n",
delete->domain);
return -EINVAL;
}
if ( (probe->domain != VBD_PROBE_ALL) &&
((p = find_domain_by_id(probe->domain)) == NULL) )
{
- DPRINTK("vbd_probe attempted for non-existent domain %llu\n",
+ DPRINTK("vbd_probe attempted for non-existent domain %u\n",
probe->domain);
return -EINVAL;
}
if ( (p = find_domain_by_id(info->domain)) == NULL )
{
- DPRINTK("vbd_info attempted for non-existent domain %llu\n",
+ DPRINTK("vbd_info attempted for non-existent domain %u\n",
info->domain);
return -EINVAL;
}
goto found;
}
- DPRINTK("vbd_translate; domain %llu attempted to access "
+ DPRINTK("vbd_translate; domain %u attempted to access "
"non-existent VBD.\n", p->domain);
spin_unlock(&p->vbd_lock);
*/
/* VGA text (mode 3) definitions. */
-#define COLUMNS 80
-#define LINES 25
+#define COLUMNS 80
+#define LINES 25
#define ATTRIBUTE 7
/* Clear the screen and initialize VIDEO, XPOS and YPOS. */
return -EFAULT;
if ( cmd & CONSOLE_RING_CLEAR )
- console_ring.len = 0;
+ console_ring.len = 0;
return len;
}
return -EFAULT;
safe_str[count] = '\0';
- sprintf(line_header, "DOM%llu: ", current->domain);
+ sprintf(line_header, "DOM%u: ", current->domain);
p = safe_str;
while ( *p != '\0' )
#else
if ( !test_and_set_bit(PF_CONSOLEWRITEBUG, ¤t->flags) )
{
- printk("DOM%llu is attempting to use the deprecated "
+ printk("DOM%u is attempting to use the deprecated "
"HYPERVISOR_console_write() interface.\n", current->domain);
printk(" - For testing, create a debug build of Xen\n");
printk(" - For production, your OS must use the new console model\n");
* This makes sure that old versions of dom0 tools will stop working in a
* well-defined way (rather than crashing the machine, for instance).
*/
-#define DOM0_INTERFACE_VERSION 0xAAAA000D
+#define DOM0_INTERFACE_VERSION 0xAAAA000E
#define MAX_DOMAIN_NAME 16
typedef struct {
/* IN variables. */
domid_t domain; /* 0 */
+ u32 __pad;
memory_t max_pfns; /* 8 */
MEMORY_PADDING;
void *buffer; /* 16 */
u32 __pad; /* 28 */
/* OUT parameters. */
domid_t domain; /* 32 */
-} PACKED dom0_createdomain_t; /* 40 bytes */
+} PACKED dom0_createdomain_t; /* 36 bytes */
#define DOM0_DESTROYDOMAIN 9
typedef struct {
/* IN variables. */
domid_t domain; /* 0 */
- u32 force; /* 8 */
-} PACKED dom0_destroydomain_t; /* 12 bytes */
+ u32 force; /* 4 */
+} PACKED dom0_destroydomain_t; /* 8 bytes */
#define DOM0_STARTDOMAIN 10
typedef struct {
/* IN parameters. */
domid_t domain; /* 0 */
-} PACKED dom0_startdomain_t; /* 8 bytes */
+} PACKED dom0_startdomain_t; /* 4 bytes */
#define DOM0_STOPDOMAIN 11
typedef struct {
domid_t domain; /* 0 */
/* hack to indicate that you want to wait for other domain -- replace
with proper sychronous stop soon! */
- u32 sync; /* 8 */
-} PACKED dom0_stopdomain_t; /* 12 bytes */
+ u32 sync; /* 4 */
+} PACKED dom0_stopdomain_t; /* 8 bytes */
#define DOM0_GETDOMAININFO 12
typedef struct {
/* IN variables. */
domid_t domain; /* 0 */
+ u32 __pad;
full_execution_context_t *ctxt; /* 8 */
MEMORY_PADDING;
/* OUT variables. */
- char name[MAX_DOMAIN_NAME]; /* 16 */
- u32 processor; /* 32 */
- u32 has_cpu; /* 36 */
+ u8 name[MAX_DOMAIN_NAME]; /* 16 */
+ u32 processor; /* 32 */
+ u32 has_cpu; /* 36 */
#define DOMSTATE_ACTIVE 0
#define DOMSTATE_STOPPED 1
- u32 state; /* 40 */
- u32 hyp_events; /* 44 */
- u32 tot_pages; /* 48 */
- u32 max_pages; /* 52 */
- u64 cpu_time; /* 56 */
+ u32 state; /* 40 */
+ u32 hyp_events; /* 44 */
+ u32 tot_pages; /* 48 */
+ u32 max_pages; /* 52 */
+ u64 cpu_time; /* 56 */
memory_t shared_info_frame; /* 64: MFN of shared_info struct */
MEMORY_PADDING;
} PACKED dom0_getdomaininfo_t; /* 72 bytes */
#define DOM0_BUILDDOMAIN 13
typedef struct {
/* IN variables. */
- domid_t domain; /* 0 */
- u32 num_vifs;/* 8 */
- u32 __pad; /* 12 */
+ domid_t domain; /* 0 */
+ u32 num_vifs; /* 4 */
/* IN/OUT parameters */
- full_execution_context_t *ctxt; /* 16 */
+ full_execution_context_t *ctxt; /* 8 */
MEMORY_PADDING;
-} PACKED dom0_builddomain_t; /* 24 bytes */
+} PACKED dom0_builddomain_t; /* 16 bytes */
#define DOM0_IOPL 14
typedef struct {
domid_t domain; /* 0 */
- u32 iopl; /* 8 */
-} PACKED dom0_iopl_t; /* 12 bytes */
+ u32 iopl; /* 4 */
+} PACKED dom0_iopl_t; /* 8 bytes */
#define DOM0_MSR 15
typedef struct {
typedef struct {
/* IN variables. */
domid_t domain; /* 0 */
- u8 opcode; /* 8 */
+ u8 opcode; /* 4 */
u8 __pad0, __pad1, __pad2;
- u32 in1; /* 12 */
- u32 in2; /* 16 */
- u32 in3; /* 20 */
- u32 in4; /* 24 */
+ u32 in1; /* 8 */
+ u32 in2; /* 12 */
+ u32 in3; /* 16 */
+ u32 in4; /* 20 */
/* OUT variables. */
- u32 status; /* 28 */
- u32 out1; /* 32 */
- u32 out2; /* 36 */
-} PACKED dom0_debug_t; /* 40 bytes */
+ u32 status; /* 24 */
+ u32 out1; /* 28 */
+ u32 out2; /* 32 */
+} PACKED dom0_debug_t; /* 36 bytes */
/*
* Set clock such that it would read <secs,usecs> after 00:00:00 UTC,
domid_t domain; /* 8: To which domain does the frame belong? */
/* OUT variables. */
/* Is the page PINNED to a type? */
- u32 type; /* 16: see above type defs */
-} PACKED dom0_getpageframeinfo_t; /* 20 bytes */
+ u32 type; /* 12: see above type defs */
+} PACKED dom0_getpageframeinfo_t; /* 16 bytes */
/*
* Read console content from Xen buffer ring.
typedef struct {
/* IN variables. */
domid_t domain; /* 0 */
- s32 cpu; /* 8: -1 implies unpin */
-} PACKED dom0_pincpudomain_t; /* 12 bytes */
+ s32 cpu; /* 4: -1 implies unpin */
+} PACKED dom0_pincpudomain_t; /* 8 bytes */
/* Get trace buffers physical base pointer */
#define DOM0_GETTBUFS 21
typedef struct {
/* IN variables. */
domid_t domain; /* 0 */
- u32 bus; /* 8 */
- u32 dev; /* 12 */
- u32 func; /* 16 */
- u32 enable; /* 20 */
-} PACKED dom0_pcidev_access_t; /* 24 bytes */
+ u32 bus; /* 4 */
+ u32 dev; /* 8 */
+ u32 func; /* 12 */
+ u32 enable; /* 16 */
+} PACKED dom0_pcidev_access_t; /* 20 bytes */
/*
* Get the ID of the current scheduler.
typedef struct {
/* IN variables. */
domid_t domain; /* 0 */
- u32 op; /* 8 */
- u32 __pad; /* 12 */
- unsigned long *dirty_bitmap; /* 16: pointer to locked buffer */
+ u32 op; /* 4 */
+ unsigned long *dirty_bitmap; /* 8: pointer to locked buffer */
MEMORY_PADDING;
/* IN/OUT variables. */
- memory_t pages; /* 24: size of buffer, updated with actual size */
+ memory_t pages; /* 16: size of buffer, updated with actual size */
MEMORY_PADDING;
/* OUT variables. */
- memory_t fault_count; /* 32 */
+ memory_t fault_count; /* 24 */
MEMORY_PADDING;
- memory_t dirty_count; /* 40 */
+ memory_t dirty_count; /* 32 */
MEMORY_PADDING;
-} PACKED dom0_shadow_control_t; /* 48 bytes */
+} PACKED dom0_shadow_control_t; /* 40 bytes */
#define DOM0_SETDOMAINNAME 26
typedef struct {
/* IN variables. */
domid_t domain; /* 0 */
- char name[MAX_DOMAIN_NAME]; /* 8 */
-} PACKED dom0_setdomainname_t; /* 24 bytes */
+ u8 name[MAX_DOMAIN_NAME]; /* 4 */
+} PACKED dom0_setdomainname_t; /* 20 bytes */
#define DOM0_SETDOMAININITIALMEM 27
typedef struct {
/* IN variables. */
domid_t domain; /* 0 */
+ u32 __pad;
memory_t initial_memkb; /* 8 */
MEMORY_PADDING;
} PACKED dom0_setdomaininitialmem_t; /* 16 bytes */
typedef struct {
/* IN variables. */
domid_t domain; /* 0 */
+ u32 __pad;
memory_t max_memkb; /* 8 */
MEMORY_PADDING;
} PACKED dom0_setdomainmaxmem_t; /* 16 bytes */
typedef struct {
/* IN variables. */
domid_t domain; /* 0 */
+ u32 __pad;
memory_t num; /* 8 */
MEMORY_PADDING;
/* IN/OUT variables. */
#define EVTCHNOP_bind_interdomain 0
typedef struct {
/* IN parameters. */
- domid_t dom1, dom2; /* 0, 8 */
+ domid_t dom1, dom2; /* 0, 4 */
/* OUT parameters. */
- u32 port1, port2; /* 16, 20 */
-} PACKED evtchn_bind_interdomain_t; /* 24 bytes */
+ u32 port1, port2; /* 8, 12 */
+} PACKED evtchn_bind_interdomain_t; /* 16 bytes */
/*
* EVTCHNOP_bind_virq: Bind a local event channel to IRQ <irq>.
typedef struct {
/* IN parameters. */
domid_t dom; /* 0 */
- u32 port; /* 8 */
+ u32 port; /* 4 */
/* No OUT parameters. */
-} PACKED evtchn_close_t; /* 12 bytes */
+} PACKED evtchn_close_t; /* 8 bytes */
/*
* EVTCHNOP_send: Send an event to the remote end of the channel whose local
typedef struct {
/* IN parameters */
domid_t dom; /* 0 */
- u32 port; /* 8 */
+ u32 port; /* 4 */
/* OUT parameters */
#define EVTCHNSTAT_closed 0 /* Chennel is not in use. */
#define EVTCHNSTAT_unbound 1 /* Channel is not bound to a source. */
#define EVTCHNSTAT_interdomain 2 /* Channel is connected to remote domain. */
#define EVTCHNSTAT_pirq 3 /* Channel is bound to a phys IRQ line. */
#define EVTCHNSTAT_virq 4 /* Channel is bound to a virtual IRQ line */
- u32 status; /* 12 */
- union {
+ u32 status; /* 8 */
+ union { /* 12 */
struct {
- domid_t dom; /* 16 */
- u32 port; /* 24 */
+ domid_t dom; /* 12 */
+ u32 port; /* 16 */
} PACKED interdomain; /* EVTCHNSTAT_interdomain */
- u32 pirq; /* EVTCHNSTAT_pirq */ /* 16 */
- u32 virq; /* EVTCHNSTAT_virq */ /* 16 */
+ u32 pirq; /* EVTCHNSTAT_pirq */ /* 12 */
+ u32 virq; /* EVTCHNSTAT_virq */ /* 12 */
} PACKED u;
-} PACKED evtchn_status_t; /* 28 bytes */
+} PACKED evtchn_status_t; /* 20 bytes */
typedef struct {
u32 cmd; /* EVTCHNOP_* */ /* 0 */
evtchn_close_t close;
evtchn_send_t send;
evtchn_status_t status;
- u8 __dummy[32];
+ u8 __dummy[24];
} PACKED u;
-} PACKED evtchn_op_t; /* 40 bytes */
+} PACKED evtchn_op_t; /* 32 bytes */
#endif /* __HYPERVISOR_IFS__EVENT_CHANNEL_H__ */
* This domain that must own all non-page-table pages that are involved in
* MMU updates. By default it is the domain that executes mmu_update(). If the
* caller has sufficient privilege then it can be changed by executing
- * MMUEXT_SET_SUBJECTDOM_{L,H}.
+ * MMUEXT_SET_SUBJECTDOM.
*
* PTS (Page-Table Subject)
* ------------------------
* This domain must own all the page-table pages that are subject to MMU
* updates. By default it is the domain that executes mmu_update(). If the
* caller has sufficient privilege then it can be changed by executing
- * MMUEXT_SET_SUBJECTDOM_H with val[14] (SET_PAGETABLE_SUBJECTDOM) set.
+ * MMUEXT_SET_SUBJECTDOM with val[14] (SET_PAGETABLE_SUBJECTDOM) set.
*
* ptr[1:0] == MMU_NORMAL_PT_UPDATE:
* Updates an entry in a page table.
* ptr[:2] -- linear address of LDT base (NB. must be page-aligned)
* val[:8] -- number of entries in LDT
*
- * val[7:0] == MMUEXT_SET_SUBJECTDOM_L:
- * (ptr[31:15],val[31:15]) -- dom[31:0]
- *
- * val[7:0] == MMUEXT_SET_SUBJECTDOM_H:
+ * val[7:0] == MMUEXT_SET_SUBJECTDOM:
* val[14] -- if TRUE then sets the PTS in addition to the GPS.
- * (ptr[31:15],val[31:15]) -- dom[63:32]
- * NB. This command must be immediately preceded by SET_SUBJECTDOM_L.
+ * (ptr[31:15],val[31:15]) -- dom[31:0]
*
* val[7:0] == MMUEXT_REASSIGN_PAGE:
* ptr[:2] -- machine address within page to be reassigned to the GPS.
#define MMUEXT_TLB_FLUSH 6 /* ptr = NULL */
#define MMUEXT_INVLPG 7 /* ptr = VA to invalidate */
#define MMUEXT_SET_LDT 8 /* ptr = VA of table; val = # entries */
-/* NB. MMUEXT_SET_SUBJECTDOM must consist of *_L followed immediately by *_H */
-#define MMUEXT_SET_SUBJECTDOM_L 9 /* (ptr[31:15],val[31:15]) = dom[31:0] */
-#define MMUEXT_SET_SUBJECTDOM_H 10 /* (ptr[31:15],val[31:15]) = dom[63:32] */
-#define SET_PAGETABLE_SUBJECTDOM (1<<14) /* OR into 'val' arg of SUBJECTDOM_H*/
-#define MMUEXT_REASSIGN_PAGE 11
-#define MMUEXT_RESET_SUBJECTDOM 12
+#define MMUEXT_SET_SUBJECTDOM 9 /* (ptr[31:15],val[31:15]) = dom[31:0] */
+#define SET_PAGETABLE_SUBJECTDOM (1<<14) /* OR into 'val' arg of SUBJECTDOM */
+#define MMUEXT_REASSIGN_PAGE 10
+#define MMUEXT_RESET_SUBJECTDOM 11
#define MMUEXT_CMD_MASK 255
#define MMUEXT_CMD_SHIFT 8
#ifndef __ASSEMBLY__
-typedef u64 domid_t;
+typedef u32 domid_t;
/* DOMID_SELF is used in certain contexts to refer to oneself. */
-#define DOMID_SELF (~1ULL)
+#define DOMID_SELF (0x7FFFFFFEU)
#include "network.h"
#include "block.h"
} net_rule_t;
/* These are specified in the 'idx' if the 'dom' is SPECIAL. */
-#define VIF_SPECIAL (~0ULL)
+#define VIF_SPECIAL (0x7FFFFFFFU)
#define VIF_UNKNOWN_INTERFACE 0
#define VIF_PHYSICAL_INTERFACE 1
#define VIF_ANY_INTERFACE 2
struct sched_adjdom_cmd
{
- u32 sched_id; /* 0 */
- u32 direction; /* 4 */
+ u32 sched_id; /* 0 */
+ u32 direction; /* 4 */
domid_t domain; /* 8 */
+ u32 __pad;
union { /* 16 */
struct bvt_adjdom
{
u16 vdevice; /* 16 bit id domain refers to VBD as */
} vbd_delete_t;
-#define VBD_PROBE_ALL (~0ULL)
+#define VBD_PROBE_ALL (0x7FFFFFFFU)
typedef struct _vbd_probe {
domid_t domain; /* domain in question or VBD_PROBE_ALL */
xen_disk_info_t xdi; /* where's our space for VBD/disk info */
unlikely(x & PGC_zombie) || /* Zombie? */
unlikely(p != domain) ) /* Wrong owner? */
{
- DPRINTK("Error pfn %08lx: ed=%p(%lld), sd=%p(%lld), caf=%08x, taf=%08x\n",
- page_to_pfn(page), domain, (domain)?domain->domain:999, p, (p && !((x & PGC_count_mask) == 0))?p->domain:999, x, page->type_and_flags);
+ DPRINTK("Error pfn %08lx: ed=%p(%u), sd=%p(%u),"
+ " caf=%08x, taf=%08x\n",
+ page_to_pfn(page), domain, (domain)?domain->domain:999,
+ p, (p && !((x & PGC_count_mask) == 0))?p->domain:999,
+ x, page->type_and_flags);
return 0;
}
__asm__ __volatile__(
extern struct task_struct idle0_task;
extern struct task_struct *idle_task[NR_CPUS];
-#define IDLE_DOMAIN_ID (~0ULL)
+#define IDLE_DOMAIN_ID (0x7FFFFFFFU)
#define is_idle_task(_p) (test_bit(PF_IDLETASK, &(_p)->flags))
#include <xen/slab.h>
/* Shadow PT flag bits in pfn_info */
-#define PSH_shadowed (1<<31) /* page has a shadow. PFN points to shadow */
-#define PSH_pending (1<<29) /* page is in the process of being shadowed */
-#define PSH_pfn_mask ((1<<21)-1)
+#define PSH_shadowed (1<<31) /* page has a shadow. PFN points to shadow */
+#define PSH_pending (1<<29) /* page is in the process of being shadowed */
+#define PSH_pfn_mask ((1<<21)-1)
/* Shadow PT operation mode : shadowmode variable in mm_struct */
#define SHM_test (1) /* just run domain on shadow PTs */
extern int shadow_mode_control( struct task_struct *p, dom0_shadow_control_t *sc );
extern int shadow_fault( unsigned long va, long error_code );
extern void shadow_l1_normal_pt_update( unsigned long pa, unsigned long gpte,
- unsigned long *prev_spfn_ptr,
- l1_pgentry_t **prev_spl1e_ptr );
+ unsigned long *prev_spfn_ptr,
+ l1_pgentry_t **prev_spl1e_ptr );
extern void shadow_l2_normal_pt_update( unsigned long pa, unsigned long gpte );
extern void unshadow_table( unsigned long gpfn, unsigned int type );
extern int shadow_mode_enable( struct task_struct *p, unsigned int mode );
#ifndef NDEBUG
#define SH_LOG(_f, _a...) \
-printk("DOM%lld: (file=shadow.c, line=%d) " _f "\n", \
+printk("DOM%u: (file=shadow.c, line=%d) " _f "\n", \
current->domain , __LINE__ , ## _a )
#else
#define SH_LOG(_f, _a...)
#if SHADOW_DEBUG
#define SH_VLOG(_f, _a...) \
- printk("DOM%lld: (file=shadow.c, line=%d) " _f "\n", \
- current->domain , __LINE__ , ## _a )
+ printk("DOM%u: (file=shadow.c, line=%d) " _f "\n", \
+ current->domain , __LINE__ , ## _a )
#else
#define SH_VLOG(_f, _a...)
#endif
#if 0
#define SH_VVLOG(_f, _a...) \
- printk("DOM%lld: (file=shadow.c, line=%d) " _f "\n", \
- current->domain , __LINE__ , ## _a )
+ printk("DOM%u: (file=shadow.c, line=%d) " _f "\n", \
+ current->domain , __LINE__ , ## _a )
#else
#define SH_VVLOG(_f, _a...)
#endif
/************************************************************************/
- static inline void __mark_dirty( struct mm_struct *m, unsigned int mfn )
+static inline void __mark_dirty( struct mm_struct *m, unsigned int mfn )
{
unsigned int pfn;
ASSERT(spin_is_locked(&m->shadow_lock));
-
- //printk("%08x %08lx\n", mfn, machine_to_phys_mapping[mfn] );
pfn = machine_to_phys_mapping[mfn];
/* We use values with the top bit set to mark MFNs that aren't
really part of the domain's psuedo-physical memory map e.g.
the shared info frame. Nothing to do here...
- */
+ */
if ( unlikely(pfn & 0x80000000U) ) return;
ASSERT(m->shadow_dirty_bitmap);
if( likely(pfn<m->shadow_dirty_bitmap_size) )
{
- /* These updates occur with mm.shadow_lock held, so use
- (__) version of test_and_set */
- if( ! __test_and_set_bit( pfn, m->shadow_dirty_bitmap ) )
- {
- m->shadow_dirty_count++;
- }
+ /* These updates occur with mm.shadow_lock held, so use
+ (__) version of test_and_set */
+ if( !__test_and_set_bit( pfn, m->shadow_dirty_bitmap) )
+ m->shadow_dirty_count++;
}
else
{
- extern void show_traceX(void);
- SH_LOG("mark_dirty OOR! mfn=%x pfn=%x max=%x (mm %p)",
- mfn, pfn, m->shadow_dirty_bitmap_size, m );
- SH_LOG("dom=%lld caf=%08x taf=%08x\n",
- frame_table[mfn].u.domain->domain,
- frame_table[mfn].count_and_flags,
- frame_table[mfn].type_and_flags );
- //show_traceX();
+ extern void show_traceX(void);
+ SH_LOG("mark_dirty OOR! mfn=%x pfn=%x max=%x (mm %p)",
+ mfn, pfn, m->shadow_dirty_bitmap_size, m );
+ SH_LOG("dom=%u caf=%08x taf=%08x\n",
+ frame_table[mfn].u.domain->domain,
+ frame_table[mfn].count_and_flags,
+ frame_table[mfn].type_and_flags );
}
}
static inline void mark_dirty( struct mm_struct *m, unsigned int mfn )
-{
+{
ASSERT(local_irq_is_enabled());
//if(spin_is_locked(&m->shadow_lock)) printk("+");
spin_lock(&m->shadow_lock);
/************************************************************************/
static inline void l1pte_write_fault( struct mm_struct *m,
- unsigned long *gpte_p, unsigned long *spte_p )
+ unsigned long *gpte_p, unsigned long *spte_p )
{
unsigned long gpte = *gpte_p;
unsigned long spte = *spte_p;
switch( m->shadow_mode )
{
case SHM_test:
- spte = gpte;
- gpte |= _PAGE_DIRTY | _PAGE_ACCESSED;
- spte |= _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED;
- break;
+ spte = gpte;
+ gpte |= _PAGE_DIRTY | _PAGE_ACCESSED;
+ spte |= _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED;
+ break;
case SHM_logdirty:
- spte = gpte;
- gpte |= _PAGE_DIRTY | _PAGE_ACCESSED;
- spte |= _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED;
- __mark_dirty( m, (gpte >> PAGE_SHIFT) );
- break;
+ spte = gpte;
+ gpte |= _PAGE_DIRTY | _PAGE_ACCESSED;
+ spte |= _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED;
+ __mark_dirty( m, (gpte >> PAGE_SHIFT) );
+ break;
}
*gpte_p = gpte;
}
static inline void l1pte_read_fault( struct mm_struct *m,
- unsigned long *gpte_p, unsigned long *spte_p )
+ unsigned long *gpte_p, unsigned long *spte_p )
{
unsigned long gpte = *gpte_p;
unsigned long spte = *spte_p;
switch( m->shadow_mode )
{
case SHM_test:
- spte = gpte;
- gpte |= _PAGE_ACCESSED;
- spte |= _PAGE_ACCESSED;
- if ( ! (gpte & _PAGE_DIRTY ) )
- spte &= ~ _PAGE_RW;
- break;
+ spte = gpte;
+ gpte |= _PAGE_ACCESSED;
+ spte |= _PAGE_ACCESSED;
+ if ( ! (gpte & _PAGE_DIRTY ) )
+ spte &= ~ _PAGE_RW;
+ break;
case SHM_logdirty:
- spte = gpte;
- gpte |= _PAGE_ACCESSED;
- spte |= _PAGE_ACCESSED;
- spte &= ~ _PAGE_RW;
- break;
+ spte = gpte;
+ gpte |= _PAGE_ACCESSED;
+ spte |= _PAGE_ACCESSED;
+ spte &= ~ _PAGE_RW;
+ break;
}
*gpte_p = gpte;
}
static inline void l1pte_no_fault( struct mm_struct *m,
- unsigned long *gpte_p, unsigned long *spte_p )
+ unsigned long *gpte_p, unsigned long *spte_p )
{
unsigned long gpte = *gpte_p;
unsigned long spte = *spte_p;
switch( m->shadow_mode )
{
case SHM_test:
- spte = 0;
- if ( (gpte & (_PAGE_PRESENT|_PAGE_ACCESSED) ) ==
- (_PAGE_PRESENT|_PAGE_ACCESSED) )
- {
- spte = gpte;
- if ( ! (gpte & _PAGE_DIRTY ) )
- spte &= ~ _PAGE_RW;
- }
- break;
+ spte = 0;
+ if ( (gpte & (_PAGE_PRESENT|_PAGE_ACCESSED) ) ==
+ (_PAGE_PRESENT|_PAGE_ACCESSED) )
+ {
+ spte = gpte;
+ if ( ! (gpte & _PAGE_DIRTY ) )
+ spte &= ~ _PAGE_RW;
+ }
+ break;
case SHM_logdirty:
- spte = 0;
- if ( (gpte & (_PAGE_PRESENT|_PAGE_ACCESSED) ) ==
- (_PAGE_PRESENT|_PAGE_ACCESSED) )
- {
- spte = gpte;
- spte &= ~ _PAGE_RW;
- }
-
- break;
+ spte = 0;
+ if ( (gpte & (_PAGE_PRESENT|_PAGE_ACCESSED) ) ==
+ (_PAGE_PRESENT|_PAGE_ACCESSED) )
+ {
+ spte = gpte;
+ spte &= ~ _PAGE_RW;
+ }
+
+ break;
}
*gpte_p = gpte;
}
static inline void l2pde_general( struct mm_struct *m,
- unsigned long *gpde_p, unsigned long *spde_p,
- unsigned long sl1pfn)
+ unsigned long *gpde_p, unsigned long *spde_p,
+ unsigned long sl1pfn)
{
unsigned long gpde = *gpde_p;
unsigned long spde = *spde_p;
if ( sl1pfn )
{
- spde = (gpde & ~PAGE_MASK) | (sl1pfn<<PAGE_SHIFT) |
- _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY;
- gpde = gpde | _PAGE_ACCESSED | _PAGE_DIRTY;
-
- if ( unlikely( (sl1pfn<<PAGE_SHIFT) == (gpde & PAGE_MASK) ) )
- {
- // detect linear map, and keep pointing at guest
- SH_VLOG("4c: linear mapping ( %08lx )",sl1pfn);
- spde = gpde & ~_PAGE_RW;
- }
+
spde = (gpde & ~PAGE_MASK) | (sl1pfn<<PAGE_SHIFT) |
+ _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY;
+ gpde = gpde | _PAGE_ACCESSED | _PAGE_DIRTY;
+
+
if ( unlikely( (sl1pfn<<PAGE_SHIFT) == (gpde & PAGE_MASK) ) )
+ {
+ // detect linear map, and keep pointing at guest
+ SH_VLOG("4c: linear mapping ( %08lx )",sl1pfn);
+ spde = gpde & ~_PAGE_RW;
+ }
}
*gpde_p = gpde;
{
int live=0, free=0, j=0, abs;
struct shadow_status *a;
-
- for(j=0;j<shadow_ht_buckets;j++)
+
+ for( j = 0; j < shadow_ht_buckets; j++ )
{
a = &m->shadow_ht[j];
- if(a->pfn){live++; ASSERT(a->spfn_and_flags&PSH_pfn_mask);}
- ASSERT((a->pfn&0xf0000000)==0);
- ASSERT(a->pfn<0x00100000);
- a=a->next;
+ if(a->pfn){live++; ASSERT(a->spfn_and_flags&PSH_pfn_mask);}
+ ASSERT((a->pfn&0xf0000000)==0);
+ ASSERT(a->pfn<0x00100000);
+ a=a->next;
while(a && live<9999)
- {
- live++;
- if(a->pfn == 0 || a->spfn_and_flags == 0)
- {
- printk("XXX live=%d pfn=%08lx sp=%08lx next=%p\n",
- live, a->pfn, a->spfn_and_flags, a->next);
- BUG();
- }
- ASSERT(a->pfn);
- ASSERT((a->pfn&0xf0000000)==0);
- ASSERT(a->pfn<0x00100000);
- ASSERT(a->spfn_and_flags&PSH_pfn_mask);
- a=a->next;
- }
- ASSERT(live<9999);
+ {
+ live++;
+ if(a->pfn == 0 || a->spfn_and_flags == 0)
+ {
+ printk("XXX live=%d pfn=%08lx sp=%08lx next=%p\n",
+ live, a->pfn, a->spfn_and_flags, a->next);
+ BUG();
+ }
+ ASSERT(a->pfn);
+ ASSERT((a->pfn&0xf0000000)==0);
+ ASSERT(a->pfn<0x00100000);
+ ASSERT(a->spfn_and_flags&PSH_pfn_mask);
+ a=a->next;
+ }
+ ASSERT(live<9999);
}
a = m->shadow_ht_free;
abs=(perfc_value(shadow_l1_pages)+perfc_value(shadow_l2_pages))-live;
if( abs < -1 || abs > 1 )
{
- printk("live=%d free=%d l1=%d l2=%d\n",live,free,
- perfc_value(shadow_l1_pages), perfc_value(shadow_l2_pages) );
- BUG();
+ printk("live=%d free=%d l1=%d l2=%d\n",live,free,
+ perfc_value(shadow_l1_pages), perfc_value(shadow_l2_pages) );
+ BUG();
}
}
static inline struct shadow_status* hash_bucket( struct mm_struct *m,
- unsigned int gpfn )
+ unsigned int gpfn )
{
return &(m->shadow_ht[gpfn % shadow_ht_buckets]);
}
static inline unsigned long __shadow_status( struct mm_struct *m,
- unsigned int gpfn )
+ unsigned int gpfn )
{
struct shadow_status **ob, *b, *B = hash_bucket( m, gpfn );
do
{
- if ( b->pfn == gpfn )
- {
- unsigned long t;
- struct shadow_status *x;
-
- // swap with head
- t=B->pfn; B->pfn=b->pfn; b->pfn=t;
- t=B->spfn_and_flags; B->spfn_and_flags=b->spfn_and_flags;
- b->spfn_and_flags=t;
-
- if(ob)
- { // pull to front
- *ob=b->next;
- x=B->next;
- B->next=b;
- b->next=x;
- }
- return B->spfn_and_flags;
- }
+ if ( b->pfn == gpfn )
+ {
+ unsigned long t;
+ struct shadow_status *x;
+
+ // swap with head
+ t=B->pfn; B->pfn=b->pfn; b->pfn=t;
+ t=B->spfn_and_flags; B->spfn_and_flags=b->spfn_and_flags;
+ b->spfn_and_flags=t;
+
+ if( ob )
+ { // pull to front
+ *ob=b->next;
+ x=B->next;
+ B->next=b;
+ b->next=x;
+ }
+ return B->spfn_and_flags;
+ }
#if SHADOW_HASH_DEBUG
- else
- {
- if(b!=B)ASSERT(b->pfn);
- }
+ else
+ {
+ if(b!=B)ASSERT(b->pfn);
+ }
#endif
- ob=&b->next;
- b=b->next;
+ ob=&b->next;
+ b=b->next;
}
while (b);
anyway its probably not worth being too clever. */
static inline unsigned long get_shadow_status( struct mm_struct *m,
- unsigned int gpfn )
+ unsigned int gpfn )
{
unsigned long res;
bit in the dirty bitmap.
NB: the VA update path doesn't use this so needs to be handled
independnetly.
- */
+ */
ASSERT(local_irq_is_enabled());
//if(spin_is_locked(&m->shadow_lock)) printk("*");
spin_lock(&m->shadow_lock);
if( m->shadow_mode == SHM_logdirty )
- __mark_dirty( m, gpfn );
-
+ __mark_dirty( m, gpfn );
+
res = __shadow_status( m, gpfn );
if (!res) spin_unlock(&m->shadow_lock);
return res;
static inline void delete_shadow_status( struct mm_struct *m,
- unsigned int gpfn )
+ unsigned int gpfn )
{
struct shadow_status *b, *B, **ob;
if( b->pfn == gpfn )
{
- if (b->next)
- {
- struct shadow_status *D=b->next;
- b->spfn_and_flags = b->next->spfn_and_flags;
- b->pfn = b->next->pfn;
-
- b->next = b->next->next;
- D->next = m->shadow_ht_free;
- D->pfn = 0;
- D->spfn_and_flags = 0;
- m->shadow_ht_free = D;
- }
- else
- {
- b->pfn = 0;
- b->spfn_and_flags = 0;
- }
+ if (b->next)
+ {
+ struct shadow_status *D=b->next;
+ b->spfn_and_flags = b->next->spfn_and_flags;
+ b->pfn = b->next->pfn;
+
+ b->next = b->next->next;
+ D->next = m->shadow_ht_free;
+ D->pfn = 0;
+ D->spfn_and_flags = 0;
+ m->shadow_ht_free = D;
+ }
+ else
+ {
+ b->pfn = 0;
+ b->spfn_and_flags = 0;
+ }
#if SHADOW_HASH_DEBUG
- if( __shadow_status(m,gpfn) ) BUG();
- shadow_audit(m,0);
+ if( __shadow_status(m,gpfn) ) BUG();
+ shadow_audit(m,0);
#endif
- return;
+ return;
}
ob = &b->next;
do
{
- if ( b->pfn == gpfn )
- {
- b->pfn = 0;
- b->spfn_and_flags = 0;
+ if ( b->pfn == gpfn )
+ {
+ b->pfn = 0;
+ b->spfn_and_flags = 0;
- // b is in the list
- *ob=b->next;
- b->next = m->shadow_ht_free;
- m->shadow_ht_free = b;
+ // b is in the list
+ *ob=b->next;
+ b->next = m->shadow_ht_free;
+ m->shadow_ht_free = b;
#if SHADOW_HASH_DEBUG
- if( __shadow_status(m,gpfn) ) BUG();
+ if( __shadow_status(m,gpfn) ) BUG();
#endif
- shadow_audit(m,0);
- return;
- }
+ shadow_audit(m,0);
+ return;
+ }
- ob = &b->next;
- b=b->next;
+ ob = &b->next;
+ b=b->next;
}
while (b);
static inline void set_shadow_status( struct mm_struct *m,
- unsigned int gpfn, unsigned long s )
+ unsigned int gpfn, unsigned long s )
{
struct shadow_status *b, *B, *extra, **fptr;
int i;
B = b = hash_bucket( m, gpfn );
ASSERT(gpfn);
- //ASSERT(s);
- //ASSERT(s&PSH_pfn_mask);
SH_VVLOG("set gpfn=%08x s=%08lx bucket=%p(%p)", gpfn, s, b, b->next );
shadow_audit(m,0);
do
{
- if ( b->pfn == gpfn )
- {
- b->spfn_and_flags = s;
- shadow_audit(m,0);
- return;
- }
-
- b=b->next;
+ if ( b->pfn == gpfn )
+ {
+ b->spfn_and_flags = s;
+ shadow_audit(m,0);
+ return;
+ }
+
+ b=b->next;
}
while (b);
if ( B->pfn == 0 )
{
- // we can use this head
- ASSERT( B->next == 0 );
- B->pfn = gpfn;
- B->spfn_and_flags = s;
- shadow_audit(m,0);
- return;
+ // we can use this head
+ ASSERT( B->next == 0 );
+ B->pfn = gpfn;
+ B->spfn_and_flags = s;
+ shadow_audit(m,0);
+ return;
}
if( unlikely(m->shadow_ht_free == NULL) )
{
- SH_LOG("allocate more shadow hashtable blocks");
+ SH_LOG("allocate more shadow hashtable blocks");
- // we need to allocate more space
- extra = kmalloc( sizeof(void*) + (shadow_ht_extra_size *
- sizeof(struct shadow_status)), GFP_KERNEL );
+ // we need to allocate more space
+ extra = kmalloc( sizeof(void*) + (shadow_ht_extra_size *
+ sizeof(struct shadow_status)), GFP_KERNEL );
- if( ! extra ) BUG(); // should be more graceful here....
+ if( ! extra ) BUG(); // should be more graceful here....
- memset( extra, 0, sizeof(void*) + (shadow_ht_extra_size *
- sizeof(struct shadow_status)) );
+ memset( extra, 0, sizeof(void*) + (shadow_ht_extra_size *
+ sizeof(struct shadow_status)) );
- m->shadow_extras_count++;
-
- // add extras to free list
- fptr = &m->shadow_ht_free;
- for ( i=0; i<shadow_ht_extra_size; i++ )
- {
- *fptr = &extra[i];
- fptr = &(extra[i].next);
- }
- *fptr = NULL;
+ m->shadow_extras_count++;
- *((struct shadow_status ** ) &extra[shadow_ht_extra_size]) =
- m->shadow_ht_extras;
- m->shadow_ht_extras = extra;
+ // add extras to free list
+ fptr = &m->shadow_ht_free;
+ for ( i=0; i<shadow_ht_extra_size; i++ )
+ {
+ *fptr = &extra[i];
+ fptr = &(extra[i].next);
+ }
+ *fptr = NULL;
+
+ *((struct shadow_status ** ) &extra[shadow_ht_extra_size]) =
+ m->shadow_ht_extras;
+ m->shadow_ht_extras = extra;
}
unsigned long gpfn, spfn=0;
gpfn = pagetable_val(mm->pagetable) >> PAGE_SHIFT;
-
+
if ( unlikely((spfn=__shadow_status(mm, gpfn)) == 0 ) )
{
- spfn = shadow_l2_table(mm, gpfn );
+ spfn = shadow_l2_table(mm, gpfn );
}
mm->shadow_table = mk_pagetable(spfn<<PAGE_SHIFT);
}
static inline void shadow_mk_pagetable( struct mm_struct *mm )
{
SH_VVLOG("shadow_mk_pagetable( gptbase=%08lx, mode=%d )",
- pagetable_val(mm->pagetable), mm->shadow_mode );
+ pagetable_val(mm->pagetable), mm->shadow_mode );
if ( unlikely(mm->shadow_mode) )
{
- ASSERT(local_irq_is_enabled());
+ ASSERT(local_irq_is_enabled());
spin_lock(&mm->shadow_lock);
- __shadow_mk_pagetable( mm );
+ __shadow_mk_pagetable( mm );
- spin_unlock(&mm->shadow_lock);
+ spin_unlock(&mm->shadow_lock);
}
SH_VVLOG("leaving shadow_mk_pagetable( gptbase=%08lx, mode=%d ) sh=%08lx",
- pagetable_val(mm->pagetable), mm->shadow_mode,
- pagetable_val(mm->shadow_table) );
+ pagetable_val(mm->pagetable), mm->shadow_mode,
+ pagetable_val(mm->shadow_table) );
}
if ( unlikely(pte_pfn >= max_page) ||
unlikely(!get_page_and_type(pte_page, p, PGT_l1_page_table)) )
{
- DPRINTK("Bad page frame for ppte %llu,%08lx,%08lx,%08x\n",
+ DPRINTK("Bad page frame for ppte %u,%08lx,%08lx,%08x\n",
p->domain, pte_pfn, max_page, pte_page->type_and_flags);
make_rx_response(vif, rx.id, 0, RING_STATUS_BAD_PAGE, 0);
continue;
put_page_and_type(&frame_table[rx->pte_ptr >> PAGE_SHIFT]);
- /* if in shadow mode, mark the PTE as dirty */
- if( p->mm.shadow_mode == SHM_logdirty )
- {
- mark_dirty( &p->mm, rx->pte_ptr>>PAGE_SHIFT );
-#if 0
- mark_dirty( &p->mm, rx->buf_pfn ); // XXXXXXX debug
-
- {
- unsigned long * p = map_domain_mem( rx->buf_pfn<<PAGE_SHIFT );
- p[2] = 0xdeadc001;
- unmap_domain_mem(p);
- }
-#endif
-
- }
- /* assume the shadow page table is about to be blown away,
- and that its not worth marking the buffer as dirty */
-
+ /*
+ * If in shadow mode, mark the PTE as dirty.
+ * (We assume the shadow page table is about to be blown away,
+ * and so it's not worth marking the buffer as dirty.)
+ */
+ if ( p->mm.shadow_mode == SHM_logdirty )
+ mark_dirty(&p->mm, rx->pte_ptr>>PAGE_SHIFT);
make_rx_response(vif, rx->id, 0, RING_STATUS_DROPPED, 0);
}
#include "common.h"
#define BLKIF_HASHSZ 1024
-#define BLKIF_HASH(_d,_h) \
- (((int)(_d)^(int)((_d)>>32)^(int)(_h))&(BLKIF_HASHSZ-1))
+#define BLKIF_HASH(_d,_h) (((int)(_d)^(int)(_h))&(BLKIF_HASHSZ-1))
static kmem_cache_t *blkif_cachep;
static blkif_t *blkif_hash[BLKIF_HASHSZ];
blkif = blkif_find_by_handle(domid, handle);
if ( unlikely(blkif == NULL) )
{
- DPRINTK("blkif_connect attempted for non-existent blkif (%llu,%u)\n",
+ DPRINTK("blkif_connect attempted for non-existent blkif (%u,%u)\n",
connect->domid, connect->blkif_handle);
connect->status = BLKIF_BE_STATUS_INTERFACE_NOT_FOUND;
return;
if ( unlikely(blkif == NULL) )
{
DPRINTK("blkif_disconnect attempted for non-existent blkif"
- " (%llu,%u)\n", disconnect->domid, disconnect->blkif_handle);
+ " (%u,%u)\n", disconnect->domid, disconnect->blkif_handle);
disconnect->status = BLKIF_BE_STATUS_INTERFACE_NOT_FOUND;
return 1; /* Caller will send response error message. */
}
mcl[i].args[0] = MMAP_VADDR(pending_idx, i) >> PAGE_SHIFT;
mcl[i].args[1] = (phys_seg[i].buffer & PAGE_MASK) | remap_prot;
mcl[i].args[2] = 0;
- mcl[i].args[3] = (unsigned long)blkif->domid;
- mcl[i].args[4] = (unsigned long)(blkif->domid>>32);
+ mcl[i].args[3] = blkif->domid;
phys_to_machine_mapping[__pa(MMAP_VADDR(pending_idx, i))>>PAGE_SHIFT] =
phys_seg[i].buffer >> PAGE_SHIFT;
blkif = blkif_find_by_handle(create->domid, create->blkif_handle);
if ( unlikely(blkif == NULL) )
{
- DPRINTK("vbd_create attempted for non-existent blkif (%llu,%u)\n",
+ DPRINTK("vbd_create attempted for non-existent blkif (%u,%u)\n",
create->domid, create->blkif_handle);
create->status = BLKIF_BE_STATUS_INTERFACE_NOT_FOUND;
return;
rb_link_node(&vbd->rb, rb_parent, rb_p);
rb_insert_color(&vbd->rb, &blkif->vbd_rb);
- DPRINTK("Successful creation of vdev=%04x (dom=%llu)\n",
+ DPRINTK("Successful creation of vdev=%04x (dom=%u)\n",
vdevice, create->domid);
create->status = BLKIF_BE_STATUS_OKAY;
blkif = blkif_find_by_handle(grow->domid, grow->blkif_handle);
if ( unlikely(blkif == NULL) )
{
- DPRINTK("vbd_grow attempted for non-existent blkif (%llu,%u)\n",
+ DPRINTK("vbd_grow attempted for non-existent blkif (%u,%u)\n",
grow->domid, grow->blkif_handle);
grow->status = BLKIF_BE_STATUS_INTERFACE_NOT_FOUND;
return;
*px = x;
- DPRINTK("Successful grow of vdev=%04x (dom=%llu)\n",
+ DPRINTK("Successful grow of vdev=%04x (dom=%u)\n",
vdevice, grow->domid);
grow->status = BLKIF_BE_STATUS_OKAY;
blkif = blkif_find_by_handle(shrink->domid, shrink->blkif_handle);
if ( unlikely(blkif == NULL) )
{
- DPRINTK("vbd_shrink attempted for non-existent blkif (%llu,%u)\n",
+ DPRINTK("vbd_shrink attempted for non-existent blkif (%u,%u)\n",
shrink->domid, shrink->blkif_handle);
shrink->status = BLKIF_BE_STATUS_INTERFACE_NOT_FOUND;
return;
blkif = blkif_find_by_handle(destroy->domid, destroy->blkif_handle);
if ( unlikely(blkif == NULL) )
{
- DPRINTK("vbd_destroy attempted for non-existent blkif (%llu,%u)\n",
+ DPRINTK("vbd_destroy attempted for non-existent blkif (%u,%u)\n",
destroy->domid, destroy->blkif_handle);
destroy->status = BLKIF_BE_STATUS_INTERFACE_NOT_FOUND;
return;
goto found;
}
- DPRINTK("vbd_translate; domain %llu attempted to access "
+ DPRINTK("vbd_translate; domain %u attempted to access "
"non-existent VBD.\n", blkif->domid);
spin_unlock(&blkif->vbd_lock);
case IOCTL_PRIVCMD_MMAP:
{
#define PRIVCMD_MMAP_SZ 32
- privcmd_mmap_t mmapcmd;
- privcmd_mmap_entry_t msg[PRIVCMD_MMAP_SZ], *p;
- int i, rc;
+ privcmd_mmap_t mmapcmd;
+ privcmd_mmap_entry_t msg[PRIVCMD_MMAP_SZ], *p;
+ int i, rc;
if ( copy_from_user(&mmapcmd, (void *)data, sizeof(mmapcmd)) )
return -EFAULT;
- p = mmapcmd.entry;
-
- for (i=0; i<mmapcmd.num; i+=PRIVCMD_MMAP_SZ, p+=PRIVCMD_MMAP_SZ)
- {
- int j, n = ((mmapcmd.num-i)>PRIVCMD_MMAP_SZ)?
- PRIVCMD_MMAP_SZ:(mmapcmd.num-i);
- if ( copy_from_user(&msg, p, n*sizeof(privcmd_mmap_entry_t)) )
- return -EFAULT;
-
- for ( j = 0; j < n; j++ )
- {
- struct vm_area_struct *vma =
- find_vma( current->mm, msg[j].va );
-
- if ( !vma )
- return -EINVAL;
-
- if ( msg[j].va > PAGE_OFFSET )
- return -EINVAL;
-
- if ( (msg[j].va + (msg[j].npages<<PAGE_SHIFT)) > vma->vm_end )
- return -EINVAL;
-
- if ( (rc = direct_remap_area_pages(vma->vm_mm,
- msg[j].va&PAGE_MASK,
- msg[j].mfn<<PAGE_SHIFT,
- msg[j].npages<<PAGE_SHIFT,
- vma->vm_page_prot,
- mmapcmd.dom)) < 0 )
- return rc;
- }
- }
- ret = 0;
+ p = mmapcmd.entry;
+
+ for (i=0; i<mmapcmd.num; i+=PRIVCMD_MMAP_SZ, p+=PRIVCMD_MMAP_SZ)
+ {
+ int j, n = ((mmapcmd.num-i)>PRIVCMD_MMAP_SZ)?
+ PRIVCMD_MMAP_SZ:(mmapcmd.num-i);
+ if ( copy_from_user(&msg, p, n*sizeof(privcmd_mmap_entry_t)) )
+ return -EFAULT;
+
+ for ( j = 0; j < n; j++ )
+ {
+ struct vm_area_struct *vma =
+ find_vma( current->mm, msg[j].va );
+
+ if ( !vma )
+ return -EINVAL;
+
+ if ( msg[j].va > PAGE_OFFSET )
+ return -EINVAL;
+
+
if ( (msg[j].va + (msg[j].npages<<PAGE_SHIFT)) > vma->vm_end )
+ return -EINVAL;
+
+ if ( (rc = direct_remap_area_pages(vma->vm_mm,
+ msg[j].va&PAGE_MASK,
+
msg[j].mfn<<PAGE_SHIFT,
+
msg[j].npages<<PAGE_SHIFT,
+ vma->vm_page_prot,
+ mmapcmd.dom)) < 0 )
+ return rc;
+ }
+ }
+ ret = 0;
}
break;
case IOCTL_PRIVCMD_MMAPBATCH:
{
#define MAX_DIRECTMAP_MMU_QUEUE 130
- mmu_update_t u[MAX_DIRECTMAP_MMU_QUEUE], *w, *v;
- privcmd_mmapbatch_t m;
- struct vm_area_struct *vma = NULL;
- unsigned long *p, addr;
- unsigned long mfn;
- int i;
+ mmu_update_t u[MAX_DIRECTMAP_MMU_QUEUE], *w, *v;
+ privcmd_mmapbatch_t m;
+ struct vm_area_struct *vma = NULL;
+ unsigned long *p, addr;
+ unsigned long mfn;
+ int i;
if ( copy_from_user(&m, (void *)data, sizeof(m)) )
- { ret = -EFAULT; goto batch_err; }
-
- vma = find_vma( current->mm, m.addr );
-
- if ( !vma )
- { ret = -EINVAL; goto batch_err; }
-
- if ( m.addr > PAGE_OFFSET )
- { ret = -EFAULT; goto batch_err; }
-
- if ( (m.addr + (m.num<<PAGE_SHIFT)) > vma->vm_end )
- { ret = -EFAULT; goto batch_err; }
-
- if ( m.dom != 0 )
- {
- u[0].val = (unsigned long)(m.dom<<16) & ~0xFFFFUL;
- u[0].ptr = (unsigned long)(m.dom<< 0) & ~0xFFFFUL;
- u[1].val = (unsigned long)(m.dom>>16) & ~0xFFFFUL;
- u[1].ptr = (unsigned long)(m.dom>>32) & ~0xFFFFUL;
- u[0].ptr |= MMU_EXTENDED_COMMAND;
- u[0].val |= MMUEXT_SET_SUBJECTDOM_L;
- u[1].ptr |= MMU_EXTENDED_COMMAND;
- u[1].val |= MMUEXT_SET_SUBJECTDOM_H;
- v = w = &u[2];
- }
- else
- {
- v = w = &u[0];
- }
-
- p = m.arr;
- addr = m.addr;
- for ( i = 0; i < m.num; i++, addr += PAGE_SIZE, p++ )
- {
- if ( get_user(mfn, p) ) return -EFAULT;
-
- v->val = (mfn << PAGE_SHIFT) | pgprot_val(vma->vm_page_prot) |
- _PAGE_IO;
-
- __direct_remap_area_pages(vma->vm_mm,
+ { ret = -EFAULT; goto batch_err; }
+
+ vma = find_vma( current->mm, m.addr );
+
+ if ( !vma )
+ { ret = -EINVAL; goto batch_err; }
+
+ if ( m.addr > PAGE_OFFSET )
+ { ret = -EFAULT; goto batch_err; }
+
+ if ( (m.addr + (m.num<<PAGE_SHIFT)) > vma->vm_end )
+ { ret = -EFAULT; goto batch_err; }
+
+ if ( m.dom != 0 )
+ {
+ u[0].val = (unsigned long)(m.dom<<16) & ~0xFFFFUL;
+ u[0].ptr = (unsigned long)(m.dom<< 0) & ~0xFFFFUL;
+ u[0].ptr |= MMU_EXTENDED_COMMAND;
+ u[0].val |= MMUEXT_SET_SUBJECTDOM;
+ v = w = &u[1];
+ }
+ else
+ {
+ v = w = &u[0];
+ }
+
+ p = m.arr;
+ addr = m.addr;
+ for ( i = 0; i < m.num; i++, addr += PAGE_SIZE, p++ )
+ {
+ if ( get_user(mfn, p) ) return -EFAULT;
+
+ v->val = (mfn << PAGE_SHIFT) | pgprot_val(vma->vm_page_prot) |
+ _PAGE_IO;
+
+ __direct_remap_area_pages(vma->vm_mm,
addr,
PAGE_SIZE,
v);
- if ( unlikely(HYPERVISOR_mmu_update(u, v - u + 1, NULL) < 0) )
- put_user( 0xF0000000 | mfn, p );
+ if ( unlikely(HYPERVISOR_mmu_update(u, v - u + 1, NULL) < 0) )
+ put_user( 0xF0000000 | mfn, p );
- v = w;
- }
- ret = 0;
- break;
+ v = w;
+ }
+ ret = 0;
+ break;
batch_err:
- printk("batch_err ret=%d vma=%p addr=%lx num=%d arr=%p %lx-%lx\n",
- ret, vma, m.addr, m.num, m.arr, vma->vm_start, vma->vm_end);
- break;
+ printk("batch_err ret=%d vma=%p addr=%lx num=%d arr=%p %lx-%lx\n",
+ ret, vma, m.addr, m.num, m.arr, vma->vm_start, vma->vm_end);
+ break;
}
break;
-
-
default:
ret = -EINVAL;
- break;
+ break;
}
return ret;
}
static int privcmd_mmap(struct file * file, struct vm_area_struct * vma)
{
- /* DONTCOPY is essential for Xen as copy_page_range is broken. */
- vma->vm_flags |= VM_RESERVED | VM_IO | VM_DONTCOPY;
+ /* DONTCOPY is essential for Xen as copy_page_range is broken. */
+ vma->vm_flags |= VM_RESERVED | VM_IO | VM_DONTCOPY;
- return 0;
+ return 0;
}
static struct file_operations privcmd_file_ops = {
- ioctl : privcmd_ioctl,
- mmap: privcmd_mmap
+ ioctl : privcmd_ioctl,
+ mmap: privcmd_mmap
};
module_init(init_module);
module_exit(cleanup_module);
+#
#include <linux/rtnetlink.h>
#define NETIF_HASHSZ 1024
-#define NETIF_HASH(_d,_h) \
- (((int)(_d)^(int)((_d)>>32)^(int)(_h))&(NETIF_HASHSZ-1))
+#define NETIF_HASH(_d,_h) (((int)(_d)^(int)(_h))&(NETIF_HASHSZ-1))
static netif_t *netif_hash[NETIF_HASHSZ];
static struct net_device *bridge_dev;
netif = netif_find_by_handle(domid, handle);
if ( unlikely(netif == NULL) )
{
- DPRINTK("netif_connect attempted for non-existent netif (%llu,%u)\n",
+ DPRINTK("netif_connect attempted for non-existent netif (%u,%u)\n",
connect->domid, connect->netif_handle);
connect->status = NETIF_BE_STATUS_INTERFACE_NOT_FOUND;
return;
if ( unlikely(netif == NULL) )
{
DPRINTK("netif_disconnect attempted for non-existent netif"
- " (%llu,%u)\n", disconnect->domid, disconnect->netif_handle);
+ " (%u,%u)\n", disconnect->domid, disconnect->netif_handle);
disconnect->status = NETIF_BE_STATUS_INTERFACE_NOT_FOUND;
return 1; /* Caller will send response error message. */
}
} rx_info_t;
static struct sk_buff_head rx_queue;
static multicall_entry_t rx_mcl[NETIF_RX_RING_SIZE*2];
-static mmu_update_t rx_mmu[NETIF_RX_RING_SIZE*4];
+static mmu_update_t rx_mmu[NETIF_RX_RING_SIZE*3];
static unsigned char rx_notify[NR_EVENT_CHANNELS];
/* Don't currently gate addition of an interface to the tx scheduling list. */
mmu[0].val = __pa(vdata) >> PAGE_SHIFT;
mmu[1].val = (unsigned long)(netif->domid<<16) & ~0xFFFFUL;
mmu[1].ptr = (unsigned long)(netif->domid<< 0) & ~0xFFFFUL;
- mmu[2].val = (unsigned long)(netif->domid>>16) & ~0xFFFFUL;
- mmu[2].ptr = (unsigned long)(netif->domid>>32) & ~0xFFFFUL;
mmu[1].ptr |= MMU_EXTENDED_COMMAND;
- mmu[1].val |= MMUEXT_SET_SUBJECTDOM_L;
- mmu[2].ptr |= MMU_EXTENDED_COMMAND;
- mmu[2].val |= MMUEXT_SET_SUBJECTDOM_H;
- mmu[3].ptr = (mdata & PAGE_MASK) | MMU_EXTENDED_COMMAND;
- mmu[3].val = MMUEXT_REASSIGN_PAGE;
+ mmu[1].val |= MMUEXT_SET_SUBJECTDOM;
+ mmu[2].ptr = (mdata & PAGE_MASK) | MMU_EXTENDED_COMMAND;
+ mmu[2].val = MMUEXT_REASSIGN_PAGE;
mcl[0].op = __HYPERVISOR_update_va_mapping;
mcl[0].args[0] = vdata >> PAGE_SHIFT;
mcl[0].args[2] = 0;
mcl[1].op = __HYPERVISOR_mmu_update;
mcl[1].args[0] = (unsigned long)mmu;
- mcl[1].args[1] = 4;
+ mcl[1].args[1] = 3;
mcl[1].args[2] = 0;
- mmu += 4;
+ mmu += 3;
mcl += 2;
((rx_info_t *)&skb->cb[0])->old_mach_ptr = mdata;
/* Check the reassignment error code. */
if ( unlikely(mcl[1].args[5] != 0) )
{
- DPRINTK("Failed MMU update transferring to DOM%llu\n",
+ DPRINTK("Failed MMU update transferring to DOM%u\n",
netif->domid);
(void)HYPERVISOR_update_va_mapping(
(unsigned long)skb->head >> PAGE_SHIFT,
mcl[0].args[0] = MMAP_VADDR(pending_idx) >> PAGE_SHIFT;
mcl[0].args[1] = (txreq.addr & PAGE_MASK) | __PAGE_KERNEL;
mcl[0].args[2] = 0;
- mcl[0].args[3] = (unsigned long)netif->domid;
- mcl[0].args[4] = (unsigned long)(netif->domid>>32);
+ mcl[0].args[3] = netif->domid;
mcl++;
((tx_info_t *)&skb->cb[0])->idx = pending_idx;
(void)request_irq(bind_virq_to_irq(VIRQ_DEBUG),
netif_be_dbg, SA_SHIRQ,
- "net-be-dbg", NULL);
+ "net-be-dbg", &netif_be_dbg);
return 0;
}
{
u[0].val = (unsigned long)(domid<<16) & ~0xFFFFUL;
u[0].ptr = (unsigned long)(domid<< 0) & ~0xFFFFUL;
- u[1].val = (unsigned long)(domid>>16) & ~0xFFFFUL;
- u[1].ptr = (unsigned long)(domid>>32) & ~0xFFFFUL;
u[0].ptr |= MMU_EXTENDED_COMMAND;
- u[0].val |= MMUEXT_SET_SUBJECTDOM_L;
- u[1].ptr |= MMU_EXTENDED_COMMAND;
- u[1].val |= MMUEXT_SET_SUBJECTDOM_H;
- v = w = &u[2];
+ u[0].val |= MMUEXT_SET_SUBJECTDOM;
+ v = w = &u[1];
}
else
{
static int mmap_mem(struct file * file, struct vm_area_struct * vma)
{
unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
- domid_t domid;
if (!(start_info.flags & SIF_PRIVILEGED))
return -ENXIO;
- domid = file->private_data ? *(domid_t *)file->private_data : 0;
-
/* DONTCOPY is essential for Xen as copy_page_range is broken. */
vma->vm_flags |= VM_RESERVED | VM_IO | VM_DONTCOPY;
vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
if (direct_remap_area_pages(vma->vm_mm, vma->vm_start, offset,
vma->vm_end-vma->vm_start, vma->vm_page_prot,
- domid))
+ (domid_t)file->private_data))
return -EAGAIN;
return 0;
}
static int ioctl_mem(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
{
- if (file->private_data == NULL)
- file->private_data = kmalloc(sizeof(domid_t), GFP_KERNEL);
switch (cmd) {
- case _IO('M', 1): ((unsigned long *)file->private_data)[0]=arg; break;
- case _IO('M', 2): ((unsigned long *)file->private_data)[1]=arg; break;
+ case _IO('M', 1): file->private_data = (void *)arg; break;
default: return -ENOSYS;
}
return 0;
}
-static int release_mem(struct inode * inode, struct file * file)
-{
- if (file->private_data != NULL)
- kfree(file->private_data);
- return 0;
-}
#endif /* CONFIG_XEN */
/*
mmap: mmap_mem,
open: open_mem,
#if defined(CONFIG_XEN_PRIVILEGED_GUEST)
- release: release_mem,
ioctl: ioctl_mem,
#endif
};
__asm__ __volatile__ (
TRAP_INSTR
: "=a" (ret) : "0" (__HYPERVISOR_update_va_mapping_otherdomain),
- "b" (page_nr), "c" ((new_val).pte_low), "d" (flags),
- "S" ((unsigned long)domid), "D" ((unsigned long)(domid>>32)) :
+ "b" (page_nr), "c" ((new_val).pte_low), "d" (flags), "S" (domid) :
"memory" );
return ret;
projects / xen.git / commitdiff