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

asmlinkage long sys_getpgid(pid_t pid){	struct task_struct *p;	struct pid *grp;	int retval;	rcu_read_lock();	if (!pid)		grp = task_pgrp(current);	else {		retval = -ESRCH;		p = find_task_by_vpid(pid);		if (!p)			goto out;		grp = task_pgrp(p);		if (!grp)			goto out;		retval = security_task_getpgid(p);		if (retval)			goto out;	}	retval = pid_vnr(grp);out:	rcu_read_unlock();	return retval;}

static int job_control(struct tty_struct *tty, struct file *file){		if (file->f_op->write != redirected_tty_write &&	    current->signal->tty == tty) {		if (!tty->pgrp)			printk(KERN_ERR "n_tty_read: no tty->pgrp!/n");		else if (task_pgrp(current) != tty->pgrp) {			if (is_ignored(SIGTTIN) ||			    is_current_pgrp_orphaned())				return -EIO;			kill_pgrp(task_pgrp(current), SIGTTIN, 1);			set_thread_flag(TIF_SIGPENDING);			return -ERESTARTSYS;		}	}	return 0;}

/* * Ugh. To avoid negative return values, "getpriority()" will * not return the normal nice-value, but a negated value that * has been offset by 20 (ie it returns 40..1 instead of -20..19) * to stay compatible. */asmlinkage long sys_getpriority(int which, int who){	struct task_struct *g, *p;	struct user_struct *user;	long niceval, retval = -ESRCH;	struct pid *pgrp;	if (which > PRIO_USER || which < PRIO_PROCESS)		return -EINVAL;	read_lock(&tasklist_lock);	switch (which) {		case PRIO_PROCESS:			if (who)				p = find_task_by_vpid(who);			else				p = current;			if (p) {				niceval = 20 - task_nice(p);				if (niceval > retval)					retval = niceval;			}			break;		case PRIO_PGRP:			if (who)				pgrp = find_vpid(who);			else				pgrp = task_pgrp(current);			do_each_pid_task(pgrp, PIDTYPE_PGID, p) {				niceval = 20 - task_nice(p);				if (niceval > retval)					retval = niceval;			} while_each_pid_task(pgrp, PIDTYPE_PGID, p);			break;		case PRIO_USER:			user = current->user;			if (!who)				who = current->uid;			else				if ((who != current->uid) && !(user = find_user(who)))					goto out_unlock;	/* No processes for this user */			do_each_thread(g, p)				if (p->uid == who) {					niceval = 20 - task_nice(p);					if (niceval > retval)						retval = niceval;				}			while_each_thread(g, p);			if (who != current->uid)				free_uid(user);		/* for find_user() */			break;	}

static int job_control(struct tty_struct *tty, struct file *file){	/* Job control check -- must be done at start and after	   every sleep (POSIX.1 7.1.1.4). */	/* NOTE: not yet done after every sleep pending a thorough	   check of the logic of this change. -- jlc */	/* don't stop on /dev/console */	if (file->f_op->write != redirected_tty_write &&	    current->signal->tty == tty) {		if (!tty->pgrp)			printk("read_chan: no tty->pgrp!/n");		else if (task_pgrp(current) != tty->pgrp) {			if (is_ignored(SIGTTIN) ||			    is_current_pgrp_orphaned())				return -EIO;			kill_pgrp(task_pgrp(current), SIGTTIN, 1);			return -ERESTARTSYS;		}	}	return 0;}

asmlinkage long sys_setpriority(int which, int who, int niceval){	struct task_struct *g, *p;	struct user_struct *user;	int error = -EINVAL;	struct pid *pgrp;	if (which > PRIO_USER || which < PRIO_PROCESS)		goto out;	/* normalize: avoid signed division (rounding problems) */	error = -ESRCH;	if (niceval < -20)		niceval = -20;	if (niceval > 19)		niceval = 19;	read_lock(&tasklist_lock);	switch (which) {		case PRIO_PROCESS:			if (who)				p = find_task_by_vpid(who);			else				p = current;			if (p)				error = set_one_prio(p, niceval, error);			break;		case PRIO_PGRP:			if (who)				pgrp = find_vpid(who);			else				pgrp = task_pgrp(current);			do_each_pid_task(pgrp, PIDTYPE_PGID, p) {				error = set_one_prio(p, niceval, error);			} while_each_pid_task(pgrp, PIDTYPE_PGID, p);			break;		case PRIO_USER:			user = current->user;			if (!who)				who = current->uid;			else				if ((who != current->uid) && !(user = find_user(who)))					goto out_unlock;	/* No processes for this user */			do_each_thread(g, p)				if (p->uid == who)					error = set_one_prio(p, niceval, error);			while_each_thread(g, p);			if (who != current->uid)				free_uid(user);		/* For find_user() */			break;	}

//.........这里部分代码省略.........		p->parent_exec_id = current->parent_exec_id;	} else {		p->real_parent = current;		p->parent_exec_id = current->self_exec_id;	}	spin_lock(&current->sighand->siglock);	/*	 * Process group and session signals need to be delivered to just the	 * parent before the fork or both the parent and the child after the	 * fork. Restart if a signal comes in before we add the new process to	 * it's process group.	 * A fatal signal pending means that current will exit, so the new	 * thread can't slip out of an OOM kill (or normal SIGKILL). 	 */	recalc_sigpending();	if (signal_pending(current)) {		spin_unlock(&current->sighand->siglock);		write_unlock_irq(&tasklist_lock);		retval = -ERESTARTNOINTR;		goto bad_fork_free_pid;	}	if (clone_flags & CLONE_THREAD) {		atomic_inc(&current->signal->count);		atomic_inc(&current->signal->live);		p->group_leader = current->group_leader;		list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);	}	if (likely(p->pid)) {		list_add_tail(&p->sibling, &p->real_parent->children);		tracehook_finish_clone(p, clone_flags, trace);		if (thread_group_leader(p)) {			if (clone_flags & CLONE_NEWPID)				p->nsproxy->pid_ns->child_reaper = p;			p->signal->leader_pid = pid;			tty_kref_put(p->signal->tty);			p->signal->tty = tty_kref_get(current->signal->tty);			attach_pid(p, PIDTYPE_PGID, task_pgrp(current));			attach_pid(p, PIDTYPE_SID, task_session(current));			list_add_tail_rcu(&p->tasks, &init_task.tasks);			__get_cpu_var(process_counts)++;		}		attach_pid(p, PIDTYPE_PID, pid);		nr_threads++;	}	total_forks++;	spin_unlock(&current->sighand->siglock);	write_unlock_irq(&tasklist_lock);	proc_fork_connector(p);	cgroup_post_fork(p);	perf_event_fork(p);	return p;bad_fork_free_pid:	if (pid != &init_struct_pid)		free_pid(pid);bad_fork_cleanup_io:	put_io_context(p->io_context);bad_fork_cleanup_namespaces:	exit_task_namespaces(p);bad_fork_cleanup_mm:	if (p->mm)		mmput(p->mm);bad_fork_cleanup_signal:	if (!(clone_flags & CLONE_THREAD))		__cleanup_signal(p->signal);bad_fork_cleanup_sighand:	__cleanup_sighand(p->sighand);bad_fork_cleanup_fs:	exit_fs(p); /* blocking */bad_fork_cleanup_files:	exit_files(p); /* blocking */bad_fork_cleanup_semundo:	exit_sem(p);bad_fork_cleanup_audit:	audit_free(p);bad_fork_cleanup_policy:	perf_event_free_task(p);#ifdef CONFIG_NUMA	mpol_put(p->mempolicy);bad_fork_cleanup_cgroup:#endif	cgroup_exit(p, cgroup_callbacks_done);	delayacct_tsk_free(p);	module_put(task_thread_info(p)->exec_domain->module);bad_fork_cleanup_count:	atomic_dec(&p->cred->user->processes);	anoubis_task_destroy(p);	exit_creds(p);bad_fork_free:	free_task(p);fork_out:	return ERR_PTR(retval);}

//.........这里部分代码省略.........		p->real_parent = current;		p->parent_exec_id = current->self_exec_id;	}	spin_lock(&current->sighand->siglock);	/*	 * Copy seccomp details explicitly here, in case they were changed	 * before holding sighand lock.	 */	copy_seccomp(p);	/*	 * Process group and session signals need to be delivered to just the	 * parent before the fork or both the parent and the child after the	 * fork. Restart if a signal comes in before we add the new process to	 * it's process group.	 * A fatal signal pending means that current will exit, so the new	 * thread can't slip out of an OOM kill (or normal SIGKILL).	*/	recalc_sigpending();	if (signal_pending(current)) {		spin_unlock(&current->sighand->siglock);		write_unlock_irq(&tasklist_lock);		retval = -ERESTARTNOINTR;		goto bad_fork_free_pid;	}	if (likely(p->pid)) {		ptrace_init_task(p, (clone_flags & CLONE_PTRACE) || trace);		init_task_pid(p, PIDTYPE_PID, pid);		if (thread_group_leader(p)) {			init_task_pid(p, PIDTYPE_PGID, task_pgrp(current));			init_task_pid(p, PIDTYPE_SID, task_session(current));			if (is_child_reaper(pid)) {				ns_of_pid(pid)->child_reaper = p;				p->signal->flags |= SIGNAL_UNKILLABLE;			}			p->signal->leader_pid = pid;			p->signal->tty = tty_kref_get(current->signal->tty);			list_add_tail(&p->sibling, &p->real_parent->children);			list_add_tail_rcu(&p->tasks, &init_task.tasks);			attach_pid(p, PIDTYPE_PGID);			attach_pid(p, PIDTYPE_SID);			__this_cpu_inc(process_counts);		} else {			current->signal->nr_threads++;			atomic_inc(&current->signal->live);			atomic_inc(&current->signal->sigcnt);			list_add_tail_rcu(&p->thread_group,					  &p->group_leader->thread_group);			list_add_tail_rcu(&p->thread_node,					  &p->signal->thread_head);		}		attach_pid(p, PIDTYPE_PID);		nr_threads++;	}	total_forks++;	spin_unlock(&current->sighand->siglock);	syscall_tracepoint_update(p);	write_unlock_irq(&tasklist_lock);

/* * This needs some heavy checking ... * I just haven't the stomach for it. I also don't fully * understand sessions/pgrp etc. Let somebody who does explain it. * * OK, I think I have the protection semantics right.... this is really * only important on a multi-user system anyway, to make sure one user * can't send a signal to a process owned by another.  -TYT, 12/12/91 * * Auch. Had to add the 'did_exec' flag to conform completely to POSIX. * LBT 04.03.94 */asmlinkage long sys_setpgid(pid_t pid, pid_t pgid){	struct task_struct *p;	struct task_struct *group_leader = current->group_leader;	struct pid *pgrp;	int err;	if (!pid)		pid = task_pid_vnr(group_leader);	if (!pgid)		pgid = pid;	if (pgid < 0)		return -EINVAL;	/* From this point forward we keep holding onto the tasklist lock	 * so that our parent does not change from under us. -DaveM	 */	write_lock_irq(&tasklist_lock);	err = -ESRCH;	p = find_task_by_vpid(pid);	if (!p)		goto out;	err = -EINVAL;	if (!thread_group_leader(p))		goto out;	if (same_thread_group(p->real_parent, group_leader)) {		err = -EPERM;		if (task_session(p) != task_session(group_leader))			goto out;		err = -EACCES;		if (p->did_exec)			goto out;	} else {		err = -ESRCH;		if (p != group_leader)			goto out;	}	err = -EPERM;	if (p->signal->leader)		goto out;	pgrp = task_pid(p);	if (pgid != pid) {		struct task_struct *g;		pgrp = find_vpid(pgid);		g = pid_task(pgrp, PIDTYPE_PGID);		if (!g || task_session(g) != task_session(group_leader))			goto out;	}	err = security_task_setpgid(p, pgid);	if (err)		goto out;	if (task_pgrp(p) != pgrp) {		change_pid(p, PIDTYPE_PGID, pgrp);		set_task_pgrp(p, pid_nr(pgrp));	}	err = 0;out:	/* All paths lead to here, thus we are safe. -DaveM */	write_unlock_irq(&tasklist_lock);	return err;}

//.........这里部分代码省略.........	 * fork. Restart if a signal comes in before we add the new process to	 * it's process group.	 * A fatal signal pending means that current will exit, so the new	 * thread can't slip out of an OOM kill (or normal SIGKILL). 	 */ 	recalc_sigpending();	if (signal_pending(current)) {		spin_unlock(&current->sighand->siglock);		write_unlock_irq(&tasklist_lock);		retval = -ERESTARTNOINTR;		goto bad_fork_cleanup_namespaces;	}	if (clone_flags & CLONE_THREAD) {		p->group_leader = current->group_leader;		list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);		if (!cputime_eq(current->signal->it_virt_expires,				cputime_zero) ||		    !cputime_eq(current->signal->it_prof_expires,				cputime_zero) ||		    current->signal->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY ||		    !list_empty(&current->signal->cpu_timers[0]) ||		    !list_empty(&current->signal->cpu_timers[1]) ||		    !list_empty(&current->signal->cpu_timers[2])) {			/*			 * Have child wake up on its first tick to check			 * for process CPU timers.			 */			p->it_prof_expires = jiffies_to_cputime(1);		}	}	if (likely(p->pid)) {		add_parent(p);		if (unlikely(p->ptrace & PT_PTRACED))			__ptrace_link(p, current->parent);		if (thread_group_leader(p)) {			p->signal->tty = current->signal->tty;			p->signal->pgrp = process_group(current);			set_signal_session(p->signal, process_session(current));			attach_pid(p, PIDTYPE_PGID, task_pgrp(current));			attach_pid(p, PIDTYPE_SID, task_session(current));			list_add_tail_rcu(&p->tasks, &init_task.tasks);			__get_cpu_var(process_counts)++;		}		attach_pid(p, PIDTYPE_PID, pid);		nr_threads++;	}	total_forks++;	spin_unlock(&current->sighand->siglock);	write_unlock_irq(&tasklist_lock);	proc_fork_connector(p);	return p;bad_fork_cleanup_namespaces:	exit_task_namespaces(p);bad_fork_cleanup_keys:	exit_keys(p);bad_fork_cleanup_mm:	if (p->mm)		mmput(p->mm);bad_fork_cleanup_signal:	cleanup_signal(p);bad_fork_cleanup_sighand:	__cleanup_sighand(p->sighand);bad_fork_cleanup_fs:	exit_fs(p); /* blocking */bad_fork_cleanup_files:	exit_files(p); /* blocking */bad_fork_cleanup_semundo:	exit_sem(p);bad_fork_cleanup_audit:	audit_free(p);bad_fork_cleanup_security:	security_task_free(p);bad_fork_cleanup_policy:#ifdef CONFIG_NUMA	mpol_free(p->mempolicy);bad_fork_cleanup_cpuset:#endif	cpuset_exit(p);bad_fork_cleanup_delays_binfmt:	delayacct_tsk_free(p);	if (p->binfmt)		module_put(p->binfmt->module);bad_fork_cleanup_put_domain:	module_put(task_thread_info(p)->exec_domain->module);bad_fork_cleanup_count:	put_group_info(p->group_info);	atomic_dec(&p->user->processes);	free_uid(p->user);bad_fork_free:	free_task(p);fork_out:	return ERR_PTR(retval);}

//.........这里部分代码省略.........		p->parent_exec_id = current->parent_exec_id;	} else {		p->real_parent = current;		p->parent_exec_id = current->self_exec_id;	}	spin_lock(&current->sighand->siglock);	recalc_sigpending();	if (signal_pending(current)) {		spin_unlock(&current->sighand->siglock);		write_unlock_irq(&tasklist_lock);		retval = -ERESTARTNOINTR;		goto bad_fork_free_pid;	}	if (clone_flags & CLONE_THREAD) {		current->signal->nr_threads++;		atomic_inc(&current->signal->live);		atomic_inc(&current->signal->sigcnt);		p->group_leader = current->group_leader;		list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);	}	if (likely(p->pid)) {		ptrace_init_task(p, (clone_flags & CLONE_PTRACE) || trace);		if (thread_group_leader(p)) {			if (is_child_reaper(pid))				p->nsproxy->pid_ns->child_reaper = p;			p->signal->leader_pid = pid;			p->signal->tty = tty_kref_get(current->signal->tty);			attach_pid(p, PIDTYPE_PGID, task_pgrp(current));			attach_pid(p, PIDTYPE_SID, task_session(current));			list_add_tail(&p->sibling, &p->real_parent->children);			list_add_tail_rcu(&p->tasks, &init_task.tasks);			__this_cpu_inc(process_counts);		}		attach_pid(p, PIDTYPE_PID, pid);		nr_threads++;	}	total_forks++;	spin_unlock(&current->sighand->siglock);	write_unlock_irq(&tasklist_lock);	proc_fork_connector(p);	cgroup_post_fork(p);	if (clone_flags & CLONE_THREAD)		threadgroup_change_end(current);	perf_event_fork(p);	trace_task_newtask(p, clone_flags);	return p;bad_fork_free_pid:	if (pid != &init_struct_pid)		free_pid(pid);bad_fork_cleanup_io:	if (p->io_context)		exit_io_context(p);bad_fork_cleanup_namespaces:	if (unlikely(clone_flags & CLONE_NEWPID))		pid_ns_release_proc(p->nsproxy->pid_ns);	exit_task_namespaces(p);