mirror of
https://github.com/torvalds/linux.git
synced 2025-08-15 06:01:56 +02:00
adf53771a3
When building with CONFIG_FORTIFY_SOURCE=y and W=1, there is a warning
because of the memcpy() in syscall_get_arguments():
In file included from include/linux/string.h:392,
from include/linux/bitmap.h:13,
from include/linux/cpumask.h:12,
from arch/riscv/include/asm/processor.h:55,
from include/linux/sched.h:13,
from kernel/ptrace.c:13:
In function 'fortify_memcpy_chk',
inlined from 'syscall_get_arguments.isra' at arch/riscv/include/asm/syscall.h:66:2:
include/linux/fortify-string.h:580:25: error: call to '__read_overflow2_field' declared with attribute warning: detected read beyond size of field (2nd parameter); maybe use struct_group()? [-Werror=attribute-warning]
580 | __read_overflow2_field(q_size_field, size);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
cc1: all warnings being treated as errors
The fortified memcpy() routine enforces that the source is not overread
and the destination is not overwritten if the size of either field and
the size of the copy are known at compile time. The memcpy() in
syscall_get_arguments() intentionally overreads from a1 to a5 in
'struct pt_regs' but this is bigger than the size of a1.
Normally, this could be solved by wrapping a1 through a5 with
struct_group() but there was already a struct_group() applied to these
members in commit bba547810c ("riscv: tracing: Fix
__write_overflow_field in ftrace_partial_regs()").
Just avoid memcpy() altogether and write the copying of args from regs
manually, which clears up the warning at the expense of three extra
lines of code.
Signed-off-by: Nathan Chancellor <nathan@kernel.org>
Reviewed-by: Dmitry V. Levin <ldv@strace.io>
Fixes: e2c0cdfba7 ("RISC-V: User-facing API")
Cc: stable@vger.kernel.org
Link: https://lore.kernel.org/r/20250409-riscv-avoid-fortify-warning-syscall_get_arguments-v1-1-7853436d4755@kernel.org
Signed-off-by: Palmer Dabbelt <palmer@rivosinc.com>
105 lines
2.5 KiB
C
105 lines
2.5 KiB
C
/* SPDX-License-Identifier: GPL-2.0-only */
|
|
/*
|
|
* Copyright (C) 2008-2009 Red Hat, Inc. All rights reserved.
|
|
* Copyright 2010 Tilera Corporation. All Rights Reserved.
|
|
* Copyright 2015 Regents of the University of California, Berkeley
|
|
*
|
|
* See asm-generic/syscall.h for descriptions of what we must do here.
|
|
*/
|
|
|
|
#ifndef _ASM_RISCV_SYSCALL_H
|
|
#define _ASM_RISCV_SYSCALL_H
|
|
|
|
#include <asm/hwprobe.h>
|
|
#include <uapi/linux/audit.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/err.h>
|
|
|
|
/* The array of function pointers for syscalls. */
|
|
extern void * const sys_call_table[];
|
|
extern void * const compat_sys_call_table[];
|
|
|
|
/*
|
|
* Only the low 32 bits of orig_r0 are meaningful, so we return int.
|
|
* This importantly ignores the high bits on 64-bit, so comparisons
|
|
* sign-extend the low 32 bits.
|
|
*/
|
|
static inline int syscall_get_nr(struct task_struct *task,
|
|
struct pt_regs *regs)
|
|
{
|
|
return regs->a7;
|
|
}
|
|
|
|
static inline void syscall_rollback(struct task_struct *task,
|
|
struct pt_regs *regs)
|
|
{
|
|
regs->a0 = regs->orig_a0;
|
|
}
|
|
|
|
static inline long syscall_get_error(struct task_struct *task,
|
|
struct pt_regs *regs)
|
|
{
|
|
unsigned long error = regs->a0;
|
|
|
|
return IS_ERR_VALUE(error) ? error : 0;
|
|
}
|
|
|
|
static inline long syscall_get_return_value(struct task_struct *task,
|
|
struct pt_regs *regs)
|
|
{
|
|
return regs->a0;
|
|
}
|
|
|
|
static inline void syscall_set_return_value(struct task_struct *task,
|
|
struct pt_regs *regs,
|
|
int error, long val)
|
|
{
|
|
regs->a0 = (long) error ?: val;
|
|
}
|
|
|
|
static inline void syscall_get_arguments(struct task_struct *task,
|
|
struct pt_regs *regs,
|
|
unsigned long *args)
|
|
{
|
|
args[0] = regs->orig_a0;
|
|
args[1] = regs->a1;
|
|
args[2] = regs->a2;
|
|
args[3] = regs->a3;
|
|
args[4] = regs->a4;
|
|
args[5] = regs->a5;
|
|
}
|
|
|
|
static inline int syscall_get_arch(struct task_struct *task)
|
|
{
|
|
#ifdef CONFIG_64BIT
|
|
return AUDIT_ARCH_RISCV64;
|
|
#else
|
|
return AUDIT_ARCH_RISCV32;
|
|
#endif
|
|
}
|
|
|
|
typedef long (*syscall_t)(const struct pt_regs *);
|
|
static inline void syscall_handler(struct pt_regs *regs, ulong syscall)
|
|
{
|
|
syscall_t fn;
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
if ((regs->status & SR_UXL) == SR_UXL_32)
|
|
fn = compat_sys_call_table[syscall];
|
|
else
|
|
#endif
|
|
fn = sys_call_table[syscall];
|
|
|
|
regs->a0 = fn(regs);
|
|
}
|
|
|
|
static inline bool arch_syscall_is_vdso_sigreturn(struct pt_regs *regs)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
asmlinkage long sys_riscv_flush_icache(uintptr_t, uintptr_t, uintptr_t);
|
|
|
|
asmlinkage long sys_riscv_hwprobe(struct riscv_hwprobe *, size_t, size_t,
|
|
unsigned long *, unsigned int);
|
|
#endif /* _ASM_RISCV_SYSCALL_H */
|