int do_copy_message(unsigned long n, int byuid, void *voidptr) { struct do_copy_info *cpy_info=(struct do_copy_info *)voidptr; int fd; struct imapflags new_flags; --n; fd=imapscan_openfile(current_mailbox, ¤t_maildir_info, n); if (fd < 0) return (0); get_message_flags(current_maildir_info.msgs+n, 0, &new_flags); if (copy_message(fd, cpy_info, &new_flags, acl_flags_adjust(cpy_info->acls, &new_flags) ? NULL : current_maildir_info.msgs[n].keywordMsg, current_maildir_info.msgs[n].uid)) { close(fd); return (-1); } close(fd); current_maildir_info.msgs[n].copiedflag=1; return (0); }
extern si_t send_window_cancel_message(struct egui_uds* uds_ptr, union message* msg, si_t window_descripter) { union message msg_to_be_sent; copy_message(msg, &msg_to_be_sent); message_set_window_cancel(&msg_to_be_sent, window_descripter); return comm_send_message(uds_ptr, &msg_to_be_sent); }
extern si_t send_widget_resize_message(struct egui_uds* uds_ptr, union message* msg, si_t window_descripter, si_t x_axis, si_t y_axis, si_t x_size, si_t y_size) { union message msg_to_be_sent; struct rectangle area = {0}; copy_message(msg, &msg_to_be_sent); rectangle_set(&area, x_axis, y_axis, x_size, y_size); message_set_widget_resize(&msg_to_be_sent, window_descripter, &area); return comm_send_message(uds_ptr, &msg_to_be_sent); }
extern si_t send_widget_move_message(struct egui_uds* uds_ptr, union message* msg, si_t window_descripter, si_t x_offset, si_t y_offset) { union message msg_to_be_sent; struct point p = {0}; point_set(&p, x_offset, y_offset); copy_message(msg, &msg_to_be_sent); message_set_widget_move(&msg_to_be_sent, window_descripter, &p); return comm_send_message(uds_ptr, &msg_to_be_sent); }
/* Send an IPC to another thread. */ NORETURN void sys_ipc_recv(word_t src_thread, word_t operation) { /* Ensure the thread exists. */ if (EXPECT_FALSE(src_thread >= max_tcbs && src_thread != IPC_WAIT_ANY)) { syscall_return_error(IPC_ERROR, EINVAL); } spin_lock(&ipc_lock); /* Get first thread on send queue. */ tcb_t *src = current_tcb->ipc_send_head; /* If there are no threads, go to sleep. */ if (src == NULL) { current_tcb->ipc_waiting_for = src; tcb_t *next = deactivate_self_schedule(THREAD_STATE_WAIT_IPC_RECV); spin_unlock(&ipc_lock); switch_to(next); } /* Otherwise, dequeue the thread. */ dequeue_send(current_tcb, src); /* Copy the message across and wake up the sender. */ copy_message(src, current_tcb); /* Is the sender performing a call? */ if (src->thread_state == THREAD_STATE_WAIT_IPC_CALL) { /* Move it into receive phase. 'ipc_waiting_for' should already be set * to us. */ word_t tid = src->tid; ASSERT(src->ipc_waiting_for == current_tcb); src->thread_state = THREAD_STATE_WAIT_IPC_RECV; spin_unlock(&ipc_lock); syscall_return_success(tid); /* NOTREACHED */ } /* If the sender was not performing a call, wake them up. */ src->ipc_waiting_for = NULL; set_syscall_return_val_success(src, 0); set_syscall_return_val_success(current_tcb, src->tid); tcb_t *next = activate_schedule(src); spin_unlock(&ipc_lock); switch_to(next); /* NOTREACHED */ }
/* * === FUNCTION ====================================================================== * Name: delay_table_add * Description: add msg to delay table * ===================================================================================== */ void delay_table_add(uint64_t key,struct receiver_msg_st *msg){ linklist *msg_list=NULL; struct receiver_msg_st *cmsg = NULL; lnodeptr pnode=NULL; delay_table_delete_obsolete(key); msg_list =(linklist *)hash_find(table,key); cmsg = copy_message(msg); pnode = lnode_malloc((void *)cmsg); if(NULL == msg_list){ lCount++; msg_list = linklist_create(); hash_add(table,key,msg_list); } mCount++; linklist_append(msg_list,pnode); return; }
void delay_table_add(uint64_t key, struct msg_server_s *msg) { tc_pool_t *pool; p_link_node ln; delay_sess_t *s; struct msg_server_s *cmsg; s = (delay_sess_t *) hash_find(table, key); if (s == NULL) { pool = tc_create_pool(TC_DEFAULT_POOL_SIZE, 0); if (pool != NULL) { s = (delay_sess_t *) tc_pcalloc(pool, sizeof(delay_sess_t)); if (s != NULL) { s->key = key; s->pool = pool; s->msg_list = link_list_create(s->pool); s->evt = tc_event_add_timer(s->pool, OUTPUT_INTERVAL, s, tc_delay_del_obs); msg_ls_cnt++; hash_add(table, s->pool, key, s); } else { return; } } else { return; } } cmsg = copy_message(s->pool, msg); if (cmsg != NULL) { ln = link_node_malloc(s->pool, (void *) cmsg); link_list_append(s->msg_list, ln); msg_item_cnt++; } }
/* Send an IPC to another thread. Return the thread that should be next * scheduled. */ static tcb_t * do_send(tcb_t *dest, int is_call, int is_non_blocking) { /* If the thread is not ready to receive, go to sleep or abort the call. */ if (EXPECT_FALSE(!is_ready_to_receive(current_tcb, dest))) goto not_ready; /* Otherwise, copy our message across. */ copy_message(current_tcb, dest); dest->ipc_waiting_for = NULL; set_syscall_return_val_success(dest, current_tcb->tid); /* If we are not performing a call, just wake up the destination and we are * done. */ if (!is_call) { set_syscall_return_val_success(current_tcb, 0); return activate_schedule(dest); } /* Otherwise, wake up the destination and go to sleep. */ current_tcb->ipc_waiting_for = dest; activate(dest); deactivate_self(THREAD_STATE_WAIT_IPC_RECV); return schedule(); /* Destination thread not ready. */ not_ready:; if (is_non_blocking) { /* Return an error and keep running. */ set_syscall_return_val_error(current_tcb, IPC_ERROR, EWOULDBLOCK); return current_tcb; } /* Go to sleep. */ enqueue_send(dest, current_tcb); current_tcb->ipc_waiting_for = dest; return deactivate_self_schedule( is_call ? THREAD_STATE_WAIT_IPC_CALL : THREAD_STATE_WAIT_IPC_SEND); }
/* add message to delay table */ void delay_table_add(uint64_t key, struct msg_server_s *msg) { link_list *msg_list; p_link_node ln; struct msg_server_s *cmsg; msg_list = (link_list *) hash_find(table, key); if (msg_list == NULL) { msg_ls_cnt++; msg_list = link_list_create(); hash_add(table, key, msg_list); } cmsg = copy_message(msg); if (cmsg != NULL) { ln = link_node_malloc((void *) cmsg); link_list_append(msg_list, ln); msg_item_cnt++; } return; }