pass: parser: Clean-up internal parsing functions to improve readability

Clean-up the internal parsing functions to improve the readability
and consider the extensibility because 'parse_level' and 'parse_scenario'
will be used on other features. Describe what are modified as following:
- Remove 'pass_' prefix from internal function
- Rename from check_compatible() to compare_compatible_name()
- Split out parse_scenario() function from parse_pmqos()
- Remove unneeded strlen() in the compare_compatible_name()
- Remove unnedded semiconlon from switch statement

[Detailed description of internal functions]
- parse_core(): Parse 'Pass' section including info of CPUHP feature
- parse_pmqos(): Parse 'PassScenario' section including info of PMQoS feature
- parse_level(): Parse 'Level' section including info of each scenario
- parse_scenario(): Parse 'Scenario' section including info of each level

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

diff --git a/src/pass/pass-parser.c b/src/pass/pass-parser.c
index 125f3414847d547c502c1bdedd5ef90880e81ba1..12e6ce74c86be8b1647a039230361500f311e179 100644 (file)
--- a/src/pass/pass-parser.c
+++ b/src/pass/pass-parser.c
@@ -1,7 +1,7 @@
 /*
  * PASS (Power Aware System Service) Parser
  *
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 - 2018 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the License);
  * you may not use this file except in compliance with the License.
@@ -31,6 +31,33 @@
 #define MAX_NUM                                255
 #define MIN_TIMEOUT_SEC                0.2
 
+static int compare_compatible_name(char *compatible, char *path_compatible)
+{
+       char buf[BUFF_MAX];
+       int len, ret;
+
+       ret = sys_get_str(path_compatible, buf);
+       if (ret < 0) {
+               _E("cannot read compatible path: %s\n",
+                               path_compatible);
+               return -EINVAL;
+       }
+
+       len = strlen(compatible);
+       if (!len) {
+               _E("cannot parse compatible\n");
+               return -EINVAL;
+       }
+
+       if (strncmp(compatible, buf, len)) {
+               _E("cannot match compatible pairs: conf = %s, read = %s\n",
+                               compatible, buf);
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
 static enum pass_state is_supported(char *value)
 {
        enum pass_state state;
@@ -48,74 +75,32 @@ static enum pass_state is_supported(char *value)
        return state;
 }
 
-static int pass_parse_pmqos(struct parse_result *result, void *user_data,
-                              unsigned int index)
+static int parse_scenario(struct parse_result *result,
+                               struct pass_scenario *scenario)
 {
-       struct pass_policy *policy = user_data;
-       struct pass_pmqos *pmqos = &policy->pmqos;
-
-       if (!policy || !result)
+       if (!result || !scenario)
                return 0;
 
        if (!result->section || !result->name || !result->value)
                return 0;
 
-       /* Parse 'PassScenario' section */
-       if (MATCH(result->section, "PassScenario")) {
-               if (MATCH(result->name, "pass_scenario_support")) {
-                       pmqos->state = is_supported(result->value);
-                       if (pmqos->state < 0)
-                               return -EINVAL;
-
-               } else if (MATCH(result->name, "pass_num_scenarios")) {
-                       unsigned int num_scenarios;
-
-                       num_scenarios = atoi(result->value);
-                       if (num_scenarios > MAX_NUM) {
-                               _E("cannot parse %s\n", result->name);
-                               return -EINVAL;
-                       }
-
-                       if (num_scenarios > 0 && !pmqos->scenarios) {
-                               pmqos->scenarios = calloc(num_scenarios,
-                                               sizeof(struct pass_scenario));
-                               if (!pmqos->scenarios) {
-                                       _E("cannot allocate memory for Scenario\n");
-                                       return -EINVAL;
-                               }
-
-                               pmqos->num_scenarios = num_scenarios;
-                       }
-               }
-       }
-
-       if (pmqos->state != PASS_ON)
-               return 0;
-
-       if (!pmqos->num_scenarios)
-               return 0;
-
-       if (index > pmqos->num_scenarios || index == PASS_UNUSED)
-               return 0;
-
        /* Parse 'Scenario' section */
        if (MATCH(result->name, "name")) {
-               snprintf(pmqos->scenarios[index].name, BUFF_MAX, "%s",
-                               result->value);
+               snprintf(scenario->name, BUFF_MAX, "%s", result->value);
        } else if (MATCH(result->name, "support")) {
-               pmqos->scenarios[index].state = is_supported(result->value);
-               if (pmqos->scenarios[index].state < 0)
+               scenario->state = is_supported(result->value);
+               if (scenario->state < 0)
                        return -EINVAL;
        } else if (MATCH(result->name, "min_level")) {
-               pmqos->scenarios[index].min_level = atoi(result->value);
+               scenario->min_level = atoi(result->value);
        } else if (MATCH(result->name, "max_level")) {
-               pmqos->scenarios[index].max_level = atoi(result->value);
+               scenario->max_level = atoi(result->value);
        }
 
        return 0;
 }
 
-static int pass_parse_level(struct parse_result *result,
+static int parse_level(struct parse_result *result,
                                struct pass_level *level)
 {
        if (!result || !level)
@@ -195,7 +180,48 @@ static int pass_parse_level(struct parse_result *result,
        return 0;
 }
 
-static int pass_parse_core(struct parse_result *result, void *user_data)
+static int parse_pmqos(struct parse_result *result, void *user_data)
+{
+       struct pass_policy *policy = user_data;
+       struct pass_pmqos *pmqos = &policy->pmqos;
+
+       if (!policy || !result)
+               return 0;
+
+       if (!result->section || !result->name || !result->value)
+               return 0;
+
+       /* Parse 'PassScenario' section */
+       if (MATCH(result->name, "pass_scenario_support")) {
+               pmqos->state = is_supported(result->value);
+               if (pmqos->state < 0)
+                       return -EINVAL;
+
+       } else if (MATCH(result->name, "pass_num_scenarios")) {
+               unsigned int num_scenarios;
+
+               num_scenarios = atoi(result->value);
+               if (num_scenarios > MAX_NUM) {
+                       _E("cannot parse %s\n", result->name);
+                       return -EINVAL;
+               }
+
+               if (num_scenarios > 0 && !pmqos->scenarios) {
+                       pmqos->scenarios = calloc(num_scenarios,
+                                       sizeof(struct pass_scenario));
+                       if (!pmqos->scenarios) {
+                               _E("cannot allocate memory for Scenario\n");
+                               return -EINVAL;
+                       }
+
+                       pmqos->num_scenarios = num_scenarios;
+               }
+       }
+
+       return 0;
+}
+
+static int parse_core(struct parse_result *result, void *user_data)
 {
        struct pass_policy *policy = user_data;
 
@@ -252,13 +278,12 @@ static int pass_parse_core(struct parse_result *result, void *user_data)
        return 0;
 }
 
-static int pass_load_config(struct parse_result *result, void *user_data)
+static int parse_each_resource(struct parse_result *result, void *user_data)
 {
        struct pass_policy *policy = user_data;
+       struct pass_pmqos *pmqos = &policy->pmqos;
        char section_name[BUFF_MAX];
-       int level = PASS_UNUSED;
-       int index = PASS_UNUSED;
-       int ret;
+       int i, ret;
 
        if (!result)
                return 0;
@@ -268,7 +293,7 @@ static int pass_load_config(struct parse_result *result, void *user_data)
 
        /* Parsing 'PASS' section */
        if (MATCH(result->section, "Pass")) {
-               ret = pass_parse_core(result, user_data);
+               ret = parse_core(result, user_data);
                if (ret < 0) {
                        _E("cannot parse the core part\n");
                        return ret;
@@ -278,13 +303,13 @@ static int pass_load_config(struct parse_result *result, void *user_data)
        }
 
        /* Parsing 'Level' section */
-       for (level = 0; level < policy->num_levels; level++) {
-               ret = snprintf(section_name, BUFF_MAX, "Level%d", level);
+       for (i = 0; i < policy->num_levels; i++) {
+               ret = snprintf(section_name, BUFF_MAX, "Level%d", i);
 
                if (MATCH(result->section, section_name)) {
-                       ret = pass_parse_level(result, &policy->levels[level]);
+                       ret = parse_level(result, &policy->levels[i]);
                        if (ret < 0) {
-                               _E("cannot parse 'Level' section\n");
+                               _E("cannot parse 'Level%d' section\n", i);
                                return ret;
                        }
 
@@ -294,7 +319,7 @@ static int pass_load_config(struct parse_result *result, void *user_data)
 
        /* Parsing 'PassScenario' section */
        if (MATCH(result->section, "PassScenario")) {
-               ret = pass_parse_pmqos(result, user_data, PASS_UNUSED);
+               ret = parse_pmqos(result, user_data);
                if (ret < 0) {
                        _E("cannot parse 'PassScenario' section\n");
                        return ret;
@@ -304,13 +329,13 @@ static int pass_load_config(struct parse_result *result, void *user_data)
        }
 
        /* Parsing 'Scenario' section */
-       for (index = 0; index < policy->pmqos.num_scenarios; index++) {
-               ret = snprintf(section_name, BUFF_MAX, "Scenario%d", index);
+       for (i = 0; i < pmqos->num_scenarios; i++) {
+               ret = snprintf(section_name, BUFF_MAX, "Scenario%d", i);
 
                if (MATCH(result->section, section_name)) {
-                       ret = pass_parse_pmqos(result, user_data, index);
+                       ret = parse_scenario(result, &pmqos->scenarios[i]);
                        if (ret < 0) {
-                               _E("cannot parse 'Scenario' section\n");
+                               _E("cannot parse 'Scenario%d' section\n", i);
                                return ret;
                        }
 
@@ -322,7 +347,7 @@ out:
        return 0;
 }
 
-static int pass_parse_resource_data(struct parse_result *result,
+static int parse_resource_data(struct parse_result *result,
                                    void *user_data, int id)
 {
        char buf[BUFF_MAX];
@@ -368,7 +393,7 @@ static int pass_parse_resource_data(struct parse_result *result,
                        break;
                default:
                        return -EINVAL;
-               };
+               }
        } else if (MATCH(result->name, "pass_num_cpus")) {
                int res_type = conf_data->res_type;
 
@@ -378,41 +403,7 @@ static int pass_parse_resource_data(struct parse_result *result,
                        break;
                default:
                        return -EINVAL;
-               };
-       }
-
-       return 0;
-}
-
-static int check_compatible(char *compatible, char *path_compatible)
-{
-       char buf[BUFF_MAX];
-       int len, ret;
-
-       len = strlen(compatible);
-       if (!len) {
-               _E("cannot parse compatible\n");
-               return -EINVAL;
-       }
-
-       len = strlen(path_compatible);
-       if (!len) {
-               _E("cannot parse path_compatible\n");
-               return -EINVAL;
-       }
-
-       ret = sys_get_str(path_compatible, buf);
-       if (ret < 0) {
-               _E("cannot read compatible path: %s\n",
-                               path_compatible);
-               return -EINVAL;
-       }
-
-       len = strlen(compatible);
-       if (strncmp(compatible, buf, len)) {
-               _E("cannot match compatible pairs: conf = %s, read = %s\n",
-                               compatible, buf);
-               return -EINVAL;
+               }
        }
 
        return 0;
@@ -420,7 +411,7 @@ static int check_compatible(char *compatible, char *path_compatible)
 
 static int parse_resource(struct parse_result *result, void *user_data)
 {
-       static char path_compatible[BUFF_MAX];
+       static char path[BUFF_MAX];
        static bool is_compatible = false;
        static char compatible[BUFF_MAX];
        struct pass *pass = user_data;
@@ -439,9 +430,9 @@ static int parse_resource(struct parse_result *result, void *user_data)
                        len = strlen(result->value);
                        snprintf(compatible, len + 1, "%s", result->value);
 
-                       len = strlen(path_compatible);
+                       len = strlen(path);
                        if (len > 0) {
-                               ret = check_compatible(compatible, path_compatible);
+                               ret = compare_compatible_name(compatible, path);
                                if (ret < 0)
                                        return ret;
 
@@ -449,11 +440,11 @@ static int parse_resource(struct parse_result *result, void *user_data)
                        }
                } else if (MATCH(result->name, "pass_path_compatible")) {
                        len = strlen(result->value);
-                       snprintf(path_compatible, len + 1, "%s", result->value);
+                       snprintf(path, len + 1, "%s", result->value);
 
                        len = strlen(compatible);
                        if (len > 0) {
-                               ret = check_compatible(compatible, path_compatible);
+                               ret = compare_compatible_name(compatible, path);
                                if (ret < 0)
                                        return ret;
 
@@ -507,10 +498,10 @@ static int parse_resource(struct parse_result *result, void *user_data)
 
                if (MATCH(section_name, result->section)) {
                        if (!is_compatible) {
-                               _E("cannot match [compatible] with the string read from [path_compatible]\n");
+                               _E("cannot match [compatible] with the string read from [path]\n");
                                return -EINVAL;
                        }
-                       ret = pass_parse_resource_data(result, pass, id);
+                       ret = parse_resource_data(result, pass, id);
                        if (ret < 0) {
                                _E("cannot parse 'PassResource%d' section\n",
                                                id);
@@ -579,7 +570,7 @@ int pass_get_each_resource_config(struct pass_resource *res, char *path)
        policy->gov_timeout = 0;
        policy->last_time = 0;
 
-       ret = config_parse(path, pass_load_config, policy);
+       ret = config_parse(path, parse_each_resource, policy);
        if (ret < 0) {
                _E("cannot parse %s\n", path);
                return -EINVAL;

diff --git a/src/pass/pass-parser.h b/src/pass/pass-parser.h
index 92726e17862401449329d53ba9811558c8e19565..1c5a4400cf20d0c993c88652742516e9ffa815fa 100644 (file)
--- a/src/pass/pass-parser.h
+++ b/src/pass/pass-parser.h
@@ -1,7 +1,7 @@
 /*
  * PASS (Power Aware System Service) Parser
  *
- * Copyright (c) 2012 - 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2012 - 2018 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the License);
  * you may not use this file except in compliance with the License.