WARNING - OLD ARCHIVES

This is an archived copy of the Xen.org mailing list, which we have preserved to ensure that existing links to archives are not broken. The live archive, which contains the latest emails, can be found at http://lists.xen.org/
   
 
 
Xen 
 
Home Products Support Community News
 
   
 

xen-changelog

[Xen-changelog] [xen-unstable] xenpm: add cpu frequency control interfac

To: xen-changelog@xxxxxxxxxxxxxxxxxxx
Subject: [Xen-changelog] [xen-unstable] xenpm: add cpu frequency control interface, through which user can
From: Xen patchbot-unstable <patchbot-unstable@xxxxxxxxxxxxxxxxxxx>
Date: Tue, 16 Dec 2008 22:31:28 -0800
Delivery-date: Tue, 16 Dec 2008 22:33:42 -0800
Envelope-to: www-data@xxxxxxxxxxxxxxxxxxx
List-help: <mailto:xen-changelog-request@lists.xensource.com?subject=help>
List-id: BK change log <xen-changelog.lists.xensource.com>
List-post: <mailto:xen-changelog@lists.xensource.com>
List-subscribe: <http://lists.xensource.com/mailman/listinfo/xen-changelog>, <mailto:xen-changelog-request@lists.xensource.com?subject=subscribe>
List-unsubscribe: <http://lists.xensource.com/mailman/listinfo/xen-changelog>, <mailto:xen-changelog-request@lists.xensource.com?subject=unsubscribe>
Reply-to: xen-devel@xxxxxxxxxxxxxxxxxxx
Sender: xen-changelog-bounces@xxxxxxxxxxxxxxxxxxx
# HG changeset patch
# User Keir Fraser <keir.fraser@xxxxxxxxxx>
# Date 1229433265 0
# Node ID a76b4e00e1862035240ec6403a8f081be61b1e2b
# Parent  fd720db486755948daf39046e7fa2941ac78d377
xenpm: add cpu frequency control interface, through which user can
tune the parameters manually.

Now, xenpm can be invoked with the following options:
Usage:
       xenpm get-cpuidle-states [cpuid]: list cpu idle information on
       CPU cpuid or all CPUs.
       xenpm get-cpufreq-states [cpuid]: list cpu frequency
       information on CPU cpuid or all CPUs.
       xenpm get-cpufreq-para [cpuid]: list cpu frequency information
       on CPU cpuid or all CPUs.
       xenpm set-scaling-maxfreq <cpuid> <HZ>: set max cpu frequency
       <HZ> on CPU <cpuid>.
       xenpm set-scaling-minfreq <cpuid> <HZ>: set min cpu frequency
       <HZ> on CPU <cpuid>.
       xenpm set-scaling-governor <cpuid> <name>: set scaling governor
       on CPU <cpuid>.
       xenpm set-scaling-speed <cpuid> <num>: set scaling speed on CPU
       <cpuid>.
       xenpm set-sampling-rate <cpuid> <num>: set sampling rate on CPU
       <cpuid>.
       xenpm set-up-threshold <cpuid> <num>: set up threshold on CPU
       <cpuid>.

To ease the use of this tool, the shortcut option is supported,
i.e. `xenpm get-cpui' is equal to `xenpm get-cpuidle-states'.

Signed-off-by: Guanqun Lu <guanqun.lu@xxxxxxxxx>
---
 tools/misc/xenpm.c |  744 ++++++++++++++++++++++++++++++++++++++++-------------
 1 files changed, 568 insertions(+), 176 deletions(-)

diff -r fd720db48675 -r a76b4e00e186 tools/misc/xenpm.c
--- a/tools/misc/xenpm.c        Tue Dec 16 12:04:13 2008 +0000
+++ b/tools/misc/xenpm.c        Tue Dec 16 13:14:25 2008 +0000
@@ -16,199 +16,591 @@
  * Place - Suite 330, Boston, MA 02111-1307 USA.
  */
 
+/* to eliminate warning on `strndup' */
+#define _GNU_SOURCE
+
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <getopt.h>
 #include <errno.h>
 
 #include <xenctrl.h>
 #include <inttypes.h>
 
-int main(int argc, char **argv)
-{
+#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
+
+/* help message */
+void show_help(void)
+{
+    fprintf(stderr,
+            "Usage:\n"
+            "       xenpm get-cpuidle-states [cpuid]: list cpu idle 
information on CPU cpuid or all CPUs.\n"
+            "       xenpm get-cpufreq-states [cpuid]: list cpu frequency 
information on CPU cpuid or all CPUs.\n"
+            "       xenpm get-cpufreq-para [cpuid]: list cpu frequency 
information on CPU cpuid or all CPUs.\n"
+            "       xenpm set-scaling-maxfreq <cpuid> <HZ>: set max cpu 
frequency <HZ> on CPU <cpuid>.\n"
+            "       xenpm set-scaling-minfreq <cpuid> <HZ>: set min cpu 
frequency <HZ> on CPU <cpuid>.\n"
+            "       xenpm set-scaling-governor <cpuid> <name>: set scaling 
governor on CPU <cpuid>.\n"
+            "       xenpm set-scaling-speed <cpuid> <num>: set scaling speed 
on CPU <cpuid>.\n"
+            "       xenpm set-sampling-rate <cpuid> <num>: set sampling rate 
on CPU <cpuid>.\n"
+            "       xenpm set-up-threshold <cpuid> <num>: set up threshold on 
CPU <cpuid>.\n");
+}
+
+/* wrapper function */
+int help_func(int xc_fd, int cpuid, uint32_t value)
+{
+    show_help();
+    return 0;
+}
+
+/* show cpu idle information on CPU cpuid */
+static int show_cx_cpuid(int xc_fd, int cpuid)
+{
+    int i, ret = 0;
+    int max_cx_num = 0;
+    struct xc_cx_stat cxstatinfo, *cxstat = &cxstatinfo;
+
+    ret = xc_pm_get_max_cx(xc_fd, cpuid, &max_cx_num);
+    if ( ret )
+    {
+        if ( errno == ENODEV )
+        {
+            fprintf(stderr, "Xen cpuidle is not enabled!\n");
+            return -ENODEV;
+        }
+        else
+        {
+            fprintf(stderr, "[CPU%d] failed to get max C-state\n", cpuid);
+            return -EINVAL;
+        }
+    }
+
+    cxstat->triggers = malloc(max_cx_num * sizeof(uint64_t));
+    if ( !cxstat->triggers )
+    {
+        fprintf(stderr, "[CPU%d] failed to malloc for C-states triggers\n", 
cpuid);
+        return -ENOMEM;
+    }
+    cxstat->residencies = malloc(max_cx_num * sizeof(uint64_t));
+    if ( !cxstat->residencies )
+    {
+        fprintf(stderr, "[CPU%d] failed to malloc for C-states residencies\n", 
cpuid);
+        free(cxstat->triggers);
+        return -ENOMEM;
+    }
+
+    ret = xc_pm_get_cxstat(xc_fd, cpuid, cxstat);
+    if( ret )
+    {
+        fprintf(stderr, "[CPU%d] failed to get C-states statistics "
+                "information\n", cpuid);
+        free(cxstat->triggers);
+        free(cxstat->residencies);
+        return -EINVAL;
+    }
+
+    printf("cpu id               : %d\n", cpuid);
+    printf("total C-states       : %d\n", cxstat->nr);
+    printf("idle time(ms)        : %"PRIu64"\n",
+           cxstat->idle_time/1000000UL);
+    for ( i = 0; i < cxstat->nr; i++ )
+    {
+        printf("C%d                   : transition [%020"PRIu64"]\n",
+               i, cxstat->triggers[i]);
+        printf("                       residency  [%020"PRIu64" ms]\n",
+               cxstat->residencies[i]*1000000UL/3579/1000000UL);
+    }
+
+    free(cxstat->triggers);
+    free(cxstat->residencies);
+
+    printf("\n");
+    return 0;
+}
+
+int cxstates_func(int xc_fd, int cpuid, uint32_t value)
+{
+    int ret = 0;
+    xc_physinfo_t physinfo = { 0 };
+
+    if ( cpuid < 0 )
+    {
+        /* show cxstates on all cpu */
+        ret = xc_physinfo(xc_fd, &physinfo);
+        if ( ret )
+        {
+            fprintf(stderr, "failed to get the processor information\n");
+        }
+        else
+        {
+            int i;
+            for ( i = 0; i < physinfo.nr_cpus; i++ )
+            {
+                if ( (ret = show_cx_cpuid(xc_fd, i)) == -ENODEV )
+                    break;
+            }
+        }
+    }
+    else
+        ret = show_cx_cpuid(xc_fd, cpuid);
+
+    return ret;
+}
+
+/* show cpu frequency information on CPU cpuid */
+static int show_px_cpuid(int xc_fd, int cpuid)
+{
+    int i, ret = 0;
+    int max_px_num = 0;
+    struct xc_px_stat pxstatinfo, *pxstat = &pxstatinfo;
+
+    ret = xc_pm_get_max_px(xc_fd, cpuid, &max_px_num);
+    if ( ret )
+    {
+        if ( errno == ENODEV )
+        {
+            printf("Xen cpufreq is not enabled!\n");
+            return -ENODEV;
+        }
+        else
+        {
+            fprintf(stderr, "[CPU%d] failed to get max P-state\n", cpuid);
+            return -EINVAL;
+        }
+    }
+
+    pxstat->trans_pt = malloc(max_px_num * max_px_num *
+                              sizeof(uint64_t));
+    if ( !pxstat->trans_pt )
+    {
+        fprintf(stderr, "[CPU%d] failed to malloc for P-states transition 
table\n", cpuid);
+        return -ENOMEM;
+    }
+    pxstat->pt = malloc(max_px_num * sizeof(struct xc_px_val));
+    if ( !pxstat->pt )
+    {
+        fprintf(stderr, "[CPU%d] failed to malloc for P-states table\n", 
cpuid);
+        free(pxstat->trans_pt);
+        return -ENOMEM;
+    }
+
+    ret = xc_pm_get_pxstat(xc_fd, cpuid, pxstat);
+    if( ret )
+    {
+        fprintf(stderr, "[CPU%d] failed to get P-states statistics 
information\n", cpuid);
+        free(pxstat->trans_pt);
+        free(pxstat->pt);
+        return -ENOMEM;
+    }
+
+    printf("cpu id               : %d\n", cpuid);
+    printf("total P-states       : %d\n", pxstat->total);
+    printf("usable P-states      : %d\n", pxstat->usable);
+    printf("current frequency    : %"PRIu64" MHz\n",
+           pxstat->pt[pxstat->cur].freq);
+    for ( i = 0; i < pxstat->total; i++ )
+    {
+        if ( pxstat->cur == i )
+            printf("*P%d", i);
+        else
+            printf("P%d ", i);
+        printf("                  : freq       [%04"PRIu64" MHz]\n",
+               pxstat->pt[i].freq);
+        printf("                       transition [%020"PRIu64"]\n",
+               pxstat->pt[i].count);
+        printf("                       residency  [%020"PRIu64" ms]\n",
+               pxstat->pt[i].residency/1000000UL);
+    }
+
+    free(pxstat->trans_pt);
+    free(pxstat->pt);
+
+    printf("\n");
+    return 0;
+}
+
+int pxstates_func(int xc_fd, int cpuid, uint32_t value)
+{
+    int ret = 0;
+    xc_physinfo_t physinfo = { 0 };
+
+    if ( cpuid < 0 )
+    {
+        ret = xc_physinfo(xc_fd, &physinfo);
+        if ( ret )
+        {
+            fprintf(stderr, "failed to get the processor information\n");
+        }
+        else
+        {
+            int i;
+            for ( i = 0; i < physinfo.nr_cpus; i++ )
+            {
+                if ( (ret = show_px_cpuid(xc_fd, i)) == -ENODEV )
+                    break;
+            }
+        }
+    }
+    else
+        ret = show_px_cpuid(xc_fd, cpuid);
+
+    return ret;
+}
+
+/* print out parameters about cpu frequency */
+static void print_cpufreq_para(int cpuid, struct xc_get_cpufreq_para 
*p_cpufreq)
+{
+    int i;
+
+    printf("cpu id               : %d\n", cpuid);
+
+    printf("affected_cpus        :");
+    for ( i = 0; i < p_cpufreq->cpu_num; i++ )
+        if ( i == cpuid )
+            printf(" *%d", p_cpufreq->affected_cpus[i]);
+        else
+            printf(" %d", p_cpufreq->affected_cpus[i]);
+    printf("\n");
+
+    printf("cpuinfo frequency    : max [%u] min [%u] cur [%u]\n",
+           p_cpufreq->cpuinfo_max_freq,
+           p_cpufreq->cpuinfo_min_freq,
+           p_cpufreq->cpuinfo_cur_freq);
+
+    printf("scaling_driver       : %s\n", p_cpufreq->scaling_driver);
+
+    printf("scaling_avail_gov    : %s\n",
+           p_cpufreq->scaling_available_governors);
+
+    printf("current_governor     : %s\n", p_cpufreq->scaling_governor);
+    if ( !strncmp(p_cpufreq->scaling_governor,
+                  "userspace", CPUFREQ_NAME_LEN) )
+    {
+        printf("  userspace specific :\n");
+        printf("    scaling_setspeed : %u\n",
+               p_cpufreq->u.userspace.scaling_setspeed);
+    }
+    else if ( !strncmp(p_cpufreq->scaling_governor,
+                       "ondemand", CPUFREQ_NAME_LEN) )
+    {
+        printf("  ondemand specific  :\n");
+        printf("    sampling_rate    : max [%u] min [%u] cur [%u]\n",
+               p_cpufreq->u.ondemand.sampling_rate_max,
+               p_cpufreq->u.ondemand.sampling_rate_min,
+               p_cpufreq->u.ondemand.sampling_rate);
+        printf("    up_threshold     : %u\n",
+               p_cpufreq->u.ondemand.up_threshold);
+    }
+
+    printf("scaling_avail_freq   :");
+    for ( i = 0; i < p_cpufreq->freq_num; i++ )
+        if ( p_cpufreq->scaling_available_frequencies[i] == 
p_cpufreq->scaling_cur_freq )
+            printf(" *%d", p_cpufreq->scaling_available_frequencies[i]);
+        else
+            printf(" %d", p_cpufreq->scaling_available_frequencies[i]);
+    printf("\n");
+
+    printf("scaling frequency    : max [%u] min [%u] cur [%u]\n",
+           p_cpufreq->scaling_max_freq,
+           p_cpufreq->scaling_min_freq,
+           p_cpufreq->scaling_cur_freq);
+    printf("\n");
+}
+
+/* show cpu frequency parameters information on CPU cpuid */
+static int show_cpufreq_para_cpuid(int xc_fd, int cpuid)
+{
+    int ret = 0;
+    struct xc_get_cpufreq_para cpufreq_para, *p_cpufreq = &cpufreq_para;
+
+    p_cpufreq->cpu_num = 0;
+    p_cpufreq->freq_num = 0;
+    p_cpufreq->gov_num = 0;
+    p_cpufreq->affected_cpus = NULL;
+    p_cpufreq->scaling_available_frequencies = NULL;
+    p_cpufreq->scaling_available_governors = NULL;
+
+    do
+    {
+        free(p_cpufreq->affected_cpus);
+        free(p_cpufreq->scaling_available_frequencies);
+        free(p_cpufreq->scaling_available_governors);
+
+        p_cpufreq->affected_cpus = NULL;
+        p_cpufreq->scaling_available_frequencies = NULL;
+        p_cpufreq->scaling_available_governors = NULL;
+
+        if (!(p_cpufreq->affected_cpus =
+              malloc(p_cpufreq->cpu_num * sizeof(uint32_t))))
+        {
+            fprintf(stderr,
+                    "[CPU%d] failed to malloc for affected_cpus\n",
+                    cpuid);
+            ret = -ENOMEM;
+            goto out;
+        }
+        if (!(p_cpufreq->scaling_available_frequencies =
+              malloc(p_cpufreq->freq_num * sizeof(uint32_t))))
+        {
+            fprintf(stderr,
+                    "[CPU%d] failed to malloc for 
scaling_available_frequencies\n",
+                    cpuid);
+            ret = -ENOMEM;
+            goto out;
+        }
+        if (!(p_cpufreq->scaling_available_governors =
+              malloc(p_cpufreq->gov_num * CPUFREQ_NAME_LEN * sizeof(char))))
+        {
+            fprintf(stderr,
+                    "[CPU%d] failed to malloc for 
scaling_available_governors\n",
+                    cpuid);
+            ret = -ENOMEM;
+            goto out;
+        }
+
+        ret = xc_get_cpufreq_para(xc_fd, cpuid, p_cpufreq);
+    } while ( ret && errno == EAGAIN );
+
+    if ( ret == 0 )
+        print_cpufreq_para(cpuid, p_cpufreq);
+    else if ( errno == ENODEV )
+    {
+        ret = -ENODEV;
+        fprintf(stderr, "Xen cpufreq is not enabled!\n");
+    }
+    else
+        fprintf(stderr,
+                "[CPU%d] failed to get cpufreq parameter\n",
+                cpuid);
+
+out:
+    free(p_cpufreq->scaling_available_governors);
+    free(p_cpufreq->scaling_available_frequencies);
+    free(p_cpufreq->affected_cpus);
+
+    return ret;
+}
+
+int cpufreq_para_func(int xc_fd, int cpuid, uint32_t value)
+{
+    int ret = 0;
+    xc_physinfo_t physinfo = { 0 };
+
+    if ( cpuid < 0 )
+    {
+        ret = xc_physinfo(xc_fd, &physinfo);
+        if ( ret )
+        {
+            fprintf(stderr, "failed to get the processor information\n");
+        }
+        else
+        {
+            int i;
+            for ( i = 0; i < physinfo.nr_cpus; i++ )
+            {
+                if ( (ret = show_cpufreq_para_cpuid(xc_fd, i)) == -ENODEV )
+                    break;
+            }
+        }
+    }
+    else
+        ret = show_cpufreq_para_cpuid(xc_fd, cpuid);
+
+    return ret;
+}
+
+int scaling_max_freq_func(int xc_fd, int cpuid, uint32_t value)
+{
+    int ret = 0;
+
+    if ( cpuid < 0 )
+    {
+        show_help();
+        return -EINVAL;
+    }
+
+    ret = xc_set_cpufreq_para(xc_fd, cpuid, SCALING_MAX_FREQ, value);
+    if ( ret )
+    {
+        fprintf(stderr, "[CPU%d] failed to set scaling max freq\n", cpuid);
+    }
+
+    return ret;
+}
+
+int scaling_min_freq_func(int xc_fd, int cpuid, uint32_t value)
+{
+    int ret;
+
+    if ( cpuid < 0 )
+    {
+        show_help();
+        return -EINVAL;
+    }
+
+    ret = xc_set_cpufreq_para(xc_fd, cpuid, SCALING_MIN_FREQ, value);
+    if ( ret )
+    {
+        fprintf(stderr, "[CPU%d] failed to set scaling min freq\n", cpuid);
+    }
+
+    return ret;
+}
+
+int scaling_speed_func(int xc_fd, int cpuid, uint32_t value)
+{
+    int ret;
+
+    if ( cpuid < 0 )
+    {
+        show_help();
+        return -EINVAL;
+    }
+
+    ret = xc_set_cpufreq_para(xc_fd, cpuid, SCALING_SETSPEED, value);
+    if ( ret )
+    {
+        fprintf(stderr, "[CPU%d] failed to set scaling speed\n", cpuid);
+    }
+
+    return ret;
+}
+
+int scaling_sampling_rate_func(int xc_fd, int cpuid, uint32_t value)
+{
+    int ret;
+
+    if ( cpuid < 0 )
+    {
+        show_help();
+        return -EINVAL;
+    }
+
+    ret = xc_set_cpufreq_para(xc_fd, cpuid, SAMPLING_RATE, value);
+    if ( ret ) 
+    {
+        fprintf(stderr, "[CPU%d] failed to set scaling sampling rate\n", 
cpuid);
+    }
+
+    return ret;
+}
+
+int scaling_up_threshold_func(int xc_fd, int cpuid, uint32_t value)
+{
+    int ret;
+
+    if ( cpuid < 0 )
+    {
+        show_help();
+        return -EINVAL;
+    }
+
+    ret = xc_set_cpufreq_para(xc_fd, cpuid, UP_THRESHOLD, value);
+    if ( ret )
+    {
+        fprintf(stderr, "[CPU%d] failed to set scaling threshold\n", cpuid);
+    }
+
+    return ret;
+}
+
+int scaling_governor_func(int xc_fd, int cpuid, char *name)
+{
+    int ret = 0;
+
+    if ( cpuid < 0 )
+    {
+        show_help();
+        return -EINVAL;
+    }
+
+    ret = xc_set_cpufreq_gov(xc_fd, cpuid, name);
+    if ( ret )
+    {
+        fprintf(stderr, "failed to set cpufreq governor to %s\n", name);
+    }
+
+    return ret;
+}
+
+struct {
+    const char *name;
+    int (*function)(int xc_fd, int cpuid, uint32_t value);
+} main_options[] = {
+    { "help", help_func },
+    { "get-cpuidle-states", cxstates_func },
+    { "get-cpufreq-states", pxstates_func },
+    { "get-cpufreq-para", cpufreq_para_func },
+    { "set-scaling-maxfreq", scaling_max_freq_func },
+    { "set-scaling-minfreq", scaling_min_freq_func },
+    { "set-scaling-governor", NULL },
+    { "set-scaling-speed", scaling_speed_func },
+    { "set-sampling-rate", scaling_sampling_rate_func },
+    { "set-up-threshold", scaling_up_threshold_func },
+};
+
+int main(int argc, char *argv[])
+{
+    int i, ret = -EINVAL;
     int xc_fd;
-    int i, j, ret = 0;
-    int cinfo = 0, pinfo = 0;
-    int ch;
-    xc_physinfo_t physinfo = { 0 };
-
-    while ( (ch = getopt(argc, argv, "cp")) != -1 )
-    {
-        switch ( ch )
-        {
-        case 'c':
-            cinfo = 1;
-            break;
-        case 'p':
-            pinfo = 1;
-            break;
-        default:
-            fprintf(stderr, "%s [-p] [-c]\n", argv[0]);
-            return -1;
-        }
-    }
-
-    if ( !cinfo && !pinfo )
-    {
-        cinfo = 1;
-        pinfo = 1;
+    int cpuid = -1;
+    uint32_t value = 0;
+    int nr_matches = 0;
+    int matches_main_options[ARRAY_SIZE(main_options)];
+
+    if ( argc < 2 )
+    {
+        show_help();
+        return ret;
+    }
+
+    if ( argc > 2 )
+    {
+        if ( sscanf(argv[2], "%d", &cpuid) != 1 )
+            cpuid = -1;
     }
 
     xc_fd = xc_interface_open();
     if ( xc_fd < 0 )
     {
         fprintf(stderr, "failed to get the handler\n");
-        return xc_fd;
-    }
-
-    ret = xc_physinfo(xc_fd, &physinfo);
-    if ( ret )
-    {
-        fprintf(stderr, "failed to get the processor information\n");
-        xc_interface_close(xc_fd);
-        return ret;
-    }
-
-    /* print out the C state information */
-    if ( cinfo )
-    {
-        int max_cx_num = 0;
-        struct xc_cx_stat cxstatinfo, *cxstat = &cxstatinfo;
-
-        for ( i = 0; i < physinfo.nr_cpus; i++ )
-        {
-            ret = xc_pm_get_max_cx(xc_fd, i, &max_cx_num);
-            if ( ret )
+    }
+
+    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, "Ambigious options: ");
+        for ( i = 0; i < nr_matches; i++ )
+            fprintf(stderr, " %s", main_options[matches_main_options[i]].name);
+        fprintf(stderr, "\n");
+    }
+    else if ( nr_matches == 1 )
+    {
+        if ( !strcmp("set-scaling-governor", 
main_options[matches_main_options[0]].name) )
+        {
+            char *name = strdup(argv[3]);
+            ret = scaling_governor_func(xc_fd, cpuid, name);
+            free(name);
+        }
+        else
+        {
+            if ( argc > 3 )
             {
-                if ( errno == ENODEV )
-                {
-                    fprintf(stderr, "Xen cpuidle is not enabled!\n");
-                    break;
-                }
-                else
-                {
-                    fprintf(stderr, "[CPU%d] failed to get max C-state\n", i);
-                    continue;
-                }
+                if ( sscanf(argv[3], "%d", &value) != 1 )
+                    value = 0;
             }
-
-            cxstat->triggers = malloc(max_cx_num * sizeof(uint64_t));
-            if ( !cxstat->triggers )
-            {
-                fprintf(stderr, "failed to malloc for C-states triggers\n");
-                break;
-            }
-            cxstat->residencies = malloc(max_cx_num * sizeof(uint64_t));
-            if ( !cxstat->residencies )
-            {
-                fprintf(stderr, "failed to malloc for C-states residencies\n");
-                free(cxstat->triggers);
-                break;
-            }
-
-            ret = xc_pm_get_cxstat(xc_fd, i, cxstat);
-            if( ret )
-            {
-                fprintf(stderr, "[CPU%d] failed to get C-states statistics "
-                        "information\n", i);
-                free(cxstat->triggers);
-                free(cxstat->residencies);
-                continue;
-            }
-
-            printf("cpu id               : %d\n", i);
-            printf("total C-states       : %d\n", cxstat->nr);
-            printf("idle time(ms)        : %"PRIu64"\n",
-                   cxstat->idle_time/1000000UL);
-            for ( j = 0; j < cxstat->nr; j++ )
-            {
-                printf("C%d                   : transition [%020"PRIu64"]\n",
-                       j, cxstat->triggers[j]);
-                printf("                       residency  [%020"PRIu64" ms]\n",
-                       cxstat->residencies[j]*1000000UL/3579/1000000UL);
-            }
-
-            free(cxstat->triggers);
-            free(cxstat->residencies);
-
-            printf("\n");
-        }
-    }
-
-    /* print out P state information */
-    if ( pinfo )
-    {
-        int max_px_num = 0;
-        struct xc_px_stat pxstatinfo, *pxstat = &pxstatinfo;
-
-        for ( i = 0; i < physinfo.nr_cpus; i++ )
-        {
-            ret = xc_pm_get_max_px(xc_fd, i, &max_px_num);
-            if ( ret )
-            {
-                if ( errno == ENODEV )
-                {
-                    printf("Xen cpufreq is not enabled!\n");
-                    break;
-                }
-                else
-                {
-                    fprintf(stderr, "[CPU%d] failed to get max P-state\n", i);
-                    continue;
-                }
-            }
-
-            pxstat->trans_pt = malloc(max_px_num * max_px_num *
-                                      sizeof(uint64_t));
-            if ( !pxstat->trans_pt )
-            {
-                fprintf(stderr, "failed to malloc for P-states "
-                        "transition table\n");
-                break;
-            }
-            pxstat->pt = malloc(max_px_num * sizeof(struct xc_px_val));
-            if ( !pxstat->pt )
-            {
-                fprintf(stderr, "failed to malloc for P-states table\n");
-                free(pxstat->trans_pt);
-                break;
-            }
-
-            ret = xc_pm_get_pxstat(xc_fd, i, pxstat);
-            if( ret )
-            {
-                fprintf(stderr, "[CPU%d] failed to get P-states "
-                        "statistics information\n", i);
-                free(pxstat->trans_pt);
-                free(pxstat->pt);
-                continue;
-            }
-
-            printf("cpu id               : %d\n", i);
-            printf("total P-states       : %d\n", pxstat->total);
-            printf("usable P-states      : %d\n", pxstat->usable);
-            printf("current frequency    : %"PRIu64" MHz\n",
-                   pxstat->pt[pxstat->cur].freq);
-            for ( j = 0; j < pxstat->total; j++ )
-            {
-                if ( pxstat->cur == j )
-                    printf("*P%d", j);
-                else
-                    printf("P%d ", j);
-                printf("                  : freq       [%04"PRIu64" MHz]\n",
-                       pxstat->pt[j].freq);
-                printf("                       transition [%020"PRIu64"]\n",
-                       pxstat->pt[j].count);
-                printf("                       residency  [%020"PRIu64" ms]\n",
-                       pxstat->pt[j].residency/1000000UL);
-            }
-
-            free(pxstat->trans_pt);
-            free(pxstat->pt);
-
-            printf("\n");
-        }
-    }
+            ret = main_options[matches_main_options[0]].function(xc_fd, cpuid, 
value);
+        }
+    }
+    else
+        show_help();
 
     xc_interface_close(xc_fd);
     return ret;

_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog

<Prev in Thread] Current Thread [Next in Thread>
  • [Xen-changelog] [xen-unstable] xenpm: add cpu frequency control interface, through which user can, Xen patchbot-unstable <=