Page History

When multiple threads must access or make modifications to a common variable, they may also access variables adjacent in memory to the common variable. This is an artefact of variables being stored compactly, with one byte holding multiple variables, and is a common optimization on word-addressed machines. Bit-fields are especially prone to this behavior, since C is designed to store multiple bit-fields in one addressable byte (or word). So race conditions may exist, not just on a variable accessed by multiple threads, but also on other variables sharing the same byte or word address.

A common means of preventing race conditions in concurrent programming is the mutex. When properly observed by all threads, a mutex may provide safe and secure access to a common variable, it guarantees nothing regarding other variables that might be accessed when a common variable is accessed.

Unfortunately there is no portable way to determine just what adjacent variables are stored along with a certain variable.

A better approach is to embed a concurrently-accessed variable inside a union, along with a long variable, or at least some padding to ensure that the concurrent variable is the only element to be accessed at that address. This would effectively guarantee that no other variables are accessed or modified when the concurrent variable is accessed or modifiedBit-fields may be used to declare struct members that use only a specified number of bits. If multiple threads are accessing or making modifications to different bit-fields, a race condition may be present, because the architecture may not be able to modify only the bits to which the member currently being modified may refer. As a result, a mutex protecting all bit-fields at the same time must be used.

Non-Compliant Code Example (Bit Field)

In the following non-compliant code, two executing threads simultaneously access two separate members of a global struct.

...

Even though each thread is modifying a separate bit-field, they are both modifying the same location in memory.  This is the same problem discussed in POS00-A. Avoid race conditions with multiple threads but is harder to diagnose, because it is not obvious at first glance that the same memory location is being modified.

Compliant Solution (Bit Field)

This compliant solution protects all usage of the flags with a mutex, preventing an unfortunate thread scheduling interleaving from being able to occur. In addition, the flags are declared volatile to ensure that the compiler will not attempt to move operations on them outside the mutex. Finally, the flags are embedded in a union alongside a long int, and a static assertion guarantees that the flags do not occupuy more space than the long. This prevents any data not checked by the mutex from being accessed or modified with the bit fields.

struct multi_threaded_flags {
  volatile int flag1 : 2;
  volatile int flag2 : 2;
};

union mtf_protect {
  struct multi_threaded_flags s;
  long padding;
};

static_assert(sizeof( long) >= sizeof( struct multi_threaded_flags));

struct mtf_mutex {
  union mtf_protect u;
  pthread_mutex_t mutex;
};

struct multimtf_threaded_flagsmutex flags;

void thread1(void) {
  pthread_mutex_lock(&flags.mutex);
  flags.u.s.flag1 = 1;
  pthread_mutex_unlock(&flags.mutex);
}

void thread2(void) {
  pthread_mutex_lock(&flags.mutex);
  flags.u.s.flag2 = 2;
  pthread_mutex_unlock(&flags.mutex);
}

Static assertions are discussed more thoroughly in DCL03-A. Use a static assertion to test the value of a constant expression.

Risk Assessment

Although the race window is narrow, having an assignment or an expression evaluate improperly due to misinterpreted data can possibly result in a corrupted running state or unintended information disclosure.

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

References

\[[ISO/IEC 9899:1999|AA. C References#ISO/IEC 9899-1999]\] Section 6.7.2.1, "Structure and union specifiers"

...