Method exitRobustList

source/kernel/kthread.cpp:614–688

 */
#define ROBUST_LIST_LIMIT 2048
void KThread::exitRobustList()
{
    BOXEDWINE_CRITICAL_SECTION;

    struct k_robust_list_head head;
    struct k_robust_list_head entry;
    struct k_robust_list_head next_entry;
    struct k_robust_list_head pending;
    unsigned int limit = ROBUST_LIST_LIMIT, pi, pip;
    unsigned int next_pi;
    U32 futex_offset = 0;
    int rc;

    if (!this->robustList || !memory->canRead(this->robustList, 12)) {
        return;
    }    
    
    memory->memcpy(&head, this->robustList, 12);
    head.address = this->robustList;        

    /*
     * Fetch the list head (which was registered earlier, via
     * sys_set_robust_list()):
     */
    if (fetch_robust_entry(this, &entry, head.next, &pi)) {
        return;
    }

    /*
     * Fetch the relative futex offset:
     */
    //U32 futexOffset = head.futex_offset;

    /*
     * Fetch any possibly pending lock-add first, and handle it
     * if it exists:
     */
    if (fetch_robust_entry(this, &pending, head.list_op_pending, &pip))
        return;

    next_entry.address = 0;	/* avoid warning with gcc */
    while (entry.address != head.next) {
        /*
         * Fetch the next entry in the list before calling
         * handle_futex_death:
         */
        rc = fetch_robust_entry(this, &next_entry, entry.next, &next_pi);
        /*
         * A pending lock might already be on the list, so
         * don't process it twice:
         */
        if (entry.address != pending.address) {
            if (handleFutexDeath(entry.address + futex_offset, pi, HANDLE_DEATH_LIST)) {
                return;
            }
        }
        if (rc) {
            return;