From 622e8bac6092ccbd1fa683478e82e8711eb158af Mon Sep 17 00:00:00 2001 From: Jingqing3948 <2351290287@qq.com> Date: Wed, 2 Aug 2023 17:08:52 +0800 Subject: [PATCH] add 20230802-riscv-klibc-str-function-analysis-1-v0-pr --- ...-riscv-klibc-str-function-analysis-1-v0.md | 459 ++++++++++++++++++ 1 file changed, 459 insertions(+) create mode 100644 articles/20230802-riscv-klibc-str-function-analysis-1-v0.md diff --git a/articles/20230802-riscv-klibc-str-function-analysis-1-v0.md b/articles/20230802-riscv-klibc-str-function-analysis-1-v0.md new file mode 100644 index 0000000..4b002e0 --- /dev/null +++ b/articles/20230802-riscv-klibc-str-function-analysis-1-v0.md @@ -0,0 +1,459 @@ +> Corrector: [TinyCorrect](https://gitee.com/tinylab/tinycorrect) v0.2-rc1 - [spaces codeinline]
+> Author: Jingqing3948 <2351290287@qq.com>
+> Date: 2023/08/02
+> Revisor: Falcon
+> Project: [RISC-V Linux 内核剖析](https://gitee.com/tinylab/riscv-linux)
+> Sponsor: PLCT Lab, ISCAS + +# kernel libc 库分析之 str v0 + +## 前言 + +本文主要是展开分析 lib 库里的 str 类函数的一部分，以及对其的一些展开测试。 + +## 列表及功能介绍 + +```shell +├── fdt_strerror.c +├── kstrtox.c # kstrtox 主要是字符串 -> 整数转换相关 +├── kstrtox.h +├── kunit +│ ├── string-stream.c # 字符串流操作 +│ ├── string-stream.h +│ └── string-stream-test.c +├── strcat_kunit.c # 测试文件 +├── string.c # 字符串的一些基础操作 +├── string_helpers.c # 字符串的辅助处理函数，如获取大小、编码解码等 +├── strncpy_from_user.c # 从用户空间获取字符串的处理函数 +├── strnlen_user.c +├── strscpy_kunit.c +├── test_fortify +│ ├── write_overflow-strcpy.c # 这一系列主要是先校验是否溢出，再决定是否调用函数 +│ ├── write_overflow-strcpy-lit.c +│ ├── write_overflow-strlcpy.c +│ ├── write_overflow-strlcpy-src.c +│ ├── write_overflow-strncpy.c +│ ├── write_overflow-strncpy-src.c +│ ├── write_overflow-strscpy.c +├── test-kstrtox.c +├── test_string.c +├── test-string_helpers.c +├── ucs2_string.c # 处理通用字符集 UCS2 的字符串函数 +``` + +因为篇幅问题本文只对其中的一部分展开分析，主要为 str 基础函数部分如 strcpy strcmp 等。 + +本文主要是对 string 中的基础函数展开分析，以及其他文件中对应函数的对比扩展。 + +由于大部分函数内容都存在于 string.c 中，少部分在其他文件中呈现，因此为了使结构不过于混乱，**本文规定：除非特殊声明，否则所有函数内容均属于 `lib/string.c` 和 `lib/test_string.c`.** + +## strcmp, memcmp + +字符串的比较。 + +`int strncasecmp(const char *s1, const char *s2, size_t len)`：比较两个字符串，忽视大小写区别。len 是最长判断范围。返回值为 0 则表示一致。 + +采用 unsigned char 存储每一位要比较的字符，更能确保比较时字符串行为一致且正确。 + +`int strcasecmp(const char *s1, const char *s2)`：重载的函数，没有给定判断长度限制，因此不用判断：当字符串结束的时候，长度是否小于 len. + +`int strcmp(const char *cs, const char *ct)`：逐位比较两个字符串是否每一位完全一致。如果第一个不一致位 cs>ct 返回 1，否则返回 -1；一致返回 0. + +`int strncmp(const char *cs, const char *ct, size_t count)`：只比较指定长度。 + +`__visible int memcmp(const void *cs, const void *ct, size_t count)` + +优化部分代码如下： + +```c +// src/linux-stable/lib/string.c:765 + +#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS + if (count >= sizeof(unsigned long)) { + const unsigned long *u1 = cs; + const unsigned long *u2 = ct; + do { + if (get_unaligned(u1) != get_unaligned(u2)) + break; + u1++; + u2++; + count -= sizeof(unsigned long); + } while (count >= sizeof(unsigned long)); + cs = u1; + ct = u2; + } +#endif +``` + +如果定义了 `CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS`，就逐字比较。否则（或者需要比较的长度大小<1 字）就逐位比较。 + +`int bcmp(const void *a, const void *b, size_t len)`：就是调用了 memcmp，返回 0 表示一致，非 0 不一致。可以在 bcmp 中加一些操作比如对返回值的判断。 + +## strcpy, memcpy + +复制 src 字符串到 dest 位置。 + +`char *strcpy(char *dest, const char *src)`：就是一位一位赋值直到到达字符串结尾。后面会介绍优化版的 strcpy，可以按块复制。 + +`char *strncpy(char *dest, const char *src, size_t count)`：复制指定长度。给 while 多加了一个判定结束的条件：`ount==0`. + +`size_t strlcpy(char *dest, const char *src, size_t size)`：把字符串指定长度复制给**缓冲区**，先判断 size 和 strlen 谁小，用小的作为复制长度调用 `memcpy`. + +和 strncpy 的区别在于：strncpy 是我指定复制 count 位过去，不管缓冲区是否溢出；`strlcpy` 是传入了 dest 的 size，来判断复制多少位可以不溢出，更安全。 + +`ssize_t strscpy(char *dest, const char *src, size_t count)`：这个就是优化版的 `strcpy` 了。返回值标识是否复制成功，成功返回 0. + +1. count 不合法，即为 0 或超出 INT_MAX：返回错误码 -E2BIG。 +2. 如果启用了 `CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS`，而且 src 和 dest 都对齐了，则设置 max 限定复制的最大字节数以免越过页边界。每次复制的块大小是 `unsigned long` 32bits，如果 max >= 32bits 就复制一块过去，直到 max < 32bits，这时候开始逐位复制。 + +```c +// src/linux-stable/lib/string.c:200 + +while (max >= sizeof(unsigned long)) { + unsigned long c, data; + + c = read_word_at_a_time(src+res); + if (has_zero(c, &data, &constants)) { + data = prep_zero_mask(c, data, &constants); + data = create_zero_mask(data); + *(unsigned long *)(dest+res) = c & zero_bytemask(data); + return res + find_zero(data); + } + *(unsigned long *)(dest+res) = c; + res += sizeof(unsigned long); + count -= sizeof(unsigned long); + max -= sizeof(unsigned long); +} +``` + +3. 读一个字长度出来，如果里面有 0（说明这个字中间终止了），则只复制到 0 位。截取 0 位以前的部分再补一个 0 位，复制给 dest。否则复制一整个 `unsigned long` 过去，然后开启下一轮复制循环。 + +4. 跳出 3 的循环后，继续逐位复制到结尾。 + +`char *stpcpy(char *__restrict__ dest, const char *__restrict__ src)`：复制完了，让 dest 指向自己这个字符串的结尾 \\0. + +`void *memcpy(void *dest, const void *src, size_t count)`：逐位复制。 + +### lib/test_strcpy.c + +`strcpy` 部分通过 `lib/test_strcpy.c` 函数测试其功能，该函数通过给定不同的 dest 缓冲区大小和 count 规定复制字符数，测试结果是否符合预期。 + +### lib/write_overflow-strcpy_*.c + +`strcpy` 部分通过 `lib/write_overflow-strcpy-*.c` 测试溢出的边界情况，如 `strcpy(small, large)`, `strncpy(small, large_src, sizeof(small) + 1)`。 + +### lib/strncpy_from_user.c + +从用户空间拷贝字符串到内核空间。 + +`static inline long do_strncpy_from_user(char *dst, const char __user *src, unsigned long count, unsigned long max)`：这里的 `strcpy` 和 `lib/string.c` 做的优化有异曲同工之妙，主要也是对齐后逐位进行处理。复制成功返回复制字节数。 + +- 首先了解一下如何从用户空间拷贝数据：`unsafe_get_user`，实际上是一个宏。不安全的主要原因是其没有做权限检查。调用方法：`unsafe_get_user(c, (unsigned long __user *)(src), byte_at_a_time);` 从 `src` 处获取 `unsigned long` 型数值存到 `char c` 里（这里是宏定义而不是函数，所以可以实现赋值），如果失败了跳转到 `byte_at_a_time` 处。参考 [unsafe_put_user 的解释][001] +- 如果 max >= unsigned long 的长度，也就是剩下需要拷贝的字符数量不够 32 位，跳转到 `byte_at_a_time` 处逐个字节复制。 +- 如果当前这一个 unsigned long 的长度里出现了 0 位，说明里面出现了字符串的终止位，通过设置掩码后赋值的方式赋值 0 位前的部分，结束复制。 +- 如果这一个 unsigned long 长度里没有 0 位，则说明字符串没有终止，直接复制一个 unsigned long 的长度后 `max -= sizeof(unsigned long);` 继续下一轮复制。 +- byte_at_a_time：循环获取 1 字节长度复制。复制完成后跳出循环；获取失败返回 `-EFAULT`。 + +`long strncpy_from_user(char *dst, const char __user *src, long count)`：`do_strncpy_from_user` 的包装类。 + +- 首先通过 `might_fault()` 标记可能出现页错误的位置； +- 如果用户启用了故障注入，返回 -EFAULT 模拟故障； +- 然后先校验 count 是否 >0，检查用户源空间是否在内核允许范围内； +- 确保内存访问不会越界（`kasan_check_write`, `check_object_size`）且内核访问用户空间的数据是安全的（`user_read_access_begin`）后，调用 `do_strncpy_from_user` 函数开始内存访问。 + +## strcat + +`char *strcat(char *dest, const char *src)`：src 拼接到 dest 结尾处，返回 dest 首指针。 + +`char *strncat(char *dest, const char *src, size_t count)`：两个判定条件，1 是 src 终止，2 是复制长度超过 cnt。 + +`size_t strlcat(char *dest, const char *src, size_t count)`：和 `strlcpy`, `strncpy` 区别类似。 + +## strchr, memchr + +`char *strchr(const char *s, int c)`：逐位搜索 s 字符串里面有没有 c 字符。返回对应位置的指针，没有返回空指针 NULL。也可以搜索空字符。 + +`char *strchrnul(const char *s, int c)`：没找到也不返回 NULL，而是返回指向字符串结尾的 \0 的指针。我觉得这样我们可以借助 `strchr` 来找字符串的结尾位置。 + +`char *strnchrnul(const char *s, size_t count, int c)`：限定一个长度范围内搜索 c。超出范围返回第一个超出的字符的指针。 + +`char *strrchr(const char *s, int c)`：找到最后一个匹配 c 的指针。 + +`char *strnchr(const char *s, size_t count, int c)`：限定在前 cnt 范围里面找。 + +`void *memchr(const void *s, int c, size_t n)`：类似 strchr。 + +`void *memchr_inv(const void *start, int c, size_t bytes)`：找第一个不匹配的字符位置。这里也有做一些优化。 + +- 首先写了一个 `static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)`，这个就是在 bytes 范围内遍历查找，低效，用于处理尾部数据。 +- 如果要寻找长度<16B，就直接调用 check_bytes8 处理即可。 + +```c +// src/linux-stable/lib/string.c:934 + + value64 = value; +#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64 + value64 *= 0x0101010101010101ULL; +#elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) + value64 *= 0x01010101; + value64 |= value64 << 32; +#else + value64 |= value64 << 8; + value64 |= value64 << 16; + value64 |= value64 << 32; +#endif +``` + +- 比如 value 是 0xEB，扩展为 64 位后就变为 0xEBEBEBEB. 这样可以同时进行比较提高效率。 + +```c +// src/linux-stable/lib/string.c:946 + +prefix = (unsigned long)start % 8; +if (prefix) { + u8 *r; + + prefix = 8 - prefix; + r = check_bytes8(start, value, prefix); + if (r) + return r; + start += prefix; + bytes -= prefix; +} +``` + +- 这里检查一下前 8 位前缀有无对齐，没有对齐就先比较一下这 8 位再将其对齐。 + +> chatGPT: 让我们假设 start 是一个指向内存区域的指针，并且当前的 u8 类型是一个无符号 8 位整数。我们来举一个具体数字的例子来说明 prefix 是如何影响对齐的。 +> 假设 start 指针指向如下的内存区域，每个字节用十六进制表示： + +``` + 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D ++----+----+----+----+----+----+----+----+----+----+----+----+----+----+ +| AB | CD | EF | 12 | 34 | 56 | 78 | 9A | BC | DE | F0 | 11 | 11 | 33 | ++----+----+----+----+----+----+----+----+----+----+----+----+----+----+ + ^ + | + start +``` + +> 在这个例子中，start 指针指向内存的位置 start[0]，即 AB（十六进制）。我们假设每个字节都是不同的，因此在这个区域内没有重复的字节值。 +> 现在，我们来计算 prefix，即指针 start 相对于 8 字节对齐的偏移量： + +```c +prefix = (unsigned long)start % 8 + = (unsigned long)0x00 % 8 + = 0 +``` + +> 由于 start 指针的值是 0x00，它已经是 8 字节对齐的，prefix 的值是 0。这意味着在此例中，start 指针已经对齐了，没有前缀需要处理。 +> 但是，如果 start 指针的值不是 8 的倍数，那么 prefix 就会有一个非零值，表示指针在 8 字节对齐时，需要向前调整的字节数。通过调用 check_bytes8 函数来查找不等于给定值的字节时，我们会处理这个前缀部分。 + +- start 想要比较完并跳转到下一个 8 字节对齐位置，需要往前比较并跳转 `8-prefix` 个长度。比较完后，start 指针 + 这个长度，剩余要比较的长度 bytes - 这个长度。处理完之后我们现在就对齐好了，可以开始更高效的查询方式了。 + +```c +// src/linux-stable/lib/string.c:958 + +words = bytes / 8; + + while (words) { + if (*(u64 *)start != value64) + return check_bytes8(start, value, 8); + start += 8; + words--; + } +``` + +- 每次比较 8 个字节 64 位，提高效率。words 部分比较完了，就剩下结尾不够 8 字节长度的待比较部分了。 + +- 结尾部分再调用 `check_bytes8(start, value, bytes%8)` 即可完成比较。 + +## strlen + +`size_t strlen(const char *s)`：逐位++到结尾为止。 + +`size_t strnlen(const char *s, size_t count)`：限定一定长度范围内获取 len。 + +### lib/strlen_from_user.c + +`static inline long do_strnlen_user(const char __user *src, unsigned long count, unsigned long max)`：优化版计算 strlen 的函数。 + +通过此方式对齐： + +```c +// lib/strlen_from_user.c:33 + +align = (sizeof(unsigned long) - 1) & (unsigned long)src; +src -= align; +max += align; +``` + +然后采用类似 `strcpy` 部分的优化方法，每次获取一个 `unsigned long` 的长度并通过掩码截断。如果获取长度 > 用户指定 count 长度，返回 count+1。 + +`long strnlen_user(const char __user *str, long count)`：比起 `do_strlen_user`，首先确定 count 是否合法和用户空间范围等。 + +这个函数基本不会被使用，因为其他线程任何时候都可以直接修改用户空间字符串，一般用 `strcpy_from_user` 直接获取字符串拷贝来代替此函数。 + +## strspn + +`size_t strspn(const char *s, const char *accept)`：找找 s 字符串里面有多少个开头连续的字符是 accept 字符串里出现过的，比如 accept 是 abcd, s 是 aabcdefgaa, 那么就出现过 5 次。 + +函数写的很简单，两层循环遍历扫描，对于每一个 s 中的字符，遍历 accept 看是否是 accept 中的一个字符，如果是 `cnt++`，如果不是直接返回 cnt，最终返回 cnt。但是这里是不是可以用一个缓冲数组存 `*accept` 对应字符，这样也不用每次到 accept 中访问指定地址中的内容？ + +`size_t strcspn(const char *s, const char *reject)`：和 accept 相反，看开头多少个字符是未出现在 reject 中的并计数。 + +## strpbrk + +`char *strpbrk(const char *cs, const char *ct)`：查找 cs 中第一次出现 ct 中字符的位置。 + +## strsep + +`char *strsep(char **s, const char *ct)`： + +1. 借助 `strpbrk` 找到第一次出现 ct 中字符的 cs 的位置； +2. 把这个字符替换成空字符； +3. 指针指向该字符位置后面的一个字符串，并返回指针。 + +## memset + +`void *memset(void *s, int c, size_t count)`：从 s 开始，赋值 count 个字符 c。返回 s 头指针也就是最开始传入的时候所指向的地址。 + +`void *memset16(uint16_t *s, uint16_t v, size_t count)`：半字长为单位进行赋值。 + +`void *memset32(uint32_t *s, uint32_t v, size_t count)`：1 字长为单位进行赋值。 + +`void *memset64(uint64_t *s, uint64_t v, size_t count)`：2 字长为单位进行赋值。 + +## memmove + +`void *memmove(void *dest, const void *src, size_t count)`：如果 dest 在 src 左边，则采用 `memcpy` 的逐位复制方法。否则采用从尾部倒过来复制的方法。这里在分析优化的时候也分析过，为了防止 dest 在 src 右边出现重叠部分从左到右复制会影响到后面的复制流程。 + +## memscan + +`void *memscan(void *addr, int c, size_t size)`：找到 c 第一次出现的地址，或者超出 size 的第一个字节的地址。 + +## strstr + +`char *strstr(const char *s1, const char *s2)`：找到 s1 中第一次出现 s2 子串的位置。遍历 s1 进行 `memcmp(s1, s2, length_of_s2)` 查找。 + +`char *strnstr(const char *s1, const char *s2, size_t len)`：限定搜索一定长度范围。 + +## 编译包含 + +```makefile +// src/linux-stable/lib/Makefile:30 + +lib-y := ctype.o string.o vsprintf.o cmdline.o \ + rbtree.o radix-tree.o timerqueue.o xarray.o \ + idr.o extable.o sha1.o irq_regs.o argv_split.o \ + flex_proportions.o ratelimit.o show_mem.o \ + is_single_threaded.o plist.o decompress.o kobject_uevent.o \ + earlycpio.o seq_buf.o siphash.o dec_and_lock.o \ + nmi_backtrace.o nodemask.o win_minmax.o memcat_p.o \ + buildid.o +``` + +这部分函数应该是无论如何都会包含在其中，编译时生成 lib.a 文件（在对应开发板 lib 文件夹内生成的）。 + +## lib/test_string.c + +对 string 的展开测试。 + +### memset_selftest + +__init 表示这个函数只会在初始化时调用一次，我们在 make boot 时调用一次自检正合适。 + +`static __init int memset16_selftest(void)`：测试思路如下。 + +1. 首先开辟 256 * 2 * 2 个字节空间。开辟失败返回 -1。 + +2. 然后这片空间每个半字全部赋值为 0xa1，最终值为：a1a1a1a1a1…… + +``` ++------+----------+----------------+ +| a1a1 | b2b2b2b2 | a1a1a1a1a1a1a1 | ++------+----------+----------------+ +^ ^ ^ ^ +| | | | +p p+i p+i+j p+512 +``` + +3. 对于这开辟的一整片空间，我们每次 i 从 0 到 256 遍历，j 从 0 到 256 遍历，我们让 [p+i,p+i+j] 中间的部分赋值为 b2b2b2b2……，[p,p+i] 部分和 [p+i+j，256] 的部分赋值仍为 a1a1a1a1……。然后循环检查赋值是否如预期。 + +4. 如果发生错误，返回 `return (i << 24) | (j << 16) | k | 0x8000;` 一整个信息可以表示出错是三个循环变量的值。 + +`static __init int memset32_selftest(void)`：类似，不过赋值格式为 0xb1b2b3b4 这样，且所需空间也加倍了。 + +`static __init int memset64_selftest(void)`：类似。 + +### strchr_selftest + +`static __init int strchr_selftest(void)`： + +测试案例：查找正常字符；查找 \\0；查找空字符串里的字符；查找未出现在非空字符串里的字符。 + +1. 测试主要围绕两个字符集合的字符串展开：`test_string`: "abcdefghijkl" 和 empty_string: "". 返回值=0 说明测试成功。 +2. 利用 `strchr(test_string, test_string[i])` 遍历测试，得到的结果应该是 i，如果不是 i 则返回 i+'a' 可根据此结果推断出错时的值。 +3. 查找 empty_string 中出现 '\\0' 的位置，结果应为 empty_string，出错返回错误码 0x101. +4. 查找 empty_string 中出现 'a' 的位置，结果应为 NULL，出错返回错误码 0x102. +5. 查找 test_string 中出现 'z' 的位置，结果应为 NULL，出错返回错误码 0x103. + +`static __init int strnchr_selftest(void)`：主要比较和 `strchr_selftest()` 增加的一些测试区别。 + +1. 遍历测试 test_string 的时候，也同时遍历长度变量 j。只有 j >i 的时候才应该查得到结果，否则应该结果为 NULL。发生错误返回错误码 `(i+'a')<<8|j` 能同时表示 i j 的信息。 +2. 查询 empty_string 中 '\\0' 的位置时令长度为 0（结果应为 NULL）和长度为 1（结果应为 empty_string）,发生错误时错误码分别对应 0x1001 0x1002. +3. 增加一个 `strnchr(NULL, 0, '\0');` 的测试用例，返回结果应为 NULL。 + +### string_selftest_init + +`static __init int string_selftest_init(void)`：调用上述所有测试用例。如果执行到其中一个报错，则终止测试并返回错误的测试序号、返回错误码信息。 + +最后通过 `module_init(string_selftest_init);` 加载模块时自动调用。 + +### 编译包含 + +Makefile: + +```makefile +obj-$(CONFIG_STRING_SELFTEST) += test_string.o +``` + +### 使用模块 + +这个测试模块位于： + +``` +menu Kernel Hacking +-> menu "Kernel Testing and Coverage" + -> if RUNTIME_TESTING_MENU ("Runtime Testing") + -> config STRING_SELFTEST ("Test string functions at runtime") 里。 +``` + +编译运行后，输出信息里有这么一句，和 `test_string.c` 里相对应： + +```shell +String selftests succeeded +``` + +## 总结 + +本文截取了一部分功能较为基础的 str 文件先进行分析。 + +分析重点主要还是在其中的一些优化手段上。其中有一部分在这篇文章中有简单分析过其应用：[articles/20230617-riscv-klibc-opt-summary.md (gitee.com)][002] + +其中的优化内容主要包括： + +1. `memcmp`：在开启高效对齐的前提下逐字比较，结尾部分逐位比较，效率高于逐位比较。 +2. `strscpy`：在开启高效对齐且 dest src 地址对齐的前提下逐字复制，结尾部分逐位复制。 +3. `strnlen`：类似，先通过判断字符串起始位置计算如何对齐后逐块计算长度。 +4. `memchr_inv`：待查找值扩展为 64 位，这样查找时更为高效。如果当前指针位置没有对齐，先逐位比较几次直至对齐在字节开始处（地址 %8 == 0），然后一次比较 8 个字节，如果在这 8 个字节中发现了要找的字符，或剩余字节数不够 8 个了，再逐位比较其中的位置。 + +在下一篇文章中将继续展开分析 str 相关函数及其中所做优化，如 str 和整数转换，编码解码等，在下一篇文章中展开叙述。 + +## 参考资料 + +- [Articles/736348][001] +- [tinylab/riscv-linux/blob/master/articles/20230617-riscv-klibc-opt-summary.md][002] + +[001]: https://lwn.net/Articles/736348/ +[002]: https://gitee.com/tinylab/riscv-linux/blob/master/articles/20230617-riscv-klibc-opt-summary.md -- Gitee