Skip to contentSkip to conversation

kernel: Introduce Time Namespace

PATCH Superseded Dmitry Safonov 6 participants 42 messages Apr 25, 2019 – May 3, 2019

Subsystems (14)
x86 VFS Kselftest MM core +10 more subsystems

v3 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#0 lore raw

v3 cover kernel: Introduce Time Namespace

Discussions around time namespace are there for a long time. The first attempt to implement it was in 2006 by Jeff Dike. From that time, the topic appears on and off in various discussions.

There are two main use cases for time namespaces:
1. change date and time inside a container;
2. adjust clocks for a container restored from a checkpoint.

“It seems like this might be one of the last major obstacles keeping migration from being used in production systems, given that not all containers and connections can be migrated as long as a time dependency is capable of messing it up.” (by github.com/dav-ell)

The kernel provides access to several clocks: CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_BOOTTIME. Last two clocks are monotonous, but the start points for them are not defined and are different for each system. When a container is migrated from one node to another, all clocks have to be restored into consistent states; in other words, they have to continue running from the same points where they have been dumped.

The main idea of this patch set is adding per-namespace offsets for system clocks. When a process in a non-root time namespace requests time of a clock, a namespace offset is added to the current value of this clock and the sum is returned.

All offsets are placed on a separate page, this allows us to map it as part of VVAR into user processes and use offsets from VDSO calls.

Now offsets are implemented for CLOCK_MONOTONIC and CLOCK_BOOTTIME clocks.

v3: Major changes:

* Simplify two VDSO images by using static_branch() in vclock_gettime() Removes unwanted conflicts with generic VDSO movement patches and simplifies things by dropping too invasive linker magic.
As an alternative to static_branch() we tested an attempt to introduce home-made dynamic patching called retcalls:
https://github.com/0x7f454c46/linux/commit/4cc0180f6d65
Considering some theoretical problems with toolchains, we decided to go with long well-tested nop-patching in static_branch(). Though, it was needed to provide backend for relative code.

* address Thomas' comments.
* add sanity checks for offsets:
- the current clock time in a namespace has to be in [0, KTIME_MAX / 2). KTIME_MAX is divided by two here to be sure that the KTIME_MAX limit is still unreachable.

v2: There are two major changes:

* Two versions of the VDSO library to avoid a performance penalty for host tasks outside time namespace (as suggested by Andy and Thomas).

As it has been discussed on timens RFC, adding a new conditional branch if (inside_time_ns) on VDSO for all processes is undesirable. It will add a penalty for everybody as branch predictor may mispredict the jump. Also there are instruction cache lines wasted on cmp/jmp.

Those effects of introducing time namespace are very much unwanted having in mind how much work have been spent on micro-optimisation VDSO code.

Addressing those problems, there are two versions of VDSO's .so:
for host tasks (without any penalty) and for processes inside of time namespace with clk_to_ns() that subtracts offsets from host's time.

* Allow to set clock offsets for a namespace only before any processes appear in it.

Now a time namespace looks similar to a pid namespace in a way how it is
created: unshare(CLONE_NEWTIME) system call creates a new time namespace, but doesn't set it to the current process. Then all children of the process will be born in the new time namespace, or a process can use the setns() system call to join a namespace.

This scheme allows to create a new time namespaces, set clock offsets and then populate the namespace with processes.

Our performance measurements show that the price of VDSO's clock_gettime() in a child time namespace is about 8% with a hot CPU cache and about 90% with a cold CPU cache. There is no performance regression for host processes outside time namespace on those tests.

We wrote two small benchmarks. The first one gettime_perf.c calls clock_gettime() in a loop for 3 seconds. It shows us performance with a hot CPU cache (more clock_gettime() cycles - the better):

        | before     | CONFIG_TIME_NS=n | host        | inside timens
--------|------------|------------------|-------------|-------------
cycles  | 139887013  | 139453003        | 139899785   | 128792458
diff (%)| 100        | 99.7             | 100         | 92

The second one gettime_perf_cold.c calls rdtsc, clock_gettime(), rdtsc and shows a difference of second and first rdtsc. We call this binary in a loop 1000 times, get 1000 values and calculate MODE for them. It should show us performance with a cold CPU cache
(lesser tsc per cycle - the better):

        | before     | CONFIG_TIME_NS=n | host        | inside timens
--------|------------|------------------|-------------|-------------
tsc     | 6748       | 6718             | 6862        | 12682
diff (%)| 100        | 99.6             | 101.7       | 188

The numbers gathered on Intel(R) Core(TM) i5-6300U CPU @ 2.40GHz.

Cc Adrian Reber <[email protected]>
Cc Andrei Vagin <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Arnd Bergmann <[email protected]>
Cc Christian Brauner <[email protected]>
Cc Cyrill Gorcunov <[email protected]>
Cc Dmitry Safonov <[email protected]>
Cc "Eric W. Biederman" <[email protected]>
Cc "H. Peter Anvin" <[email protected]>
Cc Ingo Molnar <[email protected]>
Cc Jeff Dike <[email protected]>
Cc Oleg Nesterov <[email protected]>
Cc Pavel Emelyanov <[email protected]>
Cc Shuah Khan <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Vincenzo Frascino <[email protected]>

v2: https://lore.kernel.org/lkml/[email protected]/
RFC: https://lkml.kernel.org/r/[email protected]/

Andrei Vagin (16):
ns: Introduce Time Namespace
timens: Add timens_offsets
timens: Introduce CLOCK_MONOTONIC offsets
timens: Introduce CLOCK_BOOTTIME offset
timerfd/timens: Take into account ns clock offsets posix-timers/timens: Take into account clock offsets timens/kernel: Take into account timens clock offsets in
clock_nanosleep
x86/vdso: Add offsets page in vvar
vdso: introduce timens_static_branch
timens/fs/proc: Introduce /proc/pid/timens_offsets selftest/timens: Add a test for timerfd
selftest/timens: Add a test for clock_nanosleep() selftest/timens: Add timer offsets test
x86/vdso: Align VDSO functions by CPU L1 cache line
selftests: Add a simple perf test for clock_gettime() selftest/timens: Check that a right vdso is mapped after fork and exec

Dmitry Safonov (11):
timens: Shift /proc/uptime
x86/vdso2c: Correct err messages on file opening x86/vdso2c: Convert iterator to unsigned x86/vdso/Makefile: Add vobjs32
x86/vdso: Restrict splitting VVAR VMA
x86/vdso: Rename vdso_image {.data=>.text} x86/vdso: Allocate timens vdso
x86/vdso: Switch image on setns()/unshare()/clone()
timens: Add align for timens_offsets selftest/timens: Add Time Namespace test for supported clocks selftest/timens: Add procfs selftest

 MAINTAINERS                                   |   3 +
 arch/Kconfig                                  |   5 +
 arch/x86/Kconfig                              |   1 +
 arch/x86/entry/vdso/Makefile                  |  16 +-
 arch/x86/entry/vdso/vclock_gettime.c          |  48 +++
 arch/x86/entry/vdso/vdso-layout.lds.S         |  10 +-
 arch/x86/entry/vdso/vdso2c.c                  |   7 +-
 arch/x86/entry/vdso/vdso2c.h                  |  24 +-
 arch/x86/entry/vdso/vma.c                     | 113 ++++++-
 arch/x86/include/asm/jump_label.h             |  14 +
 arch/x86/include/asm/vdso.h                   |  14 +-
 fs/proc/base.c                                | 101 ++++++
 fs/proc/namespaces.c                          |   4 +
 fs/proc/uptime.c                              |   3 +
 fs/timerfd.c                                  |   8 +-
 include/linux/hrtimer.h                       |   1 +
 include/linux/jump_label.h                    |   5 +
 include/linux/nsproxy.h                       |   2 +
 include/linux/proc_ns.h                       |   2 +
 include/linux/time_namespace.h                | 137 ++++++++
 include/linux/timens_offsets.h                |  18 +
 include/linux/user_namespace.h                |   1 +
 include/uapi/linux/sched.h                    |   1 +
 include/uapi/linux/time.h                     |   2 +
 init/Kconfig                                  |   8 +
 kernel/Makefile                               |   1 +
 kernel/fork.c                                 |   3 +-
 kernel/nsproxy.c                              |  41 ++-
 kernel/time/alarmtimer.c                      |  13 +-
 kernel/time/hrtimer.c                         |   3 +
 kernel/time/posix-stubs.c                     |  11 +-
 kernel/time/posix-timers.c                    |  27 +-
 kernel/time_namespace.c                       | 318 ++++++++++++++++++
 tools/testing/selftests/Makefile              |   1 +
 tools/testing/selftests/timens/.gitignore     |   8 +
 tools/testing/selftests/timens/Makefile       |  12 +
 .../selftests/timens/clock_nanosleep.c        | 100 ++++++
 tools/testing/selftests/timens/config         |   1 +
 tools/testing/selftests/timens/exec.c         |  91 +++++
 tools/testing/selftests/timens/gettime_perf.c |  74 ++++
 .../selftests/timens/gettime_perf_cold.c      |  63 ++++
 tools/testing/selftests/timens/log.h          |  26 ++
 tools/testing/selftests/timens/procfs.c       | 142 ++++++++
 tools/testing/selftests/timens/timens.c       | 188 +++++++++++
 tools/testing/selftests/timens/timens.h       |  63 ++++
 tools/testing/selftests/timens/timer.c        | 116 +++++++
 tools/testing/selftests/timens/timerfd.c      | 127 +++++++
 47 files changed, 1928 insertions(+), 49 deletions(-)
 create mode 100644 include/linux/time_namespace.h
 create mode 100644 include/linux/timens_offsets.h
 create mode 100644 kernel/time_namespace.c
 create mode 100644 tools/testing/selftests/timens/.gitignore
 create mode 100644 tools/testing/selftests/timens/Makefile
 create mode 100644 tools/testing/selftests/timens/clock_nanosleep.c
 create mode 100644 tools/testing/selftests/timens/config
 create mode 100644 tools/testing/selftests/timens/exec.c
 create mode 100644 tools/testing/selftests/timens/gettime_perf.c
 create mode 100644 tools/testing/selftests/timens/gettime_perf_cold.c
 create mode 100644 tools/testing/selftests/timens/log.h
 create mode 100644 tools/testing/selftests/timens/procfs.c
 create mode 100644 tools/testing/selftests/timens/timens.c
 create mode 100644 tools/testing/selftests/timens/timens.h
 create mode 100644 tools/testing/selftests/timens/timer.c
 create mode 100644 tools/testing/selftests/timens/timerfd.c
Signature · 1 line
2.21.0
#1 lore raw

PATCH v3 1/27 ns: Introduce Time Namespace

From: Andrei Vagin <[email protected]>

Time Namespace isolates clock values.

The kernel provides access to several clocks CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_BOOTTIME, etc.

CLOCK_REALTIME
System-wide clock that measures real (i.e., wall-clock) time.

CLOCK_MONOTONIC
Clock that cannot be set and represents monotonic time since some unspecified starting point.

CLOCK_BOOTTIME
Identical to CLOCK_MONOTONIC, except it also includes any time that the system is suspended.

For many users, the time namespace means the ability to changes date and time in a container (CLOCK_REALTIME).

But in a context of the checkpoint/restore functionality, monotonic and bootime clocks become interesting. Both clocks are monotonic with unspecified staring points. These clocks are widely used to measure time slices and set timers. After restoring or migrating processes, we have to guarantee that they never go backward. In an ideal case, the behavior of these clocks should be the same as for a case when a whole system is suspended. All this means that we need to be able to set CLOCK_MONOTONIC and CLOCK_BOOTTIME clocks, what can be done by adding per-namespace offsets for clocks.

A time namespace is similar to a pid namespace in a way how it is
created: unshare(CLONE_NEWTIME) system call creates a new time namespace, but doesn't set it to the current process. Then all children of the process will be born in the new time namespace, or a process can use the setns() system call to join a namespace.

This scheme allows setting clock offsets for a namespace, before any processes appear in it.

---
 MAINTAINERS                    |   2 +
 fs/proc/namespaces.c           |   4 +
 include/linux/nsproxy.h        |   2 +
 include/linux/proc_ns.h        |   2 +
 include/linux/time_namespace.h |  69 +++++++++++
 include/linux/user_namespace.h |   1 +
 include/uapi/linux/sched.h     |   1 +
 init/Kconfig                   |   7 ++
 kernel/Makefile                |   1 +
 kernel/fork.c                  |   3 +-
 kernel/nsproxy.c               |  41 +++++--
 kernel/time_namespace.c        | 215 +++++++++++++++++++++++++++++++++
 12 files changed, 340 insertions(+), 8 deletions(-)
 create mode 100644 include/linux/time_namespace.h
 create mode 100644 kernel/time_namespace.c
MAINTAINERS +2 -0
index 5c38f21aee78..b50720361de7 100644
@@ -12396,6 +12396,8 @@ T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/core
 S:	Maintained
 F:	fs/timerfd.c
 F:	include/linux/timer*
+F:	include/linux/time_namespace.h
+F:	kernel/time_namespace.c
 F:	kernel/time/*timer*
 
 POWER MANAGEMENT CORE
fs/proc/namespaces.c +4 -0
index dd2b35f78b09..8b5c720fe5d7 100644
@@ -33,6 +33,10 @@ static const struct proc_ns_operations *ns_entries[] = {
 #ifdef CONFIG_CGROUPS
 	&cgroupns_operations,
 #endif
+#ifdef CONFIG_TIME_NS
+	&timens_operations,
+	&timens_for_children_operations,
+#endif
 };
 
 static const char *proc_ns_get_link(struct dentry *dentry,
include/linux/nsproxy.h +2 -0
index 2ae1b1a4d84d..074f395b9ad2 100644
@@ -35,6 +35,8 @@ struct nsproxy {
 	struct mnt_namespace *mnt_ns;
 	struct pid_namespace *pid_ns_for_children;
 	struct net 	     *net_ns;
+	struct time_namespace *time_ns;
+	struct time_namespace *time_ns_for_children;
 	struct cgroup_namespace *cgroup_ns;
 };
 extern struct nsproxy init_nsproxy;
include/linux/proc_ns.h +2 -0
index d31cb6215905..3e6f332da465 100644
@@ -32,6 +32,8 @@ extern const struct proc_ns_operations pidns_for_children_operations;
 extern const struct proc_ns_operations userns_operations;
 extern const struct proc_ns_operations mntns_operations;
 extern const struct proc_ns_operations cgroupns_operations;
+extern const struct proc_ns_operations timens_operations;
+extern const struct proc_ns_operations timens_for_children_operations;
 
 /*
  * We always define these enumerators
include/linux/time_namespace.h new file +69 -0

69 lines not on this page · raw message

include/linux/user_namespace.h +1 -0
index d6b74b91096b..bf84f93dc411 100644
@@ -45,6 +45,7 @@ enum ucount_type {
 	UCOUNT_NET_NAMESPACES,
 	UCOUNT_MNT_NAMESPACES,
 	UCOUNT_CGROUP_NAMESPACES,
+	UCOUNT_TIME_NAMESPACES,
 #ifdef CONFIG_INOTIFY_USER
 	UCOUNT_INOTIFY_INSTANCES,
 	UCOUNT_INOTIFY_WATCHES,
include/uapi/linux/sched.h +1 -0
index 22627f80063e..adffac53c76e 100644
@@ -10,6 +10,7 @@
 #define CLONE_FS	0x00000200	/* set if fs info shared between processes */
 #define CLONE_FILES	0x00000400	/* set if open files shared between processes */
 #define CLONE_SIGHAND	0x00000800	/* set if signal handlers and blocked signals shared */
+#define CLONE_NEWTIME	0x00001000	/* New time namespace */
 #define CLONE_PTRACE	0x00002000	/* set if we want to let tracing continue on the child too */
 #define CLONE_VFORK	0x00004000	/* set if the parent wants the child to wake it up on mm_release */
 #define CLONE_PARENT	0x00008000	/* set if we want to have the same parent as the cloner */
init/Kconfig +7 -0
index 4592bf7997c0..10eebeaadfaa 100644
@@ -982,6 +982,13 @@ config UTS_NS
 	  In this namespace tasks see different info provided with the
 	  uname() system call
 
+config TIME_NS
+	bool "TIME namespace"
+	default y
+	help
+	  In this namespace boottime and monotonic clocks can be set.
+	  The time will keep going with the same pace.
+
 config IPC_NS
 	bool "IPC namespace"
 	depends on (SYSVIPC || POSIX_MQUEUE)
kernel/Makefile +1 -0
index 6c57e78817da..91a3601b84d9 100644
@@ -67,6 +67,7 @@ obj-$(CONFIG_BACKTRACE_SELF_TEST) += backtracetest.o
 obj-$(CONFIG_COMPAT) += compat.o
 obj-$(CONFIG_CGROUPS) += cgroup/
 obj-$(CONFIG_UTS_NS) += utsname.o
+obj-$(CONFIG_TIME_NS) += time_namespace.o
 obj-$(CONFIG_USER_NS) += user_namespace.o
 obj-$(CONFIG_PID_NS) += pid_namespace.o
 obj-$(CONFIG_IKCONFIG) += configs.o
kernel/fork.c +2 -1
index 9dcd18aa210b..326381a45d71 100644
@@ -2425,7 +2425,8 @@ static int check_unshare_flags(unsigned long unshare_flags)
 	if (unshare_flags & ~(CLONE_THREAD|CLONE_FS|CLONE_NEWNS|CLONE_SIGHAND|
 				CLONE_VM|CLONE_FILES|CLONE_SYSVSEM|
 				CLONE_NEWUTS|CLONE_NEWIPC|CLONE_NEWNET|
-				CLONE_NEWUSER|CLONE_NEWPID|CLONE_NEWCGROUP))
+				CLONE_NEWUSER|CLONE_NEWPID|CLONE_NEWCGROUP|
+				CLONE_NEWTIME))
 		return -EINVAL;
 	/*
 	 * Not implemented, but pretend it works if there is nothing
kernel/nsproxy.c +34 -7

88 lines not on this page · raw message

kernel/time_namespace.c new file +215 -0

215 lines not on this page · raw message

Signature · 1 line
2.21.0
#2 lore raw

Re: [PATCHv3 01/27] ns: Introduce Time Namespace

Quoted 29 lines · Dmitry Safonov

Time Namespace isolates clock values.

The kernel provides access to several clocks CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_BOOTTIME, etc.

CLOCK_REALTIME
System-wide clock that measures real (i.e., wall-clock) time.

CLOCK_MONOTONIC
Clock that cannot be set and represents monotonic time since some unspecified starting point.

CLOCK_BOOTTIME
Identical to CLOCK_MONOTONIC, except it also includes any time that the system is suspended.

For many users, the time namespace means the ability to changes date and time in a container (CLOCK_REALTIME).

But in a context of the checkpoint/restore functionality, monotonic and bootime clocks become interesting. Both clocks are monotonic with unspecified staring points. These clocks are widely used to measure time slices and set timers. After restoring or migrating processes, we have to guarantee that they never go backward. In an ideal case, the behavior of these clocks should be the same as for a case when a whole system is suspended. All this means that we need to be able to set CLOCK_MONOTONIC and CLOCK_BOOTTIME clocks, what can be done by adding per-namespace offsets for clocks.

Quoted 8 lines

A time namespace is similar to a pid namespace in a way how it is
created: unshare(CLONE_NEWTIME) system call creates a new time namespace, but doesn't set it to the current process. Then all children of the process will be born in the new time namespace, or a process can use the setns() system call to join a namespace.

This scheme allows setting clock offsets for a namespace, before any processes appear in it.

Is there a check anywhere to make sure that you can't use clone(CLONE_VM) after calling unshare(CLONE_NEWTIME), and that you can't use clone(CLONE_VM|CLONE_NEWTIME)? Those things probably shouldn't be allowed, right?

CLONE_NEWPID has similar rules; from the clone.2 manpage:

EINVAL CLONE_THREAD was specified, but the current process previously
called unshare(2) with the CLONE_NEWPID flag or used setns(2) to reassociate itself with a PID namespace.
[...]
EINVAL One (or both) of CLONE_NEWPID or CLONE_NEWUSER and one (or
both) of CLONE_THREAD or CLONE_PARENT were specified in flags.

#3 lore raw

PATCH v3 2/27 timens: Add timens_offsets

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

Introduce offsets for time namespace. They will contain an adjustment needed to convert clocks to/from host's.

Allocate one page for each time namespace that will be premapped into userspace among vvar pages.

---
 MAINTAINERS                    |  1 +
 include/linux/time_namespace.h |  1 +
 include/linux/timens_offsets.h |  8 ++++++++
 kernel/time_namespace.c        | 14 ++++++++++++--
 4 files changed, 22 insertions(+), 2 deletions(-)
 create mode 100644 include/linux/timens_offsets.h
MAINTAINERS +1 -0
index b50720361de7..6a57d94963f6 100644
@@ -12397,6 +12397,7 @@ S:	Maintained
 F:	fs/timerfd.c
 F:	include/linux/timer*
 F:	include/linux/time_namespace.h
+F:	include/linux/timens_offsets.h
 F:	kernel/time_namespace.c
 F:	kernel/time/*timer*
 
include/linux/time_namespace.h +1 -0
index 9507ed7072fe..b6985aa87479 100644
@@ -8,6 +8,7 @@
 #include <linux/nsproxy.h>
 #include <linux/ns_common.h>
 #include <linux/err.h>
+#include <linux/timens_offsets.h>
 
 struct user_namespace;
 extern struct user_namespace init_user_ns;
include/linux/timens_offsets.h new file +8 -0
new file mode 100644
index 000000000000..7d7cb68ea778
@@ -0,0 +1,8 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _LINUX_TIME_OFFSETS_H
+#define _LINUX_TIME_OFFSETS_H
+
+struct timens_offsets {
+};
+
+#endif
kernel/time_namespace.c +12 -2
index 8c600df9771d..4828447721ec 100644
@@ -13,6 +13,7 @@
 #include <linux/user_namespace.h>
 #include <linux/proc_ns.h>
 #include <linux/sched/task.h>
+#include <linux/mm.h>
 
 static struct ucounts *inc_time_namespaces(struct user_namespace *ns)
 {
@@ -46,6 +47,7 @@ static struct time_namespace *clone_time_ns(struct user_namespace *user_ns,
 {
 	struct time_namespace *ns;
 	struct ucounts *ucounts;
+	struct page *page;
 	int err;
 
 	err = -ENOSPC;
@@ -58,15 +60,22 @@ static struct time_namespace *clone_time_ns(struct user_namespace *user_ns,
 	if (!ns)
 		goto fail_dec;
 
+	page = alloc_page(GFP_KERNEL | __GFP_ZERO);
+	if (!page)
+		goto fail_free;
+	ns->offsets = page_address(page);
+	BUILD_BUG_ON(sizeof(*ns->offsets) > PAGE_SIZE);
+
 	err = ns_alloc_inum(&ns->ns);
 	if (err)
-		goto fail_free;
+		goto fail_page;
 
 	ns->ucounts = ucounts;
 	ns->ns.ops = &timens_operations;
 	ns->user_ns = get_user_ns(user_ns);
 	return ns;
-
+fail_page:
+	free_page((unsigned long)ns->offsets);
 fail_free:
 	kfree(ns);
 fail_dec:
@@ -94,6 +103,7 @@ void free_time_ns(struct kref *kref)
 	struct time_namespace *ns;
 
 	ns = container_of(kref, struct time_namespace, kref);
+	free_page((unsigned long)ns->offsets);
 	dec_time_namespaces(ns->ucounts);
 	put_user_ns(ns->user_ns);
 	ns_free_inum(&ns->ns);
Signature · 1 line
2.21.0
#4 lore raw

PATCH v3 3/27 timens: Introduce CLOCK_MONOTONIC offsets

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

Add monotonic time virtualisation for time namespace. Introduce timespec for monotionic clock into timens offsets and wire clock_gettime() syscall.

---
 include/linux/time_namespace.h |  8 ++++++++
 include/linux/timens_offsets.h |  1 +
 include/uapi/linux/time.h      |  2 ++
 kernel/time/posix-stubs.c      |  2 ++
 kernel/time/posix-timers.c     | 11 +++++++++--
 5 files changed, 22 insertions(+), 2 deletions(-)
include/linux/time_namespace.h +8 -0
index b6985aa87479..8f75d34cf34a 100644
@@ -40,6 +40,13 @@ static inline void put_time_ns(struct time_namespace *ns)
 	kref_put(&ns->kref, free_time_ns);
 }
 
+static inline void timens_add_monotonic(struct timespec64 *ts)
+{
+        struct timens_offsets *ns_offsets = current->nsproxy->time_ns->offsets;
+
+        if (ns_offsets)
+                *ts = timespec64_add(*ts, ns_offsets->monotonic_time_offset);
+}
 
 #else
 static inline struct time_namespace *get_time_ns(struct time_namespace *ns)
@@ -65,6 +72,7 @@ static inline int timens_on_fork(struct nsproxy *nsproxy, struct task_struct *ts
 	return 0;
 }
 
+static inline void timens_add_monotonic(struct timespec64 *ts) {}
 #endif
 
 #endif /* _LINUX_TIMENS_H */
include/linux/timens_offsets.h +1 -0
index 7d7cb68ea778..248b0c0bb92a 100644
@@ -3,6 +3,7 @@
 #define _LINUX_TIME_OFFSETS_H
 
 struct timens_offsets {
+	struct timespec64  monotonic_time_offset;
 };
 
 #endif
include/uapi/linux/time.h +2 -0
index 958932effc5e..32abadc68f72 100644
@@ -65,6 +65,8 @@ struct itimerval {
 #define CLOCKS_MASK			(CLOCK_REALTIME | CLOCK_MONOTONIC)
 #define CLOCKS_MONO			CLOCK_MONOTONIC
 
+#define CLOCK_TIMENS			1024
+
 /*
  * The various flags for setting POSIX.1b interval timers:
  */
kernel/time/posix-stubs.c +2 -0
index 67df65f887ac..17c67e0aecd8 100644
@@ -14,6 +14,7 @@
 #include <linux/ktime.h>
 #include <linux/timekeeping.h>
 #include <linux/posix-timers.h>
+#include <linux/time_namespace.h>
 #include <linux/compat.h>
 
 #ifdef CONFIG_ARCH_HAS_SYSCALL_WRAPPER
@@ -77,6 +78,7 @@ int do_clock_gettime(clockid_t which_clock, struct timespec64 *tp)
 		break;
 	case CLOCK_MONOTONIC:
 		ktime_get_ts64(tp);
+		timens_add_monotonic(tp);
 		break;
 	case CLOCK_BOOTTIME:
 		ktime_get_boottime_ts64(tp);
kernel/time/posix-timers.c +9 -2
index 29176635991f..a047d6b7c768 100644
@@ -30,6 +30,7 @@
 #include <linux/hashtable.h>
 #include <linux/compat.h>
 #include <linux/nospec.h>
+#include <linux/time_namespace.h>
 
 #include "timekeeping.h"
 #include "posix-timers.h"
@@ -190,6 +191,8 @@ static int posix_clock_realtime_adj(const clockid_t which_clock,
 static int posix_ktime_get_ts(clockid_t which_clock, struct timespec64 *tp)
 {
 	ktime_get_ts64(tp);
+	if (which_clock & CLOCK_TIMENS)
+		timens_add_monotonic(tp);
 	return 0;
 }
 
@@ -199,6 +202,8 @@ static int posix_ktime_get_ts(clockid_t which_clock, struct timespec64 *tp)
 static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec64 *tp)
 {
 	ktime_get_raw_ts64(tp);
+	if (which_clock & CLOCK_TIMENS)
+		timens_add_monotonic(tp);
 	return 0;
 }
 
@@ -213,6 +218,8 @@ static int posix_get_monotonic_coarse(clockid_t which_clock,
 						struct timespec64 *tp)
 {
 	ktime_get_coarse_ts64(tp);
+	if (which_clock & CLOCK_TIMENS)
+		timens_add_monotonic(tp);
 	return 0;
 }
 
@@ -1039,7 +1046,7 @@ SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
 	if (!kc)
 		return -EINVAL;
 
-	error = kc->clock_get(which_clock, &kernel_tp);
+	error = kc->clock_get(which_clock | CLOCK_TIMENS, &kernel_tp);
 
 	if (!error && put_timespec64(&kernel_tp, tp))
 		error = -EFAULT;
@@ -1121,7 +1128,7 @@ SYSCALL_DEFINE2(clock_gettime32, clockid_t, which_clock,
 	if (!kc)
 		return -EINVAL;
 
-	err = kc->clock_get(which_clock, &ts);
+	err = kc->clock_get(which_clock | CLOCK_TIMENS, &ts);
 
 	if (!err && put_old_timespec32(&ts, tp))
 		err = -EFAULT;
Signature · 1 line
2.21.0
#5 lore raw

Re: [PATCHv3 03/27] timens: Introduce CLOCK_MONOTONIC offsets

Quoted 5 lines · Dmitry Safonov

From: Andrei Vagin <[email protected]>

Add monotonic time virtualisation for time namespace. Introduce timespec for monotionic clock into timens offsets and wire clock_gettime() syscall.

That's a bit meager. It should at least explain the concept how this is supposed to work.

Quoted 2 lines

#define CLOCKS_MASK (CLOCK_REALTIME | CLOCK_MONOTONIC)
#define CLOCKS_MONO CLOCK_MONOTONIC

Unrelated to this, but those two defines can go away.

Quoted 1 line

+#define CLOCK_TIMENS 1024

Random number pulled out of thin air without any explanation. Aside of that why is this exposed to user space?

Quoted 28 lines
kernel/time/posix-stubs.c +1 -0
@@ -77,6 +78,7 @@ int do_clock_gettime(clockid_t which_clock, struct timespec64 *tp)
 		break;
 	case CLOCK_MONOTONIC:
 		ktime_get_ts64(tp);
+		timens_add_monotonic(tp);
 		break;
 	case CLOCK_BOOTTIME:
 		ktime_get_boottime_ts64(tp);
kernel/time/posix-timers.c +3 -0
index 29176635991f..a047d6b7c768 100644
@@ -30,6 +30,7 @@
 #include <linux/hashtable.h>
 #include <linux/compat.h>
 #include <linux/nospec.h>
+#include <linux/time_namespace.h>
 
 #include "timekeeping.h"
 #include "posix-timers.h"
@@ -190,6 +191,8 @@ static int posix_clock_realtime_adj(const clockid_t which_clock,
 static int posix_ktime_get_ts(clockid_t which_clock, struct timespec64 *tp)
 {
 	ktime_get_ts64(tp);
+	if (which_clock & CLOCK_TIMENS)
+		timens_add_monotonic(tp);
 

kernel/time/posix-timers.c SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock, · line 1049

Quoted 5 lines
kernel/time/posix-timers.c +1 -1
@@ -1039,7 +1046,7 @@ SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
 	if (!kc)
 		return -EINVAL;
 
-	error = kc->clock_get(which_clock, &kernel_tp);
+	error = kc->clock_get(which_clock | CLOCK_TIMENS, &kernel_tp);

Bah. After some banging the head against the wall I figured out what you are doing here. It's because kc->clock_get() is used in common_timer_get() as well and there you don't want the adjustment there. Sorry, but this is uncomprehensible and unmaintainable and adds yet another conditional into the code flow.

The callsite in common_timer_get() has already a comment:

        /*
         * The timespec64 based conversion is suboptimal, but it's not
         * worth to implement yet another callback.
         */
        kc->clock_get(timr->it_clock, &ts64);
        now = timespec64_to_ktime(ts64);

So now we have a proper justification to add that extra callback:
separation of functionality. It's trivial and not a massive code size overhead.

Thanks,

tglx

#6 lore raw

PATCH v3 4/27 timens: Introduce CLOCK_BOOTTIME offset

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

Adds boottime virtualisation for time namespace. Introduce timespec for boottime clock into timens offsets and wire clock_gettime() syscall.

---
 include/linux/time_namespace.h | 9 +++++++++
 include/linux/timens_offsets.h | 1 +
 kernel/time/alarmtimer.c       | 8 +++++++-
 kernel/time/posix-stubs.c      | 1 +
 kernel/time/posix-timers.c     | 2 ++
 5 files changed, 20 insertions(+), 1 deletion(-)
include/linux/time_namespace.h +9 -0
index 8f75d34cf34a..5f0da6858b10 100644
@@ -48,6 +48,14 @@ static inline void timens_add_monotonic(struct timespec64 *ts)
                 *ts = timespec64_add(*ts, ns_offsets->monotonic_time_offset);
 }
 
+static inline void timens_add_boottime(struct timespec64 *ts)
+{
+        struct timens_offsets *ns_offsets = current->nsproxy->time_ns->offsets;
+
+        if (ns_offsets)
+                *ts = timespec64_add(*ts, ns_offsets->monotonic_boottime_offset);
+}
+
 #else
 static inline struct time_namespace *get_time_ns(struct time_namespace *ns)
 {
@@ -73,6 +81,7 @@ static inline int timens_on_fork(struct nsproxy *nsproxy, struct task_struct *ts
 }
 
 static inline void timens_add_monotonic(struct timespec64 *ts) {}
+static inline void timens_add_boottime(struct timespec64 *ts) {}
 #endif
 
 #endif /* _LINUX_TIMENS_H */
include/linux/timens_offsets.h +1 -0
index 248b0c0bb92a..777530c46852 100644
@@ -4,6 +4,7 @@
 
 struct timens_offsets {
 	struct timespec64  monotonic_time_offset;
+	struct timespec64  monotonic_boottime_offset;
 };
 
 #endif
kernel/time/alarmtimer.c +7 -1
index 0519a8805aab..31f99361342e 100644
@@ -653,12 +653,18 @@ static int alarm_clock_getres(const clockid_t which_clock, struct timespec64 *tp
  */
 static int alarm_clock_get(clockid_t which_clock, struct timespec64 *tp)
 {
-	struct alarm_base *base = &alarm_bases[clock2alarm(which_clock)];
+	struct alarm_base *base;
+
+	base = &alarm_bases[clock2alarm(which_clock & ~CLOCK_TIMENS)];
 
 	if (!alarmtimer_get_rtcdev())
 		return -EINVAL;
 
 	*tp = ktime_to_timespec64(base->gettime());
+
+	if (which_clock == (CLOCK_BOOTTIME_ALARM | CLOCK_TIMENS))
+		timens_add_boottime(tp);
+
 	return 0;
 }
 
kernel/time/posix-stubs.c +1 -0
index 17c67e0aecd8..edaf075d1ee4 100644
@@ -82,6 +82,7 @@ int do_clock_gettime(clockid_t which_clock, struct timespec64 *tp)
 		break;
 	case CLOCK_BOOTTIME:
 		ktime_get_boottime_ts64(tp);
+		timens_add_boottime(tp);
 		break;
 	default:
 		return -EINVAL;
kernel/time/posix-timers.c +2 -0
index a047d6b7c768..a723e63d55fd 100644
@@ -232,6 +232,8 @@ static int posix_get_coarse_res(const clockid_t which_clock, struct timespec64 *
 static int posix_get_boottime(const clockid_t which_clock, struct timespec64 *tp)
 {
 	ktime_get_boottime_ts64(tp);
+	if (which_clock & CLOCK_TIMENS)
+		timens_add_boottime(tp);
 	return 0;
 }
 
Signature · 1 line
2.21.0
#7 lore raw

Re: [PATCHv3 04/27] timens: Introduce CLOCK_BOOTTIME offset

Quoted 17 lines · Dmitry Safonov
include/linux/time_namespace.h +7 -0
index 8f75d34cf34a..5f0da6858b10 100644
@@ -48,6 +48,14 @@ static inline void timens_add_monotonic(struct timespec64 *ts)
                 *ts = timespec64_add(*ts, ns_offsets->monotonic_time_offset);
 }
 
+static inline void timens_add_boottime(struct timespec64 *ts)
+{
+        struct timens_offsets *ns_offsets = current->nsproxy->time_ns->offsets;
+
+        if (ns_offsets)
+                *ts = timespec64_add(*ts, ns_offsets->monotonic_boottime_offset);
+}
 

...

include/linux/time_namespace.h

Quoted 4 lines

struct timens_offsets {

include/linux/time_namespace.h +1 -0
 	struct timespec64  monotonic_time_offset;
+	struct timespec64  monotonic_boottime_offset;
 };

Guys, is not the _offset postfix here redundant? timens_offsets already has it and ns_offsets->monotonic_boottime_offset looks too much.

static always_inline current_time_ns_offsets(void)

{
	return current->nsproxy->time_ns->offsets;
}

static inline void timens_add_boottime(struct timespec64 *ts)

{
	struct timens_offsets *tns_off = current_time_ns_offsets();

	if (tns_off)
		*ts = timespec64_add(*ts, tns_off->monotonic_boottime);
}

Hmm? Up to you though.

#8 lore raw

PATCH v3 5/27 timerfd/timens: Take into account ns clock offsets

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

Make timerfd respect timens offsets.
Provide a helper timens_ktime_to_host() that is useful to wire up timens to different kernel subsystems.

---
 fs/timerfd.c                   |  8 +++++--
 include/linux/hrtimer.h        |  1 +
 include/linux/time_namespace.h | 40 ++++++++++++++++++++++++++++++++++
 kernel/time/hrtimer.c          |  3 +++
 4 files changed, 50 insertions(+), 2 deletions(-)
fs/timerfd.c +6 -2
index 6a6fc8aa1de7..a55ade09eee1 100644
@@ -26,6 +26,7 @@
 #include <linux/syscalls.h>
 #include <linux/compat.h>
 #include <linux/rcupdate.h>
+#include <linux/time_namespace.h>
 
 struct timerfd_ctx {
 	union {
@@ -179,6 +180,8 @@ static int timerfd_setup(struct timerfd_ctx *ctx, int flags,
 	htmode = (flags & TFD_TIMER_ABSTIME) ?
 		HRTIMER_MODE_ABS: HRTIMER_MODE_REL;
 
+	htmode |= HRTIMER_MODE_NS;
+
 	texp = timespec64_to_ktime(ktmr->it_value);
 	ctx->expired = 0;
 	ctx->ticks = 0;
@@ -197,9 +200,10 @@ static int timerfd_setup(struct timerfd_ctx *ctx, int flags,
 
 	if (texp != 0) {
 		if (isalarm(ctx)) {
-			if (flags & TFD_TIMER_ABSTIME)
+			if (flags & TFD_TIMER_ABSTIME) {
+				texp = timens_ktime_to_host(clockid, texp);
 				alarm_start(&ctx->t.alarm, texp);
-			else
+			} else
 				alarm_start_relative(&ctx->t.alarm, texp);
 		} else {
 			hrtimer_start(&ctx->t.tmr, texp, htmode);
include/linux/hrtimer.h +1 -0
index 2e8957eac4d4..4b9c89c797ee 100644
@@ -38,6 +38,7 @@ enum hrtimer_mode {
 	HRTIMER_MODE_REL	= 0x01,
 	HRTIMER_MODE_PINNED	= 0x02,
 	HRTIMER_MODE_SOFT	= 0x04,
+	HRTIMER_MODE_NS		= 0x08,
 
 	HRTIMER_MODE_ABS_PINNED = HRTIMER_MODE_ABS | HRTIMER_MODE_PINNED,
 	HRTIMER_MODE_REL_PINNED = HRTIMER_MODE_REL | HRTIMER_MODE_PINNED,
include/linux/time_namespace.h +40 -0
index 5f0da6858b10..988414f7f791 100644
@@ -56,6 +56,41 @@ static inline void timens_add_boottime(struct timespec64 *ts)
                 *ts = timespec64_add(*ts, ns_offsets->monotonic_boottime_offset);
 }
 
+static inline ktime_t timens_ktime_to_host(clockid_t clockid, ktime_t tim)
+{
+	struct timens_offsets *ns_offsets = current->nsproxy->time_ns->offsets;
+	struct timespec64 *offset;
+	ktime_t koff;
+
+	if (!ns_offsets)
+		return tim;
+
+	switch (clockid) {
+		case CLOCK_MONOTONIC:
+		case CLOCK_MONOTONIC_RAW:
+		case CLOCK_MONOTONIC_COARSE:
+			offset = &ns_offsets->monotonic_time_offset;
+			break;
+		case CLOCK_BOOTTIME:
+		case CLOCK_BOOTTIME_ALARM:
+			offset = &ns_offsets->monotonic_boottime_offset;
+			break;
+		default:
+			return tim;
+	}
+
+	koff = timespec64_to_ktime(*offset);
+	if (tim < koff)
+		tim = 0;
+	else if (KTIME_MAX - tim < -koff)
+		tim = KTIME_MAX;
+	else
+		tim = ktime_sub(tim, koff);
+
+	return tim;
+}
+
+
 #else
 static inline struct time_namespace *get_time_ns(struct time_namespace *ns)
 {
@@ -82,6 +117,11 @@ static inline int timens_on_fork(struct nsproxy *nsproxy, struct task_struct *ts
 
 static inline void timens_add_monotonic(struct timespec64 *ts) {}
 static inline void timens_add_boottime(struct timespec64 *ts) {}
+
+static inline ktime_t timens_ktime_to_host(clockid_t clockid, ktime_t tim)
+{
+	return tim;
+}
 #endif
 
 #endif /* _LINUX_TIMENS_H */
kernel/time/hrtimer.c +3 -0
index 41dfff23c1f9..484a0efec1df 100644
@@ -42,6 +42,7 @@
 #include <linux/timer.h>
 #include <linux/freezer.h>
 #include <linux/compat.h>
+#include <linux/time_namespace.h>
 
 #include <linux/uaccess.h>
 
@@ -1069,6 +1070,8 @@ static int __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
 
 	if (mode & HRTIMER_MODE_REL)
 		tim = ktime_add_safe(tim, base->get_time());
+	else if (mode & HRTIMER_MODE_NS)
+		tim = timens_ktime_to_host(base->clockid, tim);
 
 	tim = hrtimer_update_lowres(timer, tim, mode);
 
Signature · 1 line
2.21.0
#9 lore raw

Re: [PATCHv3 05/27] timerfd/timens: Take into account ns clock offsets

Quoted 5 lines · Dmitry Safonov

From: Andrei Vagin <[email protected]>

Make timerfd respect timens offsets.
Provide a helper timens_ktime_to_host() that is useful to wire up timens to different kernel subsystems.

Yet another changelog which lacks meat.

fs/timerfd.c static int timerfd_setup(struct timerfd_ctx *ctx, int flags, · line 183

Quoted 5 lines
fs/timerfd.c +1 -0
@@ -179,6 +180,8 @@ static int timerfd_setup(struct timerfd_ctx *ctx, int flags,
 	htmode = (flags & TFD_TIMER_ABSTIME) ?
 		HRTIMER_MODE_ABS: HRTIMER_MODE_REL;
 
+	htmode |= HRTIMER_MODE_NS;

Without looking further this time. My gut reaction is that this is wrong. Name space adjustment is only valid for absolute timers not for relative timers.

Aside of that the name sucks. MODE_NS is really not intuitive. It could be NanoSeconds or whatever and quite some time(r) functions have a _ns element already. Please look for something more inuitive and clearly related to namespaces. We are not short of letters.

fs/timerfd.c static int timerfd_setup(struct timerfd_ctx *ctx, int flags, · line 204

Quoted 10 lines
fs/timerfd.c +2 -1
 	texp = timespec64_to_ktime(ktmr->it_value);
 	ctx->expired = 0;
 	ctx->ticks = 0;
@@ -197,9 +200,10 @@ static int timerfd_setup(struct timerfd_ctx *ctx, int flags,
 
 	if (texp != 0) {
 		if (isalarm(ctx)) {
-			if (flags & TFD_TIMER_ABSTIME)
+			if (flags & TFD_TIMER_ABSTIME) {
+				texp = timens_ktime_to_host(clockid, texp);

You are not serious about that inline function here? It's huge and pointless bloat because the only time affected here is boot time, but the compiler does not know that.

fs/timerfd.c static int timerfd_setup(struct timerfd_ctx *ctx, int flags, · line 205

Quoted 1 line
fs/timerfd.c +0 -0
 				alarm_start(&ctx->t.alarm, texp);

Make that:

alarm_start_namespace(.....)

and that does:

void alarm_start_namespace(struct alarm *alarm, ktime_t expires)

{
	if (alarm->type == ALARM_BOOTTIME)
		expires = timens_sub_boottime(expires);
	alarm_start(alarm, expires);
}

Hmm?

Quoted 28 lines
fs/timerfd.c +1 -1
-			else
+			} else
 				alarm_start_relative(&ctx->t.alarm, texp);
 		} else {
 			hrtimer_start(&ctx->t.tmr, texp, htmode);
include/linux/hrtimer.h +1 -0
index 2e8957eac4d4..4b9c89c797ee 100644
@@ -38,6 +38,7 @@ enum hrtimer_mode {
 	HRTIMER_MODE_REL	= 0x01,
 	HRTIMER_MODE_PINNED	= 0x02,
 	HRTIMER_MODE_SOFT	= 0x04,
+	HRTIMER_MODE_NS		= 0x08,
 
 	HRTIMER_MODE_ABS_PINNED = HRTIMER_MODE_ABS | HRTIMER_MODE_PINNED,
 	HRTIMER_MODE_REL_PINNED = HRTIMER_MODE_REL | HRTIMER_MODE_PINNED,
include/linux/time_namespace.h +3 -0
index 5f0da6858b10..988414f7f791 100644
@@ -56,6 +56,41 @@ static inline void timens_add_boottime(struct timespec64 *ts)
                 *ts = timespec64_add(*ts, ns_offsets->monotonic_boottime_offset);
 }
 
+static inline ktime_t timens_ktime_to_host(clockid_t clockid, ktime_t tim)
+{
+	struct timens_offsets *ns_offsets = current->nsproxy->time_ns->offsets;

include/linux/time_namespace.h static inline void timens_add_boottime(struct timespec64 *ts) · line 71

Quoted 10 lines
include/linux/time_namespace.h +10 -0
+	struct timespec64 *offset;
+	ktime_t koff;
+
+	if (!ns_offsets)
+		return tim;
+
+	switch (clockid) {
+		case CLOCK_MONOTONIC:
+		case CLOCK_MONOTONIC_RAW:
+		case CLOCK_MONOTONIC_COARSE:

What's the point of COARSE and RAW? Neither of them can be used to arm timers.

include/linux/time_namespace.h static inline void timens_add_boottime(struct timespec64 *ts) · line 82

Quoted 11 lines
include/linux/time_namespace.h +11 -0
+			offset = &ns_offsets->monotonic_time_offset;
+			break;
+		case CLOCK_BOOTTIME:
+		case CLOCK_BOOTTIME_ALARM:
+			offset = &ns_offsets->monotonic_boottime_offset;
+			break;
+		default:
+			return tim;
+	}
+
+	koff = timespec64_to_ktime(*offset);

What about storing both the timespec and the ktime_t representation?

include/linux/time_namespace.h static inline void timens_add_boottime(struct timespec64 *ts) · line 86

Quoted 4 lines
include/linux/time_namespace.h +4 -0
+	if (tim < koff)
+		tim = 0;
+	else if (KTIME_MAX - tim < -koff)
+		tim = KTIME_MAX;

Blink!?! This is completely nonobvious and you're going to stare at it in disbelief half a year from now. Comments exist for a reason.

include/linux/time_namespace.h static inline void timens_add_boottime(struct timespec64 *ts) · line 90

Quoted 4 lines
include/linux/time_namespace.h +4 -0
+	else
+		tim = ktime_sub(tim, koff);
+
+	return tim;

This whole thing is way too large for inlining.

Please create a function which does the magic substraction, something like ktime_sub_namespace_offset() and invoke it from the proper places, i.e. the alarmtimer one.

include/linux/time_namespace.h static int __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, · line 1074

Quoted 6 lines
include/linux/time_namespace.h +2 -0
@@ -1069,6 +1070,8 @@ static int __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
 
 	if (mode & HRTIMER_MODE_REL)
 		tim = ktime_add_safe(tim, base->get_time());
+	else if (mode & HRTIMER_MODE_NS)
+		tim = timens_ktime_to_host(base->clockid, tim);

You can do the same as for alarmtime above:

hrtimer_start_namespace(struct hrtimer *timer, ktime_t tim,
const enum hrtimer_mode mode)

{
	if (mode & HRTIMER_MODE_ABS) {
		switch(timer->base->clockid) {
		case CLOCK_MONOTONIC:
			tim = timens_sub_monotonic(tim);
			break;
		case CLOCK_BOOTTIME:
			tim = timens_sub_boottime(tim);
			break;
		}
	}
	hrtimer_start(timer, tim, mode);
}

Thanks,

tglx

#10 lore raw

Re: [PATCHv3 05/27] timerfd/timens: Take into account ns clock offsets

Hi Thomas,

Thank you for the review. I read your comments. All of them look reasonable. I'm sorry that you had to comment a lot. Will fix in the next version.

Thanks,
Andrei

Quoted 159 lines · Thomas Gleixner
Quoted 5 lines · Dmitry Safonov

From: Andrei Vagin <[email protected]>

Make timerfd respect timens offsets.
Provide a helper timens_ktime_to_host() that is useful to wire up timens to different kernel subsystems.

Yet another changelog which lacks meat.

fs/timerfd.c static int timerfd_setup(struct timerfd_ctx *ctx, int flags, · line 183

Quoted 5 lines
fs/timerfd.c +1 -0
@@ -179,6 +180,8 @@ static int timerfd_setup(struct timerfd_ctx *ctx, int flags,
 	htmode = (flags & TFD_TIMER_ABSTIME) ?
 		HRTIMER_MODE_ABS: HRTIMER_MODE_REL;
 
+	htmode |= HRTIMER_MODE_NS;

Without looking further this time. My gut reaction is that this is wrong. Name space adjustment is only valid for absolute timers not for relative timers.

Aside of that the name sucks. MODE_NS is really not intuitive. It could be NanoSeconds or whatever and quite some time(r) functions have a _ns element already. Please look for something more inuitive and clearly related to namespaces. We are not short of letters.

fs/timerfd.c static int timerfd_setup(struct timerfd_ctx *ctx, int flags, · line 204

Quoted 10 lines
fs/timerfd.c +2 -1
 	texp = timespec64_to_ktime(ktmr->it_value);
 	ctx->expired = 0;
 	ctx->ticks = 0;
@@ -197,9 +200,10 @@ static int timerfd_setup(struct timerfd_ctx *ctx, int flags,
 
 	if (texp != 0) {
 		if (isalarm(ctx)) {
-			if (flags & TFD_TIMER_ABSTIME)
+			if (flags & TFD_TIMER_ABSTIME) {
+				texp = timens_ktime_to_host(clockid, texp);

You are not serious about that inline function here? It's huge and pointless bloat because the only time affected here is boot time, but the compiler does not know that.

fs/timerfd.c static int timerfd_setup(struct timerfd_ctx *ctx, int flags, · line 205

Quoted 1 line
fs/timerfd.c +0 -0
 				alarm_start(&ctx->t.alarm, texp);

Make that:

   alarm_start_namespace(.....)

and that does:

void alarm_start_namespace(struct alarm *alarm, ktime_t expires)

{
	if (alarm->type == ALARM_BOOTTIME)
		expires = timens_sub_boottime(expires);
	alarm_start(alarm, expires);
}

Hmm?

Quoted 28 lines
fs/timerfd.c +1 -1
-			else
+			} else
 				alarm_start_relative(&ctx->t.alarm, texp);
 		} else {
 			hrtimer_start(&ctx->t.tmr, texp, htmode);
include/linux/hrtimer.h +1 -0
index 2e8957eac4d4..4b9c89c797ee 100644
@@ -38,6 +38,7 @@ enum hrtimer_mode {
 	HRTIMER_MODE_REL	= 0x01,
 	HRTIMER_MODE_PINNED	= 0x02,
 	HRTIMER_MODE_SOFT	= 0x04,
+	HRTIMER_MODE_NS		= 0x08,
 
 	HRTIMER_MODE_ABS_PINNED = HRTIMER_MODE_ABS | HRTIMER_MODE_PINNED,
 	HRTIMER_MODE_REL_PINNED = HRTIMER_MODE_REL | HRTIMER_MODE_PINNED,
include/linux/time_namespace.h +3 -0
index 5f0da6858b10..988414f7f791 100644
@@ -56,6 +56,41 @@ static inline void timens_add_boottime(struct timespec64 *ts)
                 *ts = timespec64_add(*ts, ns_offsets->monotonic_boottime_offset);
 }
 
+static inline ktime_t timens_ktime_to_host(clockid_t clockid, ktime_t tim)
+{
+	struct timens_offsets *ns_offsets = current->nsproxy->time_ns->offsets;

include/linux/time_namespace.h static inline void timens_add_boottime(struct timespec64 *ts) · line 71

Quoted 10 lines
include/linux/time_namespace.h +10 -0
+	struct timespec64 *offset;
+	ktime_t koff;
+
+	if (!ns_offsets)
+		return tim;
+
+	switch (clockid) {
+		case CLOCK_MONOTONIC:
+		case CLOCK_MONOTONIC_RAW:
+		case CLOCK_MONOTONIC_COARSE:

What's the point of COARSE and RAW? Neither of them can be used to arm timers.

include/linux/time_namespace.h static inline void timens_add_boottime(struct timespec64 *ts) · line 82

Quoted 11 lines
include/linux/time_namespace.h +11 -0
+			offset = &ns_offsets->monotonic_time_offset;
+			break;
+		case CLOCK_BOOTTIME:
+		case CLOCK_BOOTTIME_ALARM:
+			offset = &ns_offsets->monotonic_boottime_offset;
+			break;
+		default:
+			return tim;
+	}
+
+	koff = timespec64_to_ktime(*offset);

What about storing both the timespec and the ktime_t representation?

include/linux/time_namespace.h static inline void timens_add_boottime(struct timespec64 *ts) · line 86

Quoted 4 lines
include/linux/time_namespace.h +4 -0
+	if (tim < koff)
+		tim = 0;
+	else if (KTIME_MAX - tim < -koff)
+		tim = KTIME_MAX;

Blink!?! This is completely nonobvious and you're going to stare at it in disbelief half a year from now. Comments exist for a reason.

include/linux/time_namespace.h static inline void timens_add_boottime(struct timespec64 *ts) · line 90

Quoted 4 lines
include/linux/time_namespace.h +4 -0
+	else
+		tim = ktime_sub(tim, koff);
+
+	return tim;

This whole thing is way too large for inlining.

Please create a function which does the magic substraction, something like ktime_sub_namespace_offset() and invoke it from the proper places, i.e. the alarmtimer one.

include/linux/time_namespace.h static int __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, · line 1074

Quoted 6 lines
include/linux/time_namespace.h +2 -0
@@ -1069,6 +1070,8 @@ static int __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
 
 	if (mode & HRTIMER_MODE_REL)
 		tim = ktime_add_safe(tim, base->get_time());
+	else if (mode & HRTIMER_MODE_NS)
+		tim = timens_ktime_to_host(base->clockid, tim);

You can do the same as for alarmtime above:

hrtimer_start_namespace(struct hrtimer *timer, ktime_t tim,
const enum hrtimer_mode mode)

{
	if (mode & HRTIMER_MODE_ABS) {
		switch(timer->base->clockid) {
		case CLOCK_MONOTONIC:
			tim = timens_sub_monotonic(tim);
			break;
		case CLOCK_BOOTTIME:
			tim = timens_sub_boottime(tim);
			break;
		}
	}
	hrtimer_start(timer, tim, mode);
}

Thanks,

tglx

#11 lore raw

PATCH v3 6/27 posix-timers/timens: Take into account clock offsets

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

Wire timer_settime() syscall into time namespace virtualization.

---
 kernel/time/alarmtimer.c   | 3 +++
 kernel/time/posix-timers.c | 2 ++
 2 files changed, 5 insertions(+)
kernel/time/alarmtimer.c +3 -0
index 31f99361342e..23f5c39c8d23 100644
@@ -26,6 +26,7 @@
 #include <linux/freezer.h>
 #include <linux/compat.h>
 #include <linux/module.h>
+#include <linux/time_namespace.h>
 
 #include "posix-timers.h"
 
@@ -621,6 +622,8 @@ static void alarm_timer_arm(struct k_itimer *timr, ktime_t expires,
 
 	if (!absolute)
 		expires = ktime_add_safe(expires, base->gettime());
+	else
+		expires = timens_ktime_to_host(base->base_clockid, expires);
 	if (sigev_none)
 		alarm->node.expires = expires;
 	else
kernel/time/posix-timers.c +2 -0
index a723e63d55fd..7922731f98cd 100644
@@ -803,6 +803,8 @@ static void common_hrtimer_arm(struct k_itimer *timr, ktime_t expires,
 
 	if (!absolute)
 		expires = ktime_add_safe(expires, timer->base->get_time());
+	else
+		expires = timens_ktime_to_host(timer->base->clockid, expires);
 	hrtimer_set_expires(timer, expires);
 
 	if (!sigev_none)
Signature · 1 line
2.21.0
#12 lore raw

Re: [PATCHv3 06/27] posix-timers/timens: Take into account clock offsets

Quoted 38 lines · Dmitry Safonov

From: Andrei Vagin <[email protected]>

Wire timer_settime() syscall into time namespace virtualization.

---
 kernel/time/alarmtimer.c   | 3 +++
 kernel/time/posix-timers.c | 2 ++
 2 files changed, 5 insertions(+)
kernel/time/alarmtimer.c +3 -0
index 31f99361342e..23f5c39c8d23 100644
@@ -26,6 +26,7 @@
 #include <linux/freezer.h>
 #include <linux/compat.h>
 #include <linux/module.h>
+#include <linux/time_namespace.h>
 
 #include "posix-timers.h"
 
@@ -621,6 +622,8 @@ static void alarm_timer_arm(struct k_itimer *timr, ktime_t expires,
 
 	if (!absolute)
 		expires = ktime_add_safe(expires, base->gettime());
+	else
+		expires = timens_ktime_to_host(base->base_clockid, expires);
 
 	if (sigev_none)
 		alarm->node.expires = expires;
kernel/time/alarmtimer.c +0 -0
 	else
kernel/time/posix-timers.c +0 -0
index a723e63d55fd..7922731f98cd 100644

kernel/time/posix-timers.c static void common_hrtimer_arm(struct k_itimer *timr, ktime_t expires, · line 808

Quoted 6 lines
kernel/time/posix-timers.c +2 -0
@@ -803,6 +803,8 @@ static void common_hrtimer_arm(struct k_itimer *timr, ktime_t expires,
 
 	if (!absolute)
 		expires = ktime_add_safe(expires, timer->base->get_time());
+	else
+		expires = timens_ktime_to_host(timer->base->clockid, expires);
 	hrtimer_set_expires(timer, expires);

So you have now two places where you do that adjustment. Why? And why in the timer_arm() callback? The obvious place to do that is in common_timer_set().

- expires = timespec64_to_ktime(new_setting->it_value);
+ expires = timespec64_to_host(timr->it_clock, &new_setting->it_value);

static ktime_t timespec64_to_host(clockid_t which, struct timespec64 val)

{
	ktime_t expires = timespec64_to_ktime(val);
#ifdef NAMESPACE
	switch (which) {
	case CLOCK_MONOTONIC:
		return timens_sub_monotonic(expires);
	case CLOCK_BOOTTINE:
	case CLOCK_BOOTTIME_ALARM:
		return timens_sub_boottime(expires);
	}
#endif
	return expires;
}

Thanks,

tglx

#13 lore raw

PATCH v3 7/27 timens/kernel: Take into account timens clock offsets in clock_nanosleep

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

Wire up clock_nanosleep() to timens offsets.

---
 kernel/time/alarmtimer.c   |  2 ++
 kernel/time/posix-stubs.c  |  8 ++++----
 kernel/time/posix-timers.c | 12 ++++++++++--
 3 files changed, 16 insertions(+), 6 deletions(-)
kernel/time/alarmtimer.c +2 -0
index 23f5c39c8d23..409d518acbb3 100644
@@ -816,6 +816,8 @@ static int alarm_timer_nsleep(const clockid_t which_clock, int flags,
 		ktime_t now = alarm_bases[type].gettime();
 
 		exp = ktime_add_safe(now, exp);
+	} else {
+		exp = timens_ktime_to_host(alarm_bases[type].base_clockid, exp);
 	}
 
 	ret = alarmtimer_do_nsleep(&alarm, exp, type);
kernel/time/posix-stubs.c +4 -4
index edaf075d1ee4..f319d51e2e01 100644
@@ -147,8 +147,8 @@ SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
 		rmtp = NULL;
 	current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
 	current->restart_block.nanosleep.rmtp = rmtp;
-	return hrtimer_nanosleep(&t, flags & TIMER_ABSTIME ?
-				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
+	return hrtimer_nanosleep(&t, HRTIMER_MODE_NS | (flags & TIMER_ABSTIME ?
+				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL),
 				 which_clock);
 }
 
@@ -233,8 +233,8 @@ SYSCALL_DEFINE4(clock_nanosleep_time32, clockid_t, which_clock, int, flags,
 		rmtp = NULL;
 	current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
 	current->restart_block.nanosleep.compat_rmtp = rmtp;
-	return hrtimer_nanosleep(&t, flags & TIMER_ABSTIME ?
-				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
+	return hrtimer_nanosleep(&t, HRTIMER_MODE_NS | (flags & TIMER_ABSTIME ?
+				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL),
 				 which_clock);
 }
 #endif
kernel/time/posix-timers.c +10 -2
index 7922731f98cd..39c0330464a3 100644
@@ -1188,6 +1188,14 @@ static int common_nsleep(const clockid_t which_clock, int flags,
 				 which_clock);
 }
 
+static int common_nsleep_timens(const clockid_t which_clock, int flags,
+			 const struct timespec64 *rqtp)
+{
+	return hrtimer_nanosleep(rqtp, HRTIMER_MODE_NS | (flags & TIMER_ABSTIME ?
+				 HRTIMER_MODE_ABS : HRTIMER_MODE_REL),
+				 which_clock);
+}
+
 SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
 		const struct __kernel_timespec __user *, rqtp,
 		struct __kernel_timespec __user *, rmtp)
@@ -1262,7 +1270,7 @@ static const struct k_clock clock_realtime = {
 static const struct k_clock clock_monotonic = {
 	.clock_getres		= posix_get_hrtimer_res,
 	.clock_get		= posix_ktime_get_ts,
-	.nsleep			= common_nsleep,
+	.nsleep			= common_nsleep_timens,
 	.timer_create		= common_timer_create,
 	.timer_set		= common_timer_set,
 	.timer_get		= common_timer_get,
@@ -1307,7 +1315,7 @@ static const struct k_clock clock_tai = {
 static const struct k_clock clock_boottime = {
 	.clock_getres		= posix_get_hrtimer_res,
 	.clock_get		= posix_get_boottime,
-	.nsleep			= common_nsleep,
+	.nsleep			= common_nsleep_timens,
 	.timer_create		= common_timer_create,
 	.timer_set		= common_timer_set,
 	.timer_get		= common_timer_get,
Signature · 1 line
2.21.0
#14 lore raw

PATCH v3 8/27 timens: Shift /proc/uptime

In reply to Dmitry Safonov

Respect boottime inside time namespace for /proc/uptime

---
 fs/proc/uptime.c | 3 +++
 1 file changed, 3 insertions(+)
fs/proc/uptime.c +3 -0
index a4c2791ab70b..5a1b228964fb 100644
@@ -5,6 +5,7 @@
 #include <linux/sched.h>
 #include <linux/seq_file.h>
 #include <linux/time.h>
+#include <linux/time_namespace.h>
 #include <linux/kernel_stat.h>
 
 static int uptime_proc_show(struct seq_file *m, void *v)
@@ -20,6 +21,8 @@ static int uptime_proc_show(struct seq_file *m, void *v)
 		nsec += (__force u64) kcpustat_cpu(i).cpustat[CPUTIME_IDLE];
 
 	ktime_get_boottime_ts64(&uptime);
+	timens_add_boottime(&uptime);
+
 	idle.tv_sec = div_u64_rem(nsec, NSEC_PER_SEC, &rem);
 	idle.tv_nsec = rem;
 	seq_printf(m, "%lu.%02lu %lu.%02lu\n",
Signature · 1 line
2.21.0
#15 lore raw

PATCH v3 9/27 x86/vdso2c: Correct err messages on file opening

In reply to Dmitry Safonov

err() message in main() is misleading: it should print outfilename, which is argv[3], not argv[2].

Correct error messages to be more precise about what failed and for which file.

---
 arch/x86/entry/vdso/vdso2c.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
arch/x86/entry/vdso/vdso2c.c +2 -2
index 8e470b018512..26d7177c119e 100644
@@ -187,7 +187,7 @@ static void map_input(const char *name, void **addr, size_t *len, int prot)
 
 	int fd = open(name, O_RDONLY);
 	if (fd == -1)
-		err(1, "%s", name);
+		err(1, "open(%s)", name);
 
 	tmp_len = lseek(fd, 0, SEEK_END);
 	if (tmp_len == (off_t)-1)
@@ -240,7 +240,7 @@ int main(int argc, char **argv)
 	outfilename = argv[3];
 	outfile = fopen(outfilename, "w");
 	if (!outfile)
-		err(1, "%s", argv[2]);
+		err(1, "fopen(%s)", outfilename);
 
 	go(raw_addr, raw_len, stripped_addr, stripped_len, outfile, name);
 
Signature · 1 line
2.21.0
#16 lore raw

PATCH v3 10/27 x86/vdso2c: Convert iterator to unsigned

In reply to Dmitry Safonov

i and j are used everywhere with unsigned types.
Cleanup and prettify the code a bit.

Introduce syms_nr for readability and as a preparation for allocating an array of vDSO entries that will be needed for creating two vdso .so's:
one for host tasks and another for processes inside time namespace.

---
 arch/x86/entry/vdso/vdso2c.h | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)
arch/x86/entry/vdso/vdso2c.h +4 -5
index fa847a620f40..61c8bb2e5af8 100644
@@ -13,7 +13,7 @@ static void BITSFUNC(go)(void *raw_addr, size_t raw_len,
 	unsigned long load_size = -1;  /* Work around bogus warning */
 	unsigned long mapping_size;
 	ELF(Ehdr) *hdr = (ELF(Ehdr) *)raw_addr;
-	int i;
+	unsigned int i, syms_nr;
 	unsigned long j;
 	ELF(Shdr) *symtab_hdr = NULL, *strtab_hdr, *secstrings_hdr,
 		*alt_sec = NULL;
@@ -86,11 +86,10 @@ static void BITSFUNC(go)(void *raw_addr, size_t raw_len,
 	strtab_hdr = raw_addr + GET_LE(&hdr->e_shoff) +
 		GET_LE(&hdr->e_shentsize) * GET_LE(&symtab_hdr->sh_link);
 
+	syms_nr = GET_LE(&symtab_hdr->sh_size) / GET_LE(&symtab_hdr->sh_entsize);
 	/* Walk the symbol table */
-	for (i = 0;
-	     i < GET_LE(&symtab_hdr->sh_size) / GET_LE(&symtab_hdr->sh_entsize);
-	     i++) {
-		int k;
+	for (i = 0; i < syms_nr; i++) {
+		unsigned int k;
 		ELF(Sym) *sym = raw_addr + GET_LE(&symtab_hdr->sh_offset) +
 			GET_LE(&symtab_hdr->sh_entsize) * i;
 		const char *name = raw_addr + GET_LE(&strtab_hdr->sh_offset) +
Signature · 1 line
2.21.0
#17 lore raw

PATCH v3 11/27 x86/vdso/Makefile: Add vobjs32

In reply to Dmitry Safonov

Treat ia32/i386 objects in array the same As for 64-bit vdso objects. This is a preparation ground to avoid code duplication on introduction timens vdso.

---
 arch/x86/entry/vdso/Makefile | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)
arch/x86/entry/vdso/Makefile +5 -10
index 5bfe2243a08f..bc0bdbf49397 100644
@@ -18,6 +18,8 @@ VDSO32-$(CONFIG_IA32_EMULATION)	:= y
 
 # files to link into the vdso
 vobjs-y := vdso-note.o vclock_gettime.o vgetcpu.o
+vobjs32-y := vdso32/note.o vdso32/system_call.o vdso32/sigreturn.o
+vobjs32-y += vdso32/vclock_gettime.o
 
 # files to link into kernel
 obj-y				+= vma.o
@@ -31,10 +33,12 @@ vdso_img-$(VDSO32-y)		+= 32
 obj-$(VDSO32-y)			+= vdso32-setup.o
 
 vobjs := $(foreach F,$(vobjs-y),$(obj)/$F)
+vobjs32 := $(foreach F,$(vobjs32-y),$(obj)/$F)
 
 $(obj)/vdso.o: $(obj)/vdso.so
 
 targets += vdso.lds $(vobjs-y)
+targets += vdso32/vdso32.lds $(vobjs32-y)
 
 # Build the vDSO image C files and link them in.
 vdso_img_objs := $(vdso_img-y:%=vdso-image-%.o)
@@ -125,10 +129,6 @@ $(obj)/vdsox32.so.dbg: $(obj)/vdsox32.lds $(vobjx32s) FORCE
 CPPFLAGS_vdso32.lds = $(CPPFLAGS_vdso.lds)
 VDSO_LDFLAGS_vdso32.lds = -m elf_i386 -soname linux-gate.so.1
 
-targets += vdso32/vdso32.lds
-targets += vdso32/note.o vdso32/system_call.o vdso32/sigreturn.o
-targets += vdso32/vclock_gettime.o
-
 KBUILD_AFLAGS_32 := $(filter-out -m64,$(KBUILD_AFLAGS)) -DBUILD_VDSO
 $(obj)/vdso32.so.dbg: KBUILD_AFLAGS = $(KBUILD_AFLAGS_32)
 $(obj)/vdso32.so.dbg: asflags-$(CONFIG_X86_64) += -m32
@@ -153,12 +153,7 @@ endif
 
 $(obj)/vdso32.so.dbg: KBUILD_CFLAGS = $(KBUILD_CFLAGS_32)
 
-$(obj)/vdso32.so.dbg: FORCE \
-		      $(obj)/vdso32/vdso32.lds \
-		      $(obj)/vdso32/vclock_gettime.o \
-		      $(obj)/vdso32/note.o \
-		      $(obj)/vdso32/system_call.o \
-		      $(obj)/vdso32/sigreturn.o
+$(obj)/vdso32.so.dbg: $(obj)/vdso32/vdso32.lds $(vobjs32) FORCE
 	$(call if_changed,vdso)
 
 #
Signature · 1 line
2.21.0
#18 lore raw

PATCH v3 12/27 x86/vdso: Restrict splitting VVAR VMA

In reply to Dmitry Safonov

Although, time namespace can work with VVAR VMA split, it seems worth to forbid splitting VVAR resulting in stricter ABI and reducing amount of corner-cases to consider while working further on VDSO.

I don't think there is any use-case for partial mremap() of vvar, but if there is any - this patch can be easily reverted.

---
 arch/x86/entry/vdso/vma.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)
arch/x86/entry/vdso/vma.c +13 -0
index babc4e7a519c..ff9875a4d53b 100644
@@ -84,6 +84,18 @@ static int vdso_mremap(const struct vm_special_mapping *sm,
 	return 0;
 }
 
+static int vvar_mremap(const struct vm_special_mapping *sm,
+		struct vm_area_struct *new_vma)
+{
+	unsigned long new_size = new_vma->vm_end - new_vma->vm_start;
+	const struct vdso_image *image = current->mm->context.vdso_image;
+
+	if (new_size != -image->sym_vvar_start)
+		return -EINVAL;
+
+	return 0;
+}
+
 static vm_fault_t vvar_fault(const struct vm_special_mapping *sm,
 		      struct vm_area_struct *vma, struct vm_fault *vmf)
 {
@@ -136,6 +148,7 @@ static const struct vm_special_mapping vdso_mapping = {
 static const struct vm_special_mapping vvar_mapping = {
 	.name = "[vvar]",
 	.fault = vvar_fault,
+	.mremap = vvar_mremap,
 };
 
 /*
Signature · 1 line
2.21.0
#19 lore raw

Re: [PATCHv3 12/27] x86/vdso: Restrict splitting VVAR VMA

Quoted 3 lines · Dmitry Safonov

Although, time namespace can work with VVAR VMA split, it seems worth to forbid splitting VVAR resulting in stricter ABI and reducing amount of corner-cases to consider while working further on VDSO.

[...]

Quoted 4 lines
arch/x86/entry/vdso/vma.c +0 -0
index babc4e7a519c..ff9875a4d53b 100644

[...]

arch/x86/entry/vdso/vma.c static int vdso_mremap(const struct vm_special_mapping *sm, · line 91

Quoted 5 lines
arch/x86/entry/vdso/vma.c +5 -0
+static int vvar_mremap(const struct vm_special_mapping *sm,
+               struct vm_area_struct *new_vma)
+{
+       unsigned long new_size = new_vma->vm_end - new_vma->vm_start;
+       const struct vdso_image *image = current->mm->context.vdso_image;

Using current->mm in here is a bit awkward. So far the ->mremap handler can only be invoked for current, but still, maybe new_vma->vm_mm would be better here?

Quoted 5 lines
arch/x86/entry/vdso/vma.c +5 -0
+       if (new_size != -image->sym_vvar_start)
+               return -EINVAL;
+
+       return 0;
+}

[...]

#20 lore raw

Re: [PATCHv3 12/27] x86/vdso: Restrict splitting VVAR VMA

Quoted 10 lines · Jann Horn
Quoted 3 lines · Dmitry Safonov

Although, time namespace can work with VVAR VMA split, it seems worth to forbid splitting VVAR resulting in stricter ABI and reducing amount of corner-cases to consider while working further on VDSO.

[...]

Quoted 4 lines
arch/x86/entry/vdso/vma.c +0 -0
index babc4e7a519c..ff9875a4d53b 100644

[...]

Quoted 9 lines

arch/x86/entry/vdso/vma.c static int vdso_mremap(const struct vm_special_mapping *sm, · line 91

Quoted 5 lines
arch/x86/entry/vdso/vma.c +5 -0
+static int vvar_mremap(const struct vm_special_mapping *sm,
+               struct vm_area_struct *new_vma)
+{
+       unsigned long new_size = new_vma->vm_end - new_vma->vm_start;
+       const struct vdso_image *image = current->mm->context.vdso_image;

Using current->mm in here is a bit awkward. So far the ->mremap handler can only be invoked for current, but still, maybe new_vma->vm_mm would be better here?

Yep, can do - also in vdso_mremap().
Though, it should be only stylistic as it's checked in special_mapping_mremap() to be the same.

Quoted 8 lines
Quoted 6 lines
arch/x86/entry/vdso/vma.c +5 -0
+       if (new_size != -image->sym_vvar_start)
+               return -EINVAL;
+
+       return 0;
+}

[...]

Thanks,
Dima

#21 lore raw

PATCH v3 13/27 x86/vdso: Rename vdso_image {.data=>.text}

In reply to Dmitry Safonov

To avoid any confusion with VVAR.

---
 arch/x86/entry/vdso/vdso2c.h | 2 +-
 arch/x86/entry/vdso/vma.c    | 6 +++---
 arch/x86/include/asm/vdso.h  | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)
arch/x86/entry/vdso/vdso2c.h +1 -1
index 61c8bb2e5af8..086a11aee0e8 100644
@@ -157,7 +157,7 @@ static void BITSFUNC(go)(void *raw_addr, size_t raw_len,
 	fprintf(outfile, "\n};\n\n");
 
 	fprintf(outfile, "const struct vdso_image %s = {\n", name);
-	fprintf(outfile, "\t.data = raw_data,\n");
+	fprintf(outfile, "\t.text = raw_data,\n");
 	fprintf(outfile, "\t.size = %lu,\n", mapping_size);
 	if (alt_sec) {
 		fprintf(outfile, "\t.alt = %lu,\n",
arch/x86/entry/vdso/vma.c +3 -3
index ff9875a4d53b..35f7a1c1f4bc 100644
@@ -32,8 +32,8 @@ void __init init_vdso_image(const struct vdso_image *image)
 {
 	BUG_ON(image->size % PAGE_SIZE != 0);
 
-	apply_alternatives((struct alt_instr *)(image->data + image->alt),
-			   (struct alt_instr *)(image->data + image->alt +
+	apply_alternatives((struct alt_instr *)(image->text + image->alt),
+			   (struct alt_instr *)(image->text + image->alt +
 						image->alt_len));
 }
 
@@ -47,7 +47,7 @@ static vm_fault_t vdso_fault(const struct vm_special_mapping *sm,
 	if (!image || (vmf->pgoff << PAGE_SHIFT) >= image->size)
 		return VM_FAULT_SIGBUS;
 
-	vmf->page = virt_to_page(image->data + (vmf->pgoff << PAGE_SHIFT));
+	vmf->page = virt_to_page(image->text + (vmf->pgoff << PAGE_SHIFT));
 	get_page(vmf->page);
 	return 0;
 }
arch/x86/include/asm/vdso.h +1 -1
index 27566e57e87d..02cb843b4c0b 100644
@@ -11,7 +11,7 @@
 #include <linux/mm_types.h>
 
 struct vdso_image {
-	void *data;
+	void *text;
 	unsigned long size;   /* Always a multiple of PAGE_SIZE */
 
 	unsigned long alt, alt_len;
Signature · 1 line
2.21.0
#22 lore raw

PATCH v3 14/27 x86/vdso: Add offsets page in vvar

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

As modern applications fetch time from VDSO without entering the kernel, it's needed to provide offsets for userspace code inside time namespace.

A page for timens offsets is allocated on time namespace construction. Put that page into VVAR for tasks inside timens and zero page for host processes.

As VDSO code is already optimized as much as possible in terms of speed, any new if-condition in VDSO code is undesirable; the goal is to provide two .so(s), as was originally suggested by Andy and Thomas:
- for host tasks with optimized-out clk_to_ns() without any penalty
- for processes inside timens with clk_to_ns()
For this purpose, define clk_to_ns() under CONFIG_TIME_NS.

To eliminate any performance regression, clk_to_ns() will be called under static_branch with follow-up patches, that adds support for patching vdso.

VDSO mappings are platform-specific, add Kconfig dependency for arch.

---
 arch/Kconfig                          |  5 ++++
 arch/x86/Kconfig                      |  1 +
 arch/x86/entry/vdso/vclock_gettime.c  | 43 +++++++++++++++++++++++++++
 arch/x86/entry/vdso/vdso-layout.lds.S |  9 +++++-
 arch/x86/entry/vdso/vdso2c.c          |  3 ++
 arch/x86/entry/vdso/vma.c             | 12 ++++++++
 arch/x86/include/asm/vdso.h           |  1 +
 init/Kconfig                          |  1 +
 8 files changed, 74 insertions(+), 1 deletion(-)
arch/Kconfig +5 -0
index 33687dddd86a..1db650ad80bc 100644
@@ -717,6 +717,11 @@ config HAVE_ARCH_NVRAM_OPS
 config ISA_BUS_API
 	def_bool ISA
 
+config ARCH_HAS_VDSO_TIME_NS
+	bool
+	help
+	 VDSO can add time-ns offsets without entering kernel.
+
 #
 # ABI hall of shame
 #
arch/x86/Kconfig +1 -0
index 62fc3fda1a05..e692c62f53df 100644
@@ -69,6 +69,7 @@ config X86
 	select ARCH_HAS_STRICT_MODULE_RWX
 	select ARCH_HAS_SYNC_CORE_BEFORE_USERMODE
 	select ARCH_HAS_UBSAN_SANITIZE_ALL
+	select ARCH_HAS_VDSO_TIME_NS
 	select ARCH_HAS_ZONE_DEVICE		if X86_64
 	select ARCH_HAVE_NMI_SAFE_CMPXCHG
 	select ARCH_MIGHT_HAVE_ACPI_PDC		if ACPI
arch/x86/entry/vdso/vclock_gettime.c +43 -0

73 lines not on this page · raw message

arch/x86/entry/vdso/vdso-layout.lds.S +8 -1
index 93c6dc7812d0..ba216527e59f 100644
@@ -7,6 +7,12 @@
  * This script controls its layout.
  */
 
+#ifdef CONFIG_TIME_NS
+# define TIMENS_SZ	PAGE_SIZE
+#else
+# define TIMENS_SZ	0
+#endif
+
 SECTIONS
 {
 	/*
@@ -16,7 +22,7 @@ SECTIONS
 	 * segment.
 	 */
 
-	vvar_start = . - 3 * PAGE_SIZE;
+	vvar_start = . - (3 * PAGE_SIZE + TIMENS_SZ);
 	vvar_page = vvar_start;
 
 	/* Place all vvars at the offsets in asm/vvar.h. */
@@ -28,6 +34,7 @@ SECTIONS
 
 	pvclock_page = vvar_start + PAGE_SIZE;
 	hvclock_page = vvar_start + 2 * PAGE_SIZE;
+	timens_page = vvar_start + 3 * PAGE_SIZE;
 
 	. = SIZEOF_HEADERS;
 
arch/x86/entry/vdso/vdso2c.c +3 -0
index 26d7177c119e..ed66b023d4b9 100644
@@ -76,6 +76,7 @@ enum {
 	sym_hpet_page,
 	sym_pvclock_page,
 	sym_hvclock_page,
+	sym_timens_page,
 };
 
 const int special_pages[] = {
@@ -83,6 +84,7 @@ const int special_pages[] = {
 	sym_hpet_page,
 	sym_pvclock_page,
 	sym_hvclock_page,
+	sym_timens_page,
 };
 
 struct vdso_sym {
@@ -96,6 +98,7 @@ struct vdso_sym required_syms[] = {
 	[sym_hpet_page] = {"hpet_page", true},
 	[sym_pvclock_page] = {"pvclock_page", true},
 	[sym_hvclock_page] = {"hvclock_page", true},
+	[sym_timens_page] = {"timens_page", true},
 	{"VDSO32_NOTE_MASK", true},
 	{"__kernel_vsyscall", true},
 	{"__kernel_sigreturn", true},
arch/x86/entry/vdso/vma.c +12 -0
index 35f7a1c1f4bc..80cbb2167eba 100644
@@ -14,6 +14,7 @@
 #include <linux/elf.h>
 #include <linux/cpu.h>
 #include <linux/ptrace.h>
+#include <linux/time_namespace.h>
 #include <asm/pvclock.h>
 #include <asm/vgtod.h>
 #include <asm/proto.h>
@@ -23,6 +24,7 @@
 #include <asm/desc.h>
 #include <asm/cpufeature.h>
 #include <asm/mshyperv.h>
+#include <asm/page.h>
 
 #if defined(CONFIG_X86_64)
 unsigned int __read_mostly vdso64_enabled = 1;
@@ -135,6 +137,16 @@ static vm_fault_t vvar_fault(const struct vm_special_mapping *sm,
 		if (tsc_pg && vclock_was_used(VCLOCK_HVCLOCK))
 			return vmf_insert_pfn(vma, vmf->address,
 					vmalloc_to_pfn(tsc_pg));
+	} else if (sym_offset == image->sym_timens_page) {
+		struct time_namespace *ns = current->nsproxy->time_ns;
+		unsigned long pfn;
+
+		if (!ns->offsets)
+			pfn = page_to_pfn(ZERO_PAGE(0));
+		else
+			pfn = page_to_pfn(virt_to_page(ns->offsets));
+
+		return vmf_insert_pfn(vma, vmf->address, pfn);
 	}
 
 	return VM_FAULT_SIGBUS;
arch/x86/include/asm/vdso.h +1 -0
index 02cb843b4c0b..b0eb59c198eb 100644
@@ -22,6 +22,7 @@ struct vdso_image {
 	long sym_hpet_page;
 	long sym_pvclock_page;
 	long sym_hvclock_page;
+	long sym_timens_page;
 	long sym_VDSO32_NOTE_MASK;
 	long sym___kernel_sigreturn;
 	long sym___kernel_rt_sigreturn;
init/Kconfig +1 -0
index 10eebeaadfaa..e5a80278c395 100644
@@ -984,6 +984,7 @@ config UTS_NS
 
 config TIME_NS
 	bool "TIME namespace"
+	depends on ARCH_HAS_VDSO_TIME_NS
 	default y
 	help
 	  In this namespace boottime and monotonic clocks can be set.
Signature · 1 line
2.21.0
#23 lore raw

PATCH v3 15/27 x86/vdso: Allocate timens vdso

In reply to Dmitry Safonov

As it has been discussed on timens RFC, adding a new conditional branch if (inside_time_ns) on VDSO for all processes is undesirable. It will add a penalty for everybody as branch predictor may mispredict the jump. Also there are instruction cache lines wasted on cmp/jmp.

Those effects of introducing time namespace are very much unwanted having in mind how much work have been spent on micro-optimisation vdso code.

The propose is to allocate a second vdso code with dynamically patched out (disabled by static_branch) timens code on boot time.

Allocate another vdso and copy original code.

---
 arch/x86/entry/vdso/vdso2c.h |  2 +-
 arch/x86/entry/vdso/vma.c    | 36 +++++++++++++++++++++++++++++++-----
 arch/x86/include/asm/vdso.h  |  9 +++++----
 3 files changed, 37 insertions(+), 10 deletions(-)
arch/x86/entry/vdso/vdso2c.h +1 -1
index 086a11aee0e8..660f725a02c1 100644
@@ -156,7 +156,7 @@ static void BITSFUNC(go)(void *raw_addr, size_t raw_len,
 	}
 	fprintf(outfile, "\n};\n\n");
 
-	fprintf(outfile, "const struct vdso_image %s = {\n", name);
+	fprintf(outfile, "struct vdso_image %s __ro_after_init = {\n", name);
 	fprintf(outfile, "\t.text = raw_data,\n");
 	fprintf(outfile, "\t.size = %lu,\n", mapping_size);
 	if (alt_sec) {
arch/x86/entry/vdso/vma.c +31 -5
index 80cbb2167eba..6aae9c0d400d 100644
@@ -30,26 +30,52 @@
 unsigned int __read_mostly vdso64_enabled = 1;
 #endif
 
-void __init init_vdso_image(const struct vdso_image *image)
+void __init init_vdso_image(struct vdso_image *image)
 {
 	BUG_ON(image->size % PAGE_SIZE != 0);
 
 	apply_alternatives((struct alt_instr *)(image->text + image->alt),
 			   (struct alt_instr *)(image->text + image->alt +
 						image->alt_len));
+#ifdef CONFIG_TIME_NS
+	image->text_timens = vmalloc_32(image->size);
+	if (WARN_ON(image->text_timens == NULL))
+		return;
+
+	memcpy(image->text_timens, image->text, image->size);
+#endif
 }
 
 struct linux_binprm;
 
+#ifdef CONFIG_TIME_NS
+static inline struct timens_offsets *current_timens_offsets(void)
+{
+	struct time_namespace *ns = current->nsproxy->time_ns;
+
+	return ns->offsets;
+}
+#else
+static inline struct timens_offsets *current_timens_offsets(void)
+{
+	return NULL;
+}
+#endif
+
 static vm_fault_t vdso_fault(const struct vm_special_mapping *sm,
 		      struct vm_area_struct *vma, struct vm_fault *vmf)
 {
 	const struct vdso_image *image = vma->vm_mm->context.vdso_image;
+	unsigned long offset = vmf->pgoff << PAGE_SHIFT;
 
 	if (!image || (vmf->pgoff << PAGE_SHIFT) >= image->size)
 		return VM_FAULT_SIGBUS;
 
-	vmf->page = virt_to_page(image->text + (vmf->pgoff << PAGE_SHIFT));
+	if (current_timens_offsets() && image->text_timens)
+		vmf->page = vmalloc_to_page(image->text_timens + offset);
+	else
+		vmf->page = virt_to_page(image->text + offset);
+
 	get_page(vmf->page);
 	return 0;
 }
@@ -138,13 +164,13 @@ static vm_fault_t vvar_fault(const struct vm_special_mapping *sm,
 			return vmf_insert_pfn(vma, vmf->address,
 					vmalloc_to_pfn(tsc_pg));
 	} else if (sym_offset == image->sym_timens_page) {
-		struct time_namespace *ns = current->nsproxy->time_ns;
+		struct timens_offsets *offsets = current_timens_offsets();
 		unsigned long pfn;
 
-		if (!ns->offsets)
+		if (!offsets)
 			pfn = page_to_pfn(ZERO_PAGE(0));
 		else
-			pfn = page_to_pfn(virt_to_page(ns->offsets));
+			pfn = page_to_pfn(virt_to_page(offsets));
 
 		return vmf_insert_pfn(vma, vmf->address, pfn);
 	}
arch/x86/include/asm/vdso.h +5 -4
index b0eb59c198eb..a620c7f23425 100644
@@ -12,6 +12,7 @@
 
 struct vdso_image {
 	void *text;
+	void *text_timens;
 	unsigned long size;   /* Always a multiple of PAGE_SIZE */
 
 	unsigned long alt, alt_len;
@@ -31,18 +32,18 @@ struct vdso_image {
 };
 
 #ifdef CONFIG_X86_64
-extern const struct vdso_image vdso_image_64;
+extern struct vdso_image vdso_image_64;
 #endif
 
 #ifdef CONFIG_X86_X32
-extern const struct vdso_image vdso_image_x32;
+extern struct vdso_image vdso_image_x32;
 #endif
 
 #if defined CONFIG_X86_32 || defined CONFIG_COMPAT
-extern const struct vdso_image vdso_image_32;
+extern struct vdso_image vdso_image_32;
 #endif
 
-extern void __init init_vdso_image(const struct vdso_image *image);
+extern void __init init_vdso_image(struct vdso_image *image);
 
 extern int map_vdso_once(const struct vdso_image *image, unsigned long addr);
 
Signature · 1 line
2.21.0
#24 lore raw

Re: [PATCHv3 15/27] x86/vdso: Allocate timens vdso

Quoted 14 lines · Dmitry Safonov

As it has been discussed on timens RFC, adding a new conditional branch if (inside_time_ns) on VDSO for all processes is undesirable. It will add a penalty for everybody as branch predictor may mispredict the jump. Also there are instruction cache lines wasted on cmp/jmp.

Those effects of introducing time namespace are very much unwanted having in mind how much work have been spent on micro-optimisation vdso code.

The propose is to allocate a second vdso code with dynamically patched out (disabled by static_branch) timens code on boot time.

Allocate another vdso and copy original code.

[...]

Quoted 4 lines
arch/x86/entry/vdso/vma.c +0 -0
index 80cbb2167eba..6aae9c0d400d 100644

[...]

arch/x86/entry/vdso/vma.c line 74

Quoted 11 lines

static vm_fault_t vdso_fault(const struct vm_special_mapping *sm,
struct vm_area_struct *vma, struct vm_fault *vmf)

 {
        const struct vdso_image *image = vma->vm_mm->context.vdso_image;
arch/x86/entry/vdso/vma.c +2 -1
+       unsigned long offset = vmf->pgoff << PAGE_SHIFT;
 
        if (!image || (vmf->pgoff << PAGE_SHIFT) >= image->size)
                return VM_FAULT_SIGBUS;
 
-       vmf->page = virt_to_page(image->text + (vmf->pgoff << PAGE_SHIFT));
+       if (current_timens_offsets() && image->text_timens)

I'm pretty sure that accessing current in here is wrong. AFAIK this fault handler can be invoked on remote processes, through interfaces like /proc/$pid/mem and process_vm_readv(); in that case, the kernel should install a page based on the time namespace of the target process, not based on the time namespace of the caller.

Quoted 7 lines
arch/x86/entry/vdso/vma.c +4 -0
+               vmf->page = vmalloc_to_page(image->text_timens + offset);
+       else
+               vmf->page = virt_to_page(image->text + offset);
+
        get_page(vmf->page);
        return 0;
 }

[...]

#25 lore raw

Re: [PATCHv3 15/27] x86/vdso: Allocate timens vdso

Quoted 30 lines · Jann Horn
Quoted 14 lines · Dmitry Safonov

As it has been discussed on timens RFC, adding a new conditional branch if (inside_time_ns) on VDSO for all processes is undesirable. It will add a penalty for everybody as branch predictor may mispredict the jump. Also there are instruction cache lines wasted on cmp/jmp.

Those effects of introducing time namespace are very much unwanted having in mind how much work have been spent on micro-optimisation vdso code.

The propose is to allocate a second vdso code with dynamically patched out (disabled by static_branch) timens code on boot time.

Allocate another vdso and copy original code.

[...]

Quoted 4 lines
arch/x86/entry/vdso/vma.c +0 -0
index 80cbb2167eba..6aae9c0d400d 100644

[...]

Quoted 9 lines

static vm_fault_t vdso_fault(const struct vm_special_mapping *sm,
struct vm_area_struct *vma, struct vm_fault *vmf)

 {
        const struct vdso_image *image = vma->vm_mm->context.vdso_image;

+ unsigned long offset = vmf->pgoff << PAGE_SHIFT;

        if (!image || (vmf->pgoff << PAGE_SHIFT) >= image->size)
                return VM_FAULT_SIGBUS;
Quoted 8 lines

arch/x86/entry/vdso/vma.c line 74

Quoted 2 lines
arch/x86/entry/vdso/vma.c +1 -1
-       vmf->page = virt_to_page(image->text + (vmf->pgoff << PAGE_SHIFT));
+       if (current_timens_offsets() && image->text_timens)

I'm pretty sure that accessing current in here is wrong. AFAIK this fault handler can be invoked on remote processes, through interfaces like /proc/$pid/mem and process_vm_readv(); in that case, the kernel should install a page based on the time namespace of the target process, not based on the time namespace of the caller.

Oh yeah, I see, smells bogus.
Will try to redesign it..

Quoted 10 lines
Quoted 8 lines
arch/x86/entry/vdso/vma.c +4 -0
+               vmf->page = vmalloc_to_page(image->text_timens + offset);
+       else
+               vmf->page = virt_to_page(image->text + offset);
+
        get_page(vmf->page);
        return 0;
 }

[...]

Thanks,
Dima

#26 lore raw

PATCH v3 16/27 x86/vdso: Switch image on setns()/unshare()/clone()

In reply to Dmitry Safonov

As it has been discussed on timens RFC, adding a new conditional branch if (inside_time_ns) on VDSO for all processes is undesirable. It will add a penalty for everybody as branch predictor may mispredict the jump. Also there are instruction cache lines wasted on cmp/jmp.

Those effects of introducing time namespace are very much unwanted having in mind how much work have been spent on micro-optimisation vdso code.

Addressing those problems, there are two versions of VDSO's .so:
for host tasks (without any penalty) and for processes inside of time namespace with clk_to_ns() that subtracts offsets from host's time.

Whenever a user does setns()/unshare() or clone() with CLONE_TIMENS, change VDSO image in mm and zap existing VVAR/VDSO page tables. They will be re-faulted with corresponding image and VVAR offsets.

---
 arch/x86/entry/vdso/vma.c   | 29 +++++++++++++++++++++++++++++
 arch/x86/include/asm/vdso.h |  1 +
 kernel/time_namespace.c     | 11 +++++++++++
 3 files changed, 41 insertions(+)
arch/x86/entry/vdso/vma.c +29 -0
index 6aae9c0d400d..28628950214d 100644
@@ -25,6 +25,7 @@
 #include <asm/cpufeature.h>
 #include <asm/mshyperv.h>
 #include <asm/page.h>
+#include <asm/tlb.h>
 
 #if defined(CONFIG_X86_64)
 unsigned int __read_mostly vdso64_enabled = 1;
@@ -189,6 +190,34 @@ static const struct vm_special_mapping vvar_mapping = {
 	.mremap = vvar_mremap,
 };
 
+#ifdef CONFIG_TIME_NS
+int vdso_join_timens(struct task_struct *task, bool inside_ns)
+{
+	struct mm_struct *mm = task->mm;
+	struct vm_area_struct *vma;
+
+	if (down_write_killable(&mm->mmap_sem))
+		return -EINTR;
+
+	for (vma = mm->mmap; vma; vma = vma->vm_next) {
+		unsigned long size = vma->vm_end - vma->vm_start;
+
+		if (vma_is_special_mapping(vma, &vvar_mapping))
+			zap_page_range(vma, vma->vm_start, size);
+		if (vma_is_special_mapping(vma, &vdso_mapping))
+			zap_page_range(vma, vma->vm_start, size);
+	}
+
+	up_write(&mm->mmap_sem);
+	return 0;
+}
+#else /* CONFIG_TIME_NS */
+int vdso_join_timens(struct task_struct *task, bool inside_ns)
+{
+	return -ENXIO;
+}
+#endif
+
 /*
  * Add vdso and vvar mappings to current process.
  * @image          - blob to map
arch/x86/include/asm/vdso.h +1 -0
index a620c7f23425..583133446874 100644
@@ -46,6 +46,7 @@ extern struct vdso_image vdso_image_32;
 extern void __init init_vdso_image(struct vdso_image *image);
 
 extern int map_vdso_once(const struct vdso_image *image, unsigned long addr);
+extern int vdso_join_timens(struct task_struct *task, bool inside_ns);
 
 #endif /* __ASSEMBLER__ */
 
kernel/time_namespace.c +11 -0
index 4828447721ec..e806accc4eaf 100644
@@ -14,6 +14,7 @@
 #include <linux/proc_ns.h>
 #include <linux/sched/task.h>
 #include <linux/mm.h>
+#include <asm/vdso.h>
 
 static struct ucounts *inc_time_namespaces(struct user_namespace *ns)
 {
@@ -155,11 +156,16 @@ static void timens_put(struct ns_common *ns)
 static int timens_install(struct nsproxy *nsproxy, struct ns_common *new)
 {
 	struct time_namespace *ns = to_time_ns(new);
+	int ret;
 
 	if (!ns_capable(ns->user_ns, CAP_SYS_ADMIN) ||
 	    !ns_capable(current_user_ns(), CAP_SYS_ADMIN))
 		return -EPERM;
 
+	ret = vdso_join_timens(current, ns != &init_time_ns);
+	if (ret)
+		return ret;
+
 	get_time_ns(ns);
 	get_time_ns(ns);
 	put_time_ns(nsproxy->time_ns);
@@ -174,10 +180,15 @@ int timens_on_fork(struct nsproxy *nsproxy, struct task_struct *tsk)
 {
 	struct ns_common *nsc = &nsproxy->time_ns_for_children->ns;
 	struct time_namespace *ns = to_time_ns(nsc);
+	int ret;
 
 	if (nsproxy->time_ns == nsproxy->time_ns_for_children)
 		return 0;
 
+	ret = vdso_join_timens(tsk, ns != &init_time_ns);
+	if (ret)
+		return ret;
+
 	get_time_ns(ns);
 	put_time_ns(nsproxy->time_ns);
 	nsproxy->time_ns = ns;
Signature · 1 line
2.21.0
#27 lore raw

Re: [PATCHv3 16/27] x86/vdso: Switch image on setns()/unshare()/clone()

Quoted 16 lines · Dmitry Safonov

As it has been discussed on timens RFC, adding a new conditional branch if (inside_time_ns) on VDSO for all processes is undesirable. It will add a penalty for everybody as branch predictor may mispredict the jump. Also there are instruction cache lines wasted on cmp/jmp.

Those effects of introducing time namespace are very much unwanted having in mind how much work have been spent on micro-optimisation vdso code.

Addressing those problems, there are two versions of VDSO's .so:
for host tasks (without any penalty) and for processes inside of time namespace with clk_to_ns() that subtracts offsets from host's time.

Whenever a user does setns()/unshare() or clone() with CLONE_TIMENS, change VDSO image in mm and zap existing VVAR/VDSO page tables. They will be re-faulted with corresponding image and VVAR offsets.

[...]

Review

Quoted 2 lines
(quoted diff) +2 -0
+#ifdef CONFIG_TIME_NS
+int vdso_join_timens(struct task_struct *task, bool inside_ns)

The parameter "inside_ns" is never used, right?

Quoted 4 lines
arch/x86/entry/vdso/vma.c +4 -0
+{
+       struct mm_struct *mm = task->mm;
+       struct vm_area_struct *vma;
+

arch/x86/entry/vdso/vma.c static const struct vm_special_mapping vvar_mapping = { · line 208

Quoted 10 lines
arch/x86/entry/vdso/vma.c +10 -0
+       if (down_write_killable(&mm->mmap_sem))
+               return -EINTR;
+
+       for (vma = mm->mmap; vma; vma = vma->vm_next) {
+               unsigned long size = vma->vm_end - vma->vm_start;
+
+               if (vma_is_special_mapping(vma, &vvar_mapping))
+                       zap_page_range(vma, vma->vm_start, size);
+               if (vma_is_special_mapping(vma, &vdso_mapping))
+                       zap_page_range(vma, vma->vm_start, size);

Nit: This could be rewritten as:

if (vma_is_special_mapping(vma, &vvar_mapping) ||

    vma_is_special_mapping(vma, &vdso_mapping))
        zap_page_range(vma, vma->vm_start, size);
Quoted 5 lines
arch/x86/entry/vdso/vma.c +5 -0
+       }
+
+       up_write(&mm->mmap_sem);
+       return 0;
+}

[...]

#28 lore raw

Re: [PATCHv3 16/27] x86/vdso: Switch image on setns()/unshare()/clone()

Quoted 14 lines · Jann Horn
Quoted 13 lines · Dmitry Safonov

As it has been discussed on timens RFC, adding a new conditional branch if (inside_time_ns) on VDSO for all processes is undesirable. It will add a penalty for everybody as branch predictor may mispredict the jump. Also there are instruction cache lines wasted on cmp/jmp.

Those effects of introducing time namespace are very much unwanted having in mind how much work have been spent on micro-optimisation vdso code.

Addressing those problems, there are two versions of VDSO's .so:
for host tasks (without any penalty) and for processes inside of time namespace with clk_to_ns() that subtracts offsets from host's time.

Quoted 8 lines
Quoted 3 lines

Whenever a user does setns()/unshare() or clone() with CLONE_TIMENS, change VDSO image in mm and zap existing VVAR/VDSO page tables. They will be re-faulted with corresponding image and VVAR offsets.

[...]

Review

Quoted 2 lines
(quoted diff) +2 -0
+#ifdef CONFIG_TIME_NS
+int vdso_join_timens(struct task_struct *task, bool inside_ns)

The parameter "inside_ns" is never used, right?

Oh, yes - leftover from the previous version, where the image was swapped in the callback. Will remove it.

Quoted 18 lines
Quoted 5 lines
arch/x86/entry/vdso/vma.c +4 -0
+{
+       struct mm_struct *mm = task->mm;
+       struct vm_area_struct *vma;
+

arch/x86/entry/vdso/vma.c static const struct vm_special_mapping vvar_mapping = { · line 208

Quoted 10 lines
arch/x86/entry/vdso/vma.c +10 -0
+       if (down_write_killable(&mm->mmap_sem))
+               return -EINTR;
+
+       for (vma = mm->mmap; vma; vma = vma->vm_next) {
+               unsigned long size = vma->vm_end - vma->vm_start;
+
+               if (vma_is_special_mapping(vma, &vvar_mapping))
+                       zap_page_range(vma, vma->vm_start, size);
+               if (vma_is_special_mapping(vma, &vdso_mapping))
+                       zap_page_range(vma, vma->vm_start, size);

Nit: This could be rewritten as:

Quoted 3 lines

if (vma_is_special_mapping(vma, &vvar_mapping) ||

    vma_is_special_mapping(vma, &vdso_mapping))
        zap_page_range(vma, vma->vm_start, size);

Yes. I thought it looks better with two if's rather than with a longer line, but I don't mind - will change.

Quoted 8 lines
Quoted 6 lines
arch/x86/entry/vdso/vma.c +5 -0
+       }
+
+       up_write(&mm->mmap_sem);
+       return 0;
+}

[...]

Thanks,
Dmitry

#29 lore raw

PATCH v3 17/27 vdso: introduce timens_static_branch

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

As it has been discussed on timens RFC, adding a new conditional branch if (inside_time_ns) on VDSO for all processes is undesirable.

Addressing those problems, there are two versions of VDSO's .so:
for host tasks (without any penalty) and for processes inside of time namespace with clk_to_ns() that subtracts offsets from host's time.

This patch introduces timens_static_branch(), which is similar with static_branch_unlikely.

The timens code in vdso looks like this:

       if (timens_static_branch()) {
               clk_to_ns(clk, ts);
       }

The version of vdso which is compiled from sources will never execute clk_to_ns(). And then we can patch the 'no-op' in the straight-line codepath with a 'jump' instruction to the out-of-line true branch and get the timens version of the vdso library.

While cooking the patch, an alternative approach has being considered:
to omit no-ops - memcpy() the following asm ret sequience on the place of a function call: https://github.com/0x7f454c46/linux/commit/4cc0180f6d65
Having in mind possible issues with different toolchains, the usual static_branch() approach was choosen.

---
 arch/x86/entry/vdso/vclock_gettime.c  |  9 +++++--
 arch/x86/entry/vdso/vdso-layout.lds.S |  1 +
 arch/x86/entry/vdso/vdso2c.h          | 11 +++++++-
 arch/x86/entry/vdso/vma.c             | 37 ++++++++++++++++++++++-----
 arch/x86/include/asm/jump_label.h     | 14 ++++++++++
 arch/x86/include/asm/vdso.h           |  1 +
 include/linux/jump_label.h            |  5 ++++
 7 files changed, 69 insertions(+), 9 deletions(-)
arch/x86/entry/vdso/vclock_gettime.c +7 -2
index 1d2ba6250255..8929a1285e68 100644
@@ -18,6 +18,7 @@
 #include <asm/msr.h>
 #include <asm/pvclock.h>
 #include <asm/mshyperv.h>
+#include <asm/jump_label.h>
 #include <linux/math64.h>
 #include <linux/time.h>
 #include <linux/kernel.h>
@@ -174,8 +175,10 @@ notrace static __always_inline void clk_to_ns(clockid_t clk, struct timespec *ts
 		ts->tv_sec--;
 	}
 }
+#define _timens_static_branch_unlikely timens_static_branch_unlikely
 #else
 notrace static __always_inline void clk_to_ns(clockid_t clk, struct timespec *ts) {}
+notrace static __always_inline bool _timens_static_branch_unlikely(void) { return false; }
 #endif
 
 notrace static int do_hres(clockid_t clk, struct timespec *ts)
@@ -204,7 +207,8 @@ notrace static int do_hres(clockid_t clk, struct timespec *ts)
 	ts->tv_sec = sec + __iter_div_u64_rem(ns, NSEC_PER_SEC, &ns);
 	ts->tv_nsec = ns;
 
-	clk_to_ns(clk, ts);
+	if (_timens_static_branch_unlikely())
+		clk_to_ns(clk, ts);
 
 	return 0;
 }
@@ -220,7 +224,8 @@ notrace static void do_coarse(clockid_t clk, struct timespec *ts)
 		ts->tv_nsec = base->nsec;
 	} while (unlikely(gtod_read_retry(gtod, seq)));
 
-	clk_to_ns(clk, ts);
+	if (_timens_static_branch_unlikely())
+		clk_to_ns(clk, ts);
 }
 
 notrace int __vdso_clock_gettime(clockid_t clock, struct timespec *ts)
arch/x86/entry/vdso/vdso-layout.lds.S +1 -0
index ba216527e59f..69dbe4821aa5 100644
@@ -45,6 +45,7 @@ SECTIONS
 	.gnu.version	: { *(.gnu.version) }
 	.gnu.version_d	: { *(.gnu.version_d) }
 	.gnu.version_r	: { *(.gnu.version_r) }
+	__jump_table	: { *(__jump_table) }	:text
 
 	.dynamic	: { *(.dynamic) }		:text	:dynamic
 
arch/x86/entry/vdso/vdso2c.h +10 -1
index 660f725a02c1..e4eef5e1c6ac 100644
@@ -16,7 +16,7 @@ static void BITSFUNC(go)(void *raw_addr, size_t raw_len,
 	unsigned int i, syms_nr;
 	unsigned long j;
 	ELF(Shdr) *symtab_hdr = NULL, *strtab_hdr, *secstrings_hdr,
-		*alt_sec = NULL;
+		*alt_sec = NULL, *jump_table_sec = NULL;
 	ELF(Dyn) *dyn = 0, *dyn_end = 0;
 	const char *secstrings;
 	INT_BITS syms[NSYMS] = {};
@@ -78,6 +78,9 @@ static void BITSFUNC(go)(void *raw_addr, size_t raw_len,
 		if (!strcmp(secstrings + GET_LE(&sh->sh_name),
 			    ".altinstructions"))
 			alt_sec = sh;
+		if (!strcmp(secstrings + GET_LE(&sh->sh_name),
+			    "__jump_table"))
+			jump_table_sec  = sh;
 	}
 
 	if (!symtab_hdr)
@@ -165,6 +168,12 @@ static void BITSFUNC(go)(void *raw_addr, size_t raw_len,
 		fprintf(outfile, "\t.alt_len = %lu,\n",
 			(unsigned long)GET_LE(&alt_sec->sh_size));
 	}
+	if (jump_table_sec) {
+		fprintf(outfile, "\t.jump_table = %lu,\n",
+			(unsigned long)GET_LE(&jump_table_sec->sh_offset));
+		fprintf(outfile, "\t.jump_table_len = %lu,\n",
+			(unsigned long)GET_LE(&jump_table_sec->sh_size));
+	}
 	for (i = 0; i < NSYMS; i++) {
 		if (required_syms[i].export && syms[i])
 			fprintf(outfile, "\t.sym_%s = %" PRIi64 ",\n",
arch/x86/entry/vdso/vma.c +31 -6
index 28628950214d..b9f15647e3a1 100644
@@ -15,6 +15,7 @@
 #include <linux/cpu.h>
 #include <linux/ptrace.h>
 #include <linux/time_namespace.h>
+#include <linux/jump_label.h>
 #include <asm/pvclock.h>
 #include <asm/vgtod.h>
 #include <asm/proto.h>
@@ -31,20 +32,44 @@
 unsigned int __read_mostly vdso64_enabled = 1;
 #endif
 
-void __init init_vdso_image(struct vdso_image *image)
+#ifdef CONFIG_TIME_NS
+static __init void apply_jump_tables(struct vdso_jump_entry *ent, unsigned long nr)
 {
-	BUG_ON(image->size % PAGE_SIZE != 0);
+	while (nr--) {
+		void *code_addr	= (void *)ent + ent->code;
+		long target_addr = (long) ent->target - (ent->code + JUMP_LABEL_NOP_SIZE);
+		((char *)code_addr)[0] = 0xe9; /* JMP rel32 */
+		*((long *)(code_addr + 1)) = (long)target_addr;
+
+		ent++;
+	}
+}
+
+static __init void init_timens(struct vdso_image *image)
+{
+	struct vdso_jump_entry *entries;
 
-	apply_alternatives((struct alt_instr *)(image->text + image->alt),
-			   (struct alt_instr *)(image->text + image->alt +
-						image->alt_len));
-#ifdef CONFIG_TIME_NS
 	image->text_timens = vmalloc_32(image->size);
 	if (WARN_ON(image->text_timens == NULL))
 		return;
 
 	memcpy(image->text_timens, image->text, image->size);
+
+	entries = image->text_timens + image->jump_table;
+	apply_jump_tables(entries, image->jump_table_len / sizeof(struct vdso_jump_entry));
+}
+#else
+static inline void init_timens(struct vdso_image *image) {}
 #endif
+
+void __init init_vdso_image(struct vdso_image *image)
+{
+	BUG_ON(image->size % PAGE_SIZE != 0);
+
+	apply_alternatives((struct alt_instr *)(image->text + image->alt),
+			   (struct alt_instr *)(image->text + image->alt +
+						image->alt_len));
+	init_timens(image);
 }
 
 struct linux_binprm;
arch/x86/include/asm/jump_label.h +14 -0
index 65191ce8e1cf..1784aa49cc82 100644
@@ -51,6 +51,20 @@ static __always_inline bool arch_static_branch_jump(struct static_key *key, bool
 	return true;
 }
 
+static __always_inline bool timens_static_branch_unlikely(void)
+{
+	asm_volatile_goto("1:\n\t"
+		".byte " __stringify(STATIC_KEY_INIT_NOP) "\n\t"
+		 ".pushsection __jump_table,  \"aw\"\n\t"
+		 "2: .word 1b - 2b, %l[l_yes] - 2b\n\t"
+		 ".popsection\n\t"
+		 : :  :  : l_yes);
+
+	return false;
+l_yes:
+	return true;
+}
+
 #else	/* __ASSEMBLY__ */
 
 .macro STATIC_JUMP_IF_TRUE target, key, def
arch/x86/include/asm/vdso.h +1 -0
index 583133446874..883151c3a032 100644
@@ -16,6 +16,7 @@ struct vdso_image {
 	unsigned long size;   /* Always a multiple of PAGE_SIZE */
 
 	unsigned long alt, alt_len;
+	unsigned long jump_table, jump_table_len;
 
 	long sym_vvar_start;  /* Negative offset to the vvar area */
 
include/linux/jump_label.h +5 -0
index 3e113a1fa0f1..69854a05d2f2 100644
@@ -125,6 +125,11 @@ struct jump_entry {
 	long key;	// key may be far away from the core kernel under KASLR
 };
 
+struct vdso_jump_entry {
+	u16 code;
+	u16 target;
+};
+
 static inline unsigned long jump_entry_code(const struct jump_entry *entry)
 {
 	return (unsigned long)&entry->code + entry->code;
Signature · 1 line
2.21.0
#30 lore raw

PATCH v3 18/27 timens: Add align for timens_offsets

In reply to Dmitry Safonov

Align offsets so that time namespace will work for ia32 applications on x86_64 host.

---
 include/linux/timens_offsets.h | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)
include/linux/timens_offsets.h +10 -2
index 777530c46852..f2a03d4f7a91 100644
@@ -2,9 +2,17 @@
 #ifndef _LINUX_TIME_OFFSETS_H
 #define _LINUX_TIME_OFFSETS_H
 
+/*
+ * Time offsets need align as they're placed on VVAR page,
+ * which is used by x86_64 and ia32 VDSO code.
+ * On ia32 offset::tv_sec (u64) has align(4), so re-align offsets
+ * to the same positions as 64-bit offsets.
+ * On 64-bit big-endian systems VDSO should convert to timespec64
+ * to timespec because of a padding occurring between the fields.
+ */
 struct timens_offsets {
-	struct timespec64  monotonic_time_offset;
-	struct timespec64  monotonic_boottime_offset;
+	struct timespec64  monotonic_time_offset __aligned(8);
+	struct timespec64  monotonic_boottime_offset __aligned(8);
 };
 
 #endif
Signature · 1 line
2.21.0
#31 lore raw

PATCH v3 19/27 timens/fs/proc: Introduce /proc/pid/timens_offsets

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

API to set time namespace offsets for children processes, i.e.:
echo "clockid off_ses off_nsec" > /proc/self/timens_offsets

---
 fs/proc/base.c                 | 101 +++++++++++++++++++++++++++++++++
 include/linux/time_namespace.h |  10 ++++
 kernel/time_namespace.c        |  82 ++++++++++++++++++++++++++
 3 files changed, 193 insertions(+)
fs/proc/base.c +101 -0
index 6a803a0b75df..76d58e9b5178 100644
@@ -94,6 +94,7 @@
 #include <linux/sched/debug.h>
 #include <linux/sched/stat.h>
 #include <linux/posix-timers.h>
+#include <linux/time_namespace.h>
 #include <trace/events/oom.h>
 #include "internal.h"
 #include "fd.h"
@@ -1521,6 +1522,103 @@ static const struct file_operations proc_pid_sched_autogroup_operations = {
 
 #endif /* CONFIG_SCHED_AUTOGROUP */
 
+#ifdef CONFIG_TIME_NS
+static int timens_offsets_show(struct seq_file *m, void *v)
+{
+	struct inode *inode = m->private;
+	struct task_struct *p;
+
+	p = get_proc_task(inode);
+	if (!p)
+		return -ESRCH;
+	proc_timens_show_offsets(p, m);
+
+	put_task_struct(p);
+
+	return 0;
+}
+
+static ssize_t
+timens_offsets_write(struct file *file, const char __user *buf,
+	    size_t count, loff_t *ppos)
+{
+	struct inode *inode = file_inode(file);
+	struct proc_timens_offset offsets[2];
+	char *kbuf = NULL, *pos, *next_line;
+	struct task_struct *p;
+	int ret, noffsets;
+
+	/* Only allow < page size writes at the beginning of the file */
+	if ((*ppos != 0) || (count >= PAGE_SIZE))
+		return -EINVAL;
+
+	/* Slurp in the user data */
+	kbuf = memdup_user_nul(buf, count);
+	if (IS_ERR(kbuf))
+		return PTR_ERR(kbuf);
+
+	/* Parse the user data */
+	ret = -EINVAL;
+	noffsets = 0;
+	pos = kbuf;
+	for (; pos; pos = next_line) {
+		struct proc_timens_offset *off = &offsets[noffsets];
+		int err;
+
+		/* Find the end of line and ensure I don't look past it */
+		next_line = strchr(pos, '\n');
+		if (next_line) {
+			*next_line = '\0';
+			next_line++;
+			if (*next_line == '\0')
+				next_line = NULL;
+		}
+
+		err = sscanf(pos, "%u %lld %lu", &off->clockid,
+				&off->val.tv_sec, &off->val.tv_nsec);
+		if (err != 3 || off->val.tv_nsec >= NSEC_PER_SEC)
+			goto out;
+		if (noffsets++ == ARRAY_SIZE(offsets))
+			break;
+	}
+
+	ret = -ESRCH;
+	p = get_proc_task(inode);
+	if (!p)
+		goto out;
+	ret = proc_timens_set_offset(p, offsets, noffsets);
+	put_task_struct(p);
+	if (ret)
+		goto out;
+
+	ret = count;
+out:
+	kfree(kbuf);
+	return ret;
+}
+
+static int timens_offsets_open(struct inode *inode, struct file *filp)
+{
+	int ret;
+
+	ret = single_open(filp, timens_offsets_show, NULL);
+	if (!ret) {
+		struct seq_file *m = filp->private_data;
+
+		m->private = inode;
+	}
+	return ret;
+}
+
+static const struct file_operations proc_timens_offsets_operations = {
+	.open		= timens_offsets_open,
+	.read		= seq_read,
+	.write		= timens_offsets_write,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
+#endif /* CONFIG_TIME_NS */
+
 static ssize_t comm_write(struct file *file, const char __user *buf,
 				size_t count, loff_t *offset)
 {
@@ -2982,6 +3080,9 @@ static const struct pid_entry tgid_base_stuff[] = {
 #endif
 #ifdef CONFIG_SCHED_AUTOGROUP
 	REG("autogroup",  S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations),
+#endif
+#ifdef CONFIG_TIME_NS
+	REG("timens_offsets",  S_IRUGO|S_IWUSR, proc_timens_offsets_operations),
 #endif
 	REG("comm",      S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),
 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK
include/linux/time_namespace.h +10 -0
index 988414f7f791..1434b5664673 100644
@@ -40,6 +40,16 @@ static inline void put_time_ns(struct time_namespace *ns)
 	kref_put(&ns->kref, free_time_ns);
 }
 
+extern void proc_timens_show_offsets(struct task_struct *p, struct seq_file *m);
+
+struct proc_timens_offset {
+	int clockid;
+	struct timespec64 val;
+};
+
+extern int proc_timens_set_offset(struct task_struct *p,
+				struct proc_timens_offset *offsets, int n);
+
 static inline void timens_add_monotonic(struct timespec64 *ts)
 {
         struct timens_offsets *ns_offsets = current->nsproxy->time_ns->offsets;
kernel/time_namespace.c +82 -0

94 lines not on this page · raw message

Signature · 1 line
2.21.0
#32 lore raw

Re: [PATCHv3 19/27] timens/fs/proc: Introduce /proc/pid/timens_offsets

Quoted 2 lines · Dmitry Safonov

API to set time namespace offsets for children processes, i.e.:
echo "clockid off_ses off_nsec" > /proc/self/timens_offsets

[...]

Quoted 4 lines
fs/proc/base.c +0 -0
index 6a803a0b75df..76d58e9b5178 100644

[...]

fs/proc/base.c static const struct file_operations proc_pid_sched_autogroup_operations = { · line 1531

Quoted 11 lines
fs/proc/base.c +7 -0
@@ -1521,6 +1522,103 @@ static const struct file_operations proc_pid_sched_autogroup_operations = {
 
 #endif /* CONFIG_SCHED_AUTOGROUP */
 
+#ifdef CONFIG_TIME_NS
+static int timens_offsets_show(struct seq_file *m, void *v)
+{
+       struct inode *inode = m->private;
+       struct task_struct *p;
+
+       p = get_proc_task(inode);

(FYI, this could also be "p = get_proc_task(file_inode(m->file));". But this works, too.)

Quoted 41 lines
fs/proc/base.c +41 -0
+       if (!p)
+               return -ESRCH;
+       proc_timens_show_offsets(p, m);
+
+       put_task_struct(p);
+
+       return 0;
+}
+
+static ssize_t
+timens_offsets_write(struct file *file, const char __user *buf,
+           size_t count, loff_t *ppos)
+{
+       struct inode *inode = file_inode(file);
+       struct proc_timens_offset offsets[2];
+       char *kbuf = NULL, *pos, *next_line;
+       struct task_struct *p;
+       int ret, noffsets;
+
+       /* Only allow < page size writes at the beginning of the file */
+       if ((*ppos != 0) || (count >= PAGE_SIZE))
+               return -EINVAL;
+
+       /* Slurp in the user data */
+       kbuf = memdup_user_nul(buf, count);
+       if (IS_ERR(kbuf))
+               return PTR_ERR(kbuf);
+
+       /* Parse the user data */
+       ret = -EINVAL;
+       noffsets = 0;
+       pos = kbuf;
+       for (; pos; pos = next_line) {
+               struct proc_timens_offset *off = &offsets[noffsets];
+               int err;
+
+               /* Find the end of line and ensure I don't look past it */
+               next_line = strchr(pos, '\n');
+               if (next_line) {
+                       *next_line = '\0';
+                       next_line++;

fs/proc/base.c static const struct file_operations proc_pid_sched_autogroup_operations = { · line 1582

Quoted 10 lines
fs/proc/base.c +10 -0
+                       if (*next_line == '\0')
+                               next_line = NULL;
+               }
+
+               err = sscanf(pos, "%u %lld %lu", &off->clockid,
+                               &off->val.tv_sec, &off->val.tv_nsec);
+               if (err != 3 || off->val.tv_nsec >= NSEC_PER_SEC)
+                       goto out;
+               if (noffsets++ == ARRAY_SIZE(offsets))
+                       break;

This is equivalent to:

if (noffsets == ARRAY_SIZE(offsets))

        break;

noffsets++;

So we can reach the start of the loop with noffsets==ARRAY_SIZE(offsets), right? Which means that an out-of-bounds write can happen?

I think that for code like this, it makes sense to write the increment and the check out separately so that it's easier to spot problems; e.g. like this:

noffsets++;
if (noffsets == ARRAY_SIZE(offsets))

        break;
Quoted 19 lines
fs/proc/base.c +19 -0
+       }
+
+       ret = -ESRCH;
+       p = get_proc_task(inode);
+       if (!p)
+               goto out;
+       ret = proc_timens_set_offset(p, offsets, noffsets);
+       put_task_struct(p);
+       if (ret)
+               goto out;
+
+       ret = count;
+out:
+       kfree(kbuf);
+       return ret;
+}
+
+static int timens_offsets_open(struct inode *inode, struct file *filp)
+{

fs/proc/base.c static const struct file_operations proc_pid_sched_autogroup_operations = { · line 1611

Quoted 10 lines
fs/proc/base.c +10 -0
+       int ret;
+
+       ret = single_open(filp, timens_offsets_show, NULL);
+       if (!ret) {
+               struct seq_file *m = filp->private_data;
+
+               m->private = inode;
+       }
+       return ret;
+}

Why did you write it like this? Wouldn't the following be equivalent?

static int timens_offsets_open(struct inode *inode, struct file *file)

{
        return single_open(file, timens_offsets_show, inode);
}

(But also, you can reach the inode of a seq_file as file_inode(m->file).)

[...]

Quoted 4 lines
kernel/time_namespace.c +0 -0
index e806accc4eaf..9ad4b63c4ed2 100644

[...]

Quoted 8 lines
kernel/time_namespace.c +8 -0
+
+int proc_timens_set_offset(struct task_struct *p,
+                          struct proc_timens_offset *offsets, int noffsets)
+{
+       struct ns_common *ns;
+       struct time_namespace *time_ns;
+       struct timens_offsets *ns_offsets;
+       struct timespec64 *offset;

kernel/time_namespace.c static struct user_namespace *timens_owner(struct ns_common *ns) · line 249

Quoted 10 lines
kernel/time_namespace.c +10 -0
+       struct timespec64 tp;
+       int i, err;
+
+       ns = timens_for_children_get(p);
+       if (!ns)
+               return -ESRCH;
+       time_ns = to_time_ns(ns);
+
+       if (!time_ns->offsets || time_ns->initialized ||
+           !ns_capable(time_ns->user_ns, CAP_SYS_TIME)) {

Capability checks in VFS read/write handlers are bad. Please pass through the file pointer to this function and replace the call with "file_ns_capable(file, time_ns->user_ns, CAP_SYS_TIME)".

Quoted 3 lines
kernel/time_namespace.c +3 -0
+               put_time_ns(time_ns);
+               return -EPERM;
+       }

[...]

Quoted 1 line

+}

#33 lore raw

Re: [PATCHv3 19/27] timens/fs/proc: Introduce /proc/pid/timens_offsets

Hi Jann,

Thank you for the review. Here are a few comments inline.

Quoted 78 lines · Jann Horn
Quoted 2 lines · Dmitry Safonov

API to set time namespace offsets for children processes, i.e.:
echo "clockid off_ses off_nsec" > /proc/self/timens_offsets

[...]

Quoted 4 lines
fs/proc/base.c +0 -0
index 6a803a0b75df..76d58e9b5178 100644

[...]

fs/proc/base.c static const struct file_operations proc_pid_sched_autogroup_operations = { · line 1531

Quoted 11 lines
fs/proc/base.c +7 -0
@@ -1521,6 +1522,103 @@ static const struct file_operations proc_pid_sched_autogroup_operations = {
 
 #endif /* CONFIG_SCHED_AUTOGROUP */
 
+#ifdef CONFIG_TIME_NS
+static int timens_offsets_show(struct seq_file *m, void *v)
+{
+       struct inode *inode = m->private;
+       struct task_struct *p;
+
+       p = get_proc_task(inode);

(FYI, this could also be "p = get_proc_task(file_inode(m->file));". But this works, too.)

Quoted 41 lines
fs/proc/base.c +41 -0
+       if (!p)
+               return -ESRCH;
+       proc_timens_show_offsets(p, m);
+
+       put_task_struct(p);
+
+       return 0;
+}
+
+static ssize_t
+timens_offsets_write(struct file *file, const char __user *buf,
+           size_t count, loff_t *ppos)
+{
+       struct inode *inode = file_inode(file);
+       struct proc_timens_offset offsets[2];
+       char *kbuf = NULL, *pos, *next_line;
+       struct task_struct *p;
+       int ret, noffsets;
+
+       /* Only allow < page size writes at the beginning of the file */
+       if ((*ppos != 0) || (count >= PAGE_SIZE))
+               return -EINVAL;
+
+       /* Slurp in the user data */
+       kbuf = memdup_user_nul(buf, count);
+       if (IS_ERR(kbuf))
+               return PTR_ERR(kbuf);
+
+       /* Parse the user data */
+       ret = -EINVAL;
+       noffsets = 0;
+       pos = kbuf;
+       for (; pos; pos = next_line) {
+               struct proc_timens_offset *off = &offsets[noffsets];
+               int err;
+
+               /* Find the end of line and ensure I don't look past it */
+               next_line = strchr(pos, '\n');
+               if (next_line) {
+                       *next_line = '\0';
+                       next_line++;

fs/proc/base.c static const struct file_operations proc_pid_sched_autogroup_operations = { · line 1582

Quoted 10 lines
fs/proc/base.c +10 -0
+                       if (*next_line == '\0')
+                               next_line = NULL;
+               }
+
+               err = sscanf(pos, "%u %lld %lu", &off->clockid,
+                               &off->val.tv_sec, &off->val.tv_nsec);
+               if (err != 3 || off->val.tv_nsec >= NSEC_PER_SEC)
+                       goto out;
+               if (noffsets++ == ARRAY_SIZE(offsets))
+                       break;

This is equivalent to:

Quoted 1 line

if (noffsets == ARRAY_SIZE(offsets)) {

	  noffsets++;
Quoted 1 line
        break;

}

Quoted 5 lines

noffsets++;

So we can reach the start of the loop with noffsets==ARRAY_SIZE(offsets), right? Which means that an out-of-bounds write can happen?

good catch. I will add a test for this case.

Quoted 8 lines

I think that for code like this, it makes sense to write the increment and the check out separately so that it's easier to spot problems; e.g. like this:

noffsets++;
if (noffsets == ARRAY_SIZE(offsets))

        break;

will rewrite this way. Thanks!

Quoted 24 lines
Quoted 24 lines
fs/proc/base.c +23 -0
+       }
+
+       ret = -ESRCH;
+       p = get_proc_task(inode);
+       if (!p)
+               goto out;
+       ret = proc_timens_set_offset(p, offsets, noffsets);
+       put_task_struct(p);
+       if (ret)
+               goto out;
+
+       ret = count;
+out:
+       kfree(kbuf);
+       return ret;
+}
+
+static int timens_offsets_open(struct inode *inode, struct file *filp)
+{
+       int ret;
+
+       ret = single_open(filp, timens_offsets_show, NULL);
+       if (!ret) {
Quoted 8 lines

fs/proc/base.c static const struct file_operations proc_pid_sched_autogroup_operations = { · line 1611

Quoted 6 lines
fs/proc/base.c +6 -0
+               struct seq_file *m = filp->private_data;
+
+               m->private = inode;
+       }
+       return ret;
+}

Why did you write it like this? Wouldn't the following be equivalent?

Probably I looked at sched_autogroup_open

Quoted 28 lines

static int timens_offsets_open(struct inode *inode, struct file *file)

{
        return single_open(file, timens_offsets_show, inode);
}

(But also, you can reach the inode of a seq_file as file_inode(m->file).)

[...]

Quoted 4 lines
kernel/time_namespace.c +0 -0
index e806accc4eaf..9ad4b63c4ed2 100644

[...]

Quoted 14 lines
kernel/time_namespace.c +14 -0
+
+int proc_timens_set_offset(struct task_struct *p,
+                          struct proc_timens_offset *offsets, int noffsets)
+{
+       struct ns_common *ns;
+       struct time_namespace *time_ns;
+       struct timens_offsets *ns_offsets;
+       struct timespec64 *offset;
+       struct timespec64 tp;
+       int i, err;
+
+       ns = timens_for_children_get(p);
+       if (!ns)
+               return -ESRCH;
Quoted 8 lines

kernel/time_namespace.c static struct user_namespace *timens_owner(struct ns_common *ns) · line 249

Quoted 4 lines
kernel/time_namespace.c +4 -0
+       time_ns = to_time_ns(ns);
+
+       if (!time_ns->offsets || time_ns->initialized ||
+           !ns_capable(time_ns->user_ns, CAP_SYS_TIME)) {

Capability checks in VFS read/write handlers are bad. Please pass through the file pointer to this function and replace the call with "file_ns_capable(file, time_ns->user_ns, CAP_SYS_TIME)".

Will fix. Thanks!

Quoted 6 lines
Quoted 4 lines
kernel/time_namespace.c +3 -0
+               put_time_ns(time_ns);
+               return -EPERM;
+       }

[...]

Quoted 1 line

+}

#34 lore raw

PATCH v3 20/27 selftest/timens: Add Time Namespace test for supported clocks

In reply to Dmitry Safonov

A test to check that all supported clocks work on host and inside a new time namespace. Use both ways to get time: through VDSO and by entering the kernel with implicit syscall.

Introduce a new timens directory in selftests framework for the next timens tests.

---
 tools/testing/selftests/Makefile          |   1 +
 tools/testing/selftests/timens/.gitignore |   1 +
 tools/testing/selftests/timens/Makefile   |   5 +
 tools/testing/selftests/timens/config     |   1 +
 tools/testing/selftests/timens/log.h      |  26 +++
 tools/testing/selftests/timens/timens.c   | 188 ++++++++++++++++++++++
 tools/testing/selftests/timens/timens.h   |  63 ++++++++
 7 files changed, 285 insertions(+)
 create mode 100644 tools/testing/selftests/timens/.gitignore
 create mode 100644 tools/testing/selftests/timens/Makefile
 create mode 100644 tools/testing/selftests/timens/config
 create mode 100644 tools/testing/selftests/timens/log.h
 create mode 100644 tools/testing/selftests/timens/timens.c
 create mode 100644 tools/testing/selftests/timens/timens.h
tools/testing/selftests/Makefile +1 -0
index 971fc8428117..7cfb6e96f391 100644
@@ -47,6 +47,7 @@ TARGETS += splice
 TARGETS += static_keys
 TARGETS += sync
 TARGETS += sysctl
+TARGETS += timens
 ifneq (1, $(quicktest))
 TARGETS += timers
 endif
tools/testing/selftests/timens/.gitignore new file +1 -0
new file mode 100644
index 000000000000..27a693229ce1
@@ -0,0 +1 @@
+timens
tools/testing/selftests/timens/Makefile new file +5 -0
new file mode 100644
index 000000000000..b877efb78974
@@ -0,0 +1,5 @@
+TEST_GEN_PROGS := timens
+
+CFLAGS := -Wall -Werror
+
+include ../lib.mk
tools/testing/selftests/timens/config new file +1 -0
new file mode 100644
index 000000000000..4480620f6f49
@@ -0,0 +1 @@
+CONFIG_TIME_NS=y
tools/testing/selftests/timens/log.h new file +26 -0
new file mode 100644
index 000000000000..db64df2a8483
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef __SELFTEST_TIMENS_LOG_H__
+#define __SELFTEST_TIMENS_LOG_H__
+
+#define pr_msg(fmt, lvl, ...)						\
+	ksft_print_msg("[%s] (%s:%d)\t" fmt "\n",			\
+			lvl, __FILE__, __LINE__, ##__VA_ARGS__)
+
+#define pr_p(func, fmt, ...)	func(fmt ": %m", ##__VA_ARGS__)
+
+#define pr_err(fmt, ...)						\
+	({								\
+		ksft_test_result_error(fmt "\n", ##__VA_ARGS__);		\
+		-1;							\
+	})
+
+#define pr_fail(fmt, ...)					\
+	({							\
+		ksft_test_result_fail(fmt, ##__VA_ARGS__);	\
+		-1;						\
+	})
+
+#define pr_perror(fmt, ...)	pr_p(pr_err, fmt, ##__VA_ARGS__)
+
+#endif
tools/testing/selftests/timens/timens.c new file +188 -0

188 lines not on this page · raw message

tools/testing/selftests/timens/timens.h new file +63 -0

63 lines not on this page · raw message

Signature · 1 line
2.21.0
#35 lore raw

PATCH v3 21/27 selftest/timens: Add a test for timerfd

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

Check that timerfd_create() takes into account clock offsets.

---
 tools/testing/selftests/timens/.gitignore |   1 +
 tools/testing/selftests/timens/Makefile   |   2 +-
 tools/testing/selftests/timens/timerfd.c  | 127 ++++++++++++++++++++++
 3 files changed, 129 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/timens/timerfd.c
tools/testing/selftests/timens/.gitignore +1 -0
index 27a693229ce1..b609f6ee9fb9 100644
@@ -1 +1,2 @@
 timens
+timerfd
tools/testing/selftests/timens/Makefile +1 -1
index b877efb78974..66b90cd28e5c 100644
@@ -1,4 +1,4 @@
-TEST_GEN_PROGS := timens
+TEST_GEN_PROGS := timens timerfd
 
 CFLAGS := -Wall -Werror
 
tools/testing/selftests/timens/timerfd.c new file +127 -0

127 lines not on this page · raw message

Signature · 1 line
2.21.0
#36 lore raw

PATCH v3 22/27 selftest/timens: Add a test for clock_nanosleep()

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

Check that clock_nanosleep() takes into account clock offsets.

---
 tools/testing/selftests/timens/.gitignore     |   1 +
 tools/testing/selftests/timens/Makefile       |   2 +-
 .../selftests/timens/clock_nanosleep.c        | 100 ++++++++++++++++++
 3 files changed, 102 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/timens/clock_nanosleep.c
tools/testing/selftests/timens/.gitignore +1 -0
index b609f6ee9fb9..9b6c8ddac2c8 100644
@@ -1,2 +1,3 @@
+clock_nanosleep
 timens
 timerfd
tools/testing/selftests/timens/Makefile +1 -1
index 66b90cd28e5c..76a1dc891184 100644
@@ -1,4 +1,4 @@
-TEST_GEN_PROGS := timens timerfd
+TEST_GEN_PROGS := timens timerfd clock_nanosleep
 
 CFLAGS := -Wall -Werror
 
tools/testing/selftests/timens/clock_nanosleep.c new file +100 -0

100 lines not on this page · raw message

Signature · 1 line
2.21.0
#37 lore raw

PATCH v3 23/27 selftest/timens: Add procfs selftest

In reply to Dmitry Safonov

Check that /proc/uptime is correct inside a new time namespace.

---
 tools/testing/selftests/timens/.gitignore |   1 +
 tools/testing/selftests/timens/Makefile   |   2 +-
 tools/testing/selftests/timens/procfs.c   | 142 ++++++++++++++++++++++
 3 files changed, 144 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/timens/procfs.c
tools/testing/selftests/timens/.gitignore +1 -0
index 9b6c8ddac2c8..94ffdd9cead7 100644
@@ -1,3 +1,4 @@
 clock_nanosleep
+procfs
 timens
 timerfd
tools/testing/selftests/timens/Makefile +1 -1
index 76a1dc891184..f96f50d1fef8 100644
@@ -1,4 +1,4 @@
-TEST_GEN_PROGS := timens timerfd clock_nanosleep
+TEST_GEN_PROGS := timens timerfd clock_nanosleep procfs
 
 CFLAGS := -Wall -Werror
 
tools/testing/selftests/timens/procfs.c new file +142 -0

142 lines not on this page · raw message

Signature · 1 line
2.21.0
#38 lore raw

PATCH v3 24/27 selftest/timens: Add timer offsets test

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

Check that timer_create() takes into account clock offsets.

---
 tools/testing/selftests/timens/.gitignore |   1 +
 tools/testing/selftests/timens/Makefile   |   3 +-
 tools/testing/selftests/timens/timer.c    | 116 ++++++++++++++++++++++
 3 files changed, 119 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/timens/timer.c
tools/testing/selftests/timens/.gitignore +1 -0
index 94ffdd9cead7..3b7eda8f35ce 100644
@@ -1,4 +1,5 @@
 clock_nanosleep
 procfs
 timens
+timer
 timerfd
tools/testing/selftests/timens/Makefile +2 -1
index f96f50d1fef8..ae1ffd24cc43 100644
@@ -1,5 +1,6 @@
-TEST_GEN_PROGS := timens timerfd clock_nanosleep procfs
+TEST_GEN_PROGS := timens timerfd timer clock_nanosleep procfs
 
 CFLAGS := -Wall -Werror
+LDFLAGS := -lrt
 
 include ../lib.mk
tools/testing/selftests/timens/timer.c new file +116 -0

116 lines not on this page · raw message

Signature · 1 line
2.21.0
#39 lore raw

PATCH v3 25/27 x86/vdso: Align VDSO functions by CPU L1 cache line

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

After performance testing VDSO patches a noticeable 20% regression was found on gettime_perf selftest with a cold cache.
As it turns to be, before time namespaces introduction, VDSO functions were quite aligned to cache lines, but adding a new code to adjust timens offset inside namespace created a small shift and vdso functions become unaligned on cache lines.

Add align to vdso functions with gcc option to fix performance drop.

Coping the resulting numbers from cover letter:

Hot CPU cache (more gettime_perf.c cycles - the better):

        | before     | CONFIG_TIME_NS=n | host        | inside timens
--------|------------|------------------|-------------|-------------
cycles  | 139887013  | 139453003        | 139899785   | 128792458
diff (%)| 100        | 99.7             | 100         | 92

Cold cache (lesser tsc per gettime_perf_cold.c cycle - the better):

        | before     | CONFIG_TIME_NS=n | host        | inside timens
--------|------------|------------------|-------------|-------------
tsc     | 6748       | 6718             | 6862        | 12682
diff (%)| 100        | 99.6             | 101.7       | 188

Measured on Intel(R) Core(TM) i5-6300U CPU @ 2.40GHz

---
 arch/x86/entry/vdso/Makefile | 1 +
 1 file changed, 1 insertion(+)
arch/x86/entry/vdso/Makefile +1 -0
index bc0bdbf49397..9b45aafdfcfe 100644
@@ -4,6 +4,7 @@
 #
 
 KBUILD_CFLAGS += $(DISABLE_LTO)
+KBUILD_CFLAGS += -falign-functions=$(CONFIG_X86_L1_CACHE_SHIFT)
 KASAN_SANITIZE			:= n
 UBSAN_SANITIZE			:= n
 OBJECT_FILES_NON_STANDARD	:= y
Signature · 1 line
2.21.0
#40 lore raw

PATCH v3 26/27 selftests: Add a simple perf test for clock_gettime()

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

---
 tools/testing/selftests/timens/.gitignore     |  2 +
 tools/testing/selftests/timens/Makefile       |  8 +-
 tools/testing/selftests/timens/gettime_perf.c | 74 +++++++++++++++++++
 .../selftests/timens/gettime_perf_cold.c      | 63 ++++++++++++++++
 4 files changed, 146 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/timens/gettime_perf.c
 create mode 100644 tools/testing/selftests/timens/gettime_perf_cold.c
tools/testing/selftests/timens/.gitignore +2 -0
index 3b7eda8f35ce..16292e4d08a5 100644
@@ -1,4 +1,6 @@
 clock_nanosleep
+gettime_perf
+gettime_perf_cold
 procfs
 timens
 timer
tools/testing/selftests/timens/Makefile +7 -1
index ae1ffd24cc43..ef65bf96b55c 100644
@@ -1,4 +1,10 @@
-TEST_GEN_PROGS := timens timerfd timer clock_nanosleep procfs
+TEST_GEN_PROGS := timens timerfd timer clock_nanosleep procfs gettime_perf
+
+uname_M := $(shell uname -m 2>/dev/null || echo not)
+ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/)
+ifeq ($(ARCH),x86_64)
+TEST_GEN_PROGS += gettime_perf_cold
+endif
 
 CFLAGS := -Wall -Werror
 LDFLAGS := -lrt
tools/testing/selftests/timens/gettime_perf.c new file +74 -0

74 lines not on this page · raw message

tools/testing/selftests/timens/gettime_perf_cold.c new file +63 -0

63 lines not on this page · raw message

Signature · 1 line
2.21.0
#41 lore raw

PATCH v3 27/27 selftest/timens: Check that a right vdso is mapped after fork and exec

In reply to Dmitry Safonov

From: Andrei Vagin <[email protected]>

---
 tools/testing/selftests/timens/.gitignore |  1 +
 tools/testing/selftests/timens/Makefile   |  2 +-
 tools/testing/selftests/timens/exec.c     | 91 +++++++++++++++++++++++
 3 files changed, 93 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/timens/exec.c
tools/testing/selftests/timens/.gitignore +1 -0
index 16292e4d08a5..789f21e81028 100644
@@ -1,4 +1,5 @@
 clock_nanosleep
+exec
 gettime_perf
 gettime_perf_cold
 procfs
tools/testing/selftests/timens/Makefile +1 -1
index ef65bf96b55c..9e0edf354906 100644
@@ -1,4 +1,4 @@
-TEST_GEN_PROGS := timens timerfd timer clock_nanosleep procfs gettime_perf
+TEST_GEN_PROGS := timens timerfd timer clock_nanosleep procfs gettime_perf exec
 
 uname_M := $(shell uname -m 2>/dev/null || echo not)
 ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/)
tools/testing/selftests/timens/exec.c new file +91 -0

91 lines not on this page · raw message

Signature · 1 line
2.21.0