What does “do { … } while (0)” do exactly in kernel code? [duplicate]

Answer 1

The purpose of do{ ... } while(0) construct is to turn a group of statements into a single compound statement that can be terminated with a ;. You see, in C language the do/while construct has one weird and unusual property: even though it "works" as a compound statement, it expects a ; at the end. No other compound constructs in C have this property.

Because of this property, you can use do/while to write multi-statement macros, which can be safely used as "ordinary" functions without worrying what's inside the macro, as in the following example

if (/* some condition */)
  __local_irq_save(x); /* <- we can safely put `;` here */
else
  /* whatever */;

Answer 2

It makes use of the macro act like a real statement or function call.

A statement is either { expression-list } or expression; so that poses a problem when defining macros that need more than one expression, because if you use { } then a syntax error will occur if the caller of the macro quite reasonably adds a ; before an else.

if(whatever)
  f(x);
else
  f(y);

If f() is a single statement macro, fine, but what if it's a macro and something complicated? You end up with if(...) { s1; s2; }; else ... and that doesn't work.

So the writer of the macro has to then either make it into a real function, wrap the construct in a single statement, or use a gnu extension.

The do .. while(0) pattern is the "wrap the construct" approach.

Answer 3

The answer has already been given (so the macro forces a ; when called), but another use of this kind of statement that I have seen: it allows break to be called anywhere in the "loop", early terminating if needed. Essentially a "goto" that your fellow programmers wouldn't murder you for.

do {
    int i = do_something();
    if(i == 0) { break; } // Skips the remainder of the logic
    do_something_else();
} while(0);

Note that this is still fairly confusing, so I don't encourage its use.

Answer 4

It allows for the code to appear here:

if(a) __local_irq_save(x); else ...;

// -> if(a) do { .. } while(0); else ...;

If they simply used a { .. } you would get

if(a) { ... }; else ...; 

The else would not belong to any if anymore, because the semicolon would be the next statement and separate the else from the preceeding if. A compile error would occur.

Answer 5

It's always used in macros so that a semicolon is required after a call, just like when calling a regular function.

In your example, you have to write

__local_irq_save(1);

while

__local_irq_save(1)

would result in an error about a missing semicolon. This would not happen if the do while was not there. If it was just about scoping, a simple curly brace pair would suffice.

Answer 6

Looks like it's there just for scoping. It's similar to:

if (true)
{
    // Do stuff.
}

edit

I don't see it in your example, but it's possible that one of those function calls is actually a macro, in which case there's one key difference between do/while(0) and if(true), which is that the former allows continue and break.