[net-next-2.6.git] / kernel / cred.c

/* Task credentials management
 *
 * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 */
#include <linux/module.h>
#include <linux/cred.h>
#include <linux/sched.h>
#include <linux/key.h>
#include <linux/keyctl.h>
#include <linux/init_task.h>
#include <linux/security.h>
#include <linux/cn_proc.h>
#include "cred-internals.h"

static struct kmem_cache *cred_jar;

/*
 * The common credentials for the initial task's thread group
 */
#ifdef CONFIG_KEYS
static struct thread_group_cred init_tgcred = {
	.usage	= ATOMIC_INIT(2),
	.tgid	= 0,
	.lock	= SPIN_LOCK_UNLOCKED,
};
#endif

/*
 * The initial credentials for the initial task
 */
struct cred init_cred = {
	.usage			= ATOMIC_INIT(3),
	.securebits		= SECUREBITS_DEFAULT,
	.cap_inheritable	= CAP_INIT_INH_SET,
	.cap_permitted		= CAP_FULL_SET,
	.cap_effective		= CAP_INIT_EFF_SET,
	.cap_bset		= CAP_INIT_BSET,
	.user			= INIT_USER,
	.group_info		= &init_groups,
#ifdef CONFIG_KEYS
	.tgcred			= &init_tgcred,
#endif
};

/*
 * Dispose of the shared task group credentials
 */
#ifdef CONFIG_KEYS
static void release_tgcred_rcu(struct rcu_head *rcu)
{
	struct thread_group_cred *tgcred =
		container_of(rcu, struct thread_group_cred, rcu);

	BUG_ON(atomic_read(&tgcred->usage) != 0);

	key_put(tgcred->session_keyring);
	key_put(tgcred->process_keyring);
	kfree(tgcred);
}
#endif

/*
 * Release a set of thread group credentials.
 */
void release_tgcred(struct cred *cred)
{
#ifdef CONFIG_KEYS
	struct thread_group_cred *tgcred = cred->tgcred;

	if (atomic_dec_and_test(&tgcred->usage))
		call_rcu(&tgcred->rcu, release_tgcred_rcu);
#endif
}

/*
 * The RCU callback to actually dispose of a set of credentials
 */
static void put_cred_rcu(struct rcu_head *rcu)
{
	struct cred *cred = container_of(rcu, struct cred, rcu);

	if (atomic_read(&cred->usage) != 0)
		panic("CRED: put_cred_rcu() sees %p with usage %d\n",
		      cred, atomic_read(&cred->usage));

	security_cred_free(cred);
	key_put(cred->thread_keyring);
	key_put(cred->request_key_auth);
	release_tgcred(cred);
	put_group_info(cred->group_info);
	free_uid(cred->user);
	kmem_cache_free(cred_jar, cred);
}

/**
 * __put_cred - Destroy a set of credentials
 * @cred: The record to release
 *
 * Destroy a set of credentials on which no references remain.
 */
void __put_cred(struct cred *cred)
{
	BUG_ON(atomic_read(&cred->usage) != 0);

	call_rcu(&cred->rcu, put_cred_rcu);
}
EXPORT_SYMBOL(__put_cred);

/**
 * prepare_creds - Prepare a new set of credentials for modification
 *
 * Prepare a new set of task credentials for modification.  A task's creds
 * shouldn't generally be modified directly, therefore this function is used to
 * prepare a new copy, which the caller then modifies and then commits by
 * calling commit_creds().
 *
 * Returns a pointer to the new creds-to-be if successful, NULL otherwise.
 *
 * Call commit_creds() or abort_creds() to clean up.
 */
struct cred *prepare_creds(void)
{
	struct task_struct *task = current;
	const struct cred *old;
	struct cred *new;

	BUG_ON(atomic_read(&task->cred->usage) < 1);

	new = kmem_cache_alloc(cred_jar, GFP_KERNEL);
	if (!new)
		return NULL;

	old = task->cred;
	memcpy(new, old, sizeof(struct cred));

	atomic_set(&new->usage, 1);
	get_group_info(new->group_info);
	get_uid(new->user);

#ifdef CONFIG_KEYS
	key_get(new->thread_keyring);
	key_get(new->request_key_auth);
	atomic_inc(&new->tgcred->usage);
#endif

#ifdef CONFIG_SECURITY
	new->security = NULL;
#endif

	if (security_prepare_creds(new, old, GFP_KERNEL) < 0)
		goto error;
	return new;

error:
	abort_creds(new);
	return NULL;
}
EXPORT_SYMBOL(prepare_creds);

/*
 * prepare new credentials for the usermode helper dispatcher
 */
struct cred *prepare_usermodehelper_creds(void)
{
#ifdef CONFIG_KEYS
	struct thread_group_cred *tgcred = NULL;
#endif
	struct cred *new;

#ifdef CONFIG_KEYS
	tgcred = kzalloc(sizeof(*new->tgcred), GFP_ATOMIC);
	if (!tgcred)
		return NULL;
#endif

	new = kmem_cache_alloc(cred_jar, GFP_ATOMIC);
	if (!new)
		return NULL;

	memcpy(new, &init_cred, sizeof(struct cred));

	atomic_set(&new->usage, 1);
	get_group_info(new->group_info);
	get_uid(new->user);

#ifdef CONFIG_KEYS
	new->thread_keyring = NULL;
	new->request_key_auth = NULL;
	new->jit_keyring = KEY_REQKEY_DEFL_DEFAULT;

	atomic_set(&tgcred->usage, 1);
	spin_lock_init(&tgcred->lock);
	new->tgcred = tgcred;
#endif

#ifdef CONFIG_SECURITY
	new->security = NULL;
#endif
	if (security_prepare_creds(new, &init_cred, GFP_ATOMIC) < 0)
		goto error;

	BUG_ON(atomic_read(&new->usage) != 1);
	return new;

error:
	put_cred(new);
	return NULL;
}

/*
 * Copy credentials for the new process created by fork()
 *
 * We share if we can, but under some circumstances we have to generate a new
 * set.
 */
int copy_creds(struct task_struct *p, unsigned long clone_flags)
{
#ifdef CONFIG_KEYS
	struct thread_group_cred *tgcred;
#endif
	struct cred *new;

	mutex_init(&p->cred_exec_mutex);

	if (
#ifdef CONFIG_KEYS
		!p->cred->thread_keyring &&
#endif
		clone_flags & CLONE_THREAD
	    ) {
		get_cred(p->cred);
		atomic_inc(&p->cred->user->processes);
		return 0;
	}

	new = prepare_creds();
	if (!new)
		return -ENOMEM;

#ifdef CONFIG_KEYS
	/* new threads get their own thread keyrings if their parent already
	 * had one */
	if (new->thread_keyring) {
		key_put(new->thread_keyring);
		new->thread_keyring = NULL;
		if (clone_flags & CLONE_THREAD)
			install_thread_keyring_to_cred(new);
	}

	/* we share the process and session keyrings between all the threads in
	 * a process - this is slightly icky as we violate COW credentials a
	 * bit */
	if (!(clone_flags & CLONE_THREAD)) {
		tgcred = kmalloc(sizeof(*tgcred), GFP_KERNEL);
		if (!tgcred) {
			put_cred(new);
			return -ENOMEM;
		}
		atomic_set(&tgcred->usage, 1);
		spin_lock_init(&tgcred->lock);
		tgcred->process_keyring = NULL;
		tgcred->session_keyring = key_get(new->tgcred->session_keyring);

		release_tgcred(new);
		new->tgcred = tgcred;
	}
#endif

	atomic_inc(&new->user->processes);
	p->cred = new;
	return 0;
}

/**
 * commit_creds - Install new credentials upon the current task
 * @new: The credentials to be assigned
 *
 * Install a new set of credentials to the current task, using RCU to replace
 * the old set.
 *
 * This function eats the caller's reference to the new credentials.
 *
 * Always returns 0 thus allowing this function to be tail-called at the end
 * of, say, sys_setgid().
 */
int commit_creds(struct cred *new)
{
	struct task_struct *task = current;
	const struct cred *old;

	BUG_ON(atomic_read(&new->usage) < 1);
	BUG_ON(atomic_read(&task->cred->usage) < 1);

	old = task->cred;
	security_commit_creds(new, old);

	/* dumpability changes */
	if (old->euid != new->euid ||
	    old->egid != new->egid ||
	    old->fsuid != new->fsuid ||
	    old->fsgid != new->fsgid ||
	    !cap_issubset(new->cap_permitted, old->cap_permitted)) {
		set_dumpable(task->mm, suid_dumpable);
		task->pdeath_signal = 0;
		smp_wmb();
	}

	/* alter the thread keyring */
	if (new->fsuid != old->fsuid)
		key_fsuid_changed(task);
	if (new->fsgid != old->fsgid)
		key_fsgid_changed(task);

	/* do it
	 * - What if a process setreuid()'s and this brings the
	 *   new uid over his NPROC rlimit?  We can check this now
	 *   cheaply with the new uid cache, so if it matters
	 *   we should be checking for it.  -DaveM
	 */
	if (new->user != old->user)
		atomic_inc(&new->user->processes);
	rcu_assign_pointer(task->cred, new);
	if (new->user != old->user)
		atomic_dec(&old->user->processes);

	sched_switch_user(task);

	/* send notifications */
	if (new->uid   != old->uid  ||
	    new->euid  != old->euid ||
	    new->suid  != old->suid ||
	    new->fsuid != old->fsuid)
		proc_id_connector(task, PROC_EVENT_UID);

	if (new->gid   != old->gid  ||
	    new->egid  != old->egid ||
	    new->sgid  != old->sgid ||
	    new->fsgid != old->fsgid)
		proc_id_connector(task, PROC_EVENT_GID);

	put_cred(old);
	return 0;
}
EXPORT_SYMBOL(commit_creds);

/**
 * abort_creds - Discard a set of credentials and unlock the current task
 * @new: The credentials that were going to be applied
 *
 * Discard a set of credentials that were under construction and unlock the
 * current task.
 */
void abort_creds(struct cred *new)
{
	BUG_ON(atomic_read(&new->usage) < 1);
	put_cred(new);
}
EXPORT_SYMBOL(abort_creds);

/**
 * override_creds - Temporarily override the current process's credentials
 * @new: The credentials to be assigned
 *
 * Install a set of temporary override credentials on the current process,
 * returning the old set for later reversion.
 */
const struct cred *override_creds(const struct cred *new)
{
	const struct cred *old = current->cred;

	rcu_assign_pointer(current->cred, get_cred(new));
	return old;
}
EXPORT_SYMBOL(override_creds);

/**
 * revert_creds - Revert a temporary credentials override
 * @old: The credentials to be restored
 *
 * Revert a temporary set of override credentials to an old set, discarding the
 * override set.
 */
void revert_creds(const struct cred *old)
{
	const struct cred *override = current->cred;

	rcu_assign_pointer(current->cred, old);
	put_cred(override);
}
EXPORT_SYMBOL(revert_creds);

/*
 * initialise the credentials stuff
 */
void __init cred_init(void)
{
	/* allocate a slab in which we can store credentials */
	cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred),
				     0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
}
Commit	Line	Data
f1752eec DH	1	/* Task credentials management
	2	*
	3	* Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public Licence
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the Licence, or (at your option) any later version.
	10	*/
	11	#include <linux/module.h>
	12	#include <linux/cred.h>
	13	#include <linux/sched.h>
	14	#include <linux/key.h>
	15	#include <linux/keyctl.h>
	16	#include <linux/init_task.h>
	17	#include <linux/security.h>
d84f4f99 DH	18	#include <linux/cn_proc.h>
	19	#include "cred-internals.h"
	20
	21	static struct kmem_cache *cred_jar;
f1752eec	22
bb952bb9 DH	23	/*
	24	* The common credentials for the initial task's thread group
	25	*/
	26	#ifdef CONFIG_KEYS
	27	static struct thread_group_cred init_tgcred = {
	28	.usage = ATOMIC_INIT(2),
	29	.tgid = 0,
	30	.lock = SPIN_LOCK_UNLOCKED,
	31	};
	32	#endif
	33
f1752eec DH	34	/*
	35	* The initial credentials for the initial task
	36	*/
	37	struct cred init_cred = {
	38	.usage = ATOMIC_INIT(3),
	39	.securebits = SECUREBITS_DEFAULT,
	40	.cap_inheritable = CAP_INIT_INH_SET,
	41	.cap_permitted = CAP_FULL_SET,
	42	.cap_effective = CAP_INIT_EFF_SET,
	43	.cap_bset = CAP_INIT_BSET,
	44	.user = INIT_USER,
	45	.group_info = &init_groups,
bb952bb9 DH	46	#ifdef CONFIG_KEYS
	47	.tgcred = &init_tgcred,
	48	#endif
f1752eec DH	49	};
f1752eec DH	50
bb952bb9 DH	51	/*
	52	* Dispose of the shared task group credentials
	53	*/
	54	#ifdef CONFIG_KEYS
	55	static void release_tgcred_rcu(struct rcu_head *rcu)
	56	{
	57	struct thread_group_cred *tgcred =
	58	container_of(rcu, struct thread_group_cred, rcu);
	59
	60	BUG_ON(atomic_read(&tgcred->usage) != 0);
	61
	62	key_put(tgcred->session_keyring);
	63	key_put(tgcred->process_keyring);
	64	kfree(tgcred);
	65	}
	66	#endif
	67
	68	/*
	69	* Release a set of thread group credentials.
	70	*/
d84f4f99	71	void release_tgcred(struct cred *cred)
bb952bb9 DH	72	{
	73	#ifdef CONFIG_KEYS
	74	struct thread_group_cred *tgcred = cred->tgcred;
	75
	76	if (atomic_dec_and_test(&tgcred->usage))
	77	call_rcu(&tgcred->rcu, release_tgcred_rcu);
	78	#endif
	79	}
	80
f1752eec DH	81	/*
	82	* The RCU callback to actually dispose of a set of credentials
	83	*/
	84	static void put_cred_rcu(struct rcu_head *rcu)
	85	{
	86	struct cred *cred = container_of(rcu, struct cred, rcu);
	87
d84f4f99 DH	88	if (atomic_read(&cred->usage) != 0)
	89	panic("CRED: put_cred_rcu() sees %p with usage %d\n",
	90	cred, atomic_read(&cred->usage));
f1752eec	91
d84f4f99	92	security_cred_free(cred);
f1752eec DH	93	key_put(cred->thread_keyring);
f1752eec DH	94	key_put(cred->request_key_auth);
bb952bb9	95	release_tgcred(cred);
f1752eec DH	96	put_group_info(cred->group_info);
f1752eec DH	97	free_uid(cred->user);
d84f4f99	98	kmem_cache_free(cred_jar, cred);
f1752eec DH	99	}
	100
	101	/**
	102	* __put_cred - Destroy a set of credentials
d84f4f99	103	* @cred: The record to release
f1752eec DH	104	*
	105	* Destroy a set of credentials on which no references remain.
	106	*/
	107	void __put_cred(struct cred *cred)
	108	{
d84f4f99 DH	109	BUG_ON(atomic_read(&cred->usage) != 0);
d84f4f99 DH	110
f1752eec DH	111	call_rcu(&cred->rcu, put_cred_rcu);
	112	}
	113	EXPORT_SYMBOL(__put_cred);
	114
d84f4f99 DH	115	/**
	116	* prepare_creds - Prepare a new set of credentials for modification
	117	*
	118	* Prepare a new set of task credentials for modification. A task's creds
	119	* shouldn't generally be modified directly, therefore this function is used to
	120	* prepare a new copy, which the caller then modifies and then commits by
	121	* calling commit_creds().
	122	*
	123	* Returns a pointer to the new creds-to-be if successful, NULL otherwise.
	124	*
	125	* Call commit_creds() or abort_creds() to clean up.
	126	*/
	127	struct cred *prepare_creds(void)
	128	{
	129	struct task_struct *task = current;
	130	const struct cred *old;
	131	struct cred *new;
	132
	133	BUG_ON(atomic_read(&task->cred->usage) < 1);
	134
	135	new = kmem_cache_alloc(cred_jar, GFP_KERNEL);
	136	if (!new)
	137	return NULL;
	138
	139	old = task->cred;
	140	memcpy(new, old, sizeof(struct cred));
	141
	142	atomic_set(&new->usage, 1);
	143	get_group_info(new->group_info);
	144	get_uid(new->user);
	145
	146	#ifdef CONFIG_KEYS
	147	key_get(new->thread_keyring);
	148	key_get(new->request_key_auth);
	149	atomic_inc(&new->tgcred->usage);
	150	#endif
	151
	152	#ifdef CONFIG_SECURITY
	153	new->security = NULL;
	154	#endif
	155
	156	if (security_prepare_creds(new, old, GFP_KERNEL) < 0)
	157	goto error;
	158	return new;
	159
	160	error:
	161	abort_creds(new);
	162	return NULL;
	163	}
	164	EXPORT_SYMBOL(prepare_creds);
	165
	166	/*
	167	* prepare new credentials for the usermode helper dispatcher
	168	*/
	169	struct cred *prepare_usermodehelper_creds(void)
	170	{
	171	#ifdef CONFIG_KEYS
	172	struct thread_group_cred *tgcred = NULL;
	173	#endif
	174	struct cred *new;
	175
	176	#ifdef CONFIG_KEYS
	177	tgcred = kzalloc(sizeof(*new->tgcred), GFP_ATOMIC);
	178	if (!tgcred)
179	return NULL;
180	#endif
181
182	new = kmem_cache_alloc(cred_jar, GFP_ATOMIC);
183	if (!new)
184	return NULL;
185
186	memcpy(new, &init_cred, sizeof(struct cred));
187
188	atomic_set(&new->usage, 1);
189	get_group_info(new->group_info);
190	get_uid(new->user);
191
192	#ifdef CONFIG_KEYS
193	new->thread_keyring = NULL;
194	new->request_key_auth = NULL;
195	new->jit_keyring = KEY_REQKEY_DEFL_DEFAULT;
196
197	atomic_set(&tgcred->usage, 1);
198	spin_lock_init(&tgcred->lock);
199	new->tgcred = tgcred;
200	#endif
201
202	#ifdef CONFIG_SECURITY
203	new->security = NULL;
204	#endif
205	if (security_prepare_creds(new, &init_cred, GFP_ATOMIC) < 0)
206	goto error;
207
208	BUG_ON(atomic_read(&new->usage) != 1);
209	return new;
210
211	error:
212	put_cred(new);
213	return NULL;
214	}
215
f1752eec DH	216	/*
f1752eec DH	217	* Copy credentials for the new process created by fork()
d84f4f99 DH	218	*
	219	* We share if we can, but under some circumstances we have to generate a new
	220	* set.
f1752eec DH	221	*/
	222	int copy_creds(struct task_struct *p, unsigned long clone_flags)
	223	{
d84f4f99 DH	224	#ifdef CONFIG_KEYS
	225	struct thread_group_cred *tgcred;
	226	#endif
	227	struct cred *new;
	228
	229	mutex_init(&p->cred_exec_mutex);
f1752eec	230
d84f4f99 DH	231	if (
	232	#ifdef CONFIG_KEYS
	233	!p->cred->thread_keyring &&
	234	#endif
	235	clone_flags & CLONE_THREAD
	236	) {
	237	get_cred(p->cred);
	238	atomic_inc(&p->cred->user->processes);
	239	return 0;
	240	}
	241
	242	new = prepare_creds();
	243	if (!new)
f1752eec DH	244	return -ENOMEM;
f1752eec DH	245
bb952bb9	246	#ifdef CONFIG_KEYS
d84f4f99 DH	247	/* new threads get their own thread keyrings if their parent already
	248	* had one */
	249	if (new->thread_keyring) {
	250	key_put(new->thread_keyring);
	251	new->thread_keyring = NULL;
	252	if (clone_flags & CLONE_THREAD)
	253	install_thread_keyring_to_cred(new);
	254	}
	255
	256	/* we share the process and session keyrings between all the threads in
	257	* a process - this is slightly icky as we violate COW credentials a
	258	* bit */
	259	if (!(clone_flags & CLONE_THREAD)) {
	260	tgcred = kmalloc(sizeof(*tgcred), GFP_KERNEL);
	261	if (!tgcred) {
	262	put_cred(new);
bb952bb9 DH	263	return -ENOMEM;
bb952bb9 DH	264	}
d84f4f99 DH	265	atomic_set(&tgcred->usage, 1);
	266	spin_lock_init(&tgcred->lock);
	267	tgcred->process_keyring = NULL;
	268	tgcred->session_keyring = key_get(new->tgcred->session_keyring);
	269
	270	release_tgcred(new);
	271	new->tgcred = tgcred;
bb952bb9 DH	272	}
	273	#endif
	274
d84f4f99 DH	275	atomic_inc(&new->user->processes);
	276	p->cred = new;
	277	return 0;
	278	}
f1752eec	279
d84f4f99 DH	280	/**
	281	* commit_creds - Install new credentials upon the current task
	282	* @new: The credentials to be assigned
	283	*
	284	* Install a new set of credentials to the current task, using RCU to replace
	285	* the old set.
	286	*
	287	* This function eats the caller's reference to the new credentials.
	288	*
	289	* Always returns 0 thus allowing this function to be tail-called at the end
	290	* of, say, sys_setgid().
	291	*/
	292	int commit_creds(struct cred *new)
	293	{
	294	struct task_struct *task = current;
	295	const struct cred *old;
	296
	297	BUG_ON(atomic_read(&new->usage) < 1);
	298	BUG_ON(atomic_read(&task->cred->usage) < 1);
	299
	300	old = task->cred;
	301	security_commit_creds(new, old);
	302
	303	/* dumpability changes */
	304	if (old->euid != new->euid \|\|
	305	old->egid != new->egid \|\|
	306	old->fsuid != new->fsuid \|\|
	307	old->fsgid != new->fsgid \|\|
	308	!cap_issubset(new->cap_permitted, old->cap_permitted)) {
	309	set_dumpable(task->mm, suid_dumpable);
	310	task->pdeath_signal = 0;
	311	smp_wmb();
f1752eec DH	312	}
f1752eec DH	313
d84f4f99 DH	314	/* alter the thread keyring */
	315	if (new->fsuid != old->fsuid)
	316	key_fsuid_changed(task);
	317	if (new->fsgid != old->fsgid)
	318	key_fsgid_changed(task);
	319
	320	/* do it
	321	* - What if a process setreuid()'s and this brings the
	322	* new uid over his NPROC rlimit? We can check this now
	323	* cheaply with the new uid cache, so if it matters
	324	* we should be checking for it. -DaveM
	325	*/
	326	if (new->user != old->user)
	327	atomic_inc(&new->user->processes);
	328	rcu_assign_pointer(task->cred, new);
	329	if (new->user != old->user)
	330	atomic_dec(&old->user->processes);
	331
	332	sched_switch_user(task);
	333
	334	/* send notifications */
	335	if (new->uid != old->uid \|\|
	336	new->euid != old->euid \|\|
	337	new->suid != old->suid \|\|
	338	new->fsuid != old->fsuid)
	339	proc_id_connector(task, PROC_EVENT_UID);
f1752eec	340
d84f4f99 DH	341	if (new->gid != old->gid \|\|
	342	new->egid != old->egid \|\|
	343	new->sgid != old->sgid \|\|
	344	new->fsgid != old->fsgid)
	345	proc_id_connector(task, PROC_EVENT_GID);
f1752eec	346
d84f4f99	347	put_cred(old);
f1752eec DH	348	return 0;
f1752eec DH	349	}
d84f4f99 DH	350	EXPORT_SYMBOL(commit_creds);
	351
	352	/**
	353	* abort_creds - Discard a set of credentials and unlock the current task
	354	* @new: The credentials that were going to be applied
	355	*
	356	* Discard a set of credentials that were under construction and unlock the
	357	* current task.
	358	*/
	359	void abort_creds(struct cred *new)
	360	{
	361	BUG_ON(atomic_read(&new->usage) < 1);
	362	put_cred(new);
	363	}
	364	EXPORT_SYMBOL(abort_creds);
	365
	366	/**
	367	* override_creds - Temporarily override the current process's credentials
	368	* @new: The credentials to be assigned
	369	*
	370	* Install a set of temporary override credentials on the current process,
	371	* returning the old set for later reversion.
	372	*/
	373	const struct cred override_creds(const struct cred new)
	374	{
	375	const struct cred *old = current->cred;
	376
	377	rcu_assign_pointer(current->cred, get_cred(new));
	378	return old;
	379	}
	380	EXPORT_SYMBOL(override_creds);
	381
	382	/**
	383	* revert_creds - Revert a temporary credentials override
	384	* @old: The credentials to be restored
	385	*
	386	* Revert a temporary set of override credentials to an old set, discarding the
	387	* override set.
	388	*/
	389	void revert_creds(const struct cred *old)
	390	{
	391	const struct cred *override = current->cred;
	392
	393	rcu_assign_pointer(current->cred, old);
	394	put_cred(override);
	395	}
	396	EXPORT_SYMBOL(revert_creds);
	397
	398	/*
	399	* initialise the credentials stuff
	400	*/
	401	void __init cred_init(void)
	402	{
	403	/* allocate a slab in which we can store credentials */
	404	cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred),
	405	0, SLAB_HWCACHE_ALIGN\|SLAB_PANIC, NULL);
	406	}