write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/lib/atomic64.c
..
..
@@ -1,13 +1,9 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
1
2
 /*
2
3
  * Generic implementation of 64-bit atomics using spinlocks,
3
4
  * useful on processors that don't have 64-bit atomic instructions.
4
5
  *
5
6
  * Copyright © 2009 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
6
- *
7
- * This program is free software; you can redistribute it and/or
8
- * modify it under the terms of the GNU General Public License
9
- * as published by the Free Software Foundation; either version
10
- * 2 of the License, or (at your option) any later version.
11
7
  */
12
8
 #include <linux/types.h>
13
9
 #include <linux/cache.h>
..
..
@@ -46,11 +42,11 @@
46
42
 	return &atomic64_lock[addr & (NR_LOCKS - 1)].lock;
47
43
 }
48
44
 
49
-long long atomic64_read(const atomic64_t *v)
45
+s64 atomic64_read(const atomic64_t *v)
50
46
 {
51
47
 	unsigned long flags;
52
48
 	raw_spinlock_t *lock = lock_addr(v);
53
-	long long val;
49
+	s64 val;
54
50
 
55
51
 	raw_spin_lock_irqsave(lock, flags);
56
52
 	val = v->counter;
..
..
@@ -59,7 +55,7 @@
59
55
 }
60
56
 EXPORT_SYMBOL(atomic64_read);
61
57
 
62
-void atomic64_set(atomic64_t *v, long long i)
58
+void atomic64_set(atomic64_t *v, s64 i)
63
59
 {
64
60
 	unsigned long flags;
65
61
 	raw_spinlock_t *lock = lock_addr(v);
..
..
@@ -71,7 +67,7 @@
71
67
 EXPORT_SYMBOL(atomic64_set);
72
68
 
73
69
 #define ATOMIC64_OP(op, c_op)						\
74
-void atomic64_##op(long long a, atomic64_t *v)				\
70
+void atomic64_##op(s64 a, atomic64_t *v)				\
75
71
 {									\
76
72
 	unsigned long flags;						\
77
73
 	raw_spinlock_t *lock = lock_addr(v);				\
..
..
@@ -83,11 +79,11 @@
83
79
 EXPORT_SYMBOL(atomic64_##op);
84
80
 
85
81
 #define ATOMIC64_OP_RETURN(op, c_op)					\
86
-long long atomic64_##op##_return(long long a, atomic64_t *v)		\
82
+s64 atomic64_##op##_return(s64 a, atomic64_t *v)			\
87
83
 {									\
88
84
 	unsigned long flags;						\
89
85
 	raw_spinlock_t *lock = lock_addr(v);				\
90
-	long long val;							\
86
+	s64 val;							\
91
87
 									\
92
88
 	raw_spin_lock_irqsave(lock, flags);				\
93
89
 	val = (v->counter c_op a);					\
..
..
@@ -97,11 +93,11 @@
97
93
 EXPORT_SYMBOL(atomic64_##op##_return);
98
94
 
99
95
 #define ATOMIC64_FETCH_OP(op, c_op)					\
100
-long long atomic64_fetch_##op(long long a, atomic64_t *v)		\
96
+s64 atomic64_fetch_##op(s64 a, atomic64_t *v)				\
101
97
 {									\
102
98
 	unsigned long flags;						\
103
99
 	raw_spinlock_t *lock = lock_addr(v);				\
104
-	long long val;							\
100
+	s64 val;							\
105
101
 									\
106
102
 	raw_spin_lock_irqsave(lock, flags);				\
107
103
 	val = v->counter;						\
..
..
@@ -134,11 +130,11 @@
134
130
 #undef ATOMIC64_OP_RETURN
135
131
 #undef ATOMIC64_OP
136
132
 
137
-long long atomic64_dec_if_positive(atomic64_t *v)
133
+s64 atomic64_dec_if_positive(atomic64_t *v)
138
134
 {
139
135
 	unsigned long flags;
140
136
 	raw_spinlock_t *lock = lock_addr(v);
141
-	long long val;
137
+	s64 val;
142
138
 
143
139
 	raw_spin_lock_irqsave(lock, flags);
144
140
 	val = v->counter - 1;
..
..
@@ -149,11 +145,11 @@
149
145
 }
150
146
 EXPORT_SYMBOL(atomic64_dec_if_positive);
151
147
 
152
-long long atomic64_cmpxchg(atomic64_t *v, long long o, long long n)
148
+s64 atomic64_cmpxchg(atomic64_t *v, s64 o, s64 n)
153
149
 {
154
150
 	unsigned long flags;
155
151
 	raw_spinlock_t *lock = lock_addr(v);
156
-	long long val;
152
+	s64 val;
157
153
 
158
154
 	raw_spin_lock_irqsave(lock, flags);
159
155
 	val = v->counter;
..
..
@@ -164,11 +160,11 @@
164
160
 }
165
161
 EXPORT_SYMBOL(atomic64_cmpxchg);
166
162
 
167
-long long atomic64_xchg(atomic64_t *v, long long new)
163
+s64 atomic64_xchg(atomic64_t *v, s64 new)
168
164
 {
169
165
 	unsigned long flags;
170
166
 	raw_spinlock_t *lock = lock_addr(v);
171
-	long long val;
167
+	s64 val;
172
168
 
173
169
 	raw_spin_lock_irqsave(lock, flags);
174
170
 	val = v->counter;
..
..
@@ -178,11 +174,11 @@
178
174
 }
179
175
 EXPORT_SYMBOL(atomic64_xchg);
180
176
 
181
-long long atomic64_fetch_add_unless(atomic64_t *v, long long a, long long u)
177
+s64 atomic64_fetch_add_unless(atomic64_t *v, s64 a, s64 u)
182
178
 {
183
179
 	unsigned long flags;
184
180
 	raw_spinlock_t *lock = lock_addr(v);
185
-	long long val;
181
+	s64 val;
186
182
 
187
183
 	raw_spin_lock_irqsave(lock, flags);
188
184
 	val = v->counter;