static status_t ser_close( void* pNode, void* pCookie )
{
SerPort_s* psPort = pNode;
delete_semaphore( psPort->sp_hRecvMutex );
delete_semaphore( psPort->sp_hRecvWaitQueue );
psPort->sp_bOpen = false;
return( 0 );
}
static void do_delete_port( Process_s *psProc, MsgPort_s *psPort )
{
if ( psPort->mp_nFlags & MSG_PORT_PUBLIC )
{
unlock_mutex( g_hPortListSema );
make_port_private( psPort->mp_hPortID );
lock_mutex( g_hPortListSema, true );
}
MArray_Remove( &g_sMsgPorts, psPort->mp_hPortID );
delete_semaphore( psPort->mp_hSyncSema );
while ( psPort->mp_psFirstMsg != NULL )
{
MessageNode_s *psMsg = psPort->mp_psFirstMsg;
psPort->mp_psFirstMsg = psMsg->mn_psNext;
kfree( psMsg );
}
if ( psProc != NULL )
{
unlink_port( psProc, psPort );
}
kfree( psPort );
atomic_dec( &g_sSysBase.ex_nMessagePortCount );
}
BufferPool::~BufferPool()
{
delete_semaphore(fFreeBuffers);
LOCK(fLock);
// the return value doesn't interest us anymore
void **buffer = fFirstFree;
while (buffer != NULL) {
void **nextBuffer = (void **)*buffer;
free(buffer);
buffer = nextBuffer;
}
delete_semaphore(fLock);
}
/* Free the semaphore */
void SDL_DestroySemaphore(SDL_sem *sem)
{
if ( sem ) {
if ( sem->id >= 0 ) {
delete_semaphore(sem->id);
}
free(sem);
}
}
port_id sys_create_port( const char *const pzName, int nMaxCount )
{
int nError;
MsgPort_s *psPort;
lock_mutex( g_hPortListSema, true );
psPort = kmalloc( sizeof( MsgPort_s ), MEMF_CLEAR | MEMF_KERNEL | MEMF_LOCKED | MEMF_OKTOFAIL );
if ( psPort == NULL )
{
nError = -ENOMEM;
goto error1;
}
psPort->mp_hSyncSema = create_semaphore( "port_sync", 0, 0 );
if ( psPort->mp_hSyncSema < 0 )
{
printk( "Error: sys_create_port() failed to allocate semaphore\n" );
nError = psPort->mp_hSyncSema;
goto error2;
}
psPort->mp_hPortID = MArray_Insert( &g_sMsgPorts, psPort, false );
if ( psPort->mp_hPortID < 0 )
{
printk( "Failed to alloc descriptor for msg port %s\n", pzName );
nError = psPort->mp_hPortID;
goto error3;
}
psPort->mp_nMaxCount = nMaxCount;
psPort->mp_nFlags = 0;
strncpy_from_user( psPort->mp_zName, pzName, OS_NAME_LENGTH );
psPort->mp_zName[OS_NAME_LENGTH - 1] = '\0';
link_port( CURRENT_PROC, psPort );
unlock_mutex( g_hPortListSema );
atomic_inc( &g_sSysBase.ex_nMessagePortCount );
return ( psPort->mp_hPortID );
error3:
delete_semaphore( psPort->mp_hSyncSema );
error2:
kfree( psPort );
error1:
unlock_mutex( g_hPortListSema );
return ( nError );
}
int pthread_mutex_destroy(pthread_mutex_t *mutex)
{
if( mutex == NULL )
return( EINVAL );
if( mutex->__mutex != 0 )
delete_semaphore( mutex->__mutex );
if( mutex->__attr != NULL )
{
pthread_mutexattr_destroy( mutex->__attr );
}
return( 0 );
}
acpi_status
acpi_os_delete_semaphore(
acpi_handle handle)
{
sem_id *sem = (sem_id*) handle;
ACPI_FUNCTION_TRACE ("os_delete_semaphore");
if (!sem)
return_ACPI_STATUS (AE_BAD_PARAMETER);
delete_semaphore( *sem );
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
acpi_os_free(sem); sem = NULL;
return_ACPI_STATUS (AE_OK);
}
rtems_task Init(
rtems_task_argument argument
)
{
void *alloc_ptr = (void *)0;
int num_opens = 0;
int index = 0;
TEST_BEGIN();
puts( "Creating all barriers" );
create_all_barriers();
puts( "Creating all semaphores" );
create_all_semaphores();
puts( "Creating FIFO" );
create_fifo();
puts( "Opening FIFO.. expect ENOMEM (semaphore for pipe could not be created)" );
open_fifo(ENOMEM, O_RDWR);
delete_semaphore();
alloc_ptr = malloc( malloc_free_space() - 4 );
puts("Opening FIFO.. expect ENOMEM since no memory is available");
open_fifo(ENOMEM, O_RDWR);
free(alloc_ptr);
puts( "Opening FIFO.. expect ENOMEM (barrier-1 for pipe could not be created)" );
open_fifo(ENOMEM, O_RDWR);
delete_barrier();
puts( "Opening FIFO.. expect ENOMEM (barrier-2 for pipe could not be created" );
open_fifo(ENOMEM, O_RDWR);
delete_barrier();
puts( "Opening FIFO.. expect ENOMEM (semaphore-1 for pipe could not be created" );
open_fifo(ENOMEM, O_RDWR);
delete_semaphore();
puts( "Opening FIFO in RDWR mode. Expect OK" );
open_fifo(0, O_RDWR);
++num_opens;
puts( "Opening FIFO in non blocking RDONLY mode. Expect OK");
open_fifo(0, O_RDONLY | O_NONBLOCK);
++num_opens;
puts( "Opening FIFO in non blocking WRONLY mode. Expect ENXIO");
open_fifo(ENXIO, O_WRONLY | O_NONBLOCK);
++num_opens;
puts("\nMultiple opens\n");
index = 0;
do {
printf("%d... ", index+1);
open_fifo(0, O_RDONLY | O_NONBLOCK);
++index;
} while ( index < NUM_OPEN_REQ - num_opens );
TEST_END();
rtems_test_exit(0);
}
int main(int argc, char *argv[]) {
int fd;
int sem;
int nrpages = 1;
int ret = 0;
int tmp = 0;
int offset = 0;
char c;
char *filename;
char *actype;
char *onerror;
char *p;
pid_t pid;
int wait_status;
uint64_t pflag;
struct sembuf sembuf;
struct pagestat pgstat;
if (argc != 5) {
printf("Usage: %s filename nrpages accesstype onerror\n", argv[0]);
exit(EXIT_FAILURE);
}
filename = argv[1];
nrpages = strtol(argv[2], NULL, 10);
actype = argv[3];
onerror = argv[4];
DEB("filename = %s, nrpages = %d, actype = %s, onerror = %s\n",
filename, nrpages, actype, onerror);
if (strcmp(onerror, "onerror") == 0)
offset = 0;
else
offset = PS;
sem = create_and_init_semaphore();
fd = open_check(filename, O_RDWR, 0);
tmp = pread(fd, rbuf, nrpages*PS, 0);
DEB("parent first read %d [%c,%c]\n", tmp, rbuf[0], rbuf[PS]);
get_semaphore(sem, &sembuf);
if ((pid = fork()) == 0) {
get_semaphore(sem, &sembuf); /* wait parent to dirty page */
p = mmap_check((void *)REFADDR, nrpages * PS,
PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (p != (void *)REFADDR)
err("mmap");
if (nrpages == 1) {
DEB("child read (after dirty) [%c]\n", p[0]);
#ifdef DEBUG
get_pagestat(p, &pgstat);
#endif
} else {
DEB("child read (after dirty) [%c,%c]\n", p[0], p[PS]);
#ifdef DEBUG
get_pagestat(p, &pgstat);
get_pagestat(p+PS, &pgstat);
#endif
}
DEB("child hwpoison to vaddr %p\n", p);
madvise(&p[0], PS, 100); /* hwpoison */
put_semaphore(sem, &sembuf);
get_semaphore(sem, &sembuf);
DEB("child terminated\n");
put_semaphore(sem, &sembuf);
get_pflags(pgstat.pfn, &pflag, 1);
exit(EXIT_SUCCESS);
} else {
DEB("parent dirty\n");
usleep(1000);
memset(wbuf, 49, nrpages * PS);
pwrite(fd, wbuf, nrpages * PS, 0);
tmp = pread(fd, rbuf, nrpages * PS, 0);
DEB("parent second read (after dirty) %d [%c,%c]\n",
tmp, rbuf[0], rbuf[PS]);
put_semaphore(sem, &sembuf); /* kick child to inject error */
get_semaphore(sem, &sembuf); /* pagecache should be hwpoison */
DEB("parent check\n");
if (strcmp(actype, "read") == 0) {
tmp = pread(fd, rbuf, PS, offset);
if (tmp < 0)
DEB("parent first read failed.\n");
tmp = pread(fd, rbuf, PS, offset);
DEB("parent read after hwpoison %d [%c,%c]\n",
tmp, rbuf[0], rbuf[PS]);
if (tmp < 0) {
ret = -1;
perror("read");
} else {
ret = 0;
}
} else if (strcmp(actype, "writefull") == 0) {
memset(wbuf, 50, nrpages * PS);
tmp = pwrite(fd, wbuf, PS, offset);
tmp = pwrite(fd, wbuf, PS, offset);
DEB("parent write after hwpoison %d\n", tmp);
if (tmp < 0) {
ret = -1;
perror("writefull");
} else {
ret = 0;
}
} else if (strcmp(actype, "writepart") == 0) {
memset(wbuf, 50, nrpages * PS);
tmp = pwrite(fd, wbuf, PS / 2, offset);
tmp = pwrite(fd, wbuf, PS / 2, offset);
DEB("parent write after hwpoison %d\n", tmp);
if (tmp < 0) {
ret = -1;
perror("writefull");
} else {
ret = 0;
}
} else if (strcmp(actype, "fsync") == 0) {
ret = fsync(fd);
ret = fsync(fd);
DEB("parent fsync after hwpoison [ret %d]\n", ret);
if (ret)
perror("fsync");
} else if (strcmp(actype, "sync_range_write") == 0) {
ret = sync_file_range(fd, offset, PS, SYNC_FILE_RANGE_WRITE);
ret = sync_file_range(fd, offset, PS, SYNC_FILE_RANGE_WRITE);
if (ret)
perror("sync_range_write");
} else if (strcmp(actype, "sync_range_wait") == 0) {
ret = sync_file_range(fd, offset, PS, SYNC_FILE_RANGE_WAIT_BEFORE);
ret = sync_file_range(fd, offset, PS, SYNC_FILE_RANGE_WAIT_BEFORE);
if (ret)
perror("sync_range_wait");
} else if (strcmp(actype, "mmapread") == 0) {
/*
* If mmap access failed, this program should be
* terminated by segmentation fault with non-zero
* returned value. So we don't set ret here.
*/
p = mmap_check((void *)REFADDR, nrpages * PS,
PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (p != (void *)REFADDR)
err("mmap");
c = p[offset];
DEB("parent mmap() read after hwpoison [%c]\n", p[offset]);
} else if (strcmp(actype, "mmapwrite") == 0) {
p = mmap_check((void *)REFADDR, nrpages * PS,
PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (p != (void *)REFADDR)
err("mmap");
memset(&p[offset], 50, PS);
DEB("parent mmap() write after hwpoison [%c]\n", p[offset]);
}
}
put_semaphore(sem, &sembuf);
waitpid(pid, &wait_status, 0);
if (!WIFEXITED(wait_status))
err("waitpid");
delete_semaphore(sem);
DEB("parent exit %d.\n", ret);
return ret;
}
