Beispiel #1
0
void serial_irq_handle(void) {
    int UNUSED error;
    error = serial_lock();
    bool got_command = clear_iir();
    error = serial_irq_acknowledge();
    error = serial_unlock();
    if (got_command) {
        handle_gdb(gdb_state);
        error = serial_lock();
        clear_buffer();
        command_wait = false;
        error = serial_unlock();
    }
}
Beispiel #2
0
static int fetch_nodelist(struct motefs_node *nodes)
{
    int n, i, k, op, result, res = 0;
    uint8_t buf[MFS_DATA_SIZE];

    serial_lock();

    if (serial_send(0, MFS_OP_NODELIST, NULL, 0))
    {
        res = -EIO;
        goto ret;
    }

    /* the mote should send exactly `node_count` packets */
    for (i = 0; i < node_count; i++)
    {
        res = serial_receive(&n, &op, &result, buf, sizeof buf);
        if (res == -1 || !result || !(op & MFS_OP_NODELIST))
        {
            res = -1;
            goto ret;
        }

        nodes[n].type = result;
        for (k = 0; k < MFS_DATA_SIZE; k++)
            nodes[n].name[k] = buf[k];
    }

ret:
    serial_unlock();
    if (res < 0)
        return -1;
    return 0;
}
Beispiel #3
0
void pre_init(void) {
    morecore_area = core_buf;
    morecore_size = SERVER_CORE_SIZE;
    serial_lock();
    // Initialize the serial port
    set_dlab(0); // we always assume the dlab is 0 unless we explicitly change it
    disable_interrupt();
    disable_fifo();
    reset_lcr();
    reset_mcr();
    clear_iir();
    set_baud_rate(BAUD_RATE);
    reset_state();
    enable_fifo();
    enable_interrupt();
    clear_iir();
    // all done
    init_colours();
    /* query what getchar clients exist */
    num_getchar_clients = getchar_num_badges();
    getchar_clients = calloc(num_getchar_clients, sizeof(getchar_client_t));
    for (int i = 0; i < num_getchar_clients; i++) {
        unsigned int badge = getchar_enumerate_badge(i);
        assert(badge <= num_getchar_clients);
        getchar_clients[badge].client_id = badge;
        getchar_clients[badge].buf = getchar_buf(badge);
        getchar_clients[badge].last_head = -1;
    }
    set_putchar(serial_putchar);
    serial_irq_reg_callback(serial_irq, 0);
    /* Start regular heartbeat of 500ms */
    timeout_periodic(0, 500000000);
    serial_unlock();
}
Beispiel #4
0
static void timer_callback(void *data) {
    serial_lock();
    if (done_output) {
        done_output = 0;
    } else if (has_data) {
        /* flush everything if no writes since last callback */
        int i;
        for (i = 0; i < VM_NUM_GUESTS * 2; i++) {
            flush_buffer(i);
        }
    }
    serial_unlock();
}
Beispiel #5
0
static void internal_putchar(int b, int c) {
    serial_lock();
    /* Add to buffer */
    int index = output_buffers_used[b];
    uint8_t *buffer = output_buffers[b];
    buffer[index] = (uint8_t)c;
    output_buffers_used[b]++;
    if (index + 1 == GUEST_OUTPUT_BUFFER_SIZE || (index >= 1 && is_newline(buffer + index - 1)) || last_out == b) {
        flush_buffer(b);
    }
    has_data = 1;
    serial_unlock();
}
Beispiel #6
0
void gdb_printf(const char *format, ...) {
    va_list arg;
    char text_buf[MAX_PRINTF_LENGTH];
    va_start(arg, format);
    vsnprintf(text_buf, MAX_PRINTF_LENGTH, format, arg);
    va_end(arg);
    int UNUSED error;
    error = serial_lock();
    for (int i = 0; i < strlen(text_buf); i++) {
        serial_putchar(text_buf[i]);
    }
    error = serial_unlock();
}
Beispiel #7
0
void serial_init(gdb_state_t *gdb) {
    // Initialize the serial port
    int UNUSED error;
    error = serial_lock();
    gdb_state = gdb;
    set_dlab(0); // we always assume the dlab is 0 unless we explicitly change it
    disable_interrupt();
    disable_fifo();
    reset_lcr();
    reset_mcr();
    clear_iir();
    set_baud_rate(BAUD_RATE);
    reset_state();
    enable_fifo();
    enable_interrupt();
    clear_iir();
    initialise_buffer();
    error = serial_unlock();

}
Beispiel #8
0
static int fetch_nodecount(int *count)
{
    int op, result, res = 0;

    serial_lock();

    res = serial_send(0, MFS_OP_NODECOUNT, NULL, 0);
    if (res == -1)
        goto ret;

    res = serial_receive(NULL, &op, &result, NULL, 0);
    if (res == -1 || !result || op != MFS_OP_NODECOUNT)
    {
        res = -EIO;
        goto ret;
    }

    *count = result;
    res = 0;

ret:
    serial_unlock();
    return res;
}
Beispiel #9
0
static int op_write(const char *path, const char *buf, size_t size,
                    off_t offset, struct fuse_file_info *fi)
{
    (void) fi;
    (void) offset;

    int n, op, result, res = 0;
    uint8_t data[MFS_DATA_SIZE];

    size_t i, len;
    char line[MFS_DATA_SIZE];

    n = get_node(path);

    if (n == -1)
        return -ENOENT;

    /* copy one line without '\n' to temporary buffer
     * (and truncate it if too long) */
    for (i = 0; i < MFS_DATA_SIZE - 1 && i < size && buf[i] != '\n'; i++)
        line[i] = buf[i];
    line[i] = '\0';
    len = i;


    /* convert the line to appropriate format which can be send as a serial
     * packet */
    if (nodes[n].type & MFS_BOOL)
    {
        if (!strcmp(line, "true"))
            data[0] = 1;
        else if (!strcmp(line, "false"))
            data[0] = 0;
        else
            data[0] = atoi(line) != 0;
        len = 1;
    }
    else if (nodes[n].type & MFS_INT)
    {
        int64_t val = atoll(line);
        len = pack(data, "l", val);
    }
    else if (nodes[n].type & MFS_STR)
    {
        unsigned i;
        for (i = 0; i < len; i++)
            data[i] = line[i];
        data[len] = '\0';
    }

    serial_lock();

    if (serial_send(n, MFS_OP_WRITE, data, len))
    {
        res = -EIO;
        goto ret;
    }

    res = serial_receive(NULL, &op, &result, NULL, 0);
    if (res == -1 || !result || op != MFS_OP_WRITE)
    {
        res = -EIO;
        goto ret;
    }

ret:
    serial_unlock();
    if (!res)
        return size;
    return res;
}
Beispiel #10
0
static int op_read(const char *path, char *buf, size_t size, off_t offset,
                   struct fuse_file_info *fi)
{
    (void) fi;
    (void) offset;

    int n, i, op, result, res = 0;
    uint8_t data[MFS_DATA_SIZE];

    n = get_node(path);

    if (n == -1)
        return -ENOENT;

    if (size <= MFSMSG_SIZE)
        return -EIO;

    serial_lock();

    if (serial_send(n, MFS_OP_READ, NULL, 0))
    {
        res = -EIO;
        goto ret;
    }

    res = serial_receive(NULL, &op, &result, data, sizeof data);
    if (res == -1 || !result || op != MFS_OP_READ)
    {
        res = -EIO;
        goto ret;
    }

    /* format reply */
    switch (MFS_TYPE(nodes[n].type))
    {
    case MFS_BOOL:
        strcpy(buf, (*data) ? "1" : "0");
        break;

    case MFS_INT:
    {
        int64_t val;
        unpack(data, "l", &val);
        sprintf(buf, "%" PRIi64, val);
    }
    break;

    case MFS_STR:
        for (i = 0; i < MFS_DATA_SIZE - 1; i++)
            buf[i] = data[i];
        buf[i] = '\0';
        break;
    }

    /* add a newline because that looks better */
    strcat(buf, "\n");
    res = strlen(buf);

ret:
    serial_unlock();
    return res;
}
Beispiel #11
0
static void serial_irq(void *cookie) {
    serial_lock();
    clear_iir();
    serial_irq_reg_callback(serial_irq, cookie);
    serial_unlock();
}