--- libvirt.orig/include/libvirt/libvirt.h 2007-03-17 07:26:55.000000000 +0900 +++ libvirt.sched/include/libvirt/libvirt.h 2007-04-12 17:30:20.000000000 +0900 @@ -169,6 +169,69 @@ struct _virNodeInfo { /** + * virDomainSchedParameterType: + * + * A scheduler parameter field type + */ +typedef enum { + VIR_DOMAIN_SCHED_FIELD_INT = 0, /* integer case */ + VIR_DOMAIN_SCHED_FIELD_UINT = 1, /* unsigned integer case */ + VIR_DOMAIN_SCHED_FIELD_LLONG = 2, /* long long case */ + VIR_DOMAIN_SCHED_FIELD_ULLONG = 3, /* unsigned long long case */ + VIR_DOMAIN_SCHED_FIELD_DOUBLE = 4, /* double case */ + VIR_DOMAIN_SCHED_FIELD_BOOLEAN = 5 /* boolean(character) case */ +} virSchedParameterType; + +/** + * VIR_DOMAIN_SCHED_FIELD_LENGTH: + * + * Macro providing the field length of virSchedParameter + */ + +#define VIR_DOMAIN_SCHED_FIELD_LENGTH 80 + +/** + * virDomainSchedParameter: + * + * a virDomainSchedParameter is the set of scheduler parameters + */ + +typedef struct _virSchedParameter virSchedParameter; + +struct _virSchedParameter { + char field[VIR_DOMAIN_SCHED_FIELD_LENGTH]; /* parameter name */ + int type; /* Format type should use enum from virSchedParameterType */ + union { + int i; /* data for integer case */ + unsigned int ui; /* data for unsigned integer case */ + long long int l; /* data for long long integer case */ + unsigned long long int ul; /* data for unsigned long long integer case */ + double d; /* data for double case */ + char b; /* data for char case */ + } value; /* parameter value */ +}; + +/** + * virSchedParameterPtr: + * + * a virSchedParameterPtr is a pointer to a virSchedParameter structure. + */ + +typedef virSchedParameter *virSchedParameterPtr; + +/* + * Fetch scheduler parameters, caller allocates 'params' field of size 'nparams' + */ +int virDomainGetSchedulerParameters (virDomainPtr domain, + virSchedParameterPtr params, int *nparams); + +/* + * Change scheduler parameters + */ +int virDomainSetSchedulerParameters (virDomainPtr domain, + virSchedParameterPtr params, int *nparams); + +/** * VIR_NODEINFO_MAXCPUS: * @nodeinfo: virNodeInfo instance * @@ -303,6 +366,12 @@ int virDomainGetInfo (virDomainPtr dom virDomainInfoPtr info); /* + * Return scheduler type in effect 'sedf', 'credit', 'linux' + */ +const char * virDomainGetSchedulerType (virDomainPtr domain, + int *nparams); + +/* * Dynamic control of domains */ const char * virDomainGetName (virDomainPtr domain); --- libvirt.orig/include/libvirt/libvirt.h.in 2007-03-16 02:24:57.000000000 +0900 +++ libvirt.sched/include/libvirt/libvirt.h.in 2007-04-12 17:27:32.000000000 +0900 @@ -169,6 +169,69 @@ struct _virNodeInfo { /** + * virDomainSchedParameterType: + * + * A scheduler parameter field type + */ +typedef enum { + VIR_DOMAIN_SCHED_FIELD_INT = 0, /* integer case */ + VIR_DOMAIN_SCHED_FIELD_UINT = 1, /* unsigned integer case */ + VIR_DOMAIN_SCHED_FIELD_LLONG = 2, /* long long case */ + VIR_DOMAIN_SCHED_FIELD_ULLONG = 3, /* unsigned long long case */ + VIR_DOMAIN_SCHED_FIELD_DOUBLE = 4, /* double case */ + VIR_DOMAIN_SCHED_FIELD_BOOLEAN = 5 /* boolean(character) case */ +} virSchedParameterType; + +/** + * VIR_DOMAIN_SCHED_FIELD_LENGTH: + * + * Macro providing the field length of virSchedParameter + */ + +#define VIR_DOMAIN_SCHED_FIELD_LENGTH 80 + +/** + * virDomainSchedParameter: + * + * a virDomainSchedParameter is the set of scheduler parameters + */ + +typedef struct _virSchedParameter virSchedParameter; + +struct _virSchedParameter { + char field[VIR_DOMAIN_SCHED_FIELD_LENGTH]; /* parameter name */ + int type; /* Format type should use enum from virSchedParameterType */ + union { + int i; /* data for integer case */ + unsigned int ui; /* data for unsigned integer case */ + long long int l; /* data for long long integer case */ + unsigned long long int ul; /* data for unsigned long long integer case */ + double d; /* data for double case */ + char b; /* data for char case */ + } value; /* parameter value */ +}; + +/** + * virSchedParameterPtr: + * + * a virSchedParameterPtr is a pointer to a virSchedParameter structure. + */ + +typedef virSchedParameter *virSchedParameterPtr; + +/* + * Fetch scheduler parameters, caller allocates 'params' field of size 'nparams' + */ +int virDomainGetSchedulerParameters (virDomainPtr domain, + virSchedParameterPtr params, int *nparams); + +/* + * Change scheduler parameters + */ +int virDomainSetSchedulerParameters (virDomainPtr domain, + virSchedParameterPtr params, int *nparams); + +/** * VIR_NODEINFO_MAXCPUS: * @nodeinfo: virNodeInfo instance * @@ -303,6 +366,12 @@ int virDomainGetInfo (virDomainPtr dom virDomainInfoPtr info); /* + * Return scheduler type in effect 'sedf', 'credit', 'linux' + */ +const char * virDomainGetSchedulerType (virDomainPtr domain, + int *nparams); + +/* * Dynamic control of domains */ const char * virDomainGetName (virDomainPtr domain); --- libvirt.orig/src/driver.h 2007-04-04 23:19:49.000000000 +0900 +++ libvirt.sched/src/driver.h 2007-04-12 17:27:32.000000000 +0900 @@ -157,6 +157,18 @@ typedef int (*virDrvDomainSetAutostart) (virDomainPtr domain, int autostart); +typedef const char * + (*virDrvDomainGetSchedulerType) (virDomainPtr domain, + int *nparams); + +typedef int + (*virDrvDomainGetSchedulerParameters) (virDomainPtr domain, + virSchedParameterPtr params, int *nparams); + +typedef int + (*virDrvDomainSetSchedulerParameters) (virDomainPtr domain, + virSchedParameterPtr params, int *nparams); + typedef struct _virDriver virDriver; typedef virDriver *virDriverPtr; @@ -216,6 +228,9 @@ struct _virDriver { virDrvDomainDetachDevice domainDetachDevice; virDrvDomainGetAutostart domainGetAutostart; virDrvDomainSetAutostart domainSetAutostart; + virDrvDomainGetSchedulerType domainGetSchedulerType; + virDrvDomainGetSchedulerParameters domainGetSchedulerParameters; + virDrvDomainSetSchedulerParameters domainSetSchedulerParameters; }; typedef int --- libvirt.orig/src/libvirt.c 2007-04-04 23:19:49.000000000 +0900 +++ libvirt.sched/src/libvirt.c 2007-04-12 17:27:32.000000000 +0900 @@ -1423,6 +1423,126 @@ virConnectGetCapabilities (virConnectPtr return NULL; } +/** + * virDomainGetSchedulerType: + * @domain: pointer to domain object + * @nparams: number of scheduler parameters(return value) + * + * Get the scheduler type. + * + * Returns NULL in case of error. + */ +const char * +virDomainGetSchedulerType(virDomainPtr domain, int *nparams) +{ + virConnectPtr conn; + const char *schedtype; + + if (domain == NULL) { + TODO + return NULL; + } + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(domain, VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + return NULL; + } + conn = domain->conn; + + if (!VIR_IS_CONNECT (conn)) { + virLibConnError (conn, VIR_ERR_INVALID_CONN, __FUNCTION__); + return NULL; + } + + if (conn->driver->domainGetSchedulerType){ + schedtype = conn->driver->domainGetSchedulerType (domain, nparams); + return schedtype; + } + + return NULL; +} + + +/** + * virDomainGetSchedulerParameters: + * @domain: pointer to domain object + * @params: pointer to scheduler parameter object + * (return value) + * @nparams: pointer to number of scheduler parameter + * (this value should be same as + * the nparams of virDomainGetSchedulerType) + * + * Get the scheduler parameters + * + * Returns NULL in case of error. + */ +int +virDomainGetSchedulerParameters(virDomainPtr domain, + virSchedParameterPtr params, int *nparams) +{ + virConnectPtr conn; + + if (domain == NULL) { + TODO + return -1; + } + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(domain, VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + return -1; + } + conn = domain->conn; + + if (!VIR_IS_CONNECT (conn)) { + virLibConnError (conn, VIR_ERR_INVALID_CONN, __FUNCTION__); + return -1; + } + + if (conn->driver->domainGetSchedulerParameters) + return conn->driver->domainGetSchedulerParameters (domain, params, nparams); + + return -1; +} + +/** + * virDomainSetSchedulerParameters: + * @domain: pointer to domain object + * @params: pointer to scheduler parameter object + * @nparams: pointer to number of scheduler parameter + * (this value should be same or less as + * the nparams of virDomainGetSchedulerType) + * + * Change the scheduler parameters + * + * Returns NULL in case of error. + */ +int +virDomainSetSchedulerParameters(virDomainPtr domain, + virSchedParameterPtr params, int *nparams) +{ + virConnectPtr conn; + + if (domain == NULL) { + TODO + return -1; + } + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(domain, VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + return -1; + } + conn = domain->conn; + + if (!VIR_IS_CONNECT (conn)) { + virLibConnError (conn, VIR_ERR_INVALID_CONN, __FUNCTION__); + return -1; + } + + if (conn->driver->domainSetSchedulerParameters) + return conn->driver->domainSetSchedulerParameters (domain, params, nparams); + + return -1; +} + + + /************************************************************************ * * * Handling of defined but not running domains * --- libvirt.orig/src/libvirt_sym.version 2007-03-16 02:24:57.000000000 +0900 +++ libvirt.sched/src/libvirt_sym.version 2007-04-12 17:27:32.000000000 +0900 @@ -59,6 +59,9 @@ virDomainPinVcpu; virDomainGetVcpus; virDomainGetMaxVcpus; + virDomainGetSchedulerType; + virDomainGetSchedulerParameters; + virDomainSetSchedulerParameters; virDomainAttachDevice; virDomainDetachDevice; --- libvirt.orig/src/proxy_internal.c 2007-04-04 23:19:49.000000000 +0900 +++ libvirt.sched/src/proxy_internal.c 2007-04-12 17:27:32.000000000 +0900 @@ -87,6 +87,9 @@ virDriver xenProxyDriver = { NULL, /* domainDetachDevice */ NULL, /* domainGetAutostart */ NULL, /* domainSetAutostart */ + NULL, /* domainGetSchedulerType */ + NULL, /* domainGetSchedulerParameters */ + NULL, /* domainSetSchedulerParameters */ }; /** --- libvirt.orig/src/qemu_internal.c 2007-04-04 23:19:49.000000000 +0900 +++ libvirt.sched/src/qemu_internal.c 2007-04-12 17:27:32.000000000 +0900 @@ -1326,6 +1326,9 @@ static virDriver qemuDriver = { NULL, /* domainDetachDevice */ qemuDomainGetAutostart, /* domainGetAutostart */ qemuDomainSetAutostart, /* domainSetAutostart */ + NULL, /* domainGetSchedulerType */ + NULL, /* domainGetSchedulerParameters */ + NULL, /* domainSetSchedulerParameters */ }; static virNetworkDriver qemuNetworkDriver = { --- libvirt.orig/src/test.c 2007-04-07 00:34:09.000000000 +0900 +++ libvirt.sched/src/test.c 2007-04-12 17:27:32.000000000 +0900 @@ -132,6 +132,9 @@ static virDriver testDriver = { NULL, /* domainDetachDevice */ NULL, /* domainGetAutostart */ NULL, /* domainSetAutostart */ + NULL, /* domainGetSchedulerType */ + NULL, /* domainGetSchedulerParameters */ + NULL, /* domainSetSchedulerParameters */ }; /* Per-connection private data. */ --- libvirt.orig/src/virsh.c 2007-04-11 03:40:50.000000000 +0900 +++ libvirt.sched/src/virsh.c 2007-04-12 17:27:32.000000000 +0900 @@ -889,6 +889,118 @@ cmdSave(vshControl * ctl, vshCmd * cmd) } /* + * "schedinfo" command + */ +static vshCmdInfo info_schedinfo[] = { + {"syntax", "sched "}, + {"help", gettext_noop("show/set scheduler parameters")}, + {"desc", gettext_noop("Show/Set scheduler parameters.")}, + {NULL, NULL} +}; + +static vshCmdOptDef opts_schedinfo[] = { + {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, gettext_noop("domain name, id or uuid")}, + {"weight", VSH_OT_INT, VSH_OFLAG_NONE, gettext_noop("weight for XEN_CREDIT")}, + {"cap", VSH_OT_INT, VSH_OFLAG_NONE, gettext_noop("cap for XEN_CREDIT")}, + {NULL, 0, 0, NULL} +}; + +static int +cmdSchedinfo(vshControl * ctl, vshCmd * cmd) +{ + const char *schedulertype; + virDomainPtr dom; + virSchedParameterPtr params; + int i, ret; + int *nparams; + int inputparam = 0; + int weightfound = 0; + int weight; + int capfound = 0; + int cap; + char *str_weight = strdup("weight"); + char *str_cap = strdup("cap"); + + nparams = malloc(sizeof(int)); + *nparams = 0; + + if (!vshConnectionUsability(ctl, ctl->conn, TRUE)) + return FALSE; + + if (!(dom = vshCommandOptDomain(ctl, cmd, "domain", NULL))) + return FALSE; + + /* Currently supports Xen Credit only */ + weight = vshCommandOptInt(cmd, "weight", &weightfound); + if(weightfound){ inputparam++; } + + cap = vshCommandOptInt(cmd, "cap", &capfound); + if(capfound){ inputparam++; } + + params = vshMalloc(ctl, sizeof(virSchedParameter)* inputparam); + + inputparam=0; + if (weightfound) { + strncpy(params[inputparam].field,str_weight,sizeof(str_weight)); + params[inputparam].type = VIR_DOMAIN_SCHED_FIELD_UINT; + params[inputparam].value.ui = weight; + inputparam++; + } + + if (capfound) { + strncpy(params[inputparam].field,str_cap,sizeof(str_cap)); + params[inputparam].type = VIR_DOMAIN_SCHED_FIELD_UINT; + params[inputparam].value.ui = cap; + inputparam++; + } + /* End Currently supports Xen Credit only */ + + /* Get SchedulerType */ + schedulertype = virDomainGetSchedulerType(dom, nparams); + if (schedulertype!= NULL){ + vshPrint(ctl, "%-15s %s\n", _("Scheduler:"), + schedulertype); + } else { + vshPrint(ctl, "%-15s %s\n", _("Scheduler:"), _("Unknown")); + return -1; + } + + /* Set SchedulerParameters */ + ret = virDomainSetSchedulerParameters(dom, params, &inputparam); + + /* Get SchedulerParameters */ + params = vshMalloc(ctl, sizeof(virSchedParameter)* *nparams); + ret = virDomainGetSchedulerParameters(dom, params, nparams); + if(nparams){ + for (i = 0; i < *nparams; i++){ + switch (params[i].type) { + case VIR_DOMAIN_SCHED_FIELD_INT: + printf("%-15s: %d\n", params[i].field, params[i].value.i); + break; + case VIR_DOMAIN_SCHED_FIELD_UINT: + printf("%-15s: %u\n", params[i].field, params[i].value.ui); + break; + case VIR_DOMAIN_SCHED_FIELD_LLONG: + printf("%-15s: %Ld\n", params[i].field, params[i].value.l); + break; + case VIR_DOMAIN_SCHED_FIELD_ULLONG: + printf("%-15s: %Lu\n", params[i].field, params[i].value.ul); + break; + case VIR_DOMAIN_SCHED_FIELD_DOUBLE: + printf("%-15s: %f\n", params[i].field, params[i].value.d); + break; + case VIR_DOMAIN_SCHED_FIELD_BOOLEAN: + printf("%-15s: %d\n", params[i].field, params[i].value.b); + break; + default: + printf("not implemented scheduler parameter type\n"); + } + } + } + return TRUE; +} + +/* * "restore" command */ static vshCmdInfo info_restore[] = { @@ -2444,6 +2556,7 @@ static vshCmdDef commands[] = { {"restore", cmdRestore, opts_restore, info_restore}, {"resume", cmdResume, opts_resume, info_resume}, {"save", cmdSave, opts_save, info_save}, + {"schedinfo", cmdSchedinfo, opts_schedinfo, info_schedinfo}, {"dump", cmdDump, opts_dump, info_dump}, {"shutdown", cmdShutdown, opts_shutdown, info_shutdown}, {"setmem", cmdSetmem, opts_setmem, info_setmem}, --- libvirt.orig/src/xen_internal.h 2007-04-04 23:19:49.000000000 +0900 +++ libvirt.sched/src/xen_internal.h 2007-04-12 17:27:32.000000000 +0900 @@ -66,6 +66,17 @@ int xenHypervisorGetVcpus (virDomainPtr int maplen); int xenHypervisorGetVcpuMax (virDomainPtr domain); +const char * xenHypervisorGetSchedulerType (virDomainPtr domain, + int *nparams); + +int xenHypervisorGetSchedulerParameters (virDomainPtr domain, + virSchedParameterPtr params, + int *nparams); + +int xenHypervisorSetSchedulerParameters (virDomainPtr domain, + virSchedParameterPtr params, + int *nparams); + #ifdef __cplusplus } #endif --- libvirt.orig/src/xen_internal.c 2007-04-04 23:19:49.000000000 +0900 +++ libvirt.sched/src/xen_internal.c 2007-04-12 17:27:32.000000000 +0900 @@ -158,6 +158,19 @@ union xen_getdomaininfolist { }; typedef union xen_getdomaininfolist xen_getdomaininfolist; + +struct xen_v2_getschedulerid { + uint32_t sched_id; /* Get Scheduler ID from Xen */ +}; +typedef struct xen_v2_getschedulerid xen_v2_getschedulerid; + + +union xen_getschedulerid { + struct xen_v2_getschedulerid *v2; +}; +typedef union xen_getschedulerid xen_getschedulerid; + + #define XEN_GETDOMAININFOLIST_ALLOC(domlist, size) \ (hypervisor_version < 2 ? \ ((domlist.v0 = malloc(sizeof(xen_v0_getdomaininfo)*(size))) != NULL) : \ @@ -377,6 +390,43 @@ typedef struct xen_v2_vcpuinfo xen_v2_vc typedef struct xen_v2_setvcpumap xen_v2_getvcpumap; /* + * from V2 we get the scheduler information + */ +#define XEN_V2_OP_GETSCHEDULERID 4 + +/* + * from V2 we get the scheduler parameter + */ +#define XEN_V2_OP_SCHEDULER 16 +/* Scheduler types. */ +#define XEN_SCHEDULER_SEDF 4 +#define XEN_SCHEDULER_CREDIT 5 +/* get/set scheduler parameters */ +#define XEN_DOMCTL_SCHEDOP_putinfo 0 +#define XEN_DOMCTL_SCHEDOP_getinfo 1 + +struct xen_v2_setschedinfo { + uint32_t sched_id; + uint32_t cmd; + union { + struct xen_domctl_sched_sedf { + uint64_t period; + uint64_t slice; + uint64_t latency; + uint32_t extratime; + uint32_t weight; + } sedf; + struct xen_domctl_sched_credit { + uint16_t weight; + uint16_t cap; + } credit; + } u; +}; +typedef struct xen_v2_setschedinfo xen_v2_setschedinfo; +typedef struct xen_v2_setschedinfo xen_v2_getschedinfo; + + +/* * The hypercall operation structures also have changed on * changeset 86d26e6ec89b */ @@ -403,6 +453,7 @@ struct xen_op_v2_sys { uint32_t interface_version; union { xen_v2_getdomaininfolistop getdomaininfolist; + xen_v2_getschedulerid getschedulerid; uint8_t padding[128]; } u; }; @@ -419,6 +470,8 @@ struct xen_op_v2_dom { xen_v2_setvcpumap setvcpumap; xen_v2_vcpuinfo getvcpuinfo; xen_v2_getvcpumap getvcpumap; + xen_v2_setschedinfo setschedinfo; + xen_v2_getschedinfo getschedinfo; uint8_t padding[128]; } u; }; @@ -483,6 +536,9 @@ virDriver xenHypervisorDriver = { NULL, /* domainDetachDevice */ NULL, /* domainGetAutostart */ NULL, /* domainSetAutostart */ + xenHypervisorGetSchedulerType, /* domainGetSchedulerType */ + xenHypervisorGetSchedulerParameters, /* domainGetSchedulerParameters */ + xenHypervisorSetSchedulerParameters, /* domainSetSchedulerParameters */ }; #endif /* !PROXY */ @@ -784,6 +840,190 @@ virXen_getdomaininfo(int handle, int fir #ifndef PROXY /** + * xenHypervisorGetSchedulerType: + * @domain: pointer to the Xen Hypervisor block + * @nparams:give a number of scheduler parameters. + * + * Do a low level hypercall to get scheduler type + * + * Returns scheduler name or NULL in case of failure + */ +const char * +xenHypervisorGetSchedulerType(virDomainPtr domain, int *nparams) +{ + const char *schedulertype = NULL; + xenUnifiedPrivatePtr priv; + + if ((domain == NULL) || (domain->conn == NULL)) + return(schedulertype); + + priv = (xenUnifiedPrivatePtr) domain->conn->privateData; + if (priv->handle < 0 || domain->id < 0) + return(schedulertype); + + if (hypervisor_version > 1) { + xen_op_v2_sys op; + int ret; + + memset(&op, 0, sizeof(op)); + op.cmd = XEN_V2_OP_GETSCHEDULERID; + ret = xenHypervisorDoV2Sys(priv->handle, &op); + + switch (op.u.getschedulerid.sched_id){ + case XEN_SCHEDULER_SEDF: + schedulertype = strdup("sedf"); + *nparams = 6; + break; + case XEN_SCHEDULER_CREDIT: + schedulertype = strdup("credit"); + *nparams = 2; + break; + default: + break; + } + } + + return(schedulertype); + +} + +/** + * xenHypervisorGetSchedulerParameters: + * @domain: pointer to the Xen Hypervisor block + * @params: pointer to scheduler parameters. + * This memory area should be allocated before calling. + * @nparams:this parameter should be same as + * a given number of scheduler parameters. + * from xenHypervisorGetSchedulerType(). + * + * Do a low level hypercall to get scheduler parameters + * + * Returns 0 or -1 in case of failure + */ +int +xenHypervisorGetSchedulerParameters(virDomainPtr domain, + virSchedParameterPtr params, int *nparams) +{ + int ret = -1; + xenUnifiedPrivatePtr priv; + + if ((domain == NULL) || (domain->conn == NULL)) + return -1; + + priv = (xenUnifiedPrivatePtr) domain->conn->privateData; + if (priv->handle < 0 || domain->id < 0) + return -1; + + if (hypervisor_version > 1) { + xen_op_v2_sys op_sys; + xen_op_v2_dom op_dom; + char *str_weight =strdup("weight"); + char *str_cap =strdup("cap"); + + memset(&op_sys, 0, sizeof(op_sys)); + op_sys.cmd = XEN_V2_OP_GETSCHEDULERID; + ret = xenHypervisorDoV2Sys(priv->handle, &op_sys); + + switch (op_sys.u.getschedulerid.sched_id){ + case XEN_SCHEDULER_SEDF: + /* TODO: Implement for Xen/SEDF */ + break; + case XEN_SCHEDULER_CREDIT: + if(*nparams != 2) + break; + memset(&op_dom, 0, sizeof(op_dom)); + op_dom.cmd = XEN_V2_OP_SCHEDULER; + op_dom.domain = (domid_t) domain->id; + op_dom.u.getschedinfo.sched_id = XEN_SCHEDULER_CREDIT; + op_dom.u.getschedinfo.cmd = XEN_DOMCTL_SCHEDOP_getinfo; + ret = xenHypervisorDoV2Dom(priv->handle, &op_dom); + + strncpy(params[0].field,str_weight,sizeof(str_weight)); + params[0].type = VIR_DOMAIN_SCHED_FIELD_UINT; + params[0].value.ui = op_dom.u.getschedinfo.u.credit.weight; + + strncpy(params[1].field,str_cap,sizeof(str_cap)); + params[1].type = VIR_DOMAIN_SCHED_FIELD_UINT; + params[1].value.ui = op_dom.u.getschedinfo.u.credit.cap; + + ret = 0; + break; + default: + break; + } + } + return ret; +} + +/** + * xenHypervisorSetSchedulerParameters: + * @domain: pointer to the Xen Hypervisor block + * @nparams:give a number of scheduler setting parameters . + * + * Do a low level hypercall to set scheduler parameters + * + * Returns 0 or -1 in case of failure + */ +int +xenHypervisorSetSchedulerParameters(virDomainPtr domain, + virSchedParameterPtr params, int *nparams) +{ + int ret = -1; + int i; + xenUnifiedPrivatePtr priv; + + if ((domain == NULL) || (domain->conn == NULL)) + return -1; + + priv = (xenUnifiedPrivatePtr) domain->conn->privateData; + if (priv->handle < 0 || domain->id < 0) + return -1; + + if (hypervisor_version > 1) { + xen_op_v2_sys op_sys; + xen_op_v2_dom op_dom; + char *str_weight =strdup("weight"); + char *str_cap =strdup("cap"); + + memset(&op_sys, 0, sizeof(op_sys)); + op_sys.cmd = XEN_V2_OP_GETSCHEDULERID; + ret = xenHypervisorDoV2Sys(priv->handle, &op_sys); + + switch (op_sys.u.getschedulerid.sched_id){ + case XEN_SCHEDULER_SEDF: + /* TODO: Implement for Xen/SEDF */ + break; + case XEN_SCHEDULER_CREDIT: + memset(&op_dom, 0, sizeof(op_dom)); + op_dom.cmd = XEN_V2_OP_SCHEDULER; + op_dom.domain = (domid_t) domain->id; + op_dom.u.getschedinfo.sched_id = XEN_SCHEDULER_CREDIT; + op_dom.u.getschedinfo.cmd = XEN_DOMCTL_SCHEDOP_putinfo; + /* credit scheduler parameters + * following values do not change the parameters + */ + op_dom.u.getschedinfo.u.credit.weight = 0; + op_dom.u.getschedinfo.u.credit.cap = (uint16_t)~0U; + + for(i = 0;i < *nparams; i++ ){ + if(!strncmp(params[i].field,str_weight,sizeof(str_weight))) + op_dom.u.getschedinfo.u.credit.weight = + params[i].value.ui; + if(!strncmp(params[i].field,str_cap,sizeof(str_cap))) + op_dom.u.getschedinfo.u.credit.cap = + params[i].value.ui; + } + ret = xenHypervisorDoV2Dom(priv->handle, &op_dom); + break; + default: + break; + } + } + + return(ret); +} + +/** * virXen_pausedomain: * @handle: the hypervisor handle * @id: the domain id --- libvirt.orig/src/xen_unified.c 2007-04-10 22:00:26.000000000 +0900 +++ libvirt.sched/src/xen_unified.c 2007-04-12 17:39:14.000000000 +0900 @@ -709,6 +709,48 @@ xenUnifiedDomainSetAutostart (virDomainP return -1; } +static const char * +xenUnifiedDomainGetSchedulerType (virDomainPtr dom, int *nparams) +{ + int i; + const char *schedulertype = NULL; + for (i = 0; i < nb_drivers; i++) { + if (drivers[i]->domainGetSchedulerType) { + schedulertype = drivers[i]->domainGetSchedulerType (dom, nparams); + if (schedulertype != NULL) + return(schedulertype); + } + } + return(schedulertype); +} + +static int +xenUnifiedDomainGetSchedulerParameters (virDomainPtr dom, + virSchedParameterPtr params, int *nparams) +{ + int i; + + for (i = 0; i < nb_drivers; ++i) + if (drivers[i]->domainGetSchedulerParameters && + drivers[i]->domainGetSchedulerParameters (dom, params, nparams) == 0) + return 0; + + return -1; +} + +static int +xenUnifiedDomainSetSchedulerParameters (virDomainPtr dom, + virSchedParameterPtr params, int *nparams) +{ + int i; + + for (i = 0; i < nb_drivers; ++i) + if (drivers[i]->domainSetSchedulerParameters && + drivers[i]->domainSetSchedulerParameters (dom, params, nparams) == 0) + return 0; + + return -1; +} /*----- Register with libvirt.c, and initialise Xen drivers. -----*/ #define VERSION ((DOM0_INTERFACE_VERSION >> 24) * 1000000 + \ @@ -760,6 +802,9 @@ static virDriver xenUnifiedDriver = { .domainDetachDevice = xenUnifiedDomainDetachDevice, .domainGetAutostart = xenUnifiedDomainGetAutostart, .domainSetAutostart = xenUnifiedDomainSetAutostart, + .domainGetSchedulerType = xenUnifiedDomainGetSchedulerType, + .domainGetSchedulerParameters = xenUnifiedDomainGetSchedulerParameters, + .domainSetSchedulerParameters = xenUnifiedDomainSetSchedulerParameters, }; /** --- libvirt.orig/src/xend_internal.c 2007-04-12 01:06:30.000000000 +0900 +++ libvirt.sched/src/xend_internal.c 2007-04-12 17:27:32.000000000 +0900 @@ -107,6 +107,9 @@ virDriver xenDaemonDriver = { xenDaemonDetachDevice, /* domainDetachDevice */ NULL, /* domainGetAutostart */ NULL, /* domainSetAutostart */ + NULL, /* domainGetSchedulerType */ + NULL, /* domainGetSchedulerParameters */ + NULL, /* domainSetSchedulerParameters */ }; /** --- libvirt.orig/src/xm_internal.c 2007-04-04 23:19:49.000000000 +0900 +++ libvirt.sched/src/xm_internal.c 2007-04-12 17:27:32.000000000 +0900 @@ -113,6 +113,9 @@ virDriver xenXMDriver = { NULL, /* domainDetachDevice */ NULL, /* domainGetAutostart */ NULL, /* domainSetAutostart */ + NULL, /* domainGetSchedulerType */ + NULL, /* domainGetSchedulerParameters */ + NULL, /* domainSetSchedulerParameters */ }; static void --- libvirt.orig/src/xs_internal.c 2007-04-04 23:19:49.000000000 +0900 +++ libvirt.sched/src/xs_internal.c 2007-04-12 17:27:32.000000000 +0900 @@ -82,6 +82,9 @@ virDriver xenStoreDriver = { NULL, /* domainDetachDevice */ NULL, /* domainGetAutostart */ NULL, /* domainSetAutostart */ + NULL, /* domainGetSchedulerType */ + NULL, /* domainGetSchedulerParameters */ + NULL, /* domainSetSchedulerParameters */ }; /**