xref: /openbmc/linux/kernel/time/namespace.c (revision dc6a81c3) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Author: Andrei Vagin <avagin@openvz.org>
4  * Author: Dmitry Safonov <dima@arista.com>
5  */
6 
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/seq_file.h>
12 #include <linux/proc_ns.h>
13 #include <linux/export.h>
14 #include <linux/time.h>
15 #include <linux/slab.h>
16 #include <linux/cred.h>
17 #include <linux/err.h>
18 #include <linux/mm.h>
19 
20 #include <vdso/datapage.h>
21 
22 ktime_t do_timens_ktime_to_host(clockid_t clockid, ktime_t tim,
23 				struct timens_offsets *ns_offsets)
24 {
25 	ktime_t offset;
26 
27 	switch (clockid) {
28 	case CLOCK_MONOTONIC:
29 		offset = timespec64_to_ktime(ns_offsets->monotonic);
30 		break;
31 	case CLOCK_BOOTTIME:
32 	case CLOCK_BOOTTIME_ALARM:
33 		offset = timespec64_to_ktime(ns_offsets->boottime);
34 		break;
35 	default:
36 		return tim;
37 	}
38 
39 	/*
40 	 * Check that @tim value is in [offset, KTIME_MAX + offset]
41 	 * and subtract offset.
42 	 */
43 	if (tim < offset) {
44 		/*
45 		 * User can specify @tim *absolute* value - if it's lesser than
46 		 * the time namespace's offset - it's already expired.
47 		 */
48 		tim = 0;
49 	} else {
50 		tim = ktime_sub(tim, offset);
51 		if (unlikely(tim > KTIME_MAX))
52 			tim = KTIME_MAX;
53 	}
54 
55 	return tim;
56 }
57 
58 static struct ucounts *inc_time_namespaces(struct user_namespace *ns)
59 {
60 	return inc_ucount(ns, current_euid(), UCOUNT_TIME_NAMESPACES);
61 }
62 
63 static void dec_time_namespaces(struct ucounts *ucounts)
64 {
65 	dec_ucount(ucounts, UCOUNT_TIME_NAMESPACES);
66 }
67 
68 /**
69  * clone_time_ns - Clone a time namespace
70  * @user_ns:	User namespace which owns a new namespace.
71  * @old_ns:	Namespace to clone
72  *
73  * Clone @old_ns and set the clone refcount to 1
74  *
75  * Return: The new namespace or ERR_PTR.
76  */
77 static struct time_namespace *clone_time_ns(struct user_namespace *user_ns,
78 					  struct time_namespace *old_ns)
79 {
80 	struct time_namespace *ns;
81 	struct ucounts *ucounts;
82 	int err;
83 
84 	err = -ENOSPC;
85 	ucounts = inc_time_namespaces(user_ns);
86 	if (!ucounts)
87 		goto fail;
88 
89 	err = -ENOMEM;
90 	ns = kmalloc(sizeof(*ns), GFP_KERNEL);
91 	if (!ns)
92 		goto fail_dec;
93 
94 	kref_init(&ns->kref);
95 
96 	ns->vvar_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
97 	if (!ns->vvar_page)
98 		goto fail_free;
99 
100 	err = ns_alloc_inum(&ns->ns);
101 	if (err)
102 		goto fail_free_page;
103 
104 	ns->ucounts = ucounts;
105 	ns->ns.ops = &timens_operations;
106 	ns->user_ns = get_user_ns(user_ns);
107 	ns->offsets = old_ns->offsets;
108 	ns->frozen_offsets = false;
109 	return ns;
110 
111 fail_free_page:
112 	__free_page(ns->vvar_page);
113 fail_free:
114 	kfree(ns);
115 fail_dec:
116 	dec_time_namespaces(ucounts);
117 fail:
118 	return ERR_PTR(err);
119 }
120 
121 /**
122  * copy_time_ns - Create timens_for_children from @old_ns
123  * @flags:	Cloning flags
124  * @user_ns:	User namespace which owns a new namespace.
125  * @old_ns:	Namespace to clone
126  *
127  * If CLONE_NEWTIME specified in @flags, creates a new timens_for_children;
128  * adds a refcounter to @old_ns otherwise.
129  *
130  * Return: timens_for_children namespace or ERR_PTR.
131  */
132 struct time_namespace *copy_time_ns(unsigned long flags,
133 	struct user_namespace *user_ns, struct time_namespace *old_ns)
134 {
135 	if (!(flags & CLONE_NEWTIME))
136 		return get_time_ns(old_ns);
137 
138 	return clone_time_ns(user_ns, old_ns);
139 }
140 
141 static struct timens_offset offset_from_ts(struct timespec64 off)
142 {
143 	struct timens_offset ret;
144 
145 	ret.sec = off.tv_sec;
146 	ret.nsec = off.tv_nsec;
147 
148 	return ret;
149 }
150 
151 /*
152  * A time namespace VVAR page has the same layout as the VVAR page which
153  * contains the system wide VDSO data.
154  *
155  * For a normal task the VVAR pages are installed in the normal ordering:
156  *     VVAR
157  *     PVCLOCK
158  *     HVCLOCK
159  *     TIMENS   <- Not really required
160  *
161  * Now for a timens task the pages are installed in the following order:
162  *     TIMENS
163  *     PVCLOCK
164  *     HVCLOCK
165  *     VVAR
166  *
167  * The check for vdso_data->clock_mode is in the unlikely path of
168  * the seq begin magic. So for the non-timens case most of the time
169  * 'seq' is even, so the branch is not taken.
170  *
171  * If 'seq' is odd, i.e. a concurrent update is in progress, the extra check
172  * for vdso_data->clock_mode is a non-issue. The task is spin waiting for the
173  * update to finish and for 'seq' to become even anyway.
174  *
175  * Timens page has vdso_data->clock_mode set to VCLOCK_TIMENS which enforces
176  * the time namespace handling path.
177  */
178 static void timens_setup_vdso_data(struct vdso_data *vdata,
179 				   struct time_namespace *ns)
180 {
181 	struct timens_offset *offset = vdata->offset;
182 	struct timens_offset monotonic = offset_from_ts(ns->offsets.monotonic);
183 	struct timens_offset boottime = offset_from_ts(ns->offsets.boottime);
184 
185 	vdata->seq			= 1;
186 	vdata->clock_mode		= VCLOCK_TIMENS;
187 	offset[CLOCK_MONOTONIC]		= monotonic;
188 	offset[CLOCK_MONOTONIC_RAW]	= monotonic;
189 	offset[CLOCK_MONOTONIC_COARSE]	= monotonic;
190 	offset[CLOCK_BOOTTIME]		= boottime;
191 	offset[CLOCK_BOOTTIME_ALARM]	= boottime;
192 }
193 
194 /*
195  * Protects possibly multiple offsets writers racing each other
196  * and tasks entering the namespace.
197  */
198 static DEFINE_MUTEX(offset_lock);
199 
200 static void timens_set_vvar_page(struct task_struct *task,
201 				struct time_namespace *ns)
202 {
203 	struct vdso_data *vdata;
204 	unsigned int i;
205 
206 	if (ns == &init_time_ns)
207 		return;
208 
209 	/* Fast-path, taken by every task in namespace except the first. */
210 	if (likely(ns->frozen_offsets))
211 		return;
212 
213 	mutex_lock(&offset_lock);
214 	/* Nothing to-do: vvar_page has been already initialized. */
215 	if (ns->frozen_offsets)
216 		goto out;
217 
218 	ns->frozen_offsets = true;
219 	vdata = arch_get_vdso_data(page_address(ns->vvar_page));
220 
221 	for (i = 0; i < CS_BASES; i++)
222 		timens_setup_vdso_data(&vdata[i], ns);
223 
224 out:
225 	mutex_unlock(&offset_lock);
226 }
227 
228 void free_time_ns(struct kref *kref)
229 {
230 	struct time_namespace *ns;
231 
232 	ns = container_of(kref, struct time_namespace, kref);
233 	dec_time_namespaces(ns->ucounts);
234 	put_user_ns(ns->user_ns);
235 	ns_free_inum(&ns->ns);
236 	__free_page(ns->vvar_page);
237 	kfree(ns);
238 }
239 
240 static struct time_namespace *to_time_ns(struct ns_common *ns)
241 {
242 	return container_of(ns, struct time_namespace, ns);
243 }
244 
245 static struct ns_common *timens_get(struct task_struct *task)
246 {
247 	struct time_namespace *ns = NULL;
248 	struct nsproxy *nsproxy;
249 
250 	task_lock(task);
251 	nsproxy = task->nsproxy;
252 	if (nsproxy) {
253 		ns = nsproxy->time_ns;
254 		get_time_ns(ns);
255 	}
256 	task_unlock(task);
257 
258 	return ns ? &ns->ns : NULL;
259 }
260 
261 static struct ns_common *timens_for_children_get(struct task_struct *task)
262 {
263 	struct time_namespace *ns = NULL;
264 	struct nsproxy *nsproxy;
265 
266 	task_lock(task);
267 	nsproxy = task->nsproxy;
268 	if (nsproxy) {
269 		ns = nsproxy->time_ns_for_children;
270 		get_time_ns(ns);
271 	}
272 	task_unlock(task);
273 
274 	return ns ? &ns->ns : NULL;
275 }
276 
277 static void timens_put(struct ns_common *ns)
278 {
279 	put_time_ns(to_time_ns(ns));
280 }
281 
282 static int timens_install(struct nsproxy *nsproxy, struct ns_common *new)
283 {
284 	struct time_namespace *ns = to_time_ns(new);
285 	int err;
286 
287 	if (!current_is_single_threaded())
288 		return -EUSERS;
289 
290 	if (!ns_capable(ns->user_ns, CAP_SYS_ADMIN) ||
291 	    !ns_capable(current_user_ns(), CAP_SYS_ADMIN))
292 		return -EPERM;
293 
294 	timens_set_vvar_page(current, ns);
295 
296 	err = vdso_join_timens(current, ns);
297 	if (err)
298 		return err;
299 
300 	get_time_ns(ns);
301 	put_time_ns(nsproxy->time_ns);
302 	nsproxy->time_ns = ns;
303 
304 	get_time_ns(ns);
305 	put_time_ns(nsproxy->time_ns_for_children);
306 	nsproxy->time_ns_for_children = ns;
307 	return 0;
308 }
309 
310 int timens_on_fork(struct nsproxy *nsproxy, struct task_struct *tsk)
311 {
312 	struct ns_common *nsc = &nsproxy->time_ns_for_children->ns;
313 	struct time_namespace *ns = to_time_ns(nsc);
314 	int err;
315 
316 	/* create_new_namespaces() already incremented the ref counter */
317 	if (nsproxy->time_ns == nsproxy->time_ns_for_children)
318 		return 0;
319 
320 	timens_set_vvar_page(tsk, ns);
321 
322 	err = vdso_join_timens(tsk, ns);
323 	if (err)
324 		return err;
325 
326 	get_time_ns(ns);
327 	put_time_ns(nsproxy->time_ns);
328 	nsproxy->time_ns = ns;
329 
330 	return 0;
331 }
332 
333 static struct user_namespace *timens_owner(struct ns_common *ns)
334 {
335 	return to_time_ns(ns)->user_ns;
336 }
337 
338 static void show_offset(struct seq_file *m, int clockid, struct timespec64 *ts)
339 {
340 	seq_printf(m, "%d %lld %ld\n", clockid, ts->tv_sec, ts->tv_nsec);
341 }
342 
343 void proc_timens_show_offsets(struct task_struct *p, struct seq_file *m)
344 {
345 	struct ns_common *ns;
346 	struct time_namespace *time_ns;
347 
348 	ns = timens_for_children_get(p);
349 	if (!ns)
350 		return;
351 	time_ns = to_time_ns(ns);
352 
353 	show_offset(m, CLOCK_MONOTONIC, &time_ns->offsets.monotonic);
354 	show_offset(m, CLOCK_BOOTTIME, &time_ns->offsets.boottime);
355 	put_time_ns(time_ns);
356 }
357 
358 int proc_timens_set_offset(struct file *file, struct task_struct *p,
359 			   struct proc_timens_offset *offsets, int noffsets)
360 {
361 	struct ns_common *ns;
362 	struct time_namespace *time_ns;
363 	struct timespec64 tp;
364 	int i, err;
365 
366 	ns = timens_for_children_get(p);
367 	if (!ns)
368 		return -ESRCH;
369 	time_ns = to_time_ns(ns);
370 
371 	if (!file_ns_capable(file, time_ns->user_ns, CAP_SYS_TIME)) {
372 		put_time_ns(time_ns);
373 		return -EPERM;
374 	}
375 
376 	for (i = 0; i < noffsets; i++) {
377 		struct proc_timens_offset *off = &offsets[i];
378 
379 		switch (off->clockid) {
380 		case CLOCK_MONOTONIC:
381 			ktime_get_ts64(&tp);
382 			break;
383 		case CLOCK_BOOTTIME:
384 			ktime_get_boottime_ts64(&tp);
385 			break;
386 		default:
387 			err = -EINVAL;
388 			goto out;
389 		}
390 
391 		err = -ERANGE;
392 
393 		if (off->val.tv_sec > KTIME_SEC_MAX ||
394 		    off->val.tv_sec < -KTIME_SEC_MAX)
395 			goto out;
396 
397 		tp = timespec64_add(tp, off->val);
398 		/*
399 		 * KTIME_SEC_MAX is divided by 2 to be sure that KTIME_MAX is
400 		 * still unreachable.
401 		 */
402 		if (tp.tv_sec < 0 || tp.tv_sec > KTIME_SEC_MAX / 2)
403 			goto out;
404 	}
405 
406 	mutex_lock(&offset_lock);
407 	if (time_ns->frozen_offsets) {
408 		err = -EACCES;
409 		goto out_unlock;
410 	}
411 
412 	err = 0;
413 	/* Don't report errors after this line */
414 	for (i = 0; i < noffsets; i++) {
415 		struct proc_timens_offset *off = &offsets[i];
416 		struct timespec64 *offset = NULL;
417 
418 		switch (off->clockid) {
419 		case CLOCK_MONOTONIC:
420 			offset = &time_ns->offsets.monotonic;
421 			break;
422 		case CLOCK_BOOTTIME:
423 			offset = &time_ns->offsets.boottime;
424 			break;
425 		}
426 
427 		*offset = off->val;
428 	}
429 
430 out_unlock:
431 	mutex_unlock(&offset_lock);
432 out:
433 	put_time_ns(time_ns);
434 
435 	return err;
436 }
437 
438 const struct proc_ns_operations timens_operations = {
439 	.name		= "time",
440 	.type		= CLONE_NEWTIME,
441 	.get		= timens_get,
442 	.put		= timens_put,
443 	.install	= timens_install,
444 	.owner		= timens_owner,
445 };
446 
447 const struct proc_ns_operations timens_for_children_operations = {
448 	.name		= "time_for_children",
449 	.type		= CLONE_NEWTIME,
450 	.get		= timens_for_children_get,
451 	.put		= timens_put,
452 	.install	= timens_install,
453 	.owner		= timens_owner,
454 };
455 
456 struct time_namespace init_time_ns = {
457 	.kref		= KREF_INIT(3),
458 	.user_ns	= &init_user_ns,
459 	.ns.inum	= PROC_TIME_INIT_INO,
460 	.ns.ops		= &timens_operations,
461 	.frozen_offsets	= true,
462 };
463 
464 static int __init time_ns_init(void)
465 {
466 	return 0;
467 }
468 subsys_initcall(time_ns_init);
469