1 /* Task credentials management - see Documentation/security/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/export.h>
12 #include <linux/cred.h>
13 #include <linux/slab.h>
14 #include <linux/sched.h>
15 #include <linux/key.h>
16 #include <linux/keyctl.h>
17 #include <linux/init_task.h>
18 #include <linux/security.h>
19 #include <linux/binfmts.h>
20 #include <linux/cn_proc.h>
23 #define kdebug(FMT, ...) \
24 printk("[%-5.5s%5u] "FMT"\n", current->comm, current->pid ,##__VA_ARGS__)
26 #define kdebug(FMT, ...) \
27 no_printk("[%-5.5s%5u] "FMT"\n", current->comm, current->pid ,##__VA_ARGS__)
30 static struct kmem_cache
*cred_jar
;
33 * The common credentials for the initial task's thread group
36 static struct thread_group_cred init_tgcred
= {
37 .usage
= ATOMIC_INIT(2),
39 .lock
= __SPIN_LOCK_UNLOCKED(init_cred
.tgcred
.lock
),
44 * The initial credentials for the initial task
46 struct cred init_cred
= {
47 .usage
= ATOMIC_INIT(4),
48 #ifdef CONFIG_DEBUG_CREDENTIALS
49 .subscribers
= ATOMIC_INIT(2),
52 .securebits
= SECUREBITS_DEFAULT
,
53 .cap_inheritable
= CAP_EMPTY_SET
,
54 .cap_permitted
= CAP_FULL_SET
,
55 .cap_effective
= CAP_FULL_SET
,
56 .cap_bset
= CAP_FULL_SET
,
58 .user_ns
= &init_user_ns
,
59 .group_info
= &init_groups
,
61 .tgcred
= &init_tgcred
,
65 static inline void set_cred_subscribers(struct cred
*cred
, int n
)
67 #ifdef CONFIG_DEBUG_CREDENTIALS
68 atomic_set(&cred
->subscribers
, n
);
72 static inline int read_cred_subscribers(const struct cred
*cred
)
74 #ifdef CONFIG_DEBUG_CREDENTIALS
75 return atomic_read(&cred
->subscribers
);
81 static inline void alter_cred_subscribers(const struct cred
*_cred
, int n
)
83 #ifdef CONFIG_DEBUG_CREDENTIALS
84 struct cred
*cred
= (struct cred
*) _cred
;
86 atomic_add(n
, &cred
->subscribers
);
91 * Dispose of the shared task group credentials
94 static void release_tgcred_rcu(struct rcu_head
*rcu
)
96 struct thread_group_cred
*tgcred
=
97 container_of(rcu
, struct thread_group_cred
, rcu
);
99 BUG_ON(atomic_read(&tgcred
->usage
) != 0);
101 key_put(tgcred
->session_keyring
);
102 key_put(tgcred
->process_keyring
);
108 * Release a set of thread group credentials.
110 static void release_tgcred(struct cred
*cred
)
113 struct thread_group_cred
*tgcred
= cred
->tgcred
;
115 if (atomic_dec_and_test(&tgcred
->usage
))
116 call_rcu(&tgcred
->rcu
, release_tgcred_rcu
);
121 * The RCU callback to actually dispose of a set of credentials
123 static void put_cred_rcu(struct rcu_head
*rcu
)
125 struct cred
*cred
= container_of(rcu
, struct cred
, rcu
);
127 kdebug("put_cred_rcu(%p)", cred
);
129 #ifdef CONFIG_DEBUG_CREDENTIALS
130 if (cred
->magic
!= CRED_MAGIC_DEAD
||
131 atomic_read(&cred
->usage
) != 0 ||
132 read_cred_subscribers(cred
) != 0)
133 panic("CRED: put_cred_rcu() sees %p with"
134 " mag %x, put %p, usage %d, subscr %d\n",
135 cred
, cred
->magic
, cred
->put_addr
,
136 atomic_read(&cred
->usage
),
137 read_cred_subscribers(cred
));
139 if (atomic_read(&cred
->usage
) != 0)
140 panic("CRED: put_cred_rcu() sees %p with usage %d\n",
141 cred
, atomic_read(&cred
->usage
));
144 security_cred_free(cred
);
145 key_put(cred
->thread_keyring
);
146 key_put(cred
->request_key_auth
);
147 release_tgcred(cred
);
148 if (cred
->group_info
)
149 put_group_info(cred
->group_info
);
150 free_uid(cred
->user
);
151 kmem_cache_free(cred_jar
, cred
);
155 * __put_cred - Destroy a set of credentials
156 * @cred: The record to release
158 * Destroy a set of credentials on which no references remain.
160 void __put_cred(struct cred
*cred
)
162 kdebug("__put_cred(%p{%d,%d})", cred
,
163 atomic_read(&cred
->usage
),
164 read_cred_subscribers(cred
));
166 BUG_ON(atomic_read(&cred
->usage
) != 0);
167 #ifdef CONFIG_DEBUG_CREDENTIALS
168 BUG_ON(read_cred_subscribers(cred
) != 0);
169 cred
->magic
= CRED_MAGIC_DEAD
;
170 cred
->put_addr
= __builtin_return_address(0);
172 BUG_ON(cred
== current
->cred
);
173 BUG_ON(cred
== current
->real_cred
);
175 call_rcu(&cred
->rcu
, put_cred_rcu
);
177 EXPORT_SYMBOL(__put_cred
);
180 * Clean up a task's credentials when it exits
182 void exit_creds(struct task_struct
*tsk
)
186 kdebug("exit_creds(%u,%p,%p,{%d,%d})", tsk
->pid
, tsk
->real_cred
, tsk
->cred
,
187 atomic_read(&tsk
->cred
->usage
),
188 read_cred_subscribers(tsk
->cred
));
190 cred
= (struct cred
*) tsk
->real_cred
;
191 tsk
->real_cred
= NULL
;
192 validate_creds(cred
);
193 alter_cred_subscribers(cred
, -1);
196 cred
= (struct cred
*) tsk
->cred
;
198 validate_creds(cred
);
199 alter_cred_subscribers(cred
, -1);
202 cred
= (struct cred
*) tsk
->replacement_session_keyring
;
204 tsk
->replacement_session_keyring
= NULL
;
205 validate_creds(cred
);
211 * get_task_cred - Get another task's objective credentials
212 * @task: The task to query
214 * Get the objective credentials of a task, pinning them so that they can't go
215 * away. Accessing a task's credentials directly is not permitted.
217 * The caller must also make sure task doesn't get deleted, either by holding a
218 * ref on task or by holding tasklist_lock to prevent it from being unlinked.
220 const struct cred
*get_task_cred(struct task_struct
*task
)
222 const struct cred
*cred
;
227 cred
= __task_cred((task
));
229 } while (!atomic_inc_not_zero(&((struct cred
*)cred
)->usage
));
236 * Allocate blank credentials, such that the credentials can be filled in at a
237 * later date without risk of ENOMEM.
239 struct cred
*cred_alloc_blank(void)
243 new = kmem_cache_zalloc(cred_jar
, GFP_KERNEL
);
248 new->tgcred
= kzalloc(sizeof(*new->tgcred
), GFP_KERNEL
);
250 kmem_cache_free(cred_jar
, new);
253 atomic_set(&new->tgcred
->usage
, 1);
256 atomic_set(&new->usage
, 1);
257 #ifdef CONFIG_DEBUG_CREDENTIALS
258 new->magic
= CRED_MAGIC
;
261 if (security_cred_alloc_blank(new, GFP_KERNEL
) < 0)
272 * prepare_creds - Prepare a new set of credentials for modification
274 * Prepare a new set of task credentials for modification. A task's creds
275 * shouldn't generally be modified directly, therefore this function is used to
276 * prepare a new copy, which the caller then modifies and then commits by
277 * calling commit_creds().
279 * Preparation involves making a copy of the objective creds for modification.
281 * Returns a pointer to the new creds-to-be if successful, NULL otherwise.
283 * Call commit_creds() or abort_creds() to clean up.
285 struct cred
*prepare_creds(void)
287 struct task_struct
*task
= current
;
288 const struct cred
*old
;
291 validate_process_creds();
293 new = kmem_cache_alloc(cred_jar
, GFP_KERNEL
);
297 kdebug("prepare_creds() alloc %p", new);
300 memcpy(new, old
, sizeof(struct cred
));
302 atomic_set(&new->usage
, 1);
303 set_cred_subscribers(new, 0);
304 get_group_info(new->group_info
);
308 key_get(new->thread_keyring
);
309 key_get(new->request_key_auth
);
310 atomic_inc(&new->tgcred
->usage
);
313 #ifdef CONFIG_SECURITY
314 new->security
= NULL
;
317 if (security_prepare_creds(new, old
, GFP_KERNEL
) < 0)
326 EXPORT_SYMBOL(prepare_creds
);
329 * Prepare credentials for current to perform an execve()
330 * - The caller must hold ->cred_guard_mutex
332 struct cred
*prepare_exec_creds(void)
334 struct thread_group_cred
*tgcred
= NULL
;
338 tgcred
= kmalloc(sizeof(*tgcred
), GFP_KERNEL
);
343 new = prepare_creds();
350 /* newly exec'd tasks don't get a thread keyring */
351 key_put(new->thread_keyring
);
352 new->thread_keyring
= NULL
;
354 /* create a new per-thread-group creds for all this set of threads to
356 memcpy(tgcred
, new->tgcred
, sizeof(struct thread_group_cred
));
358 atomic_set(&tgcred
->usage
, 1);
359 spin_lock_init(&tgcred
->lock
);
361 /* inherit the session keyring; new process keyring */
362 key_get(tgcred
->session_keyring
);
363 tgcred
->process_keyring
= NULL
;
366 new->tgcred
= tgcred
;
373 * Copy credentials for the new process created by fork()
375 * We share if we can, but under some circumstances we have to generate a new
378 * The new process gets the current process's subjective credentials as its
379 * objective and subjective credentials
381 int copy_creds(struct task_struct
*p
, unsigned long clone_flags
)
384 struct thread_group_cred
*tgcred
;
389 p
->replacement_session_keyring
= NULL
;
393 !p
->cred
->thread_keyring
&&
395 clone_flags
& CLONE_THREAD
397 p
->real_cred
= get_cred(p
->cred
);
399 alter_cred_subscribers(p
->cred
, 2);
400 kdebug("share_creds(%p{%d,%d})",
401 p
->cred
, atomic_read(&p
->cred
->usage
),
402 read_cred_subscribers(p
->cred
));
403 atomic_inc(&p
->cred
->user
->processes
);
407 new = prepare_creds();
411 if (clone_flags
& CLONE_NEWUSER
) {
412 ret
= create_user_ns(new);
417 /* cache user_ns in cred. Doesn't need a refcount because it will
418 * stay pinned by cred->user
420 new->user_ns
= new->user
->user_ns
;
423 /* new threads get their own thread keyrings if their parent already
425 if (new->thread_keyring
) {
426 key_put(new->thread_keyring
);
427 new->thread_keyring
= NULL
;
428 if (clone_flags
& CLONE_THREAD
)
429 install_thread_keyring_to_cred(new);
432 /* we share the process and session keyrings between all the threads in
433 * a process - this is slightly icky as we violate COW credentials a
435 if (!(clone_flags
& CLONE_THREAD
)) {
436 tgcred
= kmalloc(sizeof(*tgcred
), GFP_KERNEL
);
441 atomic_set(&tgcred
->usage
, 1);
442 spin_lock_init(&tgcred
->lock
);
443 tgcred
->process_keyring
= NULL
;
444 tgcred
->session_keyring
= key_get(new->tgcred
->session_keyring
);
447 new->tgcred
= tgcred
;
451 atomic_inc(&new->user
->processes
);
452 p
->cred
= p
->real_cred
= get_cred(new);
453 alter_cred_subscribers(new, 2);
463 * commit_creds - Install new credentials upon the current task
464 * @new: The credentials to be assigned
466 * Install a new set of credentials to the current task, using RCU to replace
467 * the old set. Both the objective and the subjective credentials pointers are
468 * updated. This function may not be called if the subjective credentials are
469 * in an overridden state.
471 * This function eats the caller's reference to the new credentials.
473 * Always returns 0 thus allowing this function to be tail-called at the end
474 * of, say, sys_setgid().
476 int commit_creds(struct cred
*new)
478 struct task_struct
*task
= current
;
479 const struct cred
*old
= task
->real_cred
;
481 kdebug("commit_creds(%p{%d,%d})", new,
482 atomic_read(&new->usage
),
483 read_cred_subscribers(new));
485 BUG_ON(task
->cred
!= old
);
486 #ifdef CONFIG_DEBUG_CREDENTIALS
487 BUG_ON(read_cred_subscribers(old
) < 2);
491 BUG_ON(atomic_read(&new->usage
) < 1);
493 get_cred(new); /* we will require a ref for the subj creds too */
495 /* dumpability changes */
496 if (old
->euid
!= new->euid
||
497 old
->egid
!= new->egid
||
498 old
->fsuid
!= new->fsuid
||
499 old
->fsgid
!= new->fsgid
||
500 !cap_issubset(new->cap_permitted
, old
->cap_permitted
)) {
502 set_dumpable(task
->mm
, suid_dumpable
);
503 task
->pdeath_signal
= 0;
507 /* alter the thread keyring */
508 if (new->fsuid
!= old
->fsuid
)
509 key_fsuid_changed(task
);
510 if (new->fsgid
!= old
->fsgid
)
511 key_fsgid_changed(task
);
514 * RLIMIT_NPROC limits on user->processes have already been checked
517 alter_cred_subscribers(new, 2);
518 if (new->user
!= old
->user
)
519 atomic_inc(&new->user
->processes
);
520 rcu_assign_pointer(task
->real_cred
, new);
521 rcu_assign_pointer(task
->cred
, new);
522 if (new->user
!= old
->user
)
523 atomic_dec(&old
->user
->processes
);
524 alter_cred_subscribers(old
, -2);
526 /* send notifications */
527 if (new->uid
!= old
->uid
||
528 new->euid
!= old
->euid
||
529 new->suid
!= old
->suid
||
530 new->fsuid
!= old
->fsuid
)
531 proc_id_connector(task
, PROC_EVENT_UID
);
533 if (new->gid
!= old
->gid
||
534 new->egid
!= old
->egid
||
535 new->sgid
!= old
->sgid
||
536 new->fsgid
!= old
->fsgid
)
537 proc_id_connector(task
, PROC_EVENT_GID
);
539 /* release the old obj and subj refs both */
544 EXPORT_SYMBOL(commit_creds
);
547 * abort_creds - Discard a set of credentials and unlock the current task
548 * @new: The credentials that were going to be applied
550 * Discard a set of credentials that were under construction and unlock the
553 void abort_creds(struct cred
*new)
555 kdebug("abort_creds(%p{%d,%d})", new,
556 atomic_read(&new->usage
),
557 read_cred_subscribers(new));
559 #ifdef CONFIG_DEBUG_CREDENTIALS
560 BUG_ON(read_cred_subscribers(new) != 0);
562 BUG_ON(atomic_read(&new->usage
) < 1);
565 EXPORT_SYMBOL(abort_creds
);
568 * override_creds - Override the current process's subjective credentials
569 * @new: The credentials to be assigned
571 * Install a set of temporary override subjective credentials on the current
572 * process, returning the old set for later reversion.
574 const struct cred
*override_creds(const struct cred
*new)
576 const struct cred
*old
= current
->cred
;
578 kdebug("override_creds(%p{%d,%d})", new,
579 atomic_read(&new->usage
),
580 read_cred_subscribers(new));
585 alter_cred_subscribers(new, 1);
586 rcu_assign_pointer(current
->cred
, new);
587 alter_cred_subscribers(old
, -1);
589 kdebug("override_creds() = %p{%d,%d}", old
,
590 atomic_read(&old
->usage
),
591 read_cred_subscribers(old
));
594 EXPORT_SYMBOL(override_creds
);
597 * revert_creds - Revert a temporary subjective credentials override
598 * @old: The credentials to be restored
600 * Revert a temporary set of override subjective credentials to an old set,
601 * discarding the override set.
603 void revert_creds(const struct cred
*old
)
605 const struct cred
*override
= current
->cred
;
607 kdebug("revert_creds(%p{%d,%d})", old
,
608 atomic_read(&old
->usage
),
609 read_cred_subscribers(old
));
612 validate_creds(override
);
613 alter_cred_subscribers(old
, 1);
614 rcu_assign_pointer(current
->cred
, old
);
615 alter_cred_subscribers(override
, -1);
618 EXPORT_SYMBOL(revert_creds
);
621 * initialise the credentials stuff
623 void __init
cred_init(void)
625 /* allocate a slab in which we can store credentials */
626 cred_jar
= kmem_cache_create("cred_jar", sizeof(struct cred
),
627 0, SLAB_HWCACHE_ALIGN
|SLAB_PANIC
, NULL
);
631 * prepare_kernel_cred - Prepare a set of credentials for a kernel service
632 * @daemon: A userspace daemon to be used as a reference
634 * Prepare a set of credentials for a kernel service. This can then be used to
635 * override a task's own credentials so that work can be done on behalf of that
636 * task that requires a different subjective context.
638 * @daemon is used to provide a base for the security record, but can be NULL.
639 * If @daemon is supplied, then the security data will be derived from that;
640 * otherwise they'll be set to 0 and no groups, full capabilities and no keys.
642 * The caller may change these controls afterwards if desired.
644 * Returns the new credentials or NULL if out of memory.
646 * Does not take, and does not return holding current->cred_replace_mutex.
648 struct cred
*prepare_kernel_cred(struct task_struct
*daemon
)
651 struct thread_group_cred
*tgcred
;
653 const struct cred
*old
;
656 new = kmem_cache_alloc(cred_jar
, GFP_KERNEL
);
661 tgcred
= kmalloc(sizeof(*tgcred
), GFP_KERNEL
);
663 kmem_cache_free(cred_jar
, new);
668 kdebug("prepare_kernel_cred() alloc %p", new);
671 old
= get_task_cred(daemon
);
673 old
= get_cred(&init_cred
);
678 atomic_set(&new->usage
, 1);
679 set_cred_subscribers(new, 0);
681 get_group_info(new->group_info
);
684 atomic_set(&tgcred
->usage
, 1);
685 spin_lock_init(&tgcred
->lock
);
686 tgcred
->process_keyring
= NULL
;
687 tgcred
->session_keyring
= NULL
;
688 new->tgcred
= tgcred
;
689 new->request_key_auth
= NULL
;
690 new->thread_keyring
= NULL
;
691 new->jit_keyring
= KEY_REQKEY_DEFL_THREAD_KEYRING
;
694 #ifdef CONFIG_SECURITY
695 new->security
= NULL
;
697 if (security_prepare_creds(new, old
, GFP_KERNEL
) < 0)
709 EXPORT_SYMBOL(prepare_kernel_cred
);
712 * set_security_override - Set the security ID in a set of credentials
713 * @new: The credentials to alter
714 * @secid: The LSM security ID to set
716 * Set the LSM security ID in a set of credentials so that the subjective
717 * security is overridden when an alternative set of credentials is used.
719 int set_security_override(struct cred
*new, u32 secid
)
721 return security_kernel_act_as(new, secid
);
723 EXPORT_SYMBOL(set_security_override
);
726 * set_security_override_from_ctx - Set the security ID in a set of credentials
727 * @new: The credentials to alter
728 * @secctx: The LSM security context to generate the security ID from.
730 * Set the LSM security ID in a set of credentials so that the subjective
731 * security is overridden when an alternative set of credentials is used. The
732 * security ID is specified in string form as a security context to be
733 * interpreted by the LSM.
735 int set_security_override_from_ctx(struct cred
*new, const char *secctx
)
740 ret
= security_secctx_to_secid(secctx
, strlen(secctx
), &secid
);
744 return set_security_override(new, secid
);
746 EXPORT_SYMBOL(set_security_override_from_ctx
);
749 * set_create_files_as - Set the LSM file create context in a set of credentials
750 * @new: The credentials to alter
751 * @inode: The inode to take the context from
753 * Change the LSM file creation context in a set of credentials to be the same
754 * as the object context of the specified inode, so that the new inodes have
755 * the same MAC context as that inode.
757 int set_create_files_as(struct cred
*new, struct inode
*inode
)
759 new->fsuid
= inode
->i_uid
;
760 new->fsgid
= inode
->i_gid
;
761 return security_kernel_create_files_as(new, inode
);
763 EXPORT_SYMBOL(set_create_files_as
);
765 #ifdef CONFIG_DEBUG_CREDENTIALS
767 bool creds_are_invalid(const struct cred
*cred
)
769 if (cred
->magic
!= CRED_MAGIC
)
771 #ifdef CONFIG_SECURITY_SELINUX
773 * cred->security == NULL if security_cred_alloc_blank() or
774 * security_prepare_creds() returned an error.
776 if (selinux_is_enabled() && cred
->security
) {
777 if ((unsigned long) cred
->security
< PAGE_SIZE
)
779 if ((*(u32
*)cred
->security
& 0xffffff00) ==
780 (POISON_FREE
<< 24 | POISON_FREE
<< 16 | POISON_FREE
<< 8))
786 EXPORT_SYMBOL(creds_are_invalid
);
789 * dump invalid credentials
791 static void dump_invalid_creds(const struct cred
*cred
, const char *label
,
792 const struct task_struct
*tsk
)
794 printk(KERN_ERR
"CRED: %s credentials: %p %s%s%s\n",
796 cred
== &init_cred
? "[init]" : "",
797 cred
== tsk
->real_cred
? "[real]" : "",
798 cred
== tsk
->cred
? "[eff]" : "");
799 printk(KERN_ERR
"CRED: ->magic=%x, put_addr=%p\n",
800 cred
->magic
, cred
->put_addr
);
801 printk(KERN_ERR
"CRED: ->usage=%d, subscr=%d\n",
802 atomic_read(&cred
->usage
),
803 read_cred_subscribers(cred
));
804 printk(KERN_ERR
"CRED: ->*uid = { %d,%d,%d,%d }\n",
805 cred
->uid
, cred
->euid
, cred
->suid
, cred
->fsuid
);
806 printk(KERN_ERR
"CRED: ->*gid = { %d,%d,%d,%d }\n",
807 cred
->gid
, cred
->egid
, cred
->sgid
, cred
->fsgid
);
808 #ifdef CONFIG_SECURITY
809 printk(KERN_ERR
"CRED: ->security is %p\n", cred
->security
);
810 if ((unsigned long) cred
->security
>= PAGE_SIZE
&&
811 (((unsigned long) cred
->security
& 0xffffff00) !=
812 (POISON_FREE
<< 24 | POISON_FREE
<< 16 | POISON_FREE
<< 8)))
813 printk(KERN_ERR
"CRED: ->security {%x, %x}\n",
814 ((u32
*)cred
->security
)[0],
815 ((u32
*)cred
->security
)[1]);
820 * report use of invalid credentials
822 void __invalid_creds(const struct cred
*cred
, const char *file
, unsigned line
)
824 printk(KERN_ERR
"CRED: Invalid credentials\n");
825 printk(KERN_ERR
"CRED: At %s:%u\n", file
, line
);
826 dump_invalid_creds(cred
, "Specified", current
);
829 EXPORT_SYMBOL(__invalid_creds
);
832 * check the credentials on a process
834 void __validate_process_creds(struct task_struct
*tsk
,
835 const char *file
, unsigned line
)
837 if (tsk
->cred
== tsk
->real_cred
) {
838 if (unlikely(read_cred_subscribers(tsk
->cred
) < 2 ||
839 creds_are_invalid(tsk
->cred
)))
842 if (unlikely(read_cred_subscribers(tsk
->real_cred
) < 1 ||
843 read_cred_subscribers(tsk
->cred
) < 1 ||
844 creds_are_invalid(tsk
->real_cred
) ||
845 creds_are_invalid(tsk
->cred
)))
851 printk(KERN_ERR
"CRED: Invalid process credentials\n");
852 printk(KERN_ERR
"CRED: At %s:%u\n", file
, line
);
854 dump_invalid_creds(tsk
->real_cred
, "Real", tsk
);
855 if (tsk
->cred
!= tsk
->real_cred
)
856 dump_invalid_creds(tsk
->cred
, "Effective", tsk
);
858 printk(KERN_ERR
"CRED: Effective creds == Real creds\n");
861 EXPORT_SYMBOL(__validate_process_creds
);
864 * check creds for do_exit()
866 void validate_creds_for_do_exit(struct task_struct
*tsk
)
868 kdebug("validate_creds_for_do_exit(%p,%p{%d,%d})",
869 tsk
->real_cred
, tsk
->cred
,
870 atomic_read(&tsk
->cred
->usage
),
871 read_cred_subscribers(tsk
->cred
));
873 __validate_process_creds(tsk
, __FILE__
, __LINE__
);
876 #endif /* CONFIG_DEBUG_CREDENTIALS */