void migrate_manager::do_migrate_one_bucket(int bucket_number, vector<uint64_t> dest_servers) { lsn_type last_lsn = log->get_current_lsn(); current_migrating_bucket = bucket_number; usleep(MISECONDS_WAITED_FOR_WRITE); bool is_sucess = migrate_data_file(bucket_number, dest_servers); if (!is_sucess) { log_debug("migrate be stopped or file error!"); current_migrating_bucket = -1; return; } lsn_type current_lsn = log->get_current_lsn(); while((current_lsn - last_lsn >= MIGRATE_LOCK_LOG_LEN)) { is_sucess = migrate_log(bucket_number, dest_servers, last_lsn, current_lsn); if (!is_sucess) { current_migrating_bucket = -1; return; } last_lsn = current_lsn; current_lsn = log->get_current_lsn(); } current_locked_bucket = bucket_number; usleep(MISECONDS_WAITED_FOR_WRITE); current_lsn = log->get_current_lsn(); is_sucess = migrate_log(bucket_number, dest_servers, last_lsn, current_lsn); if (!is_sucess) { current_migrating_bucket = -1; current_locked_bucket = -1; return; } last_lsn = current_lsn; current_lsn = log->get_current_lsn(); while (current_lsn != last_lsn ){ is_sucess = migrate_log(bucket_number, dest_servers, last_lsn, current_lsn); if (!is_sucess) break; last_lsn = current_lsn; current_lsn = log->get_current_lsn(); } if (!is_sucess) { current_locked_bucket = -1; current_migrating_bucket = -1; return; } else { while(!(duplicator->has_bucket_duplicate_done(bucket_number))) { usleep(1000); if (is_stopped || _stop){ current_migrating_bucket = -1; current_locked_bucket = -1; return; } } finish_migrate_bucket(bucket_number); current_migrating_bucket = -1; current_locked_bucket = -1; } }
bool ecall_delete_counter(uint8_t id){ bool retval = false; int ret = sgx_destroy_migratable_counter(id); if(ret == SGX_SUCCESS){ migrate_log("[DELETE COUNTER SUCCESS]\n"); retval = true; } else { migrate_log("Error deleting counter %i with error code %x\n", id, ret); } return retval; }
uint32_t ecall_unseal( void *p_sealed_data, uint32_t sealed_data_size, uint8_t *p_additional_MACtext, uint32_t additional_MACtext_length, uint8_t *p_decrypted_text, uint32_t decrypted_text_length){ uint32_t p_additional_MACtext_length = additional_MACtext_length; uint32_t p_decrypted_text_length = decrypted_text_length; uint8_t *mac_data = (uint8_t *) malloc(additional_MACtext_length); uint8_t *enc_data = (uint8_t *) malloc(decrypted_text_length); uint32_t ret = sgx_unseal_migratable_data( (sgx_sealed_data_t*) p_sealed_data, mac_data, &p_additional_MACtext_length, enc_data, &p_decrypted_text_length); //Check if sizes match if(additional_MACtext_length != p_additional_MACtext_length || decrypted_text_length != p_decrypted_text_length){ migrate_log("ERROR sealing data: Mismatch in Sizes: %u != %u and/or %u != %u\n", additional_MACtext_length, p_additional_MACtext_length, decrypted_text_length, p_decrypted_text_length); return SGX_ERROR_INVALID_ATTRIBUTE; } memcpy(p_additional_MACtext, mac_data, p_additional_MACtext_length); memcpy(p_decrypted_text, enc_data, p_decrypted_text_length); return ret; }
bool ecall_test_counter(uint8_t id, uint32_t expected_value){ migrate_log("[TEST COUNTER] "); bool retval = false; //Test counters: int ret; uint32_t val=0; ret = sgx_read_migratable_counter(id, &val); if(ret == SGX_SUCCESS){ if(val == expected_value){ migrate_log("Counter %i has expected value %u\n", id, val); retval = true; } else { migrate_log("ERROR: Counter %i does NOT have expected value %u but instead has %u\n", id, expected_value, val); } } else { migrate_log("Read counter failed with %x\n", ret); } return retval; }
uint8_t ecall_test_create_counter(uint32_t test_value) { migrate_log("[TEST CREATE COUNTER]\n"); //Test counters: int ret; uint8_t id=0; uint32_t val=0; ret = sgx_create_migratable_counter(&id, &val); migrate_log("Counter created: Return code %x, ID:%u with value %u\n", ret, id, val); migrate_log("Increasing counter %u to %u\n", id, test_value); for(int i = 0; i < test_value; i++){ ret = sgx_increment_migratable_counter(id, &val); if(val%10 == 0){ migrate_log("Current value: %u. %u to go.\n", val, test_value - val); } } migrate_log("done\n"); ret = sgx_read_migratable_counter(id, &val); migrate_log("Counter read: Return code %x, ID:%u has value %u\n", ret, id, val); return id; }
void ecall_test_seal_unseal(){ migrate_log("[TEST] [SEAL UNSEAL]\n"); int ret; int secretValue = 1337; uint32_t sealed_data_size = sgx_calc_sealed_data_size(0, sizeof(int)); void* sealed_data = malloc(sealed_data_size); ret = sgx_seal_migratable_data(0, NULL,sizeof(int),(uint8_t*)&secretValue, sealed_data_size, (sgx_sealed_data_t*)sealed_data); migrate_log("Sealed blob with ret code %x\n", ret); int unsealed_value; uint32_t unsealed_size = sizeof(int); ret = sgx_unseal_migratable_data((sgx_sealed_data_t*) sealed_data, NULL, 0, (uint8_t*)&unsealed_value, &unsealed_size); migrate_log("Unsealed blob with ret code %x\n", ret); migrate_log("Sealed value was %u and unsealed was %u\n", secretValue, unsealed_value); if(secretValue == unsealed_value){ migrate_log("[TEST] [SEAL UNSEAL] SUCCESSFULL\n"); } else { migrate_log("[TEST] [SEAL UNSEAL] ERROR\n"); } }