int
unlockFile(int fd)
{
Lock *lock;
lock = lookupHashTable(fd_hash, fd);
if (lock == NULL) {
// errorBelch("unlockFile: fd %d not found", fd);
// This is normal: we didn't know when calling unlockFile
// whether this FD referred to a locked file or not.
return 1;
}
if (lock->readers < 0) {
lock->readers++;
} else {
lock->readers--;
}
if (lock->readers == 0) {
removeHashTable(obj_hash, (StgWord)lock, NULL);
stgFree(lock);
}
removeHashTable(fd_hash, fd, NULL);
return 0;
}
STATIC_INLINE void
freeSnEntry(snEntry *sn)
{
ASSERT(sn->sn_obj == NULL);
removeHashTable(addrToStableHash, (W_)sn->old, NULL);
sn->addr = (P_)stable_name_free;
stable_name_free = sn;
}
void
removeThreadLabel(StgWord key)
{
void * old = NULL;
if ((old = lookupHashTable(threadLabels,key))) {
removeHashTable(threadLabels,key,old);
stgFree(old);
}
}
void freeExec(AdjustorExecutable exec)
{
AdjustorWritable writ;
ffi_closure* cl;
cl = writ = execToWritable(exec);
ACQUIRE_SM_LOCK;
removeHashTable(allocatedExecs, (StgWord)exec, writ);
ffi_closure_free(cl);
RELEASE_SM_LOCK
}
void hs_spt_remove(StgWord64 key[2]) {
if (spt) {
ACQUIRE_LOCK(&spt_lock);
StgStablePtr* entry = removeHashTable(spt, (StgWord)key, NULL);
RELEASE_LOCK(&spt_lock);
if (entry)
freeSptEntry(entry);
}
}
STATIC_INLINE void
freeStableName(snEntry *sn)
{
ASSERT(sn->sn_obj == NULL);
if (sn->addr != NULL) {
removeHashTable(addrToStableHash, (W_)sn->addr, NULL);
}
sn->addr = (P_)stable_ptr_free;
stable_ptr_free = sn;
}
void
removeThreadLabel(StgWord key)
{
ACQUIRE_LOCK(&threadLabels_mutex);
void * old = NULL;
if ((old = lookupHashTable(threadLabels,key))) {
removeHashTable(threadLabels,key,old);
stgFree(old);
}
RELEASE_LOCK(&threadLabels_mutex);
}
void
updateStablePtrTable(rtsBool full)
{
snEntry *p, *end_stable_ptr_table;
if (full && addrToStableHash != NULL) {
freeHashTable(addrToStableHash,NULL);
addrToStableHash = allocHashTable();
}
end_stable_ptr_table = &stable_ptr_table[SPT_size];
// NOTE: _starting_ at index 1; index 0 is unused.
for (p = stable_ptr_table + 1; p < end_stable_ptr_table; p++) {
if (p->addr == NULL) {
if (p->old != NULL) {
// The target has been garbage collected. Remove its
// entry from the hash table.
removeHashTable(addrToStableHash, (W_)p->old, NULL);
p->old = NULL;
}
}
else if (p->addr < (P_)stable_ptr_table
|| p->addr >= (P_)end_stable_ptr_table) {
// Target still alive, Re-hash this stable name
if (full) {
insertHashTable(addrToStableHash, (W_)p->addr,
(void *)(p - stable_ptr_table));
} else if (p->addr != p->old) {
removeHashTable(addrToStableHash, (W_)p->old, NULL);
insertHashTable(addrToStableHash, (W_)p->addr,
(void *)(p - stable_ptr_table));
}
}
}
}
/**
*A chaque connection d'un client, un thread est créé et talk_to_client est appelée.
*/
void *talk_to_client(void *idSocket)
{
cle_t K;
donnee_t D;
requete_t type_requete;
socket_t sockClient = (socket_t) idSocket;
tabClient_t curr, prev;
uint64_t h;
/* Pour STATUS */
idConnexion_t ident;
while (1) {
pthread_mutex_lock(&MUTEX_NB_JOBS);
NB_JOBS++;
pthread_mutex_unlock(&MUTEX_NB_JOBS);
recevoirTypeMessage(&type_requete, sockClient);
#ifdef DEBUG_SERVEUR_IMPL
printf("%d:reçu %d\n", sockClient, type_requete);
#endif
switch (type_requete) {
case PUT:
pthread_cond_signal(&condition_cond);
recevoirCle(&K, sockClient);
h = hash(K);
#ifdef DEBUG_SERVEUR_IMPL
printf("talk_to_client:PUT:cle(%s), hash(%llu)\n", K,
h);
#endif
if (SERVEUR.h <= h
&& h < (SERVEUR.h + SERVEUR.tabl.taille)) {
envoyerOctet(1, sockClient);
recevoirDonnee(&D, sockClient);
pthread_mutex_lock(&(SERVEUR.tabl.mutexTab[h - SERVEUR.h]));
putHashTable(D, SERVEUR.tabl);
pthread_mutex_unlock(&(SERVEUR.tabl.mutexTab[h - SERVEUR.h]));
} else {
envoyerOctet(0, sockClient);
envoyerSockAddr(SERVEUR.suivServeur,
sockClient);
}
//pour les tests
#ifdef DEBUG_SERVEUR_IMPL
printf("put terminé\n");
#endif
break;
case GET:
pthread_cond_signal(&condition_cond);
recevoirCle(&K, sockClient);
h = hash(K);
#ifdef DEBUG_SERVEUR_IMPL
printf("talk_to_client:GET:cle(%s), hash(%llu)\n", K,
h);
#endif
if (SERVEUR.h <= h
&& h < (SERVEUR.h + SERVEUR.tabl.taille)) {
D = getHashTable(K, SERVEUR.tabl);
envoyerOctet(1, sockClient);
if (D == NULL) {
envoyerOctet(0, sockClient);
} else {
envoyerOctet(1, sockClient);
envoyerDonnee(D, sockClient);
}
} else {
envoyerOctet(0, sockClient);
envoyerSockAddr(SERVEUR.suivServeur,
sockClient);
}
break;
case REMOVEKEY:
pthread_cond_signal(&condition_cond);
recevoirCle(&K, sockClient);
h = hash(K);
#ifdef DEBUG_SERVEUR_IMPL
printf("talk_to_client:cle(%s), hash(%llu)\n", K, h);
#endif
if (SERVEUR.h <= h
&& h < (SERVEUR.h + SERVEUR.tabl.taille)) {
D = getHashTable(K, SERVEUR.tabl);
envoyerOctet(1, sockClient);
if (D == NULL) {
envoyerOctet(0, sockClient);
} else {
pthread_mutex_lock(&(SERVEUR.tabl.mutexTab[h - SERVEUR.h]));
valeur_t V =
removeHashTable(K, SERVEUR.tabl);
pthread_mutex_unlock(&(SERVEUR.tabl.mutexTab[h - SERVEUR.h]));
envoyerOctet(1, sockClient);
envoyerValeur(V, sockClient);
free(V);
}
} else {
envoyerOctet(0, sockClient);
envoyerSockAddr(SERVEUR.suivServeur,sockClient);
}
break;
case CONNECT:
pthread_cond_signal(&condition_cond);
break;
case QUIT:
/*pthread_cond_signal(&condition_cond);!!! */
#ifdef DEBUG_SERVEUR_IMPL
printf("QUIT\n");
#endif
pthread_mutex_lock(&SERVER_IS_DYING);
if (SERVER_IS_DYING_VAR == 0) {
SERVER_IS_DYING_VAR = 1;
//envoyer octet 1;
} else {
printf("serveur is already dead");
//envoyerOctet 0
}
pthread_mutex_unlock(&SERVER_IS_DYING);
free(SERVEUR.tabl.mutexTab);
if (NB_JOBS != 1) {
printf
("en attente que les requetes soient satisfaites\n");
pthread_cond_wait(&COND_NB_JOBS,
&MUTEX_NB_JOBS);
}
#ifdef DEBUG_SERVEUR_IMPL
printf("le serveur est libre\n");
#endif
message_quit();
exit(0);
break;
case DISCONNECT:
pthread_cond_signal(&condition_cond);
#ifdef DEBUG_SERVEUR_IMPL
printf("disconnect\n");
#endif
curr = SERVEUR.tableauClient;
prev = SERVEUR.tableauClient;
if (curr->client.idSocket == sockClient) {
SERVEUR.tableauClient = curr->suiv;
free(curr);
}
else {
while(curr->client.idSocket != sockClient && curr) {
prev = curr;
curr = curr->suiv;
}
if (curr) {
prev->suiv = curr->suiv;
free(curr);
}
else {
#ifdef DEBUG_SERVEUR_IMPL
printf("talk_to_client:DISCONNECT:client de socket %d inconnu.\n"
, sockClient);
#endif
close(sockClient);
pthread_exit(NULL);
}
}
shutdown(sockClient, SHUT_RDWR);
pthread_exit(NULL);
break;
case STATUS:
#ifdef DEBUG_SERVEUR_IMPL
printf("STATUS\n");
#endif
ident = get_my_idConnexion();
envoyerIdent(ident, sockClient);
break;
break;
default:
printf("Erreur:talk_to_client:Message inconnu\n");
break;
}
pthread_mutex_lock(&MUTEX_NB_JOBS);
NB_JOBS--;
if (NB_JOBS == 0) {
pthread_cond_signal(&COND_NB_JOBS);
}
pthread_mutex_unlock(&MUTEX_NB_JOBS);
}
}
