int sexe_event_remove(lua_State *L, int e_type, char *e_name) { sexe_event_t t_event; sexe_event_t *e; shkey_t *key; int err; memset(&t_event, 0, sizeof(t_event)); t_event.event_type = e_type; strncpy(t_event.mod_name, e_name, sizeof(t_event.mod_name) - 1); key = shkey_bin(&t_event, sizeof(sexe_event_t)); /* remove event's global callback */ lua_pushnil(L); lua_setglobal(L, shkey_hex(key)); e = (sexe_event_t *)shmap_get_ptr(event_map, key); if (e) { shmap_unset(event_map, key); free(e); } shkey_free(&key); return (0); }
int shlock_close(shkey_t *key) { shmap_t *lock_map = get_shlock_map(); shlock_t *lk; pid_t tid; int err; lk = shmap_get_ptr(lock_map, key); if (!lk) return (0); /* all done */ if (lk->ref == 0) return (0); /* the mutex is not locked. */ tid = gettid(); if (tid != lk->tid) return (0); /* wrong thread calling. */ #ifdef USE_LIBPTHREAD err = pthread_mutex_unlock(&lk->mutex); if (err) { return (-1); } #endif /* assign variables after mutex is unlocked. */ lk->ref--; if (lk->ref == 0) lk->tid = 0; return (0); }
int shlock_tryopen(shkey_t *key, int flags, shlock_t **lock_p) { shmap_t *lock_map = get_shlock_map(); shlock_t *lk; pid_t tid; #ifdef USE_LIBPTHREAD pthread_mutexattr_t attr; int err; #endif tid = gettid(); lk = shmap_get_ptr(lock_map, key); if (!lk) { lk = (shlock_t *)calloc(1, sizeof(shlock_t)); if (!lk) return (-1); shmap_set_ptr(lock_map, key, lk); #ifdef USE_LIBPTHREAD memset(&attr, 0, sizeof(attr)); if (!(flags & SHLK_PRIVATE)) { pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); } pthread_mutex_init(&lk->mutex, &attr); #endif } else if (lk->ref) { if ((flags & SHLK_PRIVATE)) { /* mutex is already locked. */ return (1); } if (tid != lk->tid) return (1); /* lock is not accessible from this thread. */ } if (!lk->ref || lk->tid != tid) { #ifdef USE_LIBPTHREAD /* returns an errno */ err = pthread_mutex_trylock(&lk->mutex); if (err == EBUSY) return (1); if (err) return (-1); #endif } /* assign variables after mutex is locked. */ lk->tid = tid; lk->ref++; *lock_p = lk; return (0); }
shlock_t *shlock_open(shkey_t *key, int flags) { shmap_t *lock_map = get_shlock_map(); shlock_t *lk; pid_t tid; #ifdef USE_LIBPTHREAD pthread_mutexattr_t attr; int err; #endif tid = gettid(); lk = shmap_get_ptr(lock_map, key); if (!lk) { lk = (shlock_t *)calloc(1, sizeof(shlock_t)); if (!lk) return (NULL); shmap_set_ptr(lock_map, key, lk); #ifdef USE_LIBPTHREAD memset(&attr, 0, sizeof(attr)); if (!(flags & SHLK_PRIVATE)) { pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); } pthread_mutex_init(&lk->mutex, &attr); #endif } #ifdef USE_LIBPTHREAD err = pthread_mutex_lock(&lk->mutex); if (err) { return (NULL); } #else /* bug: acts like trylock() instead of lock() .. need to introduce waiting psuedo-lock */ if (lk->ref) { if ((flags & SHLK_PRIVATE)) { /* mutex is already locked. */ return (NULL); } if (tid != lk->tid) { return (NULL); /* lock is not accessible from this thread. */ } } #endif /* assign variables after mutex is locked. */ lk->tid = tid; lk->ref++; return (lk); }