1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Optimized string functions 4 * 5 * S390 version 6 * Copyright IBM Corp. 2004 7 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com) 8 */ 9 10#define IN_ARCH_STRING_C 1 11 12#include <linux/types.h> 13#include <linux/string.h> 14#include <linux/export.h> 15 16/* 17 * Helper functions to find the end of a string 18 */ 19static inline char *__strend(const char *s) 20{ 21 register unsigned long r0 asm("0") = 0; 22 23 asm volatile ("0: srst %0,%1\n" 24 " jo 0b" 25 : "+d" (r0), "+a" (s) : : "cc", "memory"); 26 return (char *) r0; 27} 28 29static inline char *__strnend(const char *s, size_t n) 30{ 31 register unsigned long r0 asm("0") = 0; 32 const char *p = s + n; 33 34 asm volatile ("0: srst %0,%1\n" 35 " jo 0b" 36 : "+d" (p), "+a" (s) : "d" (r0) : "cc", "memory"); 37 return (char *) p; 38} 39 40/** 41 * strlen - Find the length of a string 42 * @s: The string to be sized 43 * 44 * returns the length of @s 45 */ 46#ifdef __HAVE_ARCH_STRLEN 47size_t strlen(const char *s) 48{ 49 return __strend(s) - s; 50} 51EXPORT_SYMBOL(strlen); 52#endif 53 54/** 55 * strnlen - Find the length of a length-limited string 56 * @s: The string to be sized 57 * @n: The maximum number of bytes to search 58 * 59 * returns the minimum of the length of @s and @n 60 */ 61#ifdef __HAVE_ARCH_STRNLEN 62size_t strnlen(const char *s, size_t n) 63{ 64 return __strnend(s, n) - s; 65} 66EXPORT_SYMBOL(strnlen); 67#endif 68 69/** 70 * strcpy - Copy a %NUL terminated string 71 * @dest: Where to copy the string to 72 * @src: Where to copy the string from 73 * 74 * returns a pointer to @dest 75 */ 76#ifdef __HAVE_ARCH_STRCPY 77char *strcpy(char *dest, const char *src) 78{ 79 register int r0 asm("0") = 0; 80 char *ret = dest; 81 82 asm volatile ("0: mvst %0,%1\n" 83 " jo 0b" 84 : "+&a" (dest), "+&a" (src) : "d" (r0) 85 : "cc", "memory" ); 86 return ret; 87} 88EXPORT_SYMBOL(strcpy); 89#endif 90 91/** 92 * strlcpy - Copy a %NUL terminated string into a sized buffer 93 * @dest: Where to copy the string to 94 * @src: Where to copy the string from 95 * @size: size of destination buffer 96 * 97 * Compatible with *BSD: the result is always a valid 98 * NUL-terminated string that fits in the buffer (unless, 99 * of course, the buffer size is zero). It does not pad 100 * out the result like strncpy() does. 101 */ 102#ifdef __HAVE_ARCH_STRLCPY 103size_t strlcpy(char *dest, const char *src, size_t size) 104{ 105 size_t ret = __strend(src) - src; 106 107 if (size) { 108 size_t len = (ret >= size) ? size-1 : ret; 109 dest[len] = '\0'; 110 memcpy(dest, src, len); 111 } 112 return ret; 113} 114EXPORT_SYMBOL(strlcpy); 115#endif 116 117/** 118 * strncpy - Copy a length-limited, %NUL-terminated string 119 * @dest: Where to copy the string to 120 * @src: Where to copy the string from 121 * @n: The maximum number of bytes to copy 122 * 123 * The result is not %NUL-terminated if the source exceeds 124 * @n bytes. 125 */ 126#ifdef __HAVE_ARCH_STRNCPY 127char *strncpy(char *dest, const char *src, size_t n) 128{ 129 size_t len = __strnend(src, n) - src; 130 memset(dest + len, 0, n - len); 131 memcpy(dest, src, len); 132 return dest; 133} 134EXPORT_SYMBOL(strncpy); 135#endif 136 137/** 138 * strcat - Append one %NUL-terminated string to another 139 * @dest: The string to be appended to 140 * @src: The string to append to it 141 * 142 * returns a pointer to @dest 143 */ 144#ifdef __HAVE_ARCH_STRCAT 145char *strcat(char *dest, const char *src) 146{ 147 register int r0 asm("0") = 0; 148 unsigned long dummy; 149 char *ret = dest; 150 151 asm volatile ("0: srst %0,%1\n" 152 " jo 0b\n" 153 "1: mvst %0,%2\n" 154 " jo 1b" 155 : "=&a" (dummy), "+a" (dest), "+a" (src) 156 : "d" (r0), "0" (0UL) : "cc", "memory" ); 157 return ret; 158} 159EXPORT_SYMBOL(strcat); 160#endif 161 162/** 163 * strlcat - Append a length-limited, %NUL-terminated string to another 164 * @dest: The string to be appended to 165 * @src: The string to append to it 166 * @n: The size of the destination buffer. 167 */ 168#ifdef __HAVE_ARCH_STRLCAT 169size_t strlcat(char *dest, const char *src, size_t n) 170{ 171 size_t dsize = __strend(dest) - dest; 172 size_t len = __strend(src) - src; 173 size_t res = dsize + len; 174 175 if (dsize < n) { 176 dest += dsize; 177 n -= dsize; 178 if (len >= n) 179 len = n - 1; 180 dest[len] = '\0'; 181 memcpy(dest, src, len); 182 } 183 return res; 184} 185EXPORT_SYMBOL(strlcat); 186#endif 187 188/** 189 * strncat - Append a length-limited, %NUL-terminated string to another 190 * @dest: The string to be appended to 191 * @src: The string to append to it 192 * @n: The maximum numbers of bytes to copy 193 * 194 * returns a pointer to @dest 195 * 196 * Note that in contrast to strncpy, strncat ensures the result is 197 * terminated. 198 */ 199#ifdef __HAVE_ARCH_STRNCAT 200char *strncat(char *dest, const char *src, size_t n) 201{ 202 size_t len = __strnend(src, n) - src; 203 char *p = __strend(dest); 204 205 p[len] = '\0'; 206 memcpy(p, src, len); 207 return dest; 208} 209EXPORT_SYMBOL(strncat); 210#endif 211 212/** 213 * strcmp - Compare two strings 214 * @s1: One string 215 * @s2: Another string 216 * 217 * returns 0 if @s1 and @s2 are equal, 218 * < 0 if @s1 is less than @s2 219 * > 0 if @s1 is greater than @s2 220 */ 221#ifdef __HAVE_ARCH_STRCMP 222int strcmp(const char *s1, const char *s2) 223{ 224 register int r0 asm("0") = 0; 225 int ret = 0; 226 227 asm volatile ("0: clst %2,%3\n" 228 " jo 0b\n" 229 " je 1f\n" 230 " ic %0,0(%2)\n" 231 " ic %1,0(%3)\n" 232 " sr %0,%1\n" 233 "1:" 234 : "+d" (ret), "+d" (r0), "+a" (s1), "+a" (s2) 235 : : "cc", "memory"); 236 return ret; 237} 238EXPORT_SYMBOL(strcmp); 239#endif 240 241/** 242 * strrchr - Find the last occurrence of a character in a string 243 * @s: The string to be searched 244 * @c: The character to search for 245 */ 246#ifdef __HAVE_ARCH_STRRCHR 247char *strrchr(const char *s, int c) 248{ 249 ssize_t len = __strend(s) - s; 250 251 do { 252 if (s[len] == (char)c) 253 return (char *)s + len; 254 } while (--len >= 0); 255 return NULL; 256} 257EXPORT_SYMBOL(strrchr); 258#endif 259 260static inline int clcle(const char *s1, unsigned long l1, 261 const char *s2, unsigned long l2) 262{ 263 register unsigned long r2 asm("2") = (unsigned long) s1; 264 register unsigned long r3 asm("3") = (unsigned long) l1; 265 register unsigned long r4 asm("4") = (unsigned long) s2; 266 register unsigned long r5 asm("5") = (unsigned long) l2; 267 int cc; 268 269 asm volatile ("0: clcle %1,%3,0\n" 270 " jo 0b\n" 271 " ipm %0\n" 272 " srl %0,28" 273 : "=&d" (cc), "+a" (r2), "+a" (r3), 274 "+a" (r4), "+a" (r5) : : "cc", "memory"); 275 return cc; 276} 277 278/** 279 * strstr - Find the first substring in a %NUL terminated string 280 * @s1: The string to be searched 281 * @s2: The string to search for 282 */ 283#ifdef __HAVE_ARCH_STRSTR 284char *strstr(const char *s1, const char *s2) 285{ 286 int l1, l2; 287 288 l2 = __strend(s2) - s2; 289 if (!l2) 290 return (char *) s1; 291 l1 = __strend(s1) - s1; 292 while (l1-- >= l2) { 293 int cc; 294 295 cc = clcle(s1, l2, s2, l2); 296 if (!cc) 297 return (char *) s1; 298 s1++; 299 } 300 return NULL; 301} 302EXPORT_SYMBOL(strstr); 303#endif 304 305/** 306 * memchr - Find a character in an area of memory. 307 * @s: The memory area 308 * @c: The byte to search for 309 * @n: The size of the area. 310 * 311 * returns the address of the first occurrence of @c, or %NULL 312 * if @c is not found 313 */ 314#ifdef __HAVE_ARCH_MEMCHR 315void *memchr(const void *s, int c, size_t n) 316{ 317 register int r0 asm("0") = (char) c; 318 const void *ret = s + n; 319 320 asm volatile ("0: srst %0,%1\n" 321 " jo 0b\n" 322 " jl 1f\n" 323 " la %0,0\n" 324 "1:" 325 : "+a" (ret), "+&a" (s) : "d" (r0) : "cc", "memory"); 326 return (void *) ret; 327} 328EXPORT_SYMBOL(memchr); 329#endif 330 331/** 332 * memcmp - Compare two areas of memory 333 * @s1: One area of memory 334 * @s2: Another area of memory 335 * @n: The size of the area. 336 */ 337#ifdef __HAVE_ARCH_MEMCMP 338int memcmp(const void *s1, const void *s2, size_t n) 339{ 340 int ret; 341 342 ret = clcle(s1, n, s2, n); 343 if (ret) 344 ret = ret == 1 ? -1 : 1; 345 return ret; 346} 347EXPORT_SYMBOL(memcmp); 348#endif 349 350/** 351 * memscan - Find a character in an area of memory. 352 * @s: The memory area 353 * @c: The byte to search for 354 * @n: The size of the area. 355 * 356 * returns the address of the first occurrence of @c, or 1 byte past 357 * the area if @c is not found 358 */ 359#ifdef __HAVE_ARCH_MEMSCAN 360void *memscan(void *s, int c, size_t n) 361{ 362 register int r0 asm("0") = (char) c; 363 const void *ret = s + n; 364 365 asm volatile ("0: srst %0,%1\n" 366 " jo 0b\n" 367 : "+a" (ret), "+&a" (s) : "d" (r0) : "cc", "memory"); 368 return (void *) ret; 369} 370EXPORT_SYMBOL(memscan); 371#endif 372