int xc_get_online_cpus(xc_interface *xch)
{
xc_physinfo_t physinfo;
if ( !xc_physinfo(xch, &physinfo) )
return physinfo.nr_cpus;
return -1;
}
int main(int argc, char *argv[])
{
int i, ret = 0;
xc_physinfo_t physinfo = { 0 };
int nr_matches = 0;
int matches_main_options[ARRAY_SIZE(main_options)];
if ( argc < 2 )
{
show_help();
return 0;
}
xc_handle = xc_interface_open(0,0,0);
if ( !xc_handle )
{
fprintf(stderr, "failed to get the handler\n");
return EIO;
}
ret = xc_physinfo(xc_handle, &physinfo);
if ( ret )
{
ret = errno;
fprintf(stderr, "failed to get processor information (%d - %s)\n",
ret, strerror(ret));
xc_interface_close(xc_handle);
return ret;
}
max_cpu_nr = physinfo.nr_cpus;
/* calculate how many options match with user's input */
for ( i = 0; i < ARRAY_SIZE(main_options); i++ )
if ( !strncmp(main_options[i].name, argv[1], strlen(argv[1])) )
matches_main_options[nr_matches++] = i;
if ( nr_matches > 1 )
{
fprintf(stderr, "Ambiguous options: ");
for ( i = 0; i < nr_matches; i++ )
fprintf(stderr, " %s", main_options[matches_main_options[i]].name);
fprintf(stderr, "\n");
ret = EINVAL;
}
else if ( nr_matches == 1 )
/* dispatch to the corresponding function handler */
main_options[matches_main_options[0]].function(argc - 2, argv + 2);
else
{
show_help();
ret = EINVAL;
}
xc_interface_close(xc_handle);
return ret;
}
static int xencpu_init (void)
{
xc_handle = xc_interface_open(XC_INTERFACE_INIT_ARGS);
if (!xc_handle)
{
ERROR ("xencpu: xc_interface_open() failed");
return (-1);
}
xc_physinfo_t *physinfo;
physinfo = calloc(1, sizeof(xc_physinfo_t));
if (physinfo == NULL)
{
ERROR ("xencpu plugin: calloc() for physinfo failed.");
xc_interface_close(xc_handle);
return (ENOMEM);
}
if (xc_physinfo(xc_handle, physinfo) < 0)
{
ERROR ("xencpu plugin: xc_physinfo() failed");
xc_interface_close(xc_handle);
free(physinfo);
return (-1);
}
num_cpus = physinfo->nr_cpus;
free(physinfo);
INFO ("xencpu plugin: Found %"PRIu32" processors.", num_cpus);
cpu_info = calloc(num_cpus, sizeof(xc_cpuinfo_t));
if (cpu_info == NULL)
{
ERROR ("xencpu plugin: calloc() for num_cpus failed.");
xc_interface_close(xc_handle);
return (ENOMEM);
}
cpu_states = calloc (num_cpus, sizeof (value_to_rate_state_t));
if (cpu_states == NULL)
{
ERROR ("xencpu plugin: calloc() for cpu_states failed.");
xc_interface_close(xc_handle);
free(cpu_info);
return (ENOMEM);
}
return (0);
} /* static int xencpu_init */
CAMLprim value stub_xenctrlext_get_max_nr_cpus(value xch)
{
CAMLparam1(xch);
xc_physinfo_t c_physinfo;
int r;
caml_enter_blocking_section();
r = xc_physinfo(_H(xch), &c_physinfo);
caml_leave_blocking_section();
if (r)
failwith_xc(_H(xch));
CAMLreturn(Val_int(c_physinfo.max_cpu_id + 1));
}
int xc_get_max_nodes(xc_interface *xch)
{
static int max_nodes = 0;
xc_physinfo_t physinfo;
if ( max_nodes )
return max_nodes;
if ( !xc_physinfo(xch, &physinfo) )
{
max_nodes = physinfo.max_node_id + 1;
return max_nodes;
}
return -1;
}
void handle_low_mem(void)
{
xc_dominfo_t dom0_info;
xc_physinfo_t info;
unsigned long long free_pages, dom0_pages, diff, dom0_target;
char data[BUFSZ], error[BUFSZ];
if (xc_physinfo(xch, &info) < 0)
{
perror("Getting physinfo failed");
return;
}
free_pages = (unsigned long long) info.free_pages;
printf("Available free pages: 0x%llx:%llux\n",
free_pages, free_pages);
/* Don't do anything if we have more than the threshold free */
if ( free_pages >= THRESHOLD_PG )
return;
diff = THRESHOLD_PG - free_pages;
if (xc_domain_getinfo(xch, 0, 1, &dom0_info) < 1)
{
perror("Failed to get dom0 info");
return;
}
dom0_pages = (unsigned long long) dom0_info.nr_pages;
printf("Dom0 pages: 0x%llx:%llu\n", dom0_pages, dom0_pages);
dom0_target = dom0_pages - diff;
if (dom0_target <= DOM0_FLOOR_PG)
return;
printf("Shooting for dom0 target 0x%llx:%llu\n",
dom0_target, dom0_target);
snprintf(data, BUFSZ, "%llu", dom0_target);
if (!xs_write(xs_handle, XBT_NULL,
"/local/domain/0/memory/target", data, strlen(data)))
{
snprintf(error, BUFSZ,"Failed to write target %s to xenstore", data);
perror(error);
}
}
static int readVNodeCounters(HSP *sp, SFLHost_vrt_node_counters *vnode)
{
if(xenHandlesOK(sp)) {
xc_physinfo_t physinfo = { 0 };
if(xc_physinfo(sp->xc_handle, &physinfo) < 0) {
myLog(LOG_ERR, "xc_physinfo() failed : %s", strerror(errno));
}
else {
vnode->mhz = (physinfo.cpu_khz / 1000);
vnode->cpus = physinfo.nr_cpus;
vnode->memory = ((uint64_t)physinfo.total_pages * sp->page_size);
vnode->memory_free = ((uint64_t)physinfo.free_pages * sp->page_size);
vnode->num_domains = sp->num_domains;
return YES;
}
}
return NO;
}
/**
* get_num_cpus - get the number of logical CPUs
*/
static unsigned int get_num_cpus(void)
{
xc_physinfo_t physinfo = { 0 };
int xc_handle = xc_interface_open();
int ret;
ret = xc_physinfo(xc_handle, &physinfo);
if ( ret != 0 )
{
PERROR("Failure to get logical CPU count from Xen");
exit(EXIT_FAILURE);
}
xc_interface_close(xc_handle);
opts.cpu_freq = (double)physinfo.cpu_khz/1000.0;
return physinfo.nr_cpus;
}
/**
* get_num_cpus - get the number of logical CPUs
*/
unsigned int get_num_cpus(void)
{
xc_physinfo_t physinfo;
int xc_handle = xc_interface_open();
int ret;
ret = xc_physinfo(xc_handle, &physinfo);
if ( ret != 0 )
{
PERROR("Failure to get logical CPU count from Xen");
exit(EXIT_FAILURE);
}
xc_interface_close(xc_handle);
opts.cpu_freq = (double)physinfo.cpu_khz/1000.0;
return (physinfo.threads_per_core *
physinfo.cores_per_socket *
physinfo.sockets_per_node *
physinfo.nr_nodes);
}
xenstat_node *xenstat_get_node(xenstat_handle * handle, unsigned int flags)
{
#define DOMAIN_CHUNK_SIZE 256
xenstat_node *node;
xc_physinfo_t physinfo = { 0 };
xc_domaininfo_t domaininfo[DOMAIN_CHUNK_SIZE];
unsigned int new_domains;
unsigned int i;
/* Create the node */
node = (xenstat_node *) calloc(1, sizeof(xenstat_node));
if (node == NULL)
return NULL;
/* Store the handle in the node for later access */
node->handle = handle;
/* Get information about the physical system */
if (xc_physinfo(handle->xc_handle, &physinfo) < 0) {
free(node);
return NULL;
}
node->cpu_hz = ((unsigned long long)physinfo.cpu_khz) * 1000ULL;
node->num_cpus = physinfo.nr_cpus;
node->tot_mem = ((unsigned long long)physinfo.total_pages)
* handle->page_size;
node->free_mem = ((unsigned long long)physinfo.free_pages)
* handle->page_size;
/* malloc(0) is not portable, so allocate a single domain. This will
* be resized below. */
node->domains = malloc(sizeof(xenstat_domain));
if (node->domains == NULL) {
free(node);
return NULL;
}
node->num_domains = 0;
do {
xenstat_domain *domain, *tmp;
new_domains = xc_domain_getinfolist(handle->xc_handle,
node->num_domains,
DOMAIN_CHUNK_SIZE,
domaininfo);
tmp = realloc(node->domains,
(node->num_domains + new_domains)
* sizeof(xenstat_domain));
if (tmp == NULL) {
free(node->domains);
free(node);
return NULL;
}
node->domains = tmp;
domain = node->domains + node->num_domains;
/* zero out newly allocated memory in case error occurs below */
memset(domain, 0, new_domains * sizeof(xenstat_domain));
for (i = 0; i < new_domains; i++) {
/* Fill in domain using domaininfo[i] */
domain->id = domaininfo[i].domain;
domain->name = xenstat_get_domain_name(handle,
domain->id);
if (domain->name == NULL) {
if (errno == ENOMEM) {
/* fatal error */
xenstat_free_node(node);
return NULL;
}
else {
/* failed to get name -- this means the
domain is being destroyed so simply
ignore this entry */
continue;
}
}
domain->state = domaininfo[i].flags;
domain->cpu_ns = domaininfo[i].cpu_time;
domain->num_vcpus = (domaininfo[i].max_vcpu_id+1);
domain->vcpus = NULL;
domain->cur_mem =
((unsigned long long)domaininfo[i].tot_pages)
* handle->page_size;
domain->max_mem =
domaininfo[i].max_pages == UINT_MAX
? (unsigned long long)-1
: (unsigned long long)(domaininfo[i].max_pages
* handle->page_size);
domain->ssid = domaininfo[i].ssidref;
domain->num_networks = 0;
domain->networks = NULL;
domain->num_vbds = 0;
domain->vbds = NULL;
domain++;
node->num_domains++;
}
} while (new_domains == DOMAIN_CHUNK_SIZE);
/* Run all the extra data collectors requested */
node->flags = 0;
for (i = 0; i < NUM_COLLECTORS; i++) {
if ((flags & collectors[i].flag) == collectors[i].flag) {
node->flags |= collectors[i].flag;
if(collectors[i].collect(node) == 0) {
xenstat_free_node(node);
return NULL;
}
}
}
return node;
}
