| /******************************************************************************* |
| * Copyright (c) 2007 Wind River Systems, Inc. and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Wind River Systems - initial API and implementation |
| *******************************************************************************/ |
| |
| /* |
| * TCF Registers - CPU registers access service. |
| */ |
| |
| #include "config.h" |
| #if SERVICE_Registers |
| |
| #include <stddef.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <assert.h> |
| #include "mdep.h" |
| #include "protocol.h" |
| #include "context.h" |
| #include "json.h" |
| #include "exceptions.h" |
| #include "registers.h" |
| |
| static const char * REGISTERS = "Registers"; |
| |
| #if defined(_WRS_KERNEL) |
| |
| # define regs_index taskRegName |
| # if defined(_WRS_REG_INDEX_REGWIDTH) || (CPU_FAMILY==COLDFIRE) |
| # define REG_WIDTH(x) (x).regWidth |
| # else |
| # define REG_WIDTH(x) 4 |
| # endif |
| |
| #else |
| |
| typedef struct { |
| char *regName; /* pointer to register name */ |
| int regOff; /* offset to entry in REG_SET */ |
| int regWidth; /* register width in bytes */ |
| } REG_INDEX; |
| |
| #define REG_WIDTH(x) (x).regWidth |
| |
| #define REG_OFFSET(name) offsetof(REG_SET, name) |
| |
| #if defined(__i386__) |
| static REG_INDEX regs_index[] = { |
| { "edi", REG_OFFSET(edi), 4}, |
| { "esi", REG_OFFSET(esi), 4}, |
| { "ebp", REG_OFFSET(ebp), 4}, |
| { "esp", REG_OFFSET(esp), 4}, |
| { "ebx", REG_OFFSET(ebx), 4}, |
| { "edx", REG_OFFSET(edx), 4}, |
| { "ecx", REG_OFFSET(ecx), 4}, |
| { "eax", REG_OFFSET(eax), 4}, |
| { "eflags", REG_OFFSET(eflags), 4}, |
| { "eip", REG_OFFSET(eip), 4}, |
| { NULL, 0, 0}, |
| }; |
| |
| #else |
| |
| /* TODO: Linux: support for CPU types other then I86 */ |
| #error "Unknown CPU" |
| |
| #endif |
| |
| #endif /* _WRS_KERNEL */ |
| |
| static short endianess_test = 0x0201; |
| #define BIG_ENDIAN_DATA (*(char *)&endianess_test == 0x02) |
| |
| static void write_context(OutputStream * out, char * id, Context * ctx, REG_INDEX * idx) { |
| assert(!ctx->exited); |
| |
| out->write(out, '{'); |
| |
| json_write_string(out, "ID"); |
| out->write(out, ':'); |
| json_write_string(out, id); |
| |
| out->write(out, ','); |
| json_write_string(out, "ParentID"); |
| out->write(out, ':'); |
| json_write_string(out, thread_id(ctx)); |
| |
| out->write(out, ','); |
| json_write_string(out, "Name"); |
| out->write(out, ':'); |
| json_write_string(out, idx->regName); |
| |
| out->write(out, ','); |
| json_write_string(out, "Readable"); |
| out->write(out, ':'); |
| json_write_boolean(out, 1); |
| |
| out->write(out, ','); |
| json_write_string(out, "Writeable"); |
| out->write(out, ':'); |
| json_write_boolean(out, 1); |
| |
| out->write(out, ','); |
| json_write_string(out, "Formats"); |
| out->write(out, ':'); |
| out->write(out, '['); |
| json_write_string(out, "Hex"); |
| out->write(out, ','); |
| json_write_string(out, "Decimal"); |
| out->write(out, ']'); |
| |
| #if !defined(_WRS_KERNEL) |
| out->write(out, ','); |
| json_write_string(out, "ProcessID"); |
| out->write(out, ':'); |
| json_write_string(out, pid2id(ctx->mem, 0)); |
| #endif |
| |
| out->write(out, ','); |
| json_write_string(out, "BigEndian"); |
| out->write(out, ':'); |
| json_write_boolean(out, BIG_ENDIAN_DATA); |
| |
| out->write(out, '}'); |
| out->write(out, 0); |
| } |
| |
| static int id2register(char * id, Context ** ctx, REG_INDEX ** idx) { |
| int i; |
| char name[64]; |
| *ctx = NULL; |
| *idx = NULL; |
| if (*id++ != 'R') { |
| errno = ERR_INV_CONTEXT; |
| return -1; |
| } |
| i = 0; |
| while (*id != '.') { |
| if (*id == 0) { |
| errno = ERR_INV_CONTEXT; |
| return -1; |
| } |
| name[i++] = *id++; |
| } |
| name[i++] = 0; |
| id++; |
| for (i = 0; regs_index[i].regName != NULL; i++) { |
| if (strcmp(regs_index[i].regName, name) == 0) break; |
| } |
| if (regs_index[i].regName == NULL) { |
| errno = ERR_INV_CONTEXT; |
| return -1; |
| } |
| *ctx = id2ctx(id); |
| *idx = regs_index + i; |
| return 0; |
| } |
| |
| static void command_get_context(char * token, InputStream * inp, OutputStream * out) { |
| int err = 0; |
| char id[256]; |
| Context * ctx = NULL; |
| REG_INDEX * idx = NULL; |
| |
| json_read_string(inp, id, sizeof(id)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| if (inp->read(inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); |
| |
| id2register(id, &ctx, &idx); |
| |
| if (ctx == NULL) err = ERR_INV_CONTEXT; |
| else if (ctx->exited) err = ERR_ALREADY_EXITED; |
| |
| write_stringz(out, "R"); |
| write_stringz(out, token); |
| write_errno(out, err); |
| if (err == 0) { |
| write_context(out, id, ctx, idx); |
| } |
| else { |
| write_stringz(out, "null"); |
| } |
| out->write(out, MARKER_EOM); |
| } |
| |
| static void command_get_children(char * token, InputStream * inp, OutputStream * out) { |
| char id[256]; |
| pid_t pid, parent; |
| |
| json_read_string(inp, id, sizeof(id)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| if (inp->read(inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); |
| |
| pid = id2pid(id, &parent); |
| |
| write_stringz(out, "R"); |
| write_stringz(out, token); |
| |
| write_errno(out, 0); |
| |
| out->write(out, '['); |
| if (pid != 0 && parent != 0) { |
| Context * ctx = context_find_from_pid(pid); |
| if (ctx != NULL) { |
| char t_id[128]; |
| REG_INDEX * idx = regs_index; |
| strcpy(t_id, thread_id(ctx)); |
| while (idx->regName != NULL) { |
| char r_id[128]; |
| if (idx != regs_index) out->write(out, ','); |
| snprintf(r_id, sizeof(r_id), "R%s.%s", idx->regName, t_id); |
| json_write_string(out, r_id); |
| idx ++; |
| } |
| } |
| } |
| out->write(out, ']'); |
| out->write(out, 0); |
| |
| out->write(out, MARKER_EOM); |
| } |
| |
| static void command_get(char * token, InputStream * inp, OutputStream * out) { |
| int err = 0; |
| char id[256]; |
| char fmt[256]; |
| int hex = 0; |
| Context * ctx = NULL; |
| REG_INDEX * idx = NULL; |
| |
| json_read_string(inp, id, sizeof(id)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| json_read_string(inp, fmt, sizeof(fmt)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| if (inp->read(inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); |
| |
| id2register(id, &ctx, &idx); |
| |
| if (ctx == NULL || idx == NULL) err = ERR_INV_CONTEXT; |
| else if (ctx->exited) err = ERR_ALREADY_EXITED; |
| else if (!ctx->intercepted) err = ERR_IS_RUNNING; |
| else if (strcmp(fmt, "Hex") == 0) hex = 1; |
| else if (strcmp(fmt, "Decimal") != 0) err = ERR_INV_FORMAT; |
| |
| write_stringz(out, "R"); |
| write_stringz(out, token); |
| write_errno(out, err); |
| if (err == 0) { |
| int64 n = 0; |
| char val[64]; |
| int val_len = 0; |
| assert(REG_WIDTH(*idx) <= sizeof(n)); |
| memcpy( (char *)&n + (BIG_ENDIAN_DATA ? sizeof(n) - REG_WIDTH(*idx) : 0), |
| (char *)&ctx->regs + idx->regOff, |
| REG_WIDTH(*idx)); |
| if (hex) { |
| while (val_len < REG_WIDTH(*idx) * 2) { |
| int i = (int)(n & 0xf); |
| val[val_len++] = i < 10 ? '0' + i : 'A' + i - 10; |
| n = n >> 4; |
| } |
| } |
| else { |
| int neg = n < 0; |
| uns64 m = neg ? -n : n; |
| do { |
| int i = (int)(m % 10); |
| val[val_len++] = '0' + i; |
| m = m / 10; |
| } |
| while (m != 0); |
| if (neg) val[val_len++] = '-'; |
| } |
| out->write(out, '"'); |
| while (val_len > 0) out->write(out, val[--val_len]); |
| out->write(out, '"'); |
| out->write(out, 0); |
| } |
| else { |
| write_stringz(out, "null"); |
| } |
| out->write(out, MARKER_EOM); |
| } |
| |
| static void send_event_register_changed(OutputStream * out, char * id) { |
| write_stringz(out, "E"); |
| write_stringz(out, REGISTERS); |
| write_stringz(out, "registerChanged"); |
| |
| json_write_string(out, id); |
| out->write(out, 0); |
| |
| out->write(out, MARKER_EOM); |
| } |
| |
| static void command_set(char * token, InputStream * inp, OutputStream * out) { |
| int err = 0; |
| char id[256]; |
| char fmt[256]; |
| char val[256]; |
| int hex = 0; |
| char * ptr = NULL; |
| Context * ctx = NULL; |
| REG_INDEX * idx = NULL; |
| |
| json_read_string(inp, id, sizeof(id)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| json_read_string(inp, fmt, sizeof(fmt)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| json_read_string(inp, val, sizeof(val)); |
| if (inp->read(inp) != 0) exception(ERR_JSON_SYNTAX); |
| if (inp->read(inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX); |
| |
| id2register(id, &ctx, &idx); |
| |
| if (ctx == NULL || idx == NULL) err = ERR_INV_CONTEXT; |
| else if (ctx->exited) err = ERR_ALREADY_EXITED; |
| else if (!ctx->intercepted) err = ERR_IS_RUNNING; |
| else if (strcmp(fmt, "Hex") == 0) hex = 1; |
| else if (strcmp(fmt, "Decimal") != 0) err = ERR_INV_FORMAT; |
| |
| if (err == 0) { |
| int64 n = 0; |
| ptr = val; |
| if (hex) { |
| while (1) { |
| if (*ptr >= '0' && *ptr <= '9') n = (n << 4) | (int64)(*ptr++ - '0'); |
| else if (*ptr >= 'A' && *ptr <= 'F') n = (n << 4) | (int64)(*ptr++ - 'A' + 10); |
| else if (*ptr >= 'a' && *ptr <= 'f') n = (n << 4) | (int64)(*ptr++ - 'a' + 10); |
| else break; |
| } |
| } |
| else { |
| uns64 m = 0; |
| int neg = *ptr == '-'; |
| if (neg) ptr++; |
| while (1) { |
| if (*ptr >= '0' && *ptr <= '9') m = (m * 10) + (uns64)(*ptr++ - '0'); |
| else break; |
| } |
| n = neg ? (~m + 1) : m; |
| } |
| if (*ptr != 0) { |
| err = ERR_INV_NUMBER; |
| } |
| else { |
| assert(REG_WIDTH(*idx) <= sizeof(n)); |
| memcpy( (char *)&ctx->regs + idx->regOff, |
| (char *)&n + (BIG_ENDIAN_DATA ? sizeof(n) - REG_WIDTH(*idx) : 0), |
| REG_WIDTH(*idx)); |
| ctx->regs_dirty = 1; |
| send_event_register_changed(out, id); |
| } |
| } |
| |
| write_stringz(out, "R"); |
| write_stringz(out, token); |
| write_errno(out, err); |
| out->write(out, MARKER_EOM); |
| } |
| |
| void ini_registers_service(void) { |
| add_command_handler(REGISTERS, "getContext", command_get_context); |
| add_command_handler(REGISTERS, "getChildren", command_get_children); |
| add_command_handler(REGISTERS, "get", command_get); |
| add_command_handler(REGISTERS, "set", command_set); |
| } |
| |
| #endif |
| |
