Set VM_KMEM_SIZE_SCALE to 1 on riscv and arm64
ClosedPublic
Actions

Authored by markj on Jan 18 2021, 6:47 PM.

Details

Reviewers

manu
kib
alc
kp

Group Reviewers

riscv
arm64

Commits

rG3e3eb5f45f33: arm64, riscv: Set VM_KMEM_SIZE_SCALE to 1

Summary

This parameter limits the amount of memory that can be allocated to UMA.
On systems with a direct map and ample KVA, however, I can't see a
reason for VM_KMEM_SIZE_SCALE to be larger than 1. I believe it was
copied from 32-bit ARM to arm64 and from there to riscv.

Diff Detail

Repository

rS FreeBSD src repository - subversion

Lint

Lint Passed

Unit

No Test Coverage

Build Status

Buildable 36323
Build 33212: arc lint + arc unit

Event Timeline

markj created this revision.Jan 18 2021, 6:47 PM

Herald added a reviewer: manu. · View Herald TranscriptJan 18 2021, 6:47 PM

Herald added subscribers: emaste, andrew, imp. · View Herald Transcript

markj requested review of this revision.Jan 18 2021, 6:47 PM

Harbormaster completed remote builds in B36323: Diff 82494.Jan 18 2021, 6:47 PM

markj added reviewers: kib, alc, riscv, arm64.Jan 18 2021, 6:48 PM

kib accepted this revision.Jan 18 2021, 7:02 PM

This revision is now accepted and ready to land.Jan 18 2021, 7:02 PM

kp accepted this revision as: kp.Jan 18 2021, 10:10 PM

Similarly, there is no reason to define VM_KMEM_SIZE_MIN.

Remove VM_KMEM_SIZE_MIN as well.

This revision now requires review to proceed.Jan 19 2021, 12:35 AM

Harbormaster completed remote builds in B36327: Diff 82513.Jan 19 2021, 12:35 AM

alc accepted this revision.Jan 19 2021, 6:54 AM

This revision is now accepted and ready to land.Jan 19 2021, 6:54 AM

kib accepted this revision.Jan 19 2021, 8:18 AM

Closed by commit rG3e3eb5f45f33: arm64, riscv: Set VM_KMEM_SIZE_SCALE to 1 (authored by markj). · Explain WhyJan 20 2021, 1:38 AM

This revision was automatically updated to reflect the committed changes.

markj added a commit: rG3e3eb5f45f33: arm64, riscv: Set VM_KMEM_SIZE_SCALE to 1.

Revision Contents
Changeset List

Path

Size

sys/

arm64/

include/

vmparam.h

2 lines

riscv/

include/

vmparam.h

2 lines

Diff 82494

View Options

sys/arm64/include/vmparam.h

	Show All 38 Lines
	#include <sys/stddef.h>			#include <sys/stddef.h>
	#include <sys/syslog.h>			#include <sys/syslog.h>
	#include <sys/time.h>			#include <sys/time.h>

	#include <linux/bitops.h>			#include <linux/bitops.h>
	#include <linux/build_bug.h>			#include <linux/build_bug.h>
	#include <linux/compiler.h>			#include <linux/compiler.h>
	#include <linux/container_of.h>			#include <linux/container_of.h>
				#include <linux/kstrtox.h>
	#include <linux/limits.h>			#include <linux/limits.h>
	#include <linux/math.h>			#include <linux/math.h>
	#include <linux/minmax.h>			#include <linux/minmax.h>
	#include <linux/stringify.h>			#include <linux/stringify.h>
	#include <linux/errno.h>			#include <linux/errno.h>
	#include <linux/sched.h>			#include <linux/sched.h>
	#include <linux/types.h>			#include <linux/types.h>
	#include <linux/typecheck.h>			#include <linux/typecheck.h>
	▲ Show 20 Lines • Show All 208 Lines • ▼ Show 20 Lines
	})			})
	#endif			#endif

	#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))			#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

	#define u64_to_user_ptr(val) ((void *)(uintptr_t)(val))			#define u64_to_user_ptr(val) ((void *)(uintptr_t)(val))

	#define _RET_IP_ __builtin_return_address(0)			#define _RET_IP_ __builtin_return_address(0)

	static inline unsigned long long
	simple_strtoull(const char cp, char *endp, unsigned int base)
	{
	return (strtouq(cp, endp, base));
	}

	static inline long long
	simple_strtoll(const char cp, char *endp, unsigned int base)
	{
	return (strtoq(cp, endp, base));
	}

	static inline unsigned long
	simple_strtoul(const char cp, char *endp, unsigned int base)
	{
	return (strtoul(cp, endp, base));
	}

	static inline long
	simple_strtol(const char cp, char *endp, unsigned int base)
	{
	return (strtol(cp, endp, base));
	}

	static inline int
	kstrtoul(const char cp, unsigned int base, unsigned long res)
	{
	char *end;

	*res = strtoul(cp, &end, base);

	/* skip newline character, if any */
	if (*end == '\n')
	end++;
	if (cp == 0 \|\| end != 0)
	return (-EINVAL);
	return (0);
	}

	static inline int
	kstrtol(const char cp, unsigned int base, long res)
	{
	char *end;

	*res = strtol(cp, &end, base);

	/* skip newline character, if any */
	if (*end == '\n')
	end++;
	if (cp == 0 \|\| end != 0)
	return (-EINVAL);
	return (0);
	}

	static inline int
	kstrtoint(const char cp, unsigned int base, int res)
	{
	char *end;
	long temp;

	*res = temp = strtol(cp, &end, base);

	/* skip newline character, if any */
	if (*end == '\n')
	end++;
	if (cp == 0 \|\| end != 0)
	return (-EINVAL);
	if (temp != (int)temp)
	return (-ERANGE);
	return (0);
	}

	static inline int
	kstrtouint(const char cp, unsigned int base, unsigned int res)
	{
	char *end;
	unsigned long temp;

	*res = temp = strtoul(cp, &end, base);

	/* skip newline character, if any */
	if (*end == '\n')
	end++;
	if (cp == 0 \|\| end != 0)
	return (-EINVAL);
	if (temp != (unsigned int)temp)
	return (-ERANGE);
	return (0);
	}

	static inline int
	kstrtou8(const char cp, unsigned int base, u8 res)
	{
	char *end;
	unsigned long temp;

	*res = temp = strtoul(cp, &end, base);

	/* skip newline character, if any */
	if (*end == '\n')
	end++;
	if (cp == 0 \|\| end != 0)
	return (-EINVAL);
	if (temp != (u8)temp)
	return (-ERANGE);
	return (0);
	}

	static inline int
	kstrtou16(const char cp, unsigned int base, u16 res)
	{
	char *end;
	unsigned long temp;

	*res = temp = strtoul(cp, &end, base);

	/* skip newline character, if any */
	if (*end == '\n')
	end++;
	if (cp == 0 \|\| end != 0)
	return (-EINVAL);
	if (temp != (u16)temp)
	return (-ERANGE);
	return (0);
	}

	static inline int
	kstrtou32(const char cp, unsigned int base, u32 res)
	{

	return (kstrtouint(cp, base, res));
	}

	static inline int
	kstrtou64(const char cp, unsigned int base, u64 res)
	{
	char *end;

	*res = strtouq(cp, &end, base);

	/* skip newline character, if any */
	if (*end == '\n')
	end++;
	if (cp == 0 \|\| end != 0)
	return (-EINVAL);
	return (0);
	}

	static inline int
	kstrtoull(const char cp, unsigned int base, unsigned long long res)
	{
	return (kstrtou64(cp, base, (u64 *)res));
	}

	static inline int
	kstrtobool(const char s, bool res)
	{
	int len;

	if (s == NULL \|\| (len = strlen(s)) == 0 \|\| res == NULL)
	return (-EINVAL);

	/* skip newline character, if any */
	if (s[len - 1] == '\n')
	len--;

	if (len == 1 && strchr("yY1", s[0]) != NULL)
	*res = true;
	else if (len == 1 && strchr("nN0", s[0]) != NULL)
	*res = false;
	else if (strncasecmp("on", s, len) == 0)
	*res = true;
	else if (strncasecmp("off", s, len) == 0)
	*res = false;
	else
	return (-EINVAL);

	return (0);
	}

	static inline int
	kstrtobool_from_user(const char __user s, size_t count, bool res)
	{
	char buf[8] = {};

	if (count > (sizeof(buf) - 1))
	count = (sizeof(buf) - 1);

	if (copy_from_user(buf, s, count))
	return (-EFAULT);

	return (kstrtobool(buf, res));
	}

	static inline int
	kstrtoint_from_user(const char __user *s, size_t count, unsigned int base,
	int *p)
	{
	char buf[36] = {};

	if (count > (sizeof(buf) - 1))
	count = (sizeof(buf) - 1);

	if (copy_from_user(buf, s, count))
	return (-EFAULT);

	return (kstrtoint(buf, base, p));
	}

	static inline int
	kstrtouint_from_user(const char __user *s, size_t count, unsigned int base,
	unsigned int *p)
	{
	char buf[36] = {};

	if (count > (sizeof(buf) - 1))
	count = (sizeof(buf) - 1);

	if (copy_from_user(buf, s, count))
	return (-EFAULT);

	return (kstrtouint(buf, base, p));
	}

	static inline int
	kstrtou32_from_user(const char __user *s, size_t count, unsigned int base,
	unsigned int *p)
	{

	return (kstrtouint_from_user(s, count, base, p));
	}

	static inline int
	kstrtou8_from_user(const char __user *s, size_t count, unsigned int base,
	u8 *p)
	{
	char buf[8] = {};

	if (count > (sizeof(buf) - 1))
	count = (sizeof(buf) - 1);

	if (copy_from_user(buf, s, count))
	return (-EFAULT);

	return (kstrtou8(buf, base, p));
	}

	#define offsetofend(t, m) \			#define offsetofend(t, m) \
	(offsetof(t, m) + sizeof((((t *)0)->m)))			(offsetof(t, m) + sizeof((((t *)0)->m)))

	#define smp_processor_id() PCPU_GET(cpuid)			#define smp_processor_id() PCPU_GET(cpuid)
	#define num_possible_cpus() mp_ncpus			#define num_possible_cpus() mp_ncpus
	#define num_online_cpus() mp_ncpus			#define num_online_cpus() mp_ncpus

	▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines