1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76#include <linux/slab.h>
77#include <linux/spinlock.h>
78#include <linux/string.h>
79
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_unpack.h"
89#include "include/resource.h"
90
91
92
93struct aa_namespace *root_ns;
94
95const char *const aa_profile_mode_names[] = {
96 "enforce",
97 "complain",
98 "kill",
99 "unconfined",
100};
101
102
103
104
105
106
107
108static const char *hname_tail(const char *hname)
109{
110 char *split;
111 hname = strim((char *)hname);
112 for (split = strstr(hname, "//"); split; split = strstr(hname, "//"))
113 hname = split + 2;
114
115 return hname;
116}
117
118
119
120
121
122
123
124
125
126
127
128static bool policy_init(struct aa_policy *policy, const char *prefix,
129 const char *name)
130{
131
132 if (prefix) {
133 policy->hname = kmalloc(strlen(prefix) + strlen(name) + 3,
134 GFP_KERNEL);
135 if (policy->hname)
136 sprintf(policy->hname, "%s//%s", prefix, name);
137 } else
138 policy->hname = kstrdup(name, GFP_KERNEL);
139 if (!policy->hname)
140 return 0;
141
142 policy->name = (char *)hname_tail(policy->hname);
143 INIT_LIST_HEAD(&policy->list);
144 INIT_LIST_HEAD(&policy->profiles);
145
146 return 1;
147}
148
149
150
151
152
153static void policy_destroy(struct aa_policy *policy)
154{
155
156 if (on_list_rcu(&policy->profiles)) {
157 AA_ERROR("%s: internal error, "
158 "policy '%s' still contains profiles\n",
159 __func__, policy->name);
160 BUG();
161 }
162 if (on_list_rcu(&policy->list)) {
163 AA_ERROR("%s: internal error, policy '%s' still on list\n",
164 __func__, policy->name);
165 BUG();
166 }
167
168
169 kzfree(policy->hname);
170}
171
172
173
174
175
176
177
178
179
180
181static struct aa_policy *__policy_find(struct list_head *head, const char *name)
182{
183 struct aa_policy *policy;
184
185 list_for_each_entry_rcu(policy, head, list) {
186 if (!strcmp(policy->name, name))
187 return policy;
188 }
189 return NULL;
190}
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205static struct aa_policy *__policy_strn_find(struct list_head *head,
206 const char *str, int len)
207{
208 struct aa_policy *policy;
209
210 list_for_each_entry_rcu(policy, head, list) {
211 if (aa_strneq(policy->name, str, len))
212 return policy;
213 }
214
215 return NULL;
216}
217
218
219
220
221
222static const char *hidden_ns_name = "---";
223
224
225
226
227
228
229
230bool aa_ns_visible(struct aa_namespace *curr, struct aa_namespace *view)
231{
232 if (curr == view)
233 return true;
234
235 for ( ; view; view = view->parent) {
236 if (view->parent == curr)
237 return true;
238 }
239 return false;
240}
241
242
243
244
245
246
247
248
249const char *aa_ns_name(struct aa_namespace *curr, struct aa_namespace *view)
250{
251
252 if (curr == view)
253 return "";
254
255 if (aa_ns_visible(curr, view)) {
256
257
258
259
260
261
262 return view->base.hname + strlen(curr->base.hname) + 2;
263 } else
264 return hidden_ns_name;
265}
266
267
268
269
270
271
272
273
274static struct aa_namespace *alloc_namespace(const char *prefix,
275 const char *name)
276{
277 struct aa_namespace *ns;
278
279 ns = kzalloc(sizeof(*ns), GFP_KERNEL);
280 AA_DEBUG("%s(%p)\n", __func__, ns);
281 if (!ns)
282 return NULL;
283 if (!policy_init(&ns->base, prefix, name))
284 goto fail_ns;
285
286 INIT_LIST_HEAD(&ns->sub_ns);
287 mutex_init(&ns->lock);
288
289
290 ns->unconfined = aa_alloc_profile("unconfined");
291 if (!ns->unconfined)
292 goto fail_unconfined;
293
294 ns->unconfined->flags = PFLAG_IX_ON_NAME_ERROR |
295 PFLAG_IMMUTABLE | PFLAG_NS_COUNT;
296 ns->unconfined->mode = APPARMOR_UNCONFINED;
297
298
299 ns->unconfined->ns = ns;
300
301 atomic_set(&ns->uniq_null, 0);
302
303 return ns;
304
305fail_unconfined:
306 kzfree(ns->base.hname);
307fail_ns:
308 kzfree(ns);
309 return NULL;
310}
311
312
313
314
315
316
317
318
319static void free_namespace(struct aa_namespace *ns)
320{
321 if (!ns)
322 return;
323
324 policy_destroy(&ns->base);
325 aa_put_namespace(ns->parent);
326
327 ns->unconfined->ns = NULL;
328 aa_free_profile(ns->unconfined);
329 kzfree(ns);
330}
331
332
333
334
335
336
337
338
339
340
341static struct aa_namespace *__aa_find_namespace(struct list_head *head,
342 const char *name)
343{
344 return (struct aa_namespace *)__policy_find(head, name);
345}
346
347
348
349
350
351
352
353
354
355
356
357struct aa_namespace *aa_find_namespace(struct aa_namespace *root,
358 const char *name)
359{
360 struct aa_namespace *ns = NULL;
361
362 rcu_read_lock();
363 ns = aa_get_namespace(__aa_find_namespace(&root->sub_ns, name));
364 rcu_read_unlock();
365
366 return ns;
367}
368
369
370
371
372
373
374
375static struct aa_namespace *aa_prepare_namespace(const char *name)
376{
377 struct aa_namespace *ns, *root;
378
379 root = aa_current_profile()->ns;
380
381 mutex_lock(&root->lock);
382
383
384 if (!name) {
385
386 ns = aa_get_namespace(root);
387 goto out;
388 }
389
390
391
392 ns = aa_get_namespace(__aa_find_namespace(&root->sub_ns, name));
393 if (!ns) {
394 ns = alloc_namespace(root->base.hname, name);
395 if (!ns)
396 goto out;
397 if (__aa_fs_namespace_mkdir(ns, ns_subns_dir(root), name)) {
398 AA_ERROR("Failed to create interface for ns %s\n",
399 ns->base.name);
400 free_namespace(ns);
401 ns = NULL;
402 goto out;
403 }
404 ns->parent = aa_get_namespace(root);
405 list_add_rcu(&ns->base.list, &root->sub_ns);
406
407 aa_get_namespace(ns);
408 }
409out:
410 mutex_unlock(&root->lock);
411
412
413 return ns;
414}
415
416
417
418
419
420
421
422
423
424
425static void __list_add_profile(struct list_head *list,
426 struct aa_profile *profile)
427{
428 list_add_rcu(&profile->base.list, list);
429
430 aa_get_profile(profile);
431}
432
433
434
435
436
437
438
439
440
441
442
443
444
445static void __list_remove_profile(struct aa_profile *profile)
446{
447 list_del_rcu(&profile->base.list);
448 aa_put_profile(profile);
449}
450
451static void __profile_list_release(struct list_head *head);
452
453
454
455
456
457
458
459static void __remove_profile(struct aa_profile *profile)
460{
461
462 __profile_list_release(&profile->base.profiles);
463
464 __aa_update_replacedby(profile, profile->ns->unconfined);
465 __aa_fs_profile_rmdir(profile);
466 __list_remove_profile(profile);
467}
468
469
470
471
472
473
474
475static void __profile_list_release(struct list_head *head)
476{
477 struct aa_profile *profile, *tmp;
478 list_for_each_entry_safe(profile, tmp, head, base.list)
479 __remove_profile(profile);
480}
481
482static void __ns_list_release(struct list_head *head);
483
484
485
486
487
488static void destroy_namespace(struct aa_namespace *ns)
489{
490 if (!ns)
491 return;
492
493 mutex_lock(&ns->lock);
494
495 __profile_list_release(&ns->base.profiles);
496
497
498 __ns_list_release(&ns->sub_ns);
499
500 if (ns->parent)
501 __aa_update_replacedby(ns->unconfined, ns->parent->unconfined);
502 __aa_fs_namespace_rmdir(ns);
503 mutex_unlock(&ns->lock);
504}
505
506
507
508
509
510
511
512static void __remove_namespace(struct aa_namespace *ns)
513{
514
515 list_del_rcu(&ns->base.list);
516 destroy_namespace(ns);
517 aa_put_namespace(ns);
518}
519
520
521
522
523
524
525
526static void __ns_list_release(struct list_head *head)
527{
528 struct aa_namespace *ns, *tmp;
529 list_for_each_entry_safe(ns, tmp, head, base.list)
530 __remove_namespace(ns);
531
532}
533
534
535
536
537
538
539
540int __init aa_alloc_root_ns(void)
541{
542
543 root_ns = alloc_namespace(NULL, "root");
544 if (!root_ns)
545 return -ENOMEM;
546
547 return 0;
548}
549
550
551
552
553void __init aa_free_root_ns(void)
554 {
555 struct aa_namespace *ns = root_ns;
556 root_ns = NULL;
557
558 destroy_namespace(ns);
559 aa_put_namespace(ns);
560}
561
562
563static void free_replacedby(struct aa_replacedby *r)
564{
565 if (r) {
566
567 aa_put_profile(rcu_dereference_protected(r->profile, true));
568 kzfree(r);
569 }
570}
571
572
573void aa_free_replacedby_kref(struct kref *kref)
574{
575 struct aa_replacedby *r = container_of(kref, struct aa_replacedby,
576 count);
577 free_replacedby(r);
578}
579
580
581
582
583
584
585
586
587
588
589
590void aa_free_profile(struct aa_profile *profile)
591{
592 AA_DEBUG("%s(%p)\n", __func__, profile);
593
594 if (!profile)
595 return;
596
597
598 policy_destroy(&profile->base);
599 aa_put_profile(rcu_access_pointer(profile->parent));
600
601 aa_put_namespace(profile->ns);
602 kzfree(profile->rename);
603
604 aa_free_file_rules(&profile->file);
605 aa_free_cap_rules(&profile->caps);
606 aa_free_rlimit_rules(&profile->rlimits);
607
608 kzfree(profile->dirname);
609 aa_put_dfa(profile->xmatch);
610 aa_put_dfa(profile->policy.dfa);
611 aa_put_replacedby(profile->replacedby);
612
613 kzfree(profile->hash);
614 kzfree(profile);
615}
616
617
618
619
620
621static void aa_free_profile_rcu(struct rcu_head *head)
622{
623 struct aa_profile *p = container_of(head, struct aa_profile, rcu);
624 if (p->flags & PFLAG_NS_COUNT)
625 free_namespace(p->ns);
626 else
627 aa_free_profile(p);
628}
629
630
631
632
633
634void aa_free_profile_kref(struct kref *kref)
635{
636 struct aa_profile *p = container_of(kref, struct aa_profile, count);
637 call_rcu(&p->rcu, aa_free_profile_rcu);
638}
639
640
641
642
643
644
645
646struct aa_profile *aa_alloc_profile(const char *hname)
647{
648 struct aa_profile *profile;
649
650
651 profile = kzalloc(sizeof(*profile), GFP_KERNEL);
652 if (!profile)
653 return NULL;
654
655 profile->replacedby = kzalloc(sizeof(struct aa_replacedby), GFP_KERNEL);
656 if (!profile->replacedby)
657 goto fail;
658 kref_init(&profile->replacedby->count);
659
660 if (!policy_init(&profile->base, NULL, hname))
661 goto fail;
662 kref_init(&profile->count);
663
664
665 return profile;
666
667fail:
668 kzfree(profile->replacedby);
669 kzfree(profile);
670
671 return NULL;
672}
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688struct aa_profile *aa_new_null_profile(struct aa_profile *parent, int hat)
689{
690 struct aa_profile *profile = NULL;
691 char *name;
692 int uniq = atomic_inc_return(&parent->ns->uniq_null);
693
694
695 name = kmalloc(strlen(parent->base.hname) + 2 + 7 + 8, GFP_KERNEL);
696 if (!name)
697 goto fail;
698 sprintf(name, "%s//null-%x", parent->base.hname, uniq);
699
700 profile = aa_alloc_profile(name);
701 kfree(name);
702 if (!profile)
703 goto fail;
704
705 profile->mode = APPARMOR_COMPLAIN;
706 profile->flags = PFLAG_NULL;
707 if (hat)
708 profile->flags |= PFLAG_HAT;
709
710
711 rcu_assign_pointer(profile->parent, aa_get_profile(parent));
712 profile->ns = aa_get_namespace(parent->ns);
713
714 mutex_lock(&profile->ns->lock);
715 __list_add_profile(&parent->base.profiles, profile);
716 mutex_unlock(&profile->ns->lock);
717
718
719 return profile;
720
721fail:
722 return NULL;
723}
724
725
726
727
728
729
730
731
732
733
734
735
736static struct aa_profile *__find_child(struct list_head *head, const char *name)
737{
738 return (struct aa_profile *)__policy_find(head, name);
739}
740
741
742
743
744
745
746
747
748
749
750
751static struct aa_profile *__strn_find_child(struct list_head *head,
752 const char *name, int len)
753{
754 return (struct aa_profile *)__policy_strn_find(head, name, len);
755}
756
757
758
759
760
761
762
763
764struct aa_profile *aa_find_child(struct aa_profile *parent, const char *name)
765{
766 struct aa_profile *profile;
767
768 rcu_read_lock();
769 profile = aa_get_profile(__find_child(&parent->base.profiles, name));
770 rcu_read_unlock();
771
772
773 return profile;
774}
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789static struct aa_policy *__lookup_parent(struct aa_namespace *ns,
790 const char *hname)
791{
792 struct aa_policy *policy;
793 struct aa_profile *profile = NULL;
794 char *split;
795
796 policy = &ns->base;
797
798 for (split = strstr(hname, "//"); split;) {
799 profile = __strn_find_child(&policy->profiles, hname,
800 split - hname);
801 if (!profile)
802 return NULL;
803 policy = &profile->base;
804 hname = split + 2;
805 split = strstr(hname, "//");
806 }
807 if (!profile)
808 return &ns->base;
809 return &profile->base;
810}
811
812
813
814
815
816
817
818
819
820
821
822
823static struct aa_profile *__lookup_profile(struct aa_policy *base,
824 const char *hname)
825{
826 struct aa_profile *profile = NULL;
827 char *split;
828
829 for (split = strstr(hname, "//"); split;) {
830 profile = __strn_find_child(&base->profiles, hname,
831 split - hname);
832 if (!profile)
833 return NULL;
834
835 base = &profile->base;
836 hname = split + 2;
837 split = strstr(hname, "//");
838 }
839
840 profile = __find_child(&base->profiles, hname);
841
842 return profile;
843}
844
845
846
847
848
849
850
851
852struct aa_profile *aa_lookup_profile(struct aa_namespace *ns, const char *hname)
853{
854 struct aa_profile *profile;
855
856 rcu_read_lock();
857 do {
858 profile = __lookup_profile(&ns->base, hname);
859 } while (profile && !aa_get_profile_not0(profile));
860 rcu_read_unlock();
861
862
863 if (!profile && strcmp(hname, "unconfined") == 0)
864 profile = aa_get_newest_profile(ns->unconfined);
865
866
867 return profile;
868}
869
870
871
872
873
874
875
876
877
878static int replacement_allowed(struct aa_profile *profile, int noreplace,
879 const char **info)
880{
881 if (profile) {
882 if (profile->flags & PFLAG_IMMUTABLE) {
883 *info = "cannot replace immutible profile";
884 return -EPERM;
885 } else if (noreplace) {
886 *info = "profile already exists";
887 return -EEXIST;
888 }
889 }
890 return 0;
891}
892
893
894
895
896
897
898
899
900
901
902
903static int audit_policy(int op, gfp_t gfp, const char *name, const char *info,
904 int error)
905{
906 struct common_audit_data sa;
907 struct apparmor_audit_data aad = {0,};
908 sa.type = LSM_AUDIT_DATA_NONE;
909 sa.aad = &aad;
910 aad.op = op;
911 aad.name = name;
912 aad.info = info;
913 aad.error = error;
914
915 return aa_audit(AUDIT_APPARMOR_STATUS, __aa_current_profile(), gfp,
916 &sa, NULL);
917}
918
919
920
921
922
923
924
925bool aa_may_manage_policy(int op)
926{
927
928 if (aa_g_lock_policy) {
929 audit_policy(op, GFP_KERNEL, NULL, "policy_locked", -EACCES);
930 return 0;
931 }
932
933 if (!capable(CAP_MAC_ADMIN)) {
934 audit_policy(op, GFP_KERNEL, NULL, "not policy admin", -EACCES);
935 return 0;
936 }
937
938 return 1;
939}
940
941static struct aa_profile *__list_lookup_parent(struct list_head *lh,
942 struct aa_profile *profile)
943{
944 const char *base = hname_tail(profile->base.hname);
945 long len = base - profile->base.hname;
946 struct aa_load_ent *ent;
947
948
949 if (len <= 2)
950 return NULL;
951 len -= 2;
952
953 list_for_each_entry(ent, lh, list) {
954 if (ent->new == profile)
955 continue;
956 if (strncmp(ent->new->base.hname, profile->base.hname, len) ==
957 0 && ent->new->base.hname[len] == 0)
958 return ent->new;
959 }
960
961 return NULL;
962}
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977static void __replace_profile(struct aa_profile *old, struct aa_profile *new,
978 bool share_replacedby)
979{
980 struct aa_profile *child, *tmp;
981
982 if (!list_empty(&old->base.profiles)) {
983 LIST_HEAD(lh);
984 list_splice_init_rcu(&old->base.profiles, &lh, synchronize_rcu);
985
986 list_for_each_entry_safe(child, tmp, &lh, base.list) {
987 struct aa_profile *p;
988
989 list_del_init(&child->base.list);
990 p = __find_child(&new->base.profiles, child->base.name);
991 if (p) {
992
993 __replace_profile(child, p, share_replacedby);
994 continue;
995 }
996
997
998
999
1000 p = aa_deref_parent(child);
1001 rcu_assign_pointer(child->parent, aa_get_profile(new));
1002 list_add_rcu(&child->base.list, &new->base.profiles);
1003 aa_put_profile(p);
1004 }
1005 }
1006
1007 if (!rcu_access_pointer(new->parent)) {
1008 struct aa_profile *parent = aa_deref_parent(old);
1009 rcu_assign_pointer(new->parent, aa_get_profile(parent));
1010 }
1011 __aa_update_replacedby(old, new);
1012 if (share_replacedby) {
1013 aa_put_replacedby(new->replacedby);
1014 new->replacedby = aa_get_replacedby(old->replacedby);
1015 } else if (!rcu_access_pointer(new->replacedby->profile))
1016
1017 rcu_assign_pointer(new->replacedby->profile,
1018 aa_get_profile(new));
1019 __aa_fs_profile_migrate_dents(old, new);
1020
1021 if (list_empty(&new->base.list)) {
1022
1023 list_replace_rcu(&old->base.list, &new->base.list);
1024 aa_get_profile(new);
1025 aa_put_profile(old);
1026 } else
1027 __list_remove_profile(old);
1028}
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040static int __lookup_replace(struct aa_namespace *ns, const char *hname,
1041 bool noreplace, struct aa_profile **p,
1042 const char **info)
1043{
1044 *p = aa_get_profile(__lookup_profile(&ns->base, hname));
1045 if (*p) {
1046 int error = replacement_allowed(*p, noreplace, info);
1047 if (error) {
1048 *info = "profile can not be replaced";
1049 return error;
1050 }
1051 }
1052
1053 return 0;
1054}
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068ssize_t aa_replace_profiles(void *udata, size_t size, bool noreplace)
1069{
1070 const char *ns_name, *name = NULL, *info = NULL;
1071 struct aa_namespace *ns = NULL;
1072 struct aa_load_ent *ent, *tmp;
1073 int op = OP_PROF_REPL;
1074 ssize_t error;
1075 LIST_HEAD(lh);
1076
1077
1078 error = aa_unpack(udata, size, &lh, &ns_name);
1079 if (error)
1080 goto out;
1081
1082
1083 ns = aa_prepare_namespace(ns_name);
1084 if (!ns) {
1085 info = "failed to prepare namespace";
1086 error = -ENOMEM;
1087 name = ns_name;
1088 goto fail;
1089 }
1090
1091 mutex_lock(&ns->lock);
1092
1093 list_for_each_entry(ent, &lh, list) {
1094 struct aa_policy *policy;
1095
1096 name = ent->new->base.hname;
1097 error = __lookup_replace(ns, ent->new->base.hname, noreplace,
1098 &ent->old, &info);
1099 if (error)
1100 goto fail_lock;
1101
1102 if (ent->new->rename) {
1103 error = __lookup_replace(ns, ent->new->rename,
1104 noreplace, &ent->rename,
1105 &info);
1106 if (error)
1107 goto fail_lock;
1108 }
1109
1110
1111 ent->new->ns = aa_get_namespace(ns);
1112
1113 if (ent->old || ent->rename)
1114 continue;
1115
1116
1117 policy = __lookup_parent(ns, ent->new->base.hname);
1118 if (!policy) {
1119 struct aa_profile *p;
1120 p = __list_lookup_parent(&lh, ent->new);
1121 if (!p) {
1122 error = -ENOENT;
1123 info = "parent does not exist";
1124 name = ent->new->base.hname;
1125 goto fail_lock;
1126 }
1127 rcu_assign_pointer(ent->new->parent, aa_get_profile(p));
1128 } else if (policy != &ns->base) {
1129
1130 struct aa_profile *p = (struct aa_profile *) policy;
1131 rcu_assign_pointer(ent->new->parent, aa_get_profile(p));
1132 }
1133 }
1134
1135
1136 list_for_each_entry(ent, &lh, list) {
1137 if (ent->old) {
1138
1139
1140
1141
1142
1143
1144 } else {
1145 struct dentry *parent;
1146 if (rcu_access_pointer(ent->new->parent)) {
1147 struct aa_profile *p;
1148 p = aa_deref_parent(ent->new);
1149 parent = prof_child_dir(p);
1150 } else
1151 parent = ns_subprofs_dir(ent->new->ns);
1152 error = __aa_fs_profile_mkdir(ent->new, parent);
1153 }
1154
1155 if (error) {
1156 info = "failed to create ";
1157 goto fail_lock;
1158 }
1159 }
1160
1161
1162 list_for_each_entry_safe(ent, tmp, &lh, list) {
1163 list_del_init(&ent->list);
1164 op = (!ent->old && !ent->rename) ? OP_PROF_LOAD : OP_PROF_REPL;
1165
1166 audit_policy(op, GFP_ATOMIC, ent->new->base.name, NULL, error);
1167
1168 if (ent->old) {
1169 __replace_profile(ent->old, ent->new, 1);
1170 if (ent->rename) {
1171
1172 struct aa_replacedby *r = ent->new->replacedby;
1173 rcu_assign_pointer(r->profile,
1174 aa_get_profile(ent->new));
1175 __replace_profile(ent->rename, ent->new, 0);
1176 }
1177 } else if (ent->rename) {
1178
1179 rcu_assign_pointer(ent->new->replacedby->profile,
1180 aa_get_profile(ent->new));
1181 __replace_profile(ent->rename, ent->new, 0);
1182 } else if (ent->new->parent) {
1183 struct aa_profile *parent, *newest;
1184 parent = aa_deref_parent(ent->new);
1185 newest = aa_get_newest_profile(parent);
1186
1187
1188 if (newest != parent) {
1189 aa_get_profile(newest);
1190 aa_put_profile(parent);
1191 rcu_assign_pointer(ent->new->parent, newest);
1192 } else
1193 aa_put_profile(newest);
1194
1195 rcu_assign_pointer(ent->new->replacedby->profile,
1196 aa_get_profile(ent->new));
1197 __list_add_profile(&parent->base.profiles, ent->new);
1198 } else {
1199
1200 rcu_assign_pointer(ent->new->replacedby->profile,
1201 aa_get_profile(ent->new));
1202 __list_add_profile(&ns->base.profiles, ent->new);
1203 }
1204 aa_load_ent_free(ent);
1205 }
1206 mutex_unlock(&ns->lock);
1207
1208out:
1209 aa_put_namespace(ns);
1210
1211 if (error)
1212 return error;
1213 return size;
1214
1215fail_lock:
1216 mutex_unlock(&ns->lock);
1217fail:
1218 error = audit_policy(op, GFP_KERNEL, name, info, error);
1219
1220 list_for_each_entry_safe(ent, tmp, &lh, list) {
1221 list_del_init(&ent->list);
1222 aa_load_ent_free(ent);
1223 }
1224
1225 goto out;
1226}
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240ssize_t aa_remove_profiles(char *fqname, size_t size)
1241{
1242 struct aa_namespace *root, *ns = NULL;
1243 struct aa_profile *profile = NULL;
1244 const char *name = fqname, *info = NULL;
1245 ssize_t error = 0;
1246
1247 if (*fqname == 0) {
1248 info = "no profile specified";
1249 error = -ENOENT;
1250 goto fail;
1251 }
1252
1253 root = aa_current_profile()->ns;
1254
1255 if (fqname[0] == ':') {
1256 char *ns_name;
1257 name = aa_split_fqname(fqname, &ns_name);
1258
1259 ns = aa_find_namespace(root, ns_name);
1260 if (!ns) {
1261 info = "namespace does not exist";
1262 error = -ENOENT;
1263 goto fail;
1264 }
1265 } else
1266
1267 ns = aa_get_namespace(root);
1268
1269 if (!name) {
1270
1271 mutex_lock(&ns->parent->lock);
1272 __remove_namespace(ns);
1273 mutex_unlock(&ns->parent->lock);
1274 } else {
1275
1276 mutex_lock(&ns->lock);
1277 profile = aa_get_profile(__lookup_profile(&ns->base, name));
1278 if (!profile) {
1279 error = -ENOENT;
1280 info = "profile does not exist";
1281 goto fail_ns_lock;
1282 }
1283 name = profile->base.hname;
1284 __remove_profile(profile);
1285 mutex_unlock(&ns->lock);
1286 }
1287
1288
1289 (void) audit_policy(OP_PROF_RM, GFP_KERNEL, name, info, error);
1290 aa_put_namespace(ns);
1291 aa_put_profile(profile);
1292 return size;
1293
1294fail_ns_lock:
1295 mutex_unlock(&ns->lock);
1296 aa_put_namespace(ns);
1297
1298fail:
1299 (void) audit_policy(OP_PROF_RM, GFP_KERNEL, name, info, error);
1300 return error;
1301}
1302