Commit 4b768bf0 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'linux_kselftest-nolibc-6.10-rc1' of... 

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()
parents 59010373 0adab2b6

tools/include/nolibc/stdlib.h

+1 −1
Original line number Diff line number Diff line
@@ -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;

}

tools/include/nolibc/string.h

+26 −20
Original line number Diff line number Diff line
@@ -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;

}

tools/include/nolibc/sys.h

+27 −0
Original line number Diff line number Diff line
@@ -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);

 */

tools/testing/selftests/nolibc/nolibc-test.c

+82 −0
Original line number Diff line number Diff line
@@ -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;