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

/* a simple Shell sort */static void groups_sort(struct group_info *group_info){	int base, max, stride;	int gidsetsize = group_info->ngroups;	for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)		; /* nothing */	stride /= 3;	while (stride) {		max = gidsetsize - stride;		for (base = 0; base < max; base++) {			int left = base;			int right = left + stride;			gid_t tmp = GROUP_AT(group_info, right);			while (left >= 0 && GROUP_AT(group_info, left) > tmp) {				GROUP_AT(group_info, right) =				    GROUP_AT(group_info, left);				right = left;				left -= stride;			}			GROUP_AT(group_info, right) = tmp;		}		stride /= 3;	}}

static intgeneric_match(struct auth_cred *acred, struct rpc_cred *cred, int flags){	struct generic_cred *gcred = container_of(cred, struct generic_cred, gc_base);	int i;	if (gcred->acred.uid != acred->uid ||	    gcred->acred.gid != acred->gid ||	    gcred->acred.machine_cred != acred->machine_cred)		goto out_nomatch;	/* Optimisation in the case where pointers are identical... */	if (gcred->acred.group_info == acred->group_info)		goto out_match;	/* Slow path... */	if (gcred->acred.group_info->ngroups != acred->group_info->ngroups)		goto out_nomatch;	for (i = 0; i < gcred->acred.group_info->ngroups; i++) {		if (GROUP_AT(gcred->acred.group_info, i) !=				GROUP_AT(acred->group_info, i))			goto out_nomatch;	}out_match:	return 1;out_nomatch:	return 0;}

static intgeneric_match(struct auth_cred *acred, struct rpc_cred *cred, int flags){	struct generic_cred *gcred = container_of(cred, struct generic_cred, gc_base);	int i;	if (acred->machine_cred)		return machine_cred_match(acred, gcred, flags);	if (gcred->acred.uid != acred->uid ||	    gcred->acred.gid != acred->gid ||	    gcred->acred.machine_cred != 0)		goto out_nomatch;		if (gcred->acred.group_info == acred->group_info)		goto out_match;		if (gcred->acred.group_info->ngroups != acred->group_info->ngroups)		goto out_nomatch;	for (i = 0; i < gcred->acred.group_info->ngroups; i++) {		if (GROUP_AT(gcred->acred.group_info, i) !=				GROUP_AT(acred->group_info, i))			goto out_nomatch;	}out_match:	return 1;out_nomatch:	return 0;}

cr_groups_search(const struct group_info *group_info, gid_t grp)#endif{	unsigned int left, right, mid;	int cmp;	if (!group_info)		return (0);	left = 0;	right = group_info->ngroups;	while (left < right) {		mid = (left + right) / 2;		cmp = KGID_TO_SGID(grp) -		    KGID_TO_SGID(GROUP_AT(group_info, mid));		if (cmp > 0)			left = mid + 1;		else if (cmp < 0)			right = mid;		else			return (1);	}	return (0);}

static inline void task_state(struct seq_file *m, struct pid_namespace *ns,                              struct pid *pid, struct task_struct *p){    struct user_namespace *user_ns = seq_user_ns(m);    struct group_info *group_info;    int g;    struct fdtable *fdt = NULL;    const struct cred *cred;    pid_t ppid, tpid;    rcu_read_lock();    ppid = pid_alive(p) ?           task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;    tpid = 0;    if (pid_alive(p)) {        struct task_struct *tracer = ptrace_parent(p);        if (tracer)            tpid = task_pid_nr_ns(tracer, ns);    }    cred = get_task_cred(p);    seq_printf(m,               "State:/t%s/n"               "Tgid:/t%d/n"               "Pid:/t%d/n"               "PPid:/t%d/n"               "TracerPid:/t%d/n"               "Uid:/t%d/t%d/t%d/t%d/n"               "Gid:/t%d/t%d/t%d/t%d/n",               get_task_state(p),               task_tgid_nr_ns(p, ns),               pid_nr_ns(pid, ns),               ppid, tpid,               from_kuid_munged(user_ns, cred->uid),               from_kuid_munged(user_ns, cred->euid),               from_kuid_munged(user_ns, cred->suid),               from_kuid_munged(user_ns, cred->fsuid),               from_kgid_munged(user_ns, cred->gid),               from_kgid_munged(user_ns, cred->egid),               from_kgid_munged(user_ns, cred->sgid),               from_kgid_munged(user_ns, cred->fsgid));    task_lock(p);    if (p->files)        fdt = files_fdtable(p->files);    seq_printf(m,               "FDSize:/t%d/n"               "Groups:/t",               fdt ? fdt->max_fds : 0);    rcu_read_unlock();    group_info = cred->group_info;    task_unlock(p);    for (g = 0; g < group_info->ngroups; g++)        seq_printf(m, "%d ",                   from_kgid_munged(user_ns, GROUP_AT(group_info, g)));    put_cred(cred);    seq_putc(m, '/n');}

static struct rpc_cred *unx_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags){	struct unx_cred	*cred;	unsigned int groups = 0;	unsigned int i;	dprintk("RPC:       allocating UNIX cred for uid %d gid %d/n",			acred->uid, acred->gid);	if (!(cred = kmalloc(sizeof(*cred), GFP_NOFS)))		return ERR_PTR(-ENOMEM);	rpcauth_init_cred(&cred->uc_base, acred, auth, &unix_credops);	cred->uc_base.cr_flags = 1UL << RPCAUTH_CRED_UPTODATE;	if (acred->group_info != NULL)		groups = acred->group_info->ngroups;	if (groups > NFS_NGROUPS)		groups = NFS_NGROUPS;	cred->uc_gid = acred->gid;	for (i = 0; i < groups; i++)		cred->uc_gids[i] = GROUP_AT(acred->group_info, i);	if (i < NFS_NGROUPS)		cred->uc_gids[i] = NOGROUP;	return &cred->uc_base;}

static int gssx_dec_linux_creds(struct xdr_stream *xdr,				struct svc_cred *creds){	u32 length;	__be32 *p;	u32 tmp;	u32 N;	int i, err;	p = xdr_inline_decode(xdr, 4);	if (unlikely(p == NULL))		return -ENOSPC;	length = be32_to_cpup(p);	if (length > (3 + NGROUPS_MAX) * sizeof(u32))		return -ENOSPC;	/* uid */	err = get_host_u32(xdr, &tmp);	if (err)		return err;	creds->cr_uid = make_kuid(&init_user_ns, tmp);	/* gid */	err = get_host_u32(xdr, &tmp);	if (err)		return err;	creds->cr_gid = make_kgid(&init_user_ns, tmp);	/* number of additional gid's */	err = get_host_u32(xdr, &tmp);	if (err)		return err;	N = tmp;	if ((3 + N) * sizeof(u32) != length)		return -EINVAL;	creds->cr_group_info = groups_alloc(N);	if (creds->cr_group_info == NULL)		return -ENOMEM;	/* gid's */	for (i = 0; i < N; i++) {		kgid_t kgid;		err = get_host_u32(xdr, &tmp);		if (err)			goto out_free_groups;		err = -EINVAL;		kgid = make_kgid(&init_user_ns, tmp);		if (!gid_valid(kgid))			goto out_free_groups;		GROUP_AT(creds->cr_group_info, i) = kgid;	}	return 0;out_free_groups:	groups_free(creds->cr_group_info);	return err;}

static inline void task_state(struct seq_file *m, struct pid_namespace *ns,				struct pid *pid, struct task_struct *p){	struct group_info *group_info;	int g;	struct fdtable *fdt = NULL;	const struct cred *cred;	pid_t ppid, tpid, vpid;	rcu_read_lock();	ppid = pid_alive(p) ? ve_task_ppid_nr_ns(p, ns) : 0;	tpid = 0;	if (pid_alive(p)) {		struct task_struct *tracer = tracehook_tracer_task(p);		if (tracer)			tpid = task_pid_nr_ns(tracer, ns);	}	vpid = task_virtual_pid(p);	cred = get_task_cred(p);	seq_printf(m,		"State:/t%s/n"		"Tgid:/t%d/n"		"Pid:/t%d/n"		"PPid:/t%d/n"		"TracerPid:/t%d/n"		"Uid:/t%d/t%d/t%d/t%d/n"		"Gid:/t%d/t%d/t%d/t%d/n",		get_task_state(p),		task_tgid_nr_ns(p, ns),		pid_nr_ns(pid, ns),		ppid, tpid,		cred->uid, cred->euid, cred->suid, cred->fsuid,		cred->gid, cred->egid, cred->sgid, cred->fsgid);	task_utrace_proc_status(m, p);	task_lock(p);	if (p->files)		fdt = files_fdtable(p->files);	seq_printf(m,		"FDSize:/t%d/n"		"Groups:/t",		fdt ? fdt->max_fds : 0);	rcu_read_unlock();	group_info = cred->group_info;	task_unlock(p);	for (g = 0; g < min(group_info->ngroups, NGROUPS_SMALL); g++)		seq_printf(m, "%d ", GROUP_AT(group_info, g));	put_cred(cred);	seq_printf(m, "/n");	seq_printf(m, "envID:/t%d/nVPid:/t%d/n",			p->ve_task_info.owner_env->veid, vpid);	seq_printf(m, "StopState:/t%u/n", p->stopped_state);}

/* a simple bsearch */int groups_search(const struct group_info *group_info, kgid_t grp){	unsigned int left, right;	if (!group_info)		return 0;	left = 0;	right = group_info->ngroups;	while (left < right) {		unsigned int mid = (left+right)/2;		if (gid_gt(grp, GROUP_AT(group_info, mid)))			left = mid + 1;		else if (gid_lt(grp, GROUP_AT(group_info, mid)))			right = mid;		else			return 1;	}	return 0;}

static int groups16_to_user(u16 __user *grouplist, struct group_info *group_info){	int i;	u16 group;	for (i = 0; i < group_info->ngroups; i++) {		group = (u16)GROUP_AT(group_info, i);		if (put_user(group, grouplist+i))			return -EFAULT;	}	return 0;}

static int groups16_from_user(struct group_info *group_info, u16 __user *grouplist){	int i;	u16 group;	for (i = 0; i < group_info->ngroups; i++) {		if (get_user(group, grouplist+i))			return  -EFAULT;		GROUP_AT(group_info, i) = (gid_t)group;	}	return 0;}

static inline void task_state(struct seq_file *m, struct pid_namespace *ns,				struct pid *pid, struct task_struct *p){	struct group_info *group_info;	int g;	struct fdtable *fdt = NULL;	pid_t ppid, tpid;	rcu_read_lock();	ppid = pid_alive(p) ?		task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;	tpid = 0;	if (pid_alive(p)) {		struct task_struct *tracer = tracehook_tracer_task(p);		if (tracer)			tpid = task_pid_nr_ns(tracer, ns);	}	seq_printf(m,		"State:/t%s/n"		"Tgid:/t%d/n"		"Pid:/t%d/n"		"PPid:/t%d/n"		"TracerPid:/t%d/n"		"Uid:/t%d/t%d/t%d/t%d/n"		"Gid:/t%d/t%d/t%d/t%d/n",		get_task_state(p),		task_tgid_nr_ns(p, ns),		pid_nr_ns(pid, ns),		ppid, tpid,		p->uid, p->euid, p->suid, p->fsuid,		p->gid, p->egid, p->sgid, p->fsgid);	task_lock(p);	if (p->files)		fdt = files_fdtable(p->files);	seq_printf(m,		"FDSize:/t%d/n"		"Groups:/t",		fdt ? fdt->max_fds : 0);	rcu_read_unlock();	group_info = p->group_info;	get_group_info(group_info);	task_unlock(p);	for (g = 0; g < min(group_info->ngroups, NGROUPS_SMALL); g++)		seq_printf(m, "%d ", GROUP_AT(group_info, g));	put_group_info(group_info);	seq_printf(m, "/n");}

static int groups16_to_user(old_gid_t __user *grouplist,    struct group_info *group_info){    int i;    old_gid_t group;    for (i = 0; i < group_info->ngroups; i++) {        group = high2lowgid(GROUP_AT(group_info, i));        if (put_user(group, grouplist+i))            return -EFAULT;    }    return 0;}

static int groups16_from_user(struct group_info *group_info,    old_gid_t __user *grouplist){    int i;    old_gid_t group;    for (i = 0; i < group_info->ngroups; i++) {        if (get_user(group, grouplist+i))            return  -EFAULT;        GROUP_AT(group_info, i) = low2highgid(group);    }    return 0;}

/* export the group_info to a user-space array */static int groups_to_user(gid_t __user *grouplist,			  const struct group_info *group_info){	struct user_namespace *user_ns = current_user_ns();	int i;	unsigned int count = group_info->ngroups;	for (i = 0; i < count; i++) {		gid_t gid;		gid = from_kgid_munged(user_ns, GROUP_AT(group_info, i));		if (put_user(gid, grouplist+i))			return -EFAULT;	}	return 0;}

static inline char * task_state(struct task_struct *p, char *buffer){	struct group_info *group_info;	int g;	struct fdtable *fdt = NULL;	read_lock(&tasklist_lock);	buffer += sprintf(buffer,		"State:/t%s/n"		"SleepAVG:/t%lu%%/n"		"Tgid:/t%d/n"		"Pid:/t%d/n"		"PPid:/t%d/n"		"TracerPid:/t%d/n"		"Uid:/t%d/t%d/t%d/t%d/n"		"Gid:/t%d/t%d/t%d/t%d/n",		get_task_state(p),		(p->sleep_avg/1024)*100/(1020000000/1024),	       	p->tgid,		p->pid, pid_alive(p) ? p->group_leader->real_parent->tgid : 0,		pid_alive(p) && p->ptrace ? p->parent->pid : 0,		p->uid, p->euid, p->suid, p->fsuid,		p->gid, p->egid, p->sgid, p->fsgid);	read_unlock(&tasklist_lock);	task_lock(p);	rcu_read_lock();	if (p->files)		fdt = files_fdtable(p->files);	buffer += sprintf(buffer,		"FDSize:/t%d/n"		"Groups:/t",		fdt ? fdt->max_fds : 0);	rcu_read_unlock();	group_info = p->group_info;	get_group_info(group_info);	task_unlock(p);	for (g = 0; g < min(group_info->ngroups,NGROUPS_SMALL); g++)		buffer += sprintf(buffer, "%d ", GROUP_AT(group_info,g));	put_group_info(group_info);	buffer += sprintf(buffer, "/n");	return buffer;}

static inline void task_state(struct seq_file *m, struct pid *pid,				struct task_struct *p){	struct group_info *group_info;	int g;	struct fdtable *fdt = NULL;	rcu_read_lock();	seq_printf(m,		"State:/t%s/n"		"SleepAVG:/t%lu%%/n"		"Tgid:/t%d/n"		"Pid:/t%d/n"		"PPid:/t%d/n"		"TracerPid:/t%d/n"		"Uid:/t%d/t%d/t%d/t%d/n"		"Gid:/t%d/t%d/t%d/t%d/n",		get_task_state(p),		(p->sleep_avg/1024)*100/(1020000000/1024),	       	p->tgid, p->pid,	       	pid_alive(p) ? rcu_dereference(p->real_parent)->tgid : 0,		pid_alive(p) && p->ptrace ? rcu_dereference(p->parent)->pid : 0,		p->uid, p->euid, p->suid, p->fsuid,		p->gid, p->egid, p->sgid, p->fsgid);	task_lock(p);	if (p->files)		fdt = files_fdtable(p->files);	seq_printf(m,		"FDSize:/t%d/n"		"Groups:/t",		fdt ? fdt->max_fds : 0);	rcu_read_unlock();	group_info = p->group_info;	get_group_info(group_info);	task_unlock(p);	for (g = 0; g < min(group_info->ngroups, NGROUPS_SMALL); g++)		seq_printf(m, "%d ", GROUP_AT(group_info, g));	put_group_info(group_info);	seq_printf(m, "/n");}

/* * Match credentials against current process creds. * The root_override argument takes care of cases where the caller may * request root creds (e.g. for NFS swapping). */static intunx_match(struct auth_cred *acred, struct rpc_cred *rcred, int flags){	struct unx_cred	*cred = container_of(rcred, struct unx_cred, uc_base);	unsigned int groups = 0;	unsigned int i;	if (cred->uc_uid != acred->uid || cred->uc_gid != acred->gid)		return 0;	if (acred->group_info != NULL)		groups = acred->group_info->ngroups;	if (groups > NFS_NGROUPS)		groups = NFS_NGROUPS;	for (i = 0; i < groups ; i++)		if (cred->uc_gids[i] != GROUP_AT(acred->group_info, i))			return 0;	return 1;}

/* a simple bsearch */int groups_search(struct group_info *group_info, gid_t grp){	unsigned int left, right;	if (!group_info)		return 0;	left = 0;	right = group_info->ngroups;	while (left < right) {		unsigned int mid = (left+right)/2;		int cmp = grp - GROUP_AT(group_info, mid);		if (cmp > 0)			left = mid + 1;		else if (cmp < 0)			right = mid;		else			return 1;	}	return 0;}

/* fill a group_info from a user-space array - it must be allocated already */static int groups_from_user(struct group_info *group_info,    gid_t __user *grouplist){	struct user_namespace *user_ns = current_user_ns();	int i;	unsigned int count = group_info->ngroups;	for (i = 0; i < count; i++) {		gid_t gid;		kgid_t kgid;		if (get_user(gid, grouplist+i))			return -EFAULT;		kgid = make_kgid(user_ns, gid);		if (!gid_valid(kgid))			return -EINVAL;		GROUP_AT(group_info, i) = kgid;	}	return 0;}

/* * Match credentials against current process creds. * The root_override argument takes care of cases where the caller may * request root creds (e.g. for NFS swapping). */static intunx_match(struct auth_cred *acred, struct rpc_cred *rcred, int flags){	struct unx_cred	*cred = container_of(rcred, struct unx_cred, uc_base);	unsigned int groups = 0;	unsigned int i;	if (!uid_eq(cred->uc_uid, acred->uid) || !gid_eq(cred->uc_gid, acred->gid))		return 0;	if (acred->group_info != NULL)		groups = acred->group_info->ngroups;	if (groups > NFS_NGROUPS)		groups = NFS_NGROUPS;	for (i = 0; i < groups ; i++)		if (!gid_eq(cred->uc_gids[i], GROUP_AT(acred->group_info, i)))			return 0;	if (groups < NFS_NGROUPS && gid_valid(cred->uc_gids[groups]))		return 0;	return 1;}

static inline void task_state(struct seq_file *m, struct pid_namespace *ns,				struct pid *pid, struct task_struct *p){	struct user_namespace *user_ns = seq_user_ns(m);	struct group_info *group_info;	int g;	struct task_struct *tracer;	const struct cred *cred;	pid_t ppid, tpid = 0, tgid, ngid;	unsigned int max_fds = 0;	rcu_read_lock();	ppid = pid_alive(p) ?		task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;	tracer = ptrace_parent(p);	if (tracer)		tpid = task_pid_nr_ns(tracer, ns);	tgid = task_tgid_nr_ns(p, ns);	ngid = task_numa_group_id(p);	cred = get_task_cred(p);	task_lock(p);	if (p->files)		max_fds = files_fdtable(p->files)->max_fds;	task_unlock(p);	rcu_read_unlock();	seq_printf(m,		"State:/t%s/n"		"Tgid:/t%d/n"		"Ngid:/t%d/n"		"Pid:/t%d/n"		"PPid:/t%d/n"		"TracerPid:/t%d/n"		"Uid:/t%d/t%d/t%d/t%d/n"		"Gid:/t%d/t%d/t%d/t%d/n"		"FDSize:/t%d/nGroups:/t",		get_task_state(p),		tgid, ngid, pid_nr_ns(pid, ns), ppid, tpid,		from_kuid_munged(user_ns, cred->uid),		from_kuid_munged(user_ns, cred->euid),		from_kuid_munged(user_ns, cred->suid),		from_kuid_munged(user_ns, cred->fsuid),		from_kgid_munged(user_ns, cred->gid),		from_kgid_munged(user_ns, cred->egid),		from_kgid_munged(user_ns, cred->sgid),		from_kgid_munged(user_ns, cred->fsgid),		max_fds);	group_info = cred->group_info;	for (g = 0; g < group_info->ngroups; g++)		seq_printf(m, "%d ",			   from_kgid_munged(user_ns, GROUP_AT(group_info, g)));	put_cred(cred);#ifdef CONFIG_PID_NS	seq_puts(m, "/nNStgid:");	for (g = ns->level; g <= pid->level; g++)		seq_printf(m, "/t%d",			task_tgid_nr_ns(p, pid->numbers[g].ns));	seq_puts(m, "/nNSpid:");	for (g = ns->level; g <= pid->level; g++)		seq_printf(m, "/t%d",			task_pid_nr_ns(p, pid->numbers[g].ns));	seq_puts(m, "/nNSpgid:");	for (g = ns->level; g <= pid->level; g++)		seq_printf(m, "/t%d",			task_pgrp_nr_ns(p, pid->numbers[g].ns));	seq_puts(m, "/nNSsid:");	for (g = ns->level; g <= pid->level; g++)		seq_printf(m, "/t%d",			task_session_nr_ns(p, pid->numbers[g].ns));#endif	seq_putc(m, '/n');}

int nfsd_setuser(struct svc_rqst *rqstp, struct svc_export *exp){	struct svc_cred	cred = rqstp->rq_cred;	int i;	int flags = nfsexp_flags(rqstp, exp);	int ret;	if (flags & NFSEXP_ALLSQUASH) {		cred.cr_uid = exp->ex_anon_uid;		cred.cr_gid = exp->ex_anon_gid;		cred.cr_group_info = groups_alloc(0);	} else if (flags & NFSEXP_ROOTSQUASH) {		struct group_info *gi;		if (!cred.cr_uid)			cred.cr_uid = exp->ex_anon_uid;		if (!cred.cr_gid)			cred.cr_gid = exp->ex_anon_gid;		gi = groups_alloc(cred.cr_group_info->ngroups);		if (gi)			for (i = 0; i < cred.cr_group_info->ngroups; i++) {				if (!GROUP_AT(cred.cr_group_info, i))					GROUP_AT(gi, i) = exp->ex_anon_gid;				else					GROUP_AT(gi, i) = GROUP_AT(cred.cr_group_info, i);			}		cred.cr_group_info = gi;	} else		get_group_info(cred.cr_group_info);	if (cred.cr_uid != (uid_t) -1)		current->fsuid = cred.cr_uid;	else		current->fsuid = exp->ex_anon_uid;	if (cred.cr_gid != (gid_t) -1)		current->fsgid = cred.cr_gid;	else		current->fsgid = exp->ex_anon_gid;	if (!cred.cr_group_info)		return -ENOMEM;	ret = set_current_groups(cred.cr_group_info);	put_group_info(cred.cr_group_info);	if ((cred.cr_uid)) {		current->cap_effective =			cap_drop_nfsd_set(current->cap_effective);	} else {		current->cap_effective =			cap_raise_nfsd_set(current->cap_effective,					   current->cap_permitted);	}	return ret;}