Unifying LKL into UML

Quoted 2 lines

make defconfig ARCH=um UMMODE=library
make ARCH=um UMMODE=library

Why not make it a real Kconfig symbol? I find the ARCH=um tricky enough to remember all the time, so much I usually write a "GNUmakefile" with

export ARCH=um
include Makefile

:-)

Quoted 3 lines

+config UMMODE_LIB
+ bool "UML mode: library mode"
+ default y if "$(UMMODE)" = "library"

So wait, you _can_ switch that through Kconfig then, because you made it a visible option (string after "bool"). But it won't work, because then you later in the build system etc. still check UMMODE instead of CONFIG_UMMODE_LIB. Seems like something that ought to be fixed one way or the other - at the very least hide this symbol if setting it manually is invalid.

Quoted 4 lines

+ help
+ This mode switches a mode to build a library of UML (Linux
+ Kernel Library/LKL). This switch is exclusive to "kernel mode"
+ of UML, which is traditional mode of UML.

Not sure if that historically made more sense, but you don't have any UMMODE_KERNEL option or something like that, so the help text seems confusing?

arch/um/Makefile else

Quoted 6 lines

arch/um/Makefile +4 -0

+ifeq ($(UMMODE),library)
+  SUBARCH := um/nommu
+endif
 
 INSTALL_PATH=$(objtree)/tools/um
+ifeq ($(UMMODE),library)

Here a few places using UMMODE which must come from the command line.

Quoted 4 lines

linux.o: vmlinux
@echo ' LINK $@'
- $(Q)$(OBJCOPY) -R .eh_frame $< $@
+ $(Q)$(OBJCOPY) -R .eh_frame -L sem_init -L sem_post -L sem_wait -L sem_destroy $< $@

Care to explain?

Quoted 3 lines

+ select UACCESS_MEMCPY
+ select ARCH_THREAD_STACK_ALLOCATOR
+ select ARCH_HAS_SYSCALL_WRAPPER

You never use this except for the selects, maybe can go elsewhere?

Quoted 19 lines

arch/um/nommu/um/Kconfig new file +19 -0

+config 64BIT
+ bool
+ default y
+
+config GENERIC_CSUM
+ def_bool y
+
+config GENERIC_ATOMIC64
+ bool
+ default y if !64BIT
+
+config SECCOMP
+ bool
+ default n
+
+config GENERIC_HWEIGHT
+ def_bool y
+
+config GENERIC_CALIBRATE_DELAY

arch/um/nommu/um/Kconfig line 32

Quoted 6 lines

+ bool
+ default n

arch/um/nommu/um/Kconfig new file +4 -0

+
+config STACKTRACE_SUPPORT
+ bool
+ default n

You ... were just changing these elsewhere, so one of that isn't needed?

Add basic utility functions for getting a string from a kernel error code and a fprintf like function that uses the host print operation. The latter is useful for informing the user about errors that occur in the host library.

Signed-off-by Hajime Tazaki <[email protected]>

---
  tools/um/lib/Build     |   4 +
  tools/um/lib/jmp_buf.c |  14 +++
  tools/um/lib/jmp_buf.h |   8 ++
  tools/um/lib/utils.c   | 210 +++++++++++++++++++++++++++++++++++++++++
  4 files changed, 236 insertions(+)

create mode 100644 tools/um/lib/Build
create mode 100644 tools/um/lib/jmp_buf.c
create mode 100644 tools/um/lib/jmp_buf.h
create mode 100644 tools/um/lib/utils.c

tools/um/lib/Build new file +4 -0

new file mode 100644
index 000000000000..fc967af4104a
@@ -0,0 +1,4 @@
+include $(objtree)/include/config/auto.conf
+
+liblinux-$(CONFIG_UMMODE_LIB) += utils.o
+liblinux-$(CONFIG_UMMODE_LIB) += jmp_buf.o

tools/um/lib/jmp_buf.c new file +14 -0

new file mode 100644
index 000000000000..f6bdd7e4bd83
@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <setjmp.h>
+#include <lkl_host.h>
+
+void jmp_buf_set(struct lkl_jmp_buf *jmpb, void (*f)(void))
+{
+	if (!setjmp(*((jmp_buf *)jmpb->buf)))
+		f();
+}
+
+void jmp_buf_longjmp(struct lkl_jmp_buf *jmpb, int val)
+{
+	longjmp(*((jmp_buf *)jmpb->buf), val);
+}

tools/um/lib/jmp_buf.h new file +8 -0

new file mode 100644
index 000000000000..8782cbaaf51f
@@ -0,0 +1,8 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _LKL_LIB_JMP_BUF_H
+#define _LKL_LIB_JMP_BUF_H
+
+void jmp_buf_set(struct lkl_jmp_buf *jmpb, void (*f)(void));
+void jmp_buf_longjmp(struct lkl_jmp_buf *jmpb, int val);
+
+#endif

tools/um/lib/utils.c new file +0 -0

new file mode 100644
index 000000000000..4930479a8a35

tools/um/lib/utils.c new file +205 -0

+
+static const char * const lkl_err_strings[] = {
+	"Success",
+	"Operation not permitted",
+	"No such file or directory",
+	"No such process",
+	"Interrupted system call",
+	"I/O error",
+	"No such device or address",
+	"Argument list too long",
+	"Exec format error",
+	"Bad file number",
+	"No child processes",
+	"Try again",
+	"Out of memory",
+	"Permission denied",
+	"Bad address",
+	"Block device required",
+	"Device or resource busy",
+	"File exists",
+	"Cross-device link",
+	"No such device",
+	"Not a directory",
+	"Is a directory",
+	"Invalid argument",
+	"File table overflow",
+	"Too many open files",
+	"Not a typewriter",
+	"Text file busy",
+	"File too large",
+	"No space left on device",
+	"Illegal seek",
+	"Read-only file system",
+	"Too many links",
+	"Broken pipe",
+	"Math argument out of domain of func",
+	"Math result not representable",
+	"Resource deadlock would occur",
+	"File name too long",
+	"No record locks available",
+	"Invalid system call number",
+	"Directory not empty",
+	"Too many symbolic links encountered",
+	"Bad error code", /* EWOULDBLOCK is EAGAIN */
+	"No message of desired type",
+	"Identifier removed",
+	"Channel number out of range",
+	"Level 2 not synchronized",
+	"Level 3 halted",
+	"Level 3 reset",
+	"Link number out of range",
+	"Protocol driver not attached",
+	"No CSI structure available",
+	"Level 2 halted",
+	"Invalid exchange",
+	"Invalid request descriptor",
+	"Exchange full",
+	"No anode",
+	"Invalid request code",
+	"Invalid slot",
+	"Bad error code", /* EDEADLOCK is EDEADLK */
+	"Bad font file format",
+	"Device not a stream",
+	"No data available",
+	"Timer expired",
+	"Out of streams resources",
+	"Machine is not on the network",
+	"Package not installed",
+	"Object is remote",
+	"Link has been severed",
+	"Advertise error",
+	"Srmount error",
+	"Communication error on send",
+	"Protocol error",
+	"Multihop attempted",
+	"RFS specific error",
+	"Not a data message",
+	"Value too large for defined data type",
+	"Name not unique on network",
+	"File descriptor in bad state",
+	"Remote address changed",
+	"Can not access a needed shared library",
+	"Accessing a corrupted shared library",
+	".lib section in a.out corrupted",
+	"Attempting to link in too many shared libraries",
+	"Cannot exec a shared library directly",
+	"Illegal byte sequence",
+	"Interrupted system call should be restarted",
+	"Streams pipe error",
+	"Too many users",
+	"Socket operation on non-socket",
+	"Destination address required",
+	"Message too long",
+	"Protocol wrong type for socket",
+	"Protocol not available",
+	"Protocol not supported",
+	"Socket type not supported",
+	"Operation not supported on transport endpoint",
+	"Protocol family not supported",
+	"Address family not supported by protocol",
+	"Address already in use",
+	"Cannot assign requested address",
+	"Network is down",
+	"Network is unreachable",
+	"Network dropped connection because of reset",
+	"Software caused connection abort",
+	"Connection reset by peer",
+	"No buffer space available",
+	"Transport endpoint is already connected",
+	"Transport endpoint is not connected",
+	"Cannot send after transport endpoint shutdown",
+	"Too many references: cannot splice",
+	"Connection timed out",
+	"Connection refused",
+	"Host is down",
+	"No route to host",
+	"Operation already in progress",
+	"Operation now in progress",
+	"Stale file handle",
+	"Structure needs cleaning",
+	"Not a XENIX named type file",
+	"No XENIX semaphores available",
+	"Is a named type file",
+	"Remote I/O error",
+	"Quota exceeded",
+	"No medium found",
+	"Wrong medium type",
+	"Operation Canceled",
+	"Required key not available",
+	"Key has expired",
+	"Key has been revoked",
+	"Key was rejected by service",
+	"Owner died",
+	"State not recoverable",
+	"Operation not possible due to RF-kill",
+	"Memory page has hardware error",
+};
+
+const char *lkl_strerror(int err)
+{
+	if (err < 0)
+		err = -err;
+
+	if ((size_t)err >= sizeof(lkl_err_strings) / sizeof(const char *))
+		return "Bad error code";
+
+	return lkl_err_strings[err];
+}
+
+void lkl_perror(char *msg, int err)
+{
+	const char *err_msg = lkl_strerror(err);
+	/* We need to use 'real' printf because lkl_host_ops.print can
+	 * be turned off when debugging is off.
+	 */
+	lkl_printf("%s: %s\n", msg, err_msg);
+}
+
+static int lkl_vprintf(const char *fmt, va_list args)
+{
+	int n;
+	char *buffer;
+	va_list copy;
+
+	if (!lkl_host_ops.print)
+		return 0;
+
+	va_copy(copy, args);
+	n = vsnprintf(NULL, 0, fmt, copy);
+	va_end(copy);
+
+	buffer = lkl_host_ops.mem_alloc(n + 1);
+	if (!buffer)
+		return (-1);
+
+	vsnprintf(buffer, n + 1, fmt, args);
+
+	lkl_host_ops.print(buffer, n);
+	lkl_host_ops.mem_free(buffer);
+
+	return n;
+}
+
+int lkl_printf(const char *fmt, ...)
+{
+	int n;
+	va_list args;
+
+	va_start(args, fmt);
+	n = lkl_vprintf(fmt, args);
+	va_end(args);
+
+	return n;
+}
+
+void lkl_bug(const char *fmt, ...)
+{
+	va_list args;
+
+	va_start(args, fmt);
+	lkl_vprintf(fmt, args);
+	va_end(args);
+
+	lkl_host_ops.panic();
+}

These are actually different on different architectures. These look like the x86 values.

IMHO a kernel strerror() would be the right way of dealing with this in the long term (i understand that we cannot call the platform one, because it may be different from the internal Linux errors). It will be useful in a lot of other places.

If we leave it as is, we need to make this arch specific at some point.

tools/um/lib/utils.c line 9

Quoted 4 lines

tools/um/lib/utils.c new file +4 -0

+
+static const char * const lkl_err_strings[] = {
+	"Success",
+	"Operation not permitted",

Quoted 8 lines · Anton Ivanov

These are actually different on different architectures. These look like the x86 values.

IMHO a kernel strerror() would be the right way of dealing with this in the long term (i understand that we cannot call the platform one, because it may be different from the internal Linux errors). It will be useful in a lot of other places.

Quoted 7 lines

If we leave it as is, we need to make this arch specific at some point.

tools/um/lib/utils.c line 9

Quoted 4 lines

tools/um/lib/utils.c new file +4 -0

+
+static const char * const lkl_err_strings[] = {
+	"Success",
+	"Operation not permitted",

Might be possible to more or less address this (except for arch-specific errors that don't always exist) but using C99 initializers?

[0] = "Success",
[EPERM] = "Operation not permitted",
..

Quoted 19 lines · Johannes Berg

Quoted 8 lines · Anton Ivanov

These are actually different on different architectures. These look like the x86 values.

IMHO a kernel strerror() would be the right way of dealing with this in the long term (i understand that we cannot call the platform one, because it may be different from the internal Linux errors). It will be useful in a lot of other places.

Quoted 7 lines

If we leave it as is, we need to make this arch specific at some point.

tools/um/lib/utils.c line 9

Quoted 4 lines

tools/um/lib/utils.c new file +4 -0

+
+static const char * const lkl_err_strings[] = {
+	"Success",
+	"Operation not permitted",

Might be possible to more or less address this (except for arch-specific errors that don't always exist) but using C99 initializers?

Quoted 3 lines

[0] = "Success",
[EPERM] = "Operation not permitted",
..

But, on the other hand, is it needed at all? I don't think the kernel ever prints out the actual string ...

johannes

_______________________________________________
linux-um mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-um

Quoted 4 lines · Johannes Berg

Quoted 3 lines · Johannes Berg

Quoted 2 lines · Anton Ivanov

These are actually different on different architectures. These look like the x86 values.

Quoted 7 lines

Quoted 7 lines

Quoted 7 lines

IMHO a kernel strerror() would be the right way of dealing with this in the long term (i understand that we cannot call the platform one, because it may be different from the internal Linux errors). It will be useful in a lot of other places.

If we leave it as is, we need to make this arch specific at some point.

Quoted 10 lines

Quoted 10 lines

Quoted 4 lines

tools/um/lib/utils.c line 9

Quoted 4 lines

tools/um/lib/utils.c new file +4 -0

+
+static const char * const lkl_err_strings[] = {
+	"Success",
+	"Operation not permitted",

Might be possible to more or less address this (except for arch-specific errors that don't always exist) but using C99 initializers?

[0] = "Success",
[EPERM] = "Operation not permitted",
..

Quoted 2 lines

But, on the other hand, is it needed at all? I don't think the kernel ever prints out the actual string ...

I can see the use case for a library in a multi-arch environment (which IMHO is the intended use case). It saves the user the effort of digging into the build and figuring out what does this error mean today :)

It is nice to have :)

If we will have it, however, it should be done as you suggested - C99 or some other way where it maps correctly to actual underlying error codes as they may end up being different depending on build config.

Quoted 7 lines · Anton Ivanov

Quoted 4 lines · Johannes Berg

Quoted 3 lines · Johannes Berg

Quoted 2 lines · Anton Ivanov

These are actually different on different architectures. These look like the x86 values.

Those variables are based on tools/um/include/lkl/asm-generic/errno.h, which is generated from include/uapi/asm-generic/errno.h, which LKL kernel eats for its values.

This is the part of patch 12/21.

Quoted 5 lines

Quoted 5 lines

Quoted 5 lines

Quoted 5 lines

IMHO a kernel strerror() would be the right way of dealing with this in the long term (i understand that we cannot call the platform one, because it may be different from the internal Linux errors). It will be useful in a lot of other places.

Quoted 2 lines

Quoted 2 lines

Quoted 2 lines

Quoted 2 lines

If we leave it as is, we need to make this arch specific at some point.

So, this particular code does not contain arch specific part I believe.
# Tavi, correct me if I'm wrong.

Quoted 4 lines · Johannes Berg

Quoted 3 lines · Johannes Berg

Quoted 2 lines · Anton Ivanov

These are actually different on different architectures. These look like the x86 values.

Quoted 7 lines

Quoted 7 lines

Quoted 7 lines

IMHO a kernel strerror() would be the right way of dealing with this in the long term (i understand that we cannot call the platform one, because it may be different from the internal Linux errors). It will be useful in a lot of other places.

If we leave it as is, we need to make this arch specific at some point.

Quoted 10 lines

Quoted 10 lines

Quoted 4 lines

tools/um/lib/utils.c line 9

Quoted 4 lines

tools/um/lib/utils.c new file +4 -0

+
+static const char * const lkl_err_strings[] = {
+	"Success",
+	"Operation not permitted",

Might be possible to more or less address this (except for arch-specific errors that don't always exist) but using C99 initializers?

[0] = "Success",
[EPERM] = "Operation not permitted",
..

Quoted 2 lines

But, on the other hand, is it needed at all? I don't think the kernel ever prints out the actual string ...

I can see the use case for a library in a multi-arch environment (which IMHO is the intended use case). It saves the user the effort of digging into the build and figuring out what does this error mean today :)

It is nice to have :)

If we will have it, however, it should be done as you suggested - C99 or some other way where it maps correctly to actual underlying error codes as they may end up being different depending on build config.

+LKL_TEST_CALL(getpid, lkl_sys_getpid, 1)

+++ b/tools/um/tests/run.py

tools/um/tests/run.py new file +7 -0

@@ -0,0 +1,172 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: GPL-2.0
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License
+#

Quoted 2 lines · Hajime Tazaki

+LKL_TEST_CALL(getpid, lkl_sys_getpid, 1)

Could that be unified with KUNIT somehow?

Quoted 9 lines

+++ b/tools/um/tests/run.py

tools/um/tests/run.py new file +7 -0

@@ -0,0 +1,172 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: GPL-2.0
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License
+#

tools/um/tests/run.py line 17

Quoted 10 lines

tools/um/tests/run.py new file +10 -0

+# Author: Octavian Purdila <[email protected]>
+#
+
+from __future__ import print_function
+
+import argparse
+import os
+import subprocess
+import sys
+import tap13

ok, I see now, you're doing something with TAP (test anything protocol)...

Hmm. I must say I'm not a fan of adding a whole testing framework to the kernel like that, even if it's pretty simple.

tools/um/tests/run.py line 20

Quoted 3 lines

tools/um/tests/run.py new file +3 -0

+import xml.etree.ElementTree as ET
+
+from junit_xml import TestSuite, TestCase

yuck

Let's see if you can use KUNIT instead. Anything beyond that doesn't really need to live in the kernel, IMHO.

This commit adds block device support for nommu mode, and also added several host utilities to run a simple test program (tools/um/test/disk.c) successfully.

Signed-off-by Hajime Tazaki <[email protected]>

---
  arch/um/include/asm/xor.h                 |   3 +-
  arch/um/include/shared/as-layout.h        |   1 +
  arch/um/kernel/um_arch.c                  |   5 +
  arch/um/nommu/include/uapi/asm/host_ops.h |   7 +
  arch/um/nommu/include/uapi/asm/unistd.h   |   2 +
  arch/um/nommu/um/Kconfig                  |   8 +
  arch/um/nommu/um/setup.c                  |  12 +
  tools/um/Targets                          |   2 +
  tools/um/include/lkl.h                    | 206 ++++++++++
  tools/um/include/lkl_host.h               |   1 +
  tools/um/lib/Build                        |   1 +
  tools/um/lib/fs.c                         | 461 ++++++++++++++++++++++
  tools/um/lib/posix-host.c                 |   1 +
  tools/um/lib/utils.c                      |   3 +
  tools/um/tests/Build                      |   1 +
  tools/um/tests/cla.c                      | 159 ++++++++
  tools/um/tests/cla.h                      |  33 ++
  tools/um/tests/disk.c                     | 168 ++++++++
  tools/um/tests/disk.sh                    |  70 ++++
  tools/um/tests/run.py                     |   2 +
  20 files changed, 1145 insertions(+), 1 deletion(-)

create mode 100644 tools/um/lib/fs.c
create mode 100644 tools/um/tests/cla.c
create mode 100644 tools/um/tests/cla.h
create mode 100644 tools/um/tests/disk.c
create mode 100755 tools/um/tests/disk.sh

arch/um/include/asm/xor.h +2 -1

index 36b33d62a35d..a5ea458a1ae9 100644
@@ -4,4 +4,5 @@
 
  /* pick an arbitrary one - measuring isn't possible with inf-cpu */
  #define XOR_SELECT_TEMPLATE(x)	\
-	(time_travel_mode == TT_MODE_INFCPU ? &xor_block_8regs : NULL)
+	(time_travel_mode == TT_MODE_INFCPU || (!IS_ENABLED(CONFIG_MMU)) ? \
+	 &xor_block_8regs : NULL)

arch/um/include/shared/as-layout.h +1 -0

index 5f286ef2721b..4423437a5ace 100644
@@ -57,6 +57,7 @@ extern unsigned long host_task_size;
 
  extern int linux_main(int argc, char **argv);
  extern void uml_finishsetup(void);
+extern void uml_set_args(char *args);
 
  struct siginfo;
  extern void (*sig_info[])(int, struct siginfo *si, struct uml_pt_regs *);

arch/um/kernel/um_arch.c +5 -0

index e2cb76c03b25..da6e06cf2808 100644
@@ -41,6 +41,11 @@ static void __init add_arg(char *arg)
  	strcat(command_line, arg);
  }
 
+void __init uml_set_args(char *args)
+{
+	strcat(command_line, args);
+}
+
  /*
   * These fields are initialized at boot time and not changed.
   * XXX This structure is used only in the non-SMP case.  Maybe this

arch/um/nommu/include/uapi/asm/host_ops.h +7 -0

index 0811494c080c..1b2507502969 100644
@@ -15,6 +15,11 @@ struct lkl_jmp_buf {
   *
   * These operations must be provided by a host library or by the application
   * itself.
+ *
+ * @um_devices - string containg the list of UML devices in command line
+ * format. This string is appended to the kernel command line and
+ * is provided here for convenience to be implemented by the host library.
+ *
   * @print - optional operation that receives console messages
   * @panic - called during a kernel panic
   *

@@ -65,6 +70,8 @@ struct lkl_jmp_buf {
   *
   */
  struct lkl_host_operations {
+	const char *um_devices;
+
  	void (*print)(const char *str, int len);
  	void (*panic)(void);
 

arch/um/nommu/include/uapi/asm/unistd.h +2 -0

index 1762ebb829f5..320762099a62 100644
@@ -3,6 +3,8 @@
  #define __UM_NOMMU_UAPI_UNISTD_H
 
  #define __ARCH_WANT_NEW_STAT
+#define __ARCH_WANT_SET_GET_RLIMIT
+
  #include <asm/bitsperlong.h>
 
  #if __BITS_PER_LONG == 64

arch/um/nommu/um/Kconfig +4 -0

index 20b3eaccb6f0..c6a3f472fe75 100644
@@ -4,6 +4,10 @@ config UML_NOMMU
  	select UACCESS_MEMCPY
  	select ARCH_THREAD_STACK_ALLOCATOR
  	select ARCH_HAS_SYSCALL_WRAPPER
+	select VFAT_FS
+	select NLS_CODEPAGE_437
+	select NLS_ISO8859_1
+	select BTRFS_FS
 
  config 64BIT
  	bool

arch/um/nommu/um/setup.c +12 -0

index 922188690139..d71d61979ad6 100644
@@ -45,13 +45,25 @@ static void __init *lkl_run_kernel(void *arg)
  	return NULL;
  }
 
+static char _cmd_line[COMMAND_LINE_SIZE];
  int __init lkl_start_kernel(struct lkl_host_operations *ops,
  			    const char *fmt, ...)
  {
+	va_list ap;
  	int ret;
 
  	lkl_ops = ops;
 
+	va_start(ap, fmt);
+	ret = vsnprintf(_cmd_line, COMMAND_LINE_SIZE, fmt, ap);
+	va_end(ap);
+
+	if (ops->um_devices)
+		strscpy(_cmd_line + ret, ops->um_devices,
+			COMMAND_LINE_SIZE - ret);
+
+	uml_set_args(_cmd_line);
+
  	init_sem = lkl_ops->sem_alloc(0);
  	if (!init_sem)
  		return -ENOMEM;

tools/um/Targets +2 -0

index 2bb90381843c..f5f8ec4b9dbb 100644
@@ -1,10 +1,12 @@
  ifeq ($(UMMODE),library)
  progs-y += tests/boot
+progs-y += tests/disk
  else
  progs-y += uml/linux
  endif
 
  LDFLAGS_boot-y := -pie
+LDFLAGS_disk-y := -pie
 
  LDLIBS := -lrt -lpthread -lutil
  LDFLAGS_linux-y := -no-pie -Wl,--wrap,malloc -Wl,--wrap,free -Wl,--wrap,calloc

tools/um/include/lkl.h +206 -0

index 707e01b64a70..4a9d874bfbf0 100644
@@ -113,6 +113,16 @@ static inline long lkl_sys_creat(const char *file, int mode)
  }
  #endif
 
+#ifdef __lkl__NR_faccessat
+/**
+ * lkl_sys_access - wrapper for lkl_sys_faccessat
+ */
+static inline long lkl_sys_access(const char *file, int mode)
+{
+	return lkl_sys_faccessat(LKL_AT_FDCWD, file, mode);
+}
+#endif
+
  #ifdef __lkl__NR_mkdirat
  /**
   * lkl_sys_mkdir - wrapper for lkl_sys_mkdirat

@@ -123,6 +133,36 @@ static inline long lkl_sys_mkdir(const char *path, mode_t mode)
  }
  #endif
 
+#ifdef __lkl__NR_unlinkat
+/**
+ * lkl_sys_rmdir - wrapper for lkl_sys_unlinkrat
+ */
+static inline long lkl_sys_rmdir(const char *path)
+{
+	return lkl_sys_unlinkat(LKL_AT_FDCWD, path, LKL_AT_REMOVEDIR);
+}
+#endif
+
+#ifdef __lkl__NR_unlinkat
+/**
+ * lkl_sys_unlink - wrapper for lkl_sys_unlinkat
+ */
+static inline long lkl_sys_unlink(const char *path)
+{
+	return lkl_sys_unlinkat(LKL_AT_FDCWD, path, 0);
+}
+#endif
+
+#ifdef __lkl__NR_mknodat
+/**
+ * lkl_sys_mknod - wrapper for lkl_sys_mknodat
+ */
+static inline long lkl_sys_mknod(const char *path, mode_t mode, dev_t dev)
+{
+	return lkl_sys_mknodat(LKL_AT_FDCWD, path, mode, dev);
+}
+#endif
+
  #ifdef __lkl__NR_epoll_create1
  /**
   * lkl_sys_epoll_create - wrapper for lkl_sys_epoll_create1

@@ -144,6 +184,172 @@ static inline long lkl_sys_epoll_wait(int fd, struct lkl_epoll_event *ev,
  }
  #endif
 
+/**
+ * struct lkl_dev_blk_ops - block device host operations, defined in lkl_host.h.
+ */
+struct lkl_dev_blk_ops;
+
+/**
+ * lkl_disk - host disk handle
+ *
+ * @dev - a pointer to private information for this disk backend
+ * @fd - a POSIX file descriptor that can be used by preadv/pwritev
+ * @handle - an NT file handle that can be used by ReadFile/WriteFile
+ */
+struct lkl_disk {
+	void *dev;
+	union {
+		int fd;
+		void *handle;
+	};
+	struct lkl_dev_blk_ops *ops;
+};
+
+/**
+ * lkl_disk_add - add a new disk
+ *
+ * @disk - the host disk handle
+ * @returns a disk id (0 is valid) or a strictly negative value in case of error
+ */
+int lkl_disk_add(struct lkl_disk *disk);
+
+/**
+ * lkl_disk_remove - remove a disk
+ *
+ * This function makes a cleanup of the @disk's private information
+ * that was initialized by lkl_disk_add before.
+ *
+ * @disk - the host disk handle
+ */
+int lkl_disk_remove(struct lkl_disk disk);
+
+/**
+ * lkl_encode_dev_from_sysfs_blkdev - extract device id from sysfs
+ *
+ * This function returns the device id for the given sysfs dev node.
+ * The content of the node has to be in the form 'MAJOR:MINOR'.
+ * Also, this function expects an absolute path which means that sysfs
+ * already has to be mounted at the given path
+ *
+ * @sysfs_path - absolute path to the sysfs dev node
+ * @pdevid - pointer to memory where dev id will be returned
+ * @returns - 0 on success, a negative value on error
+ */
+int lkl_encode_dev_from_sysfs(const char *sysfs_path, uint32_t *pdevid);
+
+/**
+ * lkl_mount_dev - mount a disk
+ *
+ * This functions creates a device file for the given disk, creates a mount
+ * point and mounts the device over the mount point.
+ *
+ * @disk_id - the disk id identifying the disk to be mounted
+ * @part - disk partition or zero for full disk
+ * @fs_type - filesystem type
+ * @flags - mount flags
+ * @opts - additional filesystem specific mount options
+ * @mnt_str - a string that will be filled by this function with the path where
+ * the filesystem has been mounted
+ * @mnt_str_len - size of mnt_str
+ * @returns - 0 on success, a negative value on error
+ */
+long lkl_mount_dev(unsigned int disk_id, unsigned int part, const char *fs_type,
+		   int flags, const char *opts,
+		   char *mnt_str, unsigned int mnt_str_len);
+
+/**
+ * lkl_umount_dev - umount a disk
+ *
+ * This functions umounts the given disks and removes the device file and the
+ * mount point.
+ *
+ * @disk_id - the disk id identifying the disk to be mounted
+ * @part - disk partition or zero for full disk
+ * @flags - umount flags
+ * @timeout_ms - timeout to wait for the kernel to flush closed files so that
+ * umount can succeed
+ * @returns - 0 on success, a negative value on error
+ */
+long lkl_umount_dev(unsigned int disk_id, unsigned int part, int flags,
+		    long timeout_ms);
+
+/**
+ * lkl_umount_timeout - umount filesystem with timeout
+ *
+ * @path - the path to unmount
+ * @flags - umount flags
+ * @timeout_ms - timeout to wait for the kernel to flush closed files so that
+ * umount can succeed
+ * @returns - 0 on success, a negative value on error
+ */
+long lkl_umount_timeout(char *path, int flags, long timeout_ms);
+
+/**
+ * lkl_opendir - open a directory
+ *
+ * @path - directory path
+ * @err - pointer to store the error in case of failure
+ * @returns - a handle to be used when calling lkl_readdir
+ */
+struct lkl_dir *lkl_opendir(const char *path, int *err);
+
+/**
+ * lkl_fdopendir - open a directory
+ *
+ * @fd - file descriptor
+ * @err - pointer to store the error in case of failure
+ * @returns - a handle to be used when calling lkl_readdir
+ */
+struct lkl_dir *lkl_fdopendir(int fd, int *err);
+
+/**
+ * lkl_rewinddir - reset directory stream
+ *
+ * @dir - the directory handler as returned by lkl_opendir
+ */
+void lkl_rewinddir(struct lkl_dir *dir);
+
+/**
+ * lkl_closedir - close the directory
+ *
+ * @dir - the directory handler as returned by lkl_opendir
+ */
+int lkl_closedir(struct lkl_dir *dir);
+
+/**
+ * lkl_readdir - get the next available entry of the directory
+ *
+ * @dir - the directory handler as returned by lkl_opendir
+ * @returns - a lkl_dirent64 entry or NULL if the end of the directory stream is
+ * reached or if an error occurred; check lkl_errdir() to distinguish between
+ * errors or end of the directory stream
+ */
+struct lkl_linux_dirent64 *lkl_readdir(struct lkl_dir *dir);
+
+/**
+ * lkl_errdir - checks if an error occurred during the last lkl_readdir call
+ *
+ * @dir - the directory handler as returned by lkl_opendir
+ * @returns - 0 if no error occurred, or a negative value otherwise
+ */
+int lkl_errdir(struct lkl_dir *dir);
+
+/**
+ * lkl_dirfd - gets the file descriptor associated with the directory handle
+ *
+ * @dir - the directory handle as returned by lkl_opendir
+ * @returns - a positive value,which is the LKL file descriptor associated with
+ * the directory handle, or a negative value otherwise
+ */
+int lkl_dirfd(struct lkl_dir *dir);
+
+/**
+ * lkl_mount_fs - mount a file system type like proc, sys
+ * @fstype - file system type. e.g. proc, sys
+ * @returns - 0 on success. 1 if it's already mounted. negative on failure.
+ */
+int lkl_mount_fs(char *fstype);
+
  #ifdef __cplusplus
  }
  #endif

tools/um/include/lkl_host.h +1 -0

index 85e80eb4ad0d..12dd95616e43 100644
@@ -10,6 +10,7 @@ extern "C" {
  #include <lkl.h>
 
  extern struct lkl_host_operations lkl_host_ops;
+extern char lkl_um_devs[4096];
 
  /**
   * lkl_printf - print a message via the host print operation

tools/um/lib/Build +1 -0

index dddff26a3b4e..29491b40746c 100644
@@ -4,3 +4,4 @@ CFLAGS_posix-host.o += -D_FILE_OFFSET_BITS=64
  liblinux-$(CONFIG_UMMODE_LIB) += utils.o
  liblinux-$(CONFIG_UMMODE_LIB) += posix-host.o
  liblinux-$(CONFIG_UMMODE_LIB) += jmp_buf.o
+liblinux-$(CONFIG_UMMODE_LIB) += fs.o

tools/um/lib/fs.c new file +461 -0

new file mode 100644
index 000000000000..948aac9730c2
@@ -0,0 +1,461 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <lkl_host.h>
+
+#define MAX_FSTYPE_LEN 50
+
+static struct lkl_disk *lkl_disks[16];
+static int registered_blk_dev_idx;
+
+static int lkl_disk_um_add(struct lkl_disk *disk, const char *blkparams)
+{
+	/* concat strings */
+	snprintf(lkl_um_devs + strlen(lkl_um_devs), sizeof(lkl_um_devs),
+		 " ubd%d=%s", registered_blk_dev_idx, blkparams);
+
+	return registered_blk_dev_idx++;
+}
+
+int lkl_disk_add(struct lkl_disk *disk)
+{
+	int ret = -1;
+
+	ret = lkl_disk_um_add(disk, disk->dev);
+
+	lkl_disks[ret] = disk;
+
+	return ret;
+}
+
+int lkl_disk_remove(struct lkl_disk disk)
+{
+	/* FIXME */
+	return 0;
+}
+
+int lkl_mount_fs(char *fstype)
+{
+	char dir[MAX_FSTYPE_LEN+2] = "/";
+	int flags = 0, ret = 0;
+
+	strncat(dir, fstype, MAX_FSTYPE_LEN);
+
+	/* Create with regular umask */
+	ret = lkl_sys_mkdir(dir, 0xff);
+	if (ret && ret != -LKL_EEXIST) {
+		lkl_perror("mount_fs mkdir", ret);
+		return ret;
+	}
+
+	/* We have no use for nonzero flags right now */
+	ret = lkl_sys_mount("none", dir, fstype, flags, NULL);
+	if (ret && ret != -LKL_EBUSY) {
+		lkl_sys_rmdir(dir);
+		return ret;
+	}
+
+	if (ret == -LKL_EBUSY)
+		return 1;
+	return 0;
+}
+
+static uint32_t new_encode_dev(unsigned int major, unsigned int minor)
+{
+	return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);
+}
+
+static int startswith(const char *str, const char *pre)
+{
+	return strncmp(pre, str, strlen(pre)) == 0;
+}
+
+static int get_node_with_prefix(const char *path, const char *prefix,
+				char *result, unsigned int result_len)
+{
+	struct lkl_dir *dir = NULL;
+	struct lkl_linux_dirent64 *dirent;
+	int ret;
+
+	dir = lkl_opendir(path, &ret);
+	if (!dir)
+		return ret;
+
+	ret = -LKL_ENOENT;
+
+	while ((dirent = lkl_readdir(dir))) {
+		if (startswith(dirent->d_name, prefix)) {
+			if (strlen(dirent->d_name) + 1 > result_len) {
+				ret = -LKL_ENOMEM;
+				break;
+			}
+			memcpy(result, dirent->d_name, strlen(dirent->d_name));
+			result[strlen(dirent->d_name)] = '\0';
+			ret = 0;
+			break;
+		}
+	}
+
+	lkl_closedir(dir);
+
+	return ret;
+}
+
+int lkl_encode_dev_from_sysfs(const char *sysfs_path, uint32_t *pdevid)
+{
+	int ret;
+	long fd;
+	int major, minor;
+	char buf[16] = { 0, };
+	char *bufptr;
+
+	fd = lkl_sys_open(sysfs_path, LKL_O_RDONLY, 0);
+	if (fd < 0)
+		return fd;
+
+	ret = lkl_sys_read(fd, buf, sizeof(buf));
+	if (ret < 0)
+		goto out_close;
+
+	if (ret == sizeof(buf)) {
+		ret = -LKL_ENOBUFS;
+		goto out_close;
+	}
+
+	bufptr = strchr(buf, ':');
+	if (bufptr == NULL) {
+		ret = -LKL_EINVAL;
+		goto out_close;
+	}
+	bufptr[0] = '\0';
+	bufptr++;
+
+	major = atoi(buf);
+	minor = atoi(bufptr);
+
+	*pdevid = new_encode_dev(major, minor);
+	ret = 0;
+
+out_close:
+	lkl_sys_close(fd);
+
+	return ret;
+}
+
+#define SYSFS_DEV_UMBLK_CMDLINE_PATH \
+	"/sysfs/devices/platform/uml-blkdev.%d"
+
+struct abuf {
+	char *mem, *ptr;
+	unsigned int len;
+};
+
+static int snprintf_append(struct abuf *buf, const char *fmt, ...)
+{
+	int ret;
+	va_list args;
+
+	if (!buf->ptr)
+		buf->ptr = buf->mem;
+
+	va_start(args, fmt);
+	ret = vsnprintf(buf->ptr, buf->len - (buf->ptr - buf->mem), fmt, args);
+	va_end(args);
+
+	if (ret < 0 || (ret >= (int)(buf->len - (buf->ptr - buf->mem))))
+		return -LKL_ENOMEM;
+
+	buf->ptr += ret;
+
+	return 0;
+}
+
+static int __lkl_get_blkdev(int disk_id, unsigned int part, uint32_t *pdevid,
+			    const char *sysfs_path_fmt, const char *drv_prefix,
+			    const char *disk_prefix)
+{
+	char sysfs_path[LKL_PATH_MAX];
+	char drv_name[LKL_PATH_MAX];
+	char disk_name[LKL_PATH_MAX];
+	struct abuf sysfs_path_buf = {
+		.mem = sysfs_path,
+		.len = sizeof(sysfs_path),
+	};
+	int ret;
+
+	if (disk_id < 0)
+		return -LKL_EINVAL;
+
+	ret = lkl_mount_fs("sysfs");
+	if (ret < 0)
+		return ret;
+
+	ret = snprintf_append(&sysfs_path_buf, sysfs_path_fmt, disk_id);
+	if (ret)
+		return ret;
+
+	ret = get_node_with_prefix(sysfs_path, drv_prefix, drv_name,
+				   sizeof(drv_name));
+	if (ret)
+		return ret;
+
+	ret = snprintf_append(&sysfs_path_buf, "/%s/block", drv_name);
+	if (ret)
+		return ret;
+
+	ret = get_node_with_prefix(sysfs_path, disk_prefix, disk_name,
+				   sizeof(disk_name));
+	if (ret)
+		return ret;
+
+	if (!part)
+		ret = snprintf_append(&sysfs_path_buf, "/%s/dev", disk_name);
+	else
+		ret = snprintf_append(&sysfs_path_buf, "/%s/%s%d/dev",
+				      disk_name, disk_name, part);
+	if (ret)
+		return ret;
+
+	return lkl_encode_dev_from_sysfs(sysfs_path, pdevid);
+}
+
+int lkl_get_blkdev(int disk_id, unsigned int part, uint32_t *pdevid)
+{
+	char *fmt;
+
+	fmt = SYSFS_DEV_UMBLK_CMDLINE_PATH;
+	return __lkl_get_blkdev(disk_id, part, pdevid, fmt, "", "ubd");
+}
+
+long lkl_mount_dev(unsigned int disk_id, unsigned int part,
+		   const char *fs_type, int flags,
+		   const char *data, char *mnt_str, unsigned int mnt_str_len)
+{
+	char dev_str[] = { "/dev/xxxxxxxx" };
+	unsigned int dev;
+	int err;
+	char _data[4096]; /* FIXME: PAGE_SIZE is not exported by LKL */
+
+	if (mnt_str_len < sizeof(dev_str))
+		return -LKL_ENOMEM;
+
+	err = lkl_get_blkdev(disk_id, part, &dev);
+	if (err < 0)
+		return err;
+
+	snprintf(dev_str, sizeof(dev_str), "/dev/%08x", dev);
+	snprintf(mnt_str, mnt_str_len, "/mnt/%08x", dev);
+
+	err = lkl_sys_access("/dev", LKL_S_IRWXO);
+	if (err < 0) {
+		if (err == -LKL_ENOENT)
+			err = lkl_sys_mkdir("/dev", 0700);
+		if (err < 0)
+			return err;
+	}
+
+	err = lkl_sys_mknod(dev_str, LKL_S_IFBLK | 0600, dev);
+	if (err < 0)
+		return err;
+
+	err = lkl_sys_access("/mnt", LKL_S_IRWXO);
+	if (err < 0) {
+		if (err == -LKL_ENOENT)
+			err = lkl_sys_mkdir("/mnt", 0700);
+		if (err < 0)
+			return err;
+	}
+
+	err = lkl_sys_mkdir(mnt_str, 0700);
+	if (err < 0) {
+		lkl_sys_unlink(dev_str);
+		return err;
+	}
+
+	/* kernel always copies a full page */
+	if (data) {
+		strncpy(_data, data, sizeof(_data));
+		_data[sizeof(_data) - 1] = 0;
+	} else {
+		_data[0] = 0;
+	}
+
+	err = lkl_sys_mount(dev_str, mnt_str, (char *)fs_type, flags, _data);
+	if (err < 0) {
+		lkl_sys_unlink(dev_str);
+		lkl_sys_rmdir(mnt_str);
+		return err;
+	}
+
+	return 0;
+}
+
+long lkl_umount_timeout(char *path, int flags, long timeout_ms)
+{
+	long incr = 10000000; /* 10 ms */
+	struct lkl_timespec ts = {
+		.tv_sec = 0,
+		.tv_nsec = incr,
+	};
+	long err;
+
+	do {
+		err = lkl_sys_umount(path, flags);
+		if (err == -LKL_EBUSY) {
+			lkl_sys_nanosleep((struct __lkl__kernel_timespec *)&ts,
+					  NULL);
+			timeout_ms -= incr / 1000000;
+		}
+	} while (err == -LKL_EBUSY && timeout_ms > 0);
+
+	return err;
+}
+
+long lkl_umount_dev(unsigned int disk_id, unsigned int part, int flags,
+		    long timeout_ms)
+{
+	char dev_str[] = { "/dev/xxxxxxxx" };
+	char mnt_str[] = { "/mnt/xxxxxxxx" };
+	unsigned int dev;
+	int err;
+
+	err = lkl_get_blkdev(disk_id, part, &dev);
+	if (err < 0)
+		return err;
+
+	snprintf(dev_str, sizeof(dev_str), "/dev/%08x", dev);
+	snprintf(mnt_str, sizeof(mnt_str), "/mnt/%08x", dev);
+
+	err = lkl_umount_timeout(mnt_str, flags, timeout_ms);
+	if (err)
+		return err;
+
+	err = lkl_sys_unlink(dev_str);
+	if (err)
+		return err;
+
+	return lkl_sys_rmdir(mnt_str);
+}
+
+struct lkl_dir {
+	int fd;
+	char buf[1024];
+	char *pos;
+	int len;
+};
+
+static struct lkl_dir *lkl_dir_alloc(int *err)
+{
+	struct lkl_dir *dir = lkl_host_ops.mem_alloc(sizeof(struct lkl_dir));
+
+	if (!dir) {
+		*err = -LKL_ENOMEM;
+		return NULL;
+	}
+
+	dir->len = 0;
+	dir->pos = NULL;
+
+	return dir;
+}
+
+struct lkl_dir *lkl_opendir(const char *path, int *err)
+{
+	struct lkl_dir *dir = lkl_dir_alloc(err);
+
+	if (!dir) {
+		*err = -LKL_ENOMEM;
+		return NULL;
+	}
+
+	dir->fd = lkl_sys_open(path, LKL_O_RDONLY | LKL_O_DIRECTORY, 0);
+	if (dir->fd < 0) {
+		*err = dir->fd;
+		lkl_host_ops.mem_free(dir);
+		return NULL;
+	}
+
+	*err = 0;
+
+	return dir;
+}
+
+struct lkl_dir *lkl_fdopendir(int fd, int *err)
+{
+	struct lkl_dir *dir = lkl_dir_alloc(err);
+
+	if (!dir)
+		return NULL;
+
+	dir->fd = fd;
+
+	return dir;
+}
+
+void lkl_rewinddir(struct lkl_dir *dir)
+{
+	lkl_sys_lseek(dir->fd, 0, LKL_SEEK_SET);
+	dir->len = 0;
+	dir->pos = NULL;
+}
+
+int lkl_closedir(struct lkl_dir *dir)
+{
+	int ret;
+
+	ret = lkl_sys_close(dir->fd);
+	lkl_host_ops.mem_free(dir);
+
+	return ret;
+}
+
+struct lkl_linux_dirent64 *lkl_readdir(struct lkl_dir *dir)
+{
+	struct lkl_linux_dirent64 *de;
+
+	if (dir->len < 0)
+		return NULL;
+
+	if (!dir->pos || dir->pos - dir->buf >= dir->len)
+		goto read_buf;
+
+return_de:
+	de = (struct lkl_linux_dirent64 *)dir->pos;
+	dir->pos += de->d_reclen;
+
+	return de;
+
+read_buf:
+	dir->pos = NULL;
+	de = (struct lkl_linux_dirent64 *)dir->buf;
+	dir->len = lkl_sys_getdents64(dir->fd, de, sizeof(dir->buf));
+	if (dir->len <= 0)
+		return NULL;
+
+	dir->pos = dir->buf;
+	goto return_de;
+}
+
+int lkl_errdir(struct lkl_dir *dir)
+{
+	if (dir->len >= 0)
+		return 0;
+
+	return dir->len;
+}
+
+int lkl_dirfd(struct lkl_dir *dir)
+{
+	return dir->fd;
+}
+
+int lkl_set_fd_limit(unsigned int fd_limit)
+{
+	struct lkl_rlimit rlim = {
+		.rlim_cur = fd_limit,
+		.rlim_max = fd_limit,
+	};
+	return lkl_sys_setrlimit(LKL_RLIMIT_NOFILE, &rlim);
+}

tools/um/lib/posix-host.c +1 -0

index b6b5b2902254..8fd88031bf2b 100644
@@ -263,6 +263,7 @@ static void *tls_get(struct lkl_tls_key *key)
  }
 
  struct lkl_host_operations lkl_host_ops = {
+	.um_devices = lkl_um_devs,
  	.panic = panic,
  	.print = print,
  	.mem_alloc = (void *)malloc,

tools/um/lib/utils.c +3 -0

index 4930479a8a35..ac65cd744a14 100644
@@ -4,6 +4,9 @@
  #include <string.h>
  #include <lkl_host.h>
 
+/* XXX: find a better place */
+char lkl_um_devs[4096];
+
  static const char * const lkl_err_strings[] = {
  	"Success",
  	"Operation not permitted",

tools/um/tests/Build +1 -0

index 564560486f98..1aa78f9ed7ef 100644
@@ -1,3 +1,4 @@
  boot-y += boot.o test.o
+disk-y += disk.o test.o cla.o
 
  CFLAGS_test.o += -Wno-implicit-fallthrough

tools/um/tests/cla.c new file +159 -0

new file mode 100644
index 000000000000..694e3a3822be
@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+#ifdef __MINGW32__
+#include <winsock2.h>
+#else
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#endif
+
+#include "cla.h"
+
+static int cl_arg_parse_bool(struct cl_arg *arg, const char *value)
+{
+	*((int *)arg->store) = 1;
+	return 0;
+}
+
+static int cl_arg_parse_str(struct cl_arg *arg, const char *value)
+{
+	*((const char **)arg->store) = value;
+	return 0;
+}
+
+static int cl_arg_parse_int(struct cl_arg *arg, const char *value)
+{
+	errno = 0;
+	*((int *)arg->store) = strtol(value, NULL, 0);
+	return errno == 0;
+}
+
+static int cl_arg_parse_str_set(struct cl_arg *arg, const char *value)
+{
+	const char **set = arg->set;
+	int i;
+
+	for (i = 0; set[i] != NULL; i++) {
+		if (strcmp(set[i], value) == 0) {
+			*((int *)arg->store) = i;
+			return 0;
+		}
+	}
+
+	return (-1);
+}
+
+static int cl_arg_parse_ipv4(struct cl_arg *arg, const char *value)
+{
+	unsigned int addr;
+
+	if (!value)
+		return (-1);
+
+	addr = inet_addr(value);
+	if (addr == INADDR_NONE)
+		return (-1);
+	*((unsigned int *)arg->store) = addr;
+	return 0;
+}
+
+static cl_arg_parser_t parsers[] = {
+	[CL_ARG_BOOL] = cl_arg_parse_bool,
+	[CL_ARG_INT] = cl_arg_parse_int,
+	[CL_ARG_STR] = cl_arg_parse_str,
+	[CL_ARG_STR_SET] = cl_arg_parse_str_set,
+	[CL_ARG_IPV4] = cl_arg_parse_ipv4,
+};
+
+static struct cl_arg *find_short_arg(char name, struct cl_arg *args)
+{
+	struct cl_arg *arg;
+
+	for (arg = args; arg->short_name != 0; arg++) {
+		if (arg->short_name == name)
+			return arg;
+	}
+
+	return NULL;
+}
+
+static struct cl_arg *find_long_arg(const char *name, struct cl_arg *args)
+{
+	struct cl_arg *arg;
+
+	for (arg = args; arg->long_name; arg++) {
+		if (strcmp(arg->long_name, name) == 0)
+			return arg;
+	}
+
+	return NULL;
+}
+
+static void print_help(struct cl_arg *args)
+{
+	struct cl_arg *arg;
+
+	fprintf(stderr, "usage:\n");
+	for (arg = args; arg->long_name; arg++) {
+		fprintf(stderr, "-%c, --%-20s %s", arg->short_name,
+			arg->long_name, arg->help);
+		if (arg->type == CL_ARG_STR_SET) {
+			const char **set = arg->set;
+
+			fprintf(stderr, " [ ");
+			while (*set != NULL)
+				fprintf(stderr, "%s ", *(set++));
+			fprintf(stderr, "]");
+		}
+		fprintf(stderr, "\n");
+	}
+}
+
+int cla_parse_args(int argc, const char **argv, struct cl_arg *args)
+{
+	int i;
+
+	for (i = 1; i < argc; i++) {
+		struct cl_arg *arg = NULL;
+		cl_arg_parser_t parser;
+
+		if (argv[i][0] == '-') {
+			if (argv[i][1] != '-')
+				arg = find_short_arg(argv[i][1], args);
+			else
+				arg = find_long_arg(&argv[i][2], args);
+		}
+
+		if (!arg) {
+			fprintf(stderr, "unknown option '%s'\n", argv[i]);
+			print_help(args);
+			return (-1);
+		}
+
+		if (arg->type == CL_ARG_USER || arg->type >= CL_ARG_END)
+			parser = arg->parser;
+		else
+			parser = parsers[arg->type];
+
+		if (!parser) {
+			fprintf(stderr, "can't parse --'%s'/-'%c'\n",
+				arg->long_name, args->short_name);
+			return (-1);
+		}
+
+		if (parser(arg, argv[i + 1]) < 0) {
+			fprintf(stderr, "can't parse '%s'\n", argv[i]);
+			print_help(args);
+			return (-1);
+		}
+
+		if (arg->has_arg)
+			i++;
+	}
+
+	return 0;
+}

tools/um/tests/cla.h new file +33 -0

new file mode 100644
index 000000000000..3d879233681f
@@ -0,0 +1,33 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+#ifndef _LKL_TEST_CLA_H
+#define _LKL_TEST_CLA_H
+
+enum cl_arg_type {
+	CL_ARG_USER = 0,
+	CL_ARG_BOOL,
+	CL_ARG_INT,
+	CL_ARG_STR,
+	CL_ARG_STR_SET,
+	CL_ARG_IPV4,
+	CL_ARG_END,
+};
+
+struct cl_arg;
+
+typedef int (*cl_arg_parser_t)(struct cl_arg *arg, const char *value);
+
+struct cl_arg {
+	const char *long_name;
+	char short_name;
+	const char *help;
+	int has_arg;
+	enum cl_arg_type type;
+	void *store;
+	void *set;
+	cl_arg_parser_t parser;
+};
+
+int cla_parse_args(int argc, const char **argv, struct cl_arg *args);
+
+
+#endif /* _LKL_TEST_CLA_H */

tools/um/tests/disk.c new file +168 -0

new file mode 100644
index 000000000000..325934935e6a
@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <time.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <lkl.h>
+#include <lkl_host.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+#include "test.h"
+#include "cla.h"
+
+static struct {
+	int printk;
+	const char *disk;
+	const char *fstype;
+	int partition;
+} cla;
+
+struct cl_arg args[] = {
+	{"disk", 'd', "disk file to use", 1, CL_ARG_STR, &cla.disk},
+	{"partition", 'P', "partition to mount", 1, CL_ARG_INT, &cla.partition},
+	{"type", 't', "filesystem type", 1, CL_ARG_STR, &cla.fstype},
+	{0},
+};
+
+
+static struct lkl_disk disk;
+static int disk_id = -1;
+
+int lkl_test_disk_add(void)
+{
+	disk.fd = open(cla.disk, O_RDWR);
+	if (disk.fd < 0)
+		goto out_unlink;
+
+	disk.ops = NULL;
+	disk.dev = (char *)cla.disk;
+
+	disk_id = lkl_disk_add(&disk);
+	if (disk_id < 0)
+		goto out_close;
+
+	goto out;
+
+out_close:
+	close(disk.fd);
+
+out_unlink:
+	unlink(cla.disk);
+
+out:
+	lkl_test_logf("disk fd/handle %x disk_id %d", disk.fd, disk_id);
+
+	if (disk_id >= 0)
+		return TEST_SUCCESS;
+
+	return TEST_FAILURE;
+}
+
+int lkl_test_disk_remove(void)
+{
+	int ret;
+
+	ret = lkl_disk_remove(disk);
+
+	close(disk.fd);
+
+	if (ret == 0)
+		return TEST_SUCCESS;
+
+	return TEST_FAILURE;
+}
+
+
+static char mnt_point[32];
+
+LKL_TEST_CALL(mount_dev, lkl_mount_dev, 0, disk_id, cla.partition, cla.fstype,
+	      0, NULL, mnt_point, sizeof(mnt_point))
+
+static int lkl_test_umount_dev(void)
+{
+	long ret, ret2;
+
+	ret = lkl_sys_chdir("/");
+
+	ret2 = lkl_umount_dev(disk_id, cla.partition, 0, 1000);
+
+	lkl_test_logf("%ld %ld", ret, ret2);
+
+	if (!ret && !ret2)
+		return TEST_SUCCESS;
+
+	return TEST_FAILURE;
+}
+
+struct lkl_dir *dir;
+
+static int lkl_test_opendir(void)
+{
+	int err;
+
+	dir = lkl_opendir(mnt_point, &err);
+
+	lkl_test_logf("lkl_opedir(%s) = %d %s\n", mnt_point, err,
+		      lkl_strerror(err));
+
+	if (err == 0)
+		return TEST_SUCCESS;
+
+	return TEST_FAILURE;
+}
+
+static int lkl_test_readdir(void)
+{
+	struct lkl_linux_dirent64 *de = lkl_readdir(dir);
+	int wr = 0;
+
+	while (de) {
+		wr += lkl_test_logf("%s ", de->d_name);
+		if (wr >= 70) {
+			lkl_test_logf("\n");
+			wr = 0;
+			break;
+		}
+		de = lkl_readdir(dir);
+	}
+
+	if (lkl_errdir(dir) == 0)
+		return TEST_SUCCESS;
+
+	return TEST_FAILURE;
+}
+
+LKL_TEST_CALL(closedir, lkl_closedir, 0, dir);
+LKL_TEST_CALL(chdir_mnt_point, lkl_sys_chdir, 0, mnt_point);
+LKL_TEST_CALL(start_kernel, lkl_start_kernel, 0, &lkl_host_ops,
+	     "mem=16M loglevel=8");
+LKL_TEST_CALL(stop_kernel, lkl_sys_halt, 0);
+
+struct lkl_test tests[] = {
+	LKL_TEST(disk_add),
+	LKL_TEST(start_kernel),
+	LKL_TEST(mount_dev),
+	LKL_TEST(chdir_mnt_point),
+	LKL_TEST(opendir),
+	LKL_TEST(readdir),
+	LKL_TEST(closedir),
+	LKL_TEST(umount_dev),
+	LKL_TEST(stop_kernel),
+	LKL_TEST(disk_remove),
+
+};
+
+int main(int argc, const char **argv)
+{
+	if (cla_parse_args(argc, argv, args) < 0)
+		return (-1);
+
+	lkl_host_ops.print = lkl_test_log;
+
+	return lkl_test_run(tests, sizeof(tests)/sizeof(struct lkl_test),
+			    "disk %s", cla.fstype);
+}

tools/um/tests/disk.sh new file +70 -0

new file mode 100755
index 000000000000..e2ec6cf69d4b
@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: GPL-2.0
+
+script_dir=$(cd $(dirname ${BASH_SOURCE:-$0}); pwd)
+
+source $script_dir/test.sh
+
+function prepfs()
+{
+    set -e
+
+    file=`mktemp`
+
+    dd if=/dev/zero of=$file bs=1024 count=204800
+
+    yes | mkfs.$1 $file
+
+    if ! [ -z $ANDROID_WDIR ]; then
+        adb shell mkdir -p $ANDROID_WDIR
+        adb push $file $ANDROID_WDIR
+        rm $file
+        file=$ANDROID_WDIR/$(basename $file)
+    fi
+    if ! [ -z $BSD_WDIR ]; then
+        $MYSSH mkdir -p $BSD_WDIR
+        ssh_copy $file $BSD_WDIR
+        rm $file
+        file=$BSD_WDIR/$(basename $file)
+    fi
+
+    export_vars file
+}
+
+function cleanfs()
+{
+    set -e
+
+    if ! [ -z $ANDROID_WDIR ]; then
+        adb shell rm $1
+        adb shell rm $ANDROID_WDIR/disk
+    elif ! [ -z $BSD_WDIR ]; then
+        $MYSSH rm $1
+        $MYSSH rm $BSD_WDIR/disk
+    else
+        rm $1
+    fi
+}
+
+if [ "$1" = "-t" ]; then
+    shift
+    fstype=$1
+    shift
+fi
+
+if [ -z "$fstype" ]; then
+    fstype="ext4"
+fi
+
+if [ -z $(which mkfs.$fstype) ]; then
+    lkl_test_plan 0 "disk $fstype"
+    echo "no mkfs.$fstype command"
+    exit 0
+fi
+
+lkl_test_plan 1 "disk $fstype"
+lkl_test_run 1 prepfs $fstype
+lkl_test_exec $script_dir/disk -d $file -t $fstype $@
+lkl_test_plan 1 "disk $fstype"
+lkl_test_run 1 cleanfs $file
+

tools/um/tests/run.py +2 -0

index c96ede90b6ad..97d6dedc217c 100755
@@ -50,6 +50,8 @@ mydir=os.path.dirname(os.path.realpath(__file__))
 
  tests = [
      'boot.sh',
+    'disk.sh -t ext4',
+    'disk.sh -t vfat',
  ]
 
  parser = argparse.ArgumentParser(description='LKL test runner')

Quoted 16 lines

arch/um/nommu/um/Kconfig +4 -0

index 20b3eaccb6f0..c6a3f472fe75 100644
@@ -4,6 +4,10 @@ config UML_NOMMU
  	select UACCESS_MEMCPY
  	select ARCH_THREAD_STACK_ALLOCATOR
  	select ARCH_HAS_SYSCALL_WRAPPER
+	select VFAT_FS
+	select NLS_CODEPAGE_437
+	select NLS_ISO8859_1
+	select BTRFS_FS
    config 64BIT
  	bool

@@ -35,3 +39,7 @@ config STACKTRACE_SUPPORT
  config PRINTK_TIME

arch/um/nommu/um/Kconfig config STACKTRACE_SUPPORT · line 45

Quoted 6 lines

arch/um/nommu/um/Kconfig +4 -0

  	bool
  	default y
+
+config RAID6_PQ_BENCHMARK
+	bool
+	default n

Why are we touching this? I thought this is already defined in lib/Kconfig?

This is another spin of the unification of LKL into UML. Based on the discussion of v4 patchset, we have tried to address issue raised and rewrote the patchset from scratch. The summary is listed in the changelog below.

Although there are still bugs in the patchset, we'd like to ask your opinions on the design we changed.

The milestone section is also updated: this patchset is for the milestone 1, though the common init API is still not implemented yet.

Changes in rfc v7:
- preserve make ARCH=um syntax to build UML
- introduce make ARCH=um UMMODE=library to build library mode
- fix undefined symbols issue during modpost
- clean up makefiles (arch/um, tools/um)

Changes in rfc v6:
- rebase with the current linus tree

Changes in rfc v5:
- rewrite whole patchset from scratch
- move arch-dependent code of arch/um and arch/x86/um to tools/um
- mainly code under os-Linux/ involved
- introduce 2-stage build (kernel, and host-dependent parts)
- clean up vmlinux.lds.S
- put LKL-specific implementations as a SUBARCH under arch/um/nommu
- introduce !CONFIG_MMU in arch/um
- use struct arch_thread and arch_switch_to() for subarch-specific thread implementation
- integrate with the IRQ infrastructure of UML
- tested with block device drivers (ubd) for the proof

Changes in rfc v4: (https://lwn.net/Articles/816276/)
- Rebase on the current uml/master branch
- Fix IRQ handling (bug fix)
- drop a patch for CONFIG_GENERIC_ATOMIC64 (comment by Peter Zijlstra)
- implement vector net driver for UMMODE_LIB (comment by Anton)
- clean up uapi headers to avoid duplicates
- clean up IRQ handling code (comment by Anton)
- fix error handling in test code (comments by David Disseldorp)

Changes in rfc v3:
- use UML drivers (net, block) from LKL programs
- drop virtio device implementations
- drop mingw32 (Windows) host
- drop android (arm/aarch64) host
- drop FreeBSD (x86_64) host
- drop LD_PRELOAD (hijack) support
- update milestone

rfc v2:
- use UMMODE instead of SUBARCH to switch UML or LKL
- tools/lkl directory is still there. I confirmed we can move under arch/um (e.g., arch/um/lkl/hosts). I will move it IF this is preferable.
- drop several patches involved non-uml directory
- drop several patches which are not required
- refine commit logs
- document updated

LKL (Linux Kernel Library) is aiming to allow reusing the Linux kernel code as extensively as possible with minimal effort and reduced maintenance overhead.

Examples of how LKL can be used are: creating userspace applications (running on Linux and other operating systems) that can read or write Linux filesystems or can use the Linux networking stack, creating kernel drivers for other operating systems that can read Linux filesystems, bootloaders support for reading/writing Linux filesystems, etc.

With LKL, the kernel code is compiled into an object file that can be directly linked by applications. The API offered by LKL is based on the Linux system call interface.

LKL is originally implemented as an architecture port in arch/lkl, but this series of commits tries to integrate this into arch/um as one of the mode of UML. This was discussed during RFC email of LKL (*1).

The latest LKL version can be found at https://github.com/lkl/linux

Milestone
=========
This patches is a first step toward upstreaming *library mode* of Linux kernel, but we think we need to have several steps toward our goal, describing in the below.

Milestone 1: LKL lib on top of UML
* Kernel - Host build split
- Build UML as a relocatable object using the UML's kernel linker script.
- Move the ptrace and other well isolated os code out of arch/um to tools/um
- Use standard host toolchain to create a static library stripped of the ptrace code. Use standard host toolchain to build the main UML executable.
- Add library init API that creates the UML kernel process and starts UML.
* System calls APIs
- Add new system call interface based on UML's irq facility.
- Use the LKL scripts to export the required headers to create system calls APIs that use the UML system calls infrastructure.
- Keep the underlying host and driver operations (threads, irqs, etc.) as they are now in UML.
* Boot test
- Port the LKL boot test to verify that we are able to programatically issue system calls.

Milestone 2: add virtio disk support
* Export asm/io.h operations to host/os. Create IO access operations and redirect them to weak os_ variants that use the current UML implementation.
* Add the LKL IO access layer including generic virtio handling and the virtio block device code.
* Port LKL disk test and disk apps (lklfuse, fs2tar, cptofs)

Milestone 3: new arch ports
* Abstract the system call / IRQ mode the move the implementation to host
* Abstract the thread model and move the implementation to host
* Add LKL thread model and LKL ports

Building LKL the host library and LKL applications
==================================================

% cd tools/um
% make

will build LKL as a object file, it will install it in tools/um/lib together with the headers files in tools/um/include then will build the host library, tests and a few of application examples:

* tests/boot - a simple applications that uses LKL and exercises the basic LKL APIs

% make run-tests

should run the above tests/boot and tests/net-test and report errors if there are any.

Supported hosts
===============

Currently LKL supports Linux userspace applications. New hosts can be added relatively easy if the host supports gcc and GNU ld. Previous versions of LKL supported Windows kernel and Haiku kernel hosts, and we also have WIP patches with rump-hypercall interface, used in UEFI, as well as macOS userspace (part of POSIX).

There is also musl-libc port for LKL, which might be interested in for some folks.

Further readings about LKL
=========================

- Discussion in github LKL issue
https://github.com/lkl/linux/issues/304

- LKL (an article)
https://www.researchgate.net/profile/Nicolae_Tapus2/publication/224164682_LKL_The_Linux_kernel_library/links/02bfe50fd921ab4f7c000000.pdf

*1 RFC email to LKML (back in 2015)
https://www.mail-archive.com/[email protected]/msg1012277.html

Please review the following changes for suitability for inclusion. If you have any objections or suggestions for improvement, please respond to the patches. If you agree with the changes, please provide your Acked-by.

The following changes since commit 805c6d3c19210c90c109107d189744e960eae025:

   Merge branch 'fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs (2020-09-22 15:08:41 -0700)

are available in the Git repository at:

   git://github.com/thehajime/linux a8686efcbad3c445d3e5bde054c04a58877915f1
   https://github.com/thehajime/linux/tree/uml-lkl-5.9rc6-v7

Hajime Tazaki (18):
um: move arch/um/os-Linux dir to tools/um/uml
um: move arch/x86/um/os-Linux to tools/um/uml/
scritps: um: suppress warnings if SRCARCH=um
um: extend arch_switch_to for alternate SUBARCH
um: add nommu mode for UML library mode
um: nommu: host interface
um: nommu: memory handling
um: nommu: kernel thread support
um: nommu: system call interface and application API
um: nommu: basic console support
um: nommu: initialization and cleanup
um: nommu: integrate with irq infrastructure of UML
um: nommu: plug in the build system
um: host: add nommu build for ARCH=um
um: host: add utilities functions
um: host: posix host operations
um: host: add test programs
um: nommu: add block device support of UML

Octavian Purdila (3):
um: split build in kernel and host parts
um: add os init and exit calls
um: host: implement os_initcalls and os_exitcalls

  arch/um/Kconfig                               |  29 +-
  arch/um/Makefile                              |  35 +-
  arch/um/drivers/Makefile                      |  10 +-
  .../um/{os-Linux => }/drivers/ethertap_kern.c |   0
  arch/um/{os-Linux => }/drivers/tuntap_kern.c  |   0
  arch/um/include/asm/common.lds.S              |  99 ----
  arch/um/include/asm/host_ops.h                |   9 +
  arch/um/include/asm/mmu.h                     |   3 +
  arch/um/include/asm/mmu_context.h             |   8 +
  arch/um/include/asm/page.h                    |  15 +
  arch/um/include/asm/pgtable.h                 |  27 +
  arch/um/include/asm/thread_info.h             |  24 +
  arch/um/include/asm/uaccess.h                 |   6 +
  arch/um/include/asm/xor.h                     |   3 +-
  arch/um/include/shared/as-layout.h            |   1 +
  .../drivers => include/shared}/etap.h         |   0
  arch/um/include/shared/init.h                 |  19 +-
  arch/um/include/shared/os.h                   |   1 +
  .../drivers => include/shared}/tuntap.h       |   0
  arch/um/include/uapi/asm/Kbuild               |   2 +
  arch/um/kernel/Makefile                       |  13 +-
  arch/um/kernel/dyn.lds.S                      | 171 -------
  arch/um/kernel/irq.c                          |  13 +
  arch/um/kernel/process.c                      |  14 +-
  arch/um/kernel/reboot.c                       |   5 +
  arch/um/kernel/time.c                         |   2 +
  arch/um/kernel/um_arch.c                      |  16 +
  arch/um/kernel/uml.lds.S                      | 115 -----
  arch/um/{os-Linux => kernel}/user_syms.c      |   0
  arch/um/kernel/vmlinux.lds.S                  |  91 +++-
  arch/um/nommu/Makefile                        |   1 +
  arch/um/nommu/Makefile.um                     |  22 +
  arch/um/nommu/include/asm/Kbuild              |   6 +
  arch/um/nommu/include/asm/archparam.h         |   1 +
  arch/um/nommu/include/asm/atomic.h            |  11 +
  arch/um/nommu/include/asm/atomic64.h          | 114 +++++
  arch/um/nommu/include/asm/bitsperlong.h       |  12 +
  arch/um/nommu/include/asm/byteorder.h         |   7 +
  arch/um/nommu/include/asm/cpu.h               |  16 +
  arch/um/nommu/include/asm/elf.h               |  15 +
  arch/um/nommu/include/asm/mm_context.h        |   8 +
  arch/um/nommu/include/asm/processor.h         |  46 ++
  arch/um/nommu/include/asm/ptrace.h            |  21 +
  arch/um/nommu/include/asm/sched.h             |  23 +
  arch/um/nommu/include/asm/segment.h           |   9 +
  arch/um/nommu/include/asm/syscall_wrapper.h   |  57 +++
  arch/um/nommu/include/asm/syscalls.h          |  15 +
  arch/um/nommu/include/uapi/asm/Kbuild         |   6 +
  arch/um/nommu/include/uapi/asm/bitsperlong.h  |  11 +
  arch/um/nommu/include/uapi/asm/byteorder.h    |  11 +
  arch/um/nommu/include/uapi/asm/host_ops.h     | 122 +++++
  arch/um/nommu/include/uapi/asm/sigcontext.h   |  12 +
  arch/um/nommu/include/uapi/asm/syscalls.h     | 287 +++++++++++
  arch/um/nommu/include/uapi/asm/unistd.h       |  17 +
  arch/um/nommu/um/Kconfig                      |  45 ++
  arch/um/nommu/um/Makefile                     |   4 +
  arch/um/nommu/um/bootmem.c                    |  87 ++++
  arch/um/nommu/um/console.c                    |  42 ++
  arch/um/nommu/um/cpu.c                        | 247 ++++++++++
  arch/um/nommu/um/delay.c                      |  31 ++
  arch/um/nommu/um/setup.c                      | 179 +++++++
  arch/um/nommu/um/shared/sysdep/archsetjmp.h   |  13 +
  arch/um/nommu/um/shared/sysdep/faultinfo.h    |   8 +
  .../nommu/um/shared/sysdep/kernel-offsets.h   |  12 +
  arch/um/nommu/um/shared/sysdep/mcontext.h     |   9 +
  arch/um/nommu/um/shared/sysdep/ptrace.h       |  42 ++
  arch/um/nommu/um/shared/sysdep/ptrace_user.h  |   7 +
  arch/um/nommu/um/syscalls.c                   | 199 ++++++++
  arch/um/nommu/um/threads.c                    | 262 ++++++++++
  arch/um/nommu/um/unimplemented.c              |  70 +++
  arch/um/nommu/um/user_constants.h             |  13 +
  arch/um/os-Linux/Makefile                     |  19 -
  arch/um/os-Linux/drivers/Makefile             |  13 -
  arch/um/scripts/headers_install.py            | 197 ++++++++
  arch/x86/um/Makefile                          |   2 +-
  arch/x86/um/os-Linux/Makefile                 |  13 -
  arch/x86/um/ptrace_32.c                       |   2 +-
  arch/x86/um/syscalls_64.c                     |   2 +-
  scripts/headers_install.sh                    |   4 +
  scripts/link-vmlinux.sh                       |  42 +-
  tools/um/.gitignore                           |   1 +
  tools/um/Makefile                             |  81 +++
  tools/um/Targets                              |  13 +
  tools/um/include/lkl.h                        | 357 ++++++++++++++
  tools/um/include/lkl_host.h                   |  27 +
  tools/um/lib/Build                            |   7 +
  tools/um/lib/fs.c                             | 461 ++++++++++++++++++
  tools/um/lib/jmp_buf.c                        |  14 +
  tools/um/lib/jmp_buf.h                        |   8 +
  tools/um/lib/posix-host.c                     | 293 +++++++++++
  tools/um/lib/utils.c                          | 213 ++++++++
  tools/um/tests/Build                          |   4 +
  tools/um/tests/boot.c                         | 393 +++++++++++++++
  tools/um/tests/boot.sh                        |   9 +
  tools/um/tests/cla.c                          | 159 ++++++
  tools/um/tests/cla.h                          |  33 ++
  tools/um/tests/disk.c                         | 168 +++++++
  tools/um/tests/disk.sh                        |  70 +++
  tools/um/tests/run.py                         | 174 +++++++
  tools/um/tests/tap13.py                       | 209 ++++++++
  tools/um/tests/test.c                         | 126 +++++
  tools/um/tests/test.h                         |  72 +++
  tools/um/tests/test.sh                        | 181 +++++++
  tools/um/uml/Build                            |  58 +++
  tools/um/uml/drivers/Build                    |  10 +
  .../um/uml}/drivers/ethertap_user.c           |   0
  .../um/uml}/drivers/tuntap_user.c             |   0
  {arch/um/os-Linux => tools/um/uml}/elf_aux.c  |   0
  {arch/um/os-Linux => tools/um/uml}/execvp.c   |   4 -
  {arch/um/os-Linux => tools/um/uml}/file.c     |   0
  {arch/um/os-Linux => tools/um/uml}/helper.c   |   0
  {arch/um/os-Linux => tools/um/uml}/irq.c      |   0
  {arch/um/os-Linux => tools/um/uml}/main.c     |   0
  {arch/um/os-Linux => tools/um/uml}/mem.c      |   0
  tools/um/uml/nommu/Build                      |   1 +
  tools/um/uml/nommu/registers.c                |  21 +
  tools/um/uml/nommu/unimplemented.c            |  21 +
  {arch/um/os-Linux => tools/um/uml}/process.c  |   2 +
  .../um/os-Linux => tools/um/uml}/registers.c  |   0
  {arch/um/os-Linux => tools/um/uml}/sigio.c    |   0
  {arch/um/os-Linux => tools/um/uml}/signal.c   |  12 +-
  .../skas/Makefile => tools/um/uml/skas/Build  |   6 +-
  {arch/um/os-Linux => tools/um/uml}/skas/mem.c |   0
  .../os-Linux => tools/um/uml}/skas/process.c  |   3 +-
  {arch/um/os-Linux => tools/um/uml}/start_up.c |   0
  {arch/um/os-Linux => tools/um/uml}/time.c     |   0
  {arch/um/os-Linux => tools/um/uml}/tty.c      |   0
  {arch/um/os-Linux => tools/um/uml}/umid.c     |   0
  {arch/um/os-Linux => tools/um/uml}/util.c     |  26 +
  tools/um/uml/x86/Build                        |  11 +
  .../os-Linux => tools/um/uml/x86}/mcontext.c  |   0
  .../um/os-Linux => tools/um/uml/x86}/prctl.c  |   0
  .../os-Linux => tools/um/uml/x86}/registers.c |   0
  .../os-Linux => tools/um/uml/x86}/task_size.c |   0
  .../um/os-Linux => tools/um/uml/x86}/tls.c    |   0
  135 files changed, 5870 insertions(+), 523 deletions(-)

rename arch/um/{os-Linux => }/drivers/ethertap_kern.c (100%) rename arch/um/{os-Linux => }/drivers/tuntap_kern.c (100%) delete mode 100644 arch/um/include/asm/common.lds.S
create mode 100644 arch/um/include/asm/host_ops.h
rename arch/um/{os-Linux/drivers => include/shared}/etap.h (100%) rename arch/um/{os-Linux/drivers => include/shared}/tuntap.h (100%) create mode 100644 arch/um/include/uapi/asm/Kbuild
delete mode 100644 arch/um/kernel/dyn.lds.S
delete mode 100644 arch/um/kernel/uml.lds.S
rename arch/um/{os-Linux => kernel}/user_syms.c (100%) create mode 100644 arch/um/nommu/Makefile
create mode 100644 arch/um/nommu/Makefile.um
create mode 100644 arch/um/nommu/include/asm/Kbuild
create mode 100644 arch/um/nommu/include/asm/archparam.h create mode 100644 arch/um/nommu/include/asm/atomic.h
create mode 100644 arch/um/nommu/include/asm/atomic64.h create mode 100644 arch/um/nommu/include/asm/bitsperlong.h create mode 100644 arch/um/nommu/include/asm/byteorder.h create mode 100644 arch/um/nommu/include/asm/cpu.h
create mode 100644 arch/um/nommu/include/asm/elf.h
create mode 100644 arch/um/nommu/include/asm/mm_context.h create mode 100644 arch/um/nommu/include/asm/processor.h create mode 100644 arch/um/nommu/include/asm/ptrace.h
create mode 100644 arch/um/nommu/include/asm/sched.h
create mode 100644 arch/um/nommu/include/asm/segment.h create mode 100644 arch/um/nommu/include/asm/syscall_wrapper.h create mode 100644 arch/um/nommu/include/asm/syscalls.h create mode 100644 arch/um/nommu/include/uapi/asm/Kbuild create mode 100644 arch/um/nommu/include/uapi/asm/bitsperlong.h create mode 100644 arch/um/nommu/include/uapi/asm/byteorder.h create mode 100644 arch/um/nommu/include/uapi/asm/host_ops.h create mode 100644 arch/um/nommu/include/uapi/asm/sigcontext.h create mode 100644 arch/um/nommu/include/uapi/asm/syscalls.h create mode 100644 arch/um/nommu/include/uapi/asm/unistd.h create mode 100644 arch/um/nommu/um/Kconfig
create mode 100644 arch/um/nommu/um/Makefile
create mode 100644 arch/um/nommu/um/bootmem.c
create mode 100644 arch/um/nommu/um/console.c
create mode 100644 arch/um/nommu/um/cpu.c
create mode 100644 arch/um/nommu/um/delay.c
create mode 100644 arch/um/nommu/um/setup.c
create mode 100644 arch/um/nommu/um/shared/sysdep/archsetjmp.h create mode 100644 arch/um/nommu/um/shared/sysdep/faultinfo.h create mode 100644 arch/um/nommu/um/shared/sysdep/kernel-offsets.h create mode 100644 arch/um/nommu/um/shared/sysdep/mcontext.h create mode 100644 arch/um/nommu/um/shared/sysdep/ptrace.h create mode 100644 arch/um/nommu/um/shared/sysdep/ptrace_user.h create mode 100644 arch/um/nommu/um/syscalls.c
create mode 100644 arch/um/nommu/um/threads.c
create mode 100644 arch/um/nommu/um/unimplemented.c
create mode 100644 arch/um/nommu/um/user_constants.h
delete mode 100644 arch/um/os-Linux/Makefile
delete mode 100644 arch/um/os-Linux/drivers/Makefile
create mode 100755 arch/um/scripts/headers_install.py
delete mode 100644 arch/x86/um/os-Linux/Makefile
create mode 100644 tools/um/.gitignore
create mode 100644 tools/um/Makefile
create mode 100644 tools/um/Targets
create mode 100644 tools/um/include/lkl.h
create mode 100644 tools/um/include/lkl_host.h
create mode 100644 tools/um/lib/Build
create mode 100644 tools/um/lib/fs.c
create mode 100644 tools/um/lib/jmp_buf.c
create mode 100644 tools/um/lib/jmp_buf.h
create mode 100644 tools/um/lib/posix-host.c
create mode 100644 tools/um/lib/utils.c
create mode 100644 tools/um/tests/Build
create mode 100644 tools/um/tests/boot.c
create mode 100755 tools/um/tests/boot.sh
create mode 100644 tools/um/tests/cla.c
create mode 100644 tools/um/tests/cla.h
create mode 100644 tools/um/tests/disk.c
create mode 100755 tools/um/tests/disk.sh
create mode 100755 tools/um/tests/run.py
create mode 100644 tools/um/tests/tap13.py
create mode 100644 tools/um/tests/test.c
create mode 100644 tools/um/tests/test.h
create mode 100644 tools/um/tests/test.sh
create mode 100644 tools/um/uml/Build
create mode 100644 tools/um/uml/drivers/Build
rename {arch/um/os-Linux => tools/um/uml}/drivers/ethertap_user.c (100%) rename {arch/um/os-Linux => tools/um/uml}/drivers/tuntap_user.c (100%) rename {arch/um/os-Linux => tools/um/uml}/elf_aux.c (100%) rename {arch/um/os-Linux => tools/um/uml}/execvp.c (98%) rename {arch/um/os-Linux => tools/um/uml}/file.c (100%) rename {arch/um/os-Linux => tools/um/uml}/helper.c (100%) rename {arch/um/os-Linux => tools/um/uml}/irq.c (100%) rename {arch/um/os-Linux => tools/um/uml}/main.c (100%) rename {arch/um/os-Linux => tools/um/uml}/mem.c (100%) create mode 100644 tools/um/uml/nommu/Build
create mode 100644 tools/um/uml/nommu/registers.c
create mode 100644 tools/um/uml/nommu/unimplemented.c
rename {arch/um/os-Linux => tools/um/uml}/process.c (99%) rename {arch/um/os-Linux => tools/um/uml}/registers.c (100%) rename {arch/um/os-Linux => tools/um/uml}/sigio.c (100%) rename {arch/um/os-Linux => tools/um/uml}/signal.c (96%) rename arch/um/os-Linux/skas/Makefile => tools/um/uml/skas/Build (56%) rename {arch/um/os-Linux => tools/um/uml}/skas/mem.c (100%) rename {arch/um/os-Linux => tools/um/uml}/skas/process.c (99%) rename {arch/um/os-Linux => tools/um/uml}/start_up.c (100%) rename {arch/um/os-Linux => tools/um/uml}/time.c (100%) rename {arch/um/os-Linux => tools/um/uml}/tty.c (100%) rename {arch/um/os-Linux => tools/um/uml}/umid.c (100%) rename {arch/um/os-Linux => tools/um/uml}/util.c (89%) create mode 100644 tools/um/uml/x86/Build
rename {arch/x86/um/os-Linux => tools/um/uml/x86}/mcontext.c (100%) rename {arch/x86/um/os-Linux => tools/um/uml/x86}/prctl.c (100%) rename {arch/x86/um/os-Linux => tools/um/uml/x86}/registers.c (100%) rename {arch/x86/um/os-Linux => tools/um/uml/x86}/task_size.c (100%) rename {arch/x86/um/os-Linux => tools/um/uml/x86}/tls.c (100%)

Quoted 12 lines · Hajime Tazaki

This is another spin of the unification of LKL into UML. Based on the discussion of v4 patchset, we have tried to address issue raised and rewrote the patchset from scratch. The summary is listed in the changelog below.

Although there are still bugs in the patchset, we'd like to ask your opinions on the design we changed.

The milestone section is also updated: this patchset is for the milestone 1, though the common init API is still not implemented yet.

Quoted 5 lines

Changes in rfc v7:
- preserve make ARCH=um syntax to build UML
- introduce make ARCH=um UMMODE=library to build library mode
- fix undefined symbols issue during modpost
- clean up makefiles (arch/um, tools/um)

Hi Hajime, hi Tavi,

Our starting point should be that it does not break the existing build. It still does.

If I build a "stock configuration" UML after applying the patchset the resulting vmlinux is not executable.

On the positive side, it builds cleanly now. I will try to go through the rest of the patchset later today and see if there is anything else that needs fixing before we do the next version.

Hello Anton,

Quoted 14 lines · Anton Ivanov

Quoted 12 lines · Hajime Tazaki

This is another spin of the unification of LKL into UML. Based on the discussion of v4 patchset, we have tried to address issue raised and rewrote the patchset from scratch. The summary is listed in the changelog below.

Although there are still bugs in the patchset, we'd like to ask your opinions on the design we changed.

The milestone section is also updated: this patchset is for the milestone 1, though the common init API is still not implemented yet.

Quoted 8 lines

Quoted 5 lines

Changes in rfc v7:
- preserve make ARCH=um syntax to build UML
- introduce make ARCH=um UMMODE=library to build library mode
- fix undefined symbols issue during modpost
- clean up makefiles (arch/um, tools/um)

Hi Hajime, hi Tavi,

Our starting point should be that it does not break the existing build. It still does.

I agree with the starting point.

Quoted 2 lines

If I build a "stock configuration" UML after applying the patchset the resulting vmlinux is not executable.

Ah, I confirmed the issue.
I was only trying to make the linux binary compatible, not vmlinux.

Because vmlinux is now build as a relocatable object, this is something we need to figure out if we wish to keep vmlinux executable.

Do you think we should make vmlinux executable even if we have the file linux executable ? If yes, we will work on this to fix the issue.

Quoted 3 lines

On the positive side, it builds cleanly now. I will try to go through the rest of the patchset later today and see if there is anything else that needs fixing before we do the next version.

thanks for your time.

-- Hajime

Quoted 36 lines · Hajime Tazaki

Hello Anton,

Quoted 14 lines · Anton Ivanov

Quoted 12 lines · Hajime Tazaki

This is another spin of the unification of LKL into UML. Based on the discussion of v4 patchset, we have tried to address issue raised and rewrote the patchset from scratch. The summary is listed in the changelog below.

Although there are still bugs in the patchset, we'd like to ask your opinions on the design we changed.

The milestone section is also updated: this patchset is for the milestone 1, though the common init API is still not implemented yet.

Quoted 8 lines

Quoted 5 lines

Changes in rfc v7:
- preserve make ARCH=um syntax to build UML
- introduce make ARCH=um UMMODE=library to build library mode
- fix undefined symbols issue during modpost
- clean up makefiles (arch/um, tools/um)

Hi Hajime, hi Tavi,

Our starting point should be that it does not break the existing build. It still does.

I agree with the starting point.

Quoted 2 lines

If I build a "stock configuration" UML after applying the patchset the resulting vmlinux is not executable.

Ah, I confirmed the issue.
I was only trying to make the linux binary compatible, not vmlinux.

Because vmlinux is now build as a relocatable object, this is something we need to figure out if we wish to keep vmlinux executable.

Quoted 2 lines

Do you think we should make vmlinux executable even if we have the file linux executable ? If yes, we will work on this to fix the issue.

In my opinion, any relocatable objects, etc should be clearly named - either .o, .so, etc depending on what they are. We should not try to reuse any of the existing files for a different purpose.

I also agree with Johannes that we are not using the tools/ directory for its intended purpose.

We are not trying to build a tool. We are trying to build a sub-architecture. IMHO, the build should use a subdirectory under arch/um.

Quoted 37 lines · Anton Ivanov

Quoted 35 lines · Hajime Tazaki

Hello Anton,

Quoted 13 lines · Anton Ivanov

Quoted 12 lines · Hajime Tazaki

This is another spin of the unification of LKL into UML. Based on the discussion of v4 patchset, we have tried to address issue raised and rewrote the patchset from scratch. The summary is listed in the changelog below.

Although there are still bugs in the patchset, we'd like to ask your opinions on the design we changed.

The milestone section is also updated: this patchset is for the milestone 1, though the common init API is still not implemented yet.

Quoted 8 lines

Quoted 5 lines

Changes in rfc v7:
- preserve make ARCH=um syntax to build UML
- introduce make ARCH=um UMMODE=library to build library mode
- fix undefined symbols issue during modpost
- clean up makefiles (arch/um, tools/um)

Hi Hajime, hi Tavi,

Our starting point should be that it does not break the existing build. It still does.

I agree with the starting point.

Quoted 2 lines

If I build a "stock configuration" UML after applying the patchset the resulting vmlinux is not executable.

Ah, I confirmed the issue.
I was only trying to make the linux binary compatible, not vmlinux.

Because vmlinux is now build as a relocatable object, this is something we need to figure out if we wish to keep vmlinux executable.

Quoted 8 lines

Quoted 2 lines

Do you think we should make vmlinux executable even if we have the file linux executable ? If yes, we will work on this to fix the issue.

In my opinion, any relocatable objects, etc should be clearly named - either .o, .so, etc depending on what they are. We should not try to reuse any of the existing files for a different purpose.

I also agree with Johannes that we are not using the tools/ directory for its intended purpose.

We are not trying to build a tool. We are trying to build a sub-architecture. IMHO, the build should use a subdirectory under arch/um.

Hi Anton, Johannes,

From strictly the UML point of view, I can see how this would be a
sub-architecture build since we are doing both the kernel build and the UML binary as a single step.

If we look at arch/um as just the kernel that enables many applications, just one of which it is uml, I believe it is cleaner to build specific applications elsewhere. That is why we proposed to do a two step build process: one that builds the kernel as a relocatable object and one that uses this object to build programs, shared libraries, etc. Besides allowing us to create multiple tools / applications it also makes it much easier to support multiple OSes or other environments (e.g. bare-metal applications). As you can see, this allowed us to remove the linker script for UML and instead just used the target compiler to build the executable.

We have picked tools because it has the infrastructure to build programs, shared libraries, and it is the single place (AFAIK) where we don't link the code in there with the kernel binary.

Thanks,
Tavi

Quoted 53 lines · Octavian Purdila

Quoted 37 lines · Anton Ivanov

Quoted 35 lines · Hajime Tazaki

Hello Anton,

Quoted 13 lines · Anton Ivanov

Quoted 12 lines · Hajime Tazaki

This is another spin of the unification of LKL into UML. Based on the discussion of v4 patchset, we have tried to address issue raised and rewrote the patchset from scratch. The summary is listed in the changelog below.

Although there are still bugs in the patchset, we'd like to ask your opinions on the design we changed.

The milestone section is also updated: this patchset is for the milestone 1, though the common init API is still not implemented yet.

Quoted 8 lines

Quoted 5 lines

Changes in rfc v7:
- preserve make ARCH=um syntax to build UML
- introduce make ARCH=um UMMODE=library to build library mode
- fix undefined symbols issue during modpost
- clean up makefiles (arch/um, tools/um)

Hi Hajime, hi Tavi,

Our starting point should be that it does not break the existing build. It still does.

I agree with the starting point.

Quoted 2 lines

If I build a "stock configuration" UML after applying the patchset the resulting vmlinux is not executable.

Ah, I confirmed the issue.
I was only trying to make the linux binary compatible, not vmlinux.

Because vmlinux is now build as a relocatable object, this is something we need to figure out if we wish to keep vmlinux executable.

Quoted 8 lines

Quoted 2 lines

Do you think we should make vmlinux executable even if we have the file linux executable ? If yes, we will work on this to fix the issue.

In my opinion, any relocatable objects, etc should be clearly named - either .o, .so, etc depending on what they are. We should not try to reuse any of the existing files for a different purpose.

I also agree with Johannes that we are not using the tools/ directory for its intended purpose.

We are not trying to build a tool. We are trying to build a sub-architecture. IMHO, the build should use a subdirectory under arch/um.

Hi Anton, Johannes,

From strictly the UML point of view, I can see how this would be a
sub-architecture build since we are doing both the kernel build and the UML binary as a single step.

Quoted 10 lines

If we look at arch/um as just the kernel that enables many applications, just one of which it is uml, I believe it is cleaner to build specific applications elsewhere. That is why we proposed to do a two step build process: one that builds the kernel as a relocatable object and one that uses this object to build programs, shared libraries, etc. Besides allowing us to create multiple tools / applications it also makes it much easier to support multiple OSes or other environments (e.g. bare-metal applications). As you can see, this allowed us to remove the linker script for UML and instead just used the target compiler to build the executable.

I have no objection to the proposal. In fact I like it very much.

My only concern is that we end up with files which are named identically to already existing ones.

IMHO, the kernel relocatable object should be vmlinux.a or vmlinux.so or vmlinux.o. It should not replace an already existing file which behaves differently.