temp

tinios的 源码

    }
  }
  
  task void SendTask() {
    call computeInstruction(&sendContext);
    if (sendContext.state == BOMB_STATE_RUN) {
      dbg(DBG_USR1, "VM: Posting SendTask in task.\n");
      post SendTask();
    }
  }
  
  task void RecvTask() {
    call computeInstruction(&recvContext);
    if (recvContext.state == BOMB_STATE_RUN) {
      post RecvTask();
    }
  }
  /*
  task void OnceTask() {
    call computeInstruction(&onceContext);
    if (onceContext.state == BOMB_STATE_RUN) {
      post OnceTask();
    }
  }
  */
  command result_t executeContext(BombillaContext* context) {
    dbg(DBG_USR1, "VM: At beginning of execCon.\n");
    if (context->state != BOMB_STATE_RUN) {return FAIL;}
    switch(context->which) {
    case BOMB_CAPSULE_CLOCK:
      dbg(DBG_USR1, "VM: Posting ClockTask in execCon.\n");
      return post ClockTask();
      dbg(DBG_USR1, "VM: Posted ClockTask.\n");
      //return SUCCESS;
      dbg(DBG_USR1, "VM: after return.\n");
      break;
      dbg(DBG_USR1, "VM: after break.\n");
    case BOMB_CAPSULE_SEND:
      dbg(DBG_USR1, "VM: Posting SendTask in execCon.\n");
      post SendTask();
      return SUCCESS;
      break;
    case BOMB_CAPSULE_RECV:
      post RecvTask();
      return SUCCESS;
      break;
      /*
        case BOMB_CAPSULE_ONCE:
        return post OnceTask();
        case BOMB_CAPSULE_OUTER: */
    default:
      dbg(DBG_ERROR, "VM: Tried to run context not yet supported: %i\n", context->which);
      return FAIL;
    }
    dbg(DBG_USR1, "VM: At end of execCon.\n");
    return FAIL;
  }

  command result_t alertSendContext(BombillaContext* caller,
                                    BombillaStackVariable* arg) {
    if (sendContext.state == BOMB_STATE_HALT) {
      nmemcpy(&state.sendrBuffer, arg->buffer.var, sizeof(BombillaDataBuffer));
      call Synch.initializeContext(&sendContext, &state);
      call Stacks.pushBuffer(&sendContext, &state.sendrBuffer);
      dbg(DBG_USR1, "VM: Calling resumeCon for sendContext in alertSend. \n");
      call Synch.resumeContext(caller, &sendContext, &(state.readyQueue), state.locks);
      // This yield/resume allows locks to be yielded to the send context,
      // and if none are shared, then it will just continue executing
      if (caller->releaseSet) {
        call Synch.releaseLocks(caller, caller, state.locks);
        call Synch.yieldContext(caller, &(state.readyQueue), state.locks);
        //call Synch.resumeContext(caller, caller, &(state.readyQueue), state.locks);
      }
    }
    else {
      // Don't send, fail silently -- send context busy
    }
    return SUCCESS;
  }

  command result_t alertReceiveContext(TOS_MsgPtr msg) {
    if (!msg->crc) {return FAIL;}
    if (recvContext.state != BOMB_STATE_HALT) {
      dbg(DBG_USR1, "VM: Received packet, receive context busy, drop.\n");
    }
    else {
      int i;
      BombillaPacket* packet = (BombillaPacket*)(msg->data);
      BombillaDataBuffer* buffer = (BombillaDataBuffer*)&(packet->payload);
      dbg(DBG_USR1, "VM: Received packet, enqueuing receive context to run.\n");
      dbg(DBG_USR1, "VM: Copying %i bytes of header over:\n  ", sizeof(recvContext.header));
      for (i = 0; i < sizeof(recvContext.header); i++) {
        dbg_clear(DBG_USR1, "%02hhx", packet->header[i]);
      }
      dbg_clear(DBG_USR1, "\n->");
      nmemcpy(&(recvContext.header), packet->header, sizeof(recvContext.header));
      for (i = 0; i < sizeof(recvContext.header); i++) {
        dbg_clear(DBG_USR1, "%02hhx", ((uint8_t*)recvContext.header)[i]);
      }
      dbg_clear(DBG_USR1, "\n");
      nmemcpy(&(state.recvBuffer), buffer, sizeof(BombillaDataBuffer));
      call Synch.initializeContext(&recvContext, &state);
      call Stacks.pushBuffer(&recvContext, &state.recvBuffer);
      dbg(DBG_USR1, "VM: Calling resumeCon for recvCon in alertRec.\n");
      call Synch.resumeContext(&recvContext, &recvContext, &(state.readyQueue), state.locks);
    }
    return SUCCESS;
  }

  command result_t StdControl.start() {
    result_t res1, res2;
    dbg(DBG_BOOT, "VM: Starting.\n");
    res1 = call SubControlTimer.start();
    res2 = call SubControlNetwork.start();
    res2 = call SubControl.start();
    call ClockTimer.start(TIMER_REPEAT, 1024);
    return rcombine(res1, res2);
  }

  command result_t StdControl.stop() {
    result_t res1, res2;
    dbg(DBG_BOOT, "VM: Stopping.\n");
    call ClockTimer.stop();
    res1 = call SubControlTimer.stop();
    res2 = call SubControlNetwork.stop();
    res2 = call SubControl.stop();
    return rcombine(res1, res2);
  }
  
  command result_t BombillaError.error(BombillaContext* context, uint8_t cause) {
    state.inErrorState = TRUE;
    dbg(DBG_ERROR|DBG_USR1, "VM: Entering ERROR state. Context: %i, cause %i\n", (int)context->which, (int)cause);
    call Leds.redOn();
    call Leds.greenOn();
    call Leds.yellowOn();
    state.errorContext = context;
    if (context != NULL) {
      state.errorContext = context;
      state.errorMsg.context = context->which;
      state.errorMsg.reason = cause;
      state.errorMsg.capsule = context->capsule->capsule.type;
      state.errorMsg.instruction = context->pc - 1;
      context->state = BOMB_STATE_HALT;
    }
    else {
      state.errorMsg.context = BOMB_CAPSULE_INVALID;
      state.errorMsg.reason = cause;
      state.errorMsg.capsule = BOMB_CAPSULE_INVALID;
      state.errorMsg.instruction = 255;
    }
    return SUCCESS;
  }

  task void ClockErrorTask() {
    dbg(DBG_USR1|DBG_ERROR, "VM: ERROR\n");
    call Leds.redToggle();
    call Leds.greenToggle();
    call Leds.yellowToggle();
    nmemcpy(state.errorContext->msg.data,
	    &state.errorMsg,
	    sizeof(BombillaErrorMsg));

    if (state.errorFlipFlop) {
      call SendError.send(TOS_UART_ADDR,
			  sizeof(BombillaErrorMsg),
			  (TOS_MsgPtr)&(state.errorContext->msg));
    }
    else {
      call SendError.send(TOS_BCAST_ADDR,
			  sizeof(BombillaErrorMsg),
			  (TOS_MsgPtr)&(state.errorContext->msg));
    }
    state.errorFlipFlop = !state.errorFlipFlop;
  }
    
  task void ClockEventTask() {
    if (clockContext.state == BOMB_STATE_HALT) {
      call Synch.initializeContext(&clockContext, &state);
      clockContext.state = BOMB_STATE_RUN;
      //initializeContext(&clockContext);
      dbg(DBG_USR1, "VM: Calling ResumeCon for clockCon in ClockEventTask.\n");
      call Synch.resumeContext(&clockContext, &clockContext, &(state.readyQueue), state.locks);
      //resumeContext(&clockContext, &clockContext);
    }
    else {
      dbg(DBG_TEMP, "VM: Clock context not halted.\n");
      // Can log a clock miss error here, but probably
      // not a good idea
    }
  }

  event result_t ClockTimer.fired() {
    dbg(DBG_USR1, "VM: clock timer fired, posting ClockEventTask.\n");
    if (state.inErrorState) {post ClockErrorTask();}
    else {post ClockEventTask();}
    return SUCCESS;
  }

  event result_t SendError.sendDone(TOS_MsgPtr msg, result_t success) {
    return SUCCESS;
  }
  
  event TOS_MsgPtr ReceivePacket.receive(TOS_MsgPtr msg) {
    return msg;
  }
  
  command result_t computeInstruction(BombillaContext* context) {
    uint8_t instr = context->capsule->capsule.code[(int)context->pc];
    //	dbg(DBG_USR1, "VM (%hhi): Issuing instruction 0x%hhx.\n", context->which, instr);
    if (context->state != BOMB_STATE_RUN) {
      dbg(DBG_ERROR, "VM: (%hhi) Tried to execute instruction in non-run state: %hhi\n", context->which, context->state);
      return FAIL;
    }
    context->pc++;
    call Bytecode.execute[instr](instr, context, &state);
    return SUCCESS;  
  }

  default command result_t Bytecode.execute[uint8_t opcode](uint8_t instr,
							    BombillaContext* context,
							    BombillaState* vmState) {
    dbg(DBG_ERROR|DBG_USR1, "VM: Executing default instruction: halt!\n");
    context->state = BOMB_STATE_HALT;
    return FAIL;
  }
  
  event result_t Virus.capsuleInstalled(BombillaCapsule* capsule) {
    //capsuleAnalysis(capsule->type & BOMB_OPTION_MASK);
    return SUCCESS;
  }

  event result_t Virus.enableExecution() {
    return SUCCESS;
  }

  event result_t Virus.disableExecution() {
    return SUCCESS;
  }

  event result_t Virus.capsuleHeard(uint8_t type) {
    return SUCCESS;
  }

  event void Virus.capsuleForce(uint8_t type) {
    return;
  }

  event result_t Synch.makeRunnable(BombillaContext* context) {
    dbg(DBG_USR1, "VM: make runnable event occured for %i.\n", (int)context->which);
    context->state = BOMB_STATE_RUN;
    dbg(DBG_USR1, "VM: calling execCon.\n");
    return call executeContext(context);
  }

}