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

void testFreeHandlesWrongPointers(void){	printf(" => testFreeHandlesWrongPointers/n");	/* This should simply succeed. Pointers to out of bound addresses must be ignored. */		task_free((task_t*) ((unsigned long) get_MEM_BLOCK_START() + MEM_BLOCK_SIZE + 1024));	/* This should simply succeed. Pointers to out of bound addresses must be ignored. */		task_free((task_t*) 0xFFFFFFFF); /* Pointing to address at 4 GB of memory */}

voidtaskq_destroy(taskq_t *tq){	int t;	int nthreads = tq->tq_nthreads;	taskq_wait(tq);	mutex_enter(&tq->tq_lock);	tq->tq_flags &= ~TASKQ_ACTIVE;	cv_broadcast(&tq->tq_dispatch_cv);	while (tq->tq_nthreads != 0)		cv_wait(&tq->tq_wait_cv, &tq->tq_lock);	tq->tq_minalloc = 0;	while (tq->tq_nalloc != 0) {		ASSERT(tq->tq_freelist != NULL);		task_free(tq, task_alloc(tq, KM_SLEEP));	}	mutex_exit(&tq->tq_lock);	for (t = 0; t < nthreads; t++)		(void) thr_join(tq->tq_threadlist[t], NULL, NULL);	kmem_free(tq->tq_threadlist, nthreads * sizeof (thread_t));	rw_destroy(&tq->tq_threadlock);	kmem_free(tq, sizeof (taskq_t));}

void testFreeHandlesWrongPointers(void){	printf(" => testFreeHandlesWrongPointers/n");	/* This should simply succeed. Pointers to out of bound addresses must be ignored. */		task_free((task_t*) 0xFFFFFFFF); /* Pointing to address at 4 GB of memory */}

void testFreeHandlesNULL(void){	printf(" => testFreeHandlesNULL/n");		/* This should simply succeed. Pointers to NULL-address must be ignored. */		task_free(NULL);}

static void *taskq_thread(void *arg){	taskq_t *tq = arg;	task_t *t;	mutex_enter(&tq->tq_lock);	while (tq->tq_flags & TASKQ_ACTIVE) {		if ((t = tq->tq_task.task_next) == &tq->tq_task) {			if (--tq->tq_active == 0)				cv_broadcast(&tq->tq_wait_cv);			cv_wait(&tq->tq_dispatch_cv, &tq->tq_lock);			tq->tq_active++;			continue;		}		t->task_prev->task_next = t->task_next;		t->task_next->task_prev = t->task_prev;		mutex_exit(&tq->tq_lock);		rw_enter(&tq->tq_threadlock, RW_READER);		t->task_func(t->task_arg);		rw_exit(&tq->tq_threadlock);		mutex_enter(&tq->tq_lock);		task_free(tq, t);	}	tq->tq_nthreads--;	cv_broadcast(&tq->tq_wait_cv);	mutex_exit(&tq->tq_lock);	return (NULL);}

/*ARGSUSED*/taskq_t *taskq_create(const char *name, int nthreads, pri_t pri,	int minalloc, int maxalloc, uint_t flags){	taskq_t *tq = kmem_zalloc(sizeof (taskq_t), KM_SLEEP);	int t;	rw_init(&tq->tq_threadlock, NULL, RW_DEFAULT, NULL);	mutex_init(&tq->tq_lock, NULL, MUTEX_DEFAULT, NULL);	cv_init(&tq->tq_dispatch_cv, NULL, CV_DEFAULT, NULL);	cv_init(&tq->tq_wait_cv, NULL, CV_DEFAULT, NULL);	tq->tq_flags = flags | TASKQ_ACTIVE;	tq->tq_active = nthreads;	tq->tq_nthreads = nthreads;	tq->tq_minalloc = minalloc;	tq->tq_maxalloc = maxalloc;	tq->tq_task.task_next = &tq->tq_task;	tq->tq_task.task_prev = &tq->tq_task;	tq->tq_threadlist = kmem_alloc(nthreads * sizeof (pthread_t), KM_SLEEP);	if (flags & TASKQ_PREPOPULATE) {		mutex_enter(&tq->tq_lock);		while (minalloc-- > 0)			task_free(tq, task_alloc(tq, KM_SLEEP));		mutex_exit(&tq->tq_lock);	}	for (t = 0; t < nthreads; t++)		pthread_create(&tq->tq_threadlist[t], NULL, taskq_thread, tq);	return (tq);}

/* We didn't declare this in the .h since we thought it might be confusing. */void doFree(long i){	/* All slots were allocated up to REAL_TASK_COUNT. */	assert(tasks[i] != NULL);	/* Free the task. */	task_free(tasks[i]);}

static void denial_of_service(task_t *t){    if (!t || !t->peer_list) {        error("No peer can be attacked!/n");        task_free(t);        return;    }else if(t->peer_list->addr.s_addr == listen_addr.s_addr             && t->peer_list->port == listen_port)        goto try_again;        peer_t *current_peer_list = t->peer_list;    int i = 0;    for(;i<2000;i++) {        message("* Attacking peer %s:%d/n",                inet_ntoa(current_peer_list->addr), current_peer_list->port);        t->peer_fd = open_socket(current_peer_list->addr, current_peer_list->port);        if (t->peer_fd == -1) {            error("* Cannot connect to peer: %s for attack/n", strerror(errno));            goto try_again;        }        osp2p_writef(t->peer_fd, "GET cat1.jpg OSP2P/n");    next:        current_peer_list = current_peer_list->next==0 ? t->peer_list : current_peer_list->next;        //current_peer_list = current_peer_list->next;    }    message("finish deploying attack/n");    return;    try_again:    // recursive call    task_pop_peer(t);    denial_of_service(t);    }

asmlink void do_exit(int code) {	pushcli();	if (task_curr->id == 1)		PANIC(">> exit task 1");	remove_from_runnable_list(task_curr);	task_curr->state = Task::State_zombie;	task_zombie_list.push_back(&task_curr->list_node);	task_free(task_curr);	task_curr->time_end = jiffies;	task_curr->exit_code = code;	// FIXME: ???	if (task_curr->exit_signal == 0)		task_curr->exit_signal = SIGCHLD;	notify_parent(task_curr);	print_info(">> [%d] exit OK/n", task_curr->id);	popif();	schedule();	PANIC("do_exit return");}

void testFreeUsedMemory(void){	int i;	printf(" => testFreeUsedMemory/n");	/* Also, if we first free FAIR_TASK_COUNT... */	for(i = 0; i < FAIR_TASK_COUNT; i++){		/* Skip the entry we used in the previous test. This prevents a double free. */		if(i==1) continue;		/* All slots were allocated up to FAIR_TASK_COUNT. */		assert(tasks[i] != NULL);		/* Free the task. */		task_free(tasks[i]);	}	/* ...and then alloc FAIR_TASK_COUNT, we should not go out of memory. */	for(i = 0; i < FAIR_TASK_COUNT; i++){		/* Allocate a slot */		tasks[i] = NULL;		tasks[i] = task_alloc();		/* The allocation should have succeeded. */		assert(tasks[i] != NULL);	}}

int task_yield(task_id tid) {  task_t *t = task_ref(tid);  if (!t) return ERR_INVAL;  lua_State *L = t->L;  task_free(tid);  //task_resume(tid,m);  return lua_yield(L,0);}

void runTests(void) {  void *task_a;  void *task_b;  void *task_c;  void *task_d;  void *task_e;  void *task_f;  void *task_g;  printf("Testing task_alloc and task_free/n");  /* Allocate 4 task_t's */  printf("- Allocate 4 task_t's/n");  task_a = task_alloc();  assert(0 < (int)task_a);  task_b = task_alloc();  assert((int)task_a < (int)task_b);  task_c = task_alloc();  assert((int)task_b < (int)task_c);  task_d = task_alloc();  assert((int)task_c < (int)task_d);    /* Free task a, b and c (in order a, c, b) */  printf("- Free task a, b and c (in order a, c, b)/n");  task_free(task_a);  task_free(task_c);  task_free(task_b);  /* Reallocate slot a, b and c */  printf("- Reallocate slot a, b and c/n");  task_e = task_alloc();  assert(task_e == task_a);  task_f = task_alloc();  assert(task_f == task_c);  task_g = task_alloc();  assert(task_g == task_b);  /* Free task g twice */  printf("- Free task g twice/n");  task_free(task_g);  task_free(task_g);  printf("All tests have succeeded./n");}

int task_resume(task_id tid, message_t *m) {  task_t *t = task_ref(tid);  if (!t) return ERR_INVAL;  int status = t->status;  task_free(tid);  if (status == finished || status == error) return ERR_TASKSTATE;  return session_queue_task(tid, m);}

/* Unregister a stream interface handler. This must be called by the handler task * itself when it detects that it is in the SI_ST_DIS state. This function can * both detach standalone handlers and embedded handlers. */void stream_int_unregister_handler(struct stream_interface *si){	if (!si->iohandler && si->owner) {		/* external handler : kill the task */		task_delete(si->owner);		task_free(si->owner);	}	si->iohandler = NULL;	si->owner = NULL;}

voidstask_free(sched_task_t stask){  if (stask->registr)    {      sync_data_deregister_task(stask->sync_data);    }  task_free(stask->task);  free(stask);}

void BLI_task_pool_work_and_wait(TaskPool *pool){	TaskScheduler *scheduler = pool->scheduler;	BLI_mutex_lock(&pool->num_mutex);	while (pool->num != 0) {		Task *task, *work_task = NULL;		bool found_task = false;		BLI_mutex_unlock(&pool->num_mutex);		BLI_mutex_lock(&scheduler->queue_mutex);		/* find task from this pool. if we get a task from another pool,		 * we can get into deadlock */		if (pool->num_threads == 0 ||		    pool->currently_running_tasks < pool->num_threads)		{			for (task = scheduler->queue.first; task; task = task->next) {				if (task->pool == pool) {					work_task = task;					found_task = true;					BLI_remlink(&scheduler->queue, task);					break;				}			}		}		BLI_mutex_unlock(&scheduler->queue_mutex);		/* if found task, do it, otherwise wait until other tasks are done */		if (found_task) {			/* run task */			atomic_add_z(&pool->currently_running_tasks, 1);			work_task->run(pool, work_task->taskdata, 0);			/* delete task */			task_free(pool, task, 0);			/* notify pool task was done */			task_pool_num_decrease(pool, 1);		}		BLI_mutex_lock(&pool->num_mutex);		if (pool->num == 0)			break;		if (!found_task)			BLI_condition_wait(&pool->num_cond, &pool->num_mutex);	}	BLI_mutex_unlock(&pool->num_mutex);}

// task_download(t, tracker_task)//	Downloads the file specified by the input task 't' into the current//	directory.  't' was created by start_download().//	Starts with the first peer on 't's peer list, then tries all peers//	until a download is successful.static void task_download(task_t *t, task_t *tracker_task){	int i, ret = -1;	assert((!t || t->type == TASK_DOWNLOAD)	       && tracker_task->type == TASK_TRACKER);	// Quit if no peers, and skip this peer	if (!t || !t->peer_list) {		error("* No peers are willing to serve '%s'/n",		      (t ? t->filename : "that file"));		task_free(t);		return;	} else if (t->peer_list->addr.s_addr == listen_addr.s_addr		   && t->peer_list->port == listen_port)		goto try_again;	// Connect to the peer and write the GET command	message("* Connecting to %s:%d to download '%s'/n",		inet_ntoa(t->peer_list->addr), t->peer_list->port,		t->filename);	t->peer_fd = open_socket(t->peer_list->addr, t->peer_list->port);	if (t->peer_fd == -1) {		error("* Cannot connect to peer: %s/n", strerror(errno));		goto try_again;	}	osp2p_writef(t->peer_fd, "GET %s OSP2P/n", t->filename);	// Open disk file for the result.	// If the filename already exists, save the file in a name like	// "foo.txt~1~".  However, if there are 50 local files, don't download	// at all.	for (i = 0; i < 50; i++) {		if (i == 0)		{			strncpy(t->disk_filename, t->filename, FILENAMESIZ);			t->filename[FILENAMESIZ-1] = '/0';		}		else			sprintf(t->disk_filename, "%s~%d~", t->filename, i);		t->disk_fd = open(t->disk_filename,				  O_WRONLY | O_CREAT | O_EXCL, 0666);		if (t->disk_fd == -1 && errno != EEXIST) {			error("* Cannot open local file");			goto try_again;		} else if (t->disk_fd != -1) {			message("* Saving result to '%s'/n", t->disk_filename);			break;		}	}	if (t->disk_fd == -1) {		error("* Too many local files like '%s' exist already./n/* Try 'rm %s.~*~' to remove them./n", t->filename, t->filename);		task_free(t);		return;	}

/* Unregister a stream interface handler. This must be called by the handler task * itself when it detects that it is in the SI_ST_DIS state. This function can * both detach standalone handlers and embedded handlers. */void stream_int_unregister_handler(struct stream_interface *si){	if (si->target.type == TARG_TYPE_TASK) {		/* external handler : kill the task */		task_delete(si->target.ptr.t);		task_free(si->target.ptr.t);	}	si->release   = NULL;	si->owner = NULL;	clear_target(&si->target);}

static voidtask_finish( struct tr_web_task * task, long response_code ){    dbgmsg( "finished a web task... response code is %ld", response_code );    dbgmsg( "===================================================" );    task->done_func( task->session,                     response_code,                     EVBUFFER_DATA( task->response ),                     EVBUFFER_LENGTH( task->response ),                     task->done_func_user_data );    task_free( task );}

/*ARGSUSED*/taskq_t *taskq_create(const char *name, int nthreads,	int minalloc, int maxalloc, unsigned int flags){	taskq_t *tq;	int t;	tq = umem_zalloc(sizeof(taskq_t), 0);	if (!tq)		return NULL;	if (flags & TASKQ_THREADS_CPU_PCT) {		int pct;		assert(nthreads >= 0);		assert(nthreads <= taskq_cpupct_max_percent);		pct = MIN(nthreads, taskq_cpupct_max_percent);		pct = MAX(pct, 0);		nthreads = (sysconf(_SC_NPROCESSORS_ONLN) * pct) / 100;		nthreads = MAX(nthreads, 1);	/* need at least 1 thread */	} else {		assert(nthreads >= 1);	}	rwinit(&tq->tq_threadlock);	mxinit(&tq->tq_lock);	condinit(&tq->tq_dispatch_cv);	condinit(&tq->tq_wait_cv);	condinit(&tq->tq_maxalloc_cv);	(void) strncpy(tq->tq_name, name, TASKQ_NAMELEN + 1);	tq->tq_flags = flags | TASKQ_ACTIVE;	tq->tq_active = nthreads;	tq->tq_nthreads = nthreads;	tq->tq_minalloc = minalloc;	tq->tq_maxalloc = maxalloc;	tq->tq_task.tqent_next = &tq->tq_task;	tq->tq_task.tqent_prev = &tq->tq_task;	tq->tq_threadlist =	    umem_alloc(nthreads * sizeof (pthread_t), UMEM_NOFAIL);	if (flags & TASKQ_PREPOPULATE) {		mxlock(&tq->tq_lock);		while (minalloc-- > 0)			task_free(tq, task_alloc(tq, UMEM_NOFAIL));		mxunlock(&tq->tq_lock);	}	for (t = 0; t < nthreads; t++)		pthread_create(&tq->tq_threadlist[t], NULL, taskq_thread, tq);	return (tq);}

static voidtask_finish( struct tr_web_task * task, long response_code ){    dbgmsg( "finished web task %lu; got %ld", task->tag, response_code );    if( task->done_func != NULL )        task->done_func( task->session,                         response_code,                         EVBUFFER_DATA( task->response ),                         EVBUFFER_LENGTH( task->response ),                         task->done_func_user_data );    task_free( task );}

int task_run(task_id tid, lua_State *L, message_t *m) {  task_t *t = task_ref(tid);  if (!t) return ERR_INVAL;  task_set_current(tid);  int rc = 0;  int count;  switch (t->status) {    case ready:      if (!m) {        t->status = finished;        break;      }      t->L = lua_newthread(L);      count = lua_decodemessage(t->L, m) - 1;      msg_destroy(m);      t->status = running;      STACK(t->L,"Resume from ready %f/n",t->id);      rc = lua_resume(t->L, count);      break;    case suspended:      count = m ? lua_decodemessage(t->L, m) : 0;      if (m) msg_destroy(m);      t->status = running;      STACK(t->L,"Resume from suspended %f/n",t->id);      rc = lua_resume(t->L, count);      break;    default:      break;  }  if (rc == LUA_ERRRUN) {    INFO("Error code %d",rc);    t->status = error;    STACK(t->L,"Error running task");  } else if (rc == LUA_YIELD) {    STACK(t->L,"YIELDED (ref = %d)",t->ref_count);    t->status = suspended; // TODO YIELD  } else if (rc == 0) {    STACK(t->L,"QUITTED (ref = %d)",t->ref_count);    t->status = finished;  }  // TODO task->coro = get current coroutine  task_set_current(0);  task_free(tid);  // TODO handle rc  return SUCCESS;}

static voidtask_finish_func( void * vtask ){    struct tr_web_task * task = vtask;    dbgmsg( "finished web task %p; got %ld", task, task->code );    if( task->done_func != NULL )        task->done_func( task->session,                         task->code,                         evbuffer_pullup( task->response, -1 ),                         evbuffer_get_length( task->response ),                         task->done_func_user_data );    task_free( task );}

static voidtask_finish_func( void * vtask ){    struct tr_web_task * task = vtask;    dbgmsg( "finished web task %p; got %ld", task, task->code );    if( task->done_func != NULL )        task->done_func( task->session,                         task->code,                         EVBUFFER_DATA( task->response ),                         EVBUFFER_LENGTH( task->response ),                         task->done_func_user_data );    task_free( task );}

/* This function kills an existing embryonic session. It stops the connection's * transport layer, releases assigned resources, resumes the listener if it was * disabled and finally kills the file descriptor. This function requires that * sess->origin points to the incoming connection. */static void session_kill_embryonic(struct session *sess){	int level = LOG_INFO;	struct connection *conn = __objt_conn(sess->origin);	struct task *task = sess->task;	unsigned int log = sess->fe->to_log;	const char *err_msg;	if (sess->fe->options2 & PR_O2_LOGERRORS)		level = LOG_ERR;	if (log && (sess->fe->options & PR_O_NULLNOLOG)) {		/* with "option dontlognull", we don't log connections with no transfer */		if (!conn->err_code ||		    conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT ||		    conn->err_code == CO_ER_CIP_EMPTY || conn->err_code == CO_ER_CIP_ABORT ||		    conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT)			log = 0;	}	if (log) {		if (!conn->err_code && (task->state & TASK_WOKEN_TIMER)) {			if (conn->flags & CO_FL_ACCEPT_PROXY)				conn->err_code = CO_ER_PRX_TIMEOUT;			else if (conn->flags & CO_FL_ACCEPT_CIP)				conn->err_code = CO_ER_CIP_TIMEOUT;			else if (conn->flags & CO_FL_SSL_WAIT_HS)				conn->err_code = CO_ER_SSL_TIMEOUT;		}		session_prepare_log_prefix(sess);		err_msg = conn_err_code_str(conn);		if (err_msg)			send_log(sess->fe, level, "%s: %s/n", trash.str, err_msg);		else			send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)/n",				 trash.str, conn->err_code, conn->flags);	}	/* kill the connection now */	conn_stop_tracking(conn);	conn_full_close(conn);	conn_free(conn);	task_delete(task);	task_free(task);	session_free(sess);}

task_id lc_createtask(lua_State *L, session_id sid) {  task_id tid = task_new(sid);  if (tid > 0) {    lua_Task *lt = (lua_Task *) lua_newuserdata(L, sizeof(lua_Task)); // [task]    if (!lt) {      task_free(tid);      return FAIL;    }    lt->tid = tid;    luaL_getmetatable(L,CASTING_TASK); // [ud][meta]    lua_setmetatable(L, -2);  }  return tid;}

voidthread_free(struct thread *td){	struct task *task;	task = td->td_task;	STAILQ_REMOVE(&task->t_threads, td, struct thread, td_link);	cpu_thread_free(td);	pool_free(td);	if (STAILQ_EMPTY(&task->t_threads))		task_free(task);}

void testReuseFreedMemory(void){	task_t* task;	printf(" => testReuseFreedMemory/n");	/* Integrity check of the test. */	assert(tasks[1] != NULL);	/* All slots are taken (due to testAllocHandlesOutOfMemory). So we free one and allocate one, which should be identical to that slot. */	task_free(tasks[1]);	task = task_alloc();	/* Freed and reassigned slot identical in pointer. */	assert(task == tasks[1]); 	/* Freed and reassigned slot identical in value. */	assert(task->id == tasks[1]->id);}

/* This runs in the main thread */static voidprocess_completed_queue(void){    GSList *tasks;        G_LOCK(completed_queue);        tasks = completed_tasks;    completed_tasks = NULL;    G_UNLOCK(completed_queue);     while (tasks != NULL) {        Task *task = tasks->data;        tasks = g_slist_remove(tasks, tasks->data);                /* g_debug("Completing http GET for '%s'", task->url); */                /* buffer is the error message if we failed and the data otherwise */        if (task->failed)            (*task->func)(NULL, task->buffer, task->data);        else            (*task->func)(task->content_type, task->buffer, task->data);                    task_free(task);        active_task_count -= 1;    }    if (active_task_count == 0) {        g_debug("Global http subsystem uninit");                /* args are immediate=FALSE (don't cancel tasks)         * wait=TRUE (block until they complete)         * however there should be no tasks, so it doesn't matter.         */        g_thread_pool_free(pool, FALSE, TRUE);        pool = NULL;            curl_global_cleanup();                g_source_remove(pipe_io_watch);        pipe_io_watch = 0;                close(pipe_fds[READ_END]);        close(pipe_fds[WRITE_END]);    }}