Example #1
0
swDataBuffer_trunk * swDataBuffer_newTrunk(swDataBuffer *data_buffer, swDataBuffer_item *item)
{
	swDataBuffer_trunk *trunk = sw_malloc(sizeof(swDataBuffer_trunk));
	if (trunk == NULL)
	{
		swWarn("malloc for trunk failed. Error: %s[%d]", strerror(errno), errno);
		return NULL;
	}
	char *buf = sw_malloc(data_buffer->trunk_size);
	if (buf == NULL)
	{
		swWarn("malloc for data failed. Error: %s[%d]", strerror(errno), errno);
		sw_free(trunk);
		return NULL;
	}
	bzero(trunk, sizeof(swDataBuffer_trunk));
	trunk->data = buf;
	item->trunk_num++;

	if(item->head == NULL)
	{
		item->tail = item->head = trunk;
	}
	else
	{
		item->tail->next = trunk;
		item->tail = trunk;
	}
	return trunk;
}
Example #2
0
swRbtree* swRbtree_new()
{
    swRbtree *rbtree = sw_malloc(sizeof(swRbtree));
    swRbtree_node *sentinel = sw_malloc(sizeof(swRbtree_node));

    sentinel->color = 0;
    rbtree->root = sentinel;
    rbtree->sentinel = sentinel;
    return rbtree;
}
Example #3
0
int swAio_dispatch(swAio_event *_event)
{
    if (SwooleAIO.init == 0)
    {
        swAio_init();
    }

    _event->task_id = SwooleAIO.current_id++;

    swAio_event *event = (swAio_event *) sw_malloc(sizeof(swAio_event));
    if (event == NULL)
    {
        swWarn("malloc failed");
        return SW_ERR;
    }
    memcpy(event, _event, sizeof(swAio_event));

    if (swThreadPool_dispatch(&pool, event, sizeof(event)) < 0)
    {
        return SW_ERR;
    }
    else
    {
        SwooleAIO.task_num++;
        return _event->task_id;
    }
}
Example #4
0
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);
}
Example #5
0
swMemoryPool *swRingBuffer_new(uint32_t size, uint8_t shared)
{
    void *mem = (shared == 1) ? sw_shm_malloc(size) : sw_malloc(size);
    if (mem == NULL)
    {
        swWarn("malloc(%d) failed.", size);
        return NULL;
    }

    swRingBuffer *object = mem;
    mem = (char *) mem + sizeof(swRingBuffer);
    bzero(object, sizeof(swRingBuffer));

    object->size = (size - sizeof(swRingBuffer) - sizeof(swMemoryPool));
    object->shared = shared;

    swMemoryPool *pool = mem;
    mem = (char *) mem + sizeof(swMemoryPool);

    pool->object = object;
    pool->destroy = swRingBuffer_destory;
    pool->free = swRingBuffer_free;
    pool->alloc = swRingBuffer_alloc;

    object->memory = mem;

    swDebug("memory: ptr=%p", mem);

    return pool;
}
Example #6
0
static int swAioBase_read(int fd, void *inbuf, size_t size, off_t offset)
{
    swAio_event *aio_ev = (swAio_event *) sw_malloc(sizeof(swAio_event));
    if (aio_ev == NULL)
    {
        swWarn("malloc failed.");
        return SW_ERR;
    }

    bzero(aio_ev, sizeof(swAio_event));
    aio_ev->fd = fd;
    aio_ev->buf = inbuf;
    aio_ev->type = SW_AIO_READ;
    aio_ev->nbytes = size;
    aio_ev->offset = offset;
    aio_ev->task_id = SwooleAIO.current_id++;

    if (swThreadPool_dispatch(&swAioBase_thread_pool, aio_ev, sizeof(aio_ev)) < 0)
    {
        return SW_ERR;
    }
    else
    {
        SwooleAIO.task_num++;
        return aio_ev->task_id;
    }
}
Example #7
0
int swReactorEpoll_create(swReactor *reactor, int max_event_num)
{
    //create reactor object
    swReactorEpoll *reactor_object = sw_malloc(sizeof(swReactorEpoll));
    if (reactor_object == NULL)
    {
        swWarn("malloc[0] fail\n");
        return SW_ERR;
    }
    reactor->object = reactor_object;
    reactor_object->events = sw_calloc(max_event_num, sizeof(struct epoll_event));

    if (reactor_object->events == NULL)
    {
        swWarn("malloc[1] fail\n");
        return SW_ERR;
    }
    //epoll create
    reactor_object->event_max = 0;
    reactor_object->epfd = epoll_create(512);
    if (reactor_object->epfd < 0)
    {
        swWarn("epoll_create fail.Error: %s[%d]", strerror(errno), errno);
        return SW_ERR;
    }
    //binding method
    reactor->add = swReactorEpoll_add;
    reactor->set = swReactorEpoll_set;
    reactor->del = swReactorEpoll_del;
    reactor->wait = swReactorEpoll_wait;
    reactor->free = swReactorEpoll_free;
    reactor->setHandle = swReactor_setHandle;
    return SW_OK;
}
Example #8
0
long swTimer_addtimeout(swTimer *timer, int timeout_ms, void *data)
{
    int new_interval = swoole_common_divisor(timeout_ms, timer->interval);
    if (new_interval < timer->interval)
    {
        swTimer_set(timer, new_interval);
        timer->interval = new_interval;
    }

    struct timeval now;
    if (gettimeofday(&now, NULL) < 0)
    {
        swWarn("gettimeofday() failed. Error: %s[%d]", strerror(errno), errno);
        return SW_ERR;
    }

    uint32_t now_ms = now.tv_sec * 1000 + now.tv_usec / 1000;
    swTimer_node *node = sw_malloc(sizeof(swTimer_node));
    if (node == NULL)
    {
        swWarn("malloc(%d) failed. Error: %s[%d]", (int ) sizeof(swTimer_node), strerror(errno), errno);
        return SW_ERR;
    }

    bzero(node, sizeof(swTimer_node));
    node->data = data;
    node->exec_msec = now_ms + timeout_ms;
    node->id = timer->_next_id++;
    swTimer_node_insert(&timer->root, node);

    return node->id;
}
Example #9
0
int swPipeBase_create(swPipe *p, int blocking)
{
	int ret;
	swPipeBase *object = sw_malloc(sizeof(swPipeBase));
	if (object == NULL)
	{
		return -1;
	}
	p->blocking = blocking;
	ret = pipe(object->pipes);
	if (ret < 0)
	{
		swWarn("pipe create fail. Error: %s[%d]", strerror(errno), errno);
		return -1;
	}
	else
	{
		//Nonblock
		if(blocking == 0)
		{
			swSetNonBlock(object->pipes[0]);
			swSetNonBlock(object->pipes[1]);
		}
		p->object = object;
		p->read = swPipeBase_read;
		p->write = swPipeBase_write;
		p->getFd = swPipeBase_getFd;
		p->close = swPipeBase_close;
	}
	return 0;
}
Example #10
0
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;
}
Example #11
0
static long swTimer_add(swTimer *timer, int msec, int interval, void *data)
{
    if (interval == 0)
    {
        return swTimer_addtimeout(timer, msec, data);
    }
    swTimer_node *node = sw_malloc(sizeof(swTimer_node));
    if (node == NULL)
    {
        swWarn("malloc failed.");
        return SW_ERR;
    }

    bzero(node, sizeof(swTimer_node));
    node->interval = msec;
    if (gettimeofday(&node->lasttime, NULL) < 0)
    {
        swSysError("gettimeofday() failed.");
        return SW_ERR;
    }
    if (msec < timer->interval)
    {
        int new_interval = swoole_common_divisor(msec, timer->interval);
        timer->interval = new_interval;
        swTimer_set(timer, new_interval);
    }
    swHashMap_add_int(timer->list, msec, node, NULL);
    timer->num++;
    return SW_OK;
}
Example #12
0
int swTimer_add(swTimer *timer, int ms)
{
	swTimer_node *node = sw_malloc(sizeof(swTimer_node));
	if (node == NULL)
	{
		swWarn("swTimer_add malloc fail");
		return SW_ERR;
	}
	bzero(node, sizeof(swTimer_node));
	node->lasttime = swTimer_get_ms();
	node->interval = ms;

	if(ms < timer->interval)
	{
		int new_interval = swoole_common_divisor(ms, timer->interval);
		timer->interval = new_interval;
#if defined(HAVE_TIMERFD) && SW_WORKER_IPC_MODE == 1
		swTimer_timerfd_set(timer, new_interval);
#else
		swTimer_signal_set(timer, new_interval);
#endif
	}
	swHashMap_add_int(&timer->list, ms, node);
	timer->num++;
	return SW_OK;
}
Example #13
0
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;
}
Example #14
0
int swReactorPoll_create(swReactor *reactor, int max_fd_num)
{
	//create reactor object
	swReactorPoll *object = sw_malloc(sizeof(swReactorPoll));
	if (object == NULL)
	{
		swError("malloc[0] failed");
		return SW_ERR;
	}
	bzero(object, sizeof(swReactorPoll));

	object->fds = sw_calloc(max_fd_num, sizeof(swPollFdInfo));
	if (object->fds == NULL)
	{
		swError("malloc[1] failed");
		return SW_ERR;
	}
	object->events = sw_calloc(max_fd_num, sizeof(struct pollfd));
	if (object->events == NULL)
	{
		swError("malloc[2] failed");
		return SW_ERR;
	}
	object->max_fd_num = max_fd_num;
	bzero(reactor->handle, sizeof(reactor->handle));
	reactor->object = object;
	//binding method
	reactor->add = swReactorPoll_add;
	reactor->del = swReactorPoll_del;
	reactor->set = swReactorPoll_set;
	reactor->wait = swReactorPoll_wait;
	reactor->free = swReactorPoll_free;
	reactor->setHandle = swReactor_setHandle;
	return SW_OK;
}
Example #15
0
int swPipeUnsock_create(swPipe *p, int blocking, int protocol)
{
	int ret;
	swPipeUnsock *object = sw_malloc(sizeof(swPipeUnsock));
	if (object == NULL)
	{
		return -1;
	}
	p->blocking = blocking;
	ret = socketpair(PF_LOCAL, protocol, 0, object->socks);
	if (ret < 0)
	{
		return -1;
	}
	else
	{
		//Nonblock
		if (blocking == 0)
		{
			swSetNonBlock(object->socks[0]);
			swSetNonBlock(object->socks[1]);
		}
		p->object = object;
		p->read = swPipeUnsock_read;
		p->write = swPipeUnsock_write;
		p->getFd = swPipeUnsock_getFd;
		p->close = swPipeUnsock_close;
	}
	return 0;
}
Example #16
0
static int swAioLinux_write(int fd, void *inbuf, size_t size, off_t offset)
{
    struct iocb *iocbps[1];
    struct iocb *iocbp = sw_malloc(sizeof(struct iocb));
    if (iocbp == NULL)
    {
        swWarn("malloc failed.");
        return SW_ERR;
    }
    bzero(iocbp, sizeof(struct iocb));

    iocbp->aio_fildes = fd;
    iocbp->aio_lio_opcode = IOCB_CMD_PWRITE;
    iocbp->aio_buf = (__u64 ) inbuf;
    iocbp->aio_offset = offset;
    iocbp->aio_nbytes = size;
    iocbp->aio_flags = IOCB_FLAG_RESFD;
    iocbp->aio_resfd = swoole_aio_eventfd;
    iocbp->aio_reqprio = SwooleAIO.current_id++;
    //iocbp->aio_data = (__u64) aio_callback;
    iocbps[0] = iocbp;

    if (io_submit(swoole_aio_context, 1, iocbps) == 1)
    {
        SwooleAIO.task_num++;
        return iocbp->aio_reqprio;
    }
    swWarn("io_submit failed. Error: %s[%d]", strerror(errno), errno);
    return SW_ERR;
}
Example #17
0
int swAio_dns_lookup(void *hostname, void *ip_addr, size_t size)
{
    swAio_event *aio_ev = (swAio_event *) sw_malloc(sizeof(swAio_event));
    if (aio_ev == NULL)
    {
        swWarn("malloc failed.");
        return SW_ERR;
    }

    bzero(aio_ev, sizeof(swAio_event));
    aio_ev->buf = ip_addr;
    aio_ev->req = hostname;
    aio_ev->type = SW_AIO_DNS_LOOKUP;
    aio_ev->nbytes = size;
    aio_ev->task_id = SwooleAIO.current_id++;

    if (swThreadPool_dispatch(&swAioBase_thread_pool, aio_ev, sizeof(aio_ev)) < 0)
    {
        return SW_ERR;
    }
    else
    {
        SwooleAIO.task_num++;
        return aio_ev->task_id;
    }
}
Example #18
0
/**
* @brief 
*	Function to assign a file descriptor and necessary information to a file
*	structure inorder to pursue subsequent operations
* @param finfo
*	Pointer to a file structure where the file information is stored
* @param entry
*	Pointer to the directory entry of the file/directory 
* @param mode
*	Mode in which the file is requested to be opened
* @return 
*	File descriptor of the file
*/
int retrieve_file_info(file_info *finfo,dir_entry *entry,u8 mode,
					   u8 *dir_offset,const char *path)
{
	file_info *temp;
	if(file_head == NULL)
		file_head = finfo;
	else{
		temp = file_head;
                while(temp->next != NULL)
                        temp = temp->next;
                temp->next = finfo;

	}
	finfo->fd = fdes = fdes + 1;
	finfo->file_path = sw_malloc(sizeof(char) * (sw_strlen(path) + 1));
	sw_strcpy(finfo->file_path,path);
	finfo->entry = entry;
	finfo->strt_cluster = (entry->strt_clus_hword)<<16 | 
			      (entry->strt_clus_lword);
	finfo->cur_cluster = finfo->strt_cluster;
	finfo->cur_offset = 0;
	finfo->file_size = entry->size;
	finfo->mode = mode;
	finfo->bytes_traversed = 0;
	finfo->dir_entry_offset = dir_offset;
	finfo->next = NULL;
	
	return(finfo->fd);
}
Example #19
0
static int swEventTimer_add(swTimer *timer, int _msec, int interval, void *data)
{
    swTimer_node *node = sw_malloc(sizeof(swTimer_node));
    if (!node)
    {
        swSysError("malloc(%d) failed.", (int )sizeof(swTimer_node));
        return SW_ERR;
    }

    int now_msec = swEventTimer_get_relative_msec();
    if (now_msec < 0)
    {
        return SW_ERR;
    }

    node->data = data;
    node->exec_msec = now_msec + _msec;
    node->interval = interval ? _msec : 0;

    if (SwooleG.main_reactor->timeout_msec > _msec)
    {
        SwooleG.main_reactor->timeout_msec = _msec;
    }

    swTimer_node_insert(&timer->root, node);
    return SW_OK;
}
Example #20
0
void* swHeap_push(swHeap *heap, uint64_t priority, void *data)
{
    void *tmp;
    uint32_t i;
    uint32_t newsize;

    if (heap->num >= heap->size)
    {
        newsize = heap->size * 2;
        if (!(tmp = sw_realloc(heap->nodes, sizeof(void *) * newsize)))
        {
            return NULL;
        }
        heap->nodes = tmp;
        heap->size = newsize;
    }

    swHeap_node *node = sw_malloc(sizeof(swHeap_node));
    if (!node)
    {
        return NULL;
    }
    node->priority = priority;
    node->data = data;
    i = heap->num++;
    heap->nodes[i] = node;
    swHeap_bubble_up(heap, i);
    return node;
}
Example #21
0
int swReactorKqueue_create(swReactor *reactor, int max_event_num)
{
	//create reactor object
	swReactorKqueue *reactor_object = sw_malloc(sizeof(swReactorKqueue));
	if (reactor_object == NULL)
	{
		swTrace("[swReactorKqueueCreate] malloc[0] fail\n");
		return SW_ERR;
	}
	reactor->object = reactor_object;
	reactor_object->events = sw_calloc(max_event_num, sizeof(struct kevent));

	if (reactor_object->events == NULL)
	{
		swTrace("[swReactorKqueueCreate] malloc[1] fail\n");
		return SW_ERR;
	}
	//kqueue create
	reactor_object->event_max = max_event_num;
	reactor_object->epfd = kqueue();
	if (reactor_object->epfd < 0)
	{
		swTrace("[swReactorKqueueCreate] kqueue_create[0] fail\n");
		return SW_ERR;
	}

	//binding method
	reactor->add = swReactorKqueue_add;
	reactor->set = swReactorKqueue_set;
	reactor->del = swReactorKqueue_del;
	reactor->wait = swReactorKqueue_wait;
	reactor->free = swReactorKqueue_free;
	reactor->setHandle = swReactor_setHandle;
	return SW_OK;
}
Example #22
0
int swPipeMsg_create(swPipe *p, int blocking, int msg_key, long type)
{
	int msg_id;
	swPipeMsg *object = sw_malloc(sizeof(swPipeMsg));
	if (object == NULL)
	{
		return -1;
	}
	if (blocking == 0)
	{
		object->ipc_wait = IPC_NOWAIT;
	}
	else
	{
		object->ipc_wait = 0;
	}
	p->blocking = blocking;
	msg_id = msgget(msg_key, IPC_CREAT | 0666);
	if (msg_id < 0)
	{
		return -1;
	}
	else
	{
		object->msg_id = msg_id;
		object->type = type;
		p->object = object;
		p->read = swPipeMsg_read;
		p->write = swPipeMsg_write;
		p->getFd = swPipeMsg_getFd;
		p->close = swPipeMsg_close;
	}
	return 0;
}
Example #23
0
static int swFactoryProcess_writer_start(swFactory *factory)
{
	swFactoryProcess *this = factory->object;
	swThreadParam *param;
	int i;
	pthread_t pidt;

	for (i = 0; i < this->writer_num; i++)
	{
		param = sw_malloc(sizeof(swThreadParam));
		if (param == NULL)
		{
			swTrace("malloc fail\n");
			return SW_ERR;
		}
		param->object = factory;
		param->pti = i;

		if (pthread_create(&pidt, NULL, (void * (*)(void *)) swFactoryProcess_writer_loop, (void *) param) < 0)
		{
			swTrace("pthread_create fail\n");
			return SW_ERR;
		}
		this->writers[i].ptid = pidt;
		SW_START_SLEEP;
	}
	return SW_OK;
}
Example #24
0
int swReactorEpoll_create(swReactor *reactor, int max_event_num)
{
	//create reactor object
	swReactorEpoll *reactor_object = sw_malloc(sizeof(swReactorEpoll));
	if (reactor_object == NULL)
	{
		swTrace("[swReactorEpollCreate] malloc[0] fail\n");
		return SW_ERR;
	}
	reactor->object = reactor_object;
	reactor_object->events = sw_calloc(max_event_num, sizeof(struct epoll_event));

	if (reactor_object->events == NULL)
	{
		swTrace("[swReactorEpollCreate] malloc[1] fail\n");
		return SW_ERR;
	}
	//epoll create
	reactor_object->event_max = 0;
	reactor_object->epfd = epoll_create(512);
	if (reactor_object->epfd < 0)
	{
		swTrace("[swReactorEpollCreate] epoll_create[0] fail\n");
		return SW_ERR;
	}
	//binding method
	reactor->add = swReactorEpoll_add;
	reactor->del = swReactorEpoll_del;
	reactor->wait = swReactorEpoll_wait;
	reactor->free = swReactorEpoll_free;
	reactor->setHandle = swReactor_setHandle;
	return SW_OK;
}
Example #25
0
int swTimer_add(swTimer *timer, int ms)
{
	swTimer_node *node = sw_malloc(sizeof(swTimer_node));
	if (node == NULL)
	{
		swWarn("malloc failed.");
		return SW_ERR;
	}

	bzero(node, sizeof(swTimer_node));
	node->lasttime = swTimer_get_ms();
	node->interval = ms;

	if (ms < timer->interval)
	{
		int new_interval = swoole_common_divisor(ms, timer->interval);
		timer->interval = new_interval;
		if (SwooleG.use_timerfd)
		{
			swTimer_timerfd_set(timer, new_interval);
		}
		else
		{
			swTimer_signal_set(timer, new_interval);
		}
	}
	swHashMap_add_int(timer->list, ms, node);
	timer->num++;
	return SW_OK;
}
Example #26
0
swMemoryPool *swRingBuffer_new(size_t size, uint8_t shared)
{
    size_t malloc_size = size + sizeof(swRingBuffer) + sizeof(swMemoryPool);
    void *mem = (shared == 1) ? sw_shm_malloc(malloc_size) : sw_malloc(malloc_size);
    if (mem == NULL)
    {
        swWarn("malloc(%ld) failed.", size);
        return NULL;
    }
    swRingBuffer *object = mem;
    mem += sizeof(swRingBuffer);
    bzero(object, sizeof(swRingBuffer));
    object->size = size;
    object->shared = shared;

    swMemoryPool *pool = mem;
    mem += sizeof(swMemoryPool);
    pool->object = object;
    pool->destroy = swRingBuffer_destory;
    pool->free = swRingBuffer_free;
    pool->alloc = swRingBuffer_alloc;

    object->memory = mem;
    return pool;
}
Example #27
0
static int swFactoryProcess_writer_start(swFactory *factory)
{
	swFactoryProcess *object = factory->object;
	swThreadParam *param;
	int i;
	pthread_t pidt;
	swThreadStartFunc thread_main;

#if SW_WORKER_IPC_MODE == 2
	thread_main = (swThreadStartFunc) swFactoryProcess_writer_loop_queue;
#else
	thread_main = (swThreadStartFunc) swFactoryProcess_writer_loop_unsock;
#endif

	for (i = 0; i < object->writer_num; i++)
	{
		param = sw_malloc(sizeof(swPipe));
		if (param == NULL)
		{
			swError("malloc fail\n");
			return SW_ERR;
		}
		param->object = factory;
		param->pti = i;
		if (pthread_create(&pidt, NULL, thread_main, (void *) param) < 0)
		{
			swTrace("pthread_create fail\n");
			return SW_ERR;
		}
		pthread_detach(pidt);
		object->writers[i].ptid = pidt;
		SW_START_SLEEP;
	}
	return SW_OK;
}
Example #28
0
static int swAioGcc_write(int fd, void *inbuf, size_t size, off_t offset)
{
    swAio_gcc_t *aiocb = sw_malloc(sizeof(swAio_gcc_t));
    if (aiocb == NULL)
    {
        swWarn("malloc failed.");
        return SW_ERR;
    }

    aiocb->next = NULL;
    if (swAioGcc_request == NULL)
    {
        swAioGcc_request = aiocb;
    }
    else
    {
        swAioGcc_request->next = aiocb;
    }
    bzero(aiocb, sizeof(swAio_gcc_t));
    aiocb->aiocb.aio_fildes = fd;
    aiocb->aiocb.aio_buf = inbuf;
    aiocb->aiocb.aio_nbytes = size;
    aiocb->aiocb.aio_lio_opcode = LIO_WRITE;

    aiocb->aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
    aiocb->aiocb.aio_sigevent.sigev_signo = SIGIO;

    if (aio_write(&aiocb->aiocb) == -1)
    {
        swWarn("aio_write failed. Error: %s[%d]", strerror(errno), errno);
        return SW_ERR;
    }
    return SW_OK;
}
Example #29
0
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;
}
Example #30
0
swDataBuffer_item* swDataBuffer_newItem(swDataBuffer *data_buffer, int fd, int trunk_size)
{
	swDataBuffer_item *newItem = sw_malloc(sizeof(swDataBuffer_item));
	//内存分配失败
	if (newItem == NULL)
	{
		swWarn("malloc for newItem failed. Error: %s[%d]", strerror(errno), errno);
		return NULL;
	}

	bzero(newItem, sizeof(swDataBuffer_item));

	//创建item时,自动建立一个trunk
	swDataBuffer_trunk *newTrunk = swDataBuffer_newTrunk(data_buffer, newItem);
	if (newTrunk == NULL)
	{
		sw_free(newItem);
		swWarn("malloc for newTrunk failed. Error: %s[%d]", strerror(errno), errno);
		return NULL;
	}

	newItem->fd = fd;
	swHashMap_add_int(&data_buffer->map, fd, newItem);

	return newItem;
}