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

static voidinfo_mach_ports_command (char *args, int from_tty){  port_name_array_t port_names_data;  port_type_array_t port_types_data;  unsigned int name_count, type_count;  kern_return_t result;  int index;  task_t task;  CHECK_ARGS ("Task", args);  sscanf (args, "0x%x", &task);  result = port_names (task,                       &port_names_data,                       &name_count, &port_types_data, &type_count);  MACH_CHECK_ERROR (result);  CHECK_FATAL (name_count == type_count);  printf_unfiltered ("Ports for task %#x:/n", task);  for (index = 0; index < name_count; ++index)    {      printf_unfiltered ("port name: %#x, type %#x/n",                         port_names_data[index], port_types_data[index]);    }  vm_deallocate (task_self (), (vm_address_t) port_names_data,                 (name_count * sizeof (mach_port_t)));  vm_deallocate (task_self (), (vm_address_t) port_types_data,                 (type_count * sizeof (mach_port_type_t)));}

static voidinfo_mach_threads_command (char *args, int from_tty){  thread_array_t threads;  unsigned int thread_count;  kern_return_t result;  task_t task;  int i;  task = get_task_from_args (args);  if (task == TASK_NULL)    return;  result = task_threads (task, &threads, &thread_count);  MACH_CHECK_ERROR (result);  printf_unfiltered (_("Threads in task %#x:/n"), task);  for (i = 0; i < thread_count; ++i)    {      printf_unfiltered (_("    %#x/n"), threads[i]);      mach_port_deallocate (task_self (), threads[i]);    }  vm_deallocate (task_self (), (vm_address_t) threads,                 (thread_count * sizeof (thread_t)));}

static void setExceptionThread(void){    kern_return_t r;//    char *nullAddr = NULL;        bailOut = FALSE;    /* save the old exception port for this task */    r = task_get_exception_port(task_self(), &(ports.old_exc_port));    if (r != KERN_SUCCESS) {	mach_error("task_get_exception_port",r);	exit(1);    }        if (!ports.exc_port) {	/* create a new exception port for this task */	r = port_allocate(task_self(), &(ports.exc_port));	if (r != KERN_SUCCESS) {	    mach_error("port_allocate",r);	    exit(1);	}	/* Fork the thread that listens to the exception port. */	cthread_detach(cthread_fork((cthread_fn_t)exc_thread,(any_t)&ports));	ports.clear_port = thread_reply();    }    /* install the new exception port for this task */    r = task_set_exception_port(task_self(), (ports.exc_port));    if (r != KERN_SUCCESS) {	mach_error("task_set_exception_port",r);	exit(1);    }    }

intmain(int argc, char *argv[]){	int pid, fd1, fd2, len;	char buf1[256], buf2[256];	printf("FIFO test program/n");	if (mknod("/mnt/fifo/test", (mode_t)(S_IFIFO | 0666), 0) == -1) {		perror("mkfifo");		exit(1);	}	pid = vfork();	if (pid == -1) {		perror("fork");		exit(1);	}	if (pid == 0) {		/* child */		printf("child: task=%x/n", (int)task_self());		fd1 = open("/mnt/fifo/test", O_RDONLY);		if (fd1 == -1) {			perror("open");			exit(1);		}		for (;;) {			printf("child: reading data from FIFO/n");			len = read(fd1, buf1, sizeof(buf1) - 1);			if (len == 0)				break;			buf1[len] = '/0';			printf("child: length=%d data=%s/n", len, buf1);		}		close(fd1);		printf("child: exit/n");		exit(0);	}	printf("parent: task=%x/n", (int)task_self());	fd2 = open("/mnt/fifo/test", O_WRONLY);	if (fd2 == -1) {		perror("open");		exit(1);	}	for (;;) {		printf("parent: please input string.../n");		fgets(buf2, sizeof(buf2) - 1, stdin);		if (feof(stdin))			break;		printf("parent: writing to FIFO/n");		write(fd2, buf2, strlen(buf2));	}	close(fd2);	printf("parent: exit/n");	exit(0);	return 0;}

intmain(int argc, char *argv[]){	char *prog, *cmd;	struct cmdentry const *entry;	int shcmd = 0;	prog = basename(argv[0]);	cmd = prog;	/*	 * Alias:	 * 'sh'            => sh	 * 'cmdbox'        => sh	 * 'cmdbox sh'     => sh	 * 'cmdbox cmd'    => cmd	 * 'cmd' (symlink) => cmd	 */	if (!strcmp(prog, "sh"))		shcmd = 1;	else if (!strcmp(prog, "cmdbox")) {		if (argc == 1)			shcmd = 1;		else {			if (!strcmp(argv[1], "sh"))				shcmd = 1;			else				cmd = argv[1];			argv++;			argc--;		}	}	if (shcmd) {		task_setname(task_self(), "sh");		exit(sh_main(argc, argv));	}	entry = builtin_cmds;	while (entry->cmd != NULL) {		if (!strcmp(cmd, entry->cmd)) {			task_setname(task_self(), cmd);			exit(entry->func(argc, argv));		}		entry++;	}	fprintf(stderr, "No such command: %s/n", cmd);	return 0;}

void_exit(int status){	for (;;)		task_terminate(task_self());}

int exec_call(void) {	int ecode;	struct task *task = task_self();	const char *path = task_resource_argv_path(task);	const char *cmd_name = exec_cmd_name(path);	const struct shell *sh = shell_lookup(cmd_name);	int c;	char **v;	if (strcmp(cmd_name, path))		task_resource_argv_insert(task, cmd_name, 0);	c = task_resource_argv_argc(task);	v = task_resource_argv_argv(task);	/* FIXME pass argv to shell_exec */	if (sh) {		ecode = shell_run(sh);	} else {		const struct cmd *cmd;		cmd = cmd_lookup(cmd_name);		if (cmd) {			task_self_module_ptr_set(cmd2mod(cmd));			ecode = cmd_exec(cmd, c, v);		} else {			ecode = ENOENT;		}	}	return ecode;}

static void exec_trampoline(void) {	sched_unlock();	kill(task_get_id(task_get_parent(task_self())), SIGCHLD);	_exit(exec_call());}

struct uio_mem *uio_map_iomem(struct uio_handle *handle, const char *name,	      paddr_t phys, size_t size){	struct uio_mem *mem;	int ret;	mem = malloc(sizeof(struct uio_mem));	if (!mem)		return NULL;	mem->phys_addr = phys;	mem->size = size;	strncpy(mem->name, name, sizeof(name));	ret = vm_map_phys(phys, size, &mem->addr);	if (ret < 0)		goto out_free_mem;	ret = vm_attribute(task_self(), mem->addr, PROT_IO);	if (ret < 0)		goto out_free_mem;	list_init(&mem->link);	list_insert(&handle->mem, &mem->link);	return mem;out_free_mem:	free(mem);	return NULL;}

static bool mutex_callback_unlock (sync_object_handle_t _handle,    error_t *_p_ecode){    mutex_handle_t p_mutex = (mutex_handle_t) _handle;    task_handle_t p_task = task_self ();    // grab the mutex    if (is_in_interrupt () || is_invalid_task (p_task)) {        return ERROR_T (ERROR_MUTEX_INVCONTEXT);    }    if (p_mutex->owner_ != p_task) {        *_p_ecode = ERROR_T (ERROR_MUTEX_NOTOWNER);        return false;    }    if (p_mutex->reference_ > 0) {        p_mutex->reference_ --;        return true;    }    // restore owner's original priority    if (p_mutex->inherited_) {        p_mutex->inherited_ = false;        task_priority_change (p_mutex->owner_, p_mutex->original_);    }    if (task_bitmap_is_empty (&p_mutex->object_.pending_bitmap_)) {        // no task is pending on this mutex        p_mutex->owner_ = null;        return true;    }    return false;}

struct thread *thread_create(unsigned int flags, void *(*run)(void *), void *arg) {	struct thread *t;	int priority;	/* check mutually exclusive flags */	if ((flags & THREAD_FLAG_PRIORITY_LOWER)			&& (flags & THREAD_FLAG_PRIORITY_HIGHER)) {		return err_ptr(EINVAL);	}	if((flags & THREAD_FLAG_NOTASK) && !(flags & THREAD_FLAG_SUSPENDED)) {		return err_ptr(EINVAL);	}	/* check correct executive function */	if (!run) {		return err_ptr(EINVAL);	}	/* calculate current thread priority. It can be change later with	 * thread_set_priority () function	 */	priority = thread_priority_by_flags(flags);	/* below we will work with thread's instances and therefore we need to	 * lock scheduler (disable scheduling) to our structures is not be	 * corrupted	 */	sched_lock();	{		/* allocate memory */		if (!(t = thread_alloc())) {			t = err_ptr(ENOMEM);			goto out_unlock;		}		/* initialize internal thread structure */		thread_init(t, priority, run, arg);		/* link with task if needed */		if (!(flags & THREAD_FLAG_NOTASK)) {			task_thread_register(task_self(), t);		}		thread_cancel_init(t);		if (!(flags & THREAD_FLAG_SUSPENDED)) {			thread_launch(t);		}		if (flags & THREAD_FLAG_DETACHED) {			thread_detach(t);		}	}out_unlock:	sched_unlock();	return t;}

kern_return_t task_stats(int pid, struct task_basic_info *info){    kern_return_t             status;    task_t					  p_task;    unsigned int              info_count=TASK_BASIC_INFO_COUNT;    /* Get the task pointer for the process. */    status = task_by_unix_pid( task_self(), pid, &p_task);    if (status!=KERN_SUCCESS) {#ifdef DEBUG        printf("pid = %i/n", pid);        mach_error("Error calling task_by_unix_pid()", status);#endif        return(status);    }    status=task_info(p_task, TASK_BASIC_INFO, (task_info_t)info, &info_count);    if (status!=KERN_SUCCESS) {#ifdef DEBUG        mach_error("Error calling task_info()", status);#endif        return(status);    }    return(KERN_SUCCESS);}

/*	These are my mach based versions, untested and probably bad ...*/caddr_t my_mmap(caddr_t addr, size_t len, int prot, int flags,          int fildes, off_t off){	kern_return_t ret_val;		/*	First map ...	*/	ret_val = map_fd ( fildes, 					/* fd				*/	                  (vm_offset_t) off,		/* offset			*/					  (vm_offset_t*)&addr,		/* address			*/					  TRUE, 					/* find_space		*/					  (vm_size_t) len);			/* size				*/	if (ret_val != KERN_SUCCESS) {    	mach_error("Error calling map_fd() in mmap", ret_val );		return (caddr_t)0;	}		/*	... then protect (this is probably bad)	*/	ret_val = vm_protect( task_self(),			/* target_task 		*/						 (vm_address_t)addr,	/* address			*/						 (vm_size_t) len,		/* size 			*/						 FALSE,					/* set_maximum		*/						 (vm_prot_t) prot);		/* new_protection	*/	if (ret_val != KERN_SUCCESS) {		mach_error("vm_protect in mmap()", ret_val );		return (caddr_t)0;	}		return addr;}

int my_mprotect(caddr_t addr, size_t len, int prot){	vm_prot_t mach_prot;	kern_return_t ret_val;		switch (prot) {		case PROT_READ:		mach_prot = VM_PROT_READ;		break;		case PROT_WRITE:	mach_prot = VM_PROT_WRITE;		break;		case PROT_EXEC:		mach_prot = VM_PROT_EXECUTE;	break;		case PROT_NONE:		mach_prot = VM_PROT_NONE;		break;	}		ret_val = vm_protect(task_self(),			/* target_task 		*/						 (vm_address_t)addr,	/* address			*/						 (vm_size_t) len,		/* size 			*/						 FALSE,					/* set_maximum		*/						 (vm_prot_t) prot);		/* new_protection	*/	if (ret_val != KERN_SUCCESS) {		mach_error("vm_protect in mprotect()", ret_val);		return -1;	}		return 0;}

static void *map_it( const char *path, int fd, void *map_at, size_t len ){  kern_return_t rc;  vm_offset_t addr;  addr = (vm_offset_t)map_at;  rc = vm_allocate( task_self(), &addr, len, /* anywhere */ FALSE );  if (rc != KERN_SUCCESS)    {      mach_error( "vm_allocate", rc );      fprintf( stderr, "%s: could not map at %08lx/n", 	       path, (unsigned long)map_at );      return NULL;    }  rc = map_fd( fd, 0, &addr, /*find_space*/ FALSE, len );  if (rc != KERN_SUCCESS)    {      mach_error( "map_fd", rc );      fprintf( stderr, "%s: could not map at %08lx/n", 	       path, (unsigned long)map_at );      return NULL;    }  return (void *)addr;}

voidvfork_end(struct proc *p){	void *stack;	task_t self = task_self();	DPRINTF(("vfork_end: org=%x saved=%x/n", p->p_stackbase,		 p->p_stacksaved));	/*	 * Restore parent's stack	 */	if (vm_map(p->p_task, p->p_stackbase, USTACK_SIZE, &stack) != 0)		return;	memcpy(stack, p->p_stacksaved, USTACK_SIZE);	vm_free(self, p->p_stacksaved);	vm_free(self, stack);	/*	 * Resume parent	 */	p->p_vforked = 0;	task_resume(p->p_task);}

intuio_unmap_iomem(struct uio_handle *handle, struct uio_mem *mem){	list_remove(&mem->link);	vm_free(task_self(), (void *)mem->phys_addr);	free(mem);	return 0;}

static int get_index(struct sock *sk) {	struct idesc_table *it;	it = task_resource_idesc_table(task_self());	assert(it);	return idesc_table_add(it, (struct idesc *)sk, 0);}

void mapf_close( void ){    if (image_file >= 0)    {	vm_deallocate( task_self(), image_mapping_addr, image_mapping_size );	close( image_file );    }}

static voidmy_free(	char *buf,	vm_size_t size	){	vm_deallocate(task_self(), (vm_address_t)buf, size);}

voidattack(void){	object_t *objp	= (object_t *)random();	object_t obj	= (object_t)random();	char *name	= (char *)random();	void *msg	= (void *)random();	size_t size	= (size_t)random();	task_t self	= task_self();	void *addr	= (void *)random();	int attr	= random() & 7;	thread_t t	= (thread_t)random();	thread_t *tp	= (thread_t *)random();	object_create(NULL, NULL);	object_create(NULL, objp);	object_create(name, NULL);	object_create(name, objp);	object_destroy(0);	object_destroy(obj);	object_lookup(NULL, objp);	object_lookup(name, NULL);	object_lookup(name, objp);	msg_send(0, msg, size);	msg_send(obj, NULL, size);	msg_send(obj, msg, 0);	msg_send(0, msg, 0);	msg_send(0, NULL, size);	msg_send(obj, msg, size);	msg_receive(0, msg, size);	msg_receive(obj, NULL, size);	msg_receive(obj, msg, 0);	msg_receive(0, msg, 0);	msg_receive(0, NULL, size);	msg_receive(obj, msg, size);	msg_reply(0, msg, size);	msg_reply(obj, NULL, size);	msg_reply(obj, msg, 0);	msg_reply(0, msg, 0);	msg_reply(0, NULL, size);	msg_reply(obj, msg, size);	vm_allocate(self, addr, size, 1);	vm_allocate(self, &addr, size, 1);	vm_free(self, addr);	vm_attribute(self, addr, attr);	vm_map(self, addr, size, &addr);	thread_create(self, tp);	thread_suspend(t);	thread_terminate(t);}

static void restoreExceptionThread(void){    /* install the old port again */    kern_return_t r = task_set_exception_port(task_self(), (ports.old_exc_port));    if (r != KERN_SUCCESS) {	mach_error("task_set_exception_port",r);	exit(1);    }}

void zombie(int sig, int code, struct sigcontext *scp) {    memcpy(&OldContext, scp, (int)sizeof(struct sigcontext));    LogMsg(0, 0, LogFile,  "****** INTERRUPTED BY SIGNAL %d CODE %d ******", sig, code);    LogMsg(0, 0, LogFile,  "****** Aborting outstanding transactions, stand by...");        LogMsg(0, 0, LogFile, "To debug via gdb: attach %d, setcontext OldContext", getpid());    LogMsg(0, 0, LogFile, "Becoming a zombie now ........");    task_suspend(task_self());}

static int xetpriority_match(int which, id_t who, struct task *task) {	struct task_u_area *task_u_area;	id_t real_who;	int is_match;	if (who != 0) {		real_who = who;	} else {		struct task *self = task_self();		struct task_u_area *self_u = task_resource_u_area(self);		switch(which) {		case PRIO_PROCESS:			real_who = task_get_id(task_self());			break;		case PRIO_PGRP:			real_who = self_u->regid;			break;		case PRIO_USER:			real_who = self_u->reuid;			break;		default:			assert(0);		}	}	task_u_area = task_resource_u_area(task);	switch (which) {	case PRIO_PROCESS:		is_match = task_get_id(task) == real_who;		break;	case PRIO_PGRP:		is_match = task_u_area->regid == real_who;		break;	case PRIO_USER:		is_match = task_u_area->reuid == real_who;		break;	default:		assert(0);	}	return is_match;}

intmain(int argc, char *argv[]){	struct timerinfo info;	task_t task;	char stack[16];	u_long start, end;	int i, pri, error;	printf("Benchmark to create/terminate %d threads/n", NR_THREADS);	sys_info(INFO_TIMER, &info);	if (info.hz == 0)		panic("can not get timer tick rate");	thread_getpri(thread_self(), &pri);	thread_setpri(thread_self(), pri - 1);	task = task_self();	error = vm_allocate(task, (void **)&thread,			    sizeof(thread_t) * NR_THREADS, 1);	if (error)		panic("vm_allocate is failed");	sys_time(&start);	/*	 * Create threads	 */	for (i = 0; i < NR_THREADS; i++) {		if (thread_create(task, &thread[i]) != 0)			panic("thread_create is failed");		if (thread_load(thread[i], null_thread, &stack) != 0)			panic("thread_load is failed");		if (thread_resume(thread[i]) != 0)			panic("thread_resume is failed");	}	/*	 * Teminate threads	 */	for (i = 0; i < NR_THREADS; i++)		thread_terminate(thread[i]);	sys_time(&end);	vm_free(task, thread);	printf("Complete. The score is %d msec (%d ticks)./n",	       (int)((end - start) * 1000 / info.hz),	       (int)(end - start));	return 0;}

kern_return_t SetServerAttribute(AttributeType attrib, UInt32 /*tagSize*/,                                            void* /*tags*/, unsigned int bufSize, void* buffer){    if ((attrib.attribClass != kServerAttr) || (attrib.version != kCurrentVersion))    {        //because the buffer is being passed out of line, make sure to free it up        vm_deallocate(task_self(), (unsigned int)buffer, bufSize);        return SCNoError;    }    kern_return_t theError = SCNoError;            switch (attrib.attribKind)    {        case kRefuseConnectionsAttr:        {            if ((buffer != NULL) && (bufSize == sizeof(QTSRefuseConnectionsRec)))                theError = SetRefuseConnections((QTSRefuseConnectionsRec*)buffer);            else                theError = SCBufferToSmall;            break;        }        case kRereadPreferencesAttr:        {            theError = RereadPreferences();            break;        }        case kLogRollAttr:        {            if ((buffer != NULL) && (bufSize == sizeof(QTSLogRollRec)))                theError = RollLogNow((QTSLogRollRec*)buffer);            else                theError = SCBufferToSmall;            break;        }        default:            theError = SCUnsupportedAttrib;    }    vm_deallocate(task_self(), (unsigned int)buffer, bufSize);    return theError;    }

static intramfs_write(vnode_t vp, file_t fp, void *buf, size_t size, size_t *result){	struct ramfs_node *np;	off_t file_pos, end_pos;	void *new_buf;	size_t new_size;	task_t task;	*result = 0;	if (vp->v_type == VFIFO)		return ramfs_write_fifo(vp, fp, buf, size, result);	if (vp->v_type == VDIR)		return EISDIR;	if (vp->v_type != VREG)		return EINVAL;	np = vp->v_data;	/* Check if the file position exceeds the end of file. */	end_pos = vp->v_size;	file_pos = (fp->f_flags & O_APPEND) ? end_pos : fp->f_offset;	if (file_pos + size > (size_t)end_pos) {		/* Expand the file size before writing to it */		end_pos = file_pos + size;		if (end_pos > (off_t)np->rn_bufsize) {			task = task_self();			/*			 * We allocate the data buffer in page boundary.			 * So that we can reduce the memory allocation unless			 * the file size exceeds next page boundary.			 * This will prevent the memory fragmentation by			 * many malloc/free calls.			 */			new_size = PAGE_ALIGN(end_pos);			if (vm_allocate(task, &new_buf, new_size, 1))				return EIO;			if (np->rn_size != 0) {				memcpy(new_buf, np->rn_buf, vp->v_size);				vm_free(task, np->rn_buf);			}			if (vp->v_size < (size_t)file_pos) /* sparse file */				memset((char *)new_buf + vp->v_size, 0,				       file_pos - vp->v_size);			np->rn_buf = new_buf;			np->rn_bufsize = new_size;		}		np->rn_size = end_pos;		vp->v_size = end_pos;	}	memcpy(np->rn_buf + file_pos, buf, size);	fp->f_offset += size;	*result = size;	return 0;}

int diag_fd(void) {	struct idesc_table *idesc_table;	idesc_table = task_resource_idesc_table(task_self());	if (!idesc_table) {		return -ENOSYS;	}	idesc_init(&diag_idesc, &diag_idx_ops, S_IROTH | S_IWOTH);	return idesc_table_add(idesc_table, &diag_idesc, 0);}

static char *my_malloc(	  vm_size_t size	  ){	vm_address_t address;	if (vm_allocate(task_self(), &address, size, TRUE) != KERN_SUCCESS) {		return (NULL);	}	return ((char *)address);}

int diag_fd(void) {	struct idesc_table *idesc_table;	idesc_table = task_resource_idesc_table(task_self());	if (!idesc_table) {		return -ENOSYS;	}	idesc_init(&diag_idesc, &diag_idx_ops, FS_MAY_READ | FS_MAY_WRITE);	return idesc_table_add(idesc_table, &diag_idesc, 0);}