void SharedRendezvous::wait() {
if (is_signaled_weak()) { // just an optimization.
return;
}
uint64_t demand = cond_.acquire_ticket();
if (is_signaled()) {
return;
}
cond_.wait(demand);
ASSERT_ND(is_signaled());
}
bool SharedRendezvous::wait_for(uint64_t timeout_nanosec) {
if (is_signaled_weak()) { // just an optimization.
return true;
}
uint64_t demand = cond_.acquire_ticket();
if (is_signaled()) {
return true;
}
bool received = cond_.timedwait(demand, timeout_nanosec / 1000);
ASSERT_ND(!received || is_signaled());
return is_signaled();
}
/*******************************************************************************
**
** Function select_read
**
** Description check if fd is ready for reading and listen for termination
** signal. need to use select in order to avoid collision
** between read and close on the same fd
**
** Returns -1: termination
** >=0: numbers of bytes read back from fd
**
*******************************************************************************/
static int select_read(int fd, uint8_t *pbuf, int len)
{
fd_set input;
int n = 0, ret = -1;
char reason = 0;
while (userial_running)
{
/* Initialize the input fd set */
FD_ZERO(&input);
if (rx_flow_on == TRUE)
{
FD_SET(fd, &input);
}
int fd_max = create_signal_fds(&input);
fd_max = fd_max > fd ? fd_max : fd;
/* Do the select */
n = select(fd_max+1, &input, NULL, NULL, NULL);
if(is_signaled(&input))
{
reason = reset_signal();
if (reason == USERIAL_RX_EXIT)
{
USERIALDBG("RX termination");
return -1;
}
else if (reason == USERIAL_RX_FLOW_OFF)
{
USERIALDBG("RX flow OFF");
rx_flow_on = FALSE;
}
else if (reason == USERIAL_RX_FLOW_ON)
{
USERIALDBG("RX flow ON");
rx_flow_on = TRUE;
}
}
if (n > 0)
{
/* We might have input */
if (FD_ISSET(fd, &input))
{
ret = read(fd, pbuf, (size_t)len);
if (0 == ret)
ALOGW( "read() returned 0!" );
return ret;
}
}
else if (n < 0)
ALOGW( "select() Failed");
else if (n == 0)
ALOGW( "Got a select() TIMEOUT");
}
return ret;
}
int main(int argc, char *argv[])
{
char *inputs[] = {
"(lambda (x) (return x))",
};
init_global_variable();
init_prims();
init_primitive_opcode();
init_macros();
load_init_file();
for (int i = 0; i < sizeof(inputs) / sizeof(char *); i++) {
write_raw_string(">> ", standard_out);
write_raw_string(inputs[i], standard_out);
write_raw_char('\n', standard_out);
lisp_object_t *expr = read_object_from_string(strdup(inputs[i]));
expr = compile_to_bytecode(expr);
if (is_signaled(expr))
writef(standard_out, "%?\n", expr);
else
writef(standard_out, "=> %?\n", expr);
}
return 0;
}
static void read_file_test(void)
{
const char text[] = "foobar";
HANDLE handle, read, write;
NTSTATUS status;
IO_STATUS_BLOCK iosb;
DWORD written;
int apc_count = 0;
char buffer[128];
LARGE_INTEGER offset;
HANDLE event = CreateEventA( NULL, TRUE, FALSE, NULL );
buffer[0] = 1;
if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
/* try read with no data */
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
ok( is_signaled( read ), "read handle is not signaled\n" );
status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
ok( status == STATUS_PENDING, "wrong status %x\n", status );
ok( !is_signaled( read ), "read handle is signaled\n" );
ok( !is_signaled( event ), "event is signaled\n" );
ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
ok( !apc_count, "apc was called\n" );
WriteFile( write, buffer, 1, &written, NULL );
/* iosb updated here by async i/o */
Sleep(1); /* FIXME: needed for wine to run the i/o apc */
ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
ok( !is_signaled( read ), "read handle is signaled\n" );
ok( is_signaled( event ), "event is not signaled\n" );
ok( !apc_count, "apc was called\n" );
apc_count = 0;
SleepEx( 1, FALSE ); /* non-alertable sleep */
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc not called\n" );
/* with no event, the pipe handle itself gets signaled */
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
ok( !is_signaled( read ), "read handle is not signaled\n" );
status = pNtReadFile( read, 0, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
ok( status == STATUS_PENDING, "wrong status %x\n", status );
ok( !is_signaled( read ), "read handle is signaled\n" );
ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
ok( !apc_count, "apc was called\n" );
WriteFile( write, buffer, 1, &written, NULL );
/* iosb updated here by async i/o */
Sleep(1); /* FIXME: needed for wine to run the i/o apc */
ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
ok( is_signaled( read ), "read handle is signaled\n" );
ok( !apc_count, "apc was called\n" );
apc_count = 0;
SleepEx( 1, FALSE ); /* non-alertable sleep */
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc not called\n" );
/* now read with data ready */
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
ResetEvent( event );
WriteFile( write, buffer, 1, &written, NULL );
status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
ok( status == STATUS_SUCCESS, "wrong status %x\n", status );
ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
ok( is_signaled( event ), "event is not signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, FALSE ); /* non-alertable sleep */
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc not called\n" );
/* try read with no data */
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
ok( is_signaled( event ), "event is not signaled\n" ); /* check that read resets the event */
status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
ok( status == STATUS_PENDING, "wrong status %x\n", status );
ok( !is_signaled( event ), "event is signaled\n" );
ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
ok( !apc_count, "apc was called\n" );
WriteFile( write, buffer, 1, &written, NULL );
/* partial read is good enough */
Sleep(1); /* FIXME: needed for wine to run the i/o apc */
ok( is_signaled( event ), "event is signaled\n" );
ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
/* read from disconnected pipe */
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
CloseHandle( write );
status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
ok( status == STATUS_PIPE_BROKEN, "wrong status %x\n", status );
ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
ok( !is_signaled( event ), "event is signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( !apc_count, "apc was called\n" );
CloseHandle( read );
/* read from closed handle */
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
SetEvent( event );
status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
ok( status == STATUS_INVALID_HANDLE, "wrong status %x\n", status );
ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
ok( is_signaled( event ), "event is signaled\n" ); /* not reset on invalid handle */
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( !apc_count, "apc was called\n" );
/* disconnect while async read is in progress */
if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
ok( status == STATUS_PENDING, "wrong status %x\n", status );
ok( !is_signaled( event ), "event is signaled\n" );
ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
ok( !apc_count, "apc was called\n" );
CloseHandle( write );
Sleep(1); /* FIXME: needed for wine to run the i/o apc */
ok( U(iosb).Status == STATUS_PIPE_BROKEN, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
ok( is_signaled( event ), "event is signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
CloseHandle( read );
/* now try a real file */
if (!(handle = create_temp_file( FILE_FLAG_OVERLAPPED ))) return;
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
offset.QuadPart = 0;
ResetEvent( event );
pNtWriteFile( handle, event, apc, &apc_count, &iosb, text, strlen(text), &offset, NULL );
ok( status == STATUS_PENDING, "wrong status %x\n", status );
ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
ok( is_signaled( event ), "event is signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
offset.QuadPart = 0;
ResetEvent( event );
status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, strlen(text) + 10, &offset, NULL );
ok( status == STATUS_SUCCESS, "wrong status %x\n", status );
ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
ok( is_signaled( event ), "event is signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
/* read beyond eof */
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
offset.QuadPart = strlen(text) + 2;
status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, &offset, NULL );
ok( status == STATUS_END_OF_FILE, "wrong status %x\n", status );
ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
ok( !is_signaled( event ), "event is signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( !apc_count, "apc was called\n" );
CloseHandle( handle );
/* now a non-overlapped file */
if (!(handle = create_temp_file(0))) return;
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
offset.QuadPart = 0;
pNtWriteFile( handle, event, apc, &apc_count, &iosb, text, strlen(text), &offset, NULL );
ok( status == STATUS_END_OF_FILE, "wrong status %x\n", status );
ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
ok( is_signaled( event ), "event is signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
offset.QuadPart = 0;
ResetEvent( event );
status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, strlen(text) + 10, &offset, NULL );
ok( status == STATUS_SUCCESS, "wrong status %x\n", status );
ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
ok( is_signaled( event ), "event is signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
todo_wine ok( !apc_count, "apc was called\n" );
/* read beyond eof */
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
offset.QuadPart = strlen(text) + 2;
ResetEvent( event );
status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, &offset, NULL );
ok( status == STATUS_END_OF_FILE, "wrong status %x\n", status );
todo_wine ok( U(iosb).Status == STATUS_END_OF_FILE, "w
/*******************************************************************************
**
** Function userial_evt_read_thread
**
** Description The reading thread on EVT and ACL_IN channels
**
** Returns void *
**
*******************************************************************************/
static void *userial_read_thread(void *arg)
{
fd_set input;
int n;
char reason = 0;
USERIALDBG("Entering userial_read_thread()");
rx_flow_on = TRUE;
userial_running = 1;
raise_priority_a2dp(TASK_HIGH_USERIAL_READ);
while (userial_running)
{
/* Initialize the input fd set */
FD_ZERO(&input);
if (rx_flow_on == TRUE)
{
FD_SET(userial_cb.fd[CH_EVT], &input);
FD_SET(userial_cb.fd[CH_ACL_IN], &input);
}
int fd_max = create_signal_fds(&input);
fd_max = (fd_max>userial_cb.fd[CH_EVT]) ? fd_max : userial_cb.fd[CH_EVT];
fd_max = (fd_max>userial_cb.fd[CH_ACL_IN]) ? fd_max : userial_cb.fd[CH_ACL_IN];
/* Do the select */
n = 0;
n = select(fd_max+1, &input, NULL, NULL, NULL);
if(is_signaled(&input))
{
reason = reset_signal();
if (reason == USERIAL_RX_EXIT)
{
ALOGI("exiting userial_read_thread");
userial_running = 0;
break;
}
else if (reason == USERIAL_RX_FLOW_OFF)
{
USERIALDBG("RX flow OFF");
rx_flow_on = FALSE;
}
else if (reason == USERIAL_RX_FLOW_ON)
{
USERIALDBG("RX flow ON");
rx_flow_on = TRUE;
}
}
if (n > 0)
{
/* We might have input */
if (FD_ISSET(userial_cb.fd[CH_EVT], &input))
{
hci_mct_receive_evt_msg();
}
if (FD_ISSET(userial_cb.fd[CH_ACL_IN], &input))
{
hci_mct_receive_acl_msg();
}
}
else if (n < 0)
ALOGW( "select() Failed");
else if (n == 0)
ALOGW( "Got a select() TIMEOUT");
} /* while */
userial_running = 0;
USERIALDBG("Leaving userial_evt_read_thread()");
pthread_exit(NULL);
return NULL; // Compiler friendly
}
