RISC-V: Task implementation

#include <generated/asm-offsets.h>

/*

 * Based on arm/arm64/include/asm/current.h

 *

 * Copyright (C) 2016 ARM

 * Copyright (C) 2017 SiFive

 *

 *   This program is free software; you can redistribute it and/or

 *   modify it under the terms of the GNU General Public License

 *   as published by the Free Software Foundation, version 2.

 *

 *   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.

 */

#ifndef __ASM_CURRENT_H

#define __ASM_CURRENT_H

#include <linux/bug.h>

#include <linux/compiler.h>

#ifndef __ASSEMBLY__

struct task_struct;

/*

 * This only works because "struct thread_info" is at offset 0 from "struct

 * task_struct".  This constraint seems to be necessary on other architectures

 * as well, but __switch_to enforces it.  We can't check TASK_TI here because

 * <asm/asm-offsets.h> includes this, and I can't get the definition of "struct

 * task_struct" here due to some header ordering problems.

 */

static __always_inline struct task_struct *get_current(void)

{

	register struct task_struct *tp __asm__("tp");

	return tp;

}

#define current get_current()

#endif /* __ASSEMBLY__ */

#endif /* __ASM_CURRENT_H */

/*

 * Copied from arch/arm64/include/asm/kprobes.h

 *

 * Copyright (C) 2013 Linaro Limited

 * Copyright (C) 2017 SiFive

 *

 * 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.

 */

#ifndef _RISCV_KPROBES_H

#define _RISCV_KPROBES_H

#include <asm-generic/kprobes.h>

#endif /* _RISCV_KPROBES_H */

/*

 * Copyright (C) 2012 Regents of the University of California

 *

 *   This program is free software; you can redistribute it and/or

 *   modify it under the terms of the GNU General Public License

 *   as published by the Free Software Foundation, version 2.

 *

 *   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.

 */

#ifndef _ASM_RISCV_PROCESSOR_H

#define _ASM_RISCV_PROCESSOR_H

#include <linux/const.h>

#include <asm/ptrace.h>

/*

 * This decides where the kernel will search for a free chunk of vm

 * space during mmap's.

 */

#define TASK_UNMAPPED_BASE	PAGE_ALIGN(TASK_SIZE >> 1)

#define STACK_TOP		TASK_SIZE

#define STACK_TOP_MAX		STACK_TOP

#define STACK_ALIGN		16

#ifndef __ASSEMBLY__

struct task_struct;

struct pt_regs;

/*

 * Default implementation of macro that returns current

 * instruction pointer ("program counter").

 */

#define current_text_addr()	({ __label__ _l; _l: &&_l; })

/* CPU-specific state of a task */

struct thread_struct {

	/* Callee-saved registers */

	unsigned long ra;

	unsigned long sp;	/* Kernel mode stack */

	unsigned long s[12];	/* s[0]: frame pointer */

	struct __riscv_d_ext_state fstate;

};

#define INIT_THREAD {					\

	.sp = sizeof(init_stack) + (long)&init_stack,	\

}

#define task_pt_regs(tsk)						\

	((struct pt_regs *)(task_stack_page(tsk) + THREAD_SIZE		\

			    - ALIGN(sizeof(struct pt_regs), STACK_ALIGN)))

#define KSTK_EIP(tsk)		(task_pt_regs(tsk)->sepc)

#define KSTK_ESP(tsk)		(task_pt_regs(tsk)->sp)

/* Do necessary setup to start up a newly executed thread. */

extern void start_thread(struct pt_regs *regs,

			unsigned long pc, unsigned long sp);

/* Free all resources held by a thread. */

static inline void release_thread(struct task_struct *dead_task)

{

}

extern unsigned long get_wchan(struct task_struct *p);

static inline void cpu_relax(void)

{

#ifdef __riscv_muldiv

	int dummy;

	/* In lieu of a halt instruction, induce a long-latency stall. */

	__asm__ __volatile__ ("div %0, %0, zero" : "=r" (dummy));

#endif

	barrier();

}

static inline void wait_for_interrupt(void)

{

	__asm__ __volatile__ ("wfi");

}

struct device_node;

extern int riscv_of_processor_hart(struct device_node *node);

extern void riscv_fill_hwcap(void);

#endif /* __ASSEMBLY__ */

#endif /* _ASM_RISCV_PROCESSOR_H */

/*

 * Copyright (C) 2012 Regents of the University of California

 *

 *   This program is free software; you can redistribute it and/or

 *   modify it under the terms of the GNU General Public License

 *   as published by the Free Software Foundation, version 2.

 *

 *   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.

 */

#ifndef _ASM_RISCV_SWITCH_TO_H

#define _ASM_RISCV_SWITCH_TO_H

#include <asm/processor.h>

#include <asm/ptrace.h>

#include <asm/csr.h>

extern void __fstate_save(struct task_struct *save_to);

extern void __fstate_restore(struct task_struct *restore_from);

static inline void __fstate_clean(struct pt_regs *regs)

{

	regs->sstatus |= (regs->sstatus & ~(SR_FS)) | SR_FS_CLEAN;

}

static inline void fstate_save(struct task_struct *task,

			       struct pt_regs *regs)

{

	if ((regs->sstatus & SR_FS) == SR_FS_DIRTY) {

		__fstate_save(task);

		__fstate_clean(regs);

	}

}

static inline void fstate_restore(struct task_struct *task,

				  struct pt_regs *regs)

{

	if ((regs->sstatus & SR_FS) != SR_FS_OFF) {

		__fstate_restore(task);

		__fstate_clean(regs);

	}

}

static inline void __switch_to_aux(struct task_struct *prev,

				   struct task_struct *next)

{

	struct pt_regs *regs;

	regs = task_pt_regs(prev);

	if (unlikely(regs->sstatus & SR_SD))

		fstate_save(prev, regs);

	fstate_restore(next, task_pt_regs(next));

}

extern struct task_struct *__switch_to(struct task_struct *,

				       struct task_struct *);

#define switch_to(prev, next, last)			\

do {							\

	struct task_struct *__prev = (prev);		\

	struct task_struct *__next = (next);		\

	__switch_to_aux(__prev, __next);		\

	((last) = __switch_to(__prev, __next));		\

} while (0)

#endif /* _ASM_RISCV_SWITCH_TO_H */