void pse51_semq_cleanup(pse51_kqueues_t *q) { xnholder_t *holder; spl_t s; xnlock_get_irqsave(&nklock, s); while ((holder = getheadq(&q->semq)) != NULL) { pse51_sem_t *sem = link2sem(holder); pse51_node_t *node; xnlock_put_irqrestore(&nklock, s); #if XENO_DEBUG(POSIX) if (sem->is_named) xnprintf("Posix: unlinking semaphore \"%s\".\n", sem2named_sem(sem)->nodebase.name); else xnprintf("Posix: destroying semaphore %p.\n", sem); #endif /* XENO_DEBUG(POSIX) */ xnlock_get_irqsave(&nklock, s); if (sem->is_named) pse51_node_remove(&node, sem2named_sem(sem)->nodebase.name, PSE51_NAMED_SEM_MAGIC); xnlock_put_irqrestore(&nklock, s); sem_destroy_inner(sem, q); xnlock_get_irqsave(&nklock, s); } xnlock_put_irqrestore(&nklock, s); }
/** * Unlink a shared memory object. * * This service unlinks the shared memory object named @a name. The shared * memory object is not destroyed until every file descriptor obtained with the * shm_open() service is closed with the close() service and all mappings done * with mmap() are unmapped with munmap(). However, after a call to this * service, the unlinked shared memory object may no longer be reached * with the shm_open() service. * * @param name name of the shared memory obect to be unlinked. * * @retval 0 on success; * @retval -1 with @a errno set if: * - EPERM, the caller context is invalid; * - ENAMETOOLONG, the length of the @a name argument exceeds 64 characters; * - ENOENT, the shared memory object does not exist. * * @par Valid contexts: * - kernel module initialization or cleanup routine; * - kernel-space cancellation cleanup routine; * - user-space thread (Xenomai threads switch to secondary mode); * - user-space cancellation cleanup routine. * * @see * <a href="http://www.opengroup.org/onlinepubs/000095399/functions/shm_unlink.html"> * Specification.</a> * */ int shm_unlink(const char *name) { pse51_node_t *node; pse51_shm_t *shm; int err; spl_t s; if (xnpod_interrupt_p() || !xnpod_root_p()) { err = EPERM; goto error; } xnlock_get_irqsave(&nklock, s); err = pse51_node_remove(&node, name, PSE51_SHM_MAGIC); if (err) { xnlock_put_irqrestore(&nklock, s); error: thread_set_errno(err); return -1; } shm = node2shm(node); pse51_shm_put(shm, 0); xnlock_put_irqrestore(&nklock, s); return 0; }
/** * Unlink a named semaphore. * * This service unlinks the semaphore named @a name. This semaphore is not * destroyed until all references obtained with sem_open() are closed by calling * sem_close(). However, the unlinked semaphore may no longer be reached with * the sem_open() service. * * When a semaphore is destroyed, the memory it used is returned to the system * heap, so that further references to this semaphore are not guaranteed to * fail, as is the case for unnamed semaphores. * * @param name the name of the semaphore to be unlinked. * * @retval 0 on success; * @retval -1 with @a errno set if: * - ENAMETOOLONG, the length of the @a name argument exceeds 64 characters; * - ENOENT, the named semaphore does not exist. * * @see * <a href="http://www.opengroup.org/onlinepubs/000095399/functions/sem_unlink.html"> * Specification.</a> * */ int sem_unlink(const char *name) { pse51_node_t *node; nsem_t *named_sem; spl_t s; int err; xnlock_get_irqsave(&nklock, s); err = pse51_node_remove(&node, name, PSE51_NAMED_SEM_MAGIC); if (err) goto error; named_sem = node2sem(node); if (pse51_node_removed_p(&named_sem->nodebase)) { xnlock_put_irqrestore(&nklock, s); sem_destroy_inner(&named_sem->sembase, pse51_kqueues(1)); } else xnlock_put_irqrestore(&nklock, s); return 0; error: xnlock_put_irqrestore(&nklock, s); thread_set_errno(err); return -1; }
void pse51_shm_pkg_cleanup(void) { xnholder_t *holder; spl_t s; xnlock_get_irqsave(&nklock, s); while ((holder = getheadq(&pse51_shmq))) { pse51_shm_t *shm = link2shm(holder); pse51_node_t *node; pse51_node_remove(&node, shm->nodebase.name, PSE51_SHM_MAGIC); xnlock_put_irqrestore(&nklock, s); #if XENO_DEBUG(POSIX) xnprintf("Posix: unlinking shared memory \"%s\".\n", shm->nodebase.name); #endif /* XENO_DEBUG(POSIX) */ xnlock_get_irqsave(&nklock, s); pse51_shm_destroy(shm, 1); } xnlock_put_irqrestore(&nklock, s); }