163e2b423SJohn Johansen /* 263e2b423SJohn Johansen * AppArmor security module 363e2b423SJohn Johansen * 463e2b423SJohn Johansen * This file contains AppArmor /sys/kernel/security/apparmor interface functions 563e2b423SJohn Johansen * 663e2b423SJohn Johansen * Copyright (C) 1998-2008 Novell/SUSE 763e2b423SJohn Johansen * Copyright 2009-2010 Canonical Ltd. 863e2b423SJohn Johansen * 963e2b423SJohn Johansen * This program is free software; you can redistribute it and/or 1063e2b423SJohn Johansen * modify it under the terms of the GNU General Public License as 1163e2b423SJohn Johansen * published by the Free Software Foundation, version 2 of the 1263e2b423SJohn Johansen * License. 1363e2b423SJohn Johansen */ 1463e2b423SJohn Johansen 150d259f04SJohn Johansen #include <linux/ctype.h> 1663e2b423SJohn Johansen #include <linux/security.h> 1763e2b423SJohn Johansen #include <linux/vmalloc.h> 1863e2b423SJohn Johansen #include <linux/module.h> 1963e2b423SJohn Johansen #include <linux/seq_file.h> 2063e2b423SJohn Johansen #include <linux/uaccess.h> 2163e2b423SJohn Johansen #include <linux/namei.h> 22e74abcf3SKees Cook #include <linux/capability.h> 2329b3822fSJohn Johansen #include <linux/rcupdate.h> 2463e2b423SJohn Johansen 2563e2b423SJohn Johansen #include "include/apparmor.h" 2663e2b423SJohn Johansen #include "include/apparmorfs.h" 2763e2b423SJohn Johansen #include "include/audit.h" 2863e2b423SJohn Johansen #include "include/context.h" 2963e2b423SJohn Johansen #include "include/policy.h" 30d384b0a1SKees Cook #include "include/resource.h" 3163e2b423SJohn Johansen 3263e2b423SJohn Johansen /** 330d259f04SJohn Johansen * aa_mangle_name - mangle a profile name to std profile layout form 340d259f04SJohn Johansen * @name: profile name to mangle (NOT NULL) 350d259f04SJohn Johansen * @target: buffer to store mangled name, same length as @name (MAYBE NULL) 360d259f04SJohn Johansen * 370d259f04SJohn Johansen * Returns: length of mangled name 380d259f04SJohn Johansen */ 390d259f04SJohn Johansen static int mangle_name(char *name, char *target) 400d259f04SJohn Johansen { 410d259f04SJohn Johansen char *t = target; 420d259f04SJohn Johansen 430d259f04SJohn Johansen while (*name == '/' || *name == '.') 440d259f04SJohn Johansen name++; 450d259f04SJohn Johansen 460d259f04SJohn Johansen if (target) { 470d259f04SJohn Johansen for (; *name; name++) { 480d259f04SJohn Johansen if (*name == '/') 490d259f04SJohn Johansen *(t)++ = '.'; 500d259f04SJohn Johansen else if (isspace(*name)) 510d259f04SJohn Johansen *(t)++ = '_'; 520d259f04SJohn Johansen else if (isalnum(*name) || strchr("._-", *name)) 530d259f04SJohn Johansen *(t)++ = *name; 540d259f04SJohn Johansen } 550d259f04SJohn Johansen 560d259f04SJohn Johansen *t = 0; 570d259f04SJohn Johansen } else { 580d259f04SJohn Johansen int len = 0; 590d259f04SJohn Johansen for (; *name; name++) { 600d259f04SJohn Johansen if (isalnum(*name) || isspace(*name) || 610d259f04SJohn Johansen strchr("/._-", *name)) 620d259f04SJohn Johansen len++; 630d259f04SJohn Johansen } 640d259f04SJohn Johansen 650d259f04SJohn Johansen return len; 660d259f04SJohn Johansen } 670d259f04SJohn Johansen 680d259f04SJohn Johansen return t - target; 690d259f04SJohn Johansen } 700d259f04SJohn Johansen 710d259f04SJohn Johansen /** 7263e2b423SJohn Johansen * aa_simple_write_to_buffer - common routine for getting policy from user 7363e2b423SJohn Johansen * @op: operation doing the user buffer copy 7463e2b423SJohn Johansen * @userbuf: user buffer to copy data from (NOT NULL) 753ed02adaSJohn Johansen * @alloc_size: size of user buffer (REQUIRES: @alloc_size >= @copy_size) 7663e2b423SJohn Johansen * @copy_size: size of data to copy from user buffer 7763e2b423SJohn Johansen * @pos: position write is at in the file (NOT NULL) 7863e2b423SJohn Johansen * 7963e2b423SJohn Johansen * Returns: kernel buffer containing copy of user buffer data or an 8063e2b423SJohn Johansen * ERR_PTR on failure. 8163e2b423SJohn Johansen */ 8263e2b423SJohn Johansen static char *aa_simple_write_to_buffer(int op, const char __user *userbuf, 8363e2b423SJohn Johansen size_t alloc_size, size_t copy_size, 8463e2b423SJohn Johansen loff_t *pos) 8563e2b423SJohn Johansen { 8663e2b423SJohn Johansen char *data; 8763e2b423SJohn Johansen 883ed02adaSJohn Johansen BUG_ON(copy_size > alloc_size); 893ed02adaSJohn Johansen 9063e2b423SJohn Johansen if (*pos != 0) 9163e2b423SJohn Johansen /* only writes from pos 0, that is complete writes */ 9263e2b423SJohn Johansen return ERR_PTR(-ESPIPE); 9363e2b423SJohn Johansen 9463e2b423SJohn Johansen /* 9563e2b423SJohn Johansen * Don't allow profile load/replace/remove from profiles that don't 9663e2b423SJohn Johansen * have CAP_MAC_ADMIN 9763e2b423SJohn Johansen */ 9863e2b423SJohn Johansen if (!aa_may_manage_policy(op)) 9963e2b423SJohn Johansen return ERR_PTR(-EACCES); 10063e2b423SJohn Johansen 10163e2b423SJohn Johansen /* freed by caller to simple_write_to_buffer */ 10263e2b423SJohn Johansen data = kvmalloc(alloc_size); 10363e2b423SJohn Johansen if (data == NULL) 10463e2b423SJohn Johansen return ERR_PTR(-ENOMEM); 10563e2b423SJohn Johansen 10663e2b423SJohn Johansen if (copy_from_user(data, userbuf, copy_size)) { 10763e2b423SJohn Johansen kvfree(data); 10863e2b423SJohn Johansen return ERR_PTR(-EFAULT); 10963e2b423SJohn Johansen } 11063e2b423SJohn Johansen 11163e2b423SJohn Johansen return data; 11263e2b423SJohn Johansen } 11363e2b423SJohn Johansen 11463e2b423SJohn Johansen 11563e2b423SJohn Johansen /* .load file hook fn to load policy */ 11663e2b423SJohn Johansen static ssize_t profile_load(struct file *f, const char __user *buf, size_t size, 11763e2b423SJohn Johansen loff_t *pos) 11863e2b423SJohn Johansen { 11963e2b423SJohn Johansen char *data; 12063e2b423SJohn Johansen ssize_t error; 12163e2b423SJohn Johansen 12263e2b423SJohn Johansen data = aa_simple_write_to_buffer(OP_PROF_LOAD, buf, size, size, pos); 12363e2b423SJohn Johansen 12463e2b423SJohn Johansen error = PTR_ERR(data); 12563e2b423SJohn Johansen if (!IS_ERR(data)) { 12663e2b423SJohn Johansen error = aa_replace_profiles(data, size, PROF_ADD); 12763e2b423SJohn Johansen kvfree(data); 12863e2b423SJohn Johansen } 12963e2b423SJohn Johansen 13063e2b423SJohn Johansen return error; 13163e2b423SJohn Johansen } 13263e2b423SJohn Johansen 13363e2b423SJohn Johansen static const struct file_operations aa_fs_profile_load = { 1346038f373SArnd Bergmann .write = profile_load, 1356038f373SArnd Bergmann .llseek = default_llseek, 13663e2b423SJohn Johansen }; 13763e2b423SJohn Johansen 13863e2b423SJohn Johansen /* .replace file hook fn to load and/or replace policy */ 13963e2b423SJohn Johansen static ssize_t profile_replace(struct file *f, const char __user *buf, 14063e2b423SJohn Johansen size_t size, loff_t *pos) 14163e2b423SJohn Johansen { 14263e2b423SJohn Johansen char *data; 14363e2b423SJohn Johansen ssize_t error; 14463e2b423SJohn Johansen 14563e2b423SJohn Johansen data = aa_simple_write_to_buffer(OP_PROF_REPL, buf, size, size, pos); 14663e2b423SJohn Johansen error = PTR_ERR(data); 14763e2b423SJohn Johansen if (!IS_ERR(data)) { 14863e2b423SJohn Johansen error = aa_replace_profiles(data, size, PROF_REPLACE); 14963e2b423SJohn Johansen kvfree(data); 15063e2b423SJohn Johansen } 15163e2b423SJohn Johansen 15263e2b423SJohn Johansen return error; 15363e2b423SJohn Johansen } 15463e2b423SJohn Johansen 15563e2b423SJohn Johansen static const struct file_operations aa_fs_profile_replace = { 1566038f373SArnd Bergmann .write = profile_replace, 1576038f373SArnd Bergmann .llseek = default_llseek, 15863e2b423SJohn Johansen }; 15963e2b423SJohn Johansen 16063e2b423SJohn Johansen /* .remove file hook fn to remove loaded policy */ 16163e2b423SJohn Johansen static ssize_t profile_remove(struct file *f, const char __user *buf, 16263e2b423SJohn Johansen size_t size, loff_t *pos) 16363e2b423SJohn Johansen { 16463e2b423SJohn Johansen char *data; 16563e2b423SJohn Johansen ssize_t error; 16663e2b423SJohn Johansen 16763e2b423SJohn Johansen /* 16863e2b423SJohn Johansen * aa_remove_profile needs a null terminated string so 1 extra 16963e2b423SJohn Johansen * byte is allocated and the copied data is null terminated. 17063e2b423SJohn Johansen */ 17163e2b423SJohn Johansen data = aa_simple_write_to_buffer(OP_PROF_RM, buf, size + 1, size, pos); 17263e2b423SJohn Johansen 17363e2b423SJohn Johansen error = PTR_ERR(data); 17463e2b423SJohn Johansen if (!IS_ERR(data)) { 17563e2b423SJohn Johansen data[size] = 0; 17663e2b423SJohn Johansen error = aa_remove_profiles(data, size); 17763e2b423SJohn Johansen kvfree(data); 17863e2b423SJohn Johansen } 17963e2b423SJohn Johansen 18063e2b423SJohn Johansen return error; 18163e2b423SJohn Johansen } 18263e2b423SJohn Johansen 18363e2b423SJohn Johansen static const struct file_operations aa_fs_profile_remove = { 1846038f373SArnd Bergmann .write = profile_remove, 1856038f373SArnd Bergmann .llseek = default_llseek, 18663e2b423SJohn Johansen }; 18763e2b423SJohn Johansen 188e74abcf3SKees Cook static int aa_fs_seq_show(struct seq_file *seq, void *v) 189e74abcf3SKees Cook { 190e74abcf3SKees Cook struct aa_fs_entry *fs_file = seq->private; 191e74abcf3SKees Cook 192e74abcf3SKees Cook if (!fs_file) 193e74abcf3SKees Cook return 0; 194e74abcf3SKees Cook 195e74abcf3SKees Cook switch (fs_file->v_type) { 196e74abcf3SKees Cook case AA_FS_TYPE_BOOLEAN: 197e74abcf3SKees Cook seq_printf(seq, "%s\n", fs_file->v.boolean ? "yes" : "no"); 198e74abcf3SKees Cook break; 199a9bf8e9fSKees Cook case AA_FS_TYPE_STRING: 200a9bf8e9fSKees Cook seq_printf(seq, "%s\n", fs_file->v.string); 201a9bf8e9fSKees Cook break; 202e74abcf3SKees Cook case AA_FS_TYPE_U64: 203e74abcf3SKees Cook seq_printf(seq, "%#08lx\n", fs_file->v.u64); 204e74abcf3SKees Cook break; 205e74abcf3SKees Cook default: 206e74abcf3SKees Cook /* Ignore unpritable entry types. */ 207e74abcf3SKees Cook break; 208e74abcf3SKees Cook } 209e74abcf3SKees Cook 210e74abcf3SKees Cook return 0; 211e74abcf3SKees Cook } 212e74abcf3SKees Cook 213e74abcf3SKees Cook static int aa_fs_seq_open(struct inode *inode, struct file *file) 214e74abcf3SKees Cook { 215e74abcf3SKees Cook return single_open(file, aa_fs_seq_show, inode->i_private); 216e74abcf3SKees Cook } 217e74abcf3SKees Cook 218e74abcf3SKees Cook const struct file_operations aa_fs_seq_file_ops = { 219e74abcf3SKees Cook .owner = THIS_MODULE, 220e74abcf3SKees Cook .open = aa_fs_seq_open, 221e74abcf3SKees Cook .read = seq_read, 222e74abcf3SKees Cook .llseek = seq_lseek, 223e74abcf3SKees Cook .release = single_release, 224e74abcf3SKees Cook }; 225e74abcf3SKees Cook 2260d259f04SJohn Johansen static int aa_fs_seq_profile_open(struct inode *inode, struct file *file, 2270d259f04SJohn Johansen int (*show)(struct seq_file *, void *)) 2280d259f04SJohn Johansen { 2290d259f04SJohn Johansen struct aa_replacedby *r = aa_get_replacedby(inode->i_private); 2300d259f04SJohn Johansen int error = single_open(file, show, r); 23163e2b423SJohn Johansen 2320d259f04SJohn Johansen if (error) { 2330d259f04SJohn Johansen file->private_data = NULL; 2340d259f04SJohn Johansen aa_put_replacedby(r); 2350d259f04SJohn Johansen } 2360d259f04SJohn Johansen 2370d259f04SJohn Johansen return error; 2380d259f04SJohn Johansen } 2390d259f04SJohn Johansen 2400d259f04SJohn Johansen static int aa_fs_seq_profile_release(struct inode *inode, struct file *file) 2410d259f04SJohn Johansen { 2420d259f04SJohn Johansen struct seq_file *seq = (struct seq_file *) file->private_data; 2430d259f04SJohn Johansen if (seq) 2440d259f04SJohn Johansen aa_put_replacedby(seq->private); 2450d259f04SJohn Johansen return single_release(inode, file); 2460d259f04SJohn Johansen } 2470d259f04SJohn Johansen 2480d259f04SJohn Johansen static int aa_fs_seq_profname_show(struct seq_file *seq, void *v) 2490d259f04SJohn Johansen { 2500d259f04SJohn Johansen struct aa_replacedby *r = seq->private; 2510d259f04SJohn Johansen struct aa_profile *profile = aa_get_profile_rcu(&r->profile); 2520d259f04SJohn Johansen seq_printf(seq, "%s\n", profile->base.name); 2530d259f04SJohn Johansen aa_put_profile(profile); 2540d259f04SJohn Johansen 2550d259f04SJohn Johansen return 0; 2560d259f04SJohn Johansen } 2570d259f04SJohn Johansen 2580d259f04SJohn Johansen static int aa_fs_seq_profname_open(struct inode *inode, struct file *file) 2590d259f04SJohn Johansen { 2600d259f04SJohn Johansen return aa_fs_seq_profile_open(inode, file, aa_fs_seq_profname_show); 2610d259f04SJohn Johansen } 2620d259f04SJohn Johansen 2630d259f04SJohn Johansen static const struct file_operations aa_fs_profname_fops = { 2640d259f04SJohn Johansen .owner = THIS_MODULE, 2650d259f04SJohn Johansen .open = aa_fs_seq_profname_open, 2660d259f04SJohn Johansen .read = seq_read, 2670d259f04SJohn Johansen .llseek = seq_lseek, 2680d259f04SJohn Johansen .release = aa_fs_seq_profile_release, 2690d259f04SJohn Johansen }; 2700d259f04SJohn Johansen 2710d259f04SJohn Johansen static int aa_fs_seq_profmode_show(struct seq_file *seq, void *v) 2720d259f04SJohn Johansen { 2730d259f04SJohn Johansen struct aa_replacedby *r = seq->private; 2740d259f04SJohn Johansen struct aa_profile *profile = aa_get_profile_rcu(&r->profile); 2750d259f04SJohn Johansen seq_printf(seq, "%s\n", aa_profile_mode_names[profile->mode]); 2760d259f04SJohn Johansen aa_put_profile(profile); 2770d259f04SJohn Johansen 2780d259f04SJohn Johansen return 0; 2790d259f04SJohn Johansen } 2800d259f04SJohn Johansen 2810d259f04SJohn Johansen static int aa_fs_seq_profmode_open(struct inode *inode, struct file *file) 2820d259f04SJohn Johansen { 2830d259f04SJohn Johansen return aa_fs_seq_profile_open(inode, file, aa_fs_seq_profmode_show); 2840d259f04SJohn Johansen } 2850d259f04SJohn Johansen 2860d259f04SJohn Johansen static const struct file_operations aa_fs_profmode_fops = { 2870d259f04SJohn Johansen .owner = THIS_MODULE, 2880d259f04SJohn Johansen .open = aa_fs_seq_profmode_open, 2890d259f04SJohn Johansen .read = seq_read, 2900d259f04SJohn Johansen .llseek = seq_lseek, 2910d259f04SJohn Johansen .release = aa_fs_seq_profile_release, 2920d259f04SJohn Johansen }; 2930d259f04SJohn Johansen 294556d0be7SJohn Johansen static int aa_fs_seq_profattach_show(struct seq_file *seq, void *v) 295556d0be7SJohn Johansen { 296556d0be7SJohn Johansen struct aa_replacedby *r = seq->private; 297556d0be7SJohn Johansen struct aa_profile *profile = aa_get_profile_rcu(&r->profile); 298556d0be7SJohn Johansen if (profile->attach) 299556d0be7SJohn Johansen seq_printf(seq, "%s\n", profile->attach); 300556d0be7SJohn Johansen else if (profile->xmatch) 301556d0be7SJohn Johansen seq_puts(seq, "<unknown>\n"); 302556d0be7SJohn Johansen else 303556d0be7SJohn Johansen seq_printf(seq, "%s\n", profile->base.name); 304556d0be7SJohn Johansen aa_put_profile(profile); 305556d0be7SJohn Johansen 306556d0be7SJohn Johansen return 0; 307556d0be7SJohn Johansen } 308556d0be7SJohn Johansen 309556d0be7SJohn Johansen static int aa_fs_seq_profattach_open(struct inode *inode, struct file *file) 310556d0be7SJohn Johansen { 311556d0be7SJohn Johansen return aa_fs_seq_profile_open(inode, file, aa_fs_seq_profattach_show); 312556d0be7SJohn Johansen } 313556d0be7SJohn Johansen 314556d0be7SJohn Johansen static const struct file_operations aa_fs_profattach_fops = { 315556d0be7SJohn Johansen .owner = THIS_MODULE, 316556d0be7SJohn Johansen .open = aa_fs_seq_profattach_open, 317556d0be7SJohn Johansen .read = seq_read, 318556d0be7SJohn Johansen .llseek = seq_lseek, 319556d0be7SJohn Johansen .release = aa_fs_seq_profile_release, 320556d0be7SJohn Johansen }; 321556d0be7SJohn Johansen 3220d259f04SJohn Johansen /** fns to setup dynamic per profile/namespace files **/ 3230d259f04SJohn Johansen void __aa_fs_profile_rmdir(struct aa_profile *profile) 3240d259f04SJohn Johansen { 3250d259f04SJohn Johansen struct aa_profile *child; 3260d259f04SJohn Johansen int i; 3270d259f04SJohn Johansen 3280d259f04SJohn Johansen if (!profile) 3290d259f04SJohn Johansen return; 3300d259f04SJohn Johansen 3310d259f04SJohn Johansen list_for_each_entry(child, &profile->base.profiles, base.list) 3320d259f04SJohn Johansen __aa_fs_profile_rmdir(child); 3330d259f04SJohn Johansen 3340d259f04SJohn Johansen for (i = AAFS_PROF_SIZEOF - 1; i >= 0; --i) { 3350d259f04SJohn Johansen struct aa_replacedby *r; 3360d259f04SJohn Johansen if (!profile->dents[i]) 3370d259f04SJohn Johansen continue; 3380d259f04SJohn Johansen 3390d259f04SJohn Johansen r = profile->dents[i]->d_inode->i_private; 3400d259f04SJohn Johansen securityfs_remove(profile->dents[i]); 3410d259f04SJohn Johansen aa_put_replacedby(r); 3420d259f04SJohn Johansen profile->dents[i] = NULL; 3430d259f04SJohn Johansen } 3440d259f04SJohn Johansen } 3450d259f04SJohn Johansen 3460d259f04SJohn Johansen void __aa_fs_profile_migrate_dents(struct aa_profile *old, 3470d259f04SJohn Johansen struct aa_profile *new) 3480d259f04SJohn Johansen { 3490d259f04SJohn Johansen int i; 3500d259f04SJohn Johansen 3510d259f04SJohn Johansen for (i = 0; i < AAFS_PROF_SIZEOF; i++) { 3520d259f04SJohn Johansen new->dents[i] = old->dents[i]; 3530d259f04SJohn Johansen old->dents[i] = NULL; 3540d259f04SJohn Johansen } 3550d259f04SJohn Johansen } 3560d259f04SJohn Johansen 3570d259f04SJohn Johansen static struct dentry *create_profile_file(struct dentry *dir, const char *name, 3580d259f04SJohn Johansen struct aa_profile *profile, 3590d259f04SJohn Johansen const struct file_operations *fops) 3600d259f04SJohn Johansen { 3610d259f04SJohn Johansen struct aa_replacedby *r = aa_get_replacedby(profile->replacedby); 3620d259f04SJohn Johansen struct dentry *dent; 3630d259f04SJohn Johansen 3640d259f04SJohn Johansen dent = securityfs_create_file(name, S_IFREG | 0444, dir, r, fops); 3650d259f04SJohn Johansen if (IS_ERR(dent)) 3660d259f04SJohn Johansen aa_put_replacedby(r); 3670d259f04SJohn Johansen 3680d259f04SJohn Johansen return dent; 3690d259f04SJohn Johansen } 3700d259f04SJohn Johansen 3710d259f04SJohn Johansen /* requires lock be held */ 3720d259f04SJohn Johansen int __aa_fs_profile_mkdir(struct aa_profile *profile, struct dentry *parent) 3730d259f04SJohn Johansen { 3740d259f04SJohn Johansen struct aa_profile *child; 3750d259f04SJohn Johansen struct dentry *dent = NULL, *dir; 3760d259f04SJohn Johansen int error; 3770d259f04SJohn Johansen 3780d259f04SJohn Johansen if (!parent) { 3790d259f04SJohn Johansen struct aa_profile *p; 3800d259f04SJohn Johansen p = aa_deref_parent(profile); 3810d259f04SJohn Johansen dent = prof_dir(p); 3820d259f04SJohn Johansen /* adding to parent that previously didn't have children */ 3830d259f04SJohn Johansen dent = securityfs_create_dir("profiles", dent); 3840d259f04SJohn Johansen if (IS_ERR(dent)) 3850d259f04SJohn Johansen goto fail; 3860d259f04SJohn Johansen prof_child_dir(p) = parent = dent; 3870d259f04SJohn Johansen } 3880d259f04SJohn Johansen 3890d259f04SJohn Johansen if (!profile->dirname) { 3900d259f04SJohn Johansen int len, id_len; 3910d259f04SJohn Johansen len = mangle_name(profile->base.name, NULL); 3920d259f04SJohn Johansen id_len = snprintf(NULL, 0, ".%ld", profile->ns->uniq_id); 3930d259f04SJohn Johansen 3940d259f04SJohn Johansen profile->dirname = kmalloc(len + id_len + 1, GFP_KERNEL); 3950d259f04SJohn Johansen if (!profile->dirname) 3960d259f04SJohn Johansen goto fail; 3970d259f04SJohn Johansen 3980d259f04SJohn Johansen mangle_name(profile->base.name, profile->dirname); 3990d259f04SJohn Johansen sprintf(profile->dirname + len, ".%ld", profile->ns->uniq_id++); 4000d259f04SJohn Johansen } 4010d259f04SJohn Johansen 4020d259f04SJohn Johansen dent = securityfs_create_dir(profile->dirname, parent); 4030d259f04SJohn Johansen if (IS_ERR(dent)) 4040d259f04SJohn Johansen goto fail; 4050d259f04SJohn Johansen prof_dir(profile) = dir = dent; 4060d259f04SJohn Johansen 4070d259f04SJohn Johansen dent = create_profile_file(dir, "name", profile, &aa_fs_profname_fops); 4080d259f04SJohn Johansen if (IS_ERR(dent)) 4090d259f04SJohn Johansen goto fail; 4100d259f04SJohn Johansen profile->dents[AAFS_PROF_NAME] = dent; 4110d259f04SJohn Johansen 4120d259f04SJohn Johansen dent = create_profile_file(dir, "mode", profile, &aa_fs_profmode_fops); 4130d259f04SJohn Johansen if (IS_ERR(dent)) 4140d259f04SJohn Johansen goto fail; 4150d259f04SJohn Johansen profile->dents[AAFS_PROF_MODE] = dent; 4160d259f04SJohn Johansen 417556d0be7SJohn Johansen dent = create_profile_file(dir, "attach", profile, 418556d0be7SJohn Johansen &aa_fs_profattach_fops); 419556d0be7SJohn Johansen if (IS_ERR(dent)) 420556d0be7SJohn Johansen goto fail; 421556d0be7SJohn Johansen profile->dents[AAFS_PROF_ATTACH] = dent; 422556d0be7SJohn Johansen 4230d259f04SJohn Johansen list_for_each_entry(child, &profile->base.profiles, base.list) { 4240d259f04SJohn Johansen error = __aa_fs_profile_mkdir(child, prof_child_dir(profile)); 4250d259f04SJohn Johansen if (error) 4260d259f04SJohn Johansen goto fail2; 4270d259f04SJohn Johansen } 4280d259f04SJohn Johansen 4290d259f04SJohn Johansen return 0; 4300d259f04SJohn Johansen 4310d259f04SJohn Johansen fail: 4320d259f04SJohn Johansen error = PTR_ERR(dent); 4330d259f04SJohn Johansen 4340d259f04SJohn Johansen fail2: 4350d259f04SJohn Johansen __aa_fs_profile_rmdir(profile); 4360d259f04SJohn Johansen 4370d259f04SJohn Johansen return error; 4380d259f04SJohn Johansen } 4390d259f04SJohn Johansen 4400d259f04SJohn Johansen void __aa_fs_namespace_rmdir(struct aa_namespace *ns) 4410d259f04SJohn Johansen { 4420d259f04SJohn Johansen struct aa_namespace *sub; 4430d259f04SJohn Johansen struct aa_profile *child; 4440d259f04SJohn Johansen int i; 4450d259f04SJohn Johansen 4460d259f04SJohn Johansen if (!ns) 4470d259f04SJohn Johansen return; 4480d259f04SJohn Johansen 4490d259f04SJohn Johansen list_for_each_entry(child, &ns->base.profiles, base.list) 4500d259f04SJohn Johansen __aa_fs_profile_rmdir(child); 4510d259f04SJohn Johansen 4520d259f04SJohn Johansen list_for_each_entry(sub, &ns->sub_ns, base.list) { 4530d259f04SJohn Johansen mutex_lock(&sub->lock); 4540d259f04SJohn Johansen __aa_fs_namespace_rmdir(sub); 4550d259f04SJohn Johansen mutex_unlock(&sub->lock); 4560d259f04SJohn Johansen } 4570d259f04SJohn Johansen 4580d259f04SJohn Johansen for (i = AAFS_NS_SIZEOF - 1; i >= 0; --i) { 4590d259f04SJohn Johansen securityfs_remove(ns->dents[i]); 4600d259f04SJohn Johansen ns->dents[i] = NULL; 4610d259f04SJohn Johansen } 4620d259f04SJohn Johansen } 4630d259f04SJohn Johansen 4640d259f04SJohn Johansen int __aa_fs_namespace_mkdir(struct aa_namespace *ns, struct dentry *parent, 4650d259f04SJohn Johansen const char *name) 4660d259f04SJohn Johansen { 4670d259f04SJohn Johansen struct aa_namespace *sub; 4680d259f04SJohn Johansen struct aa_profile *child; 4690d259f04SJohn Johansen struct dentry *dent, *dir; 4700d259f04SJohn Johansen int error; 4710d259f04SJohn Johansen 4720d259f04SJohn Johansen if (!name) 4730d259f04SJohn Johansen name = ns->base.name; 4740d259f04SJohn Johansen 4750d259f04SJohn Johansen dent = securityfs_create_dir(name, parent); 4760d259f04SJohn Johansen if (IS_ERR(dent)) 4770d259f04SJohn Johansen goto fail; 4780d259f04SJohn Johansen ns_dir(ns) = dir = dent; 4790d259f04SJohn Johansen 4800d259f04SJohn Johansen dent = securityfs_create_dir("profiles", dir); 4810d259f04SJohn Johansen if (IS_ERR(dent)) 4820d259f04SJohn Johansen goto fail; 4830d259f04SJohn Johansen ns_subprofs_dir(ns) = dent; 4840d259f04SJohn Johansen 4850d259f04SJohn Johansen dent = securityfs_create_dir("namespaces", dir); 4860d259f04SJohn Johansen if (IS_ERR(dent)) 4870d259f04SJohn Johansen goto fail; 4880d259f04SJohn Johansen ns_subns_dir(ns) = dent; 4890d259f04SJohn Johansen 4900d259f04SJohn Johansen list_for_each_entry(child, &ns->base.profiles, base.list) { 4910d259f04SJohn Johansen error = __aa_fs_profile_mkdir(child, ns_subprofs_dir(ns)); 4920d259f04SJohn Johansen if (error) 4930d259f04SJohn Johansen goto fail2; 4940d259f04SJohn Johansen } 4950d259f04SJohn Johansen 4960d259f04SJohn Johansen list_for_each_entry(sub, &ns->sub_ns, base.list) { 4970d259f04SJohn Johansen mutex_lock(&sub->lock); 4980d259f04SJohn Johansen error = __aa_fs_namespace_mkdir(sub, ns_subns_dir(ns), NULL); 4990d259f04SJohn Johansen mutex_unlock(&sub->lock); 5000d259f04SJohn Johansen if (error) 5010d259f04SJohn Johansen goto fail2; 5020d259f04SJohn Johansen } 5030d259f04SJohn Johansen 5040d259f04SJohn Johansen return 0; 5050d259f04SJohn Johansen 5060d259f04SJohn Johansen fail: 5070d259f04SJohn Johansen error = PTR_ERR(dent); 5080d259f04SJohn Johansen 5090d259f04SJohn Johansen fail2: 5100d259f04SJohn Johansen __aa_fs_namespace_rmdir(ns); 5110d259f04SJohn Johansen 5120d259f04SJohn Johansen return error; 5130d259f04SJohn Johansen } 5140d259f04SJohn Johansen 5150d259f04SJohn Johansen 51629b3822fSJohn Johansen #define list_entry_next(pos, member) \ 51729b3822fSJohn Johansen list_entry(pos->member.next, typeof(*pos), member) 51829b3822fSJohn Johansen #define list_entry_is_head(pos, head, member) (&pos->member == (head)) 51929b3822fSJohn Johansen 52029b3822fSJohn Johansen /** 52129b3822fSJohn Johansen * __next_namespace - find the next namespace to list 52229b3822fSJohn Johansen * @root: root namespace to stop search at (NOT NULL) 52329b3822fSJohn Johansen * @ns: current ns position (NOT NULL) 52429b3822fSJohn Johansen * 52529b3822fSJohn Johansen * Find the next namespace from @ns under @root and handle all locking needed 52629b3822fSJohn Johansen * while switching current namespace. 52729b3822fSJohn Johansen * 52829b3822fSJohn Johansen * Returns: next namespace or NULL if at last namespace under @root 52929b3822fSJohn Johansen * Requires: ns->parent->lock to be held 53029b3822fSJohn Johansen * NOTE: will not unlock root->lock 53129b3822fSJohn Johansen */ 53229b3822fSJohn Johansen static struct aa_namespace *__next_namespace(struct aa_namespace *root, 53329b3822fSJohn Johansen struct aa_namespace *ns) 53429b3822fSJohn Johansen { 53529b3822fSJohn Johansen struct aa_namespace *parent, *next; 53629b3822fSJohn Johansen 53729b3822fSJohn Johansen /* is next namespace a child */ 53829b3822fSJohn Johansen if (!list_empty(&ns->sub_ns)) { 53929b3822fSJohn Johansen next = list_first_entry(&ns->sub_ns, typeof(*ns), base.list); 54029b3822fSJohn Johansen mutex_lock(&next->lock); 54129b3822fSJohn Johansen return next; 54229b3822fSJohn Johansen } 54329b3822fSJohn Johansen 54429b3822fSJohn Johansen /* check if the next ns is a sibling, parent, gp, .. */ 54529b3822fSJohn Johansen parent = ns->parent; 54629b3822fSJohn Johansen while (parent) { 54729b3822fSJohn Johansen mutex_unlock(&ns->lock); 54829b3822fSJohn Johansen next = list_entry_next(ns, base.list); 54929b3822fSJohn Johansen if (!list_entry_is_head(next, &parent->sub_ns, base.list)) { 55029b3822fSJohn Johansen mutex_lock(&next->lock); 55129b3822fSJohn Johansen return next; 55229b3822fSJohn Johansen } 55329b3822fSJohn Johansen if (parent == root) 55429b3822fSJohn Johansen return NULL; 55529b3822fSJohn Johansen ns = parent; 55629b3822fSJohn Johansen parent = parent->parent; 55729b3822fSJohn Johansen } 55829b3822fSJohn Johansen 55929b3822fSJohn Johansen return NULL; 56029b3822fSJohn Johansen } 56129b3822fSJohn Johansen 56229b3822fSJohn Johansen /** 56329b3822fSJohn Johansen * __first_profile - find the first profile in a namespace 56429b3822fSJohn Johansen * @root: namespace that is root of profiles being displayed (NOT NULL) 56529b3822fSJohn Johansen * @ns: namespace to start in (NOT NULL) 56629b3822fSJohn Johansen * 56729b3822fSJohn Johansen * Returns: unrefcounted profile or NULL if no profile 56829b3822fSJohn Johansen * Requires: profile->ns.lock to be held 56929b3822fSJohn Johansen */ 57029b3822fSJohn Johansen static struct aa_profile *__first_profile(struct aa_namespace *root, 57129b3822fSJohn Johansen struct aa_namespace *ns) 57229b3822fSJohn Johansen { 57329b3822fSJohn Johansen for (; ns; ns = __next_namespace(root, ns)) { 57429b3822fSJohn Johansen if (!list_empty(&ns->base.profiles)) 57529b3822fSJohn Johansen return list_first_entry(&ns->base.profiles, 57629b3822fSJohn Johansen struct aa_profile, base.list); 57729b3822fSJohn Johansen } 57829b3822fSJohn Johansen return NULL; 57929b3822fSJohn Johansen } 58029b3822fSJohn Johansen 58129b3822fSJohn Johansen /** 58229b3822fSJohn Johansen * __next_profile - step to the next profile in a profile tree 58329b3822fSJohn Johansen * @profile: current profile in tree (NOT NULL) 58429b3822fSJohn Johansen * 58529b3822fSJohn Johansen * Perform a depth first traversal on the profile tree in a namespace 58629b3822fSJohn Johansen * 58729b3822fSJohn Johansen * Returns: next profile or NULL if done 58829b3822fSJohn Johansen * Requires: profile->ns.lock to be held 58929b3822fSJohn Johansen */ 59029b3822fSJohn Johansen static struct aa_profile *__next_profile(struct aa_profile *p) 59129b3822fSJohn Johansen { 59229b3822fSJohn Johansen struct aa_profile *parent; 59329b3822fSJohn Johansen struct aa_namespace *ns = p->ns; 59429b3822fSJohn Johansen 59529b3822fSJohn Johansen /* is next profile a child */ 59629b3822fSJohn Johansen if (!list_empty(&p->base.profiles)) 59729b3822fSJohn Johansen return list_first_entry(&p->base.profiles, typeof(*p), 59829b3822fSJohn Johansen base.list); 59929b3822fSJohn Johansen 60029b3822fSJohn Johansen /* is next profile a sibling, parent sibling, gp, sibling, .. */ 60129b3822fSJohn Johansen parent = rcu_dereference_protected(p->parent, 60229b3822fSJohn Johansen mutex_is_locked(&p->ns->lock)); 60329b3822fSJohn Johansen while (parent) { 60429b3822fSJohn Johansen p = list_entry_next(p, base.list); 60529b3822fSJohn Johansen if (!list_entry_is_head(p, &parent->base.profiles, base.list)) 60629b3822fSJohn Johansen return p; 60729b3822fSJohn Johansen p = parent; 60829b3822fSJohn Johansen parent = rcu_dereference_protected(parent->parent, 60929b3822fSJohn Johansen mutex_is_locked(&parent->ns->lock)); 61029b3822fSJohn Johansen } 61129b3822fSJohn Johansen 61229b3822fSJohn Johansen /* is next another profile in the namespace */ 61329b3822fSJohn Johansen p = list_entry_next(p, base.list); 61429b3822fSJohn Johansen if (!list_entry_is_head(p, &ns->base.profiles, base.list)) 61529b3822fSJohn Johansen return p; 61629b3822fSJohn Johansen 61729b3822fSJohn Johansen return NULL; 61829b3822fSJohn Johansen } 61929b3822fSJohn Johansen 62029b3822fSJohn Johansen /** 62129b3822fSJohn Johansen * next_profile - step to the next profile in where ever it may be 62229b3822fSJohn Johansen * @root: root namespace (NOT NULL) 62329b3822fSJohn Johansen * @profile: current profile (NOT NULL) 62429b3822fSJohn Johansen * 62529b3822fSJohn Johansen * Returns: next profile or NULL if there isn't one 62629b3822fSJohn Johansen */ 62729b3822fSJohn Johansen static struct aa_profile *next_profile(struct aa_namespace *root, 62829b3822fSJohn Johansen struct aa_profile *profile) 62929b3822fSJohn Johansen { 63029b3822fSJohn Johansen struct aa_profile *next = __next_profile(profile); 63129b3822fSJohn Johansen if (next) 63229b3822fSJohn Johansen return next; 63329b3822fSJohn Johansen 63429b3822fSJohn Johansen /* finished all profiles in namespace move to next namespace */ 63529b3822fSJohn Johansen return __first_profile(root, __next_namespace(root, profile->ns)); 63629b3822fSJohn Johansen } 63729b3822fSJohn Johansen 63829b3822fSJohn Johansen /** 63929b3822fSJohn Johansen * p_start - start a depth first traversal of profile tree 64029b3822fSJohn Johansen * @f: seq_file to fill 64129b3822fSJohn Johansen * @pos: current position 64229b3822fSJohn Johansen * 64329b3822fSJohn Johansen * Returns: first profile under current namespace or NULL if none found 64429b3822fSJohn Johansen * 64529b3822fSJohn Johansen * acquires first ns->lock 64629b3822fSJohn Johansen */ 64729b3822fSJohn Johansen static void *p_start(struct seq_file *f, loff_t *pos) 64829b3822fSJohn Johansen { 64929b3822fSJohn Johansen struct aa_profile *profile = NULL; 65029b3822fSJohn Johansen struct aa_namespace *root = aa_current_profile()->ns; 65129b3822fSJohn Johansen loff_t l = *pos; 65229b3822fSJohn Johansen f->private = aa_get_namespace(root); 65329b3822fSJohn Johansen 65429b3822fSJohn Johansen 65529b3822fSJohn Johansen /* find the first profile */ 65629b3822fSJohn Johansen mutex_lock(&root->lock); 65729b3822fSJohn Johansen profile = __first_profile(root, root); 65829b3822fSJohn Johansen 65929b3822fSJohn Johansen /* skip to position */ 66029b3822fSJohn Johansen for (; profile && l > 0; l--) 66129b3822fSJohn Johansen profile = next_profile(root, profile); 66229b3822fSJohn Johansen 66329b3822fSJohn Johansen return profile; 66429b3822fSJohn Johansen } 66529b3822fSJohn Johansen 66629b3822fSJohn Johansen /** 66729b3822fSJohn Johansen * p_next - read the next profile entry 66829b3822fSJohn Johansen * @f: seq_file to fill 66929b3822fSJohn Johansen * @p: profile previously returned 67029b3822fSJohn Johansen * @pos: current position 67129b3822fSJohn Johansen * 67229b3822fSJohn Johansen * Returns: next profile after @p or NULL if none 67329b3822fSJohn Johansen * 67429b3822fSJohn Johansen * may acquire/release locks in namespace tree as necessary 67529b3822fSJohn Johansen */ 67629b3822fSJohn Johansen static void *p_next(struct seq_file *f, void *p, loff_t *pos) 67729b3822fSJohn Johansen { 67829b3822fSJohn Johansen struct aa_profile *profile = p; 67929b3822fSJohn Johansen struct aa_namespace *ns = f->private; 68029b3822fSJohn Johansen (*pos)++; 68129b3822fSJohn Johansen 68229b3822fSJohn Johansen return next_profile(ns, profile); 68329b3822fSJohn Johansen } 68429b3822fSJohn Johansen 68529b3822fSJohn Johansen /** 68629b3822fSJohn Johansen * p_stop - stop depth first traversal 68729b3822fSJohn Johansen * @f: seq_file we are filling 68829b3822fSJohn Johansen * @p: the last profile writen 68929b3822fSJohn Johansen * 69029b3822fSJohn Johansen * Release all locking done by p_start/p_next on namespace tree 69129b3822fSJohn Johansen */ 69229b3822fSJohn Johansen static void p_stop(struct seq_file *f, void *p) 69329b3822fSJohn Johansen { 69429b3822fSJohn Johansen struct aa_profile *profile = p; 69529b3822fSJohn Johansen struct aa_namespace *root = f->private, *ns; 69629b3822fSJohn Johansen 69729b3822fSJohn Johansen if (profile) { 69829b3822fSJohn Johansen for (ns = profile->ns; ns && ns != root; ns = ns->parent) 69929b3822fSJohn Johansen mutex_unlock(&ns->lock); 70029b3822fSJohn Johansen } 70129b3822fSJohn Johansen mutex_unlock(&root->lock); 70229b3822fSJohn Johansen aa_put_namespace(root); 70329b3822fSJohn Johansen } 70429b3822fSJohn Johansen 70529b3822fSJohn Johansen /** 70629b3822fSJohn Johansen * seq_show_profile - show a profile entry 70729b3822fSJohn Johansen * @f: seq_file to file 70829b3822fSJohn Johansen * @p: current position (profile) (NOT NULL) 70929b3822fSJohn Johansen * 71029b3822fSJohn Johansen * Returns: error on failure 71129b3822fSJohn Johansen */ 71229b3822fSJohn Johansen static int seq_show_profile(struct seq_file *f, void *p) 71329b3822fSJohn Johansen { 71429b3822fSJohn Johansen struct aa_profile *profile = (struct aa_profile *)p; 71529b3822fSJohn Johansen struct aa_namespace *root = f->private; 71629b3822fSJohn Johansen 71729b3822fSJohn Johansen if (profile->ns != root) 71829b3822fSJohn Johansen seq_printf(f, ":%s://", aa_ns_name(root, profile->ns)); 71929b3822fSJohn Johansen seq_printf(f, "%s (%s)\n", profile->base.hname, 72029b3822fSJohn Johansen aa_profile_mode_names[profile->mode]); 72129b3822fSJohn Johansen 72229b3822fSJohn Johansen return 0; 72329b3822fSJohn Johansen } 72429b3822fSJohn Johansen 72529b3822fSJohn Johansen static const struct seq_operations aa_fs_profiles_op = { 72629b3822fSJohn Johansen .start = p_start, 72729b3822fSJohn Johansen .next = p_next, 72829b3822fSJohn Johansen .stop = p_stop, 72929b3822fSJohn Johansen .show = seq_show_profile, 73029b3822fSJohn Johansen }; 73129b3822fSJohn Johansen 73229b3822fSJohn Johansen static int profiles_open(struct inode *inode, struct file *file) 73329b3822fSJohn Johansen { 73429b3822fSJohn Johansen return seq_open(file, &aa_fs_profiles_op); 73529b3822fSJohn Johansen } 73629b3822fSJohn Johansen 73729b3822fSJohn Johansen static int profiles_release(struct inode *inode, struct file *file) 73829b3822fSJohn Johansen { 73929b3822fSJohn Johansen return seq_release(inode, file); 74029b3822fSJohn Johansen } 74129b3822fSJohn Johansen 74229b3822fSJohn Johansen static const struct file_operations aa_fs_profiles_fops = { 74329b3822fSJohn Johansen .open = profiles_open, 74429b3822fSJohn Johansen .read = seq_read, 74529b3822fSJohn Johansen .llseek = seq_lseek, 74629b3822fSJohn Johansen .release = profiles_release, 74729b3822fSJohn Johansen }; 74829b3822fSJohn Johansen 74929b3822fSJohn Johansen 7500d259f04SJohn Johansen /** Base file system setup **/ 751a9bf8e9fSKees Cook static struct aa_fs_entry aa_fs_entry_file[] = { 752a9bf8e9fSKees Cook AA_FS_FILE_STRING("mask", "create read write exec append mmap_exec " \ 753a9bf8e9fSKees Cook "link lock"), 754a9bf8e9fSKees Cook { } 755a9bf8e9fSKees Cook }; 756a9bf8e9fSKees Cook 757e74abcf3SKees Cook static struct aa_fs_entry aa_fs_entry_domain[] = { 758e74abcf3SKees Cook AA_FS_FILE_BOOLEAN("change_hat", 1), 759e74abcf3SKees Cook AA_FS_FILE_BOOLEAN("change_hatv", 1), 760e74abcf3SKees Cook AA_FS_FILE_BOOLEAN("change_onexec", 1), 761e74abcf3SKees Cook AA_FS_FILE_BOOLEAN("change_profile", 1), 762e74abcf3SKees Cook { } 763e74abcf3SKees Cook }; 764e74abcf3SKees Cook 7659d910a3bSJohn Johansen static struct aa_fs_entry aa_fs_entry_policy[] = { 766dd51c848SJohn Johansen AA_FS_FILE_BOOLEAN("set_load", 1), 7679d910a3bSJohn Johansen {} 7689d910a3bSJohn Johansen }; 7699d910a3bSJohn Johansen 770e74abcf3SKees Cook static struct aa_fs_entry aa_fs_entry_features[] = { 7719d910a3bSJohn Johansen AA_FS_DIR("policy", aa_fs_entry_policy), 772e74abcf3SKees Cook AA_FS_DIR("domain", aa_fs_entry_domain), 773a9bf8e9fSKees Cook AA_FS_DIR("file", aa_fs_entry_file), 774e74abcf3SKees Cook AA_FS_FILE_U64("capability", VFS_CAP_FLAGS_MASK), 775d384b0a1SKees Cook AA_FS_DIR("rlimit", aa_fs_entry_rlimit), 776e74abcf3SKees Cook { } 777e74abcf3SKees Cook }; 778e74abcf3SKees Cook 7799acd494bSKees Cook static struct aa_fs_entry aa_fs_entry_apparmor[] = { 7809acd494bSKees Cook AA_FS_FILE_FOPS(".load", 0640, &aa_fs_profile_load), 7819acd494bSKees Cook AA_FS_FILE_FOPS(".replace", 0640, &aa_fs_profile_replace), 7829acd494bSKees Cook AA_FS_FILE_FOPS(".remove", 0640, &aa_fs_profile_remove), 78329b3822fSJohn Johansen AA_FS_FILE_FOPS("profiles", 0640, &aa_fs_profiles_fops), 784e74abcf3SKees Cook AA_FS_DIR("features", aa_fs_entry_features), 7859acd494bSKees Cook { } 7869acd494bSKees Cook }; 78763e2b423SJohn Johansen 7889acd494bSKees Cook static struct aa_fs_entry aa_fs_entry = 7899acd494bSKees Cook AA_FS_DIR("apparmor", aa_fs_entry_apparmor); 7909acd494bSKees Cook 7919acd494bSKees Cook /** 7929acd494bSKees Cook * aafs_create_file - create a file entry in the apparmor securityfs 7939acd494bSKees Cook * @fs_file: aa_fs_entry to build an entry for (NOT NULL) 7949acd494bSKees Cook * @parent: the parent dentry in the securityfs 7959acd494bSKees Cook * 7969acd494bSKees Cook * Use aafs_remove_file to remove entries created with this fn. 7979acd494bSKees Cook */ 7989acd494bSKees Cook static int __init aafs_create_file(struct aa_fs_entry *fs_file, 7999acd494bSKees Cook struct dentry *parent) 80063e2b423SJohn Johansen { 8019acd494bSKees Cook int error = 0; 80263e2b423SJohn Johansen 8039acd494bSKees Cook fs_file->dentry = securityfs_create_file(fs_file->name, 8049acd494bSKees Cook S_IFREG | fs_file->mode, 8059acd494bSKees Cook parent, fs_file, 8069acd494bSKees Cook fs_file->file_ops); 8079acd494bSKees Cook if (IS_ERR(fs_file->dentry)) { 8089acd494bSKees Cook error = PTR_ERR(fs_file->dentry); 8099acd494bSKees Cook fs_file->dentry = NULL; 81063e2b423SJohn Johansen } 8119acd494bSKees Cook return error; 81263e2b423SJohn Johansen } 81363e2b423SJohn Johansen 8140d259f04SJohn Johansen static void __init aafs_remove_dir(struct aa_fs_entry *fs_dir); 81563e2b423SJohn Johansen /** 8169acd494bSKees Cook * aafs_create_dir - recursively create a directory entry in the securityfs 8179acd494bSKees Cook * @fs_dir: aa_fs_entry (and all child entries) to build (NOT NULL) 8189acd494bSKees Cook * @parent: the parent dentry in the securityfs 81963e2b423SJohn Johansen * 8209acd494bSKees Cook * Use aafs_remove_dir to remove entries created with this fn. 82163e2b423SJohn Johansen */ 8229acd494bSKees Cook static int __init aafs_create_dir(struct aa_fs_entry *fs_dir, 8239acd494bSKees Cook struct dentry *parent) 82463e2b423SJohn Johansen { 8259acd494bSKees Cook struct aa_fs_entry *fs_file; 8260d259f04SJohn Johansen struct dentry *dir; 8270d259f04SJohn Johansen int error; 82863e2b423SJohn Johansen 8290d259f04SJohn Johansen dir = securityfs_create_dir(fs_dir->name, parent); 8300d259f04SJohn Johansen if (IS_ERR(dir)) 8310d259f04SJohn Johansen return PTR_ERR(dir); 8320d259f04SJohn Johansen fs_dir->dentry = dir; 83363e2b423SJohn Johansen 8340d259f04SJohn Johansen for (fs_file = fs_dir->v.files; fs_file && fs_file->name; ++fs_file) { 8359acd494bSKees Cook if (fs_file->v_type == AA_FS_TYPE_DIR) 8369acd494bSKees Cook error = aafs_create_dir(fs_file, fs_dir->dentry); 8379acd494bSKees Cook else 8389acd494bSKees Cook error = aafs_create_file(fs_file, fs_dir->dentry); 8399acd494bSKees Cook if (error) 8409acd494bSKees Cook goto failed; 8419acd494bSKees Cook } 8429acd494bSKees Cook 8439acd494bSKees Cook return 0; 8449acd494bSKees Cook 8459acd494bSKees Cook failed: 8460d259f04SJohn Johansen aafs_remove_dir(fs_dir); 8470d259f04SJohn Johansen 8489acd494bSKees Cook return error; 8499acd494bSKees Cook } 8509acd494bSKees Cook 8519acd494bSKees Cook /** 8529acd494bSKees Cook * aafs_remove_file - drop a single file entry in the apparmor securityfs 8539acd494bSKees Cook * @fs_file: aa_fs_entry to detach from the securityfs (NOT NULL) 8549acd494bSKees Cook */ 8559acd494bSKees Cook static void __init aafs_remove_file(struct aa_fs_entry *fs_file) 8569acd494bSKees Cook { 8579acd494bSKees Cook if (!fs_file->dentry) 8589acd494bSKees Cook return; 8599acd494bSKees Cook 8609acd494bSKees Cook securityfs_remove(fs_file->dentry); 8619acd494bSKees Cook fs_file->dentry = NULL; 8629acd494bSKees Cook } 8639acd494bSKees Cook 8649acd494bSKees Cook /** 8659acd494bSKees Cook * aafs_remove_dir - recursively drop a directory entry from the securityfs 8669acd494bSKees Cook * @fs_dir: aa_fs_entry (and all child entries) to detach (NOT NULL) 8679acd494bSKees Cook */ 8689acd494bSKees Cook static void __init aafs_remove_dir(struct aa_fs_entry *fs_dir) 8699acd494bSKees Cook { 8709acd494bSKees Cook struct aa_fs_entry *fs_file; 8719acd494bSKees Cook 8720d259f04SJohn Johansen for (fs_file = fs_dir->v.files; fs_file && fs_file->name; ++fs_file) { 8739acd494bSKees Cook if (fs_file->v_type == AA_FS_TYPE_DIR) 8749acd494bSKees Cook aafs_remove_dir(fs_file); 8759acd494bSKees Cook else 8769acd494bSKees Cook aafs_remove_file(fs_file); 8779acd494bSKees Cook } 8789acd494bSKees Cook 8799acd494bSKees Cook aafs_remove_file(fs_dir); 88063e2b423SJohn Johansen } 88163e2b423SJohn Johansen 88263e2b423SJohn Johansen /** 88363e2b423SJohn Johansen * aa_destroy_aafs - cleanup and free aafs 88463e2b423SJohn Johansen * 88563e2b423SJohn Johansen * releases dentries allocated by aa_create_aafs 88663e2b423SJohn Johansen */ 88763e2b423SJohn Johansen void __init aa_destroy_aafs(void) 88863e2b423SJohn Johansen { 8899acd494bSKees Cook aafs_remove_dir(&aa_fs_entry); 89063e2b423SJohn Johansen } 89163e2b423SJohn Johansen 89263e2b423SJohn Johansen /** 89363e2b423SJohn Johansen * aa_create_aafs - create the apparmor security filesystem 89463e2b423SJohn Johansen * 89563e2b423SJohn Johansen * dentries created here are released by aa_destroy_aafs 89663e2b423SJohn Johansen * 89763e2b423SJohn Johansen * Returns: error on failure 89863e2b423SJohn Johansen */ 8993417d8d5SJames Morris static int __init aa_create_aafs(void) 90063e2b423SJohn Johansen { 90163e2b423SJohn Johansen int error; 90263e2b423SJohn Johansen 90363e2b423SJohn Johansen if (!apparmor_initialized) 90463e2b423SJohn Johansen return 0; 90563e2b423SJohn Johansen 9069acd494bSKees Cook if (aa_fs_entry.dentry) { 90763e2b423SJohn Johansen AA_ERROR("%s: AppArmor securityfs already exists\n", __func__); 90863e2b423SJohn Johansen return -EEXIST; 90963e2b423SJohn Johansen } 91063e2b423SJohn Johansen 9119acd494bSKees Cook /* Populate fs tree. */ 9129acd494bSKees Cook error = aafs_create_dir(&aa_fs_entry, NULL); 91363e2b423SJohn Johansen if (error) 91463e2b423SJohn Johansen goto error; 91563e2b423SJohn Johansen 9160d259f04SJohn Johansen error = __aa_fs_namespace_mkdir(root_ns, aa_fs_entry.dentry, 9170d259f04SJohn Johansen "policy"); 9180d259f04SJohn Johansen if (error) 9190d259f04SJohn Johansen goto error; 9200d259f04SJohn Johansen 92163e2b423SJohn Johansen /* TODO: add support for apparmorfs_null and apparmorfs_mnt */ 92263e2b423SJohn Johansen 92363e2b423SJohn Johansen /* Report that AppArmor fs is enabled */ 92463e2b423SJohn Johansen aa_info_message("AppArmor Filesystem Enabled"); 92563e2b423SJohn Johansen return 0; 92663e2b423SJohn Johansen 92763e2b423SJohn Johansen error: 92863e2b423SJohn Johansen aa_destroy_aafs(); 92963e2b423SJohn Johansen AA_ERROR("Error creating AppArmor securityfs\n"); 93063e2b423SJohn Johansen return error; 93163e2b423SJohn Johansen } 93263e2b423SJohn Johansen 93363e2b423SJohn Johansen fs_initcall(aa_create_aafs); 934