mirror of
https://github.com/torvalds/linux.git
synced 2024-12-30 14:52:05 +00:00
7b22c03536
In ftrace_syscall_enter(),
syscall_get_arguments(..., 0, n, ...)
if (i == 0) { <handle orig_x0> ...; n--;}
memcpy(..., n * sizeof(args[0]));
If 'number of arguments(n)' is zero and 'argument index(i)' is also zero in
syscall_get_arguments(), none of arguments should be copied by memcpy().
Otherwise 'n--' can be a big positive number and unexpected amount of data
will be copied. Tracing system calls which take no argument, say sync(void),
may hit this case and eventually make the system corrupted.
This patch fixes the issue both in syscall_get_arguments() and
syscall_set_arguments().
Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
Acked-by: Will Deacon <will.deacon@arm.com>
Signed-off-by: Catalin Marinas <catalin.marinas@arm.com>
108 lines
2.5 KiB
C
108 lines
2.5 KiB
C
/*
|
|
* Copyright (C) 2012 ARM Ltd.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#ifndef __ASM_SYSCALL_H
|
|
#define __ASM_SYSCALL_H
|
|
|
|
#include <linux/err.h>
|
|
|
|
|
|
static inline int syscall_get_nr(struct task_struct *task,
|
|
struct pt_regs *regs)
|
|
{
|
|
return regs->syscallno;
|
|
}
|
|
|
|
static inline void syscall_rollback(struct task_struct *task,
|
|
struct pt_regs *regs)
|
|
{
|
|
regs->regs[0] = regs->orig_x0;
|
|
}
|
|
|
|
|
|
static inline long syscall_get_error(struct task_struct *task,
|
|
struct pt_regs *regs)
|
|
{
|
|
unsigned long error = regs->regs[0];
|
|
return IS_ERR_VALUE(error) ? error : 0;
|
|
}
|
|
|
|
static inline long syscall_get_return_value(struct task_struct *task,
|
|
struct pt_regs *regs)
|
|
{
|
|
return regs->regs[0];
|
|
}
|
|
|
|
static inline void syscall_set_return_value(struct task_struct *task,
|
|
struct pt_regs *regs,
|
|
int error, long val)
|
|
{
|
|
regs->regs[0] = (long) error ? error : val;
|
|
}
|
|
|
|
#define SYSCALL_MAX_ARGS 6
|
|
|
|
static inline void syscall_get_arguments(struct task_struct *task,
|
|
struct pt_regs *regs,
|
|
unsigned int i, unsigned int n,
|
|
unsigned long *args)
|
|
{
|
|
if (n == 0)
|
|
return;
|
|
|
|
if (i + n > SYSCALL_MAX_ARGS) {
|
|
unsigned long *args_bad = args + SYSCALL_MAX_ARGS - i;
|
|
unsigned int n_bad = n + i - SYSCALL_MAX_ARGS;
|
|
pr_warning("%s called with max args %d, handling only %d\n",
|
|
__func__, i + n, SYSCALL_MAX_ARGS);
|
|
memset(args_bad, 0, n_bad * sizeof(args[0]));
|
|
}
|
|
|
|
if (i == 0) {
|
|
args[0] = regs->orig_x0;
|
|
args++;
|
|
i++;
|
|
n--;
|
|
}
|
|
|
|
memcpy(args, ®s->regs[i], n * sizeof(args[0]));
|
|
}
|
|
|
|
static inline void syscall_set_arguments(struct task_struct *task,
|
|
struct pt_regs *regs,
|
|
unsigned int i, unsigned int n,
|
|
const unsigned long *args)
|
|
{
|
|
if (n == 0)
|
|
return;
|
|
|
|
if (i + n > SYSCALL_MAX_ARGS) {
|
|
pr_warning("%s called with max args %d, handling only %d\n",
|
|
__func__, i + n, SYSCALL_MAX_ARGS);
|
|
n = SYSCALL_MAX_ARGS - i;
|
|
}
|
|
|
|
if (i == 0) {
|
|
regs->orig_x0 = args[0];
|
|
args++;
|
|
i++;
|
|
n--;
|
|
}
|
|
|
|
memcpy(®s->regs[i], args, n * sizeof(args[0]));
|
|
}
|
|
|
|
#endif /* __ASM_SYSCALL_H */
|