Though this topic has been discussed many times in this forum and all other forums, still I have doubts. Please help.

How does the `do{} while(0)` in macro work in Linux kernel?
For example, 

```
#define preempt_disable()    do { } while (0)

```

How does it disable preempt?

```
#define might_resched()    do { } while (0)

```

How does it reschedule?

Similarly I have seen macros for mutex locks and other also. How does this help? I understand for following problem but not for the examples above.

```
#define foo(x)    do { do something } while(0)

```

**Edit:**

What about the following code for `rt_mutex_lock`?

```
/**
 * rt_mutex_lock - lock a rt_mutex
 *
 * @lock: the rt_mutex to be locked
 */
void __sched rt_mutex_lock(struct rt_mutex *lock)
{
        might_sleep();
        rt_mutex_fastlock(lock, TASK_UNINTERRUPTIBLE, 0, rt_mutex_slowlock);
}
EXPORT_SYMBOL_GPL(rt_mutex_lock);

/*
 * debug aware fast / slowpath lock,trylock,unlock
 *
 * The atomic acquire/release ops are compiled away, when either the
 * architecture does not support cmpxchg or when debugging is enabled.
 */

static inline int rt_mutex_fastlock(struct rt_mutex *lock, 
    int state, int detect_deadlock, int (*slowfn)(struct rt_mutex *lock, 
    int state, struct hrtimer_sleeper *timeout, int detect_deadlock))
{
        if (!detect_deadlock && likely(rt_mutex_cmpxchg(lock, NULL, current))) {
                rt_mutex_deadlock_account_lock(lock, current);
                return 0;
        } else{
                return slowfn(lock, state, NULL, detect_deadlock);
        }
}

```

I am confused because `rt_mutex_deadlock_account_lock` is define at two places in the kernel:

In `kernel/rtmutex-debug.c`:

```
void rt_mutex_deadlock_account_lock(struct rt_mutex *lock, 
    struct task_struct *task)
{
    //....
}

```

In `kernel/rtmutex.h`:

```
#define rt_mutex_deadlock_account_lock(m, t) do { } while (0)

```

In new kernel 2.6.35.4 in the i2c driver `rt_mutex_lock(&adap->bus_lock);` has replaced the `mutex_lock()`. How does this lock then?