[PATCH] BUILD_LOCK_OPS: cleanup preempt_disable() usage

This patch changes the code from:

	preempt_disable();
	for (;;) {
		...
		preempt_disable();
	}
to:
	for (;;) {
		preempt_disable();
		...
	}

which seems more clean to me and saves a couple of bytes for
each function.

Signed-off-by: Oleg Nesterov <oleg@tv-sign.ru>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/kernel/spinlock.c b/kernel/spinlock.c
index 0375fcd..d1b8107 100644 (file)
--- a/kernel/spinlock.c
+++ b/kernel/spinlock.c
@@ -179,16 +179,16 @@ EXPORT_SYMBOL(_write_lock);
 #define BUILD_LOCK_OPS(op, locktype)                                   \
 void __lockfunc _##op##_lock(locktype##_t *lock)                       \
 {                                                                      \
-       preempt_disable();                                              \
        for (;;) {                                                      \
+               preempt_disable();                                      \
                if (likely(_raw_##op##_trylock(lock)))                  \
                        break;                                          \
                preempt_enable();                                       \
+                                                                       \
                if (!(lock)->break_lock)                                \
                        (lock)->break_lock = 1;                         \
                while (!op##_can_lock(lock) && (lock)->break_lock)      \
                        cpu_relax();                                    \
-               preempt_disable();                                      \
        }                                                               \
        (lock)->break_lock = 0;                                         \
 }                                                                      \
@@ -199,19 +199,18 @@ unsigned long __lockfunc _##op##_lock_irqsave(locktype##_t *lock) \
 {                                                                      \
        unsigned long flags;                                            \
                                                                        \
-       preempt_disable();                                              \
        for (;;) {                                                      \
+               preempt_disable();                                      \
                local_irq_save(flags);                                  \
                if (likely(_raw_##op##_trylock(lock)))                  \
                        break;                                          \
                local_irq_restore(flags);                               \
-                                                                       \
                preempt_enable();                                       \
+                                                                       \
                if (!(lock)->break_lock)                                \
                        (lock)->break_lock = 1;                         \
                while (!op##_can_lock(lock) && (lock)->break_lock)      \
                        cpu_relax();                                    \
-               preempt_disable();                                      \
        }                                                               \
        (lock)->break_lock = 0;                                         \
        return flags;                                                   \