/** * @brief Initialize the provided mutex * * Call this function to initialize the mutex * * @param IoT_Mutex_t - pointer to the mutex to be initialized * @return IoT_Error_t - error code indicating result of operation */ IoT_Error_t aws_iot_thread_mutex_init(IoT_Mutex_t *pMutex) { if (os_mutex_create(&pMutex->lock, "aws-mutex", OS_MUTEX_INHERIT) != WM_SUCCESS) { return MUTEX_LOCK_ERROR; } return AWS_SUCCESS; }
Gui::Gui(GenesisContext *context, ResourceBundle *resource_bundle) : _running(true), _focus_window(nullptr), _utility_window(create_utility_window()), _resource_bundle(resource_bundle), _spritesheet(this, "spritesheet"), img_entry_dir(_spritesheet.get_image_info("font-awesome/folder.png")), img_entry_dir_open(_spritesheet.get_image_info("font-awesome/folder-open.png")), img_entry_file(_spritesheet.get_image_info("font-awesome/file.png")), img_plus(_spritesheet.get_image_info("font-awesome/plus-square.png")), img_minus(_spritesheet.get_image_info("font-awesome/minus-square.png")), img_microphone(_spritesheet.get_image_info("font-awesome/microphone.png")), img_volume_up(_spritesheet.get_image_info("font-awesome/volume-up.png")), img_check(_spritesheet.get_image_info("font-awesome/check.png")), img_caret_right(_spritesheet.get_image_info("font-awesome/caret-right.png")), img_caret_down(_spritesheet.get_image_info("font-awesome/caret-down.png")), img_arrow_up(_spritesheet.get_image_info("font-awesome/arrow-up.png")), img_arrow_down(_spritesheet.get_image_info("font-awesome/arrow-down.png")), img_arrow_left(_spritesheet.get_image_info("font-awesome/arrow-left.png")), img_arrow_right(_spritesheet.get_image_info("font-awesome/arrow-right.png")), img_music(_spritesheet.get_image_info("font-awesome/music.png")), img_plug(_spritesheet.get_image_info("font-awesome/plug.png")), img_exclamation_circle(_spritesheet.get_image_info("font-awesome/exclamation-circle.png")), img_null(_spritesheet.get_image_info("img/null.png")), img_play_head(_spritesheet.get_image_info("img/play_head.png")), _genesis_context(context), dragging(false), drag_data(nullptr), drag_window(nullptr) { ft_ok(FT_Init_FreeType(&_ft_library)); _resource_bundle->get_file_buffer("font.ttf", _default_font_buffer); ft_ok(FT_New_Memory_Face(_ft_library, (FT_Byte*)_default_font_buffer.raw(), _default_font_buffer.length(), 0, &_default_font_face)); cursor_default = glfwCreateStandardCursor(GLFW_ARROW_CURSOR); cursor_ibeam = glfwCreateStandardCursor(GLFW_IBEAM_CURSOR); cursor_hresize = glfwCreateStandardCursor(GLFW_HRESIZE_CURSOR); cursor_vresize = glfwCreateStandardCursor(GLFW_VRESIZE_CURSOR); genesis_set_audio_device_callback(_genesis_context, audio_device_callback, this); genesis_set_midi_device_callback(_genesis_context, midi_device_callback, this); genesis_set_sound_backend_disconnect_callback(_genesis_context, sound_backend_disconnect_callback, this); genesis_flush_events(_genesis_context); genesis_refresh_midi_devices(_genesis_context); gui_mutex = ok_mem(os_mutex_create()); os_mutex_lock(gui_mutex); }
LockedQueue() { _start = 0; _end = 0; _length = 0; _capacity = 0; _items = NULL; _shutdown = false; if (!(_mutex = os_mutex_create())) mutex_err = GenesisErrorNoMem; if (!(_cond = os_cond_create())) cond_err = GenesisErrorNoMem; }
int seminfo_init(void) { int ret; ret = os_mutex_create(&sem_mutex, "sem-mutex", OS_MUTEX_INHERIT); if (ret == -WM_FAIL) { wmprintf("[sem-dbg] Failed to create sem-mutex\r\n"); return -WM_FAIL; } if (cli_register_commands (&cli[0], sizeof(cli) / sizeof(struct cli_command))) return 1; return 0; }
/*********************************************************//** Initializes global event and OS 'slow' mutex lists. */ UNIV_INTERN void os_sync_init(void) /*==============*/ { UT_LIST_INIT(os_event_list); UT_LIST_INIT(os_mutex_list); os_sync_mutex = NULL; os_sync_mutex_inited = FALSE; os_sync_mutex = os_mutex_create(NULL); os_sync_mutex_inited = TRUE; }
sync_array_t* sync_array_create( /*==============*/ /* out, own: created wait array */ ulint n_cells, /* in: number of cells in the array to create */ ulint protection) /* in: either SYNC_ARRAY_OS_MUTEX or SYNC_ARRAY_MUTEX: determines the type of mutex protecting the data structure */ { sync_array_t* arr; sync_cell_t* cell_array; sync_cell_t* cell; ulint i; ut_a(n_cells > 0); /* Allocate memory for the data structures */ arr = ut_malloc(sizeof(sync_array_t)); cell_array = ut_malloc(sizeof(sync_cell_t) * n_cells); arr->n_cells = n_cells; arr->n_reserved = 0; arr->array = cell_array; arr->protection = protection; arr->sg_count = 0; arr->res_count = 0; /* Then create the mutex to protect the wait array complex */ if (protection == SYNC_ARRAY_OS_MUTEX) { arr->os_mutex = os_mutex_create(NULL); } else if (protection == SYNC_ARRAY_MUTEX) { mutex_create(&arr->mutex, SYNC_NO_ORDER_CHECK); } else { ut_error; } for (i = 0; i < n_cells; i++) { cell = sync_array_get_nth_cell(arr, i); cell->wait_object = NULL; cell->waiting = FALSE; cell->signal_count = 0; } return(arr); }
/*******************************************************************//** Creates a synchronization wait array. It is protected by a mutex which is automatically reserved when the functions operating on it are called. @return own: created wait array */ UNIV_INTERN sync_array_t* sync_array_create( /*==============*/ ulint n_cells, /*!< in: number of cells in the array to create */ ulint protection) /*!< in: either SYNC_ARRAY_OS_MUTEX or SYNC_ARRAY_MUTEX: determines the type of mutex protecting the data structure */ { ulint sz; sync_array_t* arr; ut_a(n_cells > 0); /* Allocate memory for the data structures */ arr = ut_malloc(sizeof(sync_array_t)); memset(arr, 0x0, sizeof(*arr)); sz = sizeof(sync_cell_t) * n_cells; arr->array = ut_malloc(sz); memset(arr->array, 0x0, sz); arr->n_cells = n_cells; arr->protection = protection; /* Then create the mutex to protect the wait array complex */ if (protection == SYNC_ARRAY_OS_MUTEX) { arr->os_mutex = os_mutex_create(); } else if (protection == SYNC_ARRAY_MUTEX) { mutex_create(syn_arr_mutex_key, &arr->mutex, SYNC_NO_ORDER_CHECK); } else { ut_error; } return(arr); }
int lcd_drv_init(I2C_ID_Type id) { int ret; MDEV_lcd.name = MDEV_NAME_lcd; if (mdev_get_handle(MDEV_NAME_lcd) != NULL) return WM_SUCCESS; pinmux_drv_init(); gpio_drv_init(); i2c_drv_init(id); ret = os_mutex_create(&lcd_mutex, "lcd", OS_MUTEX_INHERIT); if (ret == -WM_FAIL) { lcd_e("Failed to create mutex"); return -WM_FAIL; } mdev_register(&MDEV_lcd); MDEV_lcd.private_data = (uint32_t) id; init_lcd(); return WM_SUCCESS; }
/* Basic Sensor IO initialization to be done here This function will be called only once during sensor registration */ int co2_sensor_init(struct sensor_info *curevent) { int ret; if (co2_sinit_f) return 0; co2_sinit_f = 1; /* using IO_48 and IO_49 for Sensor Communication Please NOTE: This need relevent change in board file */ uart_drv_init(UART2_ID, UART_8BIT); ret = os_mutex_create(&co2uart_mutex, "uart-co2", OS_MUTEX_INHERIT); if (ret != WM_SUCCESS) return -WM_FAIL; uart2_dev = uart_drv_open(UART2_ID, CO2_UART_BAUD); return 0; }
int ssp_drv_init(SSP_ID_Type id) { int ret; if (mdev_get_handle(mdev_ssp_name[id]) != NULL) return WM_SUCCESS; ret = os_mutex_create(&ssp_mutex[id], "ssp-write", OS_MUTEX_INHERIT); if (ret == -WM_FAIL) { SSP_LOG("Failed to create mutex"); return -WM_FAIL; } /* Initialize the SSP port's mdev structure */ ssp_drv_mdev_init(id); /* Register the SSP device driver for this port */ mdev_register(&mdev_ssp[id]); fill_cb_array(); return WM_SUCCESS; }
/** * @brief C main entry function * @param argc number of arguments * @param argv A pointer to arguments array * @return WPS_STATUS_SUCCESS--success, otherwise--fail */ int wps_start(struct wps_config *wps_conf) { int ret; WPS_DATA *wps_s = (WPS_DATA *) &wps_global; #ifdef CONFIG_WPA2_ENTP WPA_SM *wpa_sm_s = (WPA_SM *) &wpa_sm; #endif if (wps.initialized == true) return -WM_FAIL; local_wcc = wps_conf; memset((void *)&wps, 0, sizeof(wps)); #ifdef CONFIG_P2P wps.peer_event_queue_data = wps_peer_event_queue_data; wps.event_queue_data = wps_event_queue_data; #endif wps.cmd_queue_data = wps_cmd_queue_data; wps.data_queue_data = wps_data_queue_data; wps.cb = local_wcc->wps_callback; #ifdef CONFIG_P2P /* WFD data initiliazation */ memset(&wps_s->wfd_data, 0, sizeof(WFD_DATA)); wps_s->wfd_data.dev_index = -1; wps_s->wfd_data.dev_found = -1; ret = os_mutex_create(&wps.p2p_session, "p2p_session", OS_MUTEX_INHERIT); if (ret != WM_SUCCESS) { WPS_LOG("Error: Failed to create " "p2p session mutex: %d\r\n", ret); goto fail; } ret = os_queue_create(&wps.event_queue, "wps_event_queue", sizeof(struct wfd_wlan_event), &wps.event_queue_data); if (ret != WM_SUCCESS) { WPS_LOG ("Error: Failed to create wps event queue: %d\r\n", ret); goto fail; } ret = os_queue_create(&wps.peer_event_queue, "wps_peer_event_queue", sizeof(struct wfd_wlan_event), &wps.peer_event_queue_data); if (ret != WM_SUCCESS) { WPS_LOG ("Error: Failed to create wps peer " "event queue: %d\r\n", ret); goto fail; } ret = wifi_register_wfd_event_queue(&wps.peer_event_queue); if (ret) { WPS_LOG("Error: unable to register peer " "event queue %d\r\n", ret); os_queue_delete(&wps.peer_event_queue); goto fail; } #endif ret = os_queue_create(&wps.cmd_queue, "wps_cmd_queue", sizeof(struct wps_command **), &wps.cmd_queue_data); if (ret != WM_SUCCESS) { WPS_LOG("Error: Failed to create wps cmd queue: %d\r\n", ret); goto fail; } ret = os_queue_create(&wps.data_queue, "wps_message_queue", sizeof(struct wps_msg), &wps.data_queue_data); if (ret != WM_SUCCESS) { WPS_LOG ("Error: Failed to create wps message queue: %d\r\n", ret); goto fail; } #ifdef CONFIG_CYASSL ctaocrypt_lib_init(); #endif wps.initialized = true; memset(wps_s->ifname, 0, IFNAMSIZ + 1); #ifdef CONFIG_P2P if (local_wcc->role == WFD_ROLE) strncpy(wps_s->ifname, "wfd0", IFNAMSIZ); else if (local_wcc->role == WPS_REGISTRAR) strncpy(wps_s->ifname, "uap0", IFNAMSIZ); else #endif strncpy(wps_s->ifname, "mlan0", IFNAMSIZ); gpwps_info_initialized = false; ret = wps_private_info_allocate(&gpwps_info); wps_printf(DEBUG_INIT, "Initializing interface '%s'", wps_s->ifname); #ifdef CONFIG_P2P if (local_wcc->role == WFD_ROLE) { if (auto_go) wps_s->bss_type = BSS_TYPE_UAP; else wps_s->bss_type = BSS_TYPE_STA; } else if (local_wcc->role == WPS_REGISTRAR) wps_s->bss_type = BSS_TYPE_UAP; else wps_s->bss_type = BSS_TYPE_STA; gpwps_info->discovery_role = WPS_ENROLLEE; #else wps_s->bss_type = BSS_TYPE_STA; #endif /* * 1. Initialize L2 packet interface for receiving EAP packet. * 2. Get L2 MAC address and store to application global structure */ if (wps_loop_init(wps_s) != 0) { wps_printf(MSG_ERROR, "ERROR - Fail to initialize layer 2 socket !\n"); wps_stop(); goto fail; } #ifdef CONFIG_WPA2_ENTP memset(wpa_sm_s, 0, sizeof(WPA_SM)); wpa_sm_s->pairwise_cipher = WPA_CIPHER_CCMP; wpa_sm_s->group_cipher = WPA_CIPHER_CCMP; wpa_sm_s->proto = WPA_PROTO_RSN; wpa_sm_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X; wpa_sm_s->renew_snonce = 1; memcpy(wpa_sm_s->own_addr, wps_s->l2->my_mac_addr, ETH_ALEN); #endif #ifdef CONFIG_P2P ret = os_thread_create(&wps_main_thread, "p2p", wps_main, 0, &wps_stack, OS_PRIO_3); if (ret != WM_SUCCESS) { WPS_LOG("Error: Failed to create p2p thread: %d\r\n", ret); goto fail; } if (!auto_go) { ret = os_thread_create(&p2p_scan_thread, "p2p_scan", wps_peer_event_receive, 0, &p2p_scan_stack, OS_PRIO_3); if (ret != WM_SUCCESS) { WPS_LOG("Error: Failed to create p2p_scan" " thread: %d\r\n", ret); goto fail; } } #else ret = os_thread_create(&wps_main_thread, "wps", wps_main, 0, &wps_stack, OS_PRIO_3); if (ret != WM_SUCCESS) { WPS_LOG("Error: Failed to create wps thread: %d\r\n", ret); goto fail; } #endif return WM_SUCCESS; fail: if (wps_main_thread) os_thread_delete(&wps_main_thread); if (wps.cmd_queue) os_queue_delete(&wps.cmd_queue); if (wps.data_queue) os_queue_delete(&wps.data_queue); #ifdef CONFIG_P2P if (wps.p2p_session) os_mutex_delete(&wps.p2p_session); if (wps.peer_event_queue) os_queue_delete(&wps.peer_event_queue); if (wps.event_queue) os_queue_delete(&wps.event_queue); #endif return -WM_FAIL; }
int main() { int ret; modules_init();//模块的初始化 user_init(); /* system tag data */ store_or_retrive_taged_config(); get_mcu_version_from_psm(); LOG_DEBUG("rst cause is %x\r\n", boot_reset_cause()); #ifdef MIIO_COMMANDS mcmd_enqueue_raw("MIIO_model_req"); mcmd_enqueue_raw("MIIO_mcu_version_req"); #endif ret = os_mutex_create(&network_state_mutex,"network_state",OS_MUTEX_INHERIT); if(WM_SUCCESS != ret) { LOG_ERROR("create network_state_mutex fail"); goto main_error; } register_device_network_state_observer(led_network_state_observer); /*set wifi calbration data*/ product_set_wifi_cal_data(); /* Start the application framework */ if ((ret = app_framework_start(common_event_handler)) != WM_SUCCESS) { LOG_ERROR("Failed to start application framework.\r\n"); #if defined(CONFIG_CPU_MC200) if (-WLAN_ERROR_FW_DNLD_FAILED == ret || -WLAN_ERROR_FW_NOT_DETECTED == ret || -WLAN_ERROR_FW_NOT_READY == ret) { LOG_WARN("Wifi firmware broken, trying to recover.\r\n"); if (recover_wifi_fw() != WM_SUCCESS) { LOG_FATAL("Recovering wifi fw failed!!!\r\n"); } else { LOG_WARN("Recovering wifi fw success.\r\n"); pm_reboot_soc(); } } #endif appln_critical_error_handler((void *) -WM_FAIL); } ret = is_factory_mode_enable(); LOG_DEBUG("factory mode magic is %x\r\n" ,get_factory_mode_enable()); if (0 == ret) { // user mode static xTaskHandle task_handle; if (app_thread) { xTaskCreate(app_thread, (signed char*) "app", 2000, NULL, APPLICATION_PRIORITY, &task_handle); xTaskCreate(app_uart_thread, (signed char*) "app_uart", 2000, NULL, APPLICATION_PRIORITY, &task_handle); LOG_INFO("App thread and App uart thread started.\r\n"); } } else { // factory mode static xTaskHandle task_handle; if (app_test_thread) { xTaskCreate(app_test_thread, (signed char*) "test", 2000, NULL, 2, &task_handle); LOG_INFO("Test thread started.\r\n"); } } // Initialize power management hp_pm_init(); //enter main loop, main loop will be used as a worker thread main_loop_run(); //main loop return means error main_error: pm_reboot_soc(); //error occure on main thread , reboot return 1; }
/*********************************************************** * Function: gw_cntl_init * Input: * Output: * Return: ***********************************************************/ OPERATE_RET gw_cntl_init(VOID) { OPERATE_RET op_ret; op_ret = httpc_aes_init(); if(OPRT_OK != op_ret) { PR_ERR("op_ret:%d",op_ret); return op_ret; } op_ret = ws_db_init(); if(OPRT_OK != op_ret) { return op_ret; } memset(&gw_cntl,0,sizeof(gw_cntl)); memset(&gw_mutex,0,sizeof(gw_mutex)); // create mutex int ret; ret = os_mutex_create(&gw_mutex, "gw_mutex", 1); if(ret != WM_SUCCESS) { return OPRT_CR_MUTEX_ERR; } // create gw active timer ret = os_timer_create(&gw_actv_timer, "gw_actv_timer", os_msec_to_ticks(1000), &gw_actv_timer_cb, NULL, OS_TIMER_PERIODIC, OS_TIMER_NO_ACTIVATE); if (ret != WM_SUCCESS) { return OPRT_COM_ERROR; } PROD_IF_REC_S prod_if; #if 1 memset(&prod_if,0,sizeof(prod_if)); ws_db_get_prod_if(&prod_if); if(!prod_if.mac[0] || !prod_if.prod_idx[0]) { // un init set_gw_status(UN_INIT); return OPRT_OK; } #else strcpy(prod_if.mac,"112233445566"); strcpy(prod_if.prod_idx,"0da02001"); #endif op_ret = ws_db_get_gw_actv(&gw_cntl.active); if(OPRT_OK != op_ret) { memset(&gw_cntl.active,0,sizeof(gw_cntl.active)); ws_db_set_gw_actv(&gw_cntl.active); set_gw_status(UN_ACTIVE); }else { if(!gw_cntl.active.key[0] || !gw_cntl.active.uid_cnt) { // un active if(!gw_cntl.active.token[0]) { set_gw_status(UN_ACTIVE); }else { start_active_gateway(); } }else { set_gw_status(STAT_WORK); } } strcpy(gw_cntl.gw.sw_ver,GW_VER); #if 0 strcpy(gw_cntl.gw.name,GW_DEF_NAME); #else snprintf(gw_cntl.gw.name,sizeof(gw_cntl.gw.name),"%s-%s",GW_DEF_NAME,&prod_if.mac[8]); #endif snprintf(gw_cntl.gw.id,sizeof(gw_cntl.gw.id),"%s%s",prod_if.prod_idx,prod_if.mac); gw_cntl.gw.ability = GW_DEF_ABI; // create dev upload timer ret = os_timer_create(&dev_ul_timer, "dev_ul_timer", os_msec_to_ticks(600), &dev_ul_timer_cb, NULL, OS_TIMER_PERIODIC, OS_TIMER_NO_ACTIVATE); if (ret != WM_SUCCESS) { return OPRT_COM_ERROR; } return OPRT_OK; }
int create_midi_hardware(GenesisContext *context, const char *client_name, void (*events_signal)(struct MidiHardware *), void (*on_devices_change)(struct MidiHardware *), void *userdata, struct MidiHardware **out_midi_hardware) { *out_midi_hardware = nullptr; struct MidiHardware *midi_hardware = create_zero<MidiHardware>(); if (!midi_hardware) { destroy_midi_hardware(midi_hardware); return GenesisErrorNoMem; } midi_hardware->context = context; midi_hardware->on_buffer_overrun = default_on_buffer_overrun; midi_hardware->events_signal = events_signal; midi_hardware->on_devices_change = on_devices_change; midi_hardware->userdata = userdata; if (!(midi_hardware->mutex = os_mutex_create())) { destroy_midi_hardware(midi_hardware); return GenesisErrorNoMem; } if (snd_seq_open(&midi_hardware->seq, "default", SND_SEQ_OPEN_DUPLEX, 0) < 0) { destroy_midi_hardware(midi_hardware); return GenesisErrorOpeningMidiHardware; } if (snd_seq_set_client_name(midi_hardware->seq, client_name) < 0) { destroy_midi_hardware(midi_hardware); return GenesisErrorOpeningMidiHardware; } snd_seq_client_info_malloc(&midi_hardware->client_info); snd_seq_port_info_malloc(&midi_hardware->port_info); if (!midi_hardware->client_info || !midi_hardware->port_info) { destroy_midi_hardware(midi_hardware); return GenesisErrorNoMem; } if (snd_seq_create_simple_port(midi_hardware->seq, "genesis", SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE, SND_SEQ_PORT_TYPE_MIDI_GENERIC | SND_SEQ_PORT_TYPE_APPLICATION) < 0) { destroy_midi_hardware(midi_hardware); return GenesisErrorOpeningMidiHardware; } int err = midi_hardware_refresh(midi_hardware); if (err) { destroy_midi_hardware(midi_hardware); return err; } if (!midi_hardware->system_announce_device) { destroy_midi_hardware(midi_hardware); return GenesisErrorOpeningMidiHardware; } if (snd_seq_connect_from(midi_hardware->seq, 0, midi_hardware->system_announce_device->client_id, midi_hardware->system_announce_device->port_id) < 0) { destroy_midi_hardware(midi_hardware); return GenesisErrorOpeningMidiHardware; } if (snd_seq_get_client_info(midi_hardware->seq, midi_hardware->client_info) < 0) { destroy_midi_hardware(midi_hardware); return GenesisErrorOpeningMidiHardware; } midi_hardware->client_id = snd_seq_client_info_get_client(midi_hardware->client_info); if (snd_seq_connect_from(midi_hardware->seq, 0, midi_hardware->client_id, 0) < 0) { destroy_midi_hardware(midi_hardware); return GenesisErrorOpeningMidiHardware; } if ((err = os_thread_create(midi_thread, midi_hardware, false, &midi_hardware->thread))) { destroy_midi_hardware(midi_hardware); return err; } *out_midi_hardware = midi_hardware; return 0; }
int ordered_map_file_open(const char *path, OrderedMapFile **out_omf) { *out_omf = nullptr; OrderedMapFile *omf = create_zero<OrderedMapFile>(); if (!omf) { ordered_map_file_close(omf); return GenesisErrorNoMem; } if (!(omf->cond = os_cond_create())) { ordered_map_file_close(omf); return GenesisErrorNoMem; } if (!(omf->mutex = os_mutex_create())) { ordered_map_file_close(omf); return GenesisErrorNoMem; } if (omf->queue.error()) { ordered_map_file_close(omf); return omf->queue.error(); } omf->list = create_zero<List<OrderedMapFileEntry *>>(); if (!omf->list) { ordered_map_file_close(omf); return GenesisErrorNoMem; } omf->map = create_zero<HashMap<ByteBuffer, OrderedMapFileEntry *, ByteBuffer::hash>>(); if (!omf->map) { ordered_map_file_close(omf); return GenesisErrorNoMem; } omf->running = true; int err; if ((err = os_thread_create(run_write, omf, false, &omf->write_thread))) { ordered_map_file_close(omf); return err; } bool open_for_writing = false; omf->file = fopen(path, "rb+"); if (omf->file) { int err = read_header(omf); if (err == GenesisErrorEmptyFile) { open_for_writing = true; } else if (err) { ordered_map_file_close(omf); return err; } } else { open_for_writing = true; } if (open_for_writing) { omf->file = fopen(path, "wb+"); if (!omf->file) { ordered_map_file_close(omf); return GenesisErrorFileAccess; } int err = write_header(omf); if (err) { ordered_map_file_close(omf); return err; } } // read everything into list bool partial_transaction = false; omf->write_buffer.resize(TRANSACTION_METADATA_SIZE); omf->transaction_offset = UUID_SIZE; for (;;) { size_t amt_read = fread(omf->write_buffer.raw(), 1, TRANSACTION_METADATA_SIZE, omf->file); if (amt_read != TRANSACTION_METADATA_SIZE) { // partial transaction. ignore it and we're done. if (amt_read > 0) partial_transaction = true; break; } uint8_t *transaction_ptr = (uint8_t*)omf->write_buffer.raw(); int transaction_size = read_uint32be(&transaction_ptr[4]); if (transaction_size < TRANSACTION_METADATA_SIZE || transaction_size > MAX_TRANSACTION_SIZE) { // invalid value partial_transaction = true; break; } omf->write_buffer.resize(transaction_size); transaction_ptr = (uint8_t*)omf->write_buffer.raw(); size_t amt_to_read = transaction_size - TRANSACTION_METADATA_SIZE; amt_read = fread(&transaction_ptr[TRANSACTION_METADATA_SIZE], 1, amt_to_read, omf->file); if (amt_read != amt_to_read) { // partial transaction. ignore it and we're done. partial_transaction = true; break; } uint32_t computed_crc = crc32(0, &transaction_ptr[4], transaction_size - 4); uint32_t crc_from_file = read_uint32be(&transaction_ptr[0]); if (computed_crc != crc_from_file) { // crc check failed. ignore this transaction and we're done. partial_transaction = true; break; } int put_count = read_uint32be(&transaction_ptr[8]); int del_count = read_uint32be(&transaction_ptr[12]); int offset = TRANSACTION_METADATA_SIZE; for (int i = 0; i < put_count; i += 1) { int key_size = read_uint32be(&transaction_ptr[offset]); offset += 4; int val_size = read_uint32be(&transaction_ptr[offset]); offset += 4; OrderedMapFileEntry *entry = create_zero<OrderedMapFileEntry>(); if (!entry) { ordered_map_file_close(omf); return GenesisErrorNoMem; } entry->key = ByteBuffer((char*)&transaction_ptr[offset], key_size); offset += key_size; entry->offset = omf->transaction_offset + offset; entry->size = val_size; offset += val_size; auto old_hash_entry = omf->map->maybe_get(entry->key); if (old_hash_entry) { OrderedMapFileEntry *old_entry = old_hash_entry->value; destroy(old_entry, 1); } omf->map->put(entry->key, entry); } for (int i = 0; i < del_count; i += 1) { int key_size = read_uint32be(&transaction_ptr[offset]); offset += 4; ByteBuffer key((char*)&transaction_ptr[offset], key_size); offset += key_size; auto hash_entry = omf->map->maybe_get(key); if (hash_entry) { OrderedMapFileEntry *entry = hash_entry->value; omf->map->remove(key); destroy(entry, 1); } } omf->transaction_offset += transaction_size; } if (partial_transaction) fprintf(stderr, "Warning: Partial transaction found in project file.\n"); // transfer map to list and sort auto it = omf->map->entry_iterator(); if (omf->list->ensure_capacity(omf->map->size())) { ordered_map_file_close(omf); return GenesisErrorNoMem; } for (;;) { auto *map_entry = it.next(); if (!map_entry) break; ok_or_panic(omf->list->append(map_entry->value)); } omf->map->clear(); destroy_map(omf); omf->list->sort<compare_entries>(); *out_omf = omf; return 0; }