1457c8996SThomas Gleixner// SPDX-License-Identifier: GPL-2.0-only
21da177e4SLinus Torvalds/*
31da177e4SLinus Torvalds * sysctl.c: General linux system control interface
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * Begun 24 March 1995, Stephen Tweedie
61da177e4SLinus Torvalds * Added /proc support, Dec 1995
71da177e4SLinus Torvalds * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
81da177e4SLinus Torvalds * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
91da177e4SLinus Torvalds * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
101da177e4SLinus Torvalds * Dynamic registration fixes, Stephen Tweedie.
111da177e4SLinus Torvalds * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
121da177e4SLinus Torvalds * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris
131da177e4SLinus Torvalds *  Horn.
141da177e4SLinus Torvalds * Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.
151da177e4SLinus Torvalds * Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.
161da177e4SLinus Torvalds * Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill
171da177e4SLinus Torvalds *  Wendling.
181da177e4SLinus Torvalds * The list_for_each() macro wasn't appropriate for the sysctl loop.
191da177e4SLinus Torvalds *  Removed it and replaced it with older style, 03/23/00, Bill Wendling
201da177e4SLinus Torvalds */
211da177e4SLinus Torvalds
221da177e4SLinus Torvalds#include <linux/module.h>
231da177e4SLinus Torvalds#include <linux/mm.h>
241da177e4SLinus Torvalds#include <linux/swap.h>
251da177e4SLinus Torvalds#include <linux/slab.h>
261da177e4SLinus Torvalds#include <linux/sysctl.h>
275a04cca6SAkinobu Mita#include <linux/bitmap.h>
28d33ed52dSDave Young#include <linux/signal.h>
29f39650deSAndy Shevchenko#include <linux/panic.h>
30455cd5abSDan Rosenberg#include <linux/printk.h>
311da177e4SLinus Torvalds#include <linux/proc_fs.h>
3272c2d582SAndrew Morgan#include <linux/security.h>
331da177e4SLinus Torvalds#include <linux/ctype.h>
34fd4b616bSSteven Rostedt#include <linux/kmemleak.h>
35b6459415SJakub Kicinski#include <linux/filter.h>
3662239ac2SAdrian Bunk#include <linux/fs.h>
371da177e4SLinus Torvalds#include <linux/init.h>
381da177e4SLinus Torvalds#include <linux/kernel.h>
390296b228SKay Sievers#include <linux/kobject.h>
4020380731SArnaldo Carvalho de Melo#include <linux/net.h>
411da177e4SLinus Torvalds#include <linux/sysrq.h>
421da177e4SLinus Torvalds#include <linux/highuid.h>
431da177e4SLinus Torvalds#include <linux/writeback.h>
443fff4c42SIngo Molnar#include <linux/ratelimit.h>
4576ab0f53SMel Gorman#include <linux/compaction.h>
461da177e4SLinus Torvalds#include <linux/hugetlb.h>
471da177e4SLinus Torvalds#include <linux/initrd.h>
480b77f5bfSDavid Howells#include <linux/key.h>
491da177e4SLinus Torvalds#include <linux/times.h>
501da177e4SLinus Torvalds#include <linux/limits.h>
511da177e4SLinus Torvalds#include <linux/dcache.h>
521da177e4SLinus Torvalds#include <linux/syscalls.h>
53c748e134SAdrian Bunk#include <linux/vmstat.h>
54c255d844SPavel Machek#include <linux/nfs_fs.h>
55c255d844SPavel Machek#include <linux/acpi.h>
5610a0a8d4SJeremy Fitzhardinge#include <linux/reboot.h>
57b0fc494fSSteven Rostedt#include <linux/ftrace.h>
58cdd6c482SIngo Molnar#include <linux/perf_event.h>
598e4228e1SDavid Rientjes#include <linux/oom.h>
6017f60a7dSEric Paris#include <linux/kmod.h>
6173efc039SDan Ballard#include <linux/capability.h>
6240401530SAl Viro#include <linux/binfmts.h>
63cf4aebc2SClark Williams#include <linux/sched/sysctl.h>
647984754bSKees Cook#include <linux/kexec.h>
651be7f75dSAlexei Starovoitov#include <linux/bpf.h>
66d2921684SEric W. Biederman#include <linux/mount.h>
67cefdca0aSPeter Xu#include <linux/userfaultfd_k.h>
682374c09bSChristoph Hellwig#include <linux/latencytop.h>
692374c09bSChristoph Hellwig#include <linux/pid.h>
700cd7c741SPeter Zijlstra#include <linux/delayacct.h>
711da177e4SLinus Torvalds
727f2923c4SChristian Brauner#include "../lib/kstrtox.h"
737f2923c4SChristian Brauner
747c0f6ba6SLinus Torvalds#include <linux/uaccess.h>
751da177e4SLinus Torvalds#include <asm/processor.h>
761da177e4SLinus Torvalds
7729cbc78bSAndi Kleen#ifdef CONFIG_X86
7829cbc78bSAndi Kleen#include <asm/nmi.h>
790741f4d2SChuck Ebbert#include <asm/stacktrace.h>
806e7c4025SIngo Molnar#include <asm/io.h>
8129cbc78bSAndi Kleen#endif
82d550bbd4SDavid Howells#ifdef CONFIG_SPARC
83d550bbd4SDavid Howells#include <asm/setup.h>
84d550bbd4SDavid Howells#endif
85c55b7c3eSDave Young#ifdef CONFIG_BSD_PROCESS_ACCT
86c55b7c3eSDave Young#include <linux/acct.h>
87c55b7c3eSDave Young#endif
884f0e056fSDave Young#ifdef CONFIG_RT_MUTEXES
894f0e056fSDave Young#include <linux/rtmutex.h>
904f0e056fSDave Young#endif
912edf5e49SDave Young#if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_LOCK_STAT)
922edf5e49SDave Young#include <linux/lockdep.h>
932edf5e49SDave Young#endif
94504d7cf1SDon Zickus
951da177e4SLinus Torvalds#if defined(CONFIG_SYSCTL)
961da177e4SLinus Torvalds
97c4f3b63fSRavikiran G Thirumalai/* Constants used for minimum and  maximum */
98c4f3b63fSRavikiran G Thirumalai
99c5dfd78eSArnaldo Carvalho de Melo#ifdef CONFIG_PERF_EVENTS
100d73840ecSXiaoming Nistatic const int six_hundred_forty_kb = 640 * 1024;
101c5dfd78eSArnaldo Carvalho de Melo#endif
102c4f3b63fSRavikiran G Thirumalai
1039e4a5bdaSAndrea Righi/* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
104d73840ecSXiaoming Nistatic const unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
1059e4a5bdaSAndrea Righi
106f628867dSStephen Kittstatic const int ngroups_max = NGROUPS_MAX;
10773efc039SDan Ballardstatic const int cap_last_cap = CAP_LAST_CAP;
1081da177e4SLinus Torvalds
109d6f8ff73SRandy Dunlap#ifdef CONFIG_PROC_SYSCTL
110f4aacea2SKees Cook
111a19ac337SLuis R. Rodriguez/**
112a19ac337SLuis R. Rodriguez * enum sysctl_writes_mode - supported sysctl write modes
113a19ac337SLuis R. Rodriguez *
114a19ac337SLuis R. Rodriguez * @SYSCTL_WRITES_LEGACY: each write syscall must fully contain the sysctl value
11565f50f25SWeitao Hou *	to be written, and multiple writes on the same sysctl file descriptor
11665f50f25SWeitao Hou *	will rewrite the sysctl value, regardless of file position. No warning
11765f50f25SWeitao Hou *	is issued when the initial position is not 0.
118a19ac337SLuis R. Rodriguez * @SYSCTL_WRITES_WARN: same as above but warn when the initial file position is
11965f50f25SWeitao Hou *	not 0.
120a19ac337SLuis R. Rodriguez * @SYSCTL_WRITES_STRICT: writes to numeric sysctl entries must always be at
12165f50f25SWeitao Hou *	file position 0 and the value must be fully contained in the buffer
12265f50f25SWeitao Hou *	sent to the write syscall. If dealing with strings respect the file
12365f50f25SWeitao Hou *	position, but restrict this to the max length of the buffer, anything
12465f50f25SWeitao Hou *	passed the max length will be ignored. Multiple writes will append
12565f50f25SWeitao Hou *	to the buffer.
126a19ac337SLuis R. Rodriguez *
127a19ac337SLuis R. Rodriguez * These write modes control how current file position affects the behavior of
128a19ac337SLuis R. Rodriguez * updating sysctl values through the proc interface on each write.
129a19ac337SLuis R. Rodriguez */
130a19ac337SLuis R. Rodriguezenum sysctl_writes_mode {
131a19ac337SLuis R. Rodriguez	SYSCTL_WRITES_LEGACY		= -1,
132a19ac337SLuis R. Rodriguez	SYSCTL_WRITES_WARN		= 0,
133a19ac337SLuis R. Rodriguez	SYSCTL_WRITES_STRICT		= 1,
134a19ac337SLuis R. Rodriguez};
135f4aacea2SKees Cook
136a19ac337SLuis R. Rodriguezstatic enum sysctl_writes_mode sysctl_writes_strict = SYSCTL_WRITES_STRICT;
137f461d2dcSChristoph Hellwig#endif /* CONFIG_PROC_SYSCTL */
138ceb18132SLuis R. Rodriguez
13967f3977fSAlexandre Ghiti#if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
14067f3977fSAlexandre Ghiti    defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
1411da177e4SLinus Torvaldsint sysctl_legacy_va_layout;
1421da177e4SLinus Torvalds#endif
1431da177e4SLinus Torvalds
1445e771905SMel Gorman#ifdef CONFIG_COMPACTION
1452452dcb9SXiaoming Ni/* min_extfrag_threshold is SYSCTL_ZERO */;
146d73840ecSXiaoming Nistatic const int max_extfrag_threshold = 1000;
1475e771905SMel Gorman#endif
1485e771905SMel Gorman
149f461d2dcSChristoph Hellwig#endif /* CONFIG_SYSCTL */
150f461d2dcSChristoph Hellwig
1515447e8e0SArnd Bergmann#if defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_SYSCTL)
152d46edd67SSong Liustatic int bpf_stats_handler(struct ctl_table *table, int write,
1537787b6fcSTobias Klauser			     void *buffer, size_t *lenp, loff_t *ppos)
154d46edd67SSong Liu{
155d46edd67SSong Liu	struct static_key *key = (struct static_key *)table->data;
156d46edd67SSong Liu	static int saved_val;
157d46edd67SSong Liu	int val, ret;
158d46edd67SSong Liu	struct ctl_table tmp = {
159d46edd67SSong Liu		.data   = &val,
160d46edd67SSong Liu		.maxlen = sizeof(val),
161d46edd67SSong Liu		.mode   = table->mode,
162d46edd67SSong Liu		.extra1 = SYSCTL_ZERO,
163d46edd67SSong Liu		.extra2 = SYSCTL_ONE,
164d46edd67SSong Liu	};
165d46edd67SSong Liu
166d46edd67SSong Liu	if (write && !capable(CAP_SYS_ADMIN))
167d46edd67SSong Liu		return -EPERM;
168d46edd67SSong Liu
169d46edd67SSong Liu	mutex_lock(&bpf_stats_enabled_mutex);
170d46edd67SSong Liu	val = saved_val;
171d46edd67SSong Liu	ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
172d46edd67SSong Liu	if (write && !ret && val != saved_val) {
173d46edd67SSong Liu		if (val)
174d46edd67SSong Liu			static_key_slow_inc(key);
175d46edd67SSong Liu		else
176d46edd67SSong Liu			static_key_slow_dec(key);
177d46edd67SSong Liu		saved_val = val;
178d46edd67SSong Liu	}
179d46edd67SSong Liu	mutex_unlock(&bpf_stats_enabled_mutex);
180d46edd67SSong Liu	return ret;
181d46edd67SSong Liu}
18208389d88SDaniel Borkmann
18308389d88SDaniel Borkmannstatic int bpf_unpriv_handler(struct ctl_table *table, int write,
18408389d88SDaniel Borkmann			      void *buffer, size_t *lenp, loff_t *ppos)
18508389d88SDaniel Borkmann{
18608389d88SDaniel Borkmann	int ret, unpriv_enable = *(int *)table->data;
18708389d88SDaniel Borkmann	bool locked_state = unpriv_enable == 1;
18808389d88SDaniel Borkmann	struct ctl_table tmp = *table;
18908389d88SDaniel Borkmann
19008389d88SDaniel Borkmann	if (write && !capable(CAP_SYS_ADMIN))
19108389d88SDaniel Borkmann		return -EPERM;
19208389d88SDaniel Borkmann
19308389d88SDaniel Borkmann	tmp.data = &unpriv_enable;
19408389d88SDaniel Borkmann	ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
19508389d88SDaniel Borkmann	if (write && !ret) {
19608389d88SDaniel Borkmann		if (locked_state && unpriv_enable != 1)
19708389d88SDaniel Borkmann			return -EPERM;
19808389d88SDaniel Borkmann		*(int *)table->data = unpriv_enable;
19908389d88SDaniel Borkmann	}
20008389d88SDaniel Borkmann	return ret;
20108389d88SDaniel Borkmann}
20208389d88SDaniel Borkmann#endif /* CONFIG_BPF_SYSCALL && CONFIG_SYSCTL */
203d46edd67SSong Liu
204f461d2dcSChristoph Hellwig/*
205f461d2dcSChristoph Hellwig * /proc/sys support
206f461d2dcSChristoph Hellwig */
207f461d2dcSChristoph Hellwig
208b89a8171SEric W. Biederman#ifdef CONFIG_PROC_SYSCTL
2091da177e4SLinus Torvalds
210f8808300SKees Cookstatic int _proc_do_string(char *data, int maxlen, int write,
21132927393SChristoph Hellwig		char *buffer, size_t *lenp, loff_t *ppos)
2121da177e4SLinus Torvalds{
2131da177e4SLinus Torvalds	size_t len;
21432927393SChristoph Hellwig	char c, *p;
2158d060877SOleg Nesterov
2168d060877SOleg Nesterov	if (!data || !maxlen || !*lenp) {
2171da177e4SLinus Torvalds		*lenp = 0;
2181da177e4SLinus Torvalds		return 0;
2191da177e4SLinus Torvalds	}
2208d060877SOleg Nesterov
2211da177e4SLinus Torvalds	if (write) {
222f4aacea2SKees Cook		if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
223f4aacea2SKees Cook			/* Only continue writes not past the end of buffer. */
224f4aacea2SKees Cook			len = strlen(data);
225f4aacea2SKees Cook			if (len > maxlen - 1)
226f4aacea2SKees Cook				len = maxlen - 1;
227f4aacea2SKees Cook
228f4aacea2SKees Cook			if (*ppos > len)
229f4aacea2SKees Cook				return 0;
230f4aacea2SKees Cook			len = *ppos;
231f4aacea2SKees Cook		} else {
232f4aacea2SKees Cook			/* Start writing from beginning of buffer. */
233f4aacea2SKees Cook			len = 0;
234f4aacea2SKees Cook		}
235f4aacea2SKees Cook
2362ca9bb45SKees Cook		*ppos += *lenp;
2371da177e4SLinus Torvalds		p = buffer;
2382ca9bb45SKees Cook		while ((p - buffer) < *lenp && len < maxlen - 1) {
23932927393SChristoph Hellwig			c = *(p++);
2401da177e4SLinus Torvalds			if (c == 0 || c == '\n')
2411da177e4SLinus Torvalds				break;
2422ca9bb45SKees Cook			data[len++] = c;
2431da177e4SLinus Torvalds		}
244f8808300SKees Cook		data[len] = 0;
2451da177e4SLinus Torvalds	} else {
246f5dd3d6fSSam Vilain		len = strlen(data);
247f5dd3d6fSSam Vilain		if (len > maxlen)
248f5dd3d6fSSam Vilain			len = maxlen;
2498d060877SOleg Nesterov
2508d060877SOleg Nesterov		if (*ppos > len) {
2518d060877SOleg Nesterov			*lenp = 0;
2528d060877SOleg Nesterov			return 0;
2538d060877SOleg Nesterov		}
2548d060877SOleg Nesterov
2558d060877SOleg Nesterov		data += *ppos;
2568d060877SOleg Nesterov		len  -= *ppos;
2578d060877SOleg Nesterov
2581da177e4SLinus Torvalds		if (len > *lenp)
2591da177e4SLinus Torvalds			len = *lenp;
2601da177e4SLinus Torvalds		if (len)
26132927393SChristoph Hellwig			memcpy(buffer, data, len);
2621da177e4SLinus Torvalds		if (len < *lenp) {
26332927393SChristoph Hellwig			buffer[len] = '\n';
2641da177e4SLinus Torvalds			len++;
2651da177e4SLinus Torvalds		}
2661da177e4SLinus Torvalds		*lenp = len;
2671da177e4SLinus Torvalds		*ppos += len;
2681da177e4SLinus Torvalds	}
2691da177e4SLinus Torvalds	return 0;
2701da177e4SLinus Torvalds}
2711da177e4SLinus Torvalds
272f4aacea2SKees Cookstatic void warn_sysctl_write(struct ctl_table *table)
273f4aacea2SKees Cook{
274f4aacea2SKees Cook	pr_warn_once("%s wrote to %s when file position was not 0!\n"
275f4aacea2SKees Cook		"This will not be supported in the future. To silence this\n"
276f4aacea2SKees Cook		"warning, set kernel.sysctl_writes_strict = -1\n",
277f4aacea2SKees Cook		current->comm, table->procname);
278f4aacea2SKees Cook}
279f4aacea2SKees Cook
280d383d484SLuis R. Rodriguez/**
2815f733e8aSRandy Dunlap * proc_first_pos_non_zero_ignore - check if first position is allowed
282d383d484SLuis R. Rodriguez * @ppos: file position
283d383d484SLuis R. Rodriguez * @table: the sysctl table
284d383d484SLuis R. Rodriguez *
285d383d484SLuis R. Rodriguez * Returns true if the first position is non-zero and the sysctl_writes_strict
286d383d484SLuis R. Rodriguez * mode indicates this is not allowed for numeric input types. String proc
2875f733e8aSRandy Dunlap * handlers can ignore the return value.
288d383d484SLuis R. Rodriguez */
289d383d484SLuis R. Rodriguezstatic bool proc_first_pos_non_zero_ignore(loff_t *ppos,
290d383d484SLuis R. Rodriguez					   struct ctl_table *table)
291d383d484SLuis R. Rodriguez{
292d383d484SLuis R. Rodriguez	if (!*ppos)
293d383d484SLuis R. Rodriguez		return false;
294d383d484SLuis R. Rodriguez
295d383d484SLuis R. Rodriguez	switch (sysctl_writes_strict) {
296d383d484SLuis R. Rodriguez	case SYSCTL_WRITES_STRICT:
297d383d484SLuis R. Rodriguez		return true;
298d383d484SLuis R. Rodriguez	case SYSCTL_WRITES_WARN:
299d383d484SLuis R. Rodriguez		warn_sysctl_write(table);
300d383d484SLuis R. Rodriguez		return false;
301d383d484SLuis R. Rodriguez	default:
302d383d484SLuis R. Rodriguez		return false;
303d383d484SLuis R. Rodriguez	}
304d383d484SLuis R. Rodriguez}
305d383d484SLuis R. Rodriguez
306f5dd3d6fSSam Vilain/**
307f5dd3d6fSSam Vilain * proc_dostring - read a string sysctl
308f5dd3d6fSSam Vilain * @table: the sysctl table
309f5dd3d6fSSam Vilain * @write: %TRUE if this is a write to the sysctl file
310f5dd3d6fSSam Vilain * @buffer: the user buffer
311f5dd3d6fSSam Vilain * @lenp: the size of the user buffer
312f5dd3d6fSSam Vilain * @ppos: file position
313f5dd3d6fSSam Vilain *
314f5dd3d6fSSam Vilain * Reads/writes a string from/to the user buffer. If the kernel
315f5dd3d6fSSam Vilain * buffer provided is not large enough to hold the string, the
316f5dd3d6fSSam Vilain * string is truncated. The copied string is %NULL-terminated.
317f5dd3d6fSSam Vilain * If the string is being read by the user process, it is copied
318f5dd3d6fSSam Vilain * and a newline '\n' is added. It is truncated if the buffer is
319f5dd3d6fSSam Vilain * not large enough.
320f5dd3d6fSSam Vilain *
321f5dd3d6fSSam Vilain * Returns 0 on success.
322f5dd3d6fSSam Vilain */
3238d65af78SAlexey Dobriyanint proc_dostring(struct ctl_table *table, int write,
32432927393SChristoph Hellwig		  void *buffer, size_t *lenp, loff_t *ppos)
325f5dd3d6fSSam Vilain{
326d383d484SLuis R. Rodriguez	if (write)
327d383d484SLuis R. Rodriguez		proc_first_pos_non_zero_ignore(ppos, table);
328f4aacea2SKees Cook
32932927393SChristoph Hellwig	return _proc_do_string(table->data, table->maxlen, write, buffer, lenp,
33032927393SChristoph Hellwig			ppos);
331f5dd3d6fSSam Vilain}
332f5dd3d6fSSam Vilain
33300b7c339SAmerigo Wangstatic size_t proc_skip_spaces(char **buf)
33400b7c339SAmerigo Wang{
33500b7c339SAmerigo Wang	size_t ret;
33600b7c339SAmerigo Wang	char *tmp = skip_spaces(*buf);
33700b7c339SAmerigo Wang	ret = tmp - *buf;
33800b7c339SAmerigo Wang	*buf = tmp;
33900b7c339SAmerigo Wang	return ret;
34000b7c339SAmerigo Wang}
34100b7c339SAmerigo Wang
3429f977fb7SOctavian Purdilastatic void proc_skip_char(char **buf, size_t *size, const char v)
3439f977fb7SOctavian Purdila{
3449f977fb7SOctavian Purdila	while (*size) {
3459f977fb7SOctavian Purdila		if (**buf != v)
3469f977fb7SOctavian Purdila			break;
3479f977fb7SOctavian Purdila		(*size)--;
3489f977fb7SOctavian Purdila		(*buf)++;
3499f977fb7SOctavian Purdila	}
3509f977fb7SOctavian Purdila}
3519f977fb7SOctavian Purdila
3527f2923c4SChristian Brauner/**
3537f2923c4SChristian Brauner * strtoul_lenient - parse an ASCII formatted integer from a buffer and only
3547f2923c4SChristian Brauner *                   fail on overflow
3557f2923c4SChristian Brauner *
3567f2923c4SChristian Brauner * @cp: kernel buffer containing the string to parse
3577f2923c4SChristian Brauner * @endp: pointer to store the trailing characters
3587f2923c4SChristian Brauner * @base: the base to use
3597f2923c4SChristian Brauner * @res: where the parsed integer will be stored
3607f2923c4SChristian Brauner *
3617f2923c4SChristian Brauner * In case of success 0 is returned and @res will contain the parsed integer,
3627f2923c4SChristian Brauner * @endp will hold any trailing characters.
3637f2923c4SChristian Brauner * This function will fail the parse on overflow. If there wasn't an overflow
3647f2923c4SChristian Brauner * the function will defer the decision what characters count as invalid to the
3657f2923c4SChristian Brauner * caller.
3667f2923c4SChristian Brauner */
3677f2923c4SChristian Braunerstatic int strtoul_lenient(const char *cp, char **endp, unsigned int base,
3687f2923c4SChristian Brauner			   unsigned long *res)
3697f2923c4SChristian Brauner{
3707f2923c4SChristian Brauner	unsigned long long result;
371