void vfs_mngr_fs_remount(void)
{
sync_lock();
// Only start a remount if in the connected state and not in a transition
if (!changing_state() && (VFS_MNGR_STATE_CONNECTED == vfs_state)) {
vfs_state_next = VFS_MNGR_STATE_RECONNECTING;
}
sync_unlock();
}
// Rebuild the virtual filesystem. This must only be called
// when mass storage is inactive.
void vfs_user_enable(bool enable)
{
sync_lock();
if (enable) {
if (VFS_USER_STATE_DISCONNECTED == vfs_state_next) {
vfs_state_remaining_ms = connect_delay_ms;
vfs_state_next = VFS_USER_STATE_CONNECTED;
}
} else {
vfs_state_remaining_ms = disconnect_delay_ms;
vfs_state_next = VFS_USER_STATE_DISCONNECTED;
}
sync_unlock();
}
void vfs_mngr_fs_enable(bool enable)
{
sync_lock();
if (enable) {
if (VFS_MNGR_STATE_DISCONNECTED == vfs_state_next) {
vfs_state_next = VFS_MNGR_STATE_CONNECTED;
}
} else {
vfs_state_next = VFS_MNGR_STATE_DISCONNECTED;
}
sync_unlock();
}
void * vector_get(vector_t *vector,int index)
{
uint32_t get_pos = index;
uint8_t *vector_head = vector->vector_head;
uint32_t step = vector->step;
void * ret = NULL;
dbg_str(DBG_CONTAINER_DETAIL,"get_pos=%d",get_pos);
sync_lock(&vector->vector_lock,NULL);
ret = (vector_head + get_pos * step);
sync_unlock(&vector->vector_lock);
return ret;
}
int vector_pop_back(vector_t *vector)
{
uint32_t pop_pos = vector->end.vector_pos;
dbg_str(DBG_CONTAINER_DETAIL,"pop back");
sync_lock(&vector->vector_lock,NULL);
if(!vector_pos_equal(&vector->begin,&vector->end)){
vector_pos_init(&vector->end,--pop_pos,vector);
} else{
dbg_str(DBG_CONTAINER_WARNNING,"vector is NULL");
}
sync_unlock(&vector->vector_lock);
return 0;
}
/* Called at shutdown to tidy the lockspace */
void destroy_lvhash()
{
struct dm_hash_node *v;
struct lv_info *lvi;
char *resource;
int status;
pthread_mutex_lock(&lv_hash_lock);
dm_hash_iterate(v, lv_hash) {
lvi = dm_hash_get_data(lv_hash, v);
resource = dm_hash_get_key(lv_hash, v);
if ((status = sync_unlock(resource, lvi->lock_id)))
DEBUGLOG("unlock_all. unlock failed(%d): %s\n",
status, strerror(errno));
free(lvi);
}
int vector_set(vector_t *vector,int index,void *data)
{
uint32_t set_pos = index;
uint32_t end_pos = vector->end.vector_pos;
void *vector_head = vector->vector_head;
uint32_t step = vector->step;
int ret = 0;
dbg_str(DBG_CONTAINER_DETAIL,"set_pos=%d",set_pos);
sync_lock(&vector->vector_lock,NULL);
memcpy(vector_head + set_pos * step,data,step);
if(set_pos > end_pos){
vector_pos_init(&vector->end,set_pos,vector);
}
sync_unlock(&vector->vector_lock);
return ret;
}
int vector_insert(vector_t *vector, vector_pos_t *it, void *data)
{
uint32_t insert_pos = it->vector_pos;
uint32_t end_pos = vector->end.vector_pos;
uint32_t count = end_pos - insert_pos;
void *vector_head = vector->vector_head;
uint32_t step = vector->step;
vector_pos_t to;
vector_pos_init(&to,insert_pos + 1,vector);
dbg_str(DBG_CONTAINER_DETAIL,"insert_pos=%d,to_pos=%d",insert_pos,to.vector_pos);
sync_lock(&vector->vector_lock,NULL);
vector_copy(vector,&to,it,count);
memcpy(vector_head + insert_pos * step,data,step);
vector_pos_init(&vector->end,end_pos + 1,vector);
sync_unlock(&vector->vector_lock);
return 0;
}
int vector_delete(vector_t *vector, vector_pos_t *it)
{
uint32_t delete_pos = it->vector_pos;
uint32_t end_pos = vector->end.vector_pos;
uint32_t count = end_pos - delete_pos;
vector_pos_t from;
vector_pos_init(&from,delete_pos + 1,vector);
sync_lock(&vector->vector_lock,0);
if(vector_pos_equal(it,&vector->end)){
dbg_str(DBG_CONTAINER_WARNNING,"can't del end pos");
}else if(vector_pos_equal(it,&vector->begin)&&vector_pos_equal(&from,&vector->end)){
dbg_str(DBG_CONTAINER_WARNNING,"vector is NULL");
}else{
vector_copy(vector,it,&from,count);
vector_pos_init(&vector->end,end_pos - 1,vector);
}
sync_unlock(&vector->vector_lock);
return 0;
}
void mempool_attach_list(struct list_head *new_head,struct list_head *hl_head)
{
cds_mempool_head_list_t *head_list;
head_list = container_of(hl_head,cds_mempool_head_list_t,list_head);
sync_lock(&head_list->head_lock,NULL);
/*
*pthread_rwlock_wrlock(&head_list->head_lock);
*/
list_add(new_head,hl_head);
head_list->count++;
sync_unlock(&head_list->head_lock);
/*
*pthread_rwlock_unlock(&head_list->head_lock);
*/
/*
*dbg_str(DBG_ALLOC_DETAIL,"add head:%p hl_head:%p",new_head,hl_head);
*dbg_str(DBG_ALLOC_DETAIL,"new heads next:%p, prev:%p",new_head->next,new_head->prev);
*dbg_str(DBG_ALLOC_DETAIL,"add mempool list,list count =%d",head_list->count);
*/
}
int log_print_print_str_vl(debugger_t *debugger,size_t level,const char *fmt,va_list vl)
{
#define MAX_LOG_PRINT_BUFFER_LEN 1024*4
char buffer_str[MAX_LOG_PRINT_BUFFER_LEN];
size_t ret = 0,offset = 0;
debug_log_prive_t *log_priv = &debugger->priv.log;
level = 0;
/*
*pthread_mutex_t *lock = &log_priv->log_file_lock;
*pthread_mutex_lock(lock);
*/
sync_lock(&log_priv->log_file_lock,NULL);
memset(buffer_str,'\0',MAX_LOG_PRINT_BUFFER_LEN);
offset = vsnprintf(buffer_str,MAX_LOG_PRINT_BUFFER_LEN,fmt,vl);
ret = log_print_write_log(log_priv->fp,buffer_str);
sync_unlock(&log_priv->log_file_lock);
/*
*pthread_mutex_unlock(&log_priv->log_file_lock);
*/
return ret;
#undef MAX_LOG_PRINT_BUFFER_LEN
}
static int control_unlock(struct gfs2_sbd *sdp)
{
struct lm_lockstruct *ls = &sdp->sd_lockstruct;
return sync_unlock(sdp, &ls->ls_control_lksb, "control_lock");
}
static int mounted_unlock(struct gfs2_sbd *sdp)
{
struct lm_lockstruct *ls = &sdp->sd_lockstruct;
return sync_unlock(sdp, &ls->ls_mounted_lksb, "mounted_lock");
}
void vfs_user_periodic(uint32_t elapsed_ms)
{
vfs_user_state_t vfs_state_local;
vfs_user_state_t vfs_state_local_prev;
sync_assert_usb_thread();
sync_lock();
// Return immediately if the desired state has been reached
if (!changing_state()) {
sync_unlock();
return;
}
// Wait until the required amount of time has passed
// before changing state
if (vfs_state_remaining_ms > 0) {
vfs_state_remaining_ms -= MIN(elapsed_ms, vfs_state_remaining_ms);
sync_unlock();
return;
}
vfs_user_printf("vfs_user_periodic()\r\n");
// Transistion to new state
vfs_state_local_prev = vfs_state;
vfs_state = vfs_state_next;
switch (vfs_state) {
case VFS_USER_STATE_RECONNECTING:
// Transition back to the connected state
vfs_state_next = VFS_USER_STATE_CONNECTED;
vfs_state_remaining_ms = reconnect_delay_ms;
break;
default:
// No state change logic required in other states
break;
}
vfs_state_local = vfs_state;
sync_unlock();
// Processing when leaving a state
vfs_user_printf(" state %i->%i\r\n", vfs_state_local_prev, vfs_state_local);
switch (vfs_state_local_prev) {
case VFS_USER_STATE_DISCONNECTED:
// No action needed
break;
case VFS_USER_STATE_RECONNECTING:
// No action needed
break;
case VFS_USER_STATE_CONNECTED:
if (file_transfer_state.stream_open) {
error_t status;
file_transfer_state.stream_open = false;
status = stream_close();
if (ERROR_SUCCESS == fail_reason) {
fail_reason = status;
}
vfs_user_printf(" stream_close ret %i\r\n", status);
}
// Reset if programming was successful //TODO - move to flash layer
if (daplink_is_bootloader() && (ERROR_SUCCESS == fail_reason)) {
NVIC_SystemReset();
}
// If hold in bootloader has been set then reset after usb is disconnected
if (daplink_is_interface() && config_ram_get_hold_in_bl()) {
NVIC_SystemReset();
}
// Resume the target if configured to do so //TODO - move to flash layer
if (config_get_auto_rst()) {
target_set_state(RESET_RUN);
}
break;
}
// Processing when entering a state
switch (vfs_state_local) {
case VFS_USER_STATE_DISCONNECTED:
USBD_MSC_MediaReady = 0;
break;
case VFS_USER_STATE_RECONNECTING:
USBD_MSC_MediaReady = 0;
break;
case VFS_USER_STATE_CONNECTED:
build_filesystem();
USBD_MSC_MediaReady = 1;
break;
}
return;
}
void vfs_mngr_periodic(uint32_t elapsed_ms)
{
bool change_state;
vfs_mngr_state_t vfs_state_local;
vfs_mngr_state_t vfs_state_local_prev;
sync_assert_usb_thread();
sync_lock();
// Return immediately if the desired state has been reached
if (!changing_state()) {
sync_unlock();
return;
}
change_state = ready_for_state_change();
if (time_usb_idle < MAX_EVENT_TIME_MS) {
time_usb_idle += elapsed_ms;
}
sync_unlock();
if (!change_state) {
return;
}
vfs_mngr_printf("vfs_mngr_periodic()\r\n");
vfs_mngr_printf(" time_usb_idle=%i\r\n", time_usb_idle);
vfs_mngr_printf(" transfer_state=%i\r\n", file_transfer_state.transfer_state);
// Transistion to new state
vfs_state_local_prev = vfs_state;
vfs_state = vfs_state_next;
switch (vfs_state) {
case VFS_MNGR_STATE_RECONNECTING:
// Transition back to the connected state
vfs_state_next = VFS_MNGR_STATE_CONNECTED;
break;
default:
// No state change logic required in other states
break;
}
vfs_state_local = vfs_state;
time_usb_idle = 0;
sync_unlock();
// Processing when leaving a state
vfs_mngr_printf(" state %i->%i\r\n", vfs_state_local_prev, vfs_state_local);
switch (vfs_state_local_prev) {
case VFS_MNGR_STATE_DISCONNECTED:
// No action needed
break;
case VFS_MNGR_STATE_RECONNECTING:
// No action needed
break;
case VFS_MNGR_STATE_CONNECTED:
// Close ongoing transfer if there is one
if (file_transfer_state.transfer_state != TRASNFER_FINISHED) {
vfs_mngr_printf(" transfer timeout\r\n");
file_transfer_state.transfer_timeout = true;
transfer_update_state(ERROR_SUCCESS);
}
util_assert(TRASNFER_FINISHED == file_transfer_state.transfer_state);
vfs_user_disconnecting();
break;
}
// Processing when entering a state
switch (vfs_state_local) {
case VFS_MNGR_STATE_DISCONNECTED:
USBD_MSC_MediaReady = 0;
break;
case VFS_MNGR_STATE_RECONNECTING:
USBD_MSC_MediaReady = 0;
break;
case VFS_MNGR_STATE_CONNECTED:
build_filesystem();
USBD_MSC_MediaReady = 1;
break;
}
return;
}
void timer_unlock (void)
{
sync_unlock (&core_timer);
}
