static gboolean
test_decr_wait(void)
{
GThread *th;
struct test_decr_wait_data data = { NULL, FALSE };
int rv;
data.sem = semaphore_new_with_value(10),
th = g_thread_create(test_decr_wait_thread, (gpointer)&data, TRUE, NULL);
/* sleep to give semaphore_decrement() a chance to block (or not). */
g_usleep(G_USEC_PER_SEC / 4);
/* and then increment the semaphore enough that the decrement can succeed */
data.increment_called = TRUE;
semaphore_increment(data.sem, 10);
/* join the thread and see how it fared. */
rv = GPOINTER_TO_INT(g_thread_join(th));
semaphore_free(data.sem);
return (rv == 1);
}
static gboolean
test_wait_empty(void)
{
GThread *th;
semaphore_t *sem = semaphore_new_with_value(10);
int rv;
th = g_thread_create(test_wait_empty_thread, (gpointer)sem, TRUE, NULL);
/* sleep to give semaphore_decrement() a chance to block (or not). */
g_usleep(G_USEC_PER_SEC / 4);
/* add another 10, so decrement can hit zero next time it's called */
semaphore_increment(sem, 10);
/* and wait on the semaphore emptying */
semaphore_wait_empty(sem);
/* join the thread and see how it fared. */
rv = GPOINTER_TO_INT(g_thread_join(th));
semaphore_free(sem);
return (rv == 1);
}
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) ;
}
int
blockdevice_signalblockdone(BLOCKDEVICEP dev, int blocknum)
{
int rc ;
if (! dev) {
return 0 ;
}
rc = semaphore_increment(dev->sem) ;
return 1 ;
}
int
blockdevice_writeblock(BLOCKDEVICEP dev, void *block, int offset, int size, int blocknum, int waitforcomplete)
{
int i ;
int rc ;
if (! dev) {
/*printf("!dev\n") ;*/
return -1 ;
}
if ((size < 0) || (offset < 0)) {
/*printf("size < 1 %d, offset < 0 %d\n", size,offset) ;*/
return -1 ;
}
if ( size > dev->blocksize ) {
/*printf("size %d > dev->blocksize %d\n", size, dev->blocksize) ;*/
return -1 ;
}
if (offset > size) {
/*printf("offset %d > size %d\n", size, dev->blocksize) ;*/
return -1 ;
}
i = find_free_block(dev->bd->datablocks, dev->numblocks) ;
/*
** Yay! We found a block, stuff data into it!
*/
dev->bd->datablocks[i].datalength = size ;
dev->bd->datablocks[i].blocknum = blocknum ;
dev->bd->datablocks[i].offset = offset ;
memcpy(dev->bd->datablocks[i].data, block, size) ;
/*
** Signal dirty block.
*/
rc = semaphore_increment(dev->dirtysem) ;
if (waitforcomplete) {
rc = semaphore_decrement(dev->sem) ;
}
return size ;
}
