自学教程：C++ sw_malloc函数代码示例

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;}

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;}

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;    }}

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);}

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;}

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;    }}

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;}

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;}

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;}

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 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;}

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;}

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 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;}

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;}

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;}

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;    }}

/*** @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);}

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;}

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;}

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;}

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;}

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;}

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;}

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;}

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;}

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;}

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;}

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;}

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;}