locking without mutex/rwlocks

#include <stdio.h>
#include <pthread.h>

typedef struct {
    unsigned long l;
    unsigned long v;
} apc_lock_t;

int apc_lock_init(apc_lock_t* lock)
{
    lock->l = 0;
    lock->v = 0;
}

int apc_lock_try(apc_lock_t* lock)
{
    int failed = 1;

    asm volatile (
        "xchgl %0, 0(%1)" : "=r" (failed) : "r" (&lock->l),
        "0" (failed)
    );

    return failed;
}

int apc_lock_get(apc_lock_t* lock)
{
    int failed = 1;

    do {
        failed = apc_lock_try(lock);
    } while (failed);

    return failed;
}

int apc_lock_release(apc_lock_t* lock)
{
    int released = 0;

    if (lock->l) {
        asm volatile (
            "xchgl %0, 0(%1)" : "=r" (released) : "r" (&lock->l),
            "0" (released)
        );
    }

    if (released) {
        /* got lock */
        printf("free'd lock...\n");
    }

    return !released;
}

void* pthread_test(void *input) {
    apc_lock_t* lock = (apc_lock_t*) input;

    if (lock) {
        int runs = 0;

        while (runs++ < 1000) {
            printf("%lu get lock: %d\n", pthread_self(), apc_lock_get(lock));
            sleep(1);
            printf("%lu release lock: %d\n", pthread_self(), apc_lock_release(lock));
        }
    }
    pthread_exit(NULL);
}

int main(char **argv) {
  apc_lock_t lock;

  apc_lock_init(&lock);

  pthread_t threads[100];
  int next = 0;

  while (next++ < 100) {
    pthread_create(
        &threads[next], NULL,
        pthread_test, (void*) &lock
    );
  }

  sleep(1000);

  while (next--) {
    pthread_join(threads[next], NULL);
  }
}