tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

[PATCH] spin_unlock_bh() and preempt_check_resched()

In _spin_unlock_bh(lock):
do { \
_raw_spin_unlock(lock); \
preempt_enable(); \
local_bh_enable(); \
__release(lock); \
} while (0)

there is no reason for using preempt_enable() instead of a simple
preempt_enable_no_resched()

Since we know bottom halves are disabled, preempt_schedule() will always
return at once (preempt_count!=0), and hence preempt_check_resched() is
useless here...

This fixes it by using "preempt_enable_no_resched()" instead of the
"preempt_enable()", and thus avoids the useless preempt_check_resched()
just before re-enabling bottom halves.

Signed-off-by: Samuel Thibault <samuel.thibault@ens-lyon.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

authored by

Samuel Thibault and committed by
Linus Torvalds 10f02d1c 9636273d

+8 -8
+4 -4
include/linux/spinlock.h
··· 248 248 249 249 #define _spin_trylock_bh(lock) ({preempt_disable(); local_bh_disable(); \ 250 250 _raw_spin_trylock(lock) ? \ 251 - 1 : ({preempt_enable(); local_bh_enable(); 0;});}) 251 + 1 : ({preempt_enable_no_resched(); local_bh_enable(); 0;});}) 252 252 253 253 #define _spin_lock(lock) \ 254 254 do { \ ··· 383 383 #define _spin_unlock_bh(lock) \ 384 384 do { \ 385 385 _raw_spin_unlock(lock); \ 386 - preempt_enable(); \ 386 + preempt_enable_no_resched(); \ 387 387 local_bh_enable(); \ 388 388 __release(lock); \ 389 389 } while (0) ··· 391 391 #define _write_unlock_bh(lock) \ 392 392 do { \ 393 393 _raw_write_unlock(lock); \ 394 - preempt_enable(); \ 394 + preempt_enable_no_resched(); \ 395 395 local_bh_enable(); \ 396 396 __release(lock); \ 397 397 } while (0) ··· 423 423 #define _read_unlock_bh(lock) \ 424 424 do { \ 425 425 _raw_read_unlock(lock); \ 426 + preempt_enable_no_resched(); \ 426 427 local_bh_enable(); \ 427 - preempt_enable(); \ 428 428 __release(lock); \ 429 429 } while (0) 430 430
+4 -4
kernel/spinlock.c
··· 294 294 void __lockfunc _spin_unlock_bh(spinlock_t *lock) 295 295 { 296 296 _raw_spin_unlock(lock); 297 - preempt_enable(); 297 + preempt_enable_no_resched(); 298 298 local_bh_enable(); 299 299 } 300 300 EXPORT_SYMBOL(_spin_unlock_bh); ··· 318 318 void __lockfunc _read_unlock_bh(rwlock_t *lock) 319 319 { 320 320 _raw_read_unlock(lock); 321 - preempt_enable(); 321 + preempt_enable_no_resched(); 322 322 local_bh_enable(); 323 323 } 324 324 EXPORT_SYMBOL(_read_unlock_bh); ··· 342 342 void __lockfunc _write_unlock_bh(rwlock_t *lock) 343 343 { 344 344 _raw_write_unlock(lock); 345 - preempt_enable(); 345 + preempt_enable_no_resched(); 346 346 local_bh_enable(); 347 347 } 348 348 EXPORT_SYMBOL(_write_unlock_bh); ··· 354 354 if (_raw_spin_trylock(lock)) 355 355 return 1; 356 356 357 - preempt_enable(); 357 + preempt_enable_no_resched(); 358 358 local_bh_enable(); 359 359 return 0; 360 360 }