TEE_Result TA_InvokeCommandEntryPoint(void *pSessionContext,
uint32_t nCommandID, uint32_t nParamTypes,
TEE_Param pParams[TEE_NUM_PARAMS])
{
(void)pSessionContext;
switch (nCommandID) {
case TA_SDP_BASIC_CMD_INJECT:
return cmd_inject(nParamTypes, pParams);
case TA_SDP_BASIC_CMD_TRANSFORM:
return cmd_transform(nParamTypes, pParams);
case TA_SDP_BASIC_CMD_DUMP:
return cmd_dump(nParamTypes, pParams);
case TA_SDP_BASIC_CMD_INVOKE_INJECT:
return cmd_invoke(nParamTypes, pParams, TA_SDP_BASIC_CMD_INJECT);
case TA_SDP_BASIC_CMD_INVOKE_TRANSFORM:
return cmd_invoke(nParamTypes, pParams, TA_SDP_BASIC_CMD_TRANSFORM);
case TA_SDP_BASIC_CMD_INVOKE_DUMP:
return cmd_invoke(nParamTypes, pParams, TA_SDP_BASIC_CMD_DUMP);
case TA_SDP_BASIC_CMD_PTA_INJECT:
return cmd_invoke_pta(nParamTypes, pParams, PTA_INVOKE_TESTS_CMD_COPY_NSEC_TO_SEC);
case TA_SDP_BASIC_CMD_PTA_TRANSFORM:
return cmd_invoke_pta(nParamTypes, pParams, PTA_INVOKE_TESTS_CMD_READ_MODIFY_SEC);
case TA_SDP_BASIC_CMD_PTA_DUMP:
return cmd_invoke_pta(nParamTypes, pParams, PTA_INVOKE_TESTS_CMD_COPY_SEC_TO_NSEC);
default:
return TEE_ERROR_BAD_PARAMETERS;
}
}
int main(int argc, char** argv)
{
if(argc < 2) {
print_help();
return 1;
}
const char* const command = argv[1];
const char** const cargv = const_quirk(argv);
if(IS_CMD("decode-all", 1)) {
return cmd_get_all_and_decode(argv + 2, argc - 2);
}
else if(IS_CMD("decode", 2)) {
return cmd_decode(argv[2], cargv + 3, argc - 3);
}
else if(IS_CMD("append-all", 2)) {
return cmd_append_all(argv[2], argv[3]);
}
else if(IS_CMD("recode", 3)) {
return cmd_recode(argv[2], argv[3], cargv + 4, argc - 4);
}
else if(IS_CMD("info", 1)) {
return cmd_info(argv[2]);
}
else if(IS_CMD("dump", 1)) {
return cmd_dump(argv[2]);
}
else {
print_help();
return 1;
}
return 0;
}
static int red_cmd(char *cmd) {
char *arg = cmd+1;
SKIPSPACES(arg);
switch(*cmd) {
case 'q':
return 0;
case ';':
case '#':
break; // comment
case '>':
return cmd_dump(arg);
break;
case '<':
return cmd_load(arg);
break;
case '.':
return red_interpret(arg);
break;
case 's':
return cmd_seek(arg);
break;
case 'b':
return cmd_bsize(arg);
break;
case '/':
return cmd_search(arg);
break;
case 'd':
return cmd_system ("echo X | ired -n $BLOCK | rasm2 -o $OFFSET -D - |head -n $(($LINES-1))");
case 'p':
return cmd_print(arg);
break;
case 'r':
return cmd_resize(arg);
break;
case 'x':
return cmd_hexdump(arg);
break;
case 'X':
return cmd_bytedump(arg);
break;
case 'w':
return cmd_write(arg);
break;
case '!':
return cmd_system(arg);
break;
case 'V':
return cmd_system("vired $FILE");
break;
case '?':
return cmd_help(arg);
break;
default:
fprintf(stderr, "? %s\n", cmd);
}
return 1;
}
int main(int argc, char *argv[]) {
if (argc != 2) {
printf("usage: %s trace_file\n", argv[0]);
exit(1);
}
int result = trace_open(argv[1]);
if (result == -1) {
printf("%s: could not open %s\n", argv[0], argv[1]);
exit(1);
}
printf("number of ATMs: %d\n", trace_atm_count());
printf("number of accounts: %d\n", trace_account_count());
byte cmd[MESSAGE_SIZE];
while (trace_read_cmd(cmd) != 0) {
cmd_dump("TREADER", 0, cmd);
}
trace_close();
return 0;
}
/** cmd_runprompt
*
* Determine what the user input is and run
*
* @param mach A pointer to the lc3 simulator
* @param prompt A pointer to the string the user provided
* @param lastCommand The last command index to be run
*/
void cmd_runprompt(lc3machine* mach, char * prompt)
{
// copy prompt
char promptCopy[30];
strcpy(promptCopy, prompt);
// break appart command by spaces
char * command;
command = strtok(promptCopy, " ");
// check if command is a quit
if (strcmp(command, "quit") == 0 || strcmp(command, "q") == 0)
exit(0);
// check if command is to step
else if (strcmp(command, "step") == 0 || strcmp(command, "s") == 0) {
// get number of lines to step
command = strtok(NULL, " ");
int lines = command == NULL ? 1 : atoi(command);
lc3_run(mach, lines);
}
// check if command is continue
else if (strcmp(command, "continue") == 0 || strcmp(command, "c") == 0 || strcmp(command, "run") == 0) {
lc3_run(mach, -1);
}
// check if want the registers
else if (strcmp(command, "registers") == 0 || strcmp(command, "r") == 0) {
cmd_registers(mach);
}
// check if command is to dump memory
else if (strcmp(command, "dump") == 0) {
// check if the command is valid
if ((command = strtok(NULL, " ")) == NULL) {
printf("ERR: Input invalid: Starting memory index required\n");
return;
}
// get starting location
char * pEnd;
int dumpStart = (int) strtol(command, &pEnd, 16);
// get ending locaiton
command = strtok(NULL, " ");
int dumpEnd = command == NULL ? dumpStart : ((int) strtol(command, &pEnd, 16));
// dump the core
cmd_dump(mach, dumpStart, dumpEnd);
}
// check if command is to set memory
else if (strcmp(command, "setaddr") == 0) {
// check if the command is valid
if ((command = strtok(NULL, " ")) == NULL) {
printf("ERR: Input invalid: Memory address required\n");
return;
}
// get address
char * pEnd;
int address = (int) strtol(command, &pEnd, 16);
// check if the command is valid
if ((command = strtok(NULL, " ")) == NULL) {
printf("ERR: Input invalid: Memory value required\n");
return;
}
// set value
cmd_setaddr(mach, address, atoi(command));
}
// check if command is to set memory
else if (strcmp(command, "setreg") == 0) {
// check if the command is valid
if ((command = strtok(NULL, " ")) == NULL) {
printf("ERR: Input invalid: Register number required\n");
return;
}
// get register
int reg = atoi(command + 1);
// check if the command is valid
if ((command = strtok(NULL, " ")) == NULL) {
printf("ERR: Input invalid: Register value required\n");
return;
}
// set value
cmd_setreg(mach, reg, atoi(command));
}
// check if command is for help
else if (strcmp(command, "help") == 0) {
printf("step [n]\n\tExecutes n instructions (n defaults to 1)\nquit\n\tQuits the simulator\ncontinue\n\tRuns until the program halts\nregisters\n\tPrints all registers, pc, and cc values\ndump start [end]\n\tDumps the contents of memory from the starting address to the end (if not provided will just print one value)\nsetaddr addr value\n\tSets the value at the provided address\nsetreg Rn value\n\tSets register n with the provided value\nhelp\n\tDisplays this menu\n");
}
// command not found
else
printf("ERR: Input invalid. Type 'help' for a list of instructions\n");
}
void process_input(int* needs_refresh, const char *str, int fd, void (*cb)(int fd, const char *data, size_t len))
{
static unsigned lcore_id, task_id, nb_packets, val, id,
port, queue, rate, ip[4], prefix, next_hop_idx,
interface, gre_id, svlan, cvlan, mac[6], user;
unsigned count;
float speed;
uint32_t pkt_size;
static char mode[20];
struct rte_ring *ring;
unsigned short offset;
uint32_t value;
uint8_t value_len;
if (strcmp(str, "quit") == 0) {
plog_info("Leaving...\n");
stop_core_all();
stop_dppd = 1;
}
else if (sscanf(str, "dump %u %u %u", &lcore_id, &task_id, &nb_packets) == 3) {
if (lcore_id >= RTE_MAX_LCORE) {
plog_err("Invalid core id %u (lcore ID above %d)\n", lcore_id, RTE_MAX_LCORE);
}
else if (!dppd_core_active(lcore_id, 0)) {
plog_err("Invalid core id %u (lcore is not active)\n", lcore_id);
}
else {
cmd_dump(lcore_id, task_id, nb_packets);
}
}
else if (sscanf(str, "rate %u %u %u", &queue, &port, &rate) == 3) {
if (port > DPPD_MAX_PORTS) {
plog_err("Max port id allowed is %u (specified %u)\n", DPPD_MAX_PORTS, port);
}
else if (!dppd_port_cfg[port].active) {
plog_err("Port %u not active\n", port);
}
else if (queue >= dppd_port_cfg[port].n_txq) {
plog_err("Number of active queues is %u\n",
dppd_port_cfg[port].n_txq);
}
else if (rate > dppd_port_cfg[port].link_speed) {
plog_err("Max rate allowed on port %u queue %u is %u Mbps\n",
port, queue, dppd_port_cfg[port].link_speed);
}
else {
if (rate == 0) {
plog_info("Disabling rate limiting on port %u queue %u\n",
port, queue);
}
else {
plog_info("Setting rate limiting to %u Mbps on port %u queue %u\n",
rate, port, queue);
}
rte_eth_set_queue_rate_limit(port, queue, rate);
}
}
else if (sscanf(str, "count %u %u %u", &lcore_id, &task_id, &count) == 3) {
if (check_core_task(lcore_id, task_id)) {
if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen")) {
plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
}
else {
((struct task_gen *)lcore_cfg[lcore_id].task[task_id])->pkt_count = count;
plog_info("Core %u task %u stopping after %u packets\n", lcore_id, task_id, count);
}
}
}
else if (sscanf(str, "pkt_size %u %u %d", &lcore_id, &task_id, &pkt_size) == 3) {
if (check_core_task(lcore_id, task_id)) {
if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen")) {
plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
}
else if (pkt_size > 1514 || pkt_size < 34) { // 34 for 14 + 20 (MAC, EtherType and IP)
plog_err("pkt_size out of range (must be betweeen 34 and 1514)\n");
}
else {
((struct task_gen *)lcore_cfg[lcore_id].task[task_id])->pkt_size = pkt_size;
plog_info("Setting pkt_size to %u \n", pkt_size);
}
}
}
else if (sscanf(str, "speed %u %u %f", &lcore_id, &task_id, &speed) == 3) {
if (check_core_task(lcore_id, task_id)) {
if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen")) {
plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
}
else if (speed > 100.0f || speed < 0.0f) {
plog_err("Speed out of range (must be betweeen 0%% and 100%%)\n");
}
else {
uint64_t bps = speed * 12500000;
((struct task_gen *)lcore_cfg[lcore_id].task[task_id])->rate_bps = bps;
plog_info("Setting rate to %"PRIu64" Bps\n", bps);
}
}
}
else if (sscanf(str, "speed_byte %u %u %u", &lcore_id, &task_id, &value) == 3) {
if (check_core_task(lcore_id, task_id)) {
if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen")) {
plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
}
else if (value > 1250000000) {
plog_err("Speed out of range (must be <= 1250000000)\n");
}
else {
((struct task_gen *)lcore_cfg[lcore_id].task[task_id])->rate_bps = value;
plog_info("Setting rate to %"PRIu32" Bps\n", value);
}
}
}
else if (strcmp(str, "reset values all") == 0) {
lcore_id = -1;
while (dppd_core_next(&lcore_id, 0) == 0) {
for (task_id = 0; task_id < lcore_cfg[lcore_id].nb_tasks; task_id++) {
if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen") == 0) {
struct task_gen *task = ((struct task_gen *)lcore_cfg[lcore_id].task[task_id]);
plog_info("Resetting values on core %d task %d from %d values\n", lcore_id, task_id, task->n_values);
task->n_values = 0;
}
}
}
}
else if (sscanf(str, "reset values %u %u", &lcore_id, &task_id) == 2) {
if (check_core_task(lcore_id, task_id)) {
if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen")) {
plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
}
else {
struct task_gen *task = ((struct task_gen *)lcore_cfg[lcore_id].task[task_id]);
plog_info("Resetting values on core %d task %d from %d values\n", lcore_id, task_id, task->n_values);
task->n_values = 0;
}
}
}
else if (sscanf(str, "set value %u %u %hu %u %hhu", &lcore_id, &task_id, &offset, &value, &value_len) == 5) {
if (check_core_task(lcore_id, task_id)) {
if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen")) {
plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
}
else if (offset > ETHER_MAX_LEN) {
plog_err("Offset out of range (must be less then %u)\n", ETHER_MAX_LEN);
}
else if (value_len > 4) {
plog_err("Length out of range (must be less then 4)\n");
}
else {
struct task_gen *task = ((struct task_gen *)lcore_cfg[lcore_id].task[task_id]);
if (task->n_values >= 64) {
plog_info("Unable to set Byte %"PRIu16" to %"PRIu8" - too many value set\n", offset, value);
}
else {
task->value[task->n_values] = rte_cpu_to_be_32(value) >> ((4 - value_len) * 8);
task->offset[task->n_values] = offset;
task->value_len[task->n_values] = value_len;
task->n_values++;
plog_info("Setting Byte %"PRIu16" to %"PRIu32"\n", offset, value);
}
}
}
}
else if (sscanf(str, "thread info %u %u", &lcore_id, &task_id) == 2) {
