mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

linux_kselftest-nolibc-6.10-rc1 

This nolibc update for Linux 6.10-rc1
 
 - adds support for uname(2)
 - removes open-coded strnlen()
 - exports strlen()
 - adds tests for strlcat() and strlcpy()
 - fixes memory error in realloc()
 - fixes strlcat() return code and size usage
 - fixes strlcpy() return code and size usage
 -----BEGIN PGP SIGNATURE-----
 
 iQIzBAABCgAdFiEEPZKym/RZuOCGeA/kCwJExA0NQxwFAmZCKZ8ACgkQCwJExA0N
 QxznfRAA17AXswINyhQEu/2lJIFFpQazZqMyvZ4mv19FPI8P3zhwPN24XsmLNqdo
 py6dUIbondrs7UgOOG0R0E8N89rxDctok6F8OEScsnfvd+KKEg3+YJscJj2X1vaK
 H3qU+i/K3oGFHJo2dsaR1iYl+lzo9dyzvicOe5bFzFkVQGI0a3p88CQrhoF3HkNf
 jc9oqnxIGJn3v3UX6jxFWFiuF17CopNv4/5DZG2QIU5t0JGiqEYxl5ayDwqQsgGB
 E88eiutsuhkVTqKI/9VXs+YIE0B0xbEQfGGSQ1zzGZKfy7MBSk88PzLXa591DFZH
 SXETzfxqbI4ACX7L36mUX/JUw/sC5ch67UABZqwrj8oxXb9Ssgxfzmt7rCwBlp2i
 GdYHuoSDY5TJnskceL5a94BLuvhI9EnYsMHKA2aHM95eBBkPZo7jGqqOU8hJbL4t
 MbIu0z3iCNUBFcNSBXdfv81Dc4CJO4Orj1jnMqe0U6dSasT+hS2ulZPu6EjKIfMY
 Wqgfs89pFQ4OH3e3Crx2ngz57iL2fDYZfccfjOJQtYfxTOmXRKHjcDXcZdydsxNF
 6dXNDhtuyftvNf3h4o7B73Rv3xNbG1ObZmU2i4wxmY2fsYEsRhqR/UKhtqbTPsxF
 C/zL8KSraGzrgYuyOzQMDWAH/ybhZytn91kEd1QBWMO79TCC2JI=
 =2QlZ
 -----END PGP SIGNATURE-----

Merge tag 'linux_kselftest-nolibc-6.10-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest

Pull nolibc updates from Shuah Khan:

 - add support for uname(2)

 - remove open-coded strnlen()

 - export strlen()

 - add tests for strlcat() and strlcpy()

 - fix memory error in realloc()

 - fix strlcat() and strlcpy() return code and size usage

* tag 'linux_kselftest-nolibc-6.10-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest:
  tools/nolibc: add support for uname(2)
  tools/nolibc/string: remove open-coded strnlen()
  selftests/nolibc: Add tests for strlcat() and strlcpy()
  tools/nolibc: Fix strlcpy() return code and size usage
  tools/nolibc: Fix strlcat() return code and size usage
  tools/nolibc/string: export strlen()
  tools/nolibc/stdlib: fix memory error in realloc()
This commit is contained in:
Linus Torvalds 2024-05-14 11:31:09 -07:00
parent 5901037324 0adab2b6b7
commit 4b768bf062
4 changed files with 135 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tools/include/nolibc/stdlib.h
View File

@ -185,7 +185,7 @@ void *realloc(void *old_ptr, size_t new_size)
if (__builtin_expect(!ret, 0))
return NULL;
memcpy(ret, heap->user_p, heap->len);
memcpy(ret, heap->user_p, user_p_len);
munmap(heap, heap->len);
return ret;
}

44
tools/include/nolibc/string.h
View File

@ -123,7 +123,7 @@ char *strcpy(char *dst, const char *src)
* thus itself, hence the asm() statement below that's meant to disable this
* confusing practice.
*/
static __attribute__((unused))
__attribute__((weak,unused,section(".text.nolibc_strlen")))
size_t strlen(const char *str)
{
size_t len;
@ -187,22 +187,26 @@ char *strndup(const char *str, size_t maxlen)
static __attribute__((unused))
size_t strlcat(char *dst, const char *src, size_t size)
{
size_t len;
char c;
size_t len = strnlen(dst, size);
for (len = 0; dst[len]; len++)
;
for (;;) {
c = *src;
if (len < size)
dst[len] = c;
if (!c)
/*
* We want len < size-1. But as size is unsigned and can wrap
* around, we use len + 1 instead.
*/
while (len + 1 < size) {
dst[len] = *src;
if (*src == '\0')
break;
len++;
src++;
}
if (len < size)
dst[len] = '\0';
while (*src++)
len++;
return len;
}
@ -210,16 +214,18 @@ static __attribute__((unused))
size_t strlcpy(char *dst, const char *src, size_t size)
{
size_t len;
char c;
for (len = 0;;) {
c = src[len];
if (len < size)
dst[len] = c;
if (!c)
break;
len++;
for (len = 0; len < size; len++) {
dst[len] = src[len];
if (!dst[len])
return len;
}
if (size)
dst[size-1] = '\0';
while (src[len])
len++;
return len;
}

27
tools/include/nolibc/sys.h
View File

@ -22,6 +22,7 @@
#include <linux/stat.h> /* for statx() */
#include <linux/prctl.h>
#include <linux/resource.h>
#include <linux/utsname.h>
#include "arch.h"
#include "errno.h"
@ -1139,6 +1140,32 @@ int umount2(const char *path, int flags)
}
/*
* int uname(struct utsname *buf);
*/
struct utsname {
char sysname[65];
char nodename[65];
char release[65];
char version[65];
char machine[65];
char domainname[65];
};
static __attribute__((unused))
int sys_uname(struct utsname *buf)
{
return my_syscall1(__NR_uname, buf);
}
static __attribute__((unused))
int uname(struct utsname *buf)
{
return __sysret(sys_uname(buf));
}
/*
* int unlink(const char *path);
*/

82
tools/testing/selftests/nolibc/nolibc-test.c
View File

@ -27,6 +27,7 @@
#include <sys/syscall.h>
#include <sys/sysmacros.h>
#include <sys/time.h>
#include <sys/utsname.h>
#include <sys/wait.h>
#include <dirent.h>
#include <errno.h>
@ -600,6 +601,25 @@ int expect_strne(const char *expr, int llen, const char *cmp)
return ret;
}
#define EXPECT_STRBUFEQ(cond, expr, buf, val, cmp) \
do { if (!(cond)) result(llen, SKIPPED); else ret += expect_str_buf_eq(expr, buf, val, llen, cmp); } while (0)
static __attribute__((unused))
int expect_str_buf_eq(size_t expr, const char *buf, size_t val, int llen, const char *cmp)
{
llen += printf(" = %lu <%s> ", expr, buf);
if (strcmp(buf, cmp) != 0) {
result(llen, FAIL);
return 1;
}
if (expr != val) {
result(llen, FAIL);
return 1;
}
result(llen, OK);
return 0;
}
/* declare tests based on line numbers. There must be exactly one test per line. */
#define CASE_TEST(name) \
@ -761,6 +781,45 @@ int test_stat_timestamps(void)
return 0;
}
int test_uname(void)
{
struct utsname buf;
char osrelease[sizeof(buf.release)];
ssize_t r;
int fd;
memset(&buf.domainname, 'P', sizeof(buf.domainname));
if (uname(&buf))
return 1;
if (strncmp("Linux", buf.sysname, sizeof(buf.sysname)))
return 1;
fd = open("/proc/sys/kernel/osrelease", O_RDONLY);
if (fd == -1)
return 1;
r = read(fd, osrelease, sizeof(osrelease));
if (r == -1)
return 1;
close(fd);
if (osrelease[r - 1] == '\n')
r--;
/* Validate one of the later fields to ensure field sizes are correct */
if (strncmp(osrelease, buf.release, r))
return 1;
/* Ensure the field domainname is set, it is missing from struct old_utsname */
if (strnlen(buf.domainname, sizeof(buf.domainname)) == sizeof(buf.domainname))
return 1;
return 0;
}
int test_mmap_munmap(void)
{
int ret, fd, i, page_size;
@ -966,6 +1025,8 @@ int run_syscall(int min, int max)
CASE_TEST(stat_fault); EXPECT_SYSER(1, stat(NULL, &stat_buf), -1, EFAULT); break;
CASE_TEST(stat_timestamps); EXPECT_SYSZR(1, test_stat_timestamps()); break;
CASE_TEST(symlink_root); EXPECT_SYSER(1, symlink("/", "/"), -1, EEXIST); break;
CASE_TEST(uname); EXPECT_SYSZR(proc, test_uname()); break;
CASE_TEST(uname_fault); EXPECT_SYSER(1, uname(NULL), -1, EFAULT); break;
CASE_TEST(unlink_root); EXPECT_SYSER(1, unlink("/"), -1, EISDIR); break;
CASE_TEST(unlink_blah); EXPECT_SYSER(1, unlink("/proc/self/blah"), -1, ENOENT); break;
CASE_TEST(wait_child); EXPECT_SYSER(1, wait(&tmp), -1, ECHILD); break;
@ -991,6 +1052,14 @@ int run_stdlib(int min, int max)
for (test = min; test >= 0 && test <= max; test++) {
int llen = 0; /* line length */
/* For functions that take a long buffer, like strlcat()
* Add some more chars after the \0, to test functions that overwrite the buffer set
* the \0 at the exact right position.
*/
char buf[10] = "test123456";
buf[4] = '\0';
/* avoid leaving empty lines below, this will insert holes into
* test numbers.
*/
@ -1007,6 +1076,19 @@ int run_stdlib(int min, int max)
CASE_TEST(strchr_foobar_z); EXPECT_STRZR(1, strchr("foobar", 'z')); break;
CASE_TEST(strrchr_foobar_o); EXPECT_STREQ(1, strrchr("foobar", 'o'), "obar"); break;
CASE_TEST(strrchr_foobar_z); EXPECT_STRZR(1, strrchr("foobar", 'z')); break;
#ifdef NOLIBC
CASE_TEST(strlcat_0); EXPECT_STRBUFEQ(1, strlcat(buf, "bar", 0), buf, 3, "test"); break;
CASE_TEST(strlcat_1); EXPECT_STRBUFEQ(1, strlcat(buf, "bar", 1), buf, 4, "test"); break;
CASE_TEST(strlcat_5); EXPECT_STRBUFEQ(1, strlcat(buf, "bar", 5), buf, 7, "test"); break;
CASE_TEST(strlcat_6); EXPECT_STRBUFEQ(1, strlcat(buf, "bar", 6), buf, 7, "testb"); break;
CASE_TEST(strlcat_7); EXPECT_STRBUFEQ(1, strlcat(buf, "bar", 7), buf, 7, "testba"); break;
CASE_TEST(strlcat_8); EXPECT_STRBUFEQ(1, strlcat(buf, "bar", 8), buf, 7, "testbar"); break;
CASE_TEST(strlcpy_0); EXPECT_STRBUFEQ(1, strlcpy(buf, "bar", 0), buf, 3, "test"); break;
CASE_TEST(strlcpy_1); EXPECT_STRBUFEQ(1, strlcpy(buf, "bar", 1), buf, 3, ""); break;
CASE_TEST(strlcpy_2); EXPECT_STRBUFEQ(1, strlcpy(buf, "bar", 2), buf, 3, "b"); break;
CASE_TEST(strlcpy_3); EXPECT_STRBUFEQ(1, strlcpy(buf, "bar", 3), buf, 3, "ba"); break;
CASE_TEST(strlcpy_4); EXPECT_STRBUFEQ(1, strlcpy(buf, "bar", 4), buf, 3, "bar"); break;
#endif
CASE_TEST(memcmp_20_20); EXPECT_EQ(1, memcmp("aaa\x20", "aaa\x20", 4), 0); break;
CASE_TEST(memcmp_20_60); EXPECT_LT(1, memcmp("aaa\x20", "aaa\x60", 4), 0); break;
CASE_TEST(memcmp_60_20); EXPECT_GT(1, memcmp("aaa\x60", "aaa\x20", 4), 0); break;