constructor.c

C++ 编写的EROS RTOS

  regs.faultCode = 0;
  regs.faultInfo = 0;
  regs.domState = RS_Waiting;
  regs.domFlags = 0;
  
  /* Set the new register values. */
  (void) process_set_regs(KR_NEWDOM, &regs);

  DEBUG kdprintf(KR_OSTREAM, "Installed program counter\n");

  (void) process_swap_keyreg(KR_NEWDOM, KR_SELF, KR_NEWDOM, KR_VOID);
  (void) process_swap_keyreg(KR_NEWDOM, KR_CREATOR, KR_YIELDCRE, KR_VOID);
  (void) process_swap_keyreg(KR_NEWDOM, KR_BANK, KR_ARG0, KR_VOID);
  (void) process_swap_keyreg(KR_NEWDOM, KR_SCHED, KR_ARG1, KR_VOID);

  DEBUG kdprintf(KR_OSTREAM, "Sched in target KR_SCHED\n");

  (void) node_copy(KR_PROD_XCON, XCON_ADDRSPACE, KR_SCRATCH);
  (void) process_swap_keyreg(KR_NEWDOM, PSKR_SPACE, KR_SCRATCH, KR_VOID);

  (void) node_copy(KR_PROD_XCON, XCON_SYMTAB, KR_SCRATCH);
  (void) process_swap(KR_NEWDOM, ProcSymSpace, KR_SCRATCH, KR_VOID);

  (void) node_copy(KR_PROD_XCON, XCON_PC, KR_SCRATCH);
  (void) process_swap_keyreg(KR_NEWDOM, PSKR_PROC_PC, KR_SCRATCH, KR_VOID);

  /* User ARG2 to key arg slot 0 */
  (void) process_swap_keyreg(KR_NEWDOM, KR_ARG(0), KR_ARG2, KR_VOID);

  /* Resume key to KR_RETURN */
  (void) process_swap_keyreg(KR_NEWDOM, KR_RETURN, KR_RETURN, KR_VOID);

  /* Make up a fault key to the new process so we can set it in motion */

  DEBUG kdprintf(KR_OSTREAM, "About to call get fault key\n");
  (void) process_make_fault_key(KR_NEWDOM, KR_SCRATCH);

  DEBUG kdprintf(KR_OSTREAM, "Invoking fault key to yield...\n");

  msg->snd_key0 = KR_VOID;
  msg->snd_key1 = KR_VOID;
  msg->snd_key2 = KR_VOID;
  msg->snd_key3 = KR_VOID;
  msg->snd_code = 0;		/* ordinary restart */
  msg->snd_w1 = 0;
  msg->snd_w2 = 0;
  msg->snd_w3 = 0;
  msg->snd_len = 0;
  msg->snd_invKey = KR_SCRATCH;
  
  return RC_OK;

destroy_product:
  (void) proccre_destroy_process(KR_YIELDCRE, KR_ARG0, KR_NEWDOM);
  return RC_NoMoreNodes;
}

int
is_not_discreet(uint32_t kr, ConstructorInfo *ci)
{
  uint32_t result;
  uint32_t keyInfo;
  uint32_t isDiscreet;
  
  node_copy(KR_CONSTIT, KC_DISCRIM, KR_SCRATCH);
  
  DEBUG kdprintf(KR_OSTREAM, "constructor: is_not_discreet(): discrim_verify\n");

  discrim_verify(KR_SCRATCH, kr, &isDiscreet);
  if (isDiscreet)
    return 0;			/* ok */

  DEBUG kdprintf(KR_OSTREAM, "constructor: is_not_discreet(): proccre_amplify\n");
  result = proccre_amplify_gate(KR_YIELDCRE, kr, KR_SCRATCH, 0, &keyInfo);
  if (result == RC_OK && keyInfo == 0) {
    uint32_t isDiscreet;
    /* This key is a requestor's key to a constructor. Ask the
       constructor if it is discreet */
    result = constructor_is_discreet(kr, &isDiscreet);
    if (result == RC_OK && isDiscreet)
      return 0;			/* ok */
  }

  return 1;
}


/* Someday this should start building up a list of holes... */
void
add_new_hole(uint32_t kr, ConstructorInfo *ci)
{
  ci->has_holes = 1;
}

uint32_t
insert_constituent(uint32_t ndx, uint32_t kr, ConstructorInfo *ci)
{
  DEBUG kdprintf(KR_OSTREAM, "constructor: insert constituent %d\n", ndx);

  if (ndx >= EROS_NODE_SIZE)
    return RC_RequestError;
    
  if ( is_not_discreet(kr, ci) )
    add_new_hole(kr, ci);
  
  /* now insert the constituent in the proper constituents node: */
  node_swap(KR_PROD_CON0, ndx, kr, KR_VOID);
	    
  return RC_OK;
}

uint32_t
insert_xconstituent(uint32_t ndx, uint32_t kr, ConstructorInfo *ci)
{
  DEBUG kdprintf(KR_OSTREAM, "constructor: insert xconstituent %d\n", ndx);

  if (ndx == XCON_PC) {
    uint32_t obClass;
    
    /* This copy IS redundant with the one in is_not_discreet(), but
       this path is not performance critical and clarity matters too. */
    node_copy(KR_CONSTIT, KC_DISCRIM, KR_SCRATCH);
  
    discrim_classify(KR_SCRATCH, kr, &obClass);
    if (obClass != Discrim_Class_Number)
      return RC_RequestError;
  }

  if (ndx > XCON_PC)
    return RC_RequestError;
    
  if ( is_not_discreet(kr, ci) )
    add_new_hole(kr, ci);
  
  /* now insert the constituent in the proper constituents node: */
  node_swap(KR_PROD_XCON, ndx, kr, KR_VOID);
	    
  return RC_OK;
}

int
ProcessRequest(Message *msg, ConstructorInfo *ci)
{
  
  /*initialize the keys being sent*/
  msg->snd_len = 0;
  msg->snd_key0 = KR_VOID;
  msg->snd_key1 = KR_VOID;
  msg->snd_key2 = KR_VOID;
  msg->snd_key3 = KR_VOID;
  msg->snd_code = RC_OK;
  msg->snd_w1 = 0;
  msg->snd_w2 = 0;
  msg->snd_w3 = 0;
  msg->snd_invKey = KR_RETURN;

  switch (msg->rcv_code) {
  case OC_Constructor_IsDiscreet:
    {
      if (ci->frozen && !ci->has_holes)
	msg->snd_w1 = 1;
      else
	msg->snd_w1 = 0;
      msg->snd_code = RC_OK;

      return 1;
    }      
    
  case OC_Constructor_Request:
    {
      DEBUG kdprintf(KR_OSTREAM, "constructor: request product\n");

      msg->snd_code = MakeNewProduct(msg);
      return 1;
    }      
    
  case OC_Constructor_Seal:
    {
      DEBUG kdprintf(KR_OSTREAM, "constructor: seal\n");

      ci->frozen = 1;

      process_make_start_key(KR_SELF, 0, KR_NEWDOM);
      msg->snd_key0 = KR_NEWDOM;

      return 1;
    }      

  case OC_Constructor_Insert_Constituent:
    {
      msg->snd_code = insert_constituent(msg->rcv_w1, KR_ARG0, ci);
      
      return 1;
    }      

  case OC_Constructor_Insert_Keeper:
    {
      msg->snd_code = insert_xconstituent(XCON_KEEPER, KR_ARG0, ci);
      
      return 1;
    }      

  case OC_Constructor_Insert_AddrSpace:
    {
      msg->snd_code = insert_xconstituent(XCON_ADDRSPACE, KR_ARG0, ci);
      
      return 1;
    }      

  case OC_Constructor_Insert_Symtab:
    {
      msg->snd_code = insert_xconstituent(XCON_SYMTAB, KR_ARG0, ci);
      
      return 1;
    }      

  case OC_Constructor_Insert_PC:
    {
      msg->snd_code = insert_xconstituent(XCON_PC, KR_ARG0, ci);
      
      return 1;
    }      

  case OC_Destroy:
    {
      Sepuku();
    }
  
  case OC_KeyType:			/* check alleged keytype */
    {
      switch(msg->rcv_keyInfo) {
      case 0:
	msg->snd_code = RC_OK;
	msg->snd_w1 = AKT_ConstructorRequestor;
	break;
      case 1:
	msg->snd_code = RC_OK;
	msg->snd_w1 = AKT_ConstructorBuilder;
	break;
      }
      return 1;
    }      

  default:
    break;
  }

  msg->snd_code = RC_UnknownRequest;
  return 1;
}

int
main()
{
  Message msg;
  ConstructorInfo ci;
  
  InitConstructor(&ci);

  /* Recover our own process key from constit1 into slot 1 */
  process_make_start_key(KR_SELF, 1, KR_SCRATCH);

  msg.snd_key0 = KR_SCRATCH;
  msg.snd_key1 = KR_VOID;
  msg.snd_key2 = KR_VOID;
  msg.snd_key3 = KR_VOID;
  msg.snd_code = 0;
  msg.snd_w1 = 0;
  msg.snd_w2 = 0;
  msg.snd_w3 = 0;
  msg.snd_len = 0;
  msg.snd_data = 0;
  msg.snd_invKey = KR_RETURN;

  msg.rcv_key0 = KR_ARG0;
  msg.rcv_key1 = KR_ARG1;
  msg.rcv_key2 = KR_ARG2;
  msg.rcv_key3 = KR_RETURN;
  msg.rcv_data = 0;
  msg.rcv_len = 0;

  do {
    /* no need to re-initialize rcv_len, since always 0 */
    RETURN(&msg);
  } while (ProcessRequest(&msg, &ci));

  return 0;
}