Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
locking/spinlocks: Mark spinlocks noinline when inline spinlocks are disabled
Otherwise LTO will inline them anyways and cause a large kernel text increase.
Since the explicit intention here is to not inline them marking them noinline
is good documentation even for the non-LTO case.
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Signed-off-by: Martin Liska <mliska@suse.cz>
Signed-off-by: Jiri Slaby <jslaby@suse.cz>
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Link: https://lore.kernel.org/r/20220719110548.1544-1-jslaby@suse.cz
authored by
Andi Kleen
and committed by
Ingo Molnar
9aeaf5bc
d171011e
+28
-28
+28
-28
kernel/locking/spinlock.c
+28
-28
kernel/locking/spinlock.c
···
133
133
#endif
134
134
135
135
#ifndef CONFIG_INLINE_SPIN_TRYLOCK
136
-
int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock)
136
+
noinline int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock)
137
137
{
138
138
return __raw_spin_trylock(lock);
139
139
}
···
141
141
#endif
142
142
143
143
#ifndef CONFIG_INLINE_SPIN_TRYLOCK_BH
144
-
int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock)
144
+
noinline int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock)
145
145
{
146
146
return __raw_spin_trylock_bh(lock);
147
147
}
···
149
149
#endif
150
150
151
151
#ifndef CONFIG_INLINE_SPIN_LOCK
152
-
void __lockfunc _raw_spin_lock(raw_spinlock_t *lock)
152
+
noinline void __lockfunc _raw_spin_lock(raw_spinlock_t *lock)
153
153
{
154
154
__raw_spin_lock(lock);
155
155
}
···
157
157
#endif
158
158
159
159
#ifndef CONFIG_INLINE_SPIN_LOCK_IRQSAVE
160
-
unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock)
160
+
noinline unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock)
161
161
{
162
162
return __raw_spin_lock_irqsave(lock);
163
163
}
···
165
165
#endif
166
166
167
167
#ifndef CONFIG_INLINE_SPIN_LOCK_IRQ
168
-
void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock)
168
+
noinline void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock)
169
169
{
170
170
__raw_spin_lock_irq(lock);
171
171
}
···
173
173
#endif
174
174
175
175
#ifndef CONFIG_INLINE_SPIN_LOCK_BH
176
-
void __lockfunc _raw_spin_lock_bh(raw_spinlock_t *lock)
176
+
noinline void __lockfunc _raw_spin_lock_bh(raw_spinlock_t *lock)
177
177
{
178
178
__raw_spin_lock_bh(lock);
179
179
}
···
181
181
#endif
182
182
183
183
#ifdef CONFIG_UNINLINE_SPIN_UNLOCK
184
-
void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock)
184
+
noinline void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock)
185
185
{
186
186
__raw_spin_unlock(lock);
187
187
}
···
189
189
#endif
190
190
191
191
#ifndef CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE
192
-
void __lockfunc _raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)
192
+
noinline void __lockfunc _raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)
193
193
{
194
194
__raw_spin_unlock_irqrestore(lock, flags);
195
195
}
···
197
197
#endif
198
198
199
199
#ifndef CONFIG_INLINE_SPIN_UNLOCK_IRQ
200
-
void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock)
200
+
noinline void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock)
201
201
{
202
202
__raw_spin_unlock_irq(lock);
203
203
}
···
205
205
#endif
206
206
207
207
#ifndef CONFIG_INLINE_SPIN_UNLOCK_BH
208
-
void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock)
208
+
noinline void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock)
209
209
{
210
210
__raw_spin_unlock_bh(lock);
211
211
}
···
215
215
#ifndef CONFIG_PREEMPT_RT
216
216
217
217
#ifndef CONFIG_INLINE_READ_TRYLOCK
218
-
int __lockfunc _raw_read_trylock(rwlock_t *lock)
218
+
noinline int __lockfunc _raw_read_trylock(rwlock_t *lock)
219
219
{
220
220
return __raw_read_trylock(lock);
221
221
}
···
223
223
#endif
224
224
225
225
#ifndef CONFIG_INLINE_READ_LOCK
226
-
void __lockfunc _raw_read_lock(rwlock_t *lock)
226
+
noinline void __lockfunc _raw_read_lock(rwlock_t *lock)
227
227
{
228
228
__raw_read_lock(lock);
229
229
}
···
231
231
#endif
232
232
233
233
#ifndef CONFIG_INLINE_READ_LOCK_IRQSAVE
234
-
unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock)
234
+
noinline unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock)
235
235
{
236
236
return __raw_read_lock_irqsave(lock);
237
237
}
···
239
239
#endif
240
240
241
241
#ifndef CONFIG_INLINE_READ_LOCK_IRQ
242
-
void __lockfunc _raw_read_lock_irq(rwlock_t *lock)
242
+
noinline void __lockfunc _raw_read_lock_irq(rwlock_t *lock)
243
243
{
244
244
__raw_read_lock_irq(lock);
245
245
}
···
247
247
#endif
248
248
249
249
#ifndef CONFIG_INLINE_READ_LOCK_BH
250
-
void __lockfunc _raw_read_lock_bh(rwlock_t *lock)
250
+
noinline void __lockfunc _raw_read_lock_bh(rwlock_t *lock)
251
251
{
252
252
__raw_read_lock_bh(lock);
253
253
}
···
255
255
#endif
256
256
257
257
#ifndef CONFIG_INLINE_READ_UNLOCK
258
-
void __lockfunc _raw_read_unlock(rwlock_t *lock)
258
+
noinline void __lockfunc _raw_read_unlock(rwlock_t *lock)
259
259
{
260
260
__raw_read_unlock(lock);
261
261
}
···
263
263
#endif
264
264
265
265
#ifndef CONFIG_INLINE_READ_UNLOCK_IRQRESTORE
266
-
void __lockfunc _raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
266
+
noinline void __lockfunc _raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
267
267
{
268
268
__raw_read_unlock_irqrestore(lock, flags);
269
269
}
···
271
271
#endif
272
272
273
273
#ifndef CONFIG_INLINE_READ_UNLOCK_IRQ
274
-
void __lockfunc _raw_read_unlock_irq(rwlock_t *lock)
274
+
noinline void __lockfunc _raw_read_unlock_irq(rwlock_t *lock)
275
275
{
276
276
__raw_read_unlock_irq(lock);
277
277
}
···
279
279
#endif
280
280
281
281
#ifndef CONFIG_INLINE_READ_UNLOCK_BH
282
-
void __lockfunc _raw_read_unlock_bh(rwlock_t *lock)
282
+
noinline void __lockfunc _raw_read_unlock_bh(rwlock_t *lock)
283
283
{
284
284
__raw_read_unlock_bh(lock);
285
285
}
···
287
287
#endif
288
288
289
289
#ifndef CONFIG_INLINE_WRITE_TRYLOCK
290
-
int __lockfunc _raw_write_trylock(rwlock_t *lock)
290
+
noinline int __lockfunc _raw_write_trylock(rwlock_t *lock)
291
291
{
292
292
return __raw_write_trylock(lock);
293
293
}
···
295
295
#endif
296
296
297
297
#ifndef CONFIG_INLINE_WRITE_LOCK
298
-
void __lockfunc _raw_write_lock(rwlock_t *lock)
298
+
noinline void __lockfunc _raw_write_lock(rwlock_t *lock)
299
299
{
300
300
__raw_write_lock(lock);
301
301
}
···
313
313
#endif
314
314
315
315
#ifndef CONFIG_INLINE_WRITE_LOCK_IRQSAVE
316
-
unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock)
316
+
noinline unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock)
317
317
{
318
318
return __raw_write_lock_irqsave(lock);
319
319
}
···
321
321
#endif
322
322
323
323
#ifndef CONFIG_INLINE_WRITE_LOCK_IRQ
324
-
void __lockfunc _raw_write_lock_irq(rwlock_t *lock)
324
+
noinline void __lockfunc _raw_write_lock_irq(rwlock_t *lock)
325
325
{
326
326
__raw_write_lock_irq(lock);
327
327
}
···
329
329
#endif
330
330
331
331
#ifndef CONFIG_INLINE_WRITE_LOCK_BH
332
-
void __lockfunc _raw_write_lock_bh(rwlock_t *lock)
332
+
noinline void __lockfunc _raw_write_lock_bh(rwlock_t *lock)
333
333
{
334
334
__raw_write_lock_bh(lock);
335
335
}
···
337
337
#endif
338
338
339
339
#ifndef CONFIG_INLINE_WRITE_UNLOCK
340
-
void __lockfunc _raw_write_unlock(rwlock_t *lock)
340
+
noinline void __lockfunc _raw_write_unlock(rwlock_t *lock)
341
341
{
342
342
__raw_write_unlock(lock);
343
343
}
···
345
345
#endif
346
346
347
347
#ifndef CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE
348
-
void __lockfunc _raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
348
+
noinline void __lockfunc _raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
349
349
{
350
350
__raw_write_unlock_irqrestore(lock, flags);
351
351
}
···
353
353
#endif
354
354
355
355
#ifndef CONFIG_INLINE_WRITE_UNLOCK_IRQ
356
-
void __lockfunc _raw_write_unlock_irq(rwlock_t *lock)
356
+
noinline void __lockfunc _raw_write_unlock_irq(rwlock_t *lock)
357
357
{
358
358
__raw_write_unlock_irq(lock);
359
359
}
···
361
361
#endif
362
362
363
363
#ifndef CONFIG_INLINE_WRITE_UNLOCK_BH
364
-
void __lockfunc _raw_write_unlock_bh(rwlock_t *lock)
364
+
noinline void __lockfunc _raw_write_unlock_bh(rwlock_t *lock)
365
365
{
366
366
__raw_write_unlock_bh(lock);
367
367
}