Page MenuHomeFreeBSD
Differential D22056

Port D22041/r353622 to sparc64 and arm v4.
ClosedPublic
Actions

Authored by kib on Oct 16 2019, 12:24 PM.
Tags
None
Referenced Files
Unknown Object (File)
Feb 25 2025, 9:40 PM
Unknown Object (File)
Feb 22 2025, 2:26 PM
Unknown Object (File)
Feb 22 2025, 2:08 PM
Unknown Object (File)
Feb 22 2025, 1:49 PM
Unknown Object (File)
Feb 22 2025, 1:48 PM
Unknown Object (File)
Feb 22 2025, 1:48 PM
Unknown Object (File)
Feb 18 2025, 2:54 PM
Unknown Object (File)
Jan 21 2025, 1:28 PM
View All 56 Files
Subscribers
andrew
imp

Details

Reviewers
alc
markj
jeff
Commits
rS353664: Port r353622 to sparc64 and arm v4.

Diff Detail

Repository
rS FreeBSD src repository - subversion
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

kib created this revision.Oct 16 2019, 12:24 PM
Herald added a subscriber: imp. · View Herald TranscriptOct 16 2019, 12:24 PM
Harbormaster completed remote builds in B27067: Diff 63355.Oct 16 2019, 12:24 PM
markj accepted this revision.Oct 16 2019, 3:44 PM
This revision is now accepted and ready to land.Oct 16 2019, 3:44 PM
alc accepted this revision.Oct 16 2019, 6:38 PM
jeff accepted this revision.Oct 16 2019, 6:39 PM

Thank you.

alc added a comment.Oct 16 2019, 6:43 PM

I believe that arm/arm/pmap-v4.c also needs this fix.

jeff added a comment.Oct 16 2019, 6:59 PM

I can do arm this afternoon.

kib updated this revision to Diff 63377.Oct 16 2019, 7:03 PM

Handle arm v4.

This revision now requires review to proceed.Oct 16 2019, 7:03 PM
Herald added a subscriber: andrew. · View Herald TranscriptOct 16 2019, 7:03 PM
Harbormaster completed remote builds in B27075: Diff 63377.Oct 16 2019, 7:03 PM
kib retitled this revision from Port D22041/r353622 to sparc64. to Port D22041/r353622 to sparc64 and arm v4..Oct 16 2019, 7:03 PM
markj accepted this revision.Oct 16 2019, 7:40 PM
This revision is now accepted and ready to land.Oct 16 2019, 7:40 PM
Closed by commit rS353664: Port r353622 to sparc64 and arm v4. (authored by kib). · Explain WhyOct 16 2019, 9:07 PM
This revision was automatically updated to reflect the committed changes.
kib added a commit: rS353664: Port r353622 to sparc64 and arm v4..

Revision Contents
Changeset List

PathSize
head/
sys/
arm/
arm/
13 lines
include/
2 lines
sparc64/
include/
1 line
sparc64/
13 lines

Diff 63380

View Options

head/sys/arm/arm/pmap-v4.c

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
View Options

head/sys/arm/include/pmap.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
View Options

head/sys/sparc64/include/pmap.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
View Options

head/sys/sparc64/sparc64/pmap.c

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