1 // SPDX-License-Identifier: GPL-2.0
3 * Author: Andrei Vagin <avagin@openvz.org>
4 * Author: Dmitry Safonov <dima@arista.com>
7 #include <linux/time_namespace.h>
8 #include <linux/user_namespace.h>
9 #include <linux/sched/signal.h>
10 #include <linux/sched/task.h>
11 #include <linux/clocksource.h>
12 #include <linux/seq_file.h>
13 #include <linux/proc_ns.h>
14 #include <linux/export.h>
15 #include <linux/time.h>
16 #include <linux/slab.h>
17 #include <linux/cred.h>
18 #include <linux/err.h>
21 #include <vdso/datapage.h>
23 ktime_t
do_timens_ktime_to_host(clockid_t clockid
, ktime_t tim
,
24 struct timens_offsets
*ns_offsets
)
30 offset
= timespec64_to_ktime(ns_offsets
->monotonic
);
33 case CLOCK_BOOTTIME_ALARM
:
34 offset
= timespec64_to_ktime(ns_offsets
->boottime
);
41 * Check that @tim value is in [offset, KTIME_MAX + offset]
42 * and subtract offset.
46 * User can specify @tim *absolute* value - if it's lesser than
47 * the time namespace's offset - it's already expired.
51 tim
= ktime_sub(tim
, offset
);
52 if (unlikely(tim
> KTIME_MAX
))
59 static struct ucounts
*inc_time_namespaces(struct user_namespace
*ns
)
61 return inc_ucount(ns
, current_euid(), UCOUNT_TIME_NAMESPACES
);
64 static void dec_time_namespaces(struct ucounts
*ucounts
)
66 dec_ucount(ucounts
, UCOUNT_TIME_NAMESPACES
);
70 * clone_time_ns - Clone a time namespace
71 * @user_ns: User namespace which owns a new namespace.
72 * @old_ns: Namespace to clone
74 * Clone @old_ns and set the clone refcount to 1
76 * Return: The new namespace or ERR_PTR.
78 static struct time_namespace
*clone_time_ns(struct user_namespace
*user_ns
,
79 struct time_namespace
*old_ns
)
81 struct time_namespace
*ns
;
82 struct ucounts
*ucounts
;
86 ucounts
= inc_time_namespaces(user_ns
);
91 ns
= kmalloc(sizeof(*ns
), GFP_KERNEL
);
97 ns
->vvar_page
= alloc_page(GFP_KERNEL
| __GFP_ZERO
);
101 err
= ns_alloc_inum(&ns
->ns
);
105 ns
->ucounts
= ucounts
;
106 ns
->ns
.ops
= &timens_operations
;
107 ns
->user_ns
= get_user_ns(user_ns
);
108 ns
->offsets
= old_ns
->offsets
;
109 ns
->frozen_offsets
= false;
113 __free_page(ns
->vvar_page
);
117 dec_time_namespaces(ucounts
);
123 * copy_time_ns - Create timens_for_children from @old_ns
124 * @flags: Cloning flags
125 * @user_ns: User namespace which owns a new namespace.
126 * @old_ns: Namespace to clone
128 * If CLONE_NEWTIME specified in @flags, creates a new timens_for_children;
129 * adds a refcounter to @old_ns otherwise.
131 * Return: timens_for_children namespace or ERR_PTR.
133 struct time_namespace
*copy_time_ns(unsigned long flags
,
134 struct user_namespace
*user_ns
, struct time_namespace
*old_ns
)
136 if (!(flags
& CLONE_NEWTIME
))
137 return get_time_ns(old_ns
);
139 return clone_time_ns(user_ns
, old_ns
);
142 static struct timens_offset
offset_from_ts(struct timespec64 off
)
144 struct timens_offset ret
;
146 ret
.sec
= off
.tv_sec
;
147 ret
.nsec
= off
.tv_nsec
;
153 * A time namespace VVAR page has the same layout as the VVAR page which
154 * contains the system wide VDSO data.
156 * For a normal task the VVAR pages are installed in the normal ordering:
160 * TIMENS <- Not really required
162 * Now for a timens task the pages are installed in the following order:
168 * The check for vdso_data->clock_mode is in the unlikely path of
169 * the seq begin magic. So for the non-timens case most of the time
170 * 'seq' is even, so the branch is not taken.
172 * If 'seq' is odd, i.e. a concurrent update is in progress, the extra check
173 * for vdso_data->clock_mode is a non-issue. The task is spin waiting for the
174 * update to finish and for 'seq' to become even anyway.
176 * Timens page has vdso_data->clock_mode set to VDSO_CLOCKMODE_TIMENS which
177 * enforces the time namespace handling path.
179 static void timens_setup_vdso_data(struct vdso_data
*vdata
,
180 struct time_namespace
*ns
)
182 struct timens_offset
*offset
= vdata
->offset
;
183 struct timens_offset monotonic
= offset_from_ts(ns
->offsets
.monotonic
);
184 struct timens_offset boottime
= offset_from_ts(ns
->offsets
.boottime
);
187 vdata
->clock_mode
= VDSO_CLOCKMODE_TIMENS
;
188 offset
[CLOCK_MONOTONIC
] = monotonic
;
189 offset
[CLOCK_MONOTONIC_RAW
] = monotonic
;
190 offset
[CLOCK_MONOTONIC_COARSE
] = monotonic
;
191 offset
[CLOCK_BOOTTIME
] = boottime
;
192 offset
[CLOCK_BOOTTIME_ALARM
] = boottime
;
196 * Protects possibly multiple offsets writers racing each other
197 * and tasks entering the namespace.
199 static DEFINE_MUTEX(offset_lock
);
201 static void timens_set_vvar_page(struct task_struct
*task
,
202 struct time_namespace
*ns
)
204 struct vdso_data
*vdata
;
207 if (ns
== &init_time_ns
)
210 /* Fast-path, taken by every task in namespace except the first. */
211 if (likely(ns
->frozen_offsets
))
214 mutex_lock(&offset_lock
);
215 /* Nothing to-do: vvar_page has been already initialized. */
216 if (ns
->frozen_offsets
)
219 ns
->frozen_offsets
= true;
220 vdata
= arch_get_vdso_data(page_address(ns
->vvar_page
));
222 for (i
= 0; i
< CS_BASES
; i
++)
223 timens_setup_vdso_data(&vdata
[i
], ns
);
226 mutex_unlock(&offset_lock
);
229 void free_time_ns(struct kref
*kref
)
231 struct time_namespace
*ns
;
233 ns
= container_of(kref
, struct time_namespace
, kref
);
234 dec_time_namespaces(ns
->ucounts
);
235 put_user_ns(ns
->user_ns
);
236 ns_free_inum(&ns
->ns
);
237 __free_page(ns
->vvar_page
);
241 static struct time_namespace
*to_time_ns(struct ns_common
*ns
)
243 return container_of(ns
, struct time_namespace
, ns
);
246 static struct ns_common
*timens_get(struct task_struct
*task
)
248 struct time_namespace
*ns
= NULL
;
249 struct nsproxy
*nsproxy
;
252 nsproxy
= task
->nsproxy
;
254 ns
= nsproxy
->time_ns
;
259 return ns
? &ns
->ns
: NULL
;
262 static struct ns_common
*timens_for_children_get(struct task_struct
*task
)
264 struct time_namespace
*ns
= NULL
;
265 struct nsproxy
*nsproxy
;
268 nsproxy
= task
->nsproxy
;
270 ns
= nsproxy
->time_ns_for_children
;
275 return ns
? &ns
->ns
: NULL
;
278 static void timens_put(struct ns_common
*ns
)
280 put_time_ns(to_time_ns(ns
));
283 static int timens_install(struct nsproxy
*nsproxy
, struct ns_common
*new)
285 struct time_namespace
*ns
= to_time_ns(new);
288 if (!current_is_single_threaded())
291 if (!ns_capable(ns
->user_ns
, CAP_SYS_ADMIN
) ||
292 !ns_capable(current_user_ns(), CAP_SYS_ADMIN
))
295 timens_set_vvar_page(current
, ns
);
297 err
= vdso_join_timens(current
, ns
);
302 put_time_ns(nsproxy
->time_ns
);
303 nsproxy
->time_ns
= ns
;
306 put_time_ns(nsproxy
->time_ns_for_children
);
307 nsproxy
->time_ns_for_children
= ns
;
311 int timens_on_fork(struct nsproxy
*nsproxy
, struct task_struct
*tsk
)
313 struct ns_common
*nsc
= &nsproxy
->time_ns_for_children
->ns
;
314 struct time_namespace
*ns
= to_time_ns(nsc
);
317 /* create_new_namespaces() already incremented the ref counter */
318 if (nsproxy
->time_ns
== nsproxy
->time_ns_for_children
)
321 timens_set_vvar_page(tsk
, ns
);
323 err
= vdso_join_timens(tsk
, ns
);
328 put_time_ns(nsproxy
->time_ns
);
329 nsproxy
->time_ns
= ns
;
334 static struct user_namespace
*timens_owner(struct ns_common
*ns
)
336 return to_time_ns(ns
)->user_ns
;
339 static void show_offset(struct seq_file
*m
, int clockid
, struct timespec64
*ts
)
341 seq_printf(m
, "%d %lld %ld\n", clockid
, ts
->tv_sec
, ts
->tv_nsec
);
344 void proc_timens_show_offsets(struct task_struct
*p
, struct seq_file
*m
)
346 struct ns_common
*ns
;
347 struct time_namespace
*time_ns
;
349 ns
= timens_for_children_get(p
);
352 time_ns
= to_time_ns(ns
);
354 show_offset(m
, CLOCK_MONOTONIC
, &time_ns
->offsets
.monotonic
);
355 show_offset(m
, CLOCK_BOOTTIME
, &time_ns
->offsets
.boottime
);
356 put_time_ns(time_ns
);
359 int proc_timens_set_offset(struct file
*file
, struct task_struct
*p
,
360 struct proc_timens_offset
*offsets
, int noffsets
)
362 struct ns_common
*ns
;
363 struct time_namespace
*time_ns
;
364 struct timespec64 tp
;
367 ns
= timens_for_children_get(p
);
370 time_ns
= to_time_ns(ns
);
372 if (!file_ns_capable(file
, time_ns
->user_ns
, CAP_SYS_TIME
)) {
373 put_time_ns(time_ns
);
377 for (i
= 0; i
< noffsets
; i
++) {
378 struct proc_timens_offset
*off
= &offsets
[i
];
380 switch (off
->clockid
) {
381 case CLOCK_MONOTONIC
:
385 ktime_get_boottime_ts64(&tp
);
394 if (off
->val
.tv_sec
> KTIME_SEC_MAX
||
395 off
->val
.tv_sec
< -KTIME_SEC_MAX
)
398 tp
= timespec64_add(tp
, off
->val
);
400 * KTIME_SEC_MAX is divided by 2 to be sure that KTIME_MAX is
403 if (tp
.tv_sec
< 0 || tp
.tv_sec
> KTIME_SEC_MAX
/ 2)
407 mutex_lock(&offset_lock
);
408 if (time_ns
->frozen_offsets
) {
414 /* Don't report errors after this line */
415 for (i
= 0; i
< noffsets
; i
++) {
416 struct proc_timens_offset
*off
= &offsets
[i
];
417 struct timespec64
*offset
= NULL
;
419 switch (off
->clockid
) {
420 case CLOCK_MONOTONIC
:
421 offset
= &time_ns
->offsets
.monotonic
;
424 offset
= &time_ns
->offsets
.boottime
;
432 mutex_unlock(&offset_lock
);
434 put_time_ns(time_ns
);
439 const struct proc_ns_operations timens_operations
= {
441 .type
= CLONE_NEWTIME
,
444 .install
= timens_install
,
445 .owner
= timens_owner
,
448 const struct proc_ns_operations timens_for_children_operations
= {
449 .name
= "time_for_children",
450 .real_ns_name
= "time",
451 .type
= CLONE_NEWTIME
,
452 .get
= timens_for_children_get
,
454 .install
= timens_install
,
455 .owner
= timens_owner
,
458 struct time_namespace init_time_ns
= {
459 .kref
= KREF_INIT(3),
460 .user_ns
= &init_user_ns
,
461 .ns
.inum
= PROC_TIME_INIT_INO
,
462 .ns
.ops
= &timens_operations
,
463 .frozen_offsets
= true,
466 static int __init
time_ns_init(void)
470 subsys_initcall(time_ns_init
);