int swDataBuffer_clear(swDataBuffer *data_buffer, int fd)
{
swDataBuffer_item *item = NULL;
swHashMap_add_int(&data_buffer->map, fd, item);
if (item == NULL)
{
swTrace("buffer item not found\n");
return SW_ERR;
}
else
{
swDataBuffer_trunk *trunk = item->head;
swDataBuffer_trunk *will_free_trunk; //保存trunk的指针，用于释放内存
while (trunk != NULL)
{
sw_free(trunk->data);
will_free_trunk = trunk;
trunk = trunk->next;
sw_free(will_free_trunk);
}
swHashMap_del_int(&data_buffer->map, fd);
sw_free(item);
}
return SW_OK;
}
int swDataBuffer_flush(swDataBuffer *data_buffer, swDataBuffer_item *item)
{
if(item->head == NULL)
{
return SW_ERR;
}
item->head->len = 0;
item->tail = item->head;
item->trunk_num = 1;
item->length = 0;
swDataBuffer_trunk *trunk = item->head->next;
swDataBuffer_trunk *will_free_trunk; //保存trunk的指针，用于释放内存
while (trunk!= NULL)
{
trunk->len = 0;
sw_free(trunk->data);
will_free_trunk = trunk;
trunk = trunk->next; //这里会指向下个指针，所以需要保存
sw_free(will_free_trunk);
// swWarn("will_free_trunk");
}
item->head->next = NULL;
return SW_OK;
}
static int swFactoryThread_writer_loop(swThreadParam *param)
{
swFactory *factory = param->object;
swFactoryThread *this = factory->object;
int pti = param->pti;
int ret;
swEventData *req;
//main loop
while (swoole_running > 0)
{
ret = read(this->writers[pti].evfd, &req, sizeof(&req));
printf("[WriteThread]recv: %d|ret=%d\n", pti, ret);
if (ret > 0)
{
factory->onTask(factory, req);
sw_free(req);
}
else
{
swTrace("[swFactoryThread_writer_loop]read eventfd error");
}
}
//shutdown
close(this->writers[pti].evfd);
sw_free(param);
pthread_exit(SW_OK);
return SW_OK;
}
static void swReactorKqueue_free(swReactor *reactor)
{
swReactorKqueue *this = reactor->object;
close(this->epfd);
sw_free(this->events);
sw_free(this);
}
static int swFactoryThread_writer_loop(swThreadParam *param)
{
swFactory *factory = param->object;
swFactoryThread *this = factory->object;
int pti = param->pti;
swEventData *req;
uint64_t flag;
//main loop
while (swoole_running > 0)
{
if(swRingBuffer_pop(&(this->buffers[pti]), (void **)&req)==0)
{
factory->onTask(factory, req);
sw_free(req);
}
else
{
read(this->writers[pti].evfd, &flag, sizeof(flag));
}
}
factory->running = 0;
//shutdown
close(this->writers[pti].evfd);
sw_free(param);
pthread_exit(SW_OK);
return SW_OK;
}
void swPort_free(swListenPort *port)
{
#ifdef SW_USE_OPENSSL
if (port->ssl)
{
if (port->ssl_context)
{
swSSL_free_context(port->ssl_context);
}
sw_free(port->ssl_option.cert_file);
sw_free(port->ssl_option.key_file);
if (port->ssl_option.client_cert_file)
{
sw_free(port->ssl_option.client_cert_file);
}
}
#endif
close(port->sock);
//remove unix socket file
if (port->type == SW_SOCK_UNIX_STREAM || port->type == SW_SOCK_UNIX_DGRAM)
{
unlink(port->host);
}
}
void swReactorEpoll_free(swReactor *reactor)
{
swReactorEpoll *object = reactor->object;
close(object->epfd);
sw_free(object->events);
sw_free(object);
}
int swBuffer_flush(swBuffer *buffer)
{
if(buffer->head == NULL)
{
return SW_ERR;
}
buffer->head->length = 0;
buffer->tail = buffer->head;
buffer->trunk_num = 1;
buffer->length = 0;
swBuffer_trunk *trunk = buffer->head->next;
swBuffer_trunk *will_free_trunk; //保存trunk的指针，用于释放内存
while (trunk!= NULL)
{
trunk->length = 0;
sw_free(trunk->data);
will_free_trunk = trunk;
trunk = trunk->next; //这里会指向下个指针，所以需要保存
sw_free(will_free_trunk);
// swWarn("will_free_trunk");
}
buffer->head->next = NULL;
return SW_OK;
}
int swTimer_del(swTimer *timer, swTimer_node *tnode)
{
if (tnode->remove)
{
return SW_FALSE;
}
if (SwooleG.timer._current_id > 0 && tnode->id == SwooleG.timer._current_id)
{
tnode->remove = 1;
return SW_TRUE;
}
if (swHashMap_del_int(timer->map, tnode->id) < 0)
{
return SW_ERR;
}
//remove from min-heap
swHeap_remove(timer->heap, tnode->heap_node);
if (tnode->heap_node)
{
sw_free(tnode->heap_node);
}
sw_free(tnode);
timer->num --;
return SW_TRUE;
}
void swReactorEpoll_free(swReactor *reactor)
{
swReactorEpoll *this = reactor->object;
close(this->epfd);
sw_free(this->events);
sw_free(this);
}
int swDataBuffer_clear(swDataBuffer *data_buffer, int fd)
{
swDataBuffer_item *item = NULL;
HASH_FIND_INT(data_buffer->ht, &fd, item);
if (item == NULL)
{
swTrace("buffer item not found\n");
return SW_ERR;
}
else
{
swDataBuffer_trunk *trunk = item->first;
swDataBuffer_trunk *will_free_trunk; //保存trunk的指针，用于释放内存
while (trunk != NULL)
{
sw_free(trunk->data);
will_free_trunk = trunk;
trunk = trunk->next;
sw_free(will_free_trunk);
}
HASH_DEL(data_buffer->ht, item);
sw_free(item);
}
return SW_OK;
}
static int swFactoryThread_writer_loop(swThreadParam *param)
{
swFactory *factory = param->object;
swServer *serv = factory->ptr;
swFactoryThread *this = factory->object;
int pti = param->pti;
int ret;
swEventData *req;
uint64_t flag;
//cpu affinity setting
#if HAVE_CPU_AFFINITY
if (serv->open_cpu_affinity)
{
cpu_set_t cpu_set;
CPU_ZERO(&cpu_set);
CPU_SET(pti % SW_CPU_NUM, &cpu_set);
if (0 != pthread_setaffinity_np(pthread_self(), sizeof(cpu_set), &cpu_set))
{
swTrace("pthread_setaffinity_np set fail\n");
}
}
#endif
if (serv->onWorkerStart != NULL)
{
serv->onWorkerStart(serv, pti);
}
swSingalNone();
//main loop
while (swoole_running > 0)
{
if (swRingQueue_pop(&(this->queues[pti]), (void **) &req) == 0)
{
factory->last_from_id = req->info.from_id;
factory->onTask(factory, req);
sw_free(req);
}
else
{
ret = this->writers[pti].evfd.read(&this->writers[pti].evfd, &flag, sizeof(flag));
if (ret < 0)
{
swTrace("read fail.errno=%d", errno);
}
}
}
//shutdown
this->writers[pti].evfd.close(&this->writers[pti].evfd);
if (serv->onWorkerStop != NULL)
{
serv->onWorkerStop(serv, pti);
}
sw_free(param);
pthread_exit(SW_OK);
return SW_OK;
}
void swTimer_del(swTimer *timer, swTimer_node *tnode)
{
swHeap_remove(timer->heap, tnode->heap_node);
if (tnode->heap_node)
{
sw_free(tnode->heap_node);
}
sw_free(tnode);
}
int swFactoryThread_shutdown(swFactory *factory)
{
swoole_running = 0;
swFactoryThread *this = factory->object;
sw_free(this->writers);
sw_free(this->queues);
sw_free(this);
return SW_OK;
}
static void swProcessPool_free(swProcessPool *pool)
{
int i;
swPipe *pipe;
for (i = 0; i < pool->worker_num; i++)
{
pipe = &pool->pipes[i];
pipe->close(pipe);
}
sw_free(pool->workers);
sw_free(pool->pipes);
swHashMap_free(&pool->map);
}
void swTimeWheel_free(swTimeWheel *tw)
{
int i;
for (i = 0; i < tw->size; i++)
{
if (tw->wheel[i] != NULL)
{
swHashMap_free(tw->wheel[i]);
tw->wheel[i] = NULL;
}
}
sw_free(tw->wheel);
sw_free(tw);
}
static swTimer_node* swTimer_add(swTimer *timer, int _msec, int interval, void *data, swTimerCallback callback)
{
swTimer_node *tnode = sw_malloc(sizeof(swTimer_node));
if (!tnode)
{
swSysError("malloc(%ld) failed.", sizeof(swTimer_node));
return NULL;
}
int64_t now_msec = swTimer_get_relative_msec();
if (now_msec < 0)
{
sw_free(tnode);
return NULL;
}
tnode->data = data;
tnode->type = SW_TIMER_TYPE_KERNEL;
tnode->exec_msec = now_msec + _msec;
tnode->interval = interval ? _msec : 0;
tnode->remove = 0;
tnode->callback = callback;
tnode->round = timer->round;
if (timer->_next_msec < 0 || timer->_next_msec > _msec)
{
timer->set(timer, _msec);
timer->_next_msec = _msec;
}
tnode->id = timer->_next_id++;
if (unlikely(tnode->id < 0))
{
tnode->id = 1;
timer->_next_id = 2;
}
timer->num++;
tnode->heap_node = swHeap_push(timer->heap, tnode->exec_msec, tnode);
if (tnode->heap_node == NULL)
{
sw_free(tnode);
return NULL;
}
swTrace("id=%ld, exec_msec=%" PRId64 ", msec=%d, round=%" PRIu64, tnode->id, tnode->exec_msec, _msec, tnode->round);
swHashMap_add_int(timer->map, tnode->id, tnode);
return tnode;
}
SWINLINE swBuffer_trunk* swConnection_get_in_buffer(swConnection *conn)
{
swBuffer_trunk *trunk = NULL;
swBuffer *buffer;
if (conn->in_buffer == NULL)
{
buffer = swBuffer_new(SW_BUFFER_SIZE);
//buffer create failed
if (buffer == NULL)
{
return NULL;
}
//new trunk
trunk = swBuffer_new_trunk(buffer, SW_TRUNK_DATA, buffer->trunk_size);
if (trunk == NULL)
{
sw_free(buffer);
return NULL;
}
conn->in_buffer = buffer;
}
else
{
buffer = conn->in_buffer;
trunk = buffer->tail;
if (trunk == NULL || trunk->length == buffer->trunk_size)
{
trunk = swBuffer_new_trunk(buffer, SW_TRUNK_DATA, buffer->trunk_size);
}
}
return trunk;
}
static void aio_onReadFileCompleted(swAio_event *event)
{
zval *retval = NULL;
zval *result = NULL;
SW_MAKE_STD_ZVAL(result);
if (event->ret < 0)
{
SwooleG.error = event->error;
ZVAL_BOOL(result, 0);
}
else
{
ZVAL_STRINGL(result, event->buf, event->ret);
sw_free(event->buf);
}
php_context *context = (php_context *) event->object;
int ret = coro_resume(context, result, &retval);
if (ret == CORO_END && retval)
{
sw_zval_ptr_dtor(&retval);
}
sw_zval_ptr_dtor(&result);
efree(event->req);
efree(context);
}
int swServer_reactor_thread_onWrite(swReactor *reactor, swDataHead *ev)
{
swServer *serv = SwooleG.serv;
swConnection *conn = swServer_get_connection(serv, ev->fd);
int ret, sendn;
if (conn->output.send_file != NULL)
{
swTask_sendfile *task = conn->output.send_file;
sendn = (task->filesize - task->offset > SW_SENDFILE_TRUNK) ? SW_SENDFILE_TRUNK : task->filesize - task->offset;
ret = sendfile(ev->fd, task->fd, &task->offset, sendn);
//swWarn("ret=%d|task->offset=%ld|sendn=%d|filesize=%ld", ret, task->offset, sendn, task->filesize);
if (ret < 0)
{
swWarn("sendfile failed. Error: %s[%d]", strerror(errno), errno);
return SW_ERR;
}
if (task->offset >= task->filesize)
{
reactor->set(reactor, ev->fd, SW_EVENT_TCP | SW_EVENT_READ);
conn->output.send_file = NULL;
close(task->fd);
sw_free(task);
}
}
return SW_OK;
}
/**
* Main Loop
*/
static int swServer_poll_loop(swThreadParam *param)
{
swServer *serv = param->object;
int ret, pti = param->pti;
swReactor *reactor = &(serv->threads[pti].reactor);
struct timeval timeo;
ret = swReactorEpoll_create(reactor, (serv->max_conn / serv->poll_thread_num) + 1);
if (ret < 0)
{
return SW_ERR;
}
timeo.tv_sec = serv->timeout_sec;
timeo.tv_usec = serv->timeout_usec; //300ms
reactor->ptr = serv;
reactor->setHandle(reactor, SW_FD_CLOSE, swServer_poll_onClose);
//Thread mode must copy the data.
//will free after onFinish
if(serv->factory_mode == SW_MODE_THREAD)
{
reactor->setHandle(reactor, SW_FD_CONN, swServer_poll_onReceive2);
}
else
{
reactor->setHandle(reactor, SW_FD_CONN, swServer_poll_onReceive);
}
//main loop
reactor->wait(reactor, &timeo);
//shutdown
reactor->free(reactor);
sw_free(param);
return SW_OK;
}
static int swServer_poll_onReceive2(swReactor *reactor, swEvent *event)
{
int ret;
swServer *serv = reactor->ptr;
swFactory *factory = &(serv->factory);
swEventData *buf = sw_malloc(sizeof(swEventData));
if(buf==NULL)
{
swTrace("Malloc fail\n");
return SW_ERR;
}
bzero(buf->data, sizeof(buf->data));
ret = swRead(event->fd, buf->data, SW_BUFFER_SIZE);
if (ret < 0)
{
swTrace("Receive Error.Fd=%d.From=%d\n", event->fd, event->from_id);
return SW_ERR;
}
else if (ret == 0)
{
swTrace("Close Event.FD=%d|From=%d\n", event->fd, event->from_id);
sw_free(buf);
return swServer_close(serv, event);
}
else
{
buf->fd = event->fd;
buf->len = ret;
buf->from_id = event->from_id;
//swTrace("recv: %s|fd=%d|ret=%d|errno=%d\n", buf->data, event->fd, ret, errno);
factory->dispatch(factory, buf);
}
return SW_OK;
}
static void swTable_compress_list(swTable *table)
{
table->lock.lock(&table->lock);
swTableRow **tmp = sw_malloc(sizeof(swTableRow *) * table->size);
if (!tmp)
{
swWarn("malloc() failed, cannot compress the jump table.");
goto unlock;
}
int i, tmp_i = 0;
for (i = 0; i < table->list_n; i++)
{
if (table->rows_list[i] != NULL)
{
tmp[tmp_i] = table->rows_list[i];
tmp[tmp_i]->list_index = tmp_i;
tmp_i++;
}
}
memcpy(table->rows_list, tmp, sizeof(swTableRow *) * tmp_i);
sw_free(tmp);
table->list_n = tmp_i;
unlock: table->lock.unlock(&table->lock);
}
void swClient_free(swClient *cli)
{
assert(cli->socket->fd != 0);
//remove from reactor
if (!cli->socket->closed)
{
cli->close(cli);
}
if (cli->socket->out_buffer)
{
swBuffer_free(cli->socket->out_buffer);
cli->socket->out_buffer = NULL;
}
if (cli->socket->in_buffer)
{
swBuffer_free(cli->socket->in_buffer);
cli->socket->in_buffer = NULL;
}
bzero(cli->socket, sizeof(swConnection));
if (cli->async)
{
cli->socket->removed = 1;
}
else
{
sw_free(cli->socket);
}
}
static int swPipeEventfd_close(swPipe *p)
{
int ret;
ret = close(((swPipeEventfd *)(p->object))->event_fd);
sw_free(p->object);
return ret;
}
static int swFactoryThread_onTask(swThreadPool *pool, void *data, int len)
{
swFactory *factory = pool->ptr2;
int ret = factory->onTask(factory, (swEventData*) data);
sw_free(data);
return ret;
}
static void swProcessPool_free(swProcessPool *pool)
{
int i;
swPipe *_pipe;
if (!pool->use_msgqueue)
{
for (i = 0; i < pool->worker_num; i++)
{
_pipe = &pool->pipes[i];
_pipe->close(_pipe);
}
sw_free(pool->pipes);
}
else if (pool->msgqueue_key == 0)
{
pool->queue->remove = 1;
swMsgQueue_free(pool->queue);
}
if (pool->map)
{
swHashMap_free(pool->map);
}
}
swTimeWheel* swTimeWheel_new(uint16_t size)
{
swTimeWheel *tw = sw_malloc(sizeof(swTimeWheel));
if (!tw)
{
swWarn("malloc(%ld) failed.", sizeof(swTimeWheel));
return NULL;
}
tw->size = size;
tw->current = 0;
tw->wheel = sw_calloc(size, sizeof(void*));
if (tw->wheel == NULL)
{
swWarn("malloc(%ld) failed.", sizeof(void*) * size);
sw_free(tw);
return NULL;
}
int i;
for (i = 0; i < size; i++)
{
tw->wheel[i] = swHashMap_new(16, NULL);
if (tw->wheel[i] == NULL)
{
swTimeWheel_free(tw);
return NULL;
}
}
return tw;
}
int swWorker_create(swWorker *worker)
{
/**
* Create shared memory storage
*/
void *store = sw_shm_malloc(SwooleG.serv->buffer_output_size);
if (store == NULL)
{
swWarn("malloc for worker->store failed.");
return SW_ERR;
}
swPipe *worker_notify = sw_malloc(sizeof(swPipe));
if (worker_notify == NULL)
{
swWarn("malloc for worker->notify failed.");
sw_shm_free(store);
return SW_ERR;
}
/**
* Create notify pipe
*/
if (swPipeNotify_auto(worker_notify, 1, 0))
{
sw_shm_free(store);
sw_free(worker_notify);
return SW_ERR;
}
worker->notify = worker_notify;
worker->store.ptr = store;
worker->store.lock = 0;
return SW_OK;
}
void swPipeUnsock_close(swPipe *p)
{
swPipeUnsock *this = p->object;
close(this->socks[0]);
close(this->socks[1]);
sw_free(this);
}
