need help finding a "possible" deadlock in simple application...

Here is the code which solves the dining philosophers problem:

http://webpages.charter.net/appcore/misc/diner_c.html

Apparently, Szabolcs Ferenczi says this deadlocks as-is. Well, I am having

kind of a hard time determining where the bug is. Can you help me? Can you

please execute the code a couple of times and see if it runs to
completion? 
I am having a hard time getting it to deadlock. I guess I will code it up
in 
Relacy for a last resort!  ;^)




The code as-is runs a try-lock algorithm. Here is the relevant function:
__________________________________________________________________
void
diner_eat_trylock(
  diner* const _this
) {
  int status, i = 1, old;
  puts("********** diner_eat_trylock **********");
  /* lock in reverse-order on purpose... */
  while(! (status =
    pthread_mutex_lock(&_this->forks[i]->lock))) {
    old = i;
    i = (old) ? 0 : 1;
    if (! (status =
           pthread_mutex_trylock(&_this->forks[i]->lock))) {
      break;
    }
    assert(old != i);
    if (status != EBUSY) {
      break;
    }
    if ((status =
         pthread_mutex_unlock(&_this->forks[old]->lock))) {
      break;
    }
    sched_yield();
  }
  if (status) { assert(! status); abort(); }
}
__________________________________________________________________




There is only one unlock function:
__________________________________________________________________
void
diner_eat_unlock(
  diner* const _this
) {
  int status, i = 1;
  /* unlock in reverse-order... */
  for(; i > -1; --i) {
    if ((status =
      pthread_mutex_unlock(&_this->forks[i]->lock))) {
      break;
    }
  }
  if (status) { assert(! status); abort(); }
}
__________________________________________________________________




I can't see a deadlock off hand wrt the interaction between those two 
functions. Here is the thread entry procedure, its setup so that there is
a 
thread per-diner:
__________________________________________________________________
void*
diner_thread(
  void* this_state
) {
  int i = 0;
  diner* const _this = this_state;
  diner_wait(_this, i, "Has Been Seated!");
  for(++i; pg_run && i < DINER_ITERATIONS(); ++i) {
    if (i % 2) {
      diner_think(_this, i);
    } else {
      diner_eat(_this, i);
    }
  }
  pg_run = 0;
  diner_wait(_this, i, "Has Left The Table!");
  return 0;
}
__________________________________________________________________




`pg_run' is a simple volatile variable used to shutdown all threads when
one 
diner is finished. The program can run with any number of diners at the 
table: 1, 2, 3, 4 or 5. You can try it by tweaking the following
functions:
__________________________________________________________________
void diner_startup(
  diner _this[5]
) {
  int status, i = 0;
  pg_run = 1;
  for(; i < 5; ++i) {
    diner_sort_assert(&_this[i]);
    if ((status =
      pthread_create(&_this[i].tid, 0,
        diner_thread, &_this[i]))) {
      break;
    }
  }
  if (status) { assert(! status); abort(); }
  puts("diner_startup");
}


void diner_shutdown(
  diner _this[5]
) {
  int status, i = 0;
  for(; i < 5; ++i) {
    if ((status =
      pthread_join(_this[i].tid, 0))) {
      break;
    }
  }
  if (status) { assert(! status); abort(); }
  puts("diner_shutdown");
}
__________________________________________________________________




Just switch the 5 in the functions above two a lower number to get both of

the functions to spawn that many diners. The only function which ever
calls 
the locks/unlock functions is `diner_eat()' which is as follows:
__________________________________________________________________
void
diner_eat(
  diner* const _this,
  int const seq
) {
  /* lock */
  if (_this->flags & DINER_FLAG_SORTLOCK()) {
    diner_eat_sortlock(_this);
  } else {
    diner_eat_trylock(_this);
  }

  /* wait */
  diner_wait(_this, seq, "Is Eating Spaghettii!");

  /* unlock */
  diner_eat_unlock(_this);
}
__________________________________________________________________




The only thing that comes to mind is that he did not link to the
thread-safe 
version of the crt. However, I still would greatly appreciate any
feedback.




Thank you so very much for your time and energy!