if (count < mod->slotCount) {
if (count < (CK_ULONG)mod->slotCount) {
SECMOD_UpdateSlotList(SECMODModule *mod){    CK_RV crv;    CK_ULONG count;    int i, oldCount;    PRBool freeRef = PR_FALSE;    void *mark = NULL;    CK_ULONG *slotIDs = NULL;    PK11SlotInfo **newSlots = NULL;    PK11SlotInfo **oldSlots = NULL;    /* C_GetSlotList is not a session function, make sure      * calls are serialized */    PZ_Lock(mod->refLock);    freeRef = PR_TRUE;    /* see if the number of slots have changed */    crv = PK11_GETTAB(mod)->C_GetSlotList(PR_FALSE, NULL, &count);    if (crv != CKR_OK) {	PORT_SetError(PK11_MapError(crv));	goto loser;    }    /* nothing new, blow out early, we want this function to be quick     * and cheap in the normal case  */    if (count == mod->slotCount) { 	PZ_Unlock(mod->refLock);	return SECSuccess;    }    if (count < mod->slotCount) {	/* shouldn't happen with a properly functioning PKCS #11 module */	PORT_SetError( SEC_ERROR_INCOMPATIBLE_PKCS11 );	goto loser;    }    /* get the new slot list */    slotIDs = PORT_NewArray(CK_SLOT_ID, count);    if (slotIDs == NULL) {	goto loser;    }    crv = PK11_GETTAB(mod)->C_GetSlotList(PR_FALSE, slotIDs, &count);    if (crv != CKR_OK) {	PORT_SetError(PK11_MapError(crv));	goto loser;    }    freeRef = PR_FALSE;    PZ_Unlock(mod->refLock);    mark = PORT_ArenaMark(mod->arena);    if (mark == NULL) {	goto loser;    }    newSlots = PORT_ArenaZNewArray(mod->arena,PK11SlotInfo *,count);    /* walk down the new slot ID list returned from the module. We keep     * the old slots which match a returned ID, and we initialize the new      * slots. */    for (i=0; i < count; i++) {	PK11SlotInfo *slot = SECMOD_FindSlotByID(mod,slotIDs[i]);	if (!slot) {	    /* we have a new slot create a new slot data structure */	    slot = PK11_NewSlotInfo(mod);	    if (!slot) {		goto loser;	    }	    PK11_InitSlot(mod, slotIDs[i], slot);	    STAN_InitTokenForSlotInfo(NULL, slot);	}	newSlots[i] = slot;    }    STAN_ResetTokenInterator(NULL);    PORT_Free(slotIDs);    slotIDs = NULL;    PORT_ArenaUnmark(mod->arena, mark);    /* until this point we're still using the old slot list. Now we update     * module slot list. We update the slots (array) first then the count,      * since we've already guarrenteed that count has increased (just in case      * someone is looking at the slots field of  module without holding the      * moduleLock */    SECMOD_GetWriteLock(moduleLock);    oldCount =mod->slotCount;    oldSlots = mod->slots;    mod->slots = newSlots; /* typical arena 'leak'... old mod->slots is			    * allocated out of the module arena and won't			    * be freed until the module is freed */    mod->slotCount = count;    SECMOD_ReleaseWriteLock(moduleLock);    /* free our old references before forgetting about oldSlot*/    for (i=0; i < oldCount; i++) {	PK11_FreeSlot(oldSlots[i]);    }    return SECSuccess;loser:    if (freeRef) {	PZ_Unlock(mod->refLock);    }    if (slotIDs) {	PORT_Free(slotIDs);    }    /* free all the slots we allocated. newSlots are part of the     * mod arena. NOTE: the newSlots array contain both new and old     * slots, but we kept a reference to the old slots when we built the new     * array, so we need to free all the slots in newSlots array. */    if (newSlots) {	for (i=0; i < count; i++) {	    if (newSlots[i] == NULL) {		break; /* hit the last one */	    }	    PK11_FreeSlot(newSlots[i]);	}    }    /* must come after freeing newSlots */    if (mark) { 	PORT_ArenaRelease(mod->arena, mark);    }    return SECFailure;}