security/apparmor/apparmorfs.c

   1 /*
   2  * AppArmor security module
   3  *
   4  * This file contains AppArmor /sys/kernel/security/apparmor interface functions
   5  *
   6  * Copyright (C) 1998-2008 Novell/SUSE
   7  * Copyright 2009-2010 Canonical Ltd.
   8  *
   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
  12  * License.
  13  */
  14
  15 #include <linux/ctype.h>
  16 #include <linux/security.h>
  17 #include <linux/vmalloc.h>
  18 #include <linux/module.h>
  19 #include <linux/seq_file.h>
  20 #include <linux/uaccess.h>
  21 #include <linux/mount.h>
  22 #include <linux/namei.h>
  23 #include <linux/capability.h>
  24 #include <linux/rcupdate.h>
  25 #include <linux/fs.h>
  26 #include <linux/poll.h>
  27 #include <uapi/linux/major.h>
  28 #include <uapi/linux/magic.h>
  29
  30 #include "include/apparmor.h"
  31 #include "include/apparmorfs.h"
  32 #include "include/audit.h"
  33 #include "include/context.h"
  34 #include "include/crypto.h"
  35 #include "include/policy_ns.h"
  36 #include "include/label.h"
  37 #include "include/policy.h"
  38 #include "include/policy_ns.h"
  39 #include "include/resource.h"
  40 #include "include/policy_unpack.h"
  41
  42 /*
  43  * The apparmor filesystem interface used for policy load and introspection
  44  * The interface is split into two main components based on their function
  45  * a securityfs component:
  46  *   used for static files that are always available, and which allows
  47  *   userspace to specificy the location of the security filesystem.
  48  *
  49  *   fns and data are prefixed with
  50  *      aa_sfs_
  51  *
  52  * an apparmorfs component:
  53  *   used loaded policy content and introspection. It is not part of  a
  54  *   regular mounted filesystem and is available only through the magic
  55  *   policy symlink in the root of the securityfs apparmor/ directory.
  56  *   Tasks queries will be magically redirected to the correct portion
  57  *   of the policy tree based on their confinement.
  58  *
  59  *   fns and data are prefixed with
  60  *      aafs_
  61  *
  62  * The aa_fs_ prefix is used to indicate the fn is used by both the
  63  * securityfs and apparmorfs filesystems.
  64  */
  65
  66
  67 /*
  68  * support fns
  69  */
  70
  71 /**
  72  * aa_mangle_name - mangle a profile name to std profile layout form
  73  * @name: profile name to mangle  (NOT NULL)
  74  * @target: buffer to store mangled name, same length as @name (MAYBE NULL)
  75  *
  76  * Returns: length of mangled name
  77  */
  78 static int mangle_name(const char *name, char *target)
  79 {
  80         char *t = target;
  81
  82         while (*name == '/' || *name == '.')
  83                 name++;
  84
  85         if (target) {
  86                 for (; *name; name++) {
  87                         if (*name == '/')
  88                                 *(t)++ = '.';
  89                         else if (isspace(*name))
  90                                 *(t)++ = '_';
  91                         else if (isalnum(*name) || strchr("._-", *name))
  92                                 *(t)++ = *name;
  93                 }
  94
  95                 *t = 0;
  96         } else {
  97                 int len = 0;
  98                 for (; *name; name++) {
  99                         if (isalnum(*name) || isspace(*name) ||
 100                             strchr("/._-", *name))
 101                                 len++;
 102                 }
 103
 104                 return len;
 105         }
 106
 107         return t - target;
 108 }
 109
 110
 111 /*
 112  * aafs - core fns and data for the policy tree
 113  */
 114
 115 #define AAFS_NAME               "apparmorfs"
 116 static struct vfsmount *aafs_mnt;
 117 static int aafs_count;
 118
 119
 120 static int aafs_show_path(struct seq_file *seq, struct dentry *dentry)
 121 {
 122         struct inode *inode = d_inode(dentry);
 123
 124         seq_printf(seq, "%s:[%lu]", AAFS_NAME, inode->i_ino);
 125         return 0;
 126 }
 127
 128 static void aafs_evict_inode(struct inode *inode)
 129 {
 130         truncate_inode_pages_final(&inode->i_data);
 131         clear_inode(inode);
 132         if (S_ISLNK(inode->i_mode))
 133                 kfree(inode->i_link);
 134 }
 135
 136 static const struct super_operations aafs_super_ops = {
 137         .statfs = simple_statfs,
 138         .evict_inode = aafs_evict_inode,
 139         .show_path = aafs_show_path,
 140 };
 141
 142 static int fill_super(struct super_block *sb, void *data, int silent)
 143 {
 144         static struct tree_descr files[] = { {""} };
 145         int error;
 146
 147         error = simple_fill_super(sb, AAFS_MAGIC, files);
 148         if (error)
 149                 return error;
 150         sb->s_op = &aafs_super_ops;
 151
 152         return 0;
 153 }
 154
 155 static struct dentry *aafs_mount(struct file_system_type *fs_type,
 156                                  int flags, const char *dev_name, void *data)
 157 {
 158         return mount_single(fs_type, flags, data, fill_super);
 159 }
 160
 161 static struct file_system_type aafs_ops = {
 162         .owner = THIS_MODULE,
 163         .name = AAFS_NAME,
 164         .mount = aafs_mount,
 165         .kill_sb = kill_anon_super,
 166 };
 167
 168 /**
 169  * __aafs_setup_d_inode - basic inode setup for apparmorfs
 170  * @dir: parent directory for the dentry
 171  * @dentry: dentry we are seting the inode up for
 172  * @mode: permissions the file should have
 173  * @data: data to store on inode.i_private, available in open()
 174  * @link: if symlink, symlink target string
 175  * @fops: struct file_operations that should be used
 176  * @iops: struct of inode_operations that should be used
 177  */
 178 static int __aafs_setup_d_inode(struct inode *dir, struct dentry *dentry,
 179                                umode_t mode, void *data, char *link,
 180                                const struct file_operations *fops,
 181                                const struct inode_operations *iops)
 182 {
 183         struct inode *inode = new_inode(dir->i_sb);
 184
 185         AA_BUG(!dir);
 186         AA_BUG(!dentry);
 187
 188         if (!inode)
 189                 return -ENOMEM;
 190
 191         inode->i_ino = get_next_ino();
 192         inode->i_mode = mode;
 193         inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
 194         inode->i_private = data;
 195         if (S_ISDIR(mode)) {
 196                 inode->i_op = iops ? iops : &simple_dir_inode_operations;
 197                 inode->i_fop = &simple_dir_operations;
 198                 inc_nlink(inode);
 199                 inc_nlink(dir);
 200         } else if (S_ISLNK(mode)) {
 201                 inode->i_op = iops ? iops : &simple_symlink_inode_operations;
 202                 inode->i_link = link;
 203         } else {
 204                 inode->i_fop = fops;
 205         }
 206         d_instantiate(dentry, inode);
 207         dget(dentry);
 208
 209         return 0;
 210 }
 211
 212 /**
 213  * aafs_create - create a dentry in the apparmorfs filesystem
 214  *
 215  * @name: name of dentry to create
 216  * @mode: permissions the file should have
 217  * @parent: parent directory for this dentry
 218  * @data: data to store on inode.i_private, available in open()
 219  * @link: if symlink, symlink target string
 220  * @fops: struct file_operations that should be used for
 221  * @iops: struct of inode_operations that should be used
 222  *
 223  * This is the basic "create a xxx" function for apparmorfs.
 224  *
 225  * Returns a pointer to a dentry if it succeeds, that must be free with
 226  * aafs_remove(). Will return ERR_PTR on failure.
 227  */
 228 static struct dentry *aafs_create(const char *name, umode_t mode,
 229                                   struct dentry *parent, void *data, void *link,
 230                                   const struct file_operations *fops,
 231                                   const struct inode_operations *iops)
 232 {
 233         struct dentry *dentry;
 234         struct inode *dir;
 235         int error;
 236
 237         AA_BUG(!name);
 238         AA_BUG(!parent);
 239
 240         if (!(mode & S_IFMT))
 241                 mode = (mode & S_IALLUGO) | S_IFREG;
 242
 243         error = simple_pin_fs(&aafs_ops, &aafs_mnt, &aafs_count);
 244         if (error)
 245                 return ERR_PTR(error);
 246
 247         dir = d_inode(parent);
 248
 249         inode_lock(dir);
 250         dentry = lookup_one_len(name, parent, strlen(name));
 251         if (IS_ERR(dentry))
 252                 goto fail_lock;
 253
 254         if (d_really_is_positive(dentry)) {
 255                 error = -EEXIST;
 256                 goto fail_dentry;
 257         }
 258
 259         error = __aafs_setup_d_inode(dir, dentry, mode, data, link, fops, iops);
 260         if (error)
 261                 goto fail_dentry;
 262         inode_unlock(dir);
 263
 264         return dentry;
 265
 266 fail_dentry:
 267         dput(dentry);
 268
 269 fail_lock:
 270         inode_unlock(dir);
 271         simple_release_fs(&aafs_mnt, &aafs_count);
 272
 273         return ERR_PTR(error);
 274 }
 275
 276 /**
 277  * aafs_create_file - create a file in the apparmorfs filesystem
 278  *
 279  * @name: name of dentry to create
 280  * @mode: permissions the file should have
 281  * @parent: parent directory for this dentry
 282  * @data: data to store on inode.i_private, available in open()
 283  * @fops: struct file_operations that should be used for
 284  *
 285  * see aafs_create
 286  */
 287 static struct dentry *aafs_create_file(const char *name, umode_t mode,
 288                                        struct dentry *parent, void *data,
 289                                        const struct file_operations *fops)
 290 {
 291         return aafs_create(name, mode, parent, data, NULL, fops, NULL);
 292 }
 293
 294 /**
 295  * aafs_create_dir - create a directory in the apparmorfs filesystem
 296  *
 297  * @name: name of dentry to create
 298  * @parent: parent directory for this dentry
 299  *
 300  * see aafs_create
 301  */
 302 static struct dentry *aafs_create_dir(const char *name, struct dentry *parent)
 303 {
 304         return aafs_create(name, S_IFDIR | 0755, parent, NULL, NULL, NULL,
 305                            NULL);
 306 }
 307
 308 /**
 309  * aafs_create_symlink - create a symlink in the apparmorfs filesystem
 310  * @name: name of dentry to create
 311  * @parent: parent directory for this dentry
 312  * @target: if symlink, symlink target string
 313  * @iops: struct of inode_operations that should be used
 314  *
 315  * If @target parameter is %NULL, then the @iops parameter needs to be
 316  * setup to handle .readlink and .get_link inode_operations.
 317  */
 318 static struct dentry *aafs_create_symlink(const char *name,
 319                                           struct dentry *parent,
 320                                           const char *target,
 321                                           const struct inode_operations *iops)
 322 {
 323         struct dentry *dent;
 324         char *link = NULL;
 325
 326         if (target) {
 327                 link = kstrdup(target, GFP_KERNEL);
 328                 if (!link)
 329                         return ERR_PTR(-ENOMEM);
 330         }
 331         dent = aafs_create(name, S_IFLNK | 0444, parent, NULL, link, NULL,
 332                            iops);
 333         if (IS_ERR(dent))
 334                 kfree(link);
 335
 336         return dent;
 337 }
 338
 339 /**
 340  * aafs_remove - removes a file or directory from the apparmorfs filesystem
 341  *
 342  * @dentry: dentry of the file/directory/symlink to removed.
 343  */
 344 static void aafs_remove(struct dentry *dentry)
 345 {
 346         struct inode *dir;
 347
 348         if (!dentry || IS_ERR(dentry))
 349                 return;
 350
 351         dir = d_inode(dentry->d_parent);
 352         inode_lock(dir);
 353         if (simple_positive(dentry)) {
 354                 if (d_is_dir(dentry))
 355                         simple_rmdir(dir, dentry);
 356                 else
 357                         simple_unlink(dir, dentry);
 358                 dput(dentry);
 359         }
 360         inode_unlock(dir);
 361         simple_release_fs(&aafs_mnt, &aafs_count);
 362 }
 363
 364
 365 /*
 366  * aa_fs - policy load/replace/remove
 367  */
 368
 369 /**
 370  * aa_simple_write_to_buffer - common routine for getting policy from user
 371  * @userbuf: user buffer to copy data from  (NOT NULL)
 372  * @alloc_size: size of user buffer (REQUIRES: @alloc_size >= @copy_size)
 373  * @copy_size: size of data to copy from user buffer
 374  * @pos: position write is at in the file (NOT NULL)
 375  *
 376  * Returns: kernel buffer containing copy of user buffer data or an
 377  *          ERR_PTR on failure.
 378  */
 379 static struct aa_loaddata *aa_simple_write_to_buffer(const char __user *userbuf,
 380                                                      size_t alloc_size,
 381                                                      size_t copy_size,
 382                                                      loff_t *pos)
 383 {
 384         struct aa_loaddata *data;
 385
 386         AA_BUG(copy_size > alloc_size);
 387
 388         if (*pos != 0)
 389                 /* only writes from pos 0, that is complete writes */
 390                 return ERR_PTR(-ESPIPE);
 391
 392         /* freed by caller to simple_write_to_buffer */
 393         data = aa_loaddata_alloc(alloc_size);
 394         if (IS_ERR(data))
 395                 return data;
 396
 397         data->size = copy_size;
 398         if (copy_from_user(data->data, userbuf, copy_size)) {
 399                 kvfree(data);
 400                 return ERR_PTR(-EFAULT);
 401         }
 402
 403         return data;
 404 }
 405
 406 static ssize_t policy_update(u32 mask, const char __user *buf, size_t size,
 407                              loff_t *pos, struct aa_ns *ns)
 408 {
 409         struct aa_loaddata *data;
 410         struct aa_label *label;
 411         ssize_t error;
 412
 413         label = begin_current_label_crit_section();
 414
 415         /* high level check about policy management - fine grained in
 416          * below after unpack
 417          */
 418         error = aa_may_manage_policy(label, ns, mask);
 419         if (error)
 420                 return error;
 421
 422         data = aa_simple_write_to_buffer(buf, size, size, pos);
 423         error = PTR_ERR(data);
 424         if (!IS_ERR(data)) {
 425                 error = aa_replace_profiles(ns, label, mask, data);
 426                 aa_put_loaddata(data);
 427         }
 428         end_current_label_crit_section(label);
 429
 430         return error;
 431 }
 432
 433 /* .load file hook fn to load policy */
 434 static ssize_t profile_load(struct file *f, const char __user *buf, size_t size,
 435                             loff_t *pos)
 436 {
 437         struct aa_ns *ns = aa_get_ns(f->f_inode->i_private);
 438         int error = policy_update(AA_MAY_LOAD_POLICY, buf, size, pos, ns);
 439
 440         aa_put_ns(ns);
 441
 442         return error;
 443 }
 444
 445 static const struct file_operations aa_fs_profile_load = {
 446         .write = profile_load,
 447         .llseek = default_llseek,
 448 };
 449
 450 /* .replace file hook fn to load and/or replace policy */
 451 static ssize_t profile_replace(struct file *f, const char __user *buf,
 452                                size_t size, loff_t *pos)
 453 {
 454         struct aa_ns *ns = aa_get_ns(f->f_inode->i_private);
 455         int error = policy_update(AA_MAY_LOAD_POLICY | AA_MAY_REPLACE_POLICY,
 456                                   buf, size, pos, ns);
 457         aa_put_ns(ns);
 458
 459         return error;
 460 }
 461
 462 static const struct file_operations aa_fs_profile_replace = {
 463         .write = profile_replace,
 464         .llseek = default_llseek,
 465 };
 466
 467 /* .remove file hook fn to remove loaded policy */
 468 static ssize_t profile_remove(struct file *f, const char __user *buf,
 469                               size_t size, loff_t *pos)
 470 {
 471         struct aa_loaddata *data;
 472         struct aa_label *label;
 473         ssize_t error;
 474         struct aa_ns *ns = aa_get_ns(f->f_inode->i_private);
 475
 476         label = begin_current_label_crit_section();
 477         /* high level check about policy management - fine grained in
 478          * below after unpack
 479          */
 480         error = aa_may_manage_policy(label, ns, AA_MAY_REMOVE_POLICY);
 481         if (error)
 482                 goto out;
 483
 484         /*
 485          * aa_remove_profile needs a null terminated string so 1 extra
 486          * byte is allocated and the copied data is null terminated.
 487          */
 488         data = aa_simple_write_to_buffer(buf, size + 1, size, pos);
 489
 490         error = PTR_ERR(data);
 491         if (!IS_ERR(data)) {
 492                 data->data[size] = 0;
 493                 error = aa_remove_profiles(ns, label, data->data, size);
 494                 aa_put_loaddata(data);
 495         }
 496  out:
 497         end_current_label_crit_section(label);
 498         aa_put_ns(ns);
 499         return error;
 500 }
 501
 502 static const struct file_operations aa_fs_profile_remove = {
 503         .write = profile_remove,
 504         .llseek = default_llseek,
 505 };
 506
 507 struct aa_revision {
 508         struct aa_ns *ns;
 509         long last_read;
 510 };
 511
 512 /* revision file hook fn for policy loads */
 513 static int ns_revision_release(struct inode *inode, struct file *file)
 514 {
 515         struct aa_revision *rev = file->private_data;
 516
 517         if (rev) {
 518                 aa_put_ns(rev->ns);
 519                 kfree(rev);
 520         }
 521
 522         return 0;
 523 }
 524
 525 static ssize_t ns_revision_read(struct file *file, char __user *buf,
 526                                 size_t size, loff_t *ppos)
 527 {
 528         struct aa_revision *rev = file->private_data;
 529         char buffer[32];
 530         long last_read;
 531         int avail;
 532
 533         mutex_lock(&rev->ns->lock);
 534         last_read = rev->last_read;
 535         if (last_read == rev->ns->revision) {
 536                 mutex_unlock(&rev->ns->lock);
 537                 if (file->f_flags & O_NONBLOCK)
 538                         return -EAGAIN;
 539                 if (wait_event_interruptible(rev->ns->wait,
 540                                              last_read !=
 541                                              READ_ONCE(rev->ns->revision)))
 542                         return -ERESTARTSYS;
 543                 mutex_lock(&rev->ns->lock);
 544         }
 545
 546         avail = sprintf(buffer, "%ld\n", rev->ns->revision);
 547         if (*ppos + size > avail) {
 548                 rev->last_read = rev->ns->revision;
 549                 *ppos = 0;
 550         }
 551         mutex_unlock(&rev->ns->lock);
 552
 553         return simple_read_from_buffer(buf, size, ppos, buffer, avail);
 554 }
 555
 556 static int ns_revision_open(struct inode *inode, struct file *file)
 557 {
 558         struct aa_revision *rev = kzalloc(sizeof(*rev), GFP_KERNEL);
 559
 560         if (!rev)
 561                 return -ENOMEM;
 562
 563         rev->ns = aa_get_ns(inode->i_private);
 564         if (!rev->ns)
 565                 rev->ns = aa_get_current_ns();
 566         file->private_data = rev;
 567
 568         return 0;
 569 }
 570
 571 static unsigned int ns_revision_poll(struct file *file, poll_table *pt)
 572 {
 573         struct aa_revision *rev = file->private_data;
 574         unsigned int mask = 0;
 575
 576         if (rev) {
 577                 mutex_lock(&rev->ns->lock);
 578                 poll_wait(file, &rev->ns->wait, pt);
 579                 if (rev->last_read < rev->ns->revision)
 580                         mask |= POLLIN | POLLRDNORM;
 581                 mutex_unlock(&rev->ns->lock);
 582         }
 583
 584         return mask;
 585 }
 586
 587 void __aa_bump_ns_revision(struct aa_ns *ns)
 588 {
 589         ns->revision++;
 590         wake_up_interruptible(&ns->wait);
 591 }
 592
 593 static const struct file_operations aa_fs_ns_revision_fops = {
 594         .owner          = THIS_MODULE,
 595         .open           = ns_revision_open,
 596         .poll           = ns_revision_poll,
 597         .read           = ns_revision_read,
 598         .llseek         = generic_file_llseek,
 599         .release        = ns_revision_release,
 600 };
 601
 602 static void profile_query_cb(struct aa_profile *profile, struct aa_perms *perms,
 603                              const char *match_str, size_t match_len)
 604 {
 605         struct aa_perms tmp;
 606         struct aa_dfa *dfa;
 607         unsigned int state = 0;
 608
 609         if (profile_unconfined(profile))
 610                 return;
 611         if (profile->file.dfa && *match_str == AA_CLASS_FILE) {
 612                 dfa = profile->file.dfa;
 613                 state = aa_dfa_match_len(dfa, profile->file.start,
 614                                          match_str + 1, match_len - 1);
 615                 tmp = nullperms;
 616                 if (state) {
 617                         struct path_cond cond = { };
 618
 619                         tmp = aa_compute_fperms(dfa, state, &cond);
 620                 }
 621         } else if (profile->policy.dfa) {
 622                 if (!PROFILE_MEDIATES_SAFE(profile, *match_str))
 623                         return; /* no change to current perms */
 624                 dfa = profile->policy.dfa;
 625                 state = aa_dfa_match_len(dfa, profile->policy.start[0],
 626                                          match_str, match_len);
 627                 if (state)
 628                         aa_compute_perms(dfa, state, &tmp);
 629                 else
 630                         tmp = nullperms;
 631         }
 632         aa_apply_modes_to_perms(profile, &tmp);
 633         aa_perms_accum_raw(perms, &tmp);
 634 }
 635
 636
 637 /**
 638  * query_data - queries a policy and writes its data to buf
 639  * @buf: the resulting data is stored here (NOT NULL)
 640  * @buf_len: size of buf
 641  * @query: query string used to retrieve data
 642  * @query_len: size of query including second NUL byte
 643  *
 644  * The buffers pointed to by buf and query may overlap. The query buffer is
 645  * parsed before buf is written to.
 646  *
 647  * The query should look like "<LABEL>\0<KEY>\0", where <LABEL> is the name of
 648  * the security confinement context and <KEY> is the name of the data to
 649  * retrieve. <LABEL> and <KEY> must not be NUL-terminated.
 650  *
 651  * Don't expect the contents of buf to be preserved on failure.
 652  *
 653  * Returns: number of characters written to buf or -errno on failure
 654  */
 655 static ssize_t query_data(char *buf, size_t buf_len,
 656                           char *query, size_t query_len)
 657 {
 658         char *out;
 659         const char *key;
 660         struct label_it i;
 661         struct aa_label *label, *curr;
 662         struct aa_profile *profile;
 663         struct aa_data *data;
 664         u32 bytes, blocks;
 665         __le32 outle32;
 666
 667         if (!query_len)
 668                 return -EINVAL; /* need a query */
 669
 670         key = query + strnlen(query, query_len) + 1;
 671         if (key + 1 >= query + query_len)
 672                 return -EINVAL; /* not enough space for a non-empty key */
 673         if (key + strnlen(key, query + query_len - key) >= query + query_len)
 674                 return -EINVAL; /* must end with NUL */
 675
 676         if (buf_len < sizeof(bytes) + sizeof(blocks))
 677                 return -EINVAL; /* not enough space */
 678
 679         curr = begin_current_label_crit_section();
 680         label = aa_label_parse(curr, query, GFP_KERNEL, false, false);
 681         end_current_label_crit_section(curr);
 682         if (IS_ERR(label))
 683                 return PTR_ERR(label);
 684
 685         /* We are going to leave space for two numbers. The first is the total
 686          * number of bytes we are writing after the first number. This is so
 687          * users can read the full output without reallocation.
 688          *
 689          * The second number is the number of data blocks we're writing. An
 690          * application might be confined by multiple policies having data in
 691          * the same key.
 692          */
 693         memset(buf, 0, sizeof(bytes) + sizeof(blocks));
 694         out = buf + sizeof(bytes) + sizeof(blocks);
 695
 696         blocks = 0;
 697         label_for_each_confined(i, label, profile) {
 698                 if (!profile->data)
 699                         continue;
 700
 701                 data = rhashtable_lookup_fast(profile->data, &key,
 702                                               profile->data->p);
 703
 704                 if (data) {
 705                         if (out + sizeof(outle32) + data->size > buf +
 706                             buf_len) {
 707                                 aa_put_label(label);
 708                                 return -EINVAL; /* not enough space */
 709                         }
 710                         outle32 = __cpu_to_le32(data->size);
 711                         memcpy(out, &outle32, sizeof(outle32));
 712                         out += sizeof(outle32);
 713                         memcpy(out, data->data, data->size);
 714                         out += data->size;
 715                         blocks++;
 716                 }
 717         }
 718         aa_put_label(label);
 719
 720         outle32 = __cpu_to_le32(out - buf - sizeof(bytes));
 721         memcpy(buf, &outle32, sizeof(outle32));
 722         outle32 = __cpu_to_le32(blocks);
 723         memcpy(buf + sizeof(bytes), &outle32, sizeof(outle32));
 724
 725         return out - buf;
 726 }
 727
 728 /**
 729  * query_label - queries a label and writes permissions to buf
 730  * @buf: the resulting permissions string is stored here (NOT NULL)
 731  * @buf_len: size of buf
 732  * @query: binary query string to match against the dfa
 733  * @query_len: size of query
 734  * @view_only: only compute for querier's view
 735  *
 736  * The buffers pointed to by buf and query may overlap. The query buffer is
 737  * parsed before buf is written to.
 738  *
 739  * The query should look like "LABEL_NAME\0DFA_STRING" where LABEL_NAME is
 740  * the name of the label, in the current namespace, that is to be queried and
 741  * DFA_STRING is a binary string to match against the label(s)'s DFA.
 742  *
 743  * LABEL_NAME must be NUL terminated. DFA_STRING may contain NUL characters
 744  * but must *not* be NUL terminated.
 745  *
 746  * Returns: number of characters written to buf or -errno on failure
 747  */
 748 static ssize_t query_label(char *buf, size_t buf_len,
 749                            char *query, size_t query_len, bool view_only)
 750 {
 751         struct aa_profile *profile;
 752         struct aa_label *label, *curr;
 753         char *label_name, *match_str;
 754         size_t label_name_len, match_len;
 755         struct aa_perms perms;
 756         struct label_it i;
 757
 758         if (!query_len)
 759                 return -EINVAL;
 760
 761         label_name = query;
 762         label_name_len = strnlen(query, query_len);
 763         if (!label_name_len || label_name_len == query_len)
 764                 return -EINVAL;
 765
 766         /**
 767          * The extra byte is to account for the null byte between the
 768          * profile name and dfa string. profile_name_len is greater
 769          * than zero and less than query_len, so a byte can be safely
 770          * added or subtracted.
 771          */
 772         match_str = label_name + label_name_len + 1;
 773         match_len = query_len - label_name_len - 1;
 774
 775         curr = begin_current_label_crit_section();
 776         label = aa_label_parse(curr, label_name, GFP_KERNEL, false, false);
 777         end_current_label_crit_section(curr);
 778         if (IS_ERR(label))
 779                 return PTR_ERR(label);
 780
 781         perms = allperms;
 782         if (view_only) {
 783                 label_for_each_in_ns(i, labels_ns(label), label, profile) {
 784                         profile_query_cb(profile, &perms, match_str, match_len);
 785                 }
 786         } else {
 787                 label_for_each(i, label, profile) {
 788                         profile_query_cb(profile, &perms, match_str, match_len);
 789                 }
 790         }
 791         aa_put_label(label);
 792
 793         return scnprintf(buf, buf_len,
 794                       "allow 0x%08x\ndeny 0x%08x\naudit 0x%08x\nquiet 0x%08x\n",
 795                       perms.allow, perms.deny, perms.audit, perms.quiet);
 796 }
 797
 798 /*
 799  * Transaction based IO.
 800  * The file expects a write which triggers the transaction, and then
 801  * possibly a read(s) which collects the result - which is stored in a
 802  * file-local buffer. Once a new write is performed, a new set of results
 803  * are stored in the file-local buffer.
 804  */
 805 struct multi_transaction {
 806         struct kref count;
 807         ssize_t size;
 808         char data[0];
 809 };
 810
 811 #define MULTI_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct multi_transaction))
 812 /* TODO: replace with per file lock */
 813 static DEFINE_SPINLOCK(multi_transaction_lock);
 814
 815 static void multi_transaction_kref(struct kref *kref)
 816 {
 817         struct multi_transaction *t;
 818
 819         t = container_of(kref, struct multi_transaction, count);
 820         free_page((unsigned long) t);
 821 }
 822
 823 static struct multi_transaction *
 824 get_multi_transaction(struct multi_transaction *t)
 825 {
 826         if  (t)
 827                 kref_get(&(t->count));
 828
 829         return t;
 830 }
 831
 832 static void put_multi_transaction(struct multi_transaction *t)
 833 {
 834         if (t)
 835                 kref_put(&(t->count), multi_transaction_kref);
 836 }
 837
 838 /* does not increment @new's count */
 839 static void multi_transaction_set(struct file *file,
 840                                   struct multi_transaction *new, size_t n)
 841 {
 842         struct multi_transaction *old;
 843
 844         AA_BUG(n > MULTI_TRANSACTION_LIMIT);
 845
 846         new->size = n;
 847         spin_lock(&multi_transaction_lock);
 848         old = (struct multi_transaction *) file->private_data;
 849         file->private_data = new;
 850         spin_unlock(&multi_transaction_lock);
 851         put_multi_transaction(old);
 852 }
 853
 854 static struct multi_transaction *multi_transaction_new(struct file *file,
 855                                                        const char __user *buf,
 856                                                        size_t size)
 857 {
 858         struct multi_transaction *t;
 859
 860         if (size > MULTI_TRANSACTION_LIMIT - 1)
 861                 return ERR_PTR(-EFBIG);
 862
 863         t = (struct multi_transaction *)get_zeroed_page(GFP_KERNEL);
 864         if (!t)
 865                 return ERR_PTR(-ENOMEM);
 866         kref_init(&t->count);
 867         if (copy_from_user(t->data, buf, size))
 868                 return ERR_PTR(-EFAULT);
 869
 870         return t;
 871 }
 872
 873 static ssize_t multi_transaction_read(struct file *file, char __user *buf,
 874                                        size_t size, loff_t *pos)
 875 {
 876         struct multi_transaction *t;
 877         ssize_t ret;
 878
 879         spin_lock(&multi_transaction_lock);
 880         t = get_multi_transaction(file->private_data);
 881         spin_unlock(&multi_transaction_lock);
 882         if (!t)
 883                 return 0;
 884
 885         ret = simple_read_from_buffer(buf, size, pos, t->data, t->size);
 886         put_multi_transaction(t);
 887
 888         return ret;
 889 }
 890
 891 static int multi_transaction_release(struct inode *inode, struct file *file)
 892 {
 893         put_multi_transaction(file->private_data);
 894
 895         return 0;
 896 }
 897
 898 #define QUERY_CMD_LABEL         "label\0"
 899 #define QUERY_CMD_LABEL_LEN     6
 900 #define QUERY_CMD_PROFILE       "profile\0"
 901 #define QUERY_CMD_PROFILE_LEN   8
 902 #define QUERY_CMD_LABELALL      "labelall\0"
 903 #define QUERY_CMD_LABELALL_LEN  9
 904 #define QUERY_CMD_DATA          "data\0"
 905 #define QUERY_CMD_DATA_LEN      5
 906
 907 /**
 908  * aa_write_access - generic permissions and data query
 909  * @file: pointer to open apparmorfs/access file
 910  * @ubuf: user buffer containing the complete query string (NOT NULL)
 911  * @count: size of ubuf
 912  * @ppos: position in the file (MUST BE ZERO)
 913  *
 914  * Allows for one permissions or data query per open(), write(), and read()
 915  * sequence. The only queries currently supported are label-based queries for
 916  * permissions or data.
 917  *
 918  * For permissions queries, ubuf must begin with "label\0", followed by the
 919  * profile query specific format described in the query_label() function
 920  * documentation.
 921  *
 922  * For data queries, ubuf must have the form "data\0<LABEL>\0<KEY>\0", where
 923  * <LABEL> is the name of the security confinement context and <KEY> is the
 924  * name of the data to retrieve.
 925  *
 926  * Returns: number of bytes written or -errno on failure
 927  */
 928 static ssize_t aa_write_access(struct file *file, const char __user *ubuf,
 929                                size_t count, loff_t *ppos)
 930 {
 931         struct multi_transaction *t;
 932         ssize_t len;
 933
 934         if (*ppos)
 935                 return -ESPIPE;
 936
 937         t = multi_transaction_new(file, ubuf, count);
 938         if (IS_ERR(t))
 939                 return PTR_ERR(t);
 940
 941         if (count > QUERY_CMD_PROFILE_LEN &&
 942             !memcmp(t->data, QUERY_CMD_PROFILE, QUERY_CMD_PROFILE_LEN)) {
 943                 len = query_label(t->data, MULTI_TRANSACTION_LIMIT,
 944                                   t->data + QUERY_CMD_PROFILE_LEN,
 945                                   count - QUERY_CMD_PROFILE_LEN, true);
 946         } else if (count > QUERY_CMD_LABEL_LEN &&
 947                    !memcmp(t->data, QUERY_CMD_LABEL, QUERY_CMD_LABEL_LEN)) {
 948                 len = query_label(t->data, MULTI_TRANSACTION_LIMIT,
 949                                   t->data + QUERY_CMD_LABEL_LEN,
 950                                   count - QUERY_CMD_LABEL_LEN, true);
 951         } else if (count > QUERY_CMD_LABELALL_LEN &&
 952                    !memcmp(t->data, QUERY_CMD_LABELALL,
 953                            QUERY_CMD_LABELALL_LEN)) {
 954                 len = query_label(t->data, MULTI_TRANSACTION_LIMIT,
 955                                   t->data + QUERY_CMD_LABELALL_LEN,
 956                                   count - QUERY_CMD_LABELALL_LEN, false);
 957         } else if (count > QUERY_CMD_DATA_LEN &&
 958                    !memcmp(t->data, QUERY_CMD_DATA, QUERY_CMD_DATA_LEN)) {
 959                 len = query_data(t->data, MULTI_TRANSACTION_LIMIT,
 960                                  t->data + QUERY_CMD_DATA_LEN,
 961                                  count - QUERY_CMD_DATA_LEN);
 962         } else
 963                 len = -EINVAL;
 964
 965         if (len < 0) {
 966                 put_multi_transaction(t);
 967                 return len;
 968         }
 969
 970         multi_transaction_set(file, t, len);
 971
 972         return count;
 973 }
 974
 975 static const struct file_operations aa_sfs_access = {
 976         .write          = aa_write_access,
 977         .read           = multi_transaction_read,
 978         .release        = multi_transaction_release,
 979         .llseek         = generic_file_llseek,
 980 };
 981
 982 static int aa_sfs_seq_show(struct seq_file *seq, void *v)
 983 {
 984         struct aa_sfs_entry *fs_file = seq->private;
 985
 986         if (!fs_file)
 987                 return 0;
 988
 989         switch (fs_file->v_type) {
 990         case AA_SFS_TYPE_BOOLEAN:
 991                 seq_printf(seq, "%s\n", fs_file->v.boolean ? "yes" : "no");
 992                 break;
 993         case AA_SFS_TYPE_STRING:
 994                 seq_printf(seq, "%s\n", fs_file->v.string);
 995                 break;
 996         case AA_SFS_TYPE_U64:
 997                 seq_printf(seq, "%#08lx\n", fs_file->v.u64);
 998                 break;
 999         default:
1000                 /* Ignore unpritable entry types. */
1001                 break;
1002         }
1003
1004         return 0;
1005 }
1006
1007 static int aa_sfs_seq_open(struct inode *inode, struct file *file)
1008 {
1009         return single_open(file, aa_sfs_seq_show, inode->i_private);
1010 }
1011
1012 const struct file_operations aa_sfs_seq_file_ops = {
1013         .owner          = THIS_MODULE,
1014         .open           = aa_sfs_seq_open,
1015         .read           = seq_read,
1016         .llseek         = seq_lseek,
1017         .release        = single_release,
1018 };
1019
1020 /*
1021  * profile based file operations
1022  *     policy/profiles/XXXX/profiles/ *
1023  */
1024
1025 #define SEQ_PROFILE_FOPS(NAME)                                                \
1026 static int seq_profile_ ##NAME ##_open(struct inode *inode, struct file *file)\
1027 {                                                                             \
1028         return seq_profile_open(inode, file, seq_profile_ ##NAME ##_show);    \
1029 }                                                                             \
1030                                                                               \
1031 static const struct file_operations seq_profile_ ##NAME ##_fops = {           \
1032         .owner          = THIS_MODULE,                                        \
1033         .open           = seq_profile_ ##NAME ##_open,                        \
1034         .read           = seq_read,                                           \
1035         .llseek         = seq_lseek,                                          \
1036         .release        = seq_profile_release,                                \
1037 }                                                                             \
1038
1039 static int seq_profile_open(struct inode *inode, struct file *file,
1040                             int (*show)(struct seq_file *, void *))
1041 {
1042         struct aa_proxy *proxy = aa_get_proxy(inode->i_private);
1043         int error = single_open(file, show, proxy);
1044
1045         if (error) {
1046                 file->private_data = NULL;
1047                 aa_put_proxy(proxy);
1048         }
1049
1050         return error;
1051 }
1052
1053 static int seq_profile_release(struct inode *inode, struct file *file)
1054 {
1055         struct seq_file *seq = (struct seq_file *) file->private_data;
1056         if (seq)
1057                 aa_put_proxy(seq->private);
1058         return single_release(inode, file);
1059 }
1060
1061 static int seq_profile_name_show(struct seq_file *seq, void *v)
1062 {
1063         struct aa_proxy *proxy = seq->private;
1064         struct aa_label *label = aa_get_label_rcu(&proxy->label);
1065         struct aa_profile *profile = labels_profile(label);
1066         seq_printf(seq, "%s\n", profile->base.name);
1067         aa_put_label(label);
1068
1069         return 0;
1070 }
1071
1072 static int seq_profile_mode_show(struct seq_file *seq, void *v)
1073 {
1074         struct aa_proxy *proxy = seq->private;
1075         struct aa_label *label = aa_get_label_rcu(&proxy->label);
1076         struct aa_profile *profile = labels_profile(label);
1077         seq_printf(seq, "%s\n", aa_profile_mode_names[profile->mode]);
1078         aa_put_label(label);
1079
1080         return 0;
1081 }
1082
1083 static int seq_profile_attach_show(struct seq_file *seq, void *v)
1084 {
1085         struct aa_proxy *proxy = seq->private;
1086         struct aa_label *label = aa_get_label_rcu(&proxy->label);
1087         struct aa_profile *profile = labels_profile(label);
1088         if (profile->attach)
1089                 seq_printf(seq, "%s\n", profile->attach);
1090         else if (profile->xmatch)
1091                 seq_puts(seq, "<unknown>\n");
1092         else
1093                 seq_printf(seq, "%s\n", profile->base.name);
1094         aa_put_label(label);
1095
1096         return 0;
1097 }
1098
1099 static int seq_profile_hash_show(struct seq_file *seq, void *v)
1100 {
1101         struct aa_proxy *proxy = seq->private;
1102         struct aa_label *label = aa_get_label_rcu(&proxy->label);
1103         struct aa_profile *profile = labels_profile(label);
1104         unsigned int i, size = aa_hash_size();
1105
1106         if (profile->hash) {
1107                 for (i = 0; i < size; i++)
1108                         seq_printf(seq, "%.2x", profile->hash[i]);
1109                 seq_putc(seq, '\n');
1110         }
1111         aa_put_label(label);
1112
1113         return 0;
1114 }
1115
1116 SEQ_PROFILE_FOPS(name);
1117 SEQ_PROFILE_FOPS(mode);
1118 SEQ_PROFILE_FOPS(attach);
1119 SEQ_PROFILE_FOPS(hash);
1120
1121 /*
1122  * namespace based files
1123  *     several root files and
1124  *     policy/ *
1125  */
1126
1127 #define SEQ_NS_FOPS(NAME)                                                     \
1128 static int seq_ns_ ##NAME ##_open(struct inode *inode, struct file *file)     \
1129 {                                                                             \
1130         return single_open(file, seq_ns_ ##NAME ##_show, inode->i_private);   \
1131 }                                                                             \
1132                                                                               \
1133 static const struct file_operations seq_ns_ ##NAME ##_fops = {        \
1134         .owner          = THIS_MODULE,                                        \
1135         .open           = seq_ns_ ##NAME ##_open,                             \
1136         .read           = seq_read,                                           \
1137         .llseek         = seq_lseek,                                          \
1138         .release        = single_release,                                     \
1139 }                                                                             \
1140
1141 static int seq_ns_level_show(struct seq_file *seq, void *v)
1142 {
1143         struct aa_label *label;
1144
1145         label = begin_current_label_crit_section();
1146         seq_printf(seq, "%d\n", labels_ns(label)->level);
1147         end_current_label_crit_section(label);
1148
1149         return 0;
1150 }
1151
1152 static int seq_ns_name_show(struct seq_file *seq, void *v)
1153 {
1154         struct aa_label *label = begin_current_label_crit_section();
1155
1156         seq_printf(seq, "%s\n", aa_ns_name(labels_ns(label),
1157                                            labels_ns(label), true));
1158         end_current_label_crit_section(label);
1159
1160         return 0;
1161 }
1162
1163 SEQ_NS_FOPS(level);
1164 SEQ_NS_FOPS(name);
1165
1166
1167 /* policy/raw_data/ * file ops */
1168
1169 #define SEQ_RAWDATA_FOPS(NAME)                                                \
1170 static int seq_rawdata_ ##NAME ##_open(struct inode *inode, struct file *file)\
1171 {                                                                             \
1172         return seq_rawdata_open(inode, file, seq_rawdata_ ##NAME ##_show);    \
1173 }                                                                             \
1174                                                                               \
1175 static const struct file_operations seq_rawdata_ ##NAME ##_fops = {           \
1176         .owner          = THIS_MODULE,                                        \
1177         .open           = seq_rawdata_ ##NAME ##_open,                        \
1178         .read           = seq_read,                                           \
1179         .llseek         = seq_lseek,                                          \
1180         .release        = seq_rawdata_release,                                \
1181 }                                                                             \
1182
1183 static int seq_rawdata_open(struct inode *inode, struct file *file,
1184                             int (*show)(struct seq_file *, void *))
1185 {
1186         struct aa_loaddata *data = __aa_get_loaddata(inode->i_private);
1187         int error;
1188
1189         if (!data)
1190                 /* lost race this ent is being reaped */
1191                 return -ENOENT;
1192
1193         error = single_open(file, show, data);
1194         if (error) {
1195                 AA_BUG(file->private_data &&
1196                        ((struct seq_file *)file->private_data)->private);
1197                 aa_put_loaddata(data);
1198         }
1199
1200         return error;
1201 }
1202
1203 static int seq_rawdata_release(struct inode *inode, struct file *file)
1204 {
1205         struct seq_file *seq = (struct seq_file *) file->private_data;
1206
1207         if (seq)
1208                 aa_put_loaddata(seq->private);
1209
1210         return single_release(inode, file);
1211 }
1212
1213 static int seq_rawdata_abi_show(struct seq_file *seq, void *v)
1214 {
1215         struct aa_loaddata *data = seq->private;
1216
1217         seq_printf(seq, "v%d\n", data->abi);
1218
1219         return 0;
1220 }
1221
1222 static int seq_rawdata_revision_show(struct seq_file *seq, void *v)
1223 {
1224         struct aa_loaddata *data = seq->private;
1225
1226         seq_printf(seq, "%ld\n", data->revision);
1227
1228         return 0;
1229 }
1230
1231 static int seq_rawdata_hash_show(struct seq_file *seq, void *v)
1232 {
1233         struct aa_loaddata *data = seq->private;
1234         unsigned int i, size = aa_hash_size();
1235
1236         if (data->hash) {
1237                 for (i = 0; i < size; i++)
1238                         seq_printf(seq, "%.2x", data->hash[i]);
1239                 seq_putc(seq, '\n');
1240         }
1241
1242         return 0;
1243 }
1244
1245 SEQ_RAWDATA_FOPS(abi);
1246 SEQ_RAWDATA_FOPS(revision);
1247 SEQ_RAWDATA_FOPS(hash);
1248
1249 static ssize_t rawdata_read(struct file *file, char __user *buf, size_t size,
1250                             loff_t *ppos)
1251 {
1252         struct aa_loaddata *rawdata = file->private_data;
1253
1254         return simple_read_from_buffer(buf, size, ppos, rawdata->data,
1255                                        rawdata->size);
1256 }
1257
1258 static int rawdata_release(struct inode *inode, struct file *file)
1259 {
1260         aa_put_loaddata(file->private_data);
1261
1262         return 0;
1263 }
1264
1265 static int rawdata_open(struct inode *inode, struct file *file)
1266 {
1267         if (!policy_view_capable(NULL))
1268                 return -EACCES;
1269         file->private_data = __aa_get_loaddata(inode->i_private);
1270         if (!file->private_data)
1271                 /* lost race: this entry is being reaped */
1272                 return -ENOENT;
1273
1274         return 0;
1275 }
1276
1277 static const struct file_operations rawdata_fops = {
1278         .open = rawdata_open,
1279         .read = rawdata_read,
1280         .llseek = generic_file_llseek,
1281         .release = rawdata_release,
1282 };
1283
1284 static void remove_rawdata_dents(struct aa_loaddata *rawdata)
1285 {
1286         int i;
1287
1288         for (i = 0; i < AAFS_LOADDATA_NDENTS; i++) {
1289                 if (!IS_ERR_OR_NULL(rawdata->dents[i])) {
1290                         /* no refcounts on i_private */
1291                         aafs_remove(rawdata->dents[i]);
1292                         rawdata->dents[i] = NULL;
1293                 }
1294         }
1295 }
1296
1297 void __aa_fs_remove_rawdata(struct aa_loaddata *rawdata)
1298 {
1299         AA_BUG(rawdata->ns && !mutex_is_locked(&rawdata->ns->lock));
1300
1301         if (rawdata->ns) {
1302                 remove_rawdata_dents(rawdata);
1303                 list_del_init(&rawdata->list);
1304                 aa_put_ns(rawdata->ns);
1305                 rawdata->ns = NULL;
1306         }
1307 }
1308
1309 int __aa_fs_create_rawdata(struct aa_ns *ns, struct aa_loaddata *rawdata)
1310 {
1311         struct dentry *dent, *dir;
1312
1313         AA_BUG(!ns);
1314         AA_BUG(!rawdata);
1315         AA_BUG(!mutex_is_locked(&ns->lock));
1316         AA_BUG(!ns_subdata_dir(ns));
1317
1318         /*
1319          * just use ns revision dir was originally created at. This is
1320          * under ns->lock and if load is successful revision will be
1321          * bumped and is guaranteed to be unique
1322          */
1323         rawdata->name = kasprintf(GFP_KERNEL, "%ld", ns->revision);
1324         if (!rawdata->name)
1325                 return -ENOMEM;
1326
1327         dir = aafs_create_dir(rawdata->name, ns_subdata_dir(ns));
1328         if (IS_ERR(dir))
1329                 /* ->name freed when rawdata freed */
1330                 return PTR_ERR(dir);
1331         rawdata->dents[AAFS_LOADDATA_DIR] = dir;
1332
1333         dent = aafs_create_file("abi", S_IFREG | 0444, dir, rawdata,
1334                                       &seq_rawdata_abi_fops);
1335         if (IS_ERR(dent))
1336                 goto fail;
1337         rawdata->dents[AAFS_LOADDATA_ABI] = dent;
1338
1339         dent = aafs_create_file("revision", S_IFREG | 0444, dir, rawdata,
1340                                       &seq_rawdata_revision_fops);
1341         if (IS_ERR(dent))
1342                 goto fail;
1343         rawdata->dents[AAFS_LOADDATA_REVISION] = dent;
1344
1345         if (aa_g_hash_policy) {
1346                 dent = aafs_create_file("sha1", S_IFREG | 0444, dir,
1347                                               rawdata, &seq_rawdata_hash_fops);
1348                 if (IS_ERR(dent))
1349                         goto fail;
1350                 rawdata->dents[AAFS_LOADDATA_HASH] = dent;
1351         }
1352
1353         dent = aafs_create_file("raw_data", S_IFREG | 0444,
1354                                       dir, rawdata, &rawdata_fops);
1355         if (IS_ERR(dent))
1356                 goto fail;
1357         rawdata->dents[AAFS_LOADDATA_DATA] = dent;
1358         d_inode(dent)->i_size = rawdata->size;
1359
1360         rawdata->ns = aa_get_ns(ns);
1361         list_add(&rawdata->list, &ns->rawdata_list);
1362         /* no refcount on inode rawdata */
1363
1364         return 0;
1365
1366 fail:
1367         remove_rawdata_dents(rawdata);
1368
1369         return PTR_ERR(dent);
1370 }
1371
1372 /** fns to setup dynamic per profile/namespace files **/
1373
1374 /**
1375  *
1376  * Requires: @profile->ns->lock held
1377  */
1378 void __aafs_profile_rmdir(struct aa_profile *profile)
1379 {
1380         struct aa_profile *child;
1381         int i;
1382
1383         if (!profile)
1384                 return;
1385
1386         list_for_each_entry(child, &profile->base.profiles, base.list)
1387                 __aafs_profile_rmdir(child);
1388
1389         for (i = AAFS_PROF_SIZEOF - 1; i >= 0; --i) {
1390                 struct aa_proxy *proxy;
1391                 if (!profile->dents[i])
1392                         continue;
1393
1394                 proxy = d_inode(profile->dents[i])->i_private;
1395                 aafs_remove(profile->dents[i]);
1396                 aa_put_proxy(proxy);
1397                 profile->dents[i] = NULL;
1398         }
1399 }
1400
1401 /**
1402  *
1403  * Requires: @old->ns->lock held
1404  */
1405 void __aafs_profile_migrate_dents(struct aa_profile *old,
1406                                   struct aa_profile *new)
1407 {
1408         int i;
1409
1410         for (i = 0; i < AAFS_PROF_SIZEOF; i++) {
1411                 new->dents[i] = old->dents[i];
1412                 if (new->dents[i])
1413                         new->dents[i]->d_inode->i_mtime = current_time(new->dents[i]->d_inode);
1414                 old->dents[i] = NULL;
1415         }
1416 }
1417
1418 static struct dentry *create_profile_file(struct dentry *dir, const char *name,
1419                                           struct aa_profile *profile,
1420                                           const struct file_operations *fops)
1421 {
1422         struct aa_proxy *proxy = aa_get_proxy(profile->label.proxy);
1423         struct dentry *dent;
1424
1425         dent = aafs_create_file(name, S_IFREG | 0444, dir, proxy, fops);
1426         if (IS_ERR(dent))
1427                 aa_put_proxy(proxy);
1428
1429         return dent;
1430 }
1431
1432 static int profile_depth(struct aa_profile *profile)
1433 {
1434         int depth = 0;
1435
1436         rcu_read_lock();
1437         for (depth = 0; profile; profile = rcu_access_pointer(profile->parent))
1438                 depth++;
1439         rcu_read_unlock();
1440
1441         return depth;
1442 }
1443
1444 static int gen_symlink_name(char *buffer, size_t bsize, int depth,
1445                             const char *dirname, const char *fname)
1446 {
1447         int error;
1448
1449         for (; depth > 0; depth--) {
1450                 if (bsize < 7)
1451                         return -ENAMETOOLONG;
1452                 strcpy(buffer, "../../");
1453                 buffer += 6;
1454                 bsize -= 6;
1455         }
1456
1457         error = snprintf(buffer, bsize, "raw_data/%s/%s", dirname, fname);
1458         if (error >= bsize || error < 0)
1459                 return -ENAMETOOLONG;
1460
1461         return 0;
1462 }
1463
1464 /*
1465  * Requires: @profile->ns->lock held
1466  */
1467 int __aafs_profile_mkdir(struct aa_profile *profile, struct dentry *parent)
1468 {
1469         struct aa_profile *child;
1470         struct dentry *dent = NULL, *dir;
1471         int error;
1472
1473         if (!parent) {
1474                 struct aa_profile *p;
1475                 p = aa_deref_parent(profile);
1476                 dent = prof_dir(p);
1477                 /* adding to parent that previously didn't have children */
1478                 dent = aafs_create_dir("profiles", dent);
1479                 if (IS_ERR(dent))
1480                         goto fail;
1481                 prof_child_dir(p) = parent = dent;
1482         }
1483
1484         if (!profile->dirname) {
1485                 int len, id_len;
1486                 len = mangle_name(profile->base.name, NULL);
1487                 id_len = snprintf(NULL, 0, ".%ld", profile->ns->uniq_id);
1488
1489                 profile->dirname = kmalloc(len + id_len + 1, GFP_KERNEL);
1490                 if (!profile->dirname) {
1491                         error = -ENOMEM;
1492                         goto fail2;
1493                 }
1494
1495                 mangle_name(profile->base.name, profile->dirname);
1496                 sprintf(profile->dirname + len, ".%ld", profile->ns->uniq_id++);
1497         }
1498
1499         dent = aafs_create_dir(profile->dirname, parent);
1500         if (IS_ERR(dent))
1501                 goto fail;
1502         prof_dir(profile) = dir = dent;
1503
1504         dent = create_profile_file(dir, "name", profile,
1505                                    &seq_profile_name_fops);
1506         if (IS_ERR(dent))
1507                 goto fail;
1508         profile->dents[AAFS_PROF_NAME] = dent;
1509
1510         dent = create_profile_file(dir, "mode", profile,
1511                                    &seq_profile_mode_fops);
1512         if (IS_ERR(dent))
1513                 goto fail;
1514         profile->dents[AAFS_PROF_MODE] = dent;
1515
1516         dent = create_profile_file(dir, "attach", profile,
1517                                    &seq_profile_attach_fops);
1518         if (IS_ERR(dent))
1519                 goto fail;
1520         profile->dents[AAFS_PROF_ATTACH] = dent;
1521
1522         if (profile->hash) {
1523                 dent = create_profile_file(dir, "sha1", profile,
1524                                            &seq_profile_hash_fops);
1525                 if (IS_ERR(dent))
1526                         goto fail;
1527                 profile->dents[AAFS_PROF_HASH] = dent;
1528         }
1529
1530         if (profile->rawdata) {
1531                 char target[64];
1532                 int depth = profile_depth(profile);
1533
1534                 error = gen_symlink_name(target, sizeof(target), depth,
1535                                          profile->rawdata->name, "sha1");
1536                 if (error < 0)
1537                         goto fail2;
1538                 dent = aafs_create_symlink("raw_sha1", dir, target, NULL);
1539                 if (IS_ERR(dent))
1540                         goto fail;
1541                 profile->dents[AAFS_PROF_RAW_HASH] = dent;
1542
1543                 error = gen_symlink_name(target, sizeof(target), depth,
1544                                          profile->rawdata->name, "abi");
1545                 if (error < 0)
1546                         goto fail2;
1547                 dent = aafs_create_symlink("raw_abi", dir, target, NULL);
1548                 if (IS_ERR(dent))
1549                         goto fail;
1550                 profile->dents[AAFS_PROF_RAW_ABI] = dent;
1551
1552                 error = gen_symlink_name(target, sizeof(target), depth,
1553                                          profile->rawdata->name, "raw_data");
1554                 if (error < 0)
1555                         goto fail2;
1556                 dent = aafs_create_symlink("raw_data", dir, target, NULL);
1557                 if (IS_ERR(dent))
1558                         goto fail;
1559                 profile->dents[AAFS_PROF_RAW_DATA] = dent;
1560         }
1561
1562         list_for_each_entry(child, &profile->base.profiles, base.list) {
1563                 error = __aafs_profile_mkdir(child, prof_child_dir(profile));
1564                 if (error)
1565                         goto fail2;
1566         }
1567
1568         return 0;
1569
1570 fail:
1571         error = PTR_ERR(dent);
1572
1573 fail2:
1574         __aafs_profile_rmdir(profile);
1575
1576         return error;
1577 }
1578
1579 static int ns_mkdir_op(struct inode *dir, struct dentry *dentry, umode_t mode)
1580 {
1581         struct aa_ns *ns, *parent;
1582         /* TODO: improve permission check */
1583         struct aa_label *label;
1584         int error;
1585
1586         label = begin_current_label_crit_section();
1587         error = aa_may_manage_policy(label, NULL, AA_MAY_LOAD_POLICY);
1588         end_current_label_crit_section(label);
1589         if (error)
1590                 return error;
1591
1592         parent = aa_get_ns(dir->i_private);
1593         AA_BUG(d_inode(ns_subns_dir(parent)) != dir);
1594
1595         /* we have to unlock and then relock to get locking order right
1596          * for pin_fs
1597          */
1598         inode_unlock(dir);
1599         error = simple_pin_fs(&aafs_ops, &aafs_mnt, &aafs_count);
1600         mutex_lock(&parent->lock);
1601         inode_lock_nested(dir, I_MUTEX_PARENT);
1602         if (error)
1603                 goto out;
1604
1605         error = __aafs_setup_d_inode(dir, dentry, mode | S_IFDIR,  NULL,
1606                                      NULL, NULL, NULL);
1607         if (error)
1608                 goto out_pin;
1609
1610         ns = __aa_find_or_create_ns(parent, READ_ONCE(dentry->d_name.name),
1611                                     dentry);
1612         if (IS_ERR(ns)) {
1613                 error = PTR_ERR(ns);
1614                 ns = NULL;
1615         }
1616
1617         aa_put_ns(ns);          /* list ref remains */
1618 out_pin:
1619         if (error)
1620                 simple_release_fs(&aafs_mnt, &aafs_count);
1621 out:
1622         mutex_unlock(&parent->lock);
1623         aa_put_ns(parent);
1624
1625         return error;
1626 }
1627
1628 static int ns_rmdir_op(struct inode *dir, struct dentry *dentry)
1629 {
1630         struct aa_ns *ns, *parent;
1631         /* TODO: improve permission check */
1632         struct aa_label *label;
1633         int error;
1634
1635         label = begin_current_label_crit_section();
1636         error = aa_may_manage_policy(label, NULL, AA_MAY_LOAD_POLICY);
1637         end_current_label_crit_section(label);
1638         if (error)
1639                 return error;
1640
1641          parent = aa_get_ns(dir->i_private);
1642         /* rmdir calls the generic securityfs functions to remove files
1643          * from the apparmor dir. It is up to the apparmor ns locking
1644          * to avoid races.
1645          */
1646         inode_unlock(dir);
1647         inode_unlock(dentry->d_inode);
1648
1649         mutex_lock(&parent->lock);
1650         ns = aa_get_ns(__aa_findn_ns(&parent->sub_ns, dentry->d_name.name,
1651                                      dentry->d_name.len));
1652         if (!ns) {
1653                 error = -ENOENT;
1654                 goto out;
1655         }
1656         AA_BUG(ns_dir(ns) != dentry);
1657
1658         __aa_remove_ns(ns);
1659         aa_put_ns(ns);
1660
1661 out:
1662         mutex_unlock(&parent->lock);
1663         inode_lock_nested(dir, I_MUTEX_PARENT);
1664         inode_lock(dentry->d_inode);
1665         aa_put_ns(parent);
1666
1667         return error;
1668 }
1669
1670 static const struct inode_operations ns_dir_inode_operations = {
1671         .lookup         = simple_lookup,
1672         .mkdir          = ns_mkdir_op,
1673         .rmdir          = ns_rmdir_op,
1674 };
1675
1676 static void __aa_fs_list_remove_rawdata(struct aa_ns *ns)
1677 {
1678         struct aa_loaddata *ent, *tmp;
1679
1680         AA_BUG(!mutex_is_locked(&ns->lock));
1681
1682         list_for_each_entry_safe(ent, tmp, &ns->rawdata_list, list)
1683                 __aa_fs_remove_rawdata(ent);
1684 }
1685
1686 /**
1687  *
1688  * Requires: @ns->lock held
1689  */
1690 void __aafs_ns_rmdir(struct aa_ns *ns)
1691 {
1692         struct aa_ns *sub;
1693         struct aa_profile *child;
1694         int i;
1695
1696         if (!ns)
1697                 return;
1698
1699         list_for_each_entry(child, &ns->base.profiles, base.list)
1700                 __aafs_profile_rmdir(child);
1701
1702         list_for_each_entry(sub, &ns->sub_ns, base.list) {
1703                 mutex_lock(&sub->lock);
1704                 __aafs_ns_rmdir(sub);
1705                 mutex_unlock(&sub->lock);
1706         }
1707
1708         __aa_fs_list_remove_rawdata(ns);
1709
1710         if (ns_subns_dir(ns)) {
1711                 sub = d_inode(ns_subns_dir(ns))->i_private;
1712                 aa_put_ns(sub);
1713         }
1714         if (ns_subload(ns)) {
1715                 sub = d_inode(ns_subload(ns))->i_private;
1716                 aa_put_ns(sub);
1717         }
1718         if (ns_subreplace(ns)) {
1719                 sub = d_inode(ns_subreplace(ns))->i_private;
1720                 aa_put_ns(sub);
1721         }
1722         if (ns_subremove(ns)) {
1723                 sub = d_inode(ns_subremove(ns))->i_private;
1724                 aa_put_ns(sub);
1725         }
1726         if (ns_subrevision(ns)) {
1727                 sub = d_inode(ns_subrevision(ns))->i_private;
1728                 aa_put_ns(sub);
1729         }
1730
1731         for (i = AAFS_NS_SIZEOF - 1; i >= 0; --i) {
1732                 aafs_remove(ns->dents[i]);
1733                 ns->dents[i] = NULL;
1734         }
1735 }
1736
1737 /* assumes cleanup in caller */
1738 static int __aafs_ns_mkdir_entries(struct aa_ns *ns, struct dentry *dir)
1739 {
1740         struct dentry *dent;
1741
1742         AA_BUG(!ns);
1743         AA_BUG(!dir);
1744
1745         dent = aafs_create_dir("profiles", dir);
1746         if (IS_ERR(dent))
1747                 return PTR_ERR(dent);
1748         ns_subprofs_dir(ns) = dent;
1749
1750         dent = aafs_create_dir("raw_data", dir);
1751         if (IS_ERR(dent))
1752                 return PTR_ERR(dent);
1753         ns_subdata_dir(ns) = dent;
1754
1755         dent = aafs_create_file("revision", 0444, dir, ns,
1756                                 &aa_fs_ns_revision_fops);
1757         if (IS_ERR(dent))
1758                 return PTR_ERR(dent);
1759         aa_get_ns(ns);
1760         ns_subrevision(ns) = dent;
1761
1762         dent = aafs_create_file(".load", 0640, dir, ns,
1763                                       &aa_fs_profile_load);
1764         if (IS_ERR(dent))
1765                 return PTR_ERR(dent);
1766         aa_get_ns(ns);
1767         ns_subload(ns) = dent;
1768
1769         dent = aafs_create_file(".replace", 0640, dir, ns,
1770                                       &aa_fs_profile_replace);
1771         if (IS_ERR(dent))
1772                 return PTR_ERR(dent);
1773         aa_get_ns(ns);
1774         ns_subreplace(ns) = dent;
1775
1776         dent = aafs_create_file(".remove", 0640, dir, ns,
1777                                       &aa_fs_profile_remove);
1778         if (IS_ERR(dent))
1779                 return PTR_ERR(dent);
1780         aa_get_ns(ns);
1781         ns_subremove(ns) = dent;
1782
1783           /* use create_dentry so we can supply private data */
1784         dent = aafs_create("namespaces", S_IFDIR | 0755, dir, ns, NULL, NULL,
1785                            &ns_dir_inode_operations);
1786         if (IS_ERR(dent))
1787                 return PTR_ERR(dent);
1788         aa_get_ns(ns);
1789         ns_subns_dir(ns) = dent;
1790
1791         return 0;
1792 }
1793
1794 /*
1795  * Requires: @ns->lock held
1796  */
1797 int __aafs_ns_mkdir(struct aa_ns *ns, struct dentry *parent, const char *name,
1798                     struct dentry *dent)
1799 {
1800         struct aa_ns *sub;
1801         struct aa_profile *child;
1802         struct dentry *dir;
1803         int error;
1804
1805         AA_BUG(!ns);
1806         AA_BUG(!parent);
1807         AA_BUG(!mutex_is_locked(&ns->lock));
1808
1809         if (!name)
1810                 name = ns->base.name;
1811
1812         if (!dent) {
1813                 /* create ns dir if it doesn't already exist */
1814                 dent = aafs_create_dir(name, parent);
1815                 if (IS_ERR(dent))
1816                         goto fail;
1817         } else
1818                 dget(dent);
1819         ns_dir(ns) = dir = dent;
1820         error = __aafs_ns_mkdir_entries(ns, dir);
1821         if (error)
1822                 goto fail2;
1823
1824         /* profiles */
1825         list_for_each_entry(child, &ns->base.profiles, base.list) {
1826                 error = __aafs_profile_mkdir(child, ns_subprofs_dir(ns));
1827                 if (error)
1828                         goto fail2;
1829         }
1830
1831         /* subnamespaces */
1832         list_for_each_entry(sub, &ns->sub_ns, base.list) {
1833                 mutex_lock(&sub->lock);
1834                 error = __aafs_ns_mkdir(sub, ns_subns_dir(ns), NULL, NULL);
1835                 mutex_unlock(&sub->lock);
1836                 if (error)
1837                         goto fail2;
1838         }
1839
1840         return 0;
1841
1842 fail:
1843         error = PTR_ERR(dent);
1844
1845 fail2:
1846         __aafs_ns_rmdir(ns);
1847
1848         return error;
1849 }
1850
1851
1852 #define list_entry_is_head(pos, head, member) (&pos->member == (head))
1853
1854 /**
1855  * __next_ns - find the next namespace to list
1856  * @root: root namespace to stop search at (NOT NULL)
1857  * @ns: current ns position (NOT NULL)
1858  *
1859  * Find the next namespace from @ns under @root and handle all locking needed
1860  * while switching current namespace.
1861  *
1862  * Returns: next namespace or NULL if at last namespace under @root
1863  * Requires: ns->parent->lock to be held
1864  * NOTE: will not unlock root->lock
1865  */
1866 static struct aa_ns *__next_ns(struct aa_ns *root, struct aa_ns *ns)
1867 {
1868         struct aa_ns *parent, *next;
1869
1870         /* is next namespace a child */
1871         if (!list_empty(&ns->sub_ns)) {
1872                 next = list_first_entry(&ns->sub_ns, typeof(*ns), base.list);
1873                 mutex_lock(&next->lock);
1874                 return next;
1875         }
1876
1877         /* check if the next ns is a sibling, parent, gp, .. */
1878         parent = ns->parent;
1879         while (ns != root) {
1880                 mutex_unlock(&ns->lock);
1881                 next = list_next_entry(ns, base.list);
1882                 if (!list_entry_is_head(next, &parent->sub_ns, base.list)) {
1883                         mutex_lock(&next->lock);
1884                         return next;
1885                 }
1886                 ns = parent;
1887                 parent = parent->parent;
1888         }
1889
1890         return NULL;
1891 }
1892
1893 /**
1894  * __first_profile - find the first profile in a namespace
1895  * @root: namespace that is root of profiles being displayed (NOT NULL)
1896  * @ns: namespace to start in   (NOT NULL)
1897  *
1898  * Returns: unrefcounted profile or NULL if no profile
1899  * Requires: profile->ns.lock to be held
1900  */
1901 static struct aa_profile *__first_profile(struct aa_ns *root,
1902                                           struct aa_ns *ns)
1903 {
1904         for (; ns; ns = __next_ns(root, ns)) {
1905                 if (!list_empty(&ns->base.profiles))
1906                         return list_first_entry(&ns->base.profiles,
1907                                                 struct aa_profile, base.list);
1908         }
1909         return NULL;
1910 }
1911
1912 /**
1913  * __next_profile - step to the next profile in a profile tree
1914  * @profile: current profile in tree (NOT NULL)
1915  *
1916  * Perform a depth first traversal on the profile tree in a namespace
1917  *
1918  * Returns: next profile or NULL if done
1919  * Requires: profile->ns.lock to be held
1920  */
1921 static struct aa_profile *__next_profile(struct aa_profile *p)
1922 {
1923         struct aa_profile *parent;
1924         struct aa_ns *ns = p->ns;
1925
1926         /* is next profile a child */
1927         if (!list_empty(&p->base.profiles))
1928                 return list_first_entry(&p->base.profiles, typeof(*p),
1929                                         base.list);
1930
1931         /* is next profile a sibling, parent sibling, gp, sibling, .. */
1932         parent = rcu_dereference_protected(p->parent,
1933                                            mutex_is_locked(&p->ns->lock));
1934         while (parent) {
1935                 p = list_next_entry(p, base.list);
1936                 if (!list_entry_is_head(p, &parent->base.profiles, base.list))
1937                         return p;
1938                 p = parent;
1939                 parent = rcu_dereference_protected(parent->parent,
1940                                             mutex_is_locked(&parent->ns->lock));
1941         }
1942
1943         /* is next another profile in the namespace */
1944         p = list_next_entry(p, base.list);
1945         if (!list_entry_is_head(p, &ns->base.profiles, base.list))
1946                 return p;
1947
1948         return NULL;
1949 }
1950
1951 /**
1952  * next_profile - step to the next profile in where ever it may be
1953  * @root: root namespace  (NOT NULL)
1954  * @profile: current profile  (NOT NULL)
1955  *
1956  * Returns: next profile or NULL if there isn't one
1957  */
1958 static struct aa_profile *next_profile(struct aa_ns *root,
1959                                        struct aa_profile *profile)
1960 {
1961         struct aa_profile *next = __next_profile(profile);
1962         if (next)
1963                 return next;
1964
1965         /* finished all profiles in namespace move to next namespace */
1966         return __first_profile(root, __next_ns(root, profile->ns));
1967 }
1968
1969 /**
1970  * p_start - start a depth first traversal of profile tree
1971  * @f: seq_file to fill
1972  * @pos: current position
1973  *
1974  * Returns: first profile under current namespace or NULL if none found
1975  *
1976  * acquires first ns->lock
1977  */
1978 static void *p_start(struct seq_file *f, loff_t *pos)
1979 {
1980         struct aa_profile *profile = NULL;
1981         struct aa_ns *root = aa_get_current_ns();
1982         loff_t l = *pos;
1983         f->private = root;
1984
1985         /* find the first profile */
1986         mutex_lock(&root->lock);
1987         profile = __first_profile(root, root);
1988
1989         /* skip to position */
1990         for (; profile && l > 0; l--)
1991                 profile = next_profile(root, profile);
1992
1993         return profile;
1994 }
1995
1996 /**
1997  * p_next - read the next profile entry
1998  * @f: seq_file to fill
1999  * @p: profile previously returned
2000  * @pos: current position
2001  *
2002  * Returns: next profile after @p or NULL if none
2003  *
2004  * may acquire/release locks in namespace tree as necessary
2005  */
2006 static void *p_next(struct seq_file *f, void *p, loff_t *pos)
2007 {
2008         struct aa_profile *profile = p;
2009         struct aa_ns *ns = f->private;
2010         (*pos)++;
2011
2012         return next_profile(ns, profile);
2013 }
2014
2015 /**
2016  * p_stop - stop depth first traversal
2017  * @f: seq_file we are filling
2018  * @p: the last profile writen
2019  *
2020  * Release all locking done by p_start/p_next on namespace tree
2021  */
2022 static void p_stop(struct seq_file *f, void *p)
2023 {
2024         struct aa_profile *profile = p;
2025         struct aa_ns *root = f->private, *ns;
2026
2027         if (profile) {
2028                 for (ns = profile->ns; ns && ns != root; ns = ns->parent)
2029                         mutex_unlock(&ns->lock);
2030         }
2031         mutex_unlock(&root->lock);
2032         aa_put_ns(root);
2033 }
2034
2035 /**
2036  * seq_show_profile - show a profile entry
2037  * @f: seq_file to file
2038  * @p: current position (profile)    (NOT NULL)
2039  *
2040  * Returns: error on failure
2041  */
2042 static int seq_show_profile(struct seq_file *f, void *p)
2043 {
2044         struct aa_profile *profile = (struct aa_profile *)p;
2045         struct aa_ns *root = f->private;
2046
2047         aa_label_seq_xprint(f, root, &profile->label,
2048                             FLAG_SHOW_MODE | FLAG_VIEW_SUBNS, GFP_KERNEL);
2049         seq_putc(f, '\n');
2050
2051         return 0;
2052 }
2053
2054 static const struct seq_operations aa_sfs_profiles_op = {
2055         .start = p_start,
2056         .next = p_next,
2057         .stop = p_stop,
2058         .show = seq_show_profile,
2059 };
2060
2061 static int profiles_open(struct inode *inode, struct file *file)
2062 {
2063         if (!policy_view_capable(NULL))
2064                 return -EACCES;
2065
2066         return seq_open(file, &aa_sfs_profiles_op);
2067 }
2068
2069 static int profiles_release(struct inode *inode, struct file *file)
2070 {
2071         return seq_release(inode, file);
2072 }
2073
2074 static const struct file_operations aa_sfs_profiles_fops = {
2075         .open = profiles_open,
2076         .read = seq_read,
2077         .llseek = seq_lseek,
2078         .release = profiles_release,
2079 };
2080
2081
2082 /** Base file system setup **/
2083 static struct aa_sfs_entry aa_sfs_entry_file[] = {
2084         AA_SFS_FILE_STRING("mask",
2085                            "create read write exec append mmap_exec link lock"),
2086         { }
2087 };
2088
2089 static struct aa_sfs_entry aa_sfs_entry_ptrace[] = {
2090         AA_SFS_FILE_STRING("mask", "read trace"),
2091         { }
2092 };
2093
2094 static struct aa_sfs_entry aa_sfs_entry_domain[] = {
2095         AA_SFS_FILE_BOOLEAN("change_hat",       1),
2096         AA_SFS_FILE_BOOLEAN("change_hatv",      1),
2097         AA_SFS_FILE_BOOLEAN("change_onexec",    1),
2098         AA_SFS_FILE_BOOLEAN("change_profile",   1),
2099         AA_SFS_FILE_BOOLEAN("fix_binfmt_elf_mmap",      1),
2100         AA_SFS_FILE_STRING("version", "1.2"),
2101         { }
2102 };
2103
2104 static struct aa_sfs_entry aa_sfs_entry_versions[] = {
2105         AA_SFS_FILE_BOOLEAN("v5",       1),
2106         { }
2107 };
2108
2109 static struct aa_sfs_entry aa_sfs_entry_policy[] = {
2110         AA_SFS_DIR("versions",                  aa_sfs_entry_versions),
2111         AA_SFS_FILE_BOOLEAN("set_load",         1),
2112         { }
2113 };
2114
2115 static struct aa_sfs_entry aa_sfs_entry_query_label[] = {
2116         AA_SFS_FILE_STRING("perms", "allow deny audit quiet"),
2117         AA_SFS_FILE_BOOLEAN("data",             1),
2118         AA_SFS_FILE_BOOLEAN("multi_transaction",        1),
2119         { }
2120 };
2121
2122 static struct aa_sfs_entry aa_sfs_entry_query[] = {
2123         AA_SFS_DIR("label",                     aa_sfs_entry_query_label),
2124         { }
2125 };
2126 static struct aa_sfs_entry aa_sfs_entry_features[] = {
2127         AA_SFS_DIR("policy",                    aa_sfs_entry_policy),
2128         AA_SFS_DIR("domain",                    aa_sfs_entry_domain),
2129         AA_SFS_DIR("file",                      aa_sfs_entry_file),
2130         AA_SFS_FILE_U64("capability",           VFS_CAP_FLAGS_MASK),
2131         AA_SFS_DIR("rlimit",                    aa_sfs_entry_rlimit),
2132         AA_SFS_DIR("caps",                      aa_sfs_entry_caps),
2133         AA_SFS_DIR("ptrace",                    aa_sfs_entry_ptrace),
2134         AA_SFS_DIR("query",                     aa_sfs_entry_query),
2135         { }
2136 };
2137
2138 static struct aa_sfs_entry aa_sfs_entry_apparmor[] = {
2139         AA_SFS_FILE_FOPS(".access", 0640, &aa_sfs_access),
2140         AA_SFS_FILE_FOPS(".ns_level", 0666, &seq_ns_level_fops),
2141         AA_SFS_FILE_FOPS(".ns_name", 0640, &seq_ns_name_fops),
2142         AA_SFS_FILE_FOPS("profiles", 0440, &aa_sfs_profiles_fops),
2143         AA_SFS_DIR("features", aa_sfs_entry_features),
2144         { }
2145 };
2146
2147 static struct aa_sfs_entry aa_sfs_entry =
2148         AA_SFS_DIR("apparmor", aa_sfs_entry_apparmor);
2149
2150 /**
2151  * entry_create_file - create a file entry in the apparmor securityfs
2152  * @fs_file: aa_sfs_entry to build an entry for (NOT NULL)
2153  * @parent: the parent dentry in the securityfs
2154  *
2155  * Use entry_remove_file to remove entries created with this fn.
2156  */
2157 static int __init entry_create_file(struct aa_sfs_entry *fs_file,
2158                                     struct dentry *parent)
2159 {
2160         int error = 0;
2161
2162         fs_file->dentry = securityfs_create_file(fs_file->name,
2163                                                  S_IFREG | fs_file->mode,
2164                                                  parent, fs_file,
2165                                                  fs_file->file_ops);
2166         if (IS_ERR(fs_file->dentry)) {
2167                 error = PTR_ERR(fs_file->dentry);
2168                 fs_file->dentry = NULL;
2169         }
2170         return error;
2171 }
2172
2173 static void __init entry_remove_dir(struct aa_sfs_entry *fs_dir);
2174 /**
2175  * entry_create_dir - recursively create a directory entry in the securityfs
2176  * @fs_dir: aa_sfs_entry (and all child entries) to build (NOT NULL)
2177  * @parent: the parent dentry in the securityfs
2178  *
2179  * Use entry_remove_dir to remove entries created with this fn.
2180  */
2181 static int __init entry_create_dir(struct aa_sfs_entry *fs_dir,
2182                                    struct dentry *parent)
2183 {
2184         struct aa_sfs_entry *fs_file;
2185         struct dentry *dir;
2186         int error;
2187
2188         dir = securityfs_create_dir(fs_dir->name, parent);
2189         if (IS_ERR(dir))
2190                 return PTR_ERR(dir);
2191         fs_dir->dentry = dir;
2192
2193         for (fs_file = fs_dir->v.files; fs_file && fs_file->name; ++fs_file) {
2194                 if (fs_file->v_type == AA_SFS_TYPE_DIR)
2195                         error = entry_create_dir(fs_file, fs_dir->dentry);
2196                 else
2197                         error = entry_create_file(fs_file, fs_dir->dentry);
2198                 if (error)
2199                         goto failed;
2200         }
2201
2202         return 0;
2203
2204 failed:
2205         entry_remove_dir(fs_dir);
2206
2207         return error;
2208 }
2209
2210 /**
2211  * entry_remove_file - drop a single file entry in the apparmor securityfs
2212  * @fs_file: aa_sfs_entry to detach from the securityfs (NOT NULL)
2213  */
2214 static void __init entry_remove_file(struct aa_sfs_entry *fs_file)
2215 {
2216         if (!fs_file->dentry)
2217                 return;
2218
2219         securityfs_remove(fs_file->dentry);
2220         fs_file->dentry = NULL;
2221 }
2222
2223 /**
2224  * entry_remove_dir - recursively drop a directory entry from the securityfs
2225  * @fs_dir: aa_sfs_entry (and all child entries) to detach (NOT NULL)
2226  */
2227 static void __init entry_remove_dir(struct aa_sfs_entry *fs_dir)
2228 {
2229         struct aa_sfs_entry *fs_file;
2230
2231         for (fs_file = fs_dir->v.files; fs_file && fs_file->name; ++fs_file) {
2232                 if (fs_file->v_type == AA_SFS_TYPE_DIR)
2233                         entry_remove_dir(fs_file);
2234                 else
2235                         entry_remove_file(fs_file);
2236         }
2237
2238         entry_remove_file(fs_dir);
2239 }
2240
2241 /**
2242  * aa_destroy_aafs - cleanup and free aafs
2243  *
2244  * releases dentries allocated by aa_create_aafs
2245  */
2246 void __init aa_destroy_aafs(void)
2247 {
2248         entry_remove_dir(&aa_sfs_entry);
2249 }
2250
2251
2252 #define NULL_FILE_NAME ".null"
2253 struct path aa_null;
2254
2255 static int aa_mk_null_file(struct dentry *parent)
2256 {
2257         struct vfsmount *mount = NULL;
2258         struct dentry *dentry;
2259         struct inode *inode;
2260         int count = 0;
2261         int error = simple_pin_fs(parent->d_sb->s_type, &mount, &count);
2262
2263         if (error)
2264                 return error;
2265
2266         inode_lock(d_inode(parent));
2267         dentry = lookup_one_len(NULL_FILE_NAME, parent, strlen(NULL_FILE_NAME));
2268         if (IS_ERR(dentry)) {
2269                 error = PTR_ERR(dentry);
2270                 goto out;
2271         }
2272         inode = new_inode(parent->d_inode->i_sb);
2273         if (!inode) {
2274                 error = -ENOMEM;
2275                 goto out1;
2276         }
2277
2278         inode->i_ino = get_next_ino();
2279         inode->i_mode = S_IFCHR | S_IRUGO | S_IWUGO;
2280         inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
2281         init_special_inode(inode, S_IFCHR | S_IRUGO | S_IWUGO,
2282                            MKDEV(MEM_MAJOR, 3));
2283         d_instantiate(dentry, inode);
2284         aa_null.dentry = dget(dentry);
2285         aa_null.mnt = mntget(mount);
2286
2287         error = 0;
2288
2289 out1:
2290         dput(dentry);
2291 out:
2292         inode_unlock(d_inode(parent));
2293         simple_release_fs(&mount, &count);
2294         return error;
2295 }
2296
2297
2298
2299 static const char *policy_get_link(struct dentry *dentry,
2300                                    struct inode *inode,
2301                                    struct delayed_call *done)
2302 {
2303         struct aa_ns *ns;
2304         struct path path;
2305
2306         if (!dentry)
2307                 return ERR_PTR(-ECHILD);
2308         ns = aa_get_current_ns();
2309         path.mnt = mntget(aafs_mnt);
2310         path.dentry = dget(ns_dir(ns));
2311         nd_jump_link(&path);
2312         aa_put_ns(ns);
2313
2314         return NULL;
2315 }
2316
2317 static int ns_get_name(char *buf, size_t size, struct aa_ns *ns,
2318                        struct inode *inode)
2319 {
2320         int res = snprintf(buf, size, "%s:[%lu]", AAFS_NAME, inode->i_ino);
2321
2322         if (res < 0 || res >= size)
2323                 res = -ENOENT;
2324
2325         return res;
2326 }
2327
2328 static int policy_readlink(struct dentry *dentry, char __user *buffer,
2329                            int buflen)
2330 {
2331         struct aa_ns *ns;
2332         char name[32];
2333         int res;
2334
2335         ns = aa_get_current_ns();
2336         res = ns_get_name(name, sizeof(name), ns, d_inode(dentry));
2337         if (res >= 0)
2338                 res = readlink_copy(buffer, buflen, name);
2339         aa_put_ns(ns);
2340
2341         return res;
2342 }
2343
2344 static const struct inode_operations policy_link_iops = {
2345         .readlink       = policy_readlink,
2346         .get_link       = policy_get_link,
2347 };
2348
2349
2350 /**
2351  * aa_create_aafs - create the apparmor security filesystem
2352  *
2353  * dentries created here are released by aa_destroy_aafs
2354  *
2355  * Returns: error on failure
2356  */
2357 static int __init aa_create_aafs(void)
2358 {
2359         struct dentry *dent;
2360         int error;
2361
2362         if (!apparmor_initialized)
2363                 return 0;
2364
2365         if (aa_sfs_entry.dentry) {
2366                 AA_ERROR("%s: AppArmor securityfs already exists\n", __func__);
2367                 return -EEXIST;
2368         }
2369
2370         /* setup apparmorfs used to virtualize policy/ */
2371         aafs_mnt = kern_mount(&aafs_ops);
2372         if (IS_ERR(aafs_mnt))
2373                 panic("can't set apparmorfs up\n");
2374         aafs_mnt->mnt_sb->s_flags &= ~MS_NOUSER;
2375
2376         /* Populate fs tree. */
2377         error = entry_create_dir(&aa_sfs_entry, NULL);
2378         if (error)
2379                 goto error;
2380
2381         dent = securityfs_create_file(".load", 0666, aa_sfs_entry.dentry,
2382                                       NULL, &aa_fs_profile_load);
2383         if (IS_ERR(dent)) {
2384                 error = PTR_ERR(dent);
2385                 goto error;
2386         }
2387         ns_subload(root_ns) = dent;
2388
2389         dent = securityfs_create_file(".replace", 0666, aa_sfs_entry.dentry,
2390                                       NULL, &aa_fs_profile_replace);
2391         if (IS_ERR(dent)) {
2392                 error = PTR_ERR(dent);
2393                 goto error;
2394         }
2395         ns_subreplace(root_ns) = dent;
2396
2397         dent = securityfs_create_file(".remove", 0666, aa_sfs_entry.dentry,
2398                                       NULL, &aa_fs_profile_remove);
2399         if (IS_ERR(dent)) {
2400                 error = PTR_ERR(dent);
2401                 goto error;
2402         }
2403         ns_subremove(root_ns) = dent;
2404
2405         dent = securityfs_create_file("revision", 0444, aa_sfs_entry.dentry,
2406                                       NULL, &aa_fs_ns_revision_fops);
2407         if (IS_ERR(dent)) {
2408                 error = PTR_ERR(dent);
2409                 goto error;
2410         }
2411         ns_subrevision(root_ns) = dent;
2412
2413         /* policy tree referenced by magic policy symlink */
2414         mutex_lock(&root_ns->lock);
2415         error = __aafs_ns_mkdir(root_ns, aafs_mnt->mnt_root, ".policy",
2416                                 aafs_mnt->mnt_root);
2417         mutex_unlock(&root_ns->lock);
2418         if (error)
2419                 goto error;
2420
2421         /* magic symlink similar to nsfs redirects based on task policy */
2422         dent = securityfs_create_symlink("policy", aa_sfs_entry.dentry,
2423                                          NULL, &policy_link_iops);
2424         if (IS_ERR(dent)) {
2425                 error = PTR_ERR(dent);
2426                 goto error;
2427         }
2428
2429         error = aa_mk_null_file(aa_sfs_entry.dentry);
2430         if (error)
2431                 goto error;
2432
2433         /* TODO: add default profile to apparmorfs */
2434
2435         /* Report that AppArmor fs is enabled */
2436         aa_info_message("AppArmor Filesystem Enabled");
2437         return 0;
2438
2439 error:
2440         aa_destroy_aafs();
2441         AA_ERROR("Error creating AppArmor securityfs\n");
2442         return error;
2443 }
2444
2445 fs_initcall(aa_create_aafs);