summaryrefslogtreecommitdiff
path: root/arch/s390/include/asm/preempt.h
blob: b5ea9e14c017aae1966d08871cb7e2a43001849e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __ASM_PREEMPT_H
#define __ASM_PREEMPT_H

#include <asm/current.h>
#include <linux/thread_info.h>
#include <asm/atomic_ops.h>

#ifdef CONFIG_HAVE_MARCH_Z196_FEATURES

/* We use the MSB mostly because its available */
#define PREEMPT_NEED_RESCHED	0x80000000
#define PREEMPT_ENABLED	(0 + PREEMPT_NEED_RESCHED)

static inline int preempt_count(void)
{
	return READ_ONCE(S390_lowcore.preempt_count) & ~PREEMPT_NEED_RESCHED;
}

static inline void preempt_count_set(int pc)
{
	int old, new;

	do {
		old = READ_ONCE(S390_lowcore.preempt_count);
		new = (old & PREEMPT_NEED_RESCHED) |
			(pc & ~PREEMPT_NEED_RESCHED);
	} while (__atomic_cmpxchg(&S390_lowcore.preempt_count,
				  old, new) != old);
}

#define init_task_preempt_count(p)	do { } while (0)

#define init_idle_preempt_count(p, cpu)	do { \
	S390_lowcore.preempt_count = PREEMPT_ENABLED; \
} while (0)

static inline void set_preempt_need_resched(void)
{
	__atomic_and(~PREEMPT_NEED_RESCHED, &S390_lowcore.preempt_count);
}

static inline void clear_preempt_need_resched(void)
{
	__atomic_or(PREEMPT_NEED_RESCHED, &S390_lowcore.preempt_count);
}

static inline bool test_preempt_need_resched(void)
{
	return !(READ_ONCE(S390_lowcore.preempt_count) & PREEMPT_NEED_RESCHED);
}

static inline void __preempt_count_add(int val)
{
	if (__builtin_constant_p(val) && (val >= -128) && (val <= 127))
		__atomic_add_const(val, &S390_lowcore.preempt_count);
	else
		__atomic_add(val, &S390_lowcore.preempt_count);
}

static inline void __preempt_count_sub(int val)
{
	__preempt_count_add(-val);
}

static inline bool __preempt_count_dec_and_test(void)
{
	return __atomic_add(-1, &S390_lowcore.preempt_count) == 1;
}

static inline bool should_resched(int preempt_offset)
{
	return unlikely(READ_ONCE(S390_lowcore.preempt_count) ==
			preempt_offset);
}

#else /* CONFIG_HAVE_MARCH_Z196_FEATURES */

#define PREEMPT_ENABLED	(0)

static inline int preempt_count(void)
{
	return READ_ONCE(S390_lowcore.preempt_count);
}

static inline void preempt_count_set(int pc)
{
	S390_lowcore.preempt_count = pc;
}

#define init_task_preempt_count(p)	do { } while (0)

#define init_idle_preempt_count(p, cpu)	do { \
	S390_lowcore.preempt_count = PREEMPT_ENABLED; \
} while (0)

static inline void set_preempt_need_resched(void)
{
}

static inline void clear_preempt_need_resched(void)
{
}

static inline bool test_preempt_need_resched(void)
{
	return false;
}

static inline void __preempt_count_add(int val)
{
	S390_lowcore.preempt_count += val;
}

static inline void __preempt_count_sub(int val)
{
	S390_lowcore.preempt_count -= val;
}

static inline bool __preempt_count_dec_and_test(void)
{
	return !--S390_lowcore.preempt_count && tif_need_resched();
}

static inline bool should_resched(int preempt_offset)
{
	return unlikely(preempt_count() == preempt_offset &&
			tif_need_resched());
}

#endif /* CONFIG_HAVE_MARCH_Z196_FEATURES */

#ifdef CONFIG_PREEMPT
extern asmlinkage void preempt_schedule(void);
#define __preempt_schedule() preempt_schedule()
extern asmlinkage void preempt_schedule_notrace(void);
#define __preempt_schedule_notrace() preempt_schedule_notrace()
#endif /* CONFIG_PREEMPT */

#endif /* __ASM_PREEMPT_H */