vtpm_manager_handler.c

xen虚拟机源代码安装包

    } else {
      vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s had error writing to ipc. Aborting... \n", thread_name);
      goto abort_command;
    }
    free(out_message); out_message=NULL;
    
    if (size_write < (int)reply_size) {
      vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s unable to write full command to ipc (%d/%d)\n", thread_name, size_write, reply_size);
      goto abort_command;
    }
    
    // On certain failures an error message cannot be sent. 
    // This marks the beginning of cleanup in preperation for the next command.
  abort_command:
    //free buffers
    bzero(cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV);
    //free(in_param); // This was converted to command_buf. No need to free 
    buffer_free(result_buf);
    buffer_free(command_buf);

    // If we have a write lock, save the manager table
    if ((tag == VTPM_TAG_REQ) && (ord & VTPM_PRIV_MASK) &&
        (VTPM_SaveManagerData() != TPM_SUCCESS) ) {
       vtpmhandlerlogerror(VTPM_LOG_VTPM, "ERROR: Unable to save manager data.\n");
    }

    vtpm_lock_unlock();
    add_header = TRUE; // Reset to the default
  } // End while(1)
  
}

/////////////////////////////////////////////////////////////////////////
TPM_RESULT vtpm_manager_handle_vtpm_cmd(VTPM_DMI_RESOURCE *dmi_res, 
					TPM_COMMAND_CODE ord,
					buffer_t *command_buf,
					buffer_t *result_buf,
                                        BOOL is_priv,
                                        char *thread_name) {

  TPM_RESULT status = TPM_FAIL;

  switch (ord) {                
  case VTPM_ORD_SAVENVM:
    status= VTPM_Handle_Save_NVM(dmi_res,
                                 command_buf, 
                                 result_buf);
    break;

  case VTPM_ORD_LOADNVM:
    status= VTPM_Handle_Load_NVM(dmi_res, 
                                 command_buf, 
                                 result_buf);
    break;

  case VTPM_ORD_TPMCOMMAND:
    status= VTPM_Handle_TPM_Command(dmi_res, 
                                    command_buf, 
                                    result_buf);
    break;

  case VTPM_ORD_GET_MIG_KEY:
    status = VTPM_Handle_Get_Migration_key(command_buf, 
                                           result_buf);
    break;

  case VTPM_ORD_LOAD_MIG_KEY:
    status = VTPM_Handle_Load_Migration_key(command_buf, 
                                           result_buf);
    break;
   
  default:
    // Privileged handlers can do maintanance
    if (is_priv) {
      switch (ord) {
      case VTPM_ORD_OPEN:
        status = VTPM_Handle_New_DMI(command_buf);
        break;

      case VTPM_ORD_CLOSE:
        status = VTPM_Handle_Close_DMI(command_buf);
        break;

      case VTPM_ORD_DELETE:
        status = VTPM_Handle_Delete_DMI(command_buf);
        break;

      case VTPM_ORD_MIGRATE_IN:
        status = VTPM_Handle_Migrate_In(command_buf, result_buf);
        break;

      case VTPM_ORD_MIGRATE_OUT:
        status = VTPM_Handle_Migrate_Out(command_buf, result_buf);
        break;

      default:
        status = TPM_BAD_ORDINAL;
      } // switch
    } else { // is priv command

        status = TPM_BAD_ORDINAL;
    } // inner switch
  } // outer switch

  return(status);
}
      
/////////////////////////////////////////////////////////////////////
TPM_RESULT vtpm_manager_handle_tpm_cmd(vtpm_ipc_handle_t *tx_ipc_h,
                                       vtpm_ipc_handle_t *rx_ipc_h,
				       VTPM_DMI_RESOURCE *dmi_res, 
				       BYTE *cmd_header,
				       buffer_t *param_buf,
				       buffer_t *result_buf,
                                       char *thread_name) {

  TPM_RESULT status = TPM_FAIL;
  UINT32 dmi_dst;
  TPM_COMMAND_CODE ord;
  TPM_TAG tag_out;
  UINT32 dmi_cmd_size, in_param_size, adj_param_size;
  BYTE *dmi_cmd, *in_param;
  int  size_read, size_write, i;

  //// Dom0 can't talk to the BE, so this must be a broken FE/BE or badness
  if (dmi_res->dmi_id == VTPM_CTL_DM) {
    vtpmhandlerlogerror(VTPM_LOG_VTPM, "Illegal use of TPM command from dom0\n");
    status = TPM_FAIL;
    goto abort_with_error;
  } 

  vtpmhandlerloginfo(VTPM_LOG_VTPM, "Forwarding command to DMI.\n");
   
  //Forward TPM CMD stamped with dmi_id to DMI for handling
  if (buffer_len(param_buf)) {
    dmi_cmd = (BYTE *) malloc(VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf));
    dmi_cmd_size = VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf);
    memcpy(dmi_cmd, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV);
    memcpy(dmi_cmd + VTPM_COMMAND_HEADER_SIZE_SRV, param_buf->bytes, buffer_len(param_buf));
    size_write = vtpm_ipc_write(tx_ipc_h, dmi_res->tx_tpm_ipc_h, dmi_cmd, dmi_cmd_size);

    if (size_write > 0) {
      vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT (DMI): 0x");
      for (i=0; i<VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf); i++) {
        vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", dmi_cmd[i]);
      }
      vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n");
    } else {
      vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error writing to DMI. Aborting... \n");
      status = TPM_IOERROR;
      goto abort_with_error;
    }
    free(dmi_cmd);
  } else {
    dmi_cmd_size = VTPM_COMMAND_HEADER_SIZE_SRV;
    size_write = vtpm_ipc_write(tx_ipc_h, dmi_res->tx_tpm_ipc_h, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV );
    if (size_write > 0) {
      vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT (DMI): 0x");
      for (i=0; i<VTPM_COMMAND_HEADER_SIZE_SRV; i++) 
        vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]);

      vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n");
    } else {
      vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error writing to DMI. Aborting... \n");
      status = TPM_IOERROR;
      goto abort_with_error;
    }
  }
    
  if (size_write != (int) dmi_cmd_size) 
    vtpmhandlerlogerror(VTPM_LOG_VTPM, "Could not write entire command to DMI (%d/%d)\n", size_write, dmi_cmd_size);

  buffer_free(param_buf);
  
  // Read header for response to TPM command from DMI
  size_read = vtpm_ipc_read( rx_ipc_h, dmi_res->rx_tpm_ipc_h, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV);
  if (size_read > 0) {
    vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "RECV (DMI): 0x");
    for (i=0; i<size_read; i++) 
      vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]);

  } else {
    vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error reading from DMI. Aborting... \n");
    status = TPM_IOERROR;
    goto abort_with_error;
  }
  
  if (size_read < (int) VTPM_COMMAND_HEADER_SIZE_SRV) {
    vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command from DMI shorter than normal header. Aborting...\n");
    status = TPM_IOERROR;
    goto abort_with_error;
  }

  // Unpack response from DMI for TPM command
  BSG_UnpackList(cmd_header, 4,
                 BSG_TYPE_UINT32, &dmi_dst,
                 BSG_TPM_TAG, &tag_out,
                 BSG_TYPE_UINT32, &in_param_size,
                 BSG_TPM_COMMAND_CODE, &status );
  
  // If response has parameters, read them.
  // Note that in_param_size is in the client's context
  adj_param_size = in_param_size - VTPM_COMMAND_HEADER_SIZE_CLT;
  if (adj_param_size > 0) {
    in_param = (BYTE *) malloc(adj_param_size);
    size_read = vtpm_ipc_read(rx_ipc_h, dmi_res->rx_tpm_ipc_h, in_param, adj_param_size);
    if (size_read > 0) {
      for (i=0; i<size_read; i++) 
        vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param[i]);

    } else {
      vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error reading from BE. Aborting... \n");
      goto abort_with_error;
    }
    vtpmhandlerloginfomore(VTPM_LOG_VTPM, "\n");
   
    if (size_read < (int)adj_param_size) {
      vtpmhandlerloginfomore(VTPM_LOG_VTPM, "\n");
      vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command read(%d) from DMI is shorter than header indicates(%d). Aborting...\n", size_read, adj_param_size);
      status = TPM_IOERROR;
      goto abort_with_error;
    }
  } else {
    in_param = NULL;
    vtpmhandlerloginfomore(VTPM_LOG_VTPM, "\n");
  }
   
  if ( (buffer_init(result_buf, VTPM_COMMAND_HEADER_SIZE_SRV, cmd_header) != TPM_SUCCESS) || 
       (buffer_append_raw(result_buf, adj_param_size, in_param) != TPM_SUCCESS) ) {
    vtpmhandlerlogerror(VTPM_LOG_VTPM, "Failed to setup buffers. Aborting...\n");
    status = TPM_FAIL;
    goto abort_with_error;
  }
 
  vtpmhandlerloginfo(VTPM_LOG_VTPM, "Sending DMI's response to guest.\n");

  status = TPM_SUCCESS;

 abort_with_error:

  return status;
}