As an interesting side note, I always though that a bakery style
spin lock would be quite adaptable to use as an upgrade lock.

Basically the rules for bakery style read/write locks are

writers wait for all prior accesses to complete
readers wait for all prior write accesses to complete

read then write would be
        wait for all prior write accesses to complete
        perform read access
        wait for all prior read accesses to complete
        perform write access

In pseudo C w/ perl style assignments so I can show
the atomic bits which would probably be implemented
with compare and swap or something.

// global
int cs = 0; // current
int cx = 0;

int ns = 0; // next
int nx = 0;

// thread local
int ws = 0; // wait
int wx = 0;

// read
    (ws, wx) = (ns++, nx);  // atomic
    while (wx != cx) {}     // wait for prior write accesses to complete
    ... // read access
    cs++;                   // complete read access

// write
    (ws, wx) = (ns, nx++);  // atomic
    while (wx != cx && ws != cs) {}     // wait for prior accesses to complete
    ... // write access
    cx++;                   // complete write access

// note that
//    while (wx != cx && ws != cs)
// is equivalent to
//    while (wx != cx) {}
//    while (ws != cs) {}

// read then upgrade to write
    (ws, wx) = (ns, nx++);  // atomic
    while (wx != cx) {}     // wait for prior write accesses to complete
    ... // read access
    while (ws != cs) {}     // wait for prior read accesses to complete
    ... // write access
    cx++;                   // complete write access

Joe Seigh