1 files changed, 189 insertions, 59 deletions

diff --git a/arch/powerpc/kernel/prom_init.c b/arch/powerpc/kernel/prom_init.c
index f33ff4163a51..523bb99d7676 100644
--- a/arch/powerpc/kernel/prom_init.c
+++ b/arch/powerpc/kernel/prom_init.c
@@ -154,10 +154,8 @@ static struct prom_t __prombss prom;
 
 static unsigned long __prombss prom_entry;
 
-#define PROM_SCRATCH_SIZE 256
-
 static char __prombss of_stdout_device[256];
-static char __prombss prom_scratch[PROM_SCRATCH_SIZE];
+static char __prombss prom_scratch[256];
 
 static unsigned long __prombss dt_header_start;
 static unsigned long __prombss dt_struct_start, dt_struct_end;
@@ -224,6 +222,135 @@ static bool  __prombss rtas_has_query_cpu_stopped;
 #define PHANDLE_VALID(p)        ((p) != 0 && (p) != PROM_ERROR)
 #define IHANDLE_VALID(i)        ((i) != 0 && (i) != PROM_ERROR)
 
+/* Copied from lib/string.c and lib/kstrtox.c */
+
+static int __init prom_strcmp(const char *cs, const char *ct)
+{
+        unsigned char c1, c2;
+
+        while (1) {
+                c1 = *cs++;
+                c2 = *ct++;
+                if (c1 != c2)
+                        return c1 < c2 ? -1 : 1;
+                if (!c1)
+                        break;
+        }
+        return 0;
+}
+
+static char __init *prom_strcpy(char *dest, const char *src)
+{
+        char *tmp = dest;
+
+        while ((*dest++ = *src++) != '\0')
+                /* nothing */;
+        return tmp;
+}
+
+static int __init prom_strncmp(const char *cs, const char *ct, size_t count)
+{
+        unsigned char c1, c2;
+
+        while (count) {
+                c1 = *cs++;
+                c2 = *ct++;
+                if (c1 != c2)
+                        return c1 < c2 ? -1 : 1;
+                if (!c1)
+                        break;
+                count--;
+        }
+        return 0;
+}
+
+static size_t __init prom_strlen(const char *s)
+{
+        const char *sc;
+
+        for (sc = s; *sc != '\0'; ++sc)
+                /* nothing */;
+        return sc - s;
+}
+
+static int __init prom_memcmp(const void *cs, const void *ct, size_t count)
+{
+        const unsigned char *su1, *su2;
+        int res = 0;
+
+        for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
+                if ((res = *su1 - *su2) != 0)
+                        break;
+        return res;
+}
+
+static char __init *prom_strstr(const char *s1, const char *s2)
+{
+        size_t l1, l2;
+
+        l2 = prom_strlen(s2);
+        if (!l2)
+                return (char *)s1;
+        l1 = prom_strlen(s1);
+        while (l1 >= l2) {
+                l1--;
+                if (!prom_memcmp(s1, s2, l2))
+                        return (char *)s1;
+                s1++;
+        }
+        return NULL;
+}
+
+static size_t __init prom_strlcpy(char *dest, const char *src, size_t size)
+{
+        size_t ret = prom_strlen(src);
+
+        if (size) {
+                size_t len = (ret >= size) ? size - 1 : ret;
+                memcpy(dest, src, len);
+                dest[len] = '\0';
+        }
+        return ret;
+}
+
+#ifdef CONFIG_PPC_PSERIES
+static int __init prom_strtobool(const char *s, bool *res)
+{
+        if (!s)
+                return -EINVAL;
+
+        switch (s[0]) {
+        case 'y':
+        case 'Y':
+        case '1':
+                *res = true;
+                return 0;
+        case 'n':
+        case 'N':
+        case '0':
+                *res = false;
+                return 0;
+        case 'o':
+        case 'O':
+                switch (s[1]) {
+                case 'n':
+                case 'N':
+                        *res = true;
+                        return 0;
+                case 'f':
+                case 'F':
+                        *res = false;
+                        return 0;
+                default:
+                        break;
+                }
+        default:
+                break;
+        }
+
+        return -EINVAL;
+}
+#endif
 
 /* This is the one and *ONLY* place where we actually call open
  * firmware.
@@ -555,7 +682,7 @@ static int __init prom_setprop(phandle node, const char *nodename,
         add_string(&p, tohex((u32)(unsigned long) value));
         add_string(&p, tohex(valuelen));
         add_string(&p, tohex(ADDR(pname)));
-        add_string(&p, tohex(strlen(pname)));
+        add_string(&p, tohex(prom_strlen(pname)));
         add_string(&p, "property");
         *p = 0;
         return call_prom("interpret", 1, 1, (u32)(unsigned long) cmd);
@@ -631,33 +758,30 @@ static void __init early_cmdline_parse(void)
         const char *opt;
 
         char *p;
-        int l __maybe_unused = 0;
+        int l = 0;
 
         prom_cmd_line[0] = 0;
         p = prom_cmd_line;
         if ((long)prom.chosen > 0)
                 l = prom_getprop(prom.chosen, "bootargs", p, COMMAND_LINE_SIZE-1);
-#ifdef CONFIG_CMDLINE
-        if (l <= 0 || p[0] == '\0') /* dbl check */
-                strlcpy(prom_cmd_line,
-                        CONFIG_CMDLINE, sizeof(prom_cmd_line));
-#endif /* CONFIG_CMDLINE */
+        if (IS_ENABLED(CONFIG_CMDLINE_BOOL) && (l <= 0 || p[0] == '\0')) /* dbl check */
+                prom_strlcpy(prom_cmd_line, CONFIG_CMDLINE, sizeof(prom_cmd_line));
         prom_printf("command line: %s\n", prom_cmd_line);
 
 #ifdef CONFIG_PPC64
-        opt = strstr(prom_cmd_line, "iommu=");
+        opt = prom_strstr(prom_cmd_line, "iommu=");
         if (opt) {
                 prom_printf("iommu opt is: %s\n", opt);
                 opt += 6;
                 while (*opt && *opt == ' ')
                         opt++;
-                if (!strncmp(opt, "off", 3))
+                if (!prom_strncmp(opt, "off", 3))
                         prom_iommu_off = 1;
-                else if (!strncmp(opt, "force", 5))
+                else if (!prom_strncmp(opt, "force", 5))
                         prom_iommu_force_on = 1;
         }
 #endif
-        opt = strstr(prom_cmd_line, "mem=");
+        opt = prom_strstr(prom_cmd_line, "mem=");
         if (opt) {
                 opt += 4;
                 prom_memory_limit = prom_memparse(opt, (const char **)&opt);
@@ -669,13 +793,13 @@ static void __init early_cmdline_parse(void)
 
 #ifdef CONFIG_PPC_PSERIES
         prom_radix_disable = !IS_ENABLED(CONFIG_PPC_RADIX_MMU_DEFAULT);
-        opt = strstr(prom_cmd_line, "disable_radix");
+        opt = prom_strstr(prom_cmd_line, "disable_radix");
         if (opt) {
                 opt += 13;
                 if (*opt && *opt == '=') {
                         bool val;
 
-                        if (kstrtobool(++opt, &val))
+                        if (prom_strtobool(++opt, &val))
                                 prom_radix_disable = false;
                         else
                                 prom_radix_disable = val;
@@ -1028,7 +1152,7 @@ static int __init prom_count_smt_threads(void)
                 type[0] = 0;
                 prom_getprop(node, "device_type", type, sizeof(type));
 
-                if (strcmp(type, "cpu"))
+                if (prom_strcmp(type, "cpu"))
                         continue;
                 /*
                  * There is an entry for each smt thread, each entry being
@@ -1138,8 +1262,14 @@ static void __init prom_check_platform_support(void)
         int prop_len = prom_getproplen(prom.chosen,
                                        "ibm,arch-vec-5-platform-support");
 
-        /* First copy the architecture vec template */
-        ibm_architecture_vec = ibm_architecture_vec_template;
+        /*
+         * First copy the architecture vec template
+         *
+         * use memcpy() instead of *vec = *vec_template so that GCC replaces it
+         * by __memcpy() when KASAN is active
+         */
+        memcpy(&ibm_architecture_vec, &ibm_architecture_vec_template,
+               sizeof(ibm_architecture_vec));
 
         if (prop_len > 1) {
                 int i;
@@ -1475,7 +1605,7 @@ static void __init prom_init_mem(void)
                          */
                         prom_getprop(node, "name", type, sizeof(type));
                 }
-                if (strcmp(type, "memory"))
+                if (prom_strcmp(type, "memory"))
                         continue;
 
                 plen = prom_getprop(node, "reg", regbuf, sizeof(regbuf));
@@ -1487,8 +1617,8 @@ static void __init prom_init_mem(void)
                 endp = p + (plen / sizeof(cell_t));
 
 #ifdef DEBUG_PROM
-                memset(path, 0, PROM_SCRATCH_SIZE);
-                call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
+                memset(path, 0, sizeof(prom_scratch));
+                call_prom("package-to-path", 3, 1, node, path, sizeof(prom_scratch) - 1);
                 prom_debug("  node %s :\n", path);
 #endif /* DEBUG_PROM */
 
@@ -1756,19 +1886,19 @@ static void __init prom_initialize_tce_table(void)
                 prom_getprop(node, "device_type", type, sizeof(type));
                 prom_getprop(node, "model", model, sizeof(model));
 
-                if ((type[0] == 0) || (strstr(type, "pci") == NULL))
+                if ((type[0] == 0) || (prom_strstr(type, "pci") == NULL))
                         continue;
 
                 /* Keep the old logic intact to avoid regression. */
                 if (compatible[0] != 0) {
-                        if ((strstr(compatible, "python") == NULL) &&
-                            (strstr(compatible, "Speedwagon") == NULL) &&
-                            (strstr(compatible, "Winnipeg") == NULL))
+                        if ((prom_strstr(compatible, "python") == NULL) &&
+                            (prom_strstr(compatible, "Speedwagon") == NULL) &&
+                            (prom_strstr(compatible, "Winnipeg") == NULL))
                                 continue;
                 } else if (model[0] != 0) {
-                        if ((strstr(model, "ython") == NULL) &&
-                            (strstr(model, "peedwagon") == NULL) &&
-                            (strstr(model, "innipeg") == NULL))
+                        if ((prom_strstr(model, "ython") == NULL) &&
+                            (prom_strstr(model, "peedwagon") == NULL) &&
+                            (prom_strstr(model, "innipeg") == NULL))
                                 continue;
                 }
 
@@ -1796,10 +1926,10 @@ static void __init prom_initialize_tce_table(void)
                         local_alloc_bottom = base;
 
                 /* It seems OF doesn't null-terminate the path :-( */
-                memset(path, 0, PROM_SCRATCH_SIZE);
+                memset(path, 0, sizeof(prom_scratch));
                 /* Call OF to setup the TCE hardware */
                 if (call_prom("package-to-path", 3, 1, node,
-                              path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
+                              path, sizeof(prom_scratch) - 1) == PROM_ERROR) {
                         prom_printf("package-to-path failed\n");
                 }
 
@@ -1917,12 +2047,12 @@ static void __init prom_hold_cpus(void)
 
                 type[0] = 0;
                 prom_getprop(node, "device_type", type, sizeof(type));
-                if (strcmp(type, "cpu") != 0)
+                if (prom_strcmp(type, "cpu") != 0)
                         continue;
 
                 /* Skip non-configured cpus. */
                 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
-                        if (strcmp(type, "okay") != 0)
+                        if (prom_strcmp(type, "okay") != 0)
                                 continue;
 
                 reg = cpu_to_be32(-1); /* make sparse happy */
@@ -1998,9 +2128,9 @@ static void __init prom_find_mmu(void)
                 return;
         version[sizeof(version) - 1] = 0;
         /* XXX might need to add other versions here */
-        if (strcmp(version, "Open Firmware, 1.0.5") == 0)
+        if (prom_strcmp(version, "Open Firmware, 1.0.5") == 0)
                 of_workarounds = OF_WA_CLAIM;
-        else if (strncmp(version, "FirmWorks,3.", 12) == 0) {
+        else if (prom_strncmp(version, "FirmWorks,3.", 12) == 0) {
                 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL;
                 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim");
         } else
@@ -2033,7 +2163,7 @@ static void __init prom_init_stdout(void)
         call_prom("instance-to-path", 3, 1, prom.stdout, path, 255);
         prom_printf("OF stdout device is: %s\n", of_stdout_device);
         prom_setprop(prom.chosen, "/chosen", "linux,stdout-path",
-                     path, strlen(path) + 1);
+                     path, prom_strlen(path) + 1);
 
         /* instance-to-package fails on PA-Semi */
         stdout_node = call_prom("instance-to-package", 1, 1, prom.stdout);
@@ -2043,7 +2173,7 @@ static void __init prom_init_stdout(void)
                 /* If it's a display, note it */
                 memset(type, 0, sizeof(type));
                 prom_getprop(stdout_node, "device_type", type, sizeof(type));
-                if (strcmp(type, "display") == 0)
+                if (prom_strcmp(type, "display") == 0)
                         prom_setprop(stdout_node, path, "linux,boot-display", NULL, 0);
         }
 }
@@ -2064,19 +2194,19 @@ static int __init prom_find_machine_type(void)
                 compat[len] = 0;
                 while (i < len) {
                         char *p = &compat[i];
-                        int sl = strlen(p);
+                        int sl = prom_strlen(p);
                         if (sl == 0)
                                 break;
-                        if (strstr(p, "Power Macintosh") ||
-                            strstr(p, "MacRISC"))
+                        if (prom_strstr(p, "Power Macintosh") ||
+                            prom_strstr(p, "MacRISC"))
                                 return PLATFORM_POWERMAC;
 #ifdef CONFIG_PPC64
                         /* We must make sure we don't detect the IBM Cell
                          * blades as pSeries due to some firmware issues,
                          * so we do it here.
                          */
-                        if (strstr(p, "IBM,CBEA") ||
-                            strstr(p, "IBM,CPBW-1.0"))
+                        if (prom_strstr(p, "IBM,CBEA") ||
+                            prom_strstr(p, "IBM,CPBW-1.0"))
                                 return PLATFORM_GENERIC;
 #endif /* CONFIG_PPC64 */
                         i += sl + 1;
@@ -2093,7 +2223,7 @@ static int __init prom_find_machine_type(void)
                            compat, sizeof(compat)-1);
         if (len <= 0)
                 return PLATFORM_GENERIC;
-        if (strcmp(compat, "chrp"))
+        if (prom_strcmp(compat, "chrp"))
                 return PLATFORM_GENERIC;
 
         /* Default to pSeries. We need to know if we are running LPAR */
@@ -2155,19 +2285,19 @@ static void __init prom_check_displays(void)
         for (node = 0; prom_next_node(&node); ) {
                 memset(type, 0, sizeof(type));
                 prom_getprop(node, "device_type", type, sizeof(type));
-                if (strcmp(type, "display") != 0)
+                if (prom_strcmp(type, "display") != 0)
                         continue;
 
                 /* It seems OF doesn't null-terminate the path :-( */
                 path = prom_scratch;
-                memset(path, 0, PROM_SCRATCH_SIZE);
+                memset(path, 0, sizeof(prom_scratch));
 
                 /*
                  * leave some room at the end of the path for appending extra
                  * arguments
                  */
                 if (call_prom("package-to-path", 3, 1, node, path,
-                              PROM_SCRATCH_SIZE-10) == PROM_ERROR)
+                              sizeof(prom_scratch) - 10) == PROM_ERROR)
                         continue;
                 prom_printf("found display   : %s, opening... ", path);
                 
@@ -2259,9 +2389,9 @@ static unsigned long __init dt_find_string(char *str)
         s = os = (char *)dt_string_start;
         s += 4;
         while (s <  (char *)dt_string_end) {
-                if (strcmp(s, str) == 0)
+                if (prom_strcmp(s, str) == 0)
                         return s - os;
-                s += strlen(s) + 1;
+                s += prom_strlen(s) + 1;
         }
         return 0;
 }
@@ -2294,7 +2424,7 @@ static void __init scan_dt_build_strings(phandle node,
                 }
 
                 /* skip "name" */
-                if (strcmp(namep, "name") == 0) {
+                if (prom_strcmp(namep, "name") == 0) {
                         *mem_start = (unsigned long)namep;
                         prev_name = "name";
                         continue;
@@ -2306,7 +2436,7 @@ static void __init scan_dt_build_strings(phandle node,
                         namep = sstart + soff;
                 } else {
                         /* Trim off some if we can */
-                        *mem_start = (unsigned long)namep + strlen(namep) + 1;
+                        *mem_start = (unsigned long)namep + prom_strlen(namep) + 1;
                         dt_string_end = *mem_start;
                 }
                 prev_name = namep;
@@ -2363,8 +2493,8 @@ static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
 
         /* get it again for debugging */
         path = prom_scratch;
-        memset(path, 0, PROM_SCRATCH_SIZE);
-        call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
+        memset(path, 0, sizeof(prom_scratch));
+        call_prom("package-to-path", 3, 1, node, path, sizeof(prom_scratch) - 1);
 
         /* get and store all properties */
         prev_name = "";
@@ -2375,7 +2505,7 @@ static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
                         break;
 
                 /* skip "name" */
-                if (strcmp(pname, "name") == 0) {
+                if (prom_strcmp(pname, "name") == 0) {
                         prev_name = "name";
                         continue;
                 }
@@ -2406,7 +2536,7 @@ static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
                 call_prom("getprop", 4, 1, node, pname, valp, l);
                 *mem_start = _ALIGN(*mem_start, 4);
 
-                if (!strcmp(pname, "phandle"))
+                if (!prom_strcmp(pname, "phandle"))
                         has_phandle = 1;
         }
 
@@ -2476,8 +2606,8 @@ static void __init flatten_device_tree(void)
 
         /* Add "phandle" in there, we'll need it */
         namep = make_room(&mem_start, &mem_end, 16, 1);
-        strcpy(namep, "phandle");
-        mem_start = (unsigned long)namep + strlen(namep) + 1;
+        prom_strcpy(namep, "phandle");
+        mem_start = (unsigned long)namep + prom_strlen(namep) + 1;
 
         /* Build string array */
         prom_printf("Building dt strings...\n"); 
@@ -2799,7 +2929,7 @@ static void __init fixup_device_tree_efika(void)
         rv = prom_getprop(node, "model", prop, sizeof(prop));
         if (rv == PROM_ERROR)
                 return;
-        if (strcmp(prop, "EFIKA5K2"))
+        if (prom_strcmp(prop, "EFIKA5K2"))
                 return;
 
         prom_printf("Applying EFIKA device tree fixups\n");
@@ -2807,13 +2937,13 @@ static void __init fixup_device_tree_efika(void)
         /* Claiming to be 'chrp' is death */
         node = call_prom("finddevice", 1, 1, ADDR("/"));
         rv = prom_getprop(node, "device_type", prop, sizeof(prop));
-        if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0))
+        if (rv != PROM_ERROR && (prom_strcmp(prop, "chrp") == 0))
                 prom_setprop(node, "/", "device_type", "efika", sizeof("efika"));
 
         /* CODEGEN,description is exposed in /proc/cpuinfo so
            fix that too */
         rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop));
-        if (rv != PROM_ERROR && (strstr(prop, "CHRP")))
+        if (rv != PROM_ERROR && (prom_strstr(prop, "CHRP")))
                 prom_setprop(node, "/", "CODEGEN,description",
                              "Efika 5200B PowerPC System",
                              sizeof("Efika 5200B PowerPC System"));