pass: pmqos: Change name of 'struct pass_scenario_policy' to 'struct pass_pmqos'

The 'struct pass_scenario_policy' indicates the PMQoS module
and contains the scenario information. The 'pass_scenario_policy'
name is ambiguous for indicating the PMQoS module. So, this patch changes
the name from 'struct pass_scenario_policy' to 'struct pass_pmqos'
for the readability.

Also, this patch changes the variable name from 'list' to 'scenarios'.
The pmqos->scenarios is better than 'pmqos->list' in side of readability
in order to indicate the scenario list.

Change-Id: I402cec7ff1f922edbe67b8c216408ff702f2a2fb
Signed-off-by: Chanwoo Choi <cw00.choi@samsung.com>

diff --git a/src/pass/pass-parser.c b/src/pass/pass-parser.c
index bf58e1f..e7eda1a 100644 (file)
--- a/src/pass/pass-parser.c
+++ b/src/pass/pass-parser.c
@@ -48,11 +48,11 @@ static enum pass_state is_supported(char *value)
        return state;
 }
 
-static int pass_parse_scenario(struct parse_result *result, void *user_data,
+static int pass_parse_pmqos(struct parse_result *result, void *user_data,
                               unsigned int index)
 {
        struct pass_policy *policy = user_data;
-       struct pass_scenario_policy *scenario = &policy->scenario;
+       struct pass_pmqos *pmqos = &policy->pmqos;
 
        if (!policy || !result)
                return 0;
@@ -63,8 +63,8 @@ static int pass_parse_scenario(struct parse_result *result, void *user_data,
        /* Parse 'PassScenario' section */
        if (MATCH(result->section, "PassScenario")) {
                if (MATCH(result->name, "pass_scenario_support")) {
-                       scenario->state = is_supported(result->value);
-                       if (scenario->state < 0)
+                       pmqos->state = is_supported(result->value);
+                       if (pmqos->state < 0)
                                return -EINVAL;
 
                } else if (MATCH(result->name, "pass_num_scenarios")) {
@@ -76,40 +76,40 @@ static int pass_parse_scenario(struct parse_result *result, void *user_data,
                                return -EINVAL;
                        }
 
-                       if (num_scenarios > 0 && !scenario->list) {
-                               scenario->list = calloc(num_scenarios,
+                       if (num_scenarios > 0 && !pmqos->scenarios) {
+                               pmqos->scenarios = calloc(num_scenarios,
                                                sizeof(struct pass_scenario));
-                               if (!scenario->list) {
+                               if (!pmqos->scenarios) {
                                        _E("cannot allocate memory for Scenario\n");
                                        return -EINVAL;
                                }
 
-                               scenario->num_scenarios = num_scenarios;
+                               pmqos->num_scenarios = num_scenarios;
                        }
                }
        }
 
-       if (scenario->state != PASS_ON)
+       if (pmqos->state != PASS_ON)
                return 0;
 
-       if (!scenario->num_scenarios)
+       if (!pmqos->num_scenarios)
                return 0;
 
-       if (index > scenario->num_scenarios || index == PASS_UNUSED)
+       if (index > pmqos->num_scenarios || index == PASS_UNUSED)
                return 0;
 
        /* Parse 'Scenario' section */
        if (MATCH(result->name, "name")) {
-               snprintf(scenario->list[index].name, PASS_NAME_LEN, "%s",
+               snprintf(pmqos->scenarios[index].name, PASS_NAME_LEN, "%s",
                                result->value);
        } else if (MATCH(result->name, "support")) {
-               scenario->list[index].state = is_supported(result->value);
-               if (scenario->list[index].state < 0)
+               pmqos->scenarios[index].state = is_supported(result->value);
+               if (pmqos->scenarios[index].state < 0)
                        return -EINVAL;
        } else if (MATCH(result->name, "min_level")) {
-               scenario->list[index].min_level = atoi(result->value);
+               pmqos->scenarios[index].min_level = atoi(result->value);
        } else if (MATCH(result->name, "max_level")) {
-               scenario->list[index].max_level = atoi(result->value);
+               pmqos->scenarios[index].max_level = atoi(result->value);
        }
 
        return 0;
@@ -257,7 +257,6 @@ static int pass_parse_core(struct parse_result *result, void *user_data)
 static int pass_load_config(struct parse_result *result, void *user_data)
 {
        struct pass_policy *policy = user_data;
-       struct pass_scenario_policy *scenario = &policy->scenario;
        char section_name[BUFF_MAX];
        int level = PASS_UNUSED;
        int index = PASS_UNUSED;
@@ -297,7 +296,7 @@ static int pass_load_config(struct parse_result *result, void *user_data)
 
        /* Parsing 'PassScenario' section */
        if (MATCH(result->section, "PassScenario")) {
-               ret = pass_parse_scenario(result, user_data, PASS_UNUSED);
+               ret = pass_parse_pmqos(result, user_data, PASS_UNUSED);
                if (ret < 0) {
                        _E("cannot parse 'PassScenario' section\n");
                        return ret;
@@ -307,11 +306,11 @@ static int pass_load_config(struct parse_result *result, void *user_data)
        }
 
        /* Parsing 'Scenario' section */
-       for (index = 0; index < scenario->num_scenarios; index++) {
+       for (index = 0; index < policy->pmqos.num_scenarios; index++) {
                ret = snprintf(section_name, BUFF_MAX, "Scenario%d", index);
 
                if (MATCH(result->section, section_name)) {
-                       ret = pass_parse_scenario(result, user_data, index);
+                       ret = pass_parse_pmqos(result, user_data, index);
                        if (ret < 0) {
                                _E("cannot parse 'Scenario' section\n");
                                return ret;
@@ -330,7 +329,7 @@ int pass_get_table(struct pass_policy *policy, char *pass_conf_path)
        int ret;
 
        policy->state = PASS_UNUSED;
-       policy->scenario.state = PASS_UNUSED;
+       policy->pmqos.state = PASS_UNUSED;
 
        policy->state = 0;
        policy->gov_type = 0;
@@ -467,9 +466,9 @@ int pass_get_table(struct pass_policy *policy, char *pass_conf_path)
        if (policy->state == PASS_UNUSED)
                return -EINVAL;
 
-       if (policy->scenario.state == PASS_UNUSED)
+       if (policy->pmqos.state == PASS_UNUSED)
                _W("%s don't include the list of pass-scenario\n");
-       else if (policy->scenario.state == PASS_OFF)
+       else if (policy->pmqos.state == PASS_OFF)
                _I("cannot use pass-scenario");
 
        return 0;
@@ -482,12 +481,12 @@ void pass_put_table(struct pass_policy *policy)
                policy->levels = NULL;
        }
 
-       if (policy->scenario.list) {
-               free(policy->scenario.list);
-               policy->scenario.list = NULL;
+       if (policy->pmqos.scenarios) {
+               free(policy->pmqos.scenarios);
+               policy->pmqos.scenarios = NULL;
        }
 
-       policy->scenario.num_scenarios = 0;
+       policy->pmqos.num_scenarios = 0;
 }
 
 static int pass_parse_resource_data(struct parse_result *result,

diff --git a/src/pass/pass-pmqos.c b/src/pass/pass-pmqos.c
index fd338e9..da9fb77 100644 (file)
--- a/src/pass/pass-pmqos.c
+++ b/src/pass/pass-pmqos.c
@@ -57,10 +57,10 @@ static bool is_pmqos_enabled(struct pass_policy *policy)
        if (!policy)
                return false;
 
-       if (!policy->scenario.list)
+       if (!policy->pmqos.scenarios)
                return false;
 
-       if (policy->scenario.state != PASS_ON)
+       if (policy->pmqos.state != PASS_ON)
                return false;
 
        return true;
@@ -85,13 +85,12 @@ static enum pass_state is_pmqos_locked(char *data, char *name)
        }
 }
 
-static int find_scenario_index(struct pass_scenario_policy *scenario,
-                              char *name)
+static int find_scenario_index(struct pass_pmqos *pmqos, char *name)
 {
        int index;
 
-       for (index = 0; index < scenario->num_scenarios; index++)
-               if (MATCH(scenario->list[index].name, name))
+       for (index = 0; index < pmqos->num_scenarios; index++)
+               if (MATCH(pmqos->scenarios[index].name, name))
                        return index;
 
        return -EINVAL;
@@ -105,7 +104,7 @@ int pass_notifier_pmqos_func(struct pass_policy *policy, void *data)
 {
        struct pass_resource *res;
        struct pass_conf_data *cdata;
-       struct pass_scenario_policy *scenario;
+       struct pass_pmqos *pmqos;
        struct pass_scenario *scn = NULL;
        enum pass_state locked = PASS_UNUSED;
        char name[PASS_NAME_LEN] = {""};
@@ -119,20 +118,20 @@ int pass_notifier_pmqos_func(struct pass_policy *policy, void *data)
 
        res = to_pass_resource(policy);
        cdata = &res->cdata;
-       scenario = &policy->scenario;
+       pmqos = &policy->pmqos;
 
        /*
         * Parse scenario name(data) whether to include 'Lock' or 'Unlock'
         * string and divide correct scenario name.
         */
        locked = is_pmqos_locked(data, name);
-       index = find_scenario_index(scenario, name);
+       index = find_scenario_index(pmqos, name);
        if (index < 0) {
                _W("Unknown scenario (%s) for '%s' resource\n",
                                name, cdata->res_name);
                return -EINVAL;
        }
-       scn = &scenario->list[index];
+       scn = &pmqos->scenarios[index];
 
        /* Check the state of each scenario whether to support or not */
        if (scn->state != PASS_ON) {
@@ -154,38 +153,38 @@ int pass_notifier_pmqos_func(struct pass_policy *policy, void *data)
        scn->locked = locked;
 
        if (scn->locked) {
-               if (scenario->num_locked_scenarios == 0)
-                       new_level = scenario->init_level = policy->curr_level;
+               if (pmqos->num_locked_scenarios == 0)
+                       new_level = pmqos->init_level = policy->curr_level;
                else
-                       new_level = scenario->curr_level;
-               min_level = MAX(scn->min_level, scenario->min_level);
-               max_level = MAX(scn->max_level, scenario->max_level);
+                       new_level = pmqos->curr_level;
+               min_level = MAX(scn->min_level, pmqos->min_level);
+               max_level = MAX(scn->max_level, pmqos->max_level);
 
                if (new_level < min_level)
                        new_level = min_level;
                else if (new_level > max_level)
                        new_level = scn->max_level;
 
-               scenario->curr_level = new_level;
-               scenario->min_level = min_level;
-               scenario->max_level = max_level;
+               pmqos->curr_level = new_level;
+               pmqos->min_level = min_level;
+               pmqos->max_level = max_level;
 
-               scenario->num_locked_scenarios++;
+               pmqos->num_locked_scenarios++;
        } else {
-               scenario->num_locked_scenarios--;
+               pmqos->num_locked_scenarios--;
 
-               if (scenario->num_locked_scenarios == 0) {
-                       new_level = scenario->init_level;
+               if (pmqos->num_locked_scenarios == 0) {
+                       new_level = pmqos->init_level;
                        min_level = policy->default_min_level;
                        max_level = policy->default_max_level;
 
-                       scenario->curr_level = 0;
-                       scenario->min_level = 0;
-                       scenario->max_level = 0;
+                       pmqos->curr_level = 0;
+                       pmqos->min_level = 0;
+                       pmqos->max_level = 0;
                } else {
-                       new_level = scenario->curr_level;
-                       min_level = scenario->min_level;
-                       max_level = scenario->max_level;
+                       new_level = pmqos->curr_level;
+                       min_level = pmqos->min_level;
+                       max_level = pmqos->max_level;
                }
        }
 
@@ -196,13 +195,13 @@ int pass_notifier_pmqos_func(struct pass_policy *policy, void *data)
                _I("Lock   '%s' scenario for '%s' resource\n",
                        name, cdata->res_name);
 
-               scenario->list[index].locked_time = get_time_ms();
+               pmqos->scenarios[index].locked_time = get_time_ms();
        } else {
                _I("UnLock '%s' scenario for '%s' resource (%lldms)\n",
                        name, cdata->res_name,
-                       (get_time_ms() - scenario->list[index].locked_time));
+                       (get_time_ms() - pmqos->scenarios[index].locked_time));
 
-               scenario->list[index].locked_time = 0;
+               pmqos->scenarios[index].locked_time = 0;
        }
 
        return 0;

diff --git a/src/pass/pass.h b/src/pass/pass.h
index 4684210..7bcbed5 100644 (file)
--- a/src/pass/pass.h
+++ b/src/pass/pass.h
@@ -212,12 +212,12 @@ struct pass_scenario {
        unsigned int max_level;
 };
 
-struct pass_scenario_policy {
+struct pass_pmqos {
        enum pass_state state;
        unsigned int num_scenarios;
        unsigned int num_locked_scenarios;
 
-       struct pass_scenario *list;
+       struct pass_scenario *scenarios;
 
        unsigned int init_level;
        unsigned int curr_level;
@@ -250,7 +250,6 @@ struct pass_policy {
        int64_t last_time;
 
        struct pass_freq_policy freq;
-       struct pass_scenario_policy scenario;
 
        struct pass_level *levels;
        struct pass_cpu_stats *pass_cpu_stats;
@@ -260,6 +259,9 @@ struct pass_policy {
        double gov_timeout;
        guint gov_timeout_id;
        struct pass_hotplug *hotplug;
+
+       /* Private data for PMQoS */
+       struct pass_pmqos pmqos;
 };
 
 /******************************************************