2 * AppArmor security module
4 * This file contains AppArmor policy manipulation functions
6 * Copyright (C) 1998-2008 Novell/SUSE
7 * Copyright 2009-2010 Canonical Ltd.
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License as
11 * published by the Free Software Foundation, version 2 of the
15 * AppArmor policy is based around profiles, which contain the rules a
16 * task is confined by. Every task in the system has a profile attached
17 * to it determined either by matching "unconfined" tasks against the
18 * visible set of profiles or by following a profiles attachment rules.
20 * Each profile exists in a profile namespace which is a container of
21 * visible profiles. Each namespace contains a special "unconfined" profile,
22 * which doesn't enforce any confinement on a task beyond DAC.
24 * Namespace and profile names can be written together in either
26 * :namespace:profile - used by kernel interfaces for easy detection
27 * namespace://profile - used by policy
29 * Profile names can not start with : or @ or ^ and may not contain \0
31 * Reserved profile names
32 * unconfined - special automatically generated unconfined profile
33 * inherit - special name to indicate profile inheritance
34 * null-XXXX-YYYY - special automatically generated learning profiles
36 * Namespace names may not start with / or @ and may not contain \0 or :
37 * Reserved namespace names
38 * user-XXXX - user defined profiles
40 * a // in a profile or namespace name indicates a hierarchical name with the
41 * name before the // being the parent and the name after the child.
43 * Profile and namespace hierarchies serve two different but similar purposes.
44 * The namespace contains the set of visible profiles that are considered
45 * for attachment. The hierarchy of namespaces allows for virtualizing
46 * the namespace so that for example a chroot can have its own set of profiles
47 * which may define some local user namespaces.
48 * The profile hierarchy severs two distinct purposes,
49 * - it allows for sub profiles or hats, which allows an application to run
50 * subprograms under its own profile with different restriction than it
51 * self, and not have it use the system profile.
52 * eg. if a mail program starts an editor, the policy might make the
53 * restrictions tighter on the editor tighter than the mail program,
54 * and definitely different than general editor restrictions
55 * - it allows for binary hierarchy of profiles, so that execution history
56 * is preserved. This feature isn't exploited by AppArmor reference policy
57 * but is allowed. NOTE: this is currently suboptimal because profile
58 * aliasing is not currently implemented so that a profile for each
59 * level must be defined.
60 * eg. /bin/bash///bin/ls as a name would indicate /bin/ls was started
63 * A profile or namespace name that can contain one or more // separators
64 * is referred to as an hname (hierarchical).
65 * eg. /bin/bash//bin/ls
67 * An fqname is a name that may contain both namespace and profile hnames.
68 * eg. :ns:/bin/bash//bin/ls
71 * - locking of profile lists is currently fairly coarse. All profile
72 * lists within a namespace use the namespace lock.
73 * FIXME: move profile lists to using rcu_lists
76 #include <linux/slab.h>
77 #include <linux/spinlock.h>
78 #include <linux/string.h>
80 #include "include/apparmor.h"
81 #include "include/capability.h"
82 #include "include/context.h"
83 #include "include/file.h"
84 #include "include/ipc.h"
85 #include "include/match.h"
86 #include "include/path.h"
87 #include "include/policy.h"
88 #include "include/policy_ns.h"
89 #include "include/policy_unpack.h"
90 #include "include/resource.h"
93 const char *const aa_profile_mode_names[] = {
101 /* requires profile list write lock held */
102 void __aa_update_replacedby(struct aa_profile *orig, struct aa_profile *new)
104 struct aa_profile *tmp;
106 tmp = rcu_dereference_protected(orig->replacedby->profile,
107 mutex_is_locked(&orig->ns->lock));
108 rcu_assign_pointer(orig->replacedby->profile, aa_get_profile(new));
109 orig->flags |= PFLAG_STALE;
114 * __list_add_profile - add a profile to a list
115 * @list: list to add it to (NOT NULL)
116 * @profile: the profile to add (NOT NULL)
118 * refcount @profile, should be put by __list_remove_profile
120 * Requires: namespace lock be held, or list not be shared
122 static void __list_add_profile(struct list_head *list,
123 struct aa_profile *profile)
125 list_add_rcu(&profile->base.list, list);
126 /* get list reference */
127 aa_get_profile(profile);
131 * __list_remove_profile - remove a profile from the list it is on
132 * @profile: the profile to remove (NOT NULL)
134 * remove a profile from the list, warning generally removal should
135 * be done with __replace_profile as most profile removals are
136 * replacements to the unconfined profile.
138 * put @profile list refcount
140 * Requires: namespace lock be held, or list not have been live
142 static void __list_remove_profile(struct aa_profile *profile)
144 list_del_rcu(&profile->base.list);
145 aa_put_profile(profile);
149 * __remove_profile - remove old profile, and children
150 * @profile: profile to be replaced (NOT NULL)
152 * Requires: namespace list lock be held, or list not be shared
154 static void __remove_profile(struct aa_profile *profile)
156 /* release any children lists first */
157 __aa_profile_list_release(&profile->base.profiles);
158 /* released by free_profile */
159 __aa_update_replacedby(profile, profile->ns->unconfined);
160 __aa_fs_profile_rmdir(profile);
161 __list_remove_profile(profile);
165 * __aa_profile_list_release - remove all profiles on the list and put refs
166 * @head: list of profiles (NOT NULL)
168 * Requires: namespace lock be held
170 void __aa_profile_list_release(struct list_head *head)
172 struct aa_profile *profile, *tmp;
173 list_for_each_entry_safe(profile, tmp, head, base.list)
174 __remove_profile(profile);
178 static void free_replacedby(struct aa_replacedby *r)
181 /* r->profile will not be updated any more as r is dead */
182 aa_put_profile(rcu_dereference_protected(r->profile, true));
188 void aa_free_replacedby_kref(struct kref *kref)
190 struct aa_replacedby *r = container_of(kref, struct aa_replacedby,
196 * aa_free_profile - free a profile
197 * @profile: the profile to free (MAYBE NULL)
199 * Free a profile, its hats and null_profile. All references to the profile,
200 * its hats and null_profile must have been put.
202 * If the profile was referenced from a task context, free_profile() will
203 * be called from an rcu callback routine, so we must not sleep here.
205 void aa_free_profile(struct aa_profile *profile)
207 AA_DEBUG("%s(%p)\n", __func__, profile);
212 /* free children profiles */
213 aa_policy_destroy(&profile->base);
214 aa_put_profile(rcu_access_pointer(profile->parent));
216 aa_put_ns(profile->ns);
217 kzfree(profile->rename);
219 aa_free_file_rules(&profile->file);
220 aa_free_cap_rules(&profile->caps);
221 aa_free_rlimit_rules(&profile->rlimits);
223 kzfree(profile->dirname);
224 aa_put_dfa(profile->xmatch);
225 aa_put_dfa(profile->policy.dfa);
226 aa_put_replacedby(profile->replacedby);
228 kzfree(profile->hash);
233 * aa_free_profile_rcu - free aa_profile by rcu (called by aa_free_profile_kref)
234 * @head: rcu_head callback for freeing of a profile (NOT NULL)
236 static void aa_free_profile_rcu(struct rcu_head *head)
238 struct aa_profile *p = container_of(head, struct aa_profile, rcu);
239 if (p->flags & PFLAG_NS_COUNT)
246 * aa_free_profile_kref - free aa_profile by kref (called by aa_put_profile)
247 * @kr: kref callback for freeing of a profile (NOT NULL)
249 void aa_free_profile_kref(struct kref *kref)
251 struct aa_profile *p = container_of(kref, struct aa_profile, count);
252 call_rcu(&p->rcu, aa_free_profile_rcu);
256 * aa_alloc_profile - allocate, initialize and return a new profile
257 * @hname: name of the profile (NOT NULL)
259 * Returns: refcount profile or NULL on failure
261 struct aa_profile *aa_alloc_profile(const char *hname)
263 struct aa_profile *profile;
265 /* freed by free_profile - usually through aa_put_profile */
266 profile = kzalloc(sizeof(*profile), GFP_KERNEL);
270 profile->replacedby = kzalloc(sizeof(struct aa_replacedby), GFP_KERNEL);
271 if (!profile->replacedby)
273 kref_init(&profile->replacedby->count);
275 if (!aa_policy_init(&profile->base, NULL, hname))
277 kref_init(&profile->count);
279 /* refcount released by caller */
283 kzfree(profile->replacedby);
290 * aa_new_null_profile - create a new null-X learning profile
291 * @parent: profile that caused this profile to be created (NOT NULL)
292 * @hat: true if the null- learning profile is a hat
294 * Create a null- complain mode profile used in learning mode. The name of
295 * the profile is unique and follows the format of parent//null-<uniq>.
297 * null profiles are added to the profile list but the list does not
298 * hold a count on them so that they are automatically released when
301 * Returns: new refcounted profile else NULL on failure
303 struct aa_profile *aa_new_null_profile(struct aa_profile *parent, int hat)
305 struct aa_profile *profile = NULL;
307 int uniq = atomic_inc_return(&parent->ns->uniq_null);
310 name = kmalloc(strlen(parent->base.hname) + 2 + 7 + 8, GFP_KERNEL);
313 sprintf(name, "%s//null-%x", parent->base.hname, uniq);
315 profile = aa_alloc_profile(name);
320 profile->mode = APPARMOR_COMPLAIN;
321 profile->flags = PFLAG_NULL;
323 profile->flags |= PFLAG_HAT;
325 /* released on free_profile */
326 rcu_assign_pointer(profile->parent, aa_get_profile(parent));
327 profile->ns = aa_get_ns(parent->ns);
329 mutex_lock(&profile->ns->lock);
330 __list_add_profile(&parent->base.profiles, profile);
331 mutex_unlock(&profile->ns->lock);
333 /* refcount released by caller */
340 /* TODO: profile accounting - setup in remove */
343 * __find_child - find a profile on @head list with a name matching @name
344 * @head: list to search (NOT NULL)
345 * @name: name of profile (NOT NULL)
347 * Requires: rcu_read_lock be held
349 * Returns: unrefcounted profile ptr, or NULL if not found
351 static struct aa_profile *__find_child(struct list_head *head, const char *name)
353 return (struct aa_profile *)__policy_find(head, name);
357 * __strn_find_child - find a profile on @head list using substring of @name
358 * @head: list to search (NOT NULL)
359 * @name: name of profile (NOT NULL)
360 * @len: length of @name substring to match
362 * Requires: rcu_read_lock be held
364 * Returns: unrefcounted profile ptr, or NULL if not found
366 static struct aa_profile *__strn_find_child(struct list_head *head,
367 const char *name, int len)
369 return (struct aa_profile *)__policy_strn_find(head, name, len);
373 * aa_find_child - find a profile by @name in @parent
374 * @parent: profile to search (NOT NULL)
375 * @name: profile name to search for (NOT NULL)
377 * Returns: a refcounted profile or NULL if not found
379 struct aa_profile *aa_find_child(struct aa_profile *parent, const char *name)
381 struct aa_profile *profile;
385 profile = __find_child(&parent->base.profiles, name);
386 } while (profile && !aa_get_profile_not0(profile));
389 /* refcount released by caller */
394 * __lookup_parent - lookup the parent of a profile of name @hname
395 * @ns: namespace to lookup profile in (NOT NULL)
396 * @hname: hierarchical profile name to find parent of (NOT NULL)
398 * Lookups up the parent of a fully qualified profile name, the profile
399 * that matches hname does not need to exist, in general this
400 * is used to load a new profile.
402 * Requires: rcu_read_lock be held
404 * Returns: unrefcounted policy or NULL if not found
406 static struct aa_policy *__lookup_parent(struct aa_ns *ns,
409 struct aa_policy *policy;
410 struct aa_profile *profile = NULL;
415 for (split = strstr(hname, "//"); split;) {
416 profile = __strn_find_child(&policy->profiles, hname,
420 policy = &profile->base;
422 split = strstr(hname, "//");
426 return &profile->base;
430 * __lookup_profile - lookup the profile matching @hname
431 * @base: base list to start looking up profile name from (NOT NULL)
432 * @hname: hierarchical profile name (NOT NULL)
434 * Requires: rcu_read_lock be held
436 * Returns: unrefcounted profile pointer or NULL if not found
438 * Do a relative name lookup, recursing through profile tree.
440 static struct aa_profile *__lookup_profile(struct aa_policy *base,
443 struct aa_profile *profile = NULL;
446 for (split = strstr(hname, "//"); split;) {
447 profile = __strn_find_child(&base->profiles, hname,
452 base = &profile->base;
454 split = strstr(hname, "//");
457 profile = __find_child(&base->profiles, hname);
463 * aa_lookup_profile - find a profile by its full or partial name
464 * @ns: the namespace to start from (NOT NULL)
465 * @hname: name to do lookup on. Does not contain namespace prefix (NOT NULL)
467 * Returns: refcounted profile or NULL if not found
469 struct aa_profile *aa_lookup_profile(struct aa_ns *ns, const char *hname)
471 struct aa_profile *profile;
475 profile = __lookup_profile(&ns->base, hname);
476 } while (profile && !aa_get_profile_not0(profile));
479 /* the unconfined profile is not in the regular profile list */
480 if (!profile && strcmp(hname, "unconfined") == 0)
481 profile = aa_get_newest_profile(ns->unconfined);
483 /* refcount released by caller */
488 * replacement_allowed - test to see if replacement is allowed
489 * @profile: profile to test if it can be replaced (MAYBE NULL)
490 * @noreplace: true if replacement shouldn't be allowed but addition is okay
491 * @info: Returns - info about why replacement failed (NOT NULL)
493 * Returns: %0 if replacement allowed else error code
495 static int replacement_allowed(struct aa_profile *profile, int noreplace,
499 if (profile->flags & PFLAG_IMMUTABLE) {
500 *info = "cannot replace immutible profile";
502 } else if (noreplace) {
503 *info = "profile already exists";
511 * aa_audit_policy - Do auditing of policy changes
512 * @op: policy operation being performed
513 * @gfp: memory allocation flags
514 * @name: name of profile being manipulated (NOT NULL)
515 * @info: any extra information to be audited (MAYBE NULL)
518 * Returns: the error to be returned after audit is done
520 static int audit_policy(int op, gfp_t gfp, const char *name, const char *info,
523 struct common_audit_data sa;
524 struct apparmor_audit_data aad = {0,};
525 sa.type = LSM_AUDIT_DATA_NONE;
532 return aa_audit(AUDIT_APPARMOR_STATUS, __aa_current_profile(), gfp,
536 bool policy_view_capable(void)
538 struct user_namespace *user_ns = current_user_ns();
539 bool response = false;
541 if (ns_capable(user_ns, CAP_MAC_ADMIN))
547 bool policy_admin_capable(void)
549 return policy_view_capable() && !aa_g_lock_policy;
553 * aa_may_manage_policy - can the current task manage policy
554 * @op: the policy manipulation operation being done
556 * Returns: true if the task is allowed to manipulate policy
558 bool aa_may_manage_policy(int op)
560 /* check if loading policy is locked out */
561 if (aa_g_lock_policy) {
562 audit_policy(op, GFP_KERNEL, NULL, "policy_locked", -EACCES);
566 if (!policy_admin_capable()) {
567 audit_policy(op, GFP_KERNEL, NULL, "not policy admin", -EACCES);
574 static struct aa_profile *__list_lookup_parent(struct list_head *lh,
575 struct aa_profile *profile)
577 const char *base = hname_tail(profile->base.hname);
578 long len = base - profile->base.hname;
579 struct aa_load_ent *ent;
581 /* parent won't have trailing // so remove from len */
586 list_for_each_entry(ent, lh, list) {
587 if (ent->new == profile)
589 if (strncmp(ent->new->base.hname, profile->base.hname, len) ==
590 0 && ent->new->base.hname[len] == 0)
598 * __replace_profile - replace @old with @new on a list
599 * @old: profile to be replaced (NOT NULL)
600 * @new: profile to replace @old with (NOT NULL)
601 * @share_replacedby: transfer @old->replacedby to @new
603 * Will duplicate and refcount elements that @new inherits from @old
604 * and will inherit @old children.
606 * refcount @new for list, put @old list refcount
608 * Requires: namespace list lock be held, or list not be shared
610 static void __replace_profile(struct aa_profile *old, struct aa_profile *new,
611 bool share_replacedby)
613 struct aa_profile *child, *tmp;
615 if (!list_empty(&old->base.profiles)) {
617 list_splice_init_rcu(&old->base.profiles, &lh, synchronize_rcu);
619 list_for_each_entry_safe(child, tmp, &lh, base.list) {
620 struct aa_profile *p;
622 list_del_init(&child->base.list);
623 p = __find_child(&new->base.profiles, child->base.name);
625 /* @p replaces @child */
626 __replace_profile(child, p, share_replacedby);
630 /* inherit @child and its children */
631 /* TODO: update hname of inherited children */
632 /* list refcount transferred to @new */
633 p = aa_deref_parent(child);
634 rcu_assign_pointer(child->parent, aa_get_profile(new));
635 list_add_rcu(&child->base.list, &new->base.profiles);
640 if (!rcu_access_pointer(new->parent)) {
641 struct aa_profile *parent = aa_deref_parent(old);
642 rcu_assign_pointer(new->parent, aa_get_profile(parent));
644 __aa_update_replacedby(old, new);
645 if (share_replacedby) {
646 aa_put_replacedby(new->replacedby);
647 new->replacedby = aa_get_replacedby(old->replacedby);
648 } else if (!rcu_access_pointer(new->replacedby->profile))
649 /* aafs interface uses replacedby */
650 rcu_assign_pointer(new->replacedby->profile,
651 aa_get_profile(new));
652 __aa_fs_profile_migrate_dents(old, new);
654 if (list_empty(&new->base.list)) {
655 /* new is not on a list already */
656 list_replace_rcu(&old->base.list, &new->base.list);
660 __list_remove_profile(old);
664 * __lookup_replace - lookup replacement information for a profile
665 * @ns - namespace the lookup occurs in
666 * @hname - name of profile to lookup
667 * @noreplace - true if not replacing an existing profile
668 * @p - Returns: profile to be replaced
669 * @info - Returns: info string on why lookup failed
671 * Returns: profile to replace (no ref) on success else ptr error
673 static int __lookup_replace(struct aa_ns *ns, const char *hname,
674 bool noreplace, struct aa_profile **p,
677 *p = aa_get_profile(__lookup_profile(&ns->base, hname));
679 int error = replacement_allowed(*p, noreplace, info);
681 *info = "profile can not be replaced";
690 * aa_replace_profiles - replace profile(s) on the profile list
691 * @udata: serialized data stream (NOT NULL)
692 * @size: size of the serialized data stream
693 * @noreplace: true if only doing addition, no replacement allowed
695 * unpack and replace a profile on the profile list and uses of that profile
696 * by any aa_task_cxt. If the profile does not exist on the profile list
699 * Returns: size of data consumed else error code on failure.
701 ssize_t aa_replace_profiles(void *udata, size_t size, bool noreplace)
703 const char *ns_name, *info = NULL;
704 struct aa_ns *ns = NULL;
705 struct aa_load_ent *ent, *tmp;
706 int op = OP_PROF_REPL;
711 error = aa_unpack(udata, size, &lh, &ns_name);
716 ns = aa_prepare_ns(ns_name);
718 error = audit_policy(op, GFP_KERNEL, ns_name,
719 "failed to prepare namespace", -ENOMEM);
723 mutex_lock(&ns->lock);
724 /* setup parent and ns info */
725 list_for_each_entry(ent, &lh, list) {
726 struct aa_policy *policy;
727 error = __lookup_replace(ns, ent->new->base.hname, noreplace,
732 if (ent->new->rename) {
733 error = __lookup_replace(ns, ent->new->rename,
734 noreplace, &ent->rename,
740 /* released when @new is freed */
741 ent->new->ns = aa_get_ns(ns);
743 if (ent->old || ent->rename)
746 /* no ref on policy only use inside lock */
747 policy = __lookup_parent(ns, ent->new->base.hname);
749 struct aa_profile *p;
750 p = __list_lookup_parent(&lh, ent->new);
753 info = "parent does not exist";
756 rcu_assign_pointer(ent->new->parent, aa_get_profile(p));
757 } else if (policy != &ns->base) {
758 /* released on profile replacement or free_profile */
759 struct aa_profile *p = (struct aa_profile *) policy;
760 rcu_assign_pointer(ent->new->parent, aa_get_profile(p));
764 /* create new fs entries for introspection if needed */
765 list_for_each_entry(ent, &lh, list) {
767 /* inherit old interface files */
770 TODO: support rename */
771 /* } else if (ent->rename) {
772 TODO: support rename */
774 struct dentry *parent;
775 if (rcu_access_pointer(ent->new->parent)) {
776 struct aa_profile *p;
777 p = aa_deref_parent(ent->new);
778 parent = prof_child_dir(p);
780 parent = ns_subprofs_dir(ent->new->ns);
781 error = __aa_fs_profile_mkdir(ent->new, parent);
785 info = "failed to create ";
790 /* Done with checks that may fail - do actual replacement */
791 list_for_each_entry_safe(ent, tmp, &lh, list) {
792 list_del_init(&ent->list);
793 op = (!ent->old && !ent->rename) ? OP_PROF_LOAD : OP_PROF_REPL;
795 audit_policy(op, GFP_ATOMIC, ent->new->base.hname, NULL, error);
798 __replace_profile(ent->old, ent->new, 1);
800 /* aafs interface uses replacedby */
801 struct aa_replacedby *r = ent->new->replacedby;
802 rcu_assign_pointer(r->profile,
803 aa_get_profile(ent->new));
804 __replace_profile(ent->rename, ent->new, 0);
806 } else if (ent->rename) {
807 /* aafs interface uses replacedby */
808 rcu_assign_pointer(ent->new->replacedby->profile,
809 aa_get_profile(ent->new));
810 __replace_profile(ent->rename, ent->new, 0);
811 } else if (ent->new->parent) {
812 struct aa_profile *parent, *newest;
813 parent = aa_deref_parent(ent->new);
814 newest = aa_get_newest_profile(parent);
816 /* parent replaced in this atomic set? */
817 if (newest != parent) {
818 aa_get_profile(newest);
819 rcu_assign_pointer(ent->new->parent, newest);
820 aa_put_profile(parent);
822 /* aafs interface uses replacedby */
823 rcu_assign_pointer(ent->new->replacedby->profile,
824 aa_get_profile(ent->new));
825 __list_add_profile(&newest->base.profiles, ent->new);
826 aa_put_profile(newest);
828 /* aafs interface uses replacedby */
829 rcu_assign_pointer(ent->new->replacedby->profile,
830 aa_get_profile(ent->new));
831 __list_add_profile(&ns->base.profiles, ent->new);
833 aa_load_ent_free(ent);
835 mutex_unlock(&ns->lock);
845 mutex_unlock(&ns->lock);
847 /* audit cause of failure */
848 op = (!ent->old) ? OP_PROF_LOAD : OP_PROF_REPL;
849 audit_policy(op, GFP_KERNEL, ent->new->base.hname, info, error);
850 /* audit status that rest of profiles in the atomic set failed too */
851 info = "valid profile in failed atomic policy load";
852 list_for_each_entry(tmp, &lh, list) {
854 info = "unchecked profile in failed atomic policy load";
855 /* skip entry that caused failure */
858 op = (!ent->old) ? OP_PROF_LOAD : OP_PROF_REPL;
859 audit_policy(op, GFP_KERNEL, tmp->new->base.hname, info, error);
862 list_for_each_entry_safe(ent, tmp, &lh, list) {
863 list_del_init(&ent->list);
864 aa_load_ent_free(ent);
871 * aa_remove_profiles - remove profile(s) from the system
872 * @fqname: name of the profile or namespace to remove (NOT NULL)
873 * @size: size of the name
875 * Remove a profile or sub namespace from the current namespace, so that
876 * they can not be found anymore and mark them as replaced by unconfined
878 * NOTE: removing confinement does not restore rlimits to preconfinemnet values
880 * Returns: size of data consume else error code if fails
882 ssize_t aa_remove_profiles(char *fqname, size_t size)
884 struct aa_ns *root, *ns = NULL;
885 struct aa_profile *profile = NULL;
886 const char *name = fqname, *info = NULL;
890 info = "no profile specified";
895 root = aa_current_profile()->ns;
897 if (fqname[0] == ':') {
899 name = aa_split_fqname(fqname, &ns_name);
901 ns = aa_find_ns(root, ns_name);
903 info = "namespace does not exist";
909 ns = aa_get_ns(root);
912 /* remove namespace - can only happen if fqname[0] == ':' */
913 mutex_lock(&ns->parent->lock);
915 mutex_unlock(&ns->parent->lock);
918 mutex_lock(&ns->lock);
919 profile = aa_get_profile(__lookup_profile(&ns->base, name));
922 info = "profile does not exist";
925 name = profile->base.hname;
926 __remove_profile(profile);
927 mutex_unlock(&ns->lock);
930 /* don't fail removal if audit fails */
931 (void) audit_policy(OP_PROF_RM, GFP_KERNEL, name, info, error);
933 aa_put_profile(profile);
937 mutex_unlock(&ns->lock);
941 (void) audit_policy(OP_PROF_RM, GFP_KERNEL, name, info, error);