Exemplo n.º 1
0
void
_dispatch_semaphore_dispose(dispatch_object_t dou)
{
	dispatch_semaphore_t dsema = dou._dsema;

	if (dsema->dsema_value < dsema->dsema_orig) {
		DISPATCH_CLIENT_CRASH(
				"Semaphore/group object deallocated while in use");
	}

#if USE_MACH_SEM
	kern_return_t kr;
	if (dsema->dsema_port) {
		kr = semaphore_destroy(mach_task_self(), dsema->dsema_port);
		DISPATCH_SEMAPHORE_VERIFY_KR(kr);
	}
	if (dsema->dsema_waiter_port) {
		kr = semaphore_destroy(mach_task_self(), dsema->dsema_waiter_port);
		DISPATCH_SEMAPHORE_VERIFY_KR(kr);
	}
#elif USE_POSIX_SEM
	int ret = sem_destroy(&dsema->dsema_sem);
	DISPATCH_SEMAPHORE_VERIFY_RET(ret);
#endif
}
Exemplo n.º 2
0
static void _ringbuffer_stream_deallocate( stream_t* stream )
{
	ringbuffer_stream_t* buffer = (ringbuffer_stream_t*)stream;

	semaphore_destroy( &buffer->signal_read );
	semaphore_destroy( &buffer->signal_write );
}
Exemplo n.º 3
0
/**
 *\brief 关闭网络会话进程。
 *\param fs 定义了会话进程描述符。
 *\retval E_OK 表示成功。
 */
void fsocket_close(fsocket_t *fs) {
	if (fs->state) {
		semaphore_destroy(&fs->send_sem);
		semaphore_destroy(&fs->recv_sem);
		fs->state = 0;
	}
}
Exemplo n.º 4
0
/* Performs any initialization of the miniroute layer, if required. */
void
miniroute_initialize()
{
    network_get_my_address(hostaddr);
    discovery_alarm = -1;

    intrpt_buffer = queue_new();
    intrpt_sig = semaphore_create();
    discovery_mutex = semaphore_create();
    discovery_sig = semaphore_create();

    route_cache = miniroute_cache_new(65536, SIZE_OF_ROUTE_CACHE, MINIROUTE_CACHED_ROUTE_EXPIRE);
    disc_cache = miniroute_cache_new(65536, SIZE_OF_ROUTE_CACHE, MINIROUTE_CACHED_ROUTE_EXPIRE * 10);

    if (NULL == intrpt_buffer || NULL == intrpt_sig || NULL == route_cache
            || NULL == discovery_mutex || NULL == discovery_sig) {
        queue_free(intrpt_buffer);
        semaphore_destroy(intrpt_sig);
        semaphore_destroy(discovery_mutex);
        semaphore_destroy(discovery_sig);
        miniroute_cache_destroy(route_cache);
        return;
    }

    semaphore_initialize(intrpt_sig, 0);
    semaphore_initialize(discovery_mutex, 1);
    semaphore_initialize(discovery_sig, 0);

    network_get_my_address(hostaddr);

    minithread_fork(miniroute_control, NULL);
}
Exemplo n.º 5
0
/* Delete the route request struct */
void delete_route_request(route_request_t route_request)
{
	if (route_request->interrupt_arg != NULL)
		free(route_request->interrupt_arg);

	semaphore_destroy(route_request->initiator_sem);
	semaphore_destroy(route_request->waiting_sem);
	free(route_request);
}
Exemplo n.º 6
0
//Destroys minisockets
void minisocket_destroy(minisocket_t minisocket, int FIN) {
	int portNumber;
	int i, threads;
	interrupt_level_t prev_level;
	minisocket_error error;

	if (minisocket == NULL)
		return;

	portNumber = minisocket->port_number;

	semaphore_P(destroy_semaphore);

	minisocket->waiting = TCP_PORT_WAITING_TO_CLOSE;

	if (minisockets[portNumber] == NULL)
		return;

	semaphore_V(minisocket->packet_ready);

	semaphore_P(minisocket->mutex);

	if (minisockets[portNumber] == NULL)
		return;

	if (FIN == 1) {
		transmit_packet(minisocket, minisocket->destination_addr, minisocket->destination_port,
				1, MSG_FIN, 0, NULL, &error);
	}

	minisocket->status = TCP_PORT_CLOSING;

	prev_level = set_interrupt_level(DISABLED);
	threads = minisocket->num_waiting_on_mutex;

	for (i = 0; i < threads; i++)
	{
		semaphore_V(minisocket->mutex);
		i++;
	}
	set_interrupt_level(prev_level);

	minisockets[portNumber] = NULL;

	semaphore_destroy(minisocket->wait_for_ack_semaphore);
	semaphore_destroy(minisocket->mutex);
	semaphore_destroy(minisocket->packet_ready);

	if (minisocket->data_length != 0)
		free(minisocket->data_buffer);

	queue_free(minisocket->waiting_packets);

	free(minisocket);

	semaphore_V(destroy_semaphore);
}
Exemplo n.º 7
0
Arquivo: main.c Projeto: diegohdorta/C
static void end(void)
{
	shared_memory_destroy(shm_id);
	semaphore_destroy(semaphore_1);
	semaphore_destroy(semaphore_2);
	/*semaphore_destroy(consumer_lock);
	semaphore_destroy(producer_lock);
	semaphore_destroy(free_id);
	semaphore_destroy(busy_id);*/
}
Exemplo n.º 8
0
int
main(void)
{
    pthread_t     pthread1, pthread2, pthread3;
    semaphore_t*   sem = g_sem;
    kern_return_t kr;

    setbuf(stdout, NULL);

    kr = semaphore_create(mach_task_self(), &sem[0], SYNC_POLICY_FIFO, 0);
    OUT_ON_MACH_ERROR("semaphore_create", kr);

    kr = semaphore_create(mach_task_self(), &sem[1], SYNC_POLICY_FIFO, 0);
    OUT_ON_MACH_ERROR("semaphore_create", kr);

    (void)pthread_create(&pthread1, (const pthread_attr_t *)0,
                         start_routine, (void *) 0);
    printf("created thread1=%lx\n", 0);

    (void)pthread_create(&pthread2, (const pthread_attr_t *)0,
                         start_routine, (void *) 1);
    printf("created thread2=%lx\n", 1);

    (void)pthread_create(&pthread3, (const pthread_attr_t *)0,
                         start_routine, (void *) 2);
    printf("created thread3=%lx\n", 2);

    // wait until all three threads are ready
    SEMAPHORE_WAIT(sem[1], 3);

//    printf("main: about to signal thread3\n");
//    semaphore_signal_thread(sem[0], pthread_mach_thread_np(pthread3));

    // wait for thread3 to sem_signal()
//    semaphore_wait(sem[1]);

    sleep(1);
    printf("main: about to signal all threads\n");
    semaphore_signal_all(sem[0]);

    // wait for thread1 and thread2 to sem_signal()
    SEMAPHORE_WAIT(sem[1], 3);

out:
    if (sem[0])
        semaphore_destroy(mach_task_self(), sem[0]);
    if (sem[1])
        semaphore_destroy(mach_task_self(), sem[1]);

    exit(kr);
}
Exemplo n.º 9
0
int main(int argc, char *argv[])
{
    int s, ns;
    int semaphore_id;
    int shared_memory_id = 0;
    uint16_t port;
    pid_t pid;
    struct sockaddr_in client;
    char *tmp_shm_addr;
    shm_t *g_shm;

    check_args(&argc, argv, 0);

    port = (uint16_t) atoi(argv[1]);
    create_tcp_socket(&s, port);

    semaphore_id = semaphore_new(SEM_KEY);
    v(semaphore_id, 1);

    shared_memory_id = create_shared_memory(SHM_KEY);
    tmp_shm_addr = associate_shared_memory(shared_memory_id);
    g_shm = (shm_t *) tmp_shm_addr;


    while (true) {

        accept_new_connection(&s, &ns, &client);

        if ((pid = fork()) == 0)

            shandler(&ns, semaphore_id, client, g_shm);

        else {
            if (pid > 0)

                fprintf(stderr, "#%d# Father - Created child process: %d\n", getpid(), pid);

            else {
                fprintf(stderr, "The fork() function has failed: %s!\n", strerror(errno));
                shared_memory_destroy(shared_memory_id);
                semaphore_destroy(semaphore_id);
                exit(EXIT_FAILURE);
            }
        }
    }

    shared_memory_destroy(shared_memory_id);
    semaphore_destroy(semaphore_id);

    exit(EXIT_SUCCESS);
}
Exemplo n.º 10
0
DECLARE_TEST( semaphore, threaded )
{
	object_t thread[32];
	int ith;
	int failed_waits;

	semaphore_test_t test;
	semaphore_initialize( &test.read, 0 );
	semaphore_initialize( &test.write, 0 );
	test.loopcount = 128;
	test.counter = 0;
	
	for( ith = 0; ith < 32; ++ith )
	{
		thread[ith] = thread_create( semaphore_waiter, "semaphore_waiter", THREAD_PRIORITY_NORMAL, 0 );
		thread_start( thread[ith], &test );
	}

	test_wait_for_threads_startup( thread, 32 );

	failed_waits = 0;
	for( ith = 0; ith < test.loopcount * 32; ++ith )
	{
		semaphore_post( &test.read );
		thread_yield();
		if( !semaphore_try_wait( &test.write, 200 ) )
		{
			failed_waits++;
			EXPECT_TRUE( semaphore_wait( &test.write ) );
		}
	}

	for( ith = 0; ith < 32; ++ith )
	{
		thread_terminate( thread[ith] );
		thread_destroy( thread[ith] );
		thread_yield();
	}

	test_wait_for_threads_exit( thread, 32 );

	EXPECT_EQ( test.counter, test.loopcount * 32 );
	EXPECT_EQ( failed_waits, 0 );

	semaphore_destroy( &test.read );
	semaphore_destroy( &test.write );
	
	return 0;
}
Exemplo n.º 11
0
static void minisocket_free (minisocket_t * socket) {
  network_interrupt_arg_t *packet = NULL;
  while (queue_dequeue(socket->data, (void **)&packet) != -1) {
    free(packet);
  }
  queue_free(socket->data);
  socket->data = NULL;
  semaphore_destroy(socket->data_ready);
  semaphore_destroy(socket->wait_for_ack);
  semaphore_destroy(socket->send_receive_mutex);
  semaphore_P(ports_mutex);
  ports[socket->local_port] = NULL;
  semaphore_V(ports_mutex);
  free(socket);
}
Exemplo n.º 12
0
/* Initializes the minisocket layer. */
void minisocket_initialize()
{
  int i;
  sock_array = (minisocket_t*)malloc(sizeof(struct minisocket)*NUM_SOCKETS);
  if (!sock_array) {
    return;
  }
  for (i = 0; i < NUM_SOCKETS; i++) {
    sock_array[i] = NULL;
  }
  client_lock = semaphore_create();
  if (!client_lock) {
    free(sock_array);
    return;
  }
  server_lock = semaphore_create();
  if (!server_lock) {
    free(sock_array);
    semaphore_destroy(client_lock);
    return;
  }
  semaphore_initialize(client_lock, 1);
  semaphore_initialize(server_lock, 1);
  network_get_my_address(my_addr);
  curr_client_idx = CLIENT_START;
  //printf("minisocket_initialize complete\n");
}
Exemplo n.º 13
0
DECLARE_TEST( semaphore, postwait )
{
	semaphore_t sem;
	tick_t start, end;

	semaphore_initialize( &sem, 0 );
	EXPECT_FALSE( semaphore_try_wait( &sem, 100 ) );

	semaphore_post( &sem );
	EXPECT_TRUE( semaphore_wait( &sem ) );
	EXPECT_FALSE( semaphore_try_wait( &sem, 100 ) );

	semaphore_post( &sem );
	semaphore_post( &sem );
	EXPECT_TRUE( semaphore_wait( &sem ) );
	EXPECT_TRUE( semaphore_try_wait( &sem, 100 ) );
	EXPECT_FALSE( semaphore_try_wait( &sem, 100 ) );

	start = time_current();
	semaphore_try_wait( &sem, 0 );
	end = time_current();
	EXPECT_LT( end - start, time_ticks_per_second() / 1000 );

	start = time_current();
	semaphore_try_wait( &sem, 500 );
	end = time_current();
	EXPECT_GE( end - start, time_ticks_per_second() / 2 );

	semaphore_destroy( &sem );

	return 0;
}
Exemplo n.º 14
0
BLOCKDEVICEP 
blockdevice_create(char *name, int blocksize, int numblocks)
{
	BLOCKDEVICEP devp ;
	int rc ;

	if (blocksize != REAL_BLOCK_LENGTH) {
		/*
		** For now we simplify things and just force
		** all blockdevices to have 1k block sizes.
		** We can fix this assumption up later.
		*/
		return NULL ;
	}

	if (strlen(name) >= BLOCK_DEV_MAX_NAME_LEN) {
		return NULL ;
	}

	devp = malloc(sizeof(BLOCKDEVICE)) ;

	if (NULL == devp) {
		return NULL ;
	}

	devp->name = malloc(strlen(name)+1) ;

	if (NULL == devp->name) {
		free(devp) ;
		return NULL ;
	}

	devp->sem = semaphore_create(1234, 0) ;
	devp->dirtysem = semaphore_create(1235, 0) ;

	/*if (! devp->sem) {
		free(devp) ;
		return NULL ;
	}*/

	strcpy(devp->name, name) ;
	devp->blocksize = blocksize ;
	devp->numblocks = numblocks ;
	devp->lastblockchecked = 0 ;

	rc = shmem_open() ;

	if (0 == rc) {
		semaphore_destroy(devp->sem, 1) ;
		free(devp->name) ;
		free(devp) ;
		return NULL ;
	}

	devp->bd = (struct SHMEM_BLOCK_OVERLAY *) shmem_get_memptr() ;

	initialize_block_dev_shmem(devp->bd, blocksize, numblocks, name) ;

	return devp ;
}
void
_dispatch_sema4_create_slow(_dispatch_sema4_t *s4, int policy)
{
	semaphore_t tmp = MACH_PORT_NULL;

	_dispatch_fork_becomes_unsafe();

	// lazily allocate the semaphore port

	// Someday:
	// 1) Switch to a doubly-linked FIFO in user-space.
	// 2) User-space timers for the timeout.

#if DISPATCH_USE_OS_SEMAPHORE_CACHE
	if (policy == _DSEMA4_POLICY_FIFO) {
		tmp = (_dispatch_sema4_t)os_get_cached_semaphore();
		if (!os_atomic_cmpxchg(s4, MACH_PORT_NULL, tmp, relaxed)) {
			os_put_cached_semaphore((os_semaphore_t)tmp);
		}
		return;
	}
#endif

	kern_return_t kr = semaphore_create(mach_task_self(), &tmp, policy, 0);
	DISPATCH_SEMAPHORE_VERIFY_KR(kr);

	if (!os_atomic_cmpxchg(s4, MACH_PORT_NULL, tmp, relaxed)) {
		kr = semaphore_destroy(mach_task_self(), tmp);
		DISPATCH_SEMAPHORE_VERIFY_KR(kr);
	}
}
Exemplo n.º 16
0
Semaphore::~Semaphore()
{
	kern_return_t result = semaphore_destroy(mach_task_self(), mSemaphore);

	if(KERN_SUCCESS != result)
		LOGGER_ERR("org.sbooth.AudioEngine.Semaphore", "semaphore_destroy failed: " << mach_error_string(result));
}
Exemplo n.º 17
0
int syscall_sem_destroy(usr_sem_t* handle)
{
  int i;
  interrupt_status_t intr_status;

  intr_status = _interrupt_disable();
  spinlock_acquire(&usr_semaphore_table_slock);

  /* Look through the user semaphore table for
   * a usr_sem_t address matching the handle */
  for(i = 0; i < MAX_USR_SEMAPHORES; i++) {
    if(&usr_semaphore_table[i] == handle) {
      /* Invalidate the kernel semaphore and set the entry
       * in the userland semaphore table to empty */
      semaphore_destroy(handle->sem);
      usr_semaphore_table[i].sem = NULL;
      spinlock_release(&usr_semaphore_table_slock);
      _interrupt_set_state(intr_status);
      return 0;
    }
  }
  // If no match is found, return an error
  spinlock_release(&usr_semaphore_table_slock);
  _interrupt_set_state(intr_status);
  return 1;
}
Exemplo n.º 18
0
void
queue_locked_free(queue_locked_t q)
{
    if (q != NULL)
        semaphore_destroy(q->lock);
    free(q);
}
Exemplo n.º 19
0
BGM_TaskQueue::~BGM_TaskQueue()
{
    // Join the worker threads
    QueueSync(kBGMTaskStopWorkerThread, /* inRunOnRealtimeThread = */ true);
    QueueSync(kBGMTaskStopWorkerThread, /* inRunOnRealtimeThread = */ false);
    
    // Destroy the semaphores
    auto destroySemaphore = [] (semaphore_t inSemaphore) {
        kern_return_t theError = semaphore_destroy(mach_task_self(), inSemaphore);
        
        BGM_Utils::ThrowIfMachError("BGM_TaskQueue::~BGM_TaskQueue", "semaphore_destroy", theError);
    };
    
    destroySemaphore(mRealTimeThreadWorkQueuedSemaphore);
    destroySemaphore(mNonRealTimeThreadWorkQueuedSemaphore);
    destroySemaphore(mRealTimeThreadSyncTaskCompletedSemaphore);
    destroySemaphore(mNonRealTimeThreadSyncTaskCompletedSemaphore);
    
    BGM_Task* theTask;
    
    // Delete the tasks in the non-realtime tasks free list
    while((theTask = mNonRealTimeThreadTasksFreeList.pop_atomic()) != NULL)
    {
        delete theTask;
    }
    
    // Delete any tasks left on the non-realtime queue that need to be
    while((theTask = mNonRealTimeThreadTasks.pop_atomic()) != NULL)
    {
        if(!theTask->IsSync())
        {
            delete theTask;
        }
    }
}
Exemplo n.º 20
0
/*
 * sleep with timeout in milliseconds
 */
void minithread_sleep_with_timeout(int delay)
{
	// Create the sleep semaphore
	semaphore_t sleep_sem = semaphore_create();
	interrupt_level_t prev_level; // ISO C90...

	// Initialize it to a value of 0 so it can act as a way to signal threads
	semaphore_initialize(sleep_sem, 0);

	// Disable interrupts
	prev_level = set_interrupt_level(DISABLED);

	// Register the alarm
	register_alarm(delay, &minithread_sleep_alarm_wakeup, sleep_sem); 
	
	// If, at this point, interrupts were enabled, we could context switch away
	// the alarm could be triggered afterwards before the semaphore_P below was
	// called (depending on this threads priority level, etc) and then when this
	// thread finally calls semaphore_P(), it will hang forever.
	// Therefore we have interrupts disabled.

	// Wait on the sleep semaphore
	semaphore_P(sleep_sem);

	// Now that we've awoken, free the sleep semaphore
	semaphore_destroy(sleep_sem);

	// Restore the previous interrupt level
	set_interrupt_level(prev_level); // is this necessary? 

}
Exemplo n.º 21
0
main()
{
	SEMAPHOREP sem ;
	int rc ;
	int i ;

	sem = semaphore_open(1234) ;

	if (!sem) {
		printf("semaphore_open() failed\n") ;
		exit(1) ;
	}

	for (i = 0; i < 10; i++) {
		printf("Releasing semaphore iteration %d\n", i) ;
		rc = semaphore_increment(sem) ;
		if (! rc) {
			printf("semaphore_increment() failed\n") ;
			exit(1) ;
		}
		sleep(1) ;
	}

	rc = semaphore_destroy(sem, 0) ;
	if (! rc) {
		printf("semaphore_destroy(sem, 0) failed\n") ;
		exit(1) ;
	}

	exit(0) ;
}
Exemplo n.º 22
0
BOOL SemaphoreCloseHandle(HANDLE handle) {
	WINPR_SEMAPHORE *semaphore = (WINPR_SEMAPHORE *) handle;

	if (!SemaphoreIsHandled(handle))
		return FALSE;

#ifdef WINPR_PIPE_SEMAPHORE

	if (semaphore->pipe_fd[0] != -1)
	{
		close(semaphore->pipe_fd[0]);
		semaphore->pipe_fd[0] = -1;

		if (semaphore->pipe_fd[1] != -1)
		{
			close(semaphore->pipe_fd[1]);
			semaphore->pipe_fd[1] = -1;
		}
	}

#else
#if defined __APPLE__
	semaphore_destroy(mach_task_self(), *((winpr_sem_t*) semaphore->sem));
#else
	sem_destroy((winpr_sem_t*) semaphore->sem);
#endif
#endif
	free(semaphore);
	return TRUE;
}
Exemplo n.º 23
0
static void
_dispatch_semaphore_create_port(semaphore_t *s4)
{
	kern_return_t kr;
	semaphore_t tmp;

	if (*s4) {
		return;
	}
	_dispatch_safe_fork = false;

	// lazily allocate the semaphore port

	// Someday:
	// 1) Switch to a doubly-linked FIFO in user-space.
	// 2) User-space timers for the timeout.
	// 3) Use the per-thread semaphore port.

	while ((kr = semaphore_create(mach_task_self(), &tmp,
			SYNC_POLICY_FIFO, 0))) {
		DISPATCH_VERIFY_MIG(kr);
		sleep(1);
	}

	if (!dispatch_atomic_cmpxchg(s4, 0, tmp)) {
		kr = semaphore_destroy(mach_task_self(), tmp);
		DISPATCH_SEMAPHORE_VERIFY_KR(kr);
	}
}
Exemplo n.º 24
0
int XLinuxTask_preemptive::SemWrapper::Destroy()
{
	kern_return_t kres=semaphore_destroy(mach_task_self(), fSem);
	xbox_assert(kres==KERN_SUCCESS);

	return static_cast<int>(kres);
}
Exemplo n.º 25
0
RBSemaphore::~RBSemaphore()
{
	if(mMachSemaphore)
	{
		semaphore_destroy(mach_task_self(), mMachSemaphore);
		mMachSemaphore = NULL;
	}
}
Exemplo n.º 26
0
VOID DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{
#if defined __APPLE__
	semaphore_destroy(mach_task_self(), *((winpr_sem_t*) lpCriticalSection->LockSemaphore));
#else
	sem_destroy((winpr_sem_t*) lpCriticalSection->LockSemaphore);
#endif
}
Exemplo n.º 27
0
void event_exit_platform(void) {
	semaphore_destroy(&_usb_poll_resume);
	semaphore_destroy(&_usb_poll_suspend);

	array_destroy(&_usb_poll_pollfds, NULL);

	pipe_destroy(&_usb_poll_ready_pipe);

	usbi_close(_usb_poll_suspend_pipe[0]);
	usbi_close(_usb_poll_suspend_pipe[1]);

	event_remove_source(_stop_pipe.read_end, EVENT_SOURCE_TYPE_GENERIC);
	pipe_destroy(&_stop_pipe);

	free(_socket_error_set);
	free(_socket_write_set);
	free(_socket_read_set);
}
void com_ximeta_driver_NDASDiskArrayController::stop(IOService *provider)
{
    DbgIOLog(DEBUG_MASK_PNP_TRACE, ("Stopping\n"));
			
	if (fCommandGate) {     
		fWorkLoop->removeEventSource(fCommandGate);     
		fCommandGate->release();     
		fCommandGate = 0; 
	} 
	
	// Destroy Semaphores.
	semaphore_destroy(kernel_task, fExitSema);
	semaphore_destroy(kernel_task, fCommandSema);

	fWorkerThread = NULL;
		
    super::stop(provider);
}
Exemplo n.º 29
0
int 
blockdevice_close(BLOCKDEVICEP dev, int cleanup)
{
	int rc ;

	if (NULL == dev) {
		return 0 ;
	}

	rc = shmem_close(cleanup) ;
	rc = semaphore_destroy(dev->sem, cleanup) ;
	rc = semaphore_destroy(dev->dirtysem, cleanup) ;

	free(dev->name) ;
	free(dev) ;

	return rc ;
}
Exemplo n.º 30
0
void minisocket_destroy(minisocket_t sock, minisocket_error* error){
  network_interrupt_arg_t* pkt;

  semaphore_P(server_lock);
  sock_array[sock->src_port] = NULL;
  semaphore_V(server_lock);
  *error = SOCKET_NOERROR;
  //free all queued packets. interrupts not disabled
  //because socket in array set to null, network
  //handler cannot access queue
  while (queue_dequeue(sock->pkt_q,(void**)&pkt) != -1){
    free(pkt);
  }
  queue_free(sock->pkt_q);
  semaphore_destroy(sock->pkt_ready_sem);
  semaphore_destroy(sock->ack_ready_sem);
  semaphore_destroy(sock->sock_lock);
  free(sock);
}