Mutex locks that automatically prevent writing to data structure?

Is there a way to explicitly define a mutex lock for a C struct or other data structure such that an exception would be thrown if I tried writing to the data structure without locking first?

In short, no. There is no hardware mechanism that could be used to implement this.

The hardware paging features (virtual memory) can be set to cause a trap on any write to an address, resulting in a SIGSEGV or SIGBUS being delivered to the process. However, this would be an unconditional trap; not only if the mutex is not held. You'd pay the price of the trap (which is quite slow) on every write to the object, including those that are just fine, and you'd have to test the mutex in your signal handler.

Also, the minimum granularity of this is one page (several KB) and so either you have to put every object on its own page and waste a lot of memory, or else put up with unrelated accesses causing spurious traps that your handler must ignore, and which slow down your program by a lot.

Some machines have "hardware watchpoints" for debugging, that can trap on access to a specific address with byte or word granularity. But this is likewise unconditional, and the hardware normally provides only a small fixed number of them (single digits), and in at least some cases, using them at all slows down the entire program. (It could be handy to use in your debugger, though; e.g. via the hwatch command in gdb. gdb will also let you set a condition that the debugger will test on every hit of the watchpoint, and only stop the program if the condition is true, so you could put your lock test there.)

If all accesses to the object are through specific getter/setter functions, then of course you can put checking code in those functions. But it won't help with buggy code that accesses the object directly, or if the getter/setter itself is buggy and skips the test. (The former case is helped by languages like C++ that could make the object's data private, but in C it's up to your own discipline.) Anyway, if you're going that route, usually you would have the getter/setter handle the locking in the first place, so that it becomes a non-issue for the rest of the program.

A more effective way to find such bugs is with a tool like ThreadSanitizer, which is included in both gcc and clang. It instruments the program to identify data races such as could arise from inadequate locking. ThreadSan does have a substantial performance penalty, so it's probably not suitable for use in production, but would be a good idea for development and testing.

> Is there a way to explicitly define a mutex lock for a C struct or other data structure such that an exception would be thrown if I tried writing to the data structure without locking first?

Without OS specific tricks (e.g. just pure C without any POSIX or anything) I doubt it.

With OS specific tricks you could make the data inaccessible by default, then when the mutex is acquired map the data at a "random" virtual address and return a pointer to the data (and unmap the data when the mutex is released); so that the chance of any other thread accessing the data without acquiring the lock is almost zero (as it wouldn't know a valid virtual address for the data); and so that it's very likely that a thread will get SIGSEGV if it tries to access it without acquiring the mutex.

For Unix-like operating systems, you might want to look at shmget(), shmat() and shmdt() for this.

For Windows it might be CreateFileMapping(), MapViewOfFile() and UnmapViewOfFile().