static int pipefs_close(fs_cookie _fs, fs_vnode _v, file_cookie _cookie)
{
struct pipefs_vnode *v = _v;
struct pipefs_cookie *cookie = _cookie;
int err = 0;
TRACE(("pipefs_close: entry vnode 0x%x, cookie 0x%x\n", v, cookie));
if(v->stream.type == STREAM_TYPE_DIR)
return ERR_VFS_IS_DIR;
ASSERT(cookie->s == &v->stream);
mutex_lock(&v->stream.u.pipe.lock);
// XXX right now always RDWR
v->stream.u.pipe.read_count--;
v->stream.u.pipe.write_count--;
v->stream.u.pipe.open_count--;
if(v->stream.u.pipe.flags & PIPE_FLAGS_ANONYMOUS) {
if(v->stream.u.pipe.open_count < 2) {
// we just closed the other side of the pipe, delete the writer sem
// this will wake up any writers
sem_delete(v->stream.u.pipe.write_sem);
v->stream.u.pipe.write_sem = -1;
sem_delete(v->stream.u.pipe.read_sem);
v->stream.u.pipe.read_sem = -1;
}
}
mutex_unlock(&v->stream.u.pipe.lock);
return err;
}
int main(void)
{
sem_t m1;
int result;
/* create mutex */
if (sem_m_create(&m1) != OK) {
DEBUGMSG(TESTNR, "sem_m_create(&m1) != OK");
return FAILED;
}
/* do a sem_give while sem is not taken */
if (result=sem_give(m1) != SEM_ALREADY_FREE) {
DEBUGMSG(TESTNR, "sem_give(m1) != SEM_ALREADY_FREE");
printf("Result: %d\n", result);
if (sem_delete(m1) != OK) {
DEBUGMSG(TESTNR, "sem_delete(m1) != OK");
return FATAL_FAILURE;
}
return FAILED;
}
/* clean up */
if (sem_delete(m1) != OK) {
DEBUGMSG(TESTNR, "sem_delete(m1) != OK");
return FATAL_FAILURE;
}
/* test passed */
return OK;
}
int
port_delete(port_id id)
{
int slot;
sem_id r_sem, w_sem;
int capacity;
int i;
char *old_name;
struct port_msg *q;
if(ports_active == false)
return ERR_PORT_NOT_ACTIVE;
if(id < 0)
return ERR_INVALID_HANDLE;
slot = id % MAX_PORTS;
int_disable_interrupts();
GRAB_PORT_LOCK(ports[slot]);
if(ports[slot].id != id) {
RELEASE_PORT_LOCK(ports[slot]);
int_restore_interrupts();
dprintf("port_delete: invalid port_id %d\n", id);
return ERR_INVALID_HANDLE;
}
/* mark port as invalid */
ports[slot].id = -1;
old_name = ports[slot].name;
q = ports[slot].msg_queue;
r_sem = ports[slot].read_sem;
w_sem = ports[slot].write_sem;
capacity = ports[slot].capacity;
ports[slot].name = NULL;
RELEASE_PORT_LOCK(ports[slot]);
int_restore_interrupts();
// delete the cbuf's that are left in the queue (if any)
for (i=0; i<capacity; i++) {
if (q[i].data_cbuf != NULL)
cbuf_free_chain(q[i].data_cbuf);
}
kfree(q);
kfree(old_name);
// release the threads that were blocking on this port by deleting the sem
// read_port() will see the ERR_SEM_DELETED acq_sem() return value, and act accordingly
sem_delete(r_sem);
sem_delete(w_sem);
return NO_ERROR;
}
void sim_unregistered( ide_bus_info *bus )
{
sem_delete( bus->scan_device_sem );
sem_delete( bus->sync_wait_sem );
xpt->free_dpc( bus->irq_dpc );
uninit_synced_pc( &bus->scan_bus_syncinfo );
uninit_synced_pc( &bus->disconnect_syncinfo );
kfree( bus );
}
CNXT_SMC_STATUS cnxt_smc_term ( void )
{
u_int32 i;
IS_DRIVER_INITED(SMC, pDriverInst->bInit);
if (sem_get(pDriverInst->DriverSem, KAL_WAIT_FOREVER) != RC_OK)
{
return CNXT_SMC_INTERNAL_ERROR;
}
/* Mark the driver as not initialized */
pDriverInst->bInit = FALSE;
/* notify all clients of termination of the driver */
for ( i = 0 ; i < CNXT_SMC_NUM_UNITS ; i ++ )
{
cnxt_smc_notify_unit_clients(CNXT_SMC_EVENT_TERM, i);
if ( Card[i].ResetJob.SyncSem )
{
sem_delete ( Card[i].ResetJob.SyncSem );
Card[i].ResetJob.SyncSem = 0;
}
if ( Card[i].PowerdownJob.SyncSem )
{
sem_delete ( Card[i].PowerdownJob.SyncSem );
Card[i].PowerdownJob.SyncSem = 0;
}
}
/* destroy RW job semaphores */
for ( i = 0 ; i < CNXT_SMC_MAX_PENDING_RW ; i ++ )
{
if ( RwJobs[i].SyncSem )
{
sem_delete ( RwJobs[i].SyncSem );
}
}
/* Destroy semaphore */
if (pDriverInst->DriverSem)
{
sem_delete(pDriverInst->DriverSem);
pDriverInst->DriverSem = 0;
}
return CNXT_SMC_OK;
} /* end cnxt_smc_term() */
int net_timer_init(void)
{
int err;
net_q.next = net_q.prev = (net_timer_event *)&net_q;
err = hal_mutex_init(&net_q.lock, "net timer mutex");
if(err < 0)
return err;
//net_q.wait_sem = sem_create(0, "net timer wait sem");
if( hal_sem_init(&(net_q.wait_sem), "NetQ") < 0 ) {
mutex_destroy(&net_q.lock);
return -1; //net_q.wait_sem;
}
//net_q.runner_thread = thread_create_kernel_thread("net timer runner", &net_timer_runner, NULL);
net_q.runner_thread = hal_start_kernel_thread_arg( &net_timer_runner, NULL );
if(net_q.runner_thread < 0) {
sem_delete(net_q.wait_sem);
mutex_destroy(&net_q.lock);
return -1; //net_q.runner_thread;
}
//thread_resume_thread(net_q.runner_thread);
return 0;
}
/* in semcreate erstellten semaphore löschen */
int main(void) {
key_t key = ftok(".",0);
if (sem_delete(sem_create(key)) < 0) {
perror("sem_delete()");
}
return EXIT_SUCCESS;
}
void recursive_lock_destroy(recursive_lock *lock)
{
if(lock == NULL)
return;
if(lock->sem > 0)
sem_delete(lock->sem);
lock->sem = -1;
}
void handle_delete()
{
if(sem_delete())
{
perror("System call semctl(for delete) failed");
exit(EXIT_FAILURE);
}
}
static struct pipefs_vnode *pipefs_create_vnode(struct pipefs *fs, const char *name, stream_type type)
{
struct pipefs_vnode *v;
v = kmalloc(sizeof(struct pipefs_vnode));
if(v == NULL)
return NULL;
memset(v, 0, sizeof(struct pipefs_vnode));
v->id = atomic_add(&fs->next_vnode_id, 1);
v->name = kstrdup(name);
if(v->name == NULL)
goto err;
v->stream.type = type;
switch(type) {
case STREAM_TYPE_DIR:
v->stream.u.dir.dir_head = NULL;
v->stream.u.dir.jar_head = NULL;
if(mutex_init(&v->stream.u.dir.dir_lock, "pipefs_dir_lock") < 0)
goto err;
break;
case STREAM_TYPE_PIPE:
v->stream.u.pipe.buf = kmalloc(PIPE_BUFFER_LEN);
if(v->stream.u.pipe.buf == NULL)
goto err;
v->stream.u.pipe.buf_len = PIPE_BUFFER_LEN;
if(mutex_init(&v->stream.u.pipe.lock, "pipe_lock") < 0) {
kfree(v->stream.u.pipe.buf);
goto err;
}
v->stream.u.pipe.read_sem = sem_create(0, "pipe_read_sem");
if(v->stream.u.pipe.read_sem < 0) {
mutex_destroy(&v->stream.u.pipe.lock);
kfree(v->stream.u.pipe.buf);
goto err;
}
v->stream.u.pipe.write_sem = sem_create(1, "pipe_write_sem");
if(v->stream.u.pipe.write_sem < 0) {
sem_delete(v->stream.u.pipe.read_sem);
mutex_destroy(&v->stream.u.pipe.lock);
kfree(v->stream.u.pipe.buf);
goto err;
}
break;
}
return v;
err:
if(v->name)
kfree(v->name);
kfree(v);
return NULL;
}
void mutex_destroy(mutex *m)
{
if(m == NULL)
return;
if(m->sem >= 0) {
sem_delete(m->sem);
m->sem = -1;
}
m->holder = -1;
}
int main(int argc, char** argv) {
int i;
key_t key;
for(i=0; i<ANZ; i++) {
key = ftok(".",i);
if (sem_delete(sem_create(key)) < 0) {
perror("sem_delete()");
}
}
return EXIT_SUCCESS;
}
static int pipefs_delete_vnode(struct pipefs *fs, struct pipefs_vnode *v, bool force_delete)
{
// cant delete it if it's in a directory or is a directory
// and has children
if(!force_delete && ((v->stream.type == STREAM_TYPE_DIR && v->stream.u.dir.dir_head != NULL) || v->dir_next != NULL)) {
return ERR_NOT_ALLOWED;
}
// remove it from the global hash table
hash_remove(fs->vnode_list_hash, v);
if(v->stream.type == STREAM_TYPE_PIPE) {
sem_delete(v->stream.u.pipe.write_sem);
sem_delete(v->stream.u.pipe.read_sem);
mutex_destroy(&v->stream.u.pipe.lock);
kfree(v->stream.u.pipe.buf);
}
if(v->name != NULL)
kfree(v->name);
kfree(v);
return 0;
}
static void udp_endpoint_release_ref(udp_endpoint *e)
{
if(atomic_add(&e->ref_count, -1) == 1) {
udp_queue_elem *qe;
mutex_destroy(&e->lock);
sem_delete(e->blocking_sem);
// clear out the queue of packets
for(qe = udp_queue_pop(&e->q); qe; qe = udp_queue_pop(&e->q)) {
if(qe->buf)
cbuf_free_chain(qe->buf);
kfree(qe);
}
}
}
void tl_daemonzie(int iSem)
{
pid_t pid, sid;
pid = fork();
if(pid < 0)
exit(1);
if(pid > 0)
{
sem_take(iSem);
sem_delete(iSem);
exit(0);
}
sid = setsid();
if(sid < 0)
exit(1);
}
int connect_channel( const char *name,
ide_controller_interface *controller,
ide_channel_cookie channel,
ide_controller_params *controller_params,
ide_bus_info **bus_out )
{
ide_bus_info *bus;
xpt_bus_cookie xpt_cookie;
int res;
SHOW_FLOW0( 3, "" );
bus = kmalloc( sizeof( *bus ));
if( bus == NULL )
return ERR_NO_MEMORY;
SHOW_FLOW0( 3, "1" );
memset( bus, 0, sizeof( *bus ));
memcpy( &bus->controller_params, controller_params, sizeof( *controller_params ));
bus->lock = 0;
bus->num_running_reqs = 0;
bus->controller = controller;
bus->channel = channel;
bus->active_qrequest = NULL;
bus->disconnected = false;
init_synced_pc( &bus->scan_bus_syncinfo, scan_device_worker );
init_synced_pc( &bus->disconnect_syncinfo, disconnect_worker );
bus->wait_id = bus->dpc_id = 0;
bus->xpt_cookie = NULL;
timer_setup_timer( ide_timeout, bus, &bus->timer );
bus->state = ide_state_idle;
bus->device_to_reconnect = NULL;
bus->synced_pc_list = NULL;
if( (res = xpt->alloc_dpc( &bus->irq_dpc )) < 0 )
goto err1;
SHOW_FLOW0( 3, "2" );
bus->active_device = NULL;
bus->sync_wait_sem = sem_create( 0, "ide_sync_wait" );
if( bus->sync_wait_sem < 0 ) {
res = bus->sync_wait_sem;
goto err2;
}
SHOW_FLOW0( 3, "3" );
bus->devices[0] = bus->devices[1] = NULL;
bus->scan_device_sem = sem_create( 0, "ide_scan_finished" );
if( bus->scan_device_sem < 0 ) {
res = bus->scan_device_sem;
goto err3;
}
SHOW_FLOW0( 3, "4" );
bus->first_device = NULL;
strncpy( bus->controller_name, name, HBA_ID );
res = xpt->register_SIM( &ide_sim_interface, (cam_sim_cookie) bus,
&xpt_cookie );
if( res < 0 )
goto err4;
SHOW_FLOW0( 3, "5" );
bus->path_id = res;
// do assignment very last as the irq handler uses this value, so it
// must be either NULL or valid
bus->xpt_cookie = xpt_cookie;
// after this, the bus must be fully functional
*bus_out = bus;
call_xpt_bus_scan( bus );
return NO_ERROR;
err4:
sem_delete( bus->scan_device_sem );
err3:
sem_delete( bus->sync_wait_sem );
err2:
xpt->free_dpc( bus->irq_dpc );
err1:
uninit_synced_pc( &bus->scan_bus_syncinfo );
uninit_synced_pc( &bus->disconnect_syncinfo );
kfree( bus );
return res;
}
port_id
port_create(int32 queue_length, const char *name)
{
int i;
sem_id sem_r, sem_w;
port_id retval;
char *temp_name;
int name_len;
void *q;
proc_id owner;
if(ports_active == false)
return ERR_PORT_NOT_ACTIVE;
if(name == NULL)
name = "unnamed port";
name_len = strlen(name) + 1;
name_len = min(name_len, SYS_MAX_OS_NAME_LEN);
temp_name = (char *)kmalloc(name_len);
if(temp_name == NULL)
return ERR_NO_MEMORY;
strlcpy(temp_name, name, name_len);
// check queue length
if (queue_length < 1 || queue_length > MAX_QUEUE_LENGTH) {
kfree(temp_name);
return ERR_INVALID_ARGS;
}
// alloc a queue
q = kmalloc( queue_length * sizeof(struct port_msg) );
if (q == NULL) {
kfree(temp_name); // dealloc name, too
return ERR_NO_MEMORY;
}
// create sem_r with owner set to -1
sem_r = sem_create_etc(0, temp_name, -1);
if (sem_r < 0) {
// cleanup
kfree(temp_name);
kfree(q);
return sem_r;
}
// create sem_w
sem_w = sem_create_etc(queue_length, temp_name, -1);
if (sem_w < 0) {
// cleanup
sem_delete(sem_r);
kfree(temp_name);
kfree(q);
return sem_w;
}
owner = proc_get_current_proc_id();
int_disable_interrupts();
GRAB_PORT_LIST_LOCK();
// find the first empty spot
for(i=0; i<MAX_PORTS; i++) {
if(ports[i].id == -1) {
// make the port_id be a multiple of the slot it's in
if(i >= next_port % MAX_PORTS) {
next_port += i - next_port % MAX_PORTS;
} else {
next_port += MAX_PORTS - (next_port % MAX_PORTS - i);
}
ports[i].id = next_port++;
ports[i].lock = 0;
GRAB_PORT_LOCK(ports[i]);
RELEASE_PORT_LIST_LOCK();
ports[i].capacity = queue_length;
ports[i].name = temp_name;
// assign sem
ports[i].read_sem = sem_r;
ports[i].write_sem = sem_w;
ports[i].msg_queue = q;
ports[i].head = 0;
ports[i].tail = 0;
ports[i].total_count= 0;
ports[i].owner = owner;
retval = ports[i].id;
RELEASE_PORT_LOCK(ports[i]);
goto out;
}
}
// not enough ports...
RELEASE_PORT_LIST_LOCK();
kfree(q);
kfree(temp_name);
retval = ERR_PORT_OUT_OF_SLOTS;
dprintf("port_create(): ERR_PORT_OUT_OF_SLOTS\n");
// cleanup
sem_delete(sem_w);
sem_delete(sem_r);
kfree(temp_name);
kfree(q);
out:
int_restore_interrupts();
return retval;
}
