remove the build INITRAMFS
[qi-kernel.git] / kernel / cred.c
blob1ed8ca18790c1e937208af47bed6695f4218858b
1 /* Task credentials management - see Documentation/credentials.txt
3 * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
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>
18 #include <linux/cn_proc.h>
19 #include "cred-internals.h"
21 #if 0
22 #define kdebug(FMT, ...) \
23 printk("[%-5.5s%5u] "FMT"\n", current->comm, current->pid ,##__VA_ARGS__)
24 #else
25 static inline __attribute__((format(printf, 1, 2)))
26 void no_printk(const char *fmt, ...)
29 #define kdebug(FMT, ...) \
30 no_printk("[%-5.5s%5u] "FMT"\n", current->comm, current->pid ,##__VA_ARGS__)
31 #endif
33 static struct kmem_cache *cred_jar;
36 * The common credentials for the initial task's thread group
38 #ifdef CONFIG_KEYS
39 static struct thread_group_cred init_tgcred = {
40 .usage = ATOMIC_INIT(2),
41 .tgid = 0,
42 .lock = SPIN_LOCK_UNLOCKED,
44 #endif
47 * The initial credentials for the initial task
49 struct cred init_cred = {
50 .usage = ATOMIC_INIT(4),
51 #ifdef CONFIG_DEBUG_CREDENTIALS
52 .subscribers = ATOMIC_INIT(2),
53 .magic = CRED_MAGIC,
54 #endif
55 .securebits = SECUREBITS_DEFAULT,
56 .cap_inheritable = CAP_INIT_INH_SET,
57 .cap_permitted = CAP_FULL_SET,
58 .cap_effective = CAP_INIT_EFF_SET,
59 .cap_bset = CAP_INIT_BSET,
60 .user = INIT_USER,
61 .group_info = &init_groups,
62 #ifdef CONFIG_KEYS
63 .tgcred = &init_tgcred,
64 #endif
67 static inline void set_cred_subscribers(struct cred *cred, int n)
69 #ifdef CONFIG_DEBUG_CREDENTIALS
70 atomic_set(&cred->subscribers, n);
71 #endif
74 static inline int read_cred_subscribers(const struct cred *cred)
76 #ifdef CONFIG_DEBUG_CREDENTIALS
77 return atomic_read(&cred->subscribers);
78 #else
79 return 0;
80 #endif
83 static inline void alter_cred_subscribers(const struct cred *_cred, int n)
85 #ifdef CONFIG_DEBUG_CREDENTIALS
86 struct cred *cred = (struct cred *) _cred;
88 atomic_add(n, &cred->subscribers);
89 #endif
93 * Dispose of the shared task group credentials
95 #ifdef CONFIG_KEYS
96 static void release_tgcred_rcu(struct rcu_head *rcu)
98 struct thread_group_cred *tgcred =
99 container_of(rcu, struct thread_group_cred, rcu);
101 BUG_ON(atomic_read(&tgcred->usage) != 0);
103 key_put(tgcred->session_keyring);
104 key_put(tgcred->process_keyring);
105 kfree(tgcred);
107 #endif
110 * Release a set of thread group credentials.
112 static void release_tgcred(struct cred *cred)
114 #ifdef CONFIG_KEYS
115 struct thread_group_cred *tgcred = cred->tgcred;
117 if (atomic_dec_and_test(&tgcred->usage))
118 call_rcu(&tgcred->rcu, release_tgcred_rcu);
119 #endif
123 * The RCU callback to actually dispose of a set of credentials
125 static void put_cred_rcu(struct rcu_head *rcu)
127 struct cred *cred = container_of(rcu, struct cred, rcu);
129 kdebug("put_cred_rcu(%p)", cred);
131 #ifdef CONFIG_DEBUG_CREDENTIALS
132 if (cred->magic != CRED_MAGIC_DEAD ||
133 atomic_read(&cred->usage) != 0 ||
134 read_cred_subscribers(cred) != 0)
135 panic("CRED: put_cred_rcu() sees %p with"
136 " mag %x, put %p, usage %d, subscr %d\n",
137 cred, cred->magic, cred->put_addr,
138 atomic_read(&cred->usage),
139 read_cred_subscribers(cred));
140 #else
141 if (atomic_read(&cred->usage) != 0)
142 panic("CRED: put_cred_rcu() sees %p with usage %d\n",
143 cred, atomic_read(&cred->usage));
144 #endif
146 security_cred_free(cred);
147 key_put(cred->thread_keyring);
148 key_put(cred->request_key_auth);
149 release_tgcred(cred);
150 if (cred->group_info)
151 put_group_info(cred->group_info);
152 free_uid(cred->user);
153 kmem_cache_free(cred_jar, cred);
157 * __put_cred - Destroy a set of credentials
158 * @cred: The record to release
160 * Destroy a set of credentials on which no references remain.
162 void __put_cred(struct cred *cred)
164 kdebug("__put_cred(%p{%d,%d})", cred,
165 atomic_read(&cred->usage),
166 read_cred_subscribers(cred));
168 BUG_ON(atomic_read(&cred->usage) != 0);
169 #ifdef CONFIG_DEBUG_CREDENTIALS
170 BUG_ON(read_cred_subscribers(cred) != 0);
171 cred->magic = CRED_MAGIC_DEAD;
172 cred->put_addr = __builtin_return_address(0);
173 #endif
174 BUG_ON(cred == current->cred);
175 BUG_ON(cred == current->real_cred);
177 call_rcu(&cred->rcu, put_cred_rcu);
179 EXPORT_SYMBOL(__put_cred);
182 * Clean up a task's credentials when it exits
184 void exit_creds(struct task_struct *tsk)
186 struct cred *cred;
188 kdebug("exit_creds(%u,%p,%p,{%d,%d})", tsk->pid, tsk->real_cred, tsk->cred,
189 atomic_read(&tsk->cred->usage),
190 read_cred_subscribers(tsk->cred));
192 cred = (struct cred *) tsk->real_cred;
193 tsk->real_cred = NULL;
194 validate_creds(cred);
195 alter_cred_subscribers(cred, -1);
196 put_cred(cred);
198 cred = (struct cred *) tsk->cred;
199 tsk->cred = NULL;
200 validate_creds(cred);
201 alter_cred_subscribers(cred, -1);
202 put_cred(cred);
204 cred = (struct cred *) tsk->replacement_session_keyring;
205 if (cred) {
206 tsk->replacement_session_keyring = NULL;
207 validate_creds(cred);
208 put_cred(cred);
213 * Allocate blank credentials, such that the credentials can be filled in at a
214 * later date without risk of ENOMEM.
216 struct cred *cred_alloc_blank(void)
218 struct cred *new;
220 new = kmem_cache_zalloc(cred_jar, GFP_KERNEL);
221 if (!new)
222 return NULL;
224 #ifdef CONFIG_KEYS
225 new->tgcred = kzalloc(sizeof(*new->tgcred), GFP_KERNEL);
226 if (!new->tgcred) {
227 kmem_cache_free(cred_jar, new);
228 return NULL;
230 atomic_set(&new->tgcred->usage, 1);
231 #endif
233 atomic_set(&new->usage, 1);
235 if (security_cred_alloc_blank(new, GFP_KERNEL) < 0)
236 goto error;
238 #ifdef CONFIG_DEBUG_CREDENTIALS
239 new->magic = CRED_MAGIC;
240 #endif
241 return new;
243 error:
244 abort_creds(new);
245 return NULL;
249 * prepare_creds - Prepare a new set of credentials for modification
251 * Prepare a new set of task credentials for modification. A task's creds
252 * shouldn't generally be modified directly, therefore this function is used to
253 * prepare a new copy, which the caller then modifies and then commits by
254 * calling commit_creds().
256 * Preparation involves making a copy of the objective creds for modification.
258 * Returns a pointer to the new creds-to-be if successful, NULL otherwise.
260 * Call commit_creds() or abort_creds() to clean up.
262 struct cred *prepare_creds(void)
264 struct task_struct *task = current;
265 const struct cred *old;
266 struct cred *new;
268 validate_process_creds();
270 new = kmem_cache_alloc(cred_jar, GFP_KERNEL);
271 if (!new)
272 return NULL;
274 kdebug("prepare_creds() alloc %p", new);
276 old = task->cred;
277 memcpy(new, old, sizeof(struct cred));
279 atomic_set(&new->usage, 1);
280 set_cred_subscribers(new, 0);
281 get_group_info(new->group_info);
282 get_uid(new->user);
284 #ifdef CONFIG_KEYS
285 key_get(new->thread_keyring);
286 key_get(new->request_key_auth);
287 atomic_inc(&new->tgcred->usage);
288 #endif
290 #ifdef CONFIG_SECURITY
291 new->security = NULL;
292 #endif
294 if (security_prepare_creds(new, old, GFP_KERNEL) < 0)
295 goto error;
296 validate_creds(new);
297 return new;
299 error:
300 abort_creds(new);
301 return NULL;
303 EXPORT_SYMBOL(prepare_creds);
306 * Prepare credentials for current to perform an execve()
307 * - The caller must hold current->cred_guard_mutex
309 struct cred *prepare_exec_creds(void)
311 struct thread_group_cred *tgcred = NULL;
312 struct cred *new;
314 #ifdef CONFIG_KEYS
315 tgcred = kmalloc(sizeof(*tgcred), GFP_KERNEL);
316 if (!tgcred)
317 return NULL;
318 #endif
320 new = prepare_creds();
321 if (!new) {
322 kfree(tgcred);
323 return new;
326 #ifdef CONFIG_KEYS
327 /* newly exec'd tasks don't get a thread keyring */
328 key_put(new->thread_keyring);
329 new->thread_keyring = NULL;
331 /* create a new per-thread-group creds for all this set of threads to
332 * share */
333 memcpy(tgcred, new->tgcred, sizeof(struct thread_group_cred));
335 atomic_set(&tgcred->usage, 1);
336 spin_lock_init(&tgcred->lock);
338 /* inherit the session keyring; new process keyring */
339 key_get(tgcred->session_keyring);
340 tgcred->process_keyring = NULL;
342 release_tgcred(new);
343 new->tgcred = tgcred;
344 #endif
346 return new;
350 * prepare new credentials for the usermode helper dispatcher
352 struct cred *prepare_usermodehelper_creds(void)
354 #ifdef CONFIG_KEYS
355 struct thread_group_cred *tgcred = NULL;
356 #endif
357 struct cred *new;
359 #ifdef CONFIG_KEYS
360 tgcred = kzalloc(sizeof(*new->tgcred), GFP_ATOMIC);
361 if (!tgcred)
362 return NULL;
363 #endif
365 new = kmem_cache_alloc(cred_jar, GFP_ATOMIC);
366 if (!new)
367 return NULL;
369 kdebug("prepare_usermodehelper_creds() alloc %p", new);
371 memcpy(new, &init_cred, sizeof(struct cred));
373 atomic_set(&new->usage, 1);
374 set_cred_subscribers(new, 0);
375 get_group_info(new->group_info);
376 get_uid(new->user);
378 #ifdef CONFIG_KEYS
379 new->thread_keyring = NULL;
380 new->request_key_auth = NULL;
381 new->jit_keyring = KEY_REQKEY_DEFL_DEFAULT;
383 atomic_set(&tgcred->usage, 1);
384 spin_lock_init(&tgcred->lock);
385 new->tgcred = tgcred;
386 #endif
388 #ifdef CONFIG_SECURITY
389 new->security = NULL;
390 #endif
391 if (security_prepare_creds(new, &init_cred, GFP_ATOMIC) < 0)
392 goto error;
393 validate_creds(new);
395 BUG_ON(atomic_read(&new->usage) != 1);
396 return new;
398 error:
399 put_cred(new);
400 return NULL;
404 * Copy credentials for the new process created by fork()
406 * We share if we can, but under some circumstances we have to generate a new
407 * set.
409 * The new process gets the current process's subjective credentials as its
410 * objective and subjective credentials
412 int copy_creds(struct task_struct *p, unsigned long clone_flags)
414 #ifdef CONFIG_KEYS
415 struct thread_group_cred *tgcred;
416 #endif
417 struct cred *new;
418 int ret;
420 mutex_init(&p->cred_guard_mutex);
422 if (
423 #ifdef CONFIG_KEYS
424 !p->cred->thread_keyring &&
425 #endif
426 clone_flags & CLONE_THREAD
428 p->real_cred = get_cred(p->cred);
429 get_cred(p->cred);
430 alter_cred_subscribers(p->cred, 2);
431 kdebug("share_creds(%p{%d,%d})",
432 p->cred, atomic_read(&p->cred->usage),
433 read_cred_subscribers(p->cred));
434 atomic_inc(&p->cred->user->processes);
435 return 0;
438 new = prepare_creds();
439 if (!new)
440 return -ENOMEM;
442 if (clone_flags & CLONE_NEWUSER) {
443 ret = create_user_ns(new);
444 if (ret < 0)
445 goto error_put;
448 #ifdef CONFIG_KEYS
449 /* new threads get their own thread keyrings if their parent already
450 * had one */
451 if (new->thread_keyring) {
452 key_put(new->thread_keyring);
453 new->thread_keyring = NULL;
454 if (clone_flags & CLONE_THREAD)
455 install_thread_keyring_to_cred(new);
458 /* we share the process and session keyrings between all the threads in
459 * a process - this is slightly icky as we violate COW credentials a
460 * bit */
461 if (!(clone_flags & CLONE_THREAD)) {
462 tgcred = kmalloc(sizeof(*tgcred), GFP_KERNEL);
463 if (!tgcred) {
464 ret = -ENOMEM;
465 goto error_put;
467 atomic_set(&tgcred->usage, 1);
468 spin_lock_init(&tgcred->lock);
469 tgcred->process_keyring = NULL;
470 tgcred->session_keyring = key_get(new->tgcred->session_keyring);
472 release_tgcred(new);
473 new->tgcred = tgcred;
475 #endif
477 atomic_inc(&new->user->processes);
478 p->cred = p->real_cred = get_cred(new);
479 alter_cred_subscribers(new, 2);
480 validate_creds(new);
481 return 0;
483 error_put:
484 put_cred(new);
485 return ret;
489 * commit_creds - Install new credentials upon the current task
490 * @new: The credentials to be assigned
492 * Install a new set of credentials to the current task, using RCU to replace
493 * the old set. Both the objective and the subjective credentials pointers are
494 * updated. This function may not be called if the subjective credentials are
495 * in an overridden state.
497 * This function eats the caller's reference to the new credentials.
499 * Always returns 0 thus allowing this function to be tail-called at the end
500 * of, say, sys_setgid().
502 int commit_creds(struct cred *new)
504 struct task_struct *task = current;
505 const struct cred *old = task->real_cred;
507 kdebug("commit_creds(%p{%d,%d})", new,
508 atomic_read(&new->usage),
509 read_cred_subscribers(new));
511 BUG_ON(task->cred != old);
512 #ifdef CONFIG_DEBUG_CREDENTIALS
513 BUG_ON(read_cred_subscribers(old) < 2);
514 validate_creds(old);
515 validate_creds(new);
516 #endif
517 BUG_ON(atomic_read(&new->usage) < 1);
519 security_commit_creds(new, old);
521 get_cred(new); /* we will require a ref for the subj creds too */
523 /* dumpability changes */
524 if (old->euid != new->euid ||
525 old->egid != new->egid ||
526 old->fsuid != new->fsuid ||
527 old->fsgid != new->fsgid ||
528 !cap_issubset(new->cap_permitted, old->cap_permitted)) {
529 if (task->mm)
530 set_dumpable(task->mm, suid_dumpable);
531 task->pdeath_signal = 0;
532 smp_wmb();
535 /* alter the thread keyring */
536 if (new->fsuid != old->fsuid)
537 key_fsuid_changed(task);
538 if (new->fsgid != old->fsgid)
539 key_fsgid_changed(task);
541 /* do it
542 * - What if a process setreuid()'s and this brings the
543 * new uid over his NPROC rlimit? We can check this now
544 * cheaply with the new uid cache, so if it matters
545 * we should be checking for it. -DaveM
547 alter_cred_subscribers(new, 2);
548 if (new->user != old->user)
549 atomic_inc(&new->user->processes);
550 rcu_assign_pointer(task->real_cred, new);
551 rcu_assign_pointer(task->cred, new);
552 if (new->user != old->user)
553 atomic_dec(&old->user->processes);
554 alter_cred_subscribers(old, -2);
556 sched_switch_user(task);
558 /* send notifications */
559 if (new->uid != old->uid ||
560 new->euid != old->euid ||
561 new->suid != old->suid ||
562 new->fsuid != old->fsuid)
563 proc_id_connector(task, PROC_EVENT_UID);
565 if (new->gid != old->gid ||
566 new->egid != old->egid ||
567 new->sgid != old->sgid ||
568 new->fsgid != old->fsgid)
569 proc_id_connector(task, PROC_EVENT_GID);
571 /* release the old obj and subj refs both */
572 put_cred(old);
573 put_cred(old);
574 return 0;
576 EXPORT_SYMBOL(commit_creds);
579 * abort_creds - Discard a set of credentials and unlock the current task
580 * @new: The credentials that were going to be applied
582 * Discard a set of credentials that were under construction and unlock the
583 * current task.
585 void abort_creds(struct cred *new)
587 kdebug("abort_creds(%p{%d,%d})", new,
588 atomic_read(&new->usage),
589 read_cred_subscribers(new));
591 #ifdef CONFIG_DEBUG_CREDENTIALS
592 BUG_ON(read_cred_subscribers(new) != 0);
593 #endif
594 BUG_ON(atomic_read(&new->usage) < 1);
595 put_cred(new);
597 EXPORT_SYMBOL(abort_creds);
600 * override_creds - Override the current process's subjective credentials
601 * @new: The credentials to be assigned
603 * Install a set of temporary override subjective credentials on the current
604 * process, returning the old set for later reversion.
606 const struct cred *override_creds(const struct cred *new)
608 const struct cred *old = current->cred;
610 kdebug("override_creds(%p{%d,%d})", new,
611 atomic_read(&new->usage),
612 read_cred_subscribers(new));
614 validate_creds(old);
615 validate_creds(new);
616 get_cred(new);
617 alter_cred_subscribers(new, 1);
618 rcu_assign_pointer(current->cred, new);
619 alter_cred_subscribers(old, -1);
621 kdebug("override_creds() = %p{%d,%d}", old,
622 atomic_read(&old->usage),
623 read_cred_subscribers(old));
624 return old;
626 EXPORT_SYMBOL(override_creds);
629 * revert_creds - Revert a temporary subjective credentials override
630 * @old: The credentials to be restored
632 * Revert a temporary set of override subjective credentials to an old set,
633 * discarding the override set.
635 void revert_creds(const struct cred *old)
637 const struct cred *override = current->cred;
639 kdebug("revert_creds(%p{%d,%d})", old,
640 atomic_read(&old->usage),
641 read_cred_subscribers(old));
643 validate_creds(old);
644 validate_creds(override);
645 alter_cred_subscribers(old, 1);
646 rcu_assign_pointer(current->cred, old);
647 alter_cred_subscribers(override, -1);
648 put_cred(override);
650 EXPORT_SYMBOL(revert_creds);
653 * initialise the credentials stuff
655 void __init cred_init(void)
657 /* allocate a slab in which we can store credentials */
658 cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred),
659 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
663 * prepare_kernel_cred - Prepare a set of credentials for a kernel service
664 * @daemon: A userspace daemon to be used as a reference
666 * Prepare a set of credentials for a kernel service. This can then be used to
667 * override a task's own credentials so that work can be done on behalf of that
668 * task that requires a different subjective context.
670 * @daemon is used to provide a base for the security record, but can be NULL.
671 * If @daemon is supplied, then the security data will be derived from that;
672 * otherwise they'll be set to 0 and no groups, full capabilities and no keys.
674 * The caller may change these controls afterwards if desired.
676 * Returns the new credentials or NULL if out of memory.
678 * Does not take, and does not return holding current->cred_replace_mutex.
680 struct cred *prepare_kernel_cred(struct task_struct *daemon)
682 const struct cred *old;
683 struct cred *new;
685 new = kmem_cache_alloc(cred_jar, GFP_KERNEL);
686 if (!new)
687 return NULL;
689 kdebug("prepare_kernel_cred() alloc %p", new);
691 if (daemon)
692 old = get_task_cred(daemon);
693 else
694 old = get_cred(&init_cred);
696 validate_creds(old);
698 *new = *old;
699 get_uid(new->user);
700 get_group_info(new->group_info);
702 #ifdef CONFIG_KEYS
703 atomic_inc(&init_tgcred.usage);
704 new->tgcred = &init_tgcred;
705 new->request_key_auth = NULL;
706 new->thread_keyring = NULL;
707 new->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING;
708 #endif
710 #ifdef CONFIG_SECURITY
711 new->security = NULL;
712 #endif
713 if (security_prepare_creds(new, old, GFP_KERNEL) < 0)
714 goto error;
716 atomic_set(&new->usage, 1);
717 set_cred_subscribers(new, 0);
718 put_cred(old);
719 validate_creds(new);
720 return new;
722 error:
723 put_cred(new);
724 put_cred(old);
725 return NULL;
727 EXPORT_SYMBOL(prepare_kernel_cred);
730 * set_security_override - Set the security ID in a set of credentials
731 * @new: The credentials to alter
732 * @secid: The LSM security ID to set
734 * Set the LSM security ID in a set of credentials so that the subjective
735 * security is overridden when an alternative set of credentials is used.
737 int set_security_override(struct cred *new, u32 secid)
739 return security_kernel_act_as(new, secid);
741 EXPORT_SYMBOL(set_security_override);
744 * set_security_override_from_ctx - Set the security ID in a set of credentials
745 * @new: The credentials to alter
746 * @secctx: The LSM security context to generate the security ID from.
748 * Set the LSM security ID in a set of credentials so that the subjective
749 * security is overridden when an alternative set of credentials is used. The
750 * security ID is specified in string form as a security context to be
751 * interpreted by the LSM.
753 int set_security_override_from_ctx(struct cred *new, const char *secctx)
755 u32 secid;
756 int ret;
758 ret = security_secctx_to_secid(secctx, strlen(secctx), &secid);
759 if (ret < 0)
760 return ret;
762 return set_security_override(new, secid);
764 EXPORT_SYMBOL(set_security_override_from_ctx);
767 * set_create_files_as - Set the LSM file create context in a set of credentials
768 * @new: The credentials to alter
769 * @inode: The inode to take the context from
771 * Change the LSM file creation context in a set of credentials to be the same
772 * as the object context of the specified inode, so that the new inodes have
773 * the same MAC context as that inode.
775 int set_create_files_as(struct cred *new, struct inode *inode)
777 new->fsuid = inode->i_uid;
778 new->fsgid = inode->i_gid;
779 return security_kernel_create_files_as(new, inode);
781 EXPORT_SYMBOL(set_create_files_as);
783 #ifdef CONFIG_DEBUG_CREDENTIALS
785 bool creds_are_invalid(const struct cred *cred)
787 if (cred->magic != CRED_MAGIC)
788 return true;
789 if (atomic_read(&cred->usage) < atomic_read(&cred->subscribers))
790 return true;
791 #ifdef CONFIG_SECURITY_SELINUX
792 if (selinux_is_enabled()) {
793 if ((unsigned long) cred->security < PAGE_SIZE)
794 return true;
795 if ((*(u32 *)cred->security & 0xffffff00) ==
796 (POISON_FREE << 24 | POISON_FREE << 16 | POISON_FREE << 8))
797 return true;
799 #endif
800 return false;
802 EXPORT_SYMBOL(creds_are_invalid);
805 * dump invalid credentials
807 static void dump_invalid_creds(const struct cred *cred, const char *label,
808 const struct task_struct *tsk)
810 printk(KERN_ERR "CRED: %s credentials: %p %s%s%s\n",
811 label, cred,
812 cred == &init_cred ? "[init]" : "",
813 cred == tsk->real_cred ? "[real]" : "",
814 cred == tsk->cred ? "[eff]" : "");
815 printk(KERN_ERR "CRED: ->magic=%x, put_addr=%p\n",
816 cred->magic, cred->put_addr);
817 printk(KERN_ERR "CRED: ->usage=%d, subscr=%d\n",
818 atomic_read(&cred->usage),
819 read_cred_subscribers(cred));
820 printk(KERN_ERR "CRED: ->*uid = { %d,%d,%d,%d }\n",
821 cred->uid, cred->euid, cred->suid, cred->fsuid);
822 printk(KERN_ERR "CRED: ->*gid = { %d,%d,%d,%d }\n",
823 cred->gid, cred->egid, cred->sgid, cred->fsgid);
824 #ifdef CONFIG_SECURITY
825 printk(KERN_ERR "CRED: ->security is %p\n", cred->security);
826 if ((unsigned long) cred->security >= PAGE_SIZE &&
827 (((unsigned long) cred->security & 0xffffff00) !=
828 (POISON_FREE << 24 | POISON_FREE << 16 | POISON_FREE << 8)))
829 printk(KERN_ERR "CRED: ->security {%x, %x}\n",
830 ((u32*)cred->security)[0],
831 ((u32*)cred->security)[1]);
832 #endif
836 * report use of invalid credentials
838 void __invalid_creds(const struct cred *cred, const char *file, unsigned line)
840 printk(KERN_ERR "CRED: Invalid credentials\n");
841 printk(KERN_ERR "CRED: At %s:%u\n", file, line);
842 dump_invalid_creds(cred, "Specified", current);
843 BUG();
845 EXPORT_SYMBOL(__invalid_creds);
848 * check the credentials on a process
850 void __validate_process_creds(struct task_struct *tsk,
851 const char *file, unsigned line)
853 if (tsk->cred == tsk->real_cred) {
854 if (unlikely(read_cred_subscribers(tsk->cred) < 2 ||
855 creds_are_invalid(tsk->cred)))
856 goto invalid_creds;
857 } else {
858 if (unlikely(read_cred_subscribers(tsk->real_cred) < 1 ||
859 read_cred_subscribers(tsk->cred) < 1 ||
860 creds_are_invalid(tsk->real_cred) ||
861 creds_are_invalid(tsk->cred)))
862 goto invalid_creds;
864 return;
866 invalid_creds:
867 printk(KERN_ERR "CRED: Invalid process credentials\n");
868 printk(KERN_ERR "CRED: At %s:%u\n", file, line);
870 dump_invalid_creds(tsk->real_cred, "Real", tsk);
871 if (tsk->cred != tsk->real_cred)
872 dump_invalid_creds(tsk->cred, "Effective", tsk);
873 else
874 printk(KERN_ERR "CRED: Effective creds == Real creds\n");
875 BUG();
877 EXPORT_SYMBOL(__validate_process_creds);
880 * check creds for do_exit()
882 void validate_creds_for_do_exit(struct task_struct *tsk)
884 kdebug("validate_creds_for_do_exit(%p,%p{%d,%d})",
885 tsk->real_cred, tsk->cred,
886 atomic_read(&tsk->cred->usage),
887 read_cred_subscribers(tsk->cred));
889 __validate_process_creds(tsk, __FILE__, __LINE__);
892 #endif /* CONFIG_DEBUG_CREDENTIALS */