void Kernel::copy_fields( Kernel & k_dst , unsigned i_dst , Kernel & k_src , unsigned i_src ) { static const char method[] = "phdmesh::Kernel::copy_fields" ; const std::vector<FieldBase*> & field_set = k_dst.mesh().mesh_meta_data().get_fields(); unsigned char * const s = reinterpret_cast<unsigned char*>(k_src.m_entities); unsigned char * const d = reinterpret_cast<unsigned char*>(k_dst.m_entities); DataMap * j = k_src.m_field_map ; DataMap * i = k_dst.m_field_map ; DataMap * const e = i + field_set.size(); for ( ; i != e ; ++i , ++j ) { if ( i->m_size ) { if ( j->m_size ) { if ( i->m_size == j->m_size ) { memory_copy( d + i->m_base + i->m_size * i_dst , s + j->m_base + j->m_size * i_src , i->m_size ); } else { std::ostringstream msg ; msg << method ; msg << " FAILED WITH INCOMPATIBLE FIELD SIZES" ; throw std::runtime_error( msg.str() ); } } else { memory_zero( d + i->m_base + i->m_size * i_dst , i->m_size ); } } } }
listening_t * conn_listening_add(array_t *listening, pool_t *pool, log_t *log, in_addr_t addr, in_port_t port, event_handler_pt handler, int rbuff_len, int sbuff_len) { uchar_t *address = NULL; listening_t *ls = NULL; struct sockaddr_in *sin = NULL; if (!listening || !pool || !log || (port <= 0)) { return NULL; } //alloc sin addr sin = pool_alloc(pool, sizeof(struct sockaddr_in)); if (!sin) { fast_log_error(log, FAST_LOG_ALERT, 0, "conn_listening_add: pooll alloc sockaddr failed"); return NULL; } sin->sin_family = AF_INET; sin->sin_addr.s_addr = addr; sin->sin_port = htons(port); address = (uchar_t *)inet_ntoa(sin->sin_addr); //push listening socket ls = array_push(listening); if (!ls) { fast_log_error(log, FAST_LOG_ALERT, 0, "conn_listening_add: push listening socket failed!"); return NULL; } memory_zero(ls, sizeof(listening_t)); ls->addr_text.data = pool_calloc(pool, INET_ADDRSTRLEN - 1 + sizeof(":65535") - 1); if (!ls->addr_text.data) { fast_log_error(log, FAST_LOG_ALERT, 0, "conn_listening_add: pool alloc ls->addr text failed"); return NULL; } ls->addr_text.len = string_xxsprintf(ls->addr_text.data, "%s:%d", address, port) - ls->addr_text.data; ls->fd = FAST_INVALID_FILE; ls->family = AF_INET; ls->type = SOCK_STREAM; ls->sockaddr = (struct sockaddr *) sin; ls->socklen = sizeof(struct sockaddr_in); //config from config file ls->backlog = CONN_DEFAULT_BACKLOG; ls->rcvbuf = rbuff_len > CONN_DEFAULT_RCVBUF? rbuff_len: CONN_DEFAULT_RCVBUF; ls->sndbuf = sbuff_len > CONN_DEFAULT_SNDBUF? sbuff_len: CONN_DEFAULT_SNDBUF; //connection pool size ls->conn_psize = CONN_DEFAULT_POOL_SIZE; ls->log = log; ls->handler = handler; ls->open = 0; ls->linger = 1; return ls; }
void conn_set_default(conn_t *c, int s) { event_t *rev = NULL; event_t *wev = NULL; uint32_t instance; uint32_t last_instance; c->fd = s; rev = c->read; wev = c->write; instance = rev->instance; last_instance = rev->last_instance; c->sent = 0; c->conn_data = NULL; c->next = NULL; c->error = 0; c->listening = NULL; c->next = NULL; c->sendfile = FAST_FALSE; c->sndlowat = 0; c->sockaddr = NULL; memory_zero(&c->addr_text, sizeof(string_t)); c->socklen = 0; //set rev & wev->instance to !last->instance memory_zero(rev, sizeof(event_t)); memory_zero(wev, sizeof(event_t)); rev->instance = !instance; wev->instance = !instance; rev->last_instance = last_instance; rev->data = c; wev->data = c; wev->write = FAST_TRUE; }
void Kernel::zero_fields( Kernel & k_dst , unsigned i_dst ) { const std::vector<FieldBase*> & field_set = k_dst.mesh().mesh_meta_data().get_fields(); unsigned char * const p = reinterpret_cast<unsigned char*>(k_dst.m_entities); const DataMap * i = k_dst.m_field_map ; const DataMap * const e = i + field_set.size(); for ( ; i != e ; ++i ) { if ( i->m_size ) { memory_zero( p + i->m_base + i->m_size * i_dst , i->m_size ); } } }
int create_task(task_func program, size_t stack_size, struct task_info **task) { PANIC_ON(program == NULL, "Program pointer cannot be NULL"); PANIC_ON(stack_size == 0, "Cannot create task with stack size of 0."); *task = malloc(sizeof(struct task_info)); if(!*task) return -1; uint8_t *stack = (uint8_t*)malloc(stack_size); uint8_t *stack_base = stack + stack_size; if(!stack) { free(*task); return -1; } memory_zero(stack, stack_size); (*task)->stack_ptr = stack; (*task)->stack_base = stack + stack_size; (*task)->current_sp = stack + stack_size; (*task)->program = program; stack_push(*task, 514); // EFLAGS (No idea what to put here, I inspected EFLAGS at some random location and found it had the value 514) stack_push(*task, 0x08); // code segment stack_push(*task, (uint32_t)program); // EIP stack_push(*task, 0x0); // edi stack_push(*task, 0x0); // esi stack_push(*task, 0x0); // ebx stack_push(*task, 0x0); // edx stack_push(*task, 0x0); // ecx stack_push(*task, 0x0); // eax char buf[92]; uint32_t *ebp = (uint32_t*)(*task)->stack_base; uint32_t *esp = (uint32_t*)(*task)->current_sp; snprintf(buf, 92, "DEBUG: created new task with EBP: %d, ESP: %d\n", 2, ebp, esp); print(buf); return 0; }