static void
protocol_entry (unsigned char type, gpointer data, int size)
{
int index;
BinaryProtocolBuffer *buffer;
if (!binary_protocol_file)
return;
lock_recursive ();
retry:
buffer = binary_protocol_get_buffer (size + 1);
retry_same_buffer:
index = buffer->index;
if (index + 1 + size > BINARY_PROTOCOL_BUFFER_SIZE)
goto retry;
if (InterlockedCompareExchange (&buffer->index, index + 1 + size, index) != index)
goto retry_same_buffer;
/* FIXME: if we're interrupted at this point, we have a buffer
entry that contains random data. */
buffer->buffer [index++] = type;
memcpy (buffer->buffer + index, data, size);
index += size;
g_assert (index <= BINARY_PROTOCOL_BUFFER_SIZE);
unlock_recursive ();
}
void op_display(enum op_severity sev, enum op_module mod, uint16_t code)
{
uint32_t w0 = sev << 16 | mod;
uint32_t w1;
bool clean_lock;
if (!fsp_present())
return;
w1 = tohex((code >> 12) & 0xf) << 24;
w1 |= tohex((code >> 8) & 0xf) << 16;
w1 |= tohex((code >> 4) & 0xf) << 8;
w1 |= tohex((code ) & 0xf);
/*
* We use lock_recursive to detect recursion. We avoid sending
* the message if that happens as this could be a case of a
* locking error in the FSP driver for example
*/
clean_lock = lock_recursive(&op_lock);
if (!clean_lock)
return;
/* We don't use mkmsg, we use a preallocated msg to avoid
* going down the malloc path etc... since this can be called
* in case of fatal errors
*/
fsp_fillmsg(&op_msg, FSP_CMD_DISP_SRC_DIRECT, 3, 1, w0, w1);
fsp_sync_msg(&op_msg, false);
unlock(&op_lock);
}
ssize_t read(int fd __unused, void *buf, size_t req_count)
{
bool need_unlock = lock_recursive(&con_lock);
size_t count = 0;
if (con_driver && con_driver->read)
count = con_driver->read(buf, req_count);
if (!count)
count = inmem_read(buf, req_count);
if (need_unlock)
unlock(&con_lock);
return count;
}
ssize_t console_write(bool flush_to_drivers, const void *buf, size_t count)
{
/* We use recursive locking here as we can get called
* from fairly deep debug path
*/
bool need_unlock = lock_recursive(&con_lock);
const char *cbuf = buf;
while(count--) {
char c = *(cbuf++);
if (c == 10)
write_char(13);
write_char(c);
}
__flush_console(flush_to_drivers);
if (need_unlock)
unlock(&con_lock);
return count;
}
static void
protocol_entry (unsigned char type, gpointer data, int size)
{
#ifdef HAVE_UNISTD_H
int index;
BinaryProtocolBuffer *buffer;
if (binary_protocol_file == -1)
return;
if (sgen_thread_pool_is_thread_pool_thread (mono_native_thread_id_get ()))
type |= 0x80;
lock_recursive ();
retry:
buffer = binary_protocol_get_buffer (size + 1);
retry_same_buffer:
index = buffer->index;
if (index + 1 + size > BINARY_PROTOCOL_BUFFER_SIZE)
goto retry;
if (InterlockedCompareExchange (&buffer->index, index + 1 + size, index) != index)
goto retry_same_buffer;
/* FIXME: if we're interrupted at this point, we have a buffer
entry that contains random data. */
buffer->buffer [index++] = type;
memcpy (buffer->buffer + index, data, size);
index += size;
g_assert (index <= BINARY_PROTOCOL_BUFFER_SIZE);
unlock_recursive ();
#endif
}
