security/selinux/selinuxfs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Updated: Karl MacMillan <kmacmillan@tresys.com>
   3  *
   4  *      Added conditional policy language extensions
   5  *
   6  *  Updated: Hewlett-Packard <paul@paul-moore.com>
   7  *
   8  *      Added support for the policy capability bitmap
   9  *
  10  * Copyright (C) 2007 Hewlett-Packard Development Company, L.P.
  11  * Copyright (C) 2003 - 2004 Tresys Technology, LLC
  12  * Copyright (C) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/pagemap.h>
  17 #include <linux/slab.h>
  18 #include <linux/vmalloc.h>
  19 #include <linux/fs.h>
  20 #include <linux/fs_context.h>
  21 #include <linux/mount.h>
  22 #include <linux/mutex.h>
  23 #include <linux/namei.h>
  24 #include <linux/init.h>
  25 #include <linux/string.h>
  26 #include <linux/security.h>
  27 #include <linux/major.h>
  28 #include <linux/seq_file.h>
  29 #include <linux/percpu.h>
  30 #include <linux/audit.h>
  31 #include <linux/uaccess.h>
  32 #include <linux/kobject.h>
  33 #include <linux/ctype.h>
  34
  35 /* selinuxfs pseudo filesystem for exporting the security policy API.
  36    Based on the proc code and the fs/nfsd/nfsctl.c code. */
  37
  38 #include "flask.h"
  39 #include "avc.h"
  40 #include "avc_ss.h"
  41 #include "security.h"
  42 #include "objsec.h"
  43 #include "conditional.h"
  44 #include "ima.h"
  45
  46 enum sel_inos {
  47         SEL_ROOT_INO = 2,
  48         SEL_LOAD,       /* load policy */
  49         SEL_ENFORCE,    /* get or set enforcing status */
  50         SEL_CONTEXT,    /* validate context */
  51         SEL_ACCESS,     /* compute access decision */
  52         SEL_CREATE,     /* compute create labeling decision */
  53         SEL_RELABEL,    /* compute relabeling decision */
  54         SEL_USER,       /* compute reachable user contexts */
  55         SEL_POLICYVERS, /* return policy version for this kernel */
  56         SEL_COMMIT_BOOLS, /* commit new boolean values */
  57         SEL_MLS,        /* return if MLS policy is enabled */
  58         SEL_DISABLE,    /* disable SELinux until next reboot */
  59         SEL_MEMBER,     /* compute polyinstantiation membership decision */
  60         SEL_CHECKREQPROT, /* check requested protection, not kernel-applied one */
  61         SEL_COMPAT_NET, /* whether to use old compat network packet controls */
  62         SEL_REJECT_UNKNOWN, /* export unknown reject handling to userspace */
  63         SEL_DENY_UNKNOWN, /* export unknown deny handling to userspace */
  64         SEL_STATUS,     /* export current status using mmap() */
  65         SEL_POLICY,     /* allow userspace to read the in kernel policy */
  66         SEL_VALIDATE_TRANS, /* compute validatetrans decision */
  67         SEL_INO_NEXT,   /* The next inode number to use */
  68 };
  69
  70 struct selinux_fs_info {
  71         struct dentry *bool_dir;
  72         unsigned int bool_num;
  73         char **bool_pending_names;
  74         unsigned int *bool_pending_values;
  75         struct dentry *class_dir;
  76         unsigned long last_class_ino;
  77         bool policy_opened;
  78         struct dentry *policycap_dir;
  79         unsigned long last_ino;
  80         struct selinux_state *state;
  81         struct super_block *sb;
  82 };
  83
  84 static int selinux_fs_info_create(struct super_block *sb)
  85 {
  86         struct selinux_fs_info *fsi;
  87
  88         fsi = kzalloc(sizeof(*fsi), GFP_KERNEL);
  89         if (!fsi)
  90                 return -ENOMEM;
  91
  92         fsi->last_ino = SEL_INO_NEXT - 1;
  93         fsi->state = &selinux_state;
  94         fsi->sb = sb;
  95         sb->s_fs_info = fsi;
  96         return 0;
  97 }
  98
  99 static void selinux_fs_info_free(struct super_block *sb)
 100 {
 101         struct selinux_fs_info *fsi = sb->s_fs_info;
 102         int i;
 103
 104         if (fsi) {
 105                 for (i = 0; i < fsi->bool_num; i++)
 106                         kfree(fsi->bool_pending_names[i]);
 107                 kfree(fsi->bool_pending_names);
 108                 kfree(fsi->bool_pending_values);
 109         }
 110         kfree(sb->s_fs_info);
 111         sb->s_fs_info = NULL;
 112 }
 113
 114 #define SEL_INITCON_INO_OFFSET          0x01000000
 115 #define SEL_BOOL_INO_OFFSET             0x02000000
 116 #define SEL_CLASS_INO_OFFSET            0x04000000
 117 #define SEL_POLICYCAP_INO_OFFSET        0x08000000
 118 #define SEL_INO_MASK                    0x00ffffff
 119
 120 #define BOOL_DIR_NAME "booleans"
 121 #define CLASS_DIR_NAME "class"
 122 #define POLICYCAP_DIR_NAME "policy_capabilities"
 123
 124 #define TMPBUFLEN       12
 125 static ssize_t sel_read_enforce(struct file *filp, char __user *buf,
 126                                 size_t count, loff_t *ppos)
 127 {
 128         struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
 129         char tmpbuf[TMPBUFLEN];
 130         ssize_t length;
 131
 132         length = scnprintf(tmpbuf, TMPBUFLEN, "%d",
 133                            enforcing_enabled(fsi->state));
 134         return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
 135 }
 136
 137 #ifdef CONFIG_SECURITY_SELINUX_DEVELOP
 138 static ssize_t sel_write_enforce(struct file *file, const char __user *buf,
 139                                  size_t count, loff_t *ppos)
 140
 141 {
 142         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
 143         struct selinux_state *state = fsi->state;
 144         char *page = NULL;
 145         ssize_t length;
 146         int old_value, new_value;
 147
 148         if (count >= PAGE_SIZE)
 149                 return -ENOMEM;
 150
 151         /* No partial writes. */
 152         if (*ppos != 0)
 153                 return -EINVAL;
 154
 155         page = memdup_user_nul(buf, count);
 156         if (IS_ERR(page))
 157                 return PTR_ERR(page);
 158
 159         length = -EINVAL;
 160         if (sscanf(page, "%d", &new_value) != 1)
 161                 goto out;
 162
 163         new_value = !!new_value;
 164
 165         old_value = enforcing_enabled(state);
 166         if (new_value != old_value) {
 167                 length = avc_has_perm(&selinux_state,
 168                                       current_sid(), SECINITSID_SECURITY,
 169                                       SECCLASS_SECURITY, SECURITY__SETENFORCE,
 170                                       NULL);
 171                 if (length)
 172                         goto out;
 173                 audit_log(audit_context(), GFP_KERNEL, AUDIT_MAC_STATUS,
 174                         "enforcing=%d old_enforcing=%d auid=%u ses=%u"
 175                         " enabled=1 old-enabled=1 lsm=selinux res=1",
 176                         new_value, old_value,
 177                         from_kuid(&init_user_ns, audit_get_loginuid(current)),
 178                         audit_get_sessionid(current));
 179                 enforcing_set(state, new_value);
 180                 if (new_value)
 181                         avc_ss_reset(state->avc, 0);
 182                 selnl_notify_setenforce(new_value);
 183                 selinux_status_update_setenforce(state, new_value);
 184                 if (!new_value)
 185                         call_blocking_lsm_notifier(LSM_POLICY_CHANGE, NULL);
 186
 187                 selinux_ima_measure_state(state);
 188         }
 189         length = count;
 190 out:
 191         kfree(page);
 192         return length;
 193 }
 194 #else
 195 #define sel_write_enforce NULL
 196 #endif
 197
 198 static const struct file_operations sel_enforce_ops = {
 199         .read           = sel_read_enforce,
 200         .write          = sel_write_enforce,
 201         .llseek         = generic_file_llseek,
 202 };
 203
 204 static ssize_t sel_read_handle_unknown(struct file *filp, char __user *buf,
 205                                         size_t count, loff_t *ppos)
 206 {
 207         struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
 208         struct selinux_state *state = fsi->state;
 209         char tmpbuf[TMPBUFLEN];
 210         ssize_t length;
 211         ino_t ino = file_inode(filp)->i_ino;
 212         int handle_unknown = (ino == SEL_REJECT_UNKNOWN) ?
 213                 security_get_reject_unknown(state) :
 214                 !security_get_allow_unknown(state);
 215
 216         length = scnprintf(tmpbuf, TMPBUFLEN, "%d", handle_unknown);
 217         return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
 218 }
 219
 220 static const struct file_operations sel_handle_unknown_ops = {
 221         .read           = sel_read_handle_unknown,
 222         .llseek         = generic_file_llseek,
 223 };
 224
 225 static int sel_open_handle_status(struct inode *inode, struct file *filp)
 226 {
 227         struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
 228         struct page    *status = selinux_kernel_status_page(fsi->state);
 229
 230         if (!status)
 231                 return -ENOMEM;
 232
 233         filp->private_data = status;
 234
 235         return 0;
 236 }
 237
 238 static ssize_t sel_read_handle_status(struct file *filp, char __user *buf,
 239                                       size_t count, loff_t *ppos)
 240 {
 241         struct page    *status = filp->private_data;
 242
 243         BUG_ON(!status);
 244
 245         return simple_read_from_buffer(buf, count, ppos,
 246                                        page_address(status),
 247                                        sizeof(struct selinux_kernel_status));
 248 }
 249
 250 static int sel_mmap_handle_status(struct file *filp,
 251                                   struct vm_area_struct *vma)
 252 {
 253         struct page    *status = filp->private_data;
 254         unsigned long   size = vma->vm_end - vma->vm_start;
 255
 256         BUG_ON(!status);
 257
 258         /* only allows one page from the head */
 259         if (vma->vm_pgoff > 0 || size != PAGE_SIZE)
 260                 return -EIO;
 261         /* disallow writable mapping */
 262         if (vma->vm_flags & VM_WRITE)
 263                 return -EPERM;
 264         /* disallow mprotect() turns it into writable */
 265         vma->vm_flags &= ~VM_MAYWRITE;
 266
 267         return remap_pfn_range(vma, vma->vm_start,
 268                                page_to_pfn(status),
 269                                size, vma->vm_page_prot);
 270 }
 271
 272 static const struct file_operations sel_handle_status_ops = {
 273         .open           = sel_open_handle_status,
 274         .read           = sel_read_handle_status,
 275         .mmap           = sel_mmap_handle_status,
 276         .llseek         = generic_file_llseek,
 277 };
 278
 279 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
 280 static ssize_t sel_write_disable(struct file *file, const char __user *buf,
 281                                  size_t count, loff_t *ppos)
 282
 283 {
 284         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
 285         char *page;
 286         ssize_t length;
 287         int new_value;
 288         int enforcing;
 289
 290         /* NOTE: we are now officially considering runtime disable as
 291          *       deprecated, and using it will become increasingly painful
 292          *       (e.g. sleeping/blocking) as we progress through future
 293          *       kernel releases until eventually it is removed
 294          */
 295         pr_err("SELinux:  Runtime disable is deprecated, use selinux=0 on the kernel cmdline.\n");
 296
 297         if (count >= PAGE_SIZE)
 298                 return -ENOMEM;
 299
 300         /* No partial writes. */
 301         if (*ppos != 0)
 302                 return -EINVAL;
 303
 304         page = memdup_user_nul(buf, count);
 305         if (IS_ERR(page))
 306                 return PTR_ERR(page);
 307
 308         length = -EINVAL;
 309         if (sscanf(page, "%d", &new_value) != 1)
 310                 goto out;
 311
 312         if (new_value) {
 313                 enforcing = enforcing_enabled(fsi->state);
 314                 length = selinux_disable(fsi->state);
 315                 if (length)
 316                         goto out;
 317                 audit_log(audit_context(), GFP_KERNEL, AUDIT_MAC_STATUS,
 318                         "enforcing=%d old_enforcing=%d auid=%u ses=%u"
 319                         " enabled=0 old-enabled=1 lsm=selinux res=1",
 320                         enforcing, enforcing,
 321                         from_kuid(&init_user_ns, audit_get_loginuid(current)),
 322                         audit_get_sessionid(current));
 323         }
 324
 325         length = count;
 326 out:
 327         kfree(page);
 328         return length;
 329 }
 330 #else
 331 #define sel_write_disable NULL
 332 #endif
 333
 334 static const struct file_operations sel_disable_ops = {
 335         .write          = sel_write_disable,
 336         .llseek         = generic_file_llseek,
 337 };
 338
 339 static ssize_t sel_read_policyvers(struct file *filp, char __user *buf,
 340                                    size_t count, loff_t *ppos)
 341 {
 342         char tmpbuf[TMPBUFLEN];
 343         ssize_t length;
 344
 345         length = scnprintf(tmpbuf, TMPBUFLEN, "%u", POLICYDB_VERSION_MAX);
 346         return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
 347 }
 348
 349 static const struct file_operations sel_policyvers_ops = {
 350         .read           = sel_read_policyvers,
 351         .llseek         = generic_file_llseek,
 352 };
 353
 354 /* declaration for sel_write_load */
 355 static int sel_make_bools(struct selinux_policy *newpolicy, struct dentry *bool_dir,
 356                           unsigned int *bool_num, char ***bool_pending_names,
 357                           unsigned int **bool_pending_values);
 358 static int sel_make_classes(struct selinux_policy *newpolicy,
 359                             struct dentry *class_dir,
 360                             unsigned long *last_class_ino);
 361
 362 /* declaration for sel_make_class_dirs */
 363 static struct dentry *sel_make_dir(struct dentry *dir, const char *name,
 364                         unsigned long *ino);
 365
 366 /* declaration for sel_make_policy_nodes */
 367 static struct dentry *sel_make_disconnected_dir(struct super_block *sb,
 368                                                 unsigned long *ino);
 369
 370 /* declaration for sel_make_policy_nodes */
 371 static void sel_remove_entries(struct dentry *de);
 372
 373 static ssize_t sel_read_mls(struct file *filp, char __user *buf,
 374                                 size_t count, loff_t *ppos)
 375 {
 376         struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
 377         char tmpbuf[TMPBUFLEN];
 378         ssize_t length;
 379
 380         length = scnprintf(tmpbuf, TMPBUFLEN, "%d",
 381                            security_mls_enabled(fsi->state));
 382         return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
 383 }
 384
 385 static const struct file_operations sel_mls_ops = {
 386         .read           = sel_read_mls,
 387         .llseek         = generic_file_llseek,
 388 };
 389
 390 struct policy_load_memory {
 391         size_t len;
 392         void *data;
 393 };
 394
 395 static int sel_open_policy(struct inode *inode, struct file *filp)
 396 {
 397         struct selinux_fs_info *fsi = inode->i_sb->s_fs_info;
 398         struct selinux_state *state = fsi->state;
 399         struct policy_load_memory *plm = NULL;
 400         int rc;
 401
 402         BUG_ON(filp->private_data);
 403
 404         mutex_lock(&fsi->state->policy_mutex);
 405
 406         rc = avc_has_perm(&selinux_state,
 407                           current_sid(), SECINITSID_SECURITY,
 408                           SECCLASS_SECURITY, SECURITY__READ_POLICY, NULL);
 409         if (rc)
 410                 goto err;
 411
 412         rc = -EBUSY;
 413         if (fsi->policy_opened)
 414                 goto err;
 415
 416         rc = -ENOMEM;
 417         plm = kzalloc(sizeof(*plm), GFP_KERNEL);
 418         if (!plm)
 419                 goto err;
 420
 421         rc = security_read_policy(state, &plm->data, &plm->len);
 422         if (rc)
 423                 goto err;
 424
 425         if ((size_t)i_size_read(inode) != plm->len) {
 426                 inode_lock(inode);
 427                 i_size_write(inode, plm->len);
 428                 inode_unlock(inode);
 429         }
 430
 431         fsi->policy_opened = 1;
 432
 433         filp->private_data = plm;
 434
 435         mutex_unlock(&fsi->state->policy_mutex);
 436
 437         return 0;
 438 err:
 439         mutex_unlock(&fsi->state->policy_mutex);
 440
 441         if (plm)
 442                 vfree(plm->data);
 443         kfree(plm);
 444         return rc;
 445 }
 446
 447 static int sel_release_policy(struct inode *inode, struct file *filp)
 448 {
 449         struct selinux_fs_info *fsi = inode->i_sb->s_fs_info;
 450         struct policy_load_memory *plm = filp->private_data;
 451
 452         BUG_ON(!plm);
 453
 454         fsi->policy_opened = 0;
 455
 456         vfree(plm->data);
 457         kfree(plm);
 458
 459         return 0;
 460 }
 461
 462 static ssize_t sel_read_policy(struct file *filp, char __user *buf,
 463                                size_t count, loff_t *ppos)
 464 {
 465         struct policy_load_memory *plm = filp->private_data;
 466         int ret;
 467
 468         ret = avc_has_perm(&selinux_state,
 469                            current_sid(), SECINITSID_SECURITY,
 470                           SECCLASS_SECURITY, SECURITY__READ_POLICY, NULL);
 471         if (ret)
 472                 return ret;
 473
 474         return simple_read_from_buffer(buf, count, ppos, plm->data, plm->len);
 475 }
 476
 477 static vm_fault_t sel_mmap_policy_fault(struct vm_fault *vmf)
 478 {
 479         struct policy_load_memory *plm = vmf->vma->vm_file->private_data;
 480         unsigned long offset;
 481         struct page *page;
 482
 483         if (vmf->flags & (FAULT_FLAG_MKWRITE | FAULT_FLAG_WRITE))
 484                 return VM_FAULT_SIGBUS;
 485
 486         offset = vmf->pgoff << PAGE_SHIFT;
 487         if (offset >= roundup(plm->len, PAGE_SIZE))
 488                 return VM_FAULT_SIGBUS;
 489
 490         page = vmalloc_to_page(plm->data + offset);
 491         get_page(page);
 492
 493         vmf->page = page;
 494
 495         return 0;
 496 }
 497
 498 static const struct vm_operations_struct sel_mmap_policy_ops = {
 499         .fault = sel_mmap_policy_fault,
 500         .page_mkwrite = sel_mmap_policy_fault,
 501 };
 502
 503 static int sel_mmap_policy(struct file *filp, struct vm_area_struct *vma)
 504 {
 505         if (vma->vm_flags & VM_SHARED) {
 506                 /* do not allow mprotect to make mapping writable */
 507                 vma->vm_flags &= ~VM_MAYWRITE;
 508
 509                 if (vma->vm_flags & VM_WRITE)
 510                         return -EACCES;
 511         }
 512
 513         vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
 514         vma->vm_ops = &sel_mmap_policy_ops;
 515
 516         return 0;
 517 }
 518
 519 static const struct file_operations sel_policy_ops = {
 520         .open           = sel_open_policy,
 521         .read           = sel_read_policy,
 522         .mmap           = sel_mmap_policy,
 523         .release        = sel_release_policy,
 524         .llseek         = generic_file_llseek,
 525 };
 526
 527 static void sel_remove_old_bool_data(unsigned int bool_num, char **bool_names,
 528                                 unsigned int *bool_values)
 529 {
 530         u32 i;
 531
 532         /* bool_dir cleanup */
 533         for (i = 0; i < bool_num; i++)
 534                 kfree(bool_names[i]);
 535         kfree(bool_names);
 536         kfree(bool_values);
 537 }
 538
 539 static int sel_make_policy_nodes(struct selinux_fs_info *fsi,
 540                                 struct selinux_policy *newpolicy)
 541 {
 542         int ret = 0;
 543         struct dentry *tmp_parent, *tmp_bool_dir, *tmp_class_dir, *old_dentry;
 544         unsigned int tmp_bool_num, old_bool_num;
 545         char **tmp_bool_names, **old_bool_names;
 546         unsigned int *tmp_bool_values, *old_bool_values;
 547         unsigned long tmp_ino = fsi->last_ino; /* Don't increment last_ino in this function */
 548
 549         tmp_parent = sel_make_disconnected_dir(fsi->sb, &tmp_ino);
 550         if (IS_ERR(tmp_parent))
 551                 return PTR_ERR(tmp_parent);
 552
 553         tmp_ino = fsi->bool_dir->d_inode->i_ino - 1; /* sel_make_dir will increment and set */
 554         tmp_bool_dir = sel_make_dir(tmp_parent, BOOL_DIR_NAME, &tmp_ino);
 555         if (IS_ERR(tmp_bool_dir)) {
 556                 ret = PTR_ERR(tmp_bool_dir);
 557                 goto out;
 558         }
 559
 560         tmp_ino = fsi->class_dir->d_inode->i_ino - 1; /* sel_make_dir will increment and set */
 561         tmp_class_dir = sel_make_dir(tmp_parent, CLASS_DIR_NAME, &tmp_ino);
 562         if (IS_ERR(tmp_class_dir)) {
 563                 ret = PTR_ERR(tmp_class_dir);
 564                 goto out;
 565         }
 566
 567         ret = sel_make_bools(newpolicy, tmp_bool_dir, &tmp_bool_num,
 568                              &tmp_bool_names, &tmp_bool_values);
 569         if (ret)
 570                 goto out;
 571
 572         ret = sel_make_classes(newpolicy, tmp_class_dir,
 573                                &fsi->last_class_ino);
 574         if (ret)
 575                 goto out;
 576
 577         /* booleans */
 578         old_dentry = fsi->bool_dir;
 579         lock_rename(tmp_bool_dir, old_dentry);
 580         d_exchange(tmp_bool_dir, fsi->bool_dir);
 581
 582         old_bool_num = fsi->bool_num;
 583         old_bool_names = fsi->bool_pending_names;
 584         old_bool_values = fsi->bool_pending_values;
 585
 586         fsi->bool_num = tmp_bool_num;
 587         fsi->bool_pending_names = tmp_bool_names;
 588         fsi->bool_pending_values = tmp_bool_values;
 589
 590         sel_remove_old_bool_data(old_bool_num, old_bool_names, old_bool_values);
 591
 592         fsi->bool_dir = tmp_bool_dir;
 593         unlock_rename(tmp_bool_dir, old_dentry);
 594
 595         /* classes */
 596         old_dentry = fsi->class_dir;
 597         lock_rename(tmp_class_dir, old_dentry);
 598         d_exchange(tmp_class_dir, fsi->class_dir);
 599         fsi->class_dir = tmp_class_dir;
 600         unlock_rename(tmp_class_dir, old_dentry);
 601
 602 out:
 603         /* Since the other temporary dirs are children of tmp_parent
 604          * this will handle all the cleanup in the case of a failure before
 605          * the swapover
 606          */
 607         sel_remove_entries(tmp_parent);
 608         dput(tmp_parent); /* d_genocide() only handles the children */
 609
 610         return ret;
 611 }
 612
 613 static ssize_t sel_write_load(struct file *file, const char __user *buf,
 614                               size_t count, loff_t *ppos)
 615
 616 {
 617         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
 618         struct selinux_load_state load_state;
 619         ssize_t length;
 620         void *data = NULL;
 621
 622         mutex_lock(&fsi->state->policy_mutex);
 623
 624         length = avc_has_perm(&selinux_state,
 625                               current_sid(), SECINITSID_SECURITY,
 626                               SECCLASS_SECURITY, SECURITY__LOAD_POLICY, NULL);
 627         if (length)
 628                 goto out;
 629
 630         /* No partial writes. */
 631         length = -EINVAL;
 632         if (*ppos != 0)
 633                 goto out;
 634
 635         length = -ENOMEM;
 636         data = vmalloc(count);
 637         if (!data)
 638                 goto out;
 639
 640         length = -EFAULT;
 641         if (copy_from_user(data, buf, count) != 0)
 642                 goto out;
 643
 644         length = security_load_policy(fsi->state, data, count, &load_state);
 645         if (length) {
 646                 pr_warn_ratelimited("SELinux: failed to load policy\n");
 647                 goto out;
 648         }
 649
 650         length = sel_make_policy_nodes(fsi, load_state.policy);
 651         if (length) {
 652                 pr_warn_ratelimited("SELinux: failed to initialize selinuxfs\n");
 653                 selinux_policy_cancel(fsi->state, &load_state);
 654                 goto out;
 655         }
 656
 657         selinux_policy_commit(fsi->state, &load_state);
 658
 659         length = count;
 660
 661         audit_log(audit_context(), GFP_KERNEL, AUDIT_MAC_POLICY_LOAD,
 662                 "auid=%u ses=%u lsm=selinux res=1",
 663                 from_kuid(&init_user_ns, audit_get_loginuid(current)),
 664                 audit_get_sessionid(current));
 665 out:
 666         mutex_unlock(&fsi->state->policy_mutex);
 667         vfree(data);
 668         return length;
 669 }
 670
 671 static const struct file_operations sel_load_ops = {
 672         .write          = sel_write_load,
 673         .llseek         = generic_file_llseek,
 674 };
 675
 676 static ssize_t sel_write_context(struct file *file, char *buf, size_t size)
 677 {
 678         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
 679         struct selinux_state *state = fsi->state;
 680         char *canon = NULL;
 681         u32 sid, len;
 682         ssize_t length;
 683
 684         length = avc_has_perm(&selinux_state,
 685                               current_sid(), SECINITSID_SECURITY,
 686                               SECCLASS_SECURITY, SECURITY__CHECK_CONTEXT, NULL);
 687         if (length)
 688                 goto out;
 689
 690         length = security_context_to_sid(state, buf, size, &sid, GFP_KERNEL);
 691         if (length)
 692                 goto out;
 693
 694         length = security_sid_to_context(state, sid, &canon, &len);
 695         if (length)
 696                 goto out;
 697
 698         length = -ERANGE;
 699         if (len > SIMPLE_TRANSACTION_LIMIT) {
 700                 pr_err("SELinux: %s:  context size (%u) exceeds "
 701                         "payload max\n", __func__, len);
 702                 goto out;
 703         }
 704
 705         memcpy(buf, canon, len);
 706         length = len;
 707 out:
 708         kfree(canon);
 709         return length;
 710 }
 711
 712 static ssize_t sel_read_checkreqprot(struct file *filp, char __user *buf,
 713                                      size_t count, loff_t *ppos)
 714 {
 715         struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
 716         char tmpbuf[TMPBUFLEN];
 717         ssize_t length;
 718
 719         length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
 720                            checkreqprot_get(fsi->state));
 721         return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
 722 }
 723
 724 static ssize_t sel_write_checkreqprot(struct file *file, const char __user *buf,
 725                                       size_t count, loff_t *ppos)
 726 {
 727         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
 728         char *page;
 729         ssize_t length;
 730         unsigned int new_value;
 731
 732         length = avc_has_perm(&selinux_state,
 733                               current_sid(), SECINITSID_SECURITY,
 734                               SECCLASS_SECURITY, SECURITY__SETCHECKREQPROT,
 735                               NULL);
 736         if (length)
 737                 return length;
 738
 739         if (count >= PAGE_SIZE)
 740                 return -ENOMEM;
 741
 742         /* No partial writes. */
 743         if (*ppos != 0)
 744                 return -EINVAL;
 745
 746         page = memdup_user_nul(buf, count);
 747         if (IS_ERR(page))
 748                 return PTR_ERR(page);
 749
 750         length = -EINVAL;
 751         if (sscanf(page, "%u", &new_value) != 1)
 752                 goto out;
 753
 754         if (new_value) {
 755                 char comm[sizeof(current->comm)];
 756
 757                 memcpy(comm, current->comm, sizeof(comm));
 758                 pr_warn_once("SELinux: %s (%d) set checkreqprot to 1. This is deprecated and will be rejected in a future kernel release.\n",
 759                              comm, current->pid);
 760         }
 761
 762         checkreqprot_set(fsi->state, (new_value ? 1 : 0));
 763         length = count;
 764
 765         selinux_ima_measure_state(fsi->state);
 766
 767 out:
 768         kfree(page);
 769         return length;
 770 }
 771 static const struct file_operations sel_checkreqprot_ops = {
 772         .read           = sel_read_checkreqprot,
 773         .write          = sel_write_checkreqprot,
 774         .llseek         = generic_file_llseek,
 775 };
 776
 777 static ssize_t sel_write_validatetrans(struct file *file,
 778                                         const char __user *buf,
 779                                         size_t count, loff_t *ppos)
 780 {
 781         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
 782         struct selinux_state *state = fsi->state;
 783         char *oldcon = NULL, *newcon = NULL, *taskcon = NULL;
 784         char *req = NULL;
 785         u32 osid, nsid, tsid;
 786         u16 tclass;
 787         int rc;
 788
 789         rc = avc_has_perm(&selinux_state,
 790                           current_sid(), SECINITSID_SECURITY,
 791                           SECCLASS_SECURITY, SECURITY__VALIDATE_TRANS, NULL);
 792         if (rc)
 793                 goto out;
 794
 795         rc = -ENOMEM;
 796         if (count >= PAGE_SIZE)
 797                 goto out;
 798
 799         /* No partial writes. */
 800         rc = -EINVAL;
 801         if (*ppos != 0)
 802                 goto out;
 803
 804         req = memdup_user_nul(buf, count);
 805         if (IS_ERR(req)) {
 806                 rc = PTR_ERR(req);
 807                 req = NULL;
 808                 goto out;
 809         }
 810
 811         rc = -ENOMEM;
 812         oldcon = kzalloc(count + 1, GFP_KERNEL);
 813         if (!oldcon)
 814                 goto out;
 815
 816         newcon = kzalloc(count + 1, GFP_KERNEL);
 817         if (!newcon)
 818                 goto out;
 819
 820         taskcon = kzalloc(count + 1, GFP_KERNEL);
 821         if (!taskcon)
 822                 goto out;
 823
 824         rc = -EINVAL;
 825         if (sscanf(req, "%s %s %hu %s", oldcon, newcon, &tclass, taskcon) != 4)
 826                 goto out;
 827
 828         rc = security_context_str_to_sid(state, oldcon, &osid, GFP_KERNEL);
 829         if (rc)
 830                 goto out;
 831
 832         rc = security_context_str_to_sid(state, newcon, &nsid, GFP_KERNEL);
 833         if (rc)
 834                 goto out;
 835
 836         rc = security_context_str_to_sid(state, taskcon, &tsid, GFP_KERNEL);
 837         if (rc)
 838                 goto out;
 839
 840         rc = security_validate_transition_user(state, osid, nsid, tsid, tclass);
 841         if (!rc)
 842                 rc = count;
 843 out:
 844         kfree(req);
 845         kfree(oldcon);
 846         kfree(newcon);
 847         kfree(taskcon);
 848         return rc;
 849 }
 850
 851 static const struct file_operations sel_transition_ops = {
 852         .write          = sel_write_validatetrans,
 853         .llseek         = generic_file_llseek,
 854 };
 855
 856 /*
 857  * Remaining nodes use transaction based IO methods like nfsd/nfsctl.c
 858  */
 859 static ssize_t sel_write_access(struct file *file, char *buf, size_t size);
 860 static ssize_t sel_write_create(struct file *file, char *buf, size_t size);
 861 static ssize_t sel_write_relabel(struct file *file, char *buf, size_t size);
 862 static ssize_t sel_write_user(struct file *file, char *buf, size_t size);
 863 static ssize_t sel_write_member(struct file *file, char *buf, size_t size);
 864
 865 static ssize_t (*const write_op[])(struct file *, char *, size_t) = {
 866         [SEL_ACCESS] = sel_write_access,
 867         [SEL_CREATE] = sel_write_create,
 868         [SEL_RELABEL] = sel_write_relabel,
 869         [SEL_USER] = sel_write_user,
 870         [SEL_MEMBER] = sel_write_member,
 871         [SEL_CONTEXT] = sel_write_context,
 872 };
 873
 874 static ssize_t selinux_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
 875 {
 876         ino_t ino = file_inode(file)->i_ino;
 877         char *data;
 878         ssize_t rv;
 879
 880         if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
 881                 return -EINVAL;
 882
 883         data = simple_transaction_get(file, buf, size);
 884         if (IS_ERR(data))
 885                 return PTR_ERR(data);
 886
 887         rv = write_op[ino](file, data, size);
 888         if (rv > 0) {
 889                 simple_transaction_set(file, rv);
 890                 rv = size;
 891         }
 892         return rv;
 893 }
 894
 895 static const struct file_operations transaction_ops = {
 896         .write          = selinux_transaction_write,
 897         .read           = simple_transaction_read,
 898         .release        = simple_transaction_release,
 899         .llseek         = generic_file_llseek,
 900 };
 901
 902 /*
 903  * payload - write methods
 904  * If the method has a response, the response should be put in buf,
 905  * and the length returned.  Otherwise return 0 or and -error.
 906  */
 907
 908 static ssize_t sel_write_access(struct file *file, char *buf, size_t size)
 909 {
 910         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
 911         struct selinux_state *state = fsi->state;
 912         char *scon = NULL, *tcon = NULL;
 913         u32 ssid, tsid;
 914         u16 tclass;
 915         struct av_decision avd;
 916         ssize_t length;
 917
 918         length = avc_has_perm(&selinux_state,
 919                               current_sid(), SECINITSID_SECURITY,
 920                               SECCLASS_SECURITY, SECURITY__COMPUTE_AV, NULL);
 921         if (length)
 922                 goto out;
 923
 924         length = -ENOMEM;
 925         scon = kzalloc(size + 1, GFP_KERNEL);
 926         if (!scon)
 927                 goto out;
 928
 929         length = -ENOMEM;
 930         tcon = kzalloc(size + 1, GFP_KERNEL);
 931         if (!tcon)
 932                 goto out;
 933
 934         length = -EINVAL;
 935         if (sscanf(buf, "%s %s %hu", scon, tcon, &tclass) != 3)
 936                 goto out;
 937
 938         length = security_context_str_to_sid(state, scon, &ssid, GFP_KERNEL);
 939         if (length)
 940                 goto out;
 941
 942         length = security_context_str_to_sid(state, tcon, &tsid, GFP_KERNEL);
 943         if (length)
 944                 goto out;
 945
 946         security_compute_av_user(state, ssid, tsid, tclass, &avd);
 947
 948         length = scnprintf(buf, SIMPLE_TRANSACTION_LIMIT,
 949                           "%x %x %x %x %u %x",
 950                           avd.allowed, 0xffffffff,
 951                           avd.auditallow, avd.auditdeny,
 952                           avd.seqno, avd.flags);
 953 out:
 954         kfree(tcon);
 955         kfree(scon);
 956         return length;
 957 }
 958
 959 static ssize_t sel_write_create(struct file *file, char *buf, size_t size)
 960 {
 961         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
 962         struct selinux_state *state = fsi->state;
 963         char *scon = NULL, *tcon = NULL;
 964         char *namebuf = NULL, *objname = NULL;
 965         u32 ssid, tsid, newsid;
 966         u16 tclass;
 967         ssize_t length;
 968         char *newcon = NULL;
 969         u32 len;
 970         int nargs;
 971
 972         length = avc_has_perm(&selinux_state,
 973                               current_sid(), SECINITSID_SECURITY,
 974                               SECCLASS_SECURITY, SECURITY__COMPUTE_CREATE,
 975                               NULL);
 976         if (length)
 977                 goto out;
 978
 979         length = -ENOMEM;
 980         scon = kzalloc(size + 1, GFP_KERNEL);
 981         if (!scon)
 982                 goto out;
 983
 984         length = -ENOMEM;
 985         tcon = kzalloc(size + 1, GFP_KERNEL);
 986         if (!tcon)
 987                 goto out;
 988
 989         length = -ENOMEM;
 990         namebuf = kzalloc(size + 1, GFP_KERNEL);
 991         if (!namebuf)
 992                 goto out;
 993
 994         length = -EINVAL;
 995         nargs = sscanf(buf, "%s %s %hu %s", scon, tcon, &tclass, namebuf);
 996         if (nargs < 3 || nargs > 4)
 997                 goto out;
 998         if (nargs == 4) {
 999                 /*
1000                  * If and when the name of new object to be queried contains
1001                  * either whitespace or multibyte characters, they shall be
1002                  * encoded based on the percentage-encoding rule.
1003                  * If not encoded, the sscanf logic picks up only left-half
1004                  * of the supplied name; splitted by a whitespace unexpectedly.
1005                  */
1006                 char   *r, *w;
1007                 int     c1, c2;
1008
1009                 r = w = namebuf;
1010                 do {
1011                         c1 = *r++;
1012                         if (c1 == '+')
1013                                 c1 = ' ';
1014                         else if (c1 == '%') {
1015                                 c1 = hex_to_bin(*r++);
1016                                 if (c1 < 0)
1017                                         goto out;
1018                                 c2 = hex_to_bin(*r++);
1019                                 if (c2 < 0)
1020                                         goto out;
1021                                 c1 = (c1 << 4) | c2;
1022                         }
1023                         *w++ = c1;
1024                 } while (c1 != '\0');
1025
1026                 objname = namebuf;
1027         }
1028
1029         length = security_context_str_to_sid(state, scon, &ssid, GFP_KERNEL);
1030         if (length)
1031                 goto out;
1032
1033         length = security_context_str_to_sid(state, tcon, &tsid, GFP_KERNEL);
1034         if (length)
1035                 goto out;
1036
1037         length = security_transition_sid_user(state, ssid, tsid, tclass,
1038                                               objname, &newsid);
1039         if (length)
1040                 goto out;
1041
1042         length = security_sid_to_context(state, newsid, &newcon, &len);
1043         if (length)
1044                 goto out;
1045
1046         length = -ERANGE;
1047         if (len > SIMPLE_TRANSACTION_LIMIT) {
1048                 pr_err("SELinux: %s:  context size (%u) exceeds "
1049                         "payload max\n", __func__, len);
1050                 goto out;
1051         }
1052
1053         memcpy(buf, newcon, len);
1054         length = len;
1055 out:
1056         kfree(newcon);
1057         kfree(namebuf);
1058         kfree(tcon);
1059         kfree(scon);
1060         return length;
1061 }
1062
1063 static ssize_t sel_write_relabel(struct file *file, char *buf, size_t size)
1064 {
1065         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
1066         struct selinux_state *state = fsi->state;
1067         char *scon = NULL, *tcon = NULL;
1068         u32 ssid, tsid, newsid;
1069         u16 tclass;
1070         ssize_t length;
1071         char *newcon = NULL;
1072         u32 len;
1073
1074         length = avc_has_perm(&selinux_state,
1075                               current_sid(), SECINITSID_SECURITY,
1076                               SECCLASS_SECURITY, SECURITY__COMPUTE_RELABEL,
1077                               NULL);
1078         if (length)
1079                 goto out;
1080
1081         length = -ENOMEM;
1082         scon = kzalloc(size + 1, GFP_KERNEL);
1083         if (!scon)
1084                 goto out;
1085
1086         length = -ENOMEM;
1087         tcon = kzalloc(size + 1, GFP_KERNEL);
1088         if (!tcon)
1089                 goto out;
1090
1091         length = -EINVAL;
1092         if (sscanf(buf, "%s %s %hu", scon, tcon, &tclass) != 3)
1093                 goto out;
1094
1095         length = security_context_str_to_sid(state, scon, &ssid, GFP_KERNEL);
1096         if (length)
1097                 goto out;
1098
1099         length = security_context_str_to_sid(state, tcon, &tsid, GFP_KERNEL);
1100         if (length)
1101                 goto out;
1102
1103         length = security_change_sid(state, ssid, tsid, tclass, &newsid);
1104         if (length)
1105                 goto out;
1106
1107         length = security_sid_to_context(state, newsid, &newcon, &len);
1108         if (length)
1109                 goto out;
1110
1111         length = -ERANGE;
1112         if (len > SIMPLE_TRANSACTION_LIMIT)
1113                 goto out;
1114
1115         memcpy(buf, newcon, len);
1116         length = len;
1117 out:
1118         kfree(newcon);
1119         kfree(tcon);
1120         kfree(scon);
1121         return length;
1122 }
1123
1124 static ssize_t sel_write_user(struct file *file, char *buf, size_t size)
1125 {
1126         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
1127         struct selinux_state *state = fsi->state;
1128         char *con = NULL, *user = NULL, *ptr;
1129         u32 sid, *sids = NULL;
1130         ssize_t length;
1131         char *newcon;
1132         int i, rc;
1133         u32 len, nsids;
1134
1135         length = avc_has_perm(&selinux_state,
1136                               current_sid(), SECINITSID_SECURITY,
1137                               SECCLASS_SECURITY, SECURITY__COMPUTE_USER,
1138                               NULL);
1139         if (length)
1140                 goto out;
1141
1142         length = -ENOMEM;
1143         con = kzalloc(size + 1, GFP_KERNEL);
1144         if (!con)
1145                 goto out;
1146
1147         length = -ENOMEM;
1148         user = kzalloc(size + 1, GFP_KERNEL);
1149         if (!user)
1150                 goto out;
1151
1152         length = -EINVAL;
1153         if (sscanf(buf, "%s %s", con, user) != 2)
1154                 goto out;
1155
1156         length = security_context_str_to_sid(state, con, &sid, GFP_KERNEL);
1157         if (length)
1158                 goto out;
1159
1160         length = security_get_user_sids(state, sid, user, &sids, &nsids);
1161         if (length)
1162                 goto out;
1163
1164         length = sprintf(buf, "%u", nsids) + 1;
1165         ptr = buf + length;
1166         for (i = 0; i < nsids; i++) {
1167                 rc = security_sid_to_context(state, sids[i], &newcon, &len);
1168                 if (rc) {
1169                         length = rc;
1170                         goto out;
1171                 }
1172                 if ((length + len) >= SIMPLE_TRANSACTION_LIMIT) {
1173                         kfree(newcon);
1174                         length = -ERANGE;
1175                         goto out;
1176                 }
1177                 memcpy(ptr, newcon, len);
1178                 kfree(newcon);
1179                 ptr += len;
1180                 length += len;
1181         }
1182 out:
1183         kfree(sids);
1184         kfree(user);
1185         kfree(con);
1186         return length;
1187 }
1188
1189 static ssize_t sel_write_member(struct file *file, char *buf, size_t size)
1190 {
1191         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
1192         struct selinux_state *state = fsi->state;
1193         char *scon = NULL, *tcon = NULL;
1194         u32 ssid, tsid, newsid;
1195         u16 tclass;
1196         ssize_t length;
1197         char *newcon = NULL;
1198         u32 len;
1199
1200         length = avc_has_perm(&selinux_state,
1201                               current_sid(), SECINITSID_SECURITY,
1202                               SECCLASS_SECURITY, SECURITY__COMPUTE_MEMBER,
1203                               NULL);
1204         if (length)
1205                 goto out;
1206
1207         length = -ENOMEM;
1208         scon = kzalloc(size + 1, GFP_KERNEL);
1209         if (!scon)
1210                 goto out;
1211
1212         length = -ENOMEM;
1213         tcon = kzalloc(size + 1, GFP_KERNEL);
1214         if (!tcon)
1215                 goto out;
1216
1217         length = -EINVAL;
1218         if (sscanf(buf, "%s %s %hu", scon, tcon, &tclass) != 3)
1219                 goto out;
1220
1221         length = security_context_str_to_sid(state, scon, &ssid, GFP_KERNEL);
1222         if (length)
1223                 goto out;
1224
1225         length = security_context_str_to_sid(state, tcon, &tsid, GFP_KERNEL);
1226         if (length)
1227                 goto out;
1228
1229         length = security_member_sid(state, ssid, tsid, tclass, &newsid);
1230         if (length)
1231                 goto out;
1232
1233         length = security_sid_to_context(state, newsid, &newcon, &len);
1234         if (length)
1235                 goto out;
1236
1237         length = -ERANGE;
1238         if (len > SIMPLE_TRANSACTION_LIMIT) {
1239                 pr_err("SELinux: %s:  context size (%u) exceeds "
1240                         "payload max\n", __func__, len);
1241                 goto out;
1242         }
1243
1244         memcpy(buf, newcon, len);
1245         length = len;
1246 out:
1247         kfree(newcon);
1248         kfree(tcon);
1249         kfree(scon);
1250         return length;
1251 }
1252
1253 static struct inode *sel_make_inode(struct super_block *sb, int mode)
1254 {
1255         struct inode *ret = new_inode(sb);
1256
1257         if (ret) {
1258                 ret->i_mode = mode;
1259                 ret->i_atime = ret->i_mtime = ret->i_ctime = current_time(ret);
1260         }
1261         return ret;
1262 }
1263
1264 static ssize_t sel_read_bool(struct file *filep, char __user *buf,
1265                              size_t count, loff_t *ppos)
1266 {
1267         struct selinux_fs_info *fsi = file_inode(filep)->i_sb->s_fs_info;
1268         char *page = NULL;
1269         ssize_t length;
1270         ssize_t ret;
1271         int cur_enforcing;
1272         unsigned index = file_inode(filep)->i_ino & SEL_INO_MASK;
1273         const char *name = filep->f_path.dentry->d_name.name;
1274
1275         mutex_lock(&fsi->state->policy_mutex);
1276
1277         ret = -EINVAL;
1278         if (index >= fsi->bool_num || strcmp(name,
1279                                              fsi->bool_pending_names[index]))
1280                 goto out_unlock;
1281
1282         ret = -ENOMEM;
1283         page = (char *)get_zeroed_page(GFP_KERNEL);
1284         if (!page)
1285                 goto out_unlock;
1286
1287         cur_enforcing = security_get_bool_value(fsi->state, index);
1288         if (cur_enforcing < 0) {
1289                 ret = cur_enforcing;
1290                 goto out_unlock;
1291         }
1292         length = scnprintf(page, PAGE_SIZE, "%d %d", cur_enforcing,
1293                           fsi->bool_pending_values[index]);
1294         mutex_unlock(&fsi->state->policy_mutex);
1295         ret = simple_read_from_buffer(buf, count, ppos, page, length);
1296 out_free:
1297         free_page((unsigned long)page);
1298         return ret;
1299
1300 out_unlock:
1301         mutex_unlock(&fsi->state->policy_mutex);
1302         goto out_free;
1303 }
1304
1305 static ssize_t sel_write_bool(struct file *filep, const char __user *buf,
1306                               size_t count, loff_t *ppos)
1307 {
1308         struct selinux_fs_info *fsi = file_inode(filep)->i_sb->s_fs_info;
1309         char *page = NULL;
1310         ssize_t length;
1311         int new_value;
1312         unsigned index = file_inode(filep)->i_ino & SEL_INO_MASK;
1313         const char *name = filep->f_path.dentry->d_name.name;
1314
1315         if (count >= PAGE_SIZE)
1316                 return -ENOMEM;
1317
1318         /* No partial writes. */
1319         if (*ppos != 0)
1320                 return -EINVAL;
1321
1322         page = memdup_user_nul(buf, count);
1323         if (IS_ERR(page))
1324                 return PTR_ERR(page);
1325
1326         mutex_lock(&fsi->state->policy_mutex);
1327
1328         length = avc_has_perm(&selinux_state,
1329                               current_sid(), SECINITSID_SECURITY,
1330                               SECCLASS_SECURITY, SECURITY__SETBOOL,
1331                               NULL);
1332         if (length)
1333                 goto out;
1334
1335         length = -EINVAL;
1336         if (index >= fsi->bool_num || strcmp(name,
1337                                              fsi->bool_pending_names[index]))
1338                 goto out;
1339
1340         length = -EINVAL;
1341         if (sscanf(page, "%d", &new_value) != 1)
1342                 goto out;
1343
1344         if (new_value)
1345                 new_value = 1;
1346
1347         fsi->bool_pending_values[index] = new_value;
1348         length = count;
1349
1350 out:
1351         mutex_unlock(&fsi->state->policy_mutex);
1352         kfree(page);
1353         return length;
1354 }
1355
1356 static const struct file_operations sel_bool_ops = {
1357         .read           = sel_read_bool,
1358         .write          = sel_write_bool,
1359         .llseek         = generic_file_llseek,
1360 };
1361
1362 static ssize_t sel_commit_bools_write(struct file *filep,
1363                                       const char __user *buf,
1364                                       size_t count, loff_t *ppos)
1365 {
1366         struct selinux_fs_info *fsi = file_inode(filep)->i_sb->s_fs_info;
1367         char *page = NULL;
1368         ssize_t length;
1369         int new_value;
1370
1371         if (count >= PAGE_SIZE)
1372                 return -ENOMEM;
1373
1374         /* No partial writes. */
1375         if (*ppos != 0)
1376                 return -EINVAL;
1377
1378         page = memdup_user_nul(buf, count);
1379         if (IS_ERR(page))
1380                 return PTR_ERR(page);
1381
1382         mutex_lock(&fsi->state->policy_mutex);
1383
1384         length = avc_has_perm(&selinux_state,
1385                               current_sid(), SECINITSID_SECURITY,
1386                               SECCLASS_SECURITY, SECURITY__SETBOOL,
1387                               NULL);
1388         if (length)
1389                 goto out;
1390
1391         length = -EINVAL;
1392         if (sscanf(page, "%d", &new_value) != 1)
1393                 goto out;
1394
1395         length = 0;
1396         if (new_value && fsi->bool_pending_values)
1397                 length = security_set_bools(fsi->state, fsi->bool_num,
1398                                             fsi->bool_pending_values);
1399
1400         if (!length)
1401                 length = count;
1402
1403 out:
1404         mutex_unlock(&fsi->state->policy_mutex);
1405         kfree(page);
1406         return length;
1407 }
1408
1409 static const struct file_operations sel_commit_bools_ops = {
1410         .write          = sel_commit_bools_write,
1411         .llseek         = generic_file_llseek,
1412 };
1413
1414 static void sel_remove_entries(struct dentry *de)
1415 {
1416         d_genocide(de);
1417         shrink_dcache_parent(de);
1418 }
1419
1420 static int sel_make_bools(struct selinux_policy *newpolicy, struct dentry *bool_dir,
1421                           unsigned int *bool_num, char ***bool_pending_names,
1422                           unsigned int **bool_pending_values)
1423 {
1424         int ret;
1425         ssize_t len;
1426         struct dentry *dentry = NULL;
1427         struct inode *inode = NULL;
1428         struct inode_security_struct *isec;
1429         char **names = NULL, *page;
1430         u32 i, num;
1431         int *values = NULL;
1432         u32 sid;
1433
1434         ret = -ENOMEM;
1435         page = (char *)get_zeroed_page(GFP_KERNEL);
1436         if (!page)
1437                 goto out;
1438
1439         ret = security_get_bools(newpolicy, &num, &names, &values);
1440         if (ret)
1441                 goto out;
1442
1443         for (i = 0; i < num; i++) {
1444                 ret = -ENOMEM;
1445                 dentry = d_alloc_name(bool_dir, names[i]);
1446                 if (!dentry)
1447                         goto out;
1448
1449                 ret = -ENOMEM;
1450                 inode = sel_make_inode(bool_dir->d_sb, S_IFREG | S_IRUGO | S_IWUSR);
1451                 if (!inode) {
1452                         dput(dentry);
1453                         goto out;
1454                 }
1455
1456                 ret = -ENAMETOOLONG;
1457                 len = snprintf(page, PAGE_SIZE, "/%s/%s", BOOL_DIR_NAME, names[i]);
1458                 if (len >= PAGE_SIZE) {
1459                         dput(dentry);
1460                         iput(inode);
1461                         goto out;
1462                 }
1463
1464                 isec = selinux_inode(inode);
1465                 ret = selinux_policy_genfs_sid(newpolicy, "selinuxfs", page,
1466                                          SECCLASS_FILE, &sid);
1467                 if (ret) {
1468                         pr_warn_ratelimited("SELinux: no sid found, defaulting to security isid for %s\n",
1469                                            page);
1470                         sid = SECINITSID_SECURITY;
1471                 }
1472
1473                 isec->sid = sid;
1474                 isec->initialized = LABEL_INITIALIZED;
1475                 inode->i_fop = &sel_bool_ops;
1476                 inode->i_ino = i|SEL_BOOL_INO_OFFSET;
1477                 d_add(dentry, inode);
1478         }
1479         *bool_num = num;
1480         *bool_pending_names = names;
1481         *bool_pending_values = values;
1482
1483         free_page((unsigned long)page);
1484         return 0;
1485 out:
1486         free_page((unsigned long)page);
1487
1488         if (names) {
1489                 for (i = 0; i < num; i++)
1490                         kfree(names[i]);
1491                 kfree(names);
1492         }
1493         kfree(values);
1494         sel_remove_entries(bool_dir);
1495
1496         return ret;
1497 }
1498
1499 static ssize_t sel_read_avc_cache_threshold(struct file *filp, char __user *buf,
1500                                             size_t count, loff_t *ppos)
1501 {
1502         struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
1503         struct selinux_state *state = fsi->state;
1504         char tmpbuf[TMPBUFLEN];
1505         ssize_t length;
1506
1507         length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
1508                            avc_get_cache_threshold(state->avc));
1509         return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
1510 }
1511
1512 static ssize_t sel_write_avc_cache_threshold(struct file *file,
1513                                              const char __user *buf,
1514                                              size_t count, loff_t *ppos)
1515
1516 {
1517         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
1518         struct selinux_state *state = fsi->state;
1519         char *page;
1520         ssize_t ret;
1521         unsigned int new_value;
1522
1523         ret = avc_has_perm(&selinux_state,
1524                            current_sid(), SECINITSID_SECURITY,
1525                            SECCLASS_SECURITY, SECURITY__SETSECPARAM,
1526                            NULL);
1527         if (ret)
1528                 return ret;
1529
1530         if (count >= PAGE_SIZE)
1531                 return -ENOMEM;
1532
1533         /* No partial writes. */
1534         if (*ppos != 0)
1535                 return -EINVAL;
1536
1537         page = memdup_user_nul(buf, count);
1538         if (IS_ERR(page))
1539                 return PTR_ERR(page);
1540
1541         ret = -EINVAL;
1542         if (sscanf(page, "%u", &new_value) != 1)
1543                 goto out;
1544
1545         avc_set_cache_threshold(state->avc, new_value);
1546
1547         ret = count;
1548 out:
1549         kfree(page);
1550         return ret;
1551 }
1552
1553 static ssize_t sel_read_avc_hash_stats(struct file *filp, char __user *buf,
1554                                        size_t count, loff_t *ppos)
1555 {
1556         struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
1557         struct selinux_state *state = fsi->state;
1558         char *page;
1559         ssize_t length;
1560
1561         page = (char *)__get_free_page(GFP_KERNEL);
1562         if (!page)
1563                 return -ENOMEM;
1564
1565         length = avc_get_hash_stats(state->avc, page);
1566         if (length >= 0)
1567                 length = simple_read_from_buffer(buf, count, ppos, page, length);
1568         free_page((unsigned long)page);
1569
1570         return length;
1571 }
1572
1573 static ssize_t sel_read_sidtab_hash_stats(struct file *filp, char __user *buf,
1574                                         size_t count, loff_t *ppos)
1575 {
1576         struct selinux_fs_info *fsi = file_inode(filp)->i_sb->s_fs_info;
1577         struct selinux_state *state = fsi->state;
1578         char *page;
1579         ssize_t length;
1580
1581         page = (char *)__get_free_page(GFP_KERNEL);
1582         if (!page)
1583                 return -ENOMEM;
1584
1585         length = security_sidtab_hash_stats(state, page);
1586         if (length >= 0)
1587                 length = simple_read_from_buffer(buf, count, ppos, page,
1588                                                 length);
1589         free_page((unsigned long)page);
1590
1591         return length;
1592 }
1593
1594 static const struct file_operations sel_sidtab_hash_stats_ops = {
1595         .read           = sel_read_sidtab_hash_stats,
1596         .llseek         = generic_file_llseek,
1597 };
1598
1599 static const struct file_operations sel_avc_cache_threshold_ops = {
1600         .read           = sel_read_avc_cache_threshold,
1601         .write          = sel_write_avc_cache_threshold,
1602         .llseek         = generic_file_llseek,
1603 };
1604
1605 static const struct file_operations sel_avc_hash_stats_ops = {
1606         .read           = sel_read_avc_hash_stats,
1607         .llseek         = generic_file_llseek,
1608 };
1609
1610 #ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
1611 static struct avc_cache_stats *sel_avc_get_stat_idx(loff_t *idx)
1612 {
1613         int cpu;
1614
1615         for (cpu = *idx; cpu < nr_cpu_ids; ++cpu) {
1616                 if (!cpu_possible(cpu))
1617                         continue;
1618                 *idx = cpu + 1;
1619                 return &per_cpu(avc_cache_stats, cpu);
1620         }
1621         (*idx)++;
1622         return NULL;
1623 }
1624
1625 static void *sel_avc_stats_seq_start(struct seq_file *seq, loff_t *pos)
1626 {
1627         loff_t n = *pos - 1;
1628
1629         if (*pos == 0)
1630                 return SEQ_START_TOKEN;
1631
1632         return sel_avc_get_stat_idx(&n);
1633 }
1634
1635 static void *sel_avc_stats_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1636 {
1637         return sel_avc_get_stat_idx(pos);
1638 }
1639
1640 static int sel_avc_stats_seq_show(struct seq_file *seq, void *v)
1641 {
1642         struct avc_cache_stats *st = v;
1643
1644         if (v == SEQ_START_TOKEN) {
1645                 seq_puts(seq,
1646                          "lookups hits misses allocations reclaims frees\n");
1647         } else {
1648                 unsigned int lookups = st->lookups;
1649                 unsigned int misses = st->misses;
1650                 unsigned int hits = lookups - misses;
1651                 seq_printf(seq, "%u %u %u %u %u %u\n", lookups,
1652                            hits, misses, st->allocations,
1653                            st->reclaims, st->frees);
1654         }
1655         return 0;
1656 }
1657
1658 static void sel_avc_stats_seq_stop(struct seq_file *seq, void *v)
1659 { }
1660
1661 static const struct seq_operations sel_avc_cache_stats_seq_ops = {
1662         .start          = sel_avc_stats_seq_start,
1663         .next           = sel_avc_stats_seq_next,
1664         .show           = sel_avc_stats_seq_show,
1665         .stop           = sel_avc_stats_seq_stop,
1666 };
1667
1668 static int sel_open_avc_cache_stats(struct inode *inode, struct file *file)
1669 {
1670         return seq_open(file, &sel_avc_cache_stats_seq_ops);
1671 }
1672
1673 static const struct file_operations sel_avc_cache_stats_ops = {
1674         .open           = sel_open_avc_cache_stats,
1675         .read           = seq_read,
1676         .llseek         = seq_lseek,
1677         .release        = seq_release,
1678 };
1679 #endif
1680
1681 static int sel_make_avc_files(struct dentry *dir)
1682 {
1683         struct super_block *sb = dir->d_sb;
1684         struct selinux_fs_info *fsi = sb->s_fs_info;
1685         int i;
1686         static const struct tree_descr files[] = {
1687                 { "cache_threshold",
1688                   &sel_avc_cache_threshold_ops, S_IRUGO|S_IWUSR },
1689                 { "hash_stats", &sel_avc_hash_stats_ops, S_IRUGO },
1690 #ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
1691                 { "cache_stats", &sel_avc_cache_stats_ops, S_IRUGO },
1692 #endif
1693         };
1694
1695         for (i = 0; i < ARRAY_SIZE(files); i++) {
1696                 struct inode *inode;
1697                 struct dentry *dentry;
1698
1699                 dentry = d_alloc_name(dir, files[i].name);
1700                 if (!dentry)
1701                         return -ENOMEM;
1702
1703                 inode = sel_make_inode(dir->d_sb, S_IFREG|files[i].mode);
1704                 if (!inode) {
1705                         dput(dentry);
1706                         return -ENOMEM;
1707                 }
1708
1709                 inode->i_fop = files[i].ops;
1710                 inode->i_ino = ++fsi->last_ino;
1711                 d_add(dentry, inode);
1712         }
1713
1714         return 0;
1715 }
1716
1717 static int sel_make_ss_files(struct dentry *dir)
1718 {
1719         struct super_block *sb = dir->d_sb;
1720         struct selinux_fs_info *fsi = sb->s_fs_info;
1721         int i;
1722         static struct tree_descr files[] = {
1723                 { "sidtab_hash_stats", &sel_sidtab_hash_stats_ops, S_IRUGO },
1724         };
1725
1726         for (i = 0; i < ARRAY_SIZE(files); i++) {
1727                 struct inode *inode;
1728                 struct dentry *dentry;
1729
1730                 dentry = d_alloc_name(dir, files[i].name);
1731                 if (!dentry)
1732                         return -ENOMEM;
1733
1734                 inode = sel_make_inode(dir->d_sb, S_IFREG|files[i].mode);
1735                 if (!inode) {
1736                         dput(dentry);
1737                         return -ENOMEM;
1738                 }
1739
1740                 inode->i_fop = files[i].ops;
1741                 inode->i_ino = ++fsi->last_ino;
1742                 d_add(dentry, inode);
1743         }
1744
1745         return 0;
1746 }
1747
1748 static ssize_t sel_read_initcon(struct file *file, char __user *buf,
1749                                 size_t count, loff_t *ppos)
1750 {
1751         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
1752         char *con;
1753         u32 sid, len;
1754         ssize_t ret;
1755
1756         sid = file_inode(file)->i_ino&SEL_INO_MASK;
1757         ret = security_sid_to_context(fsi->state, sid, &con, &len);
1758         if (ret)
1759                 return ret;
1760
1761         ret = simple_read_from_buffer(buf, count, ppos, con, len);
1762         kfree(con);
1763         return ret;
1764 }
1765
1766 static const struct file_operations sel_initcon_ops = {
1767         .read           = sel_read_initcon,
1768         .llseek         = generic_file_llseek,
1769 };
1770
1771 static int sel_make_initcon_files(struct dentry *dir)
1772 {
1773         int i;
1774
1775         for (i = 1; i <= SECINITSID_NUM; i++) {
1776                 struct inode *inode;
1777                 struct dentry *dentry;
1778                 const char *s = security_get_initial_sid_context(i);
1779
1780                 if (!s)
1781                         continue;
1782                 dentry = d_alloc_name(dir, s);
1783                 if (!dentry)
1784                         return -ENOMEM;
1785
1786                 inode = sel_make_inode(dir->d_sb, S_IFREG|S_IRUGO);
1787                 if (!inode) {
1788                         dput(dentry);
1789                         return -ENOMEM;
1790                 }
1791
1792                 inode->i_fop = &sel_initcon_ops;
1793                 inode->i_ino = i|SEL_INITCON_INO_OFFSET;
1794                 d_add(dentry, inode);
1795         }
1796
1797         return 0;
1798 }
1799
1800 static inline unsigned long sel_class_to_ino(u16 class)
1801 {
1802         return (class * (SEL_VEC_MAX + 1)) | SEL_CLASS_INO_OFFSET;
1803 }
1804
1805 static inline u16 sel_ino_to_class(unsigned long ino)
1806 {
1807         return (ino & SEL_INO_MASK) / (SEL_VEC_MAX + 1);
1808 }
1809
1810 static inline unsigned long sel_perm_to_ino(u16 class, u32 perm)
1811 {
1812         return (class * (SEL_VEC_MAX + 1) + perm) | SEL_CLASS_INO_OFFSET;
1813 }
1814
1815 static inline u32 sel_ino_to_perm(unsigned long ino)
1816 {
1817         return (ino & SEL_INO_MASK) % (SEL_VEC_MAX + 1);
1818 }
1819
1820 static ssize_t sel_read_class(struct file *file, char __user *buf,
1821                                 size_t count, loff_t *ppos)
1822 {
1823         unsigned long ino = file_inode(file)->i_ino;
1824         char res[TMPBUFLEN];
1825         ssize_t len = scnprintf(res, sizeof(res), "%d", sel_ino_to_class(ino));
1826         return simple_read_from_buffer(buf, count, ppos, res, len);
1827 }
1828
1829 static const struct file_operations sel_class_ops = {
1830         .read           = sel_read_class,
1831         .llseek         = generic_file_llseek,
1832 };
1833
1834 static ssize_t sel_read_perm(struct file *file, char __user *buf,
1835                                 size_t count, loff_t *ppos)
1836 {
1837         unsigned long ino = file_inode(file)->i_ino;
1838         char res[TMPBUFLEN];
1839         ssize_t len = scnprintf(res, sizeof(res), "%d", sel_ino_to_perm(ino));
1840         return simple_read_from_buffer(buf, count, ppos, res, len);
1841 }
1842
1843 static const struct file_operations sel_perm_ops = {
1844         .read           = sel_read_perm,
1845         .llseek         = generic_file_llseek,
1846 };
1847
1848 static ssize_t sel_read_policycap(struct file *file, char __user *buf,
1849                                   size_t count, loff_t *ppos)
1850 {
1851         struct selinux_fs_info *fsi = file_inode(file)->i_sb->s_fs_info;
1852         int value;
1853         char tmpbuf[TMPBUFLEN];
1854         ssize_t length;
1855         unsigned long i_ino = file_inode(file)->i_ino;
1856
1857         value = security_policycap_supported(fsi->state, i_ino & SEL_INO_MASK);
1858         length = scnprintf(tmpbuf, TMPBUFLEN, "%d", value);
1859
1860         return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
1861 }
1862
1863 static const struct file_operations sel_policycap_ops = {
1864         .read           = sel_read_policycap,
1865         .llseek         = generic_file_llseek,
1866 };
1867
1868 static int sel_make_perm_files(struct selinux_policy *newpolicy,
1869                         char *objclass, int classvalue,
1870                         struct dentry *dir)
1871 {
1872         int i, rc, nperms;
1873         char **perms;
1874
1875         rc = security_get_permissions(newpolicy, objclass, &perms, &nperms);
1876         if (rc)
1877                 return rc;
1878
1879         for (i = 0; i < nperms; i++) {
1880                 struct inode *inode;
1881                 struct dentry *dentry;
1882
1883                 rc = -ENOMEM;
1884                 dentry = d_alloc_name(dir, perms[i]);
1885                 if (!dentry)
1886                         goto out;
1887
1888                 rc = -ENOMEM;
1889                 inode = sel_make_inode(dir->d_sb, S_IFREG|S_IRUGO);
1890                 if (!inode) {
1891                         dput(dentry);
1892                         goto out;
1893                 }
1894
1895                 inode->i_fop = &sel_perm_ops;
1896                 /* i+1 since perm values are 1-indexed */
1897                 inode->i_ino = sel_perm_to_ino(classvalue, i + 1);
1898                 d_add(dentry, inode);
1899         }
1900         rc = 0;
1901 out:
1902         for (i = 0; i < nperms; i++)
1903                 kfree(perms[i]);
1904         kfree(perms);
1905         return rc;
1906 }
1907
1908 static int sel_make_class_dir_entries(struct selinux_policy *newpolicy,
1909                                 char *classname, int index,
1910                                 struct dentry *dir)
1911 {
1912         struct super_block *sb = dir->d_sb;
1913         struct selinux_fs_info *fsi = sb->s_fs_info;
1914         struct dentry *dentry = NULL;
1915         struct inode *inode = NULL;
1916         int rc;
1917
1918         dentry = d_alloc_name(dir, "index");
1919         if (!dentry)
1920                 return -ENOMEM;
1921
1922         inode = sel_make_inode(dir->d_sb, S_IFREG|S_IRUGO);
1923         if (!inode) {
1924                 dput(dentry);
1925                 return -ENOMEM;
1926         }
1927
1928         inode->i_fop = &sel_class_ops;
1929         inode->i_ino = sel_class_to_ino(index);
1930         d_add(dentry, inode);
1931
1932         dentry = sel_make_dir(dir, "perms", &fsi->last_class_ino);
1933         if (IS_ERR(dentry))
1934                 return PTR_ERR(dentry);
1935
1936         rc = sel_make_perm_files(newpolicy, classname, index, dentry);
1937
1938         return rc;
1939 }
1940
1941 static int sel_make_classes(struct selinux_policy *newpolicy,
1942                             struct dentry *class_dir,
1943                             unsigned long *last_class_ino)
1944 {
1945
1946         int rc, nclasses, i;
1947         char **classes;
1948
1949         rc = security_get_classes(newpolicy, &classes, &nclasses);
1950         if (rc)
1951                 return rc;
1952
1953         /* +2 since classes are 1-indexed */
1954         *last_class_ino = sel_class_to_ino(nclasses + 2);
1955
1956         for (i = 0; i < nclasses; i++) {
1957                 struct dentry *class_name_dir;
1958
1959                 class_name_dir = sel_make_dir(class_dir, classes[i],
1960                                               last_class_ino);
1961                 if (IS_ERR(class_name_dir)) {
1962                         rc = PTR_ERR(class_name_dir);
1963                         goto out;
1964                 }
1965
1966                 /* i+1 since class values are 1-indexed */
1967                 rc = sel_make_class_dir_entries(newpolicy, classes[i], i + 1,
1968                                 class_name_dir);
1969                 if (rc)
1970                         goto out;
1971         }
1972         rc = 0;
1973 out:
1974         for (i = 0; i < nclasses; i++)
1975                 kfree(classes[i]);
1976         kfree(classes);
1977         return rc;
1978 }
1979
1980 static int sel_make_policycap(struct selinux_fs_info *fsi)
1981 {
1982         unsigned int iter;
1983         struct dentry *dentry = NULL;
1984         struct inode *inode = NULL;
1985
1986         for (iter = 0; iter <= POLICYDB_CAPABILITY_MAX; iter++) {
1987                 if (iter < ARRAY_SIZE(selinux_policycap_names))
1988                         dentry = d_alloc_name(fsi->policycap_dir,
1989                                               selinux_policycap_names[iter]);
1990                 else
1991                         dentry = d_alloc_name(fsi->policycap_dir, "unknown");
1992
1993                 if (dentry == NULL)
1994                         return -ENOMEM;
1995
1996                 inode = sel_make_inode(fsi->sb, S_IFREG | 0444);
1997                 if (inode == NULL) {
1998                         dput(dentry);
1999                         return -ENOMEM;
2000                 }
2001
2002                 inode->i_fop = &sel_policycap_ops;
2003                 inode->i_ino = iter | SEL_POLICYCAP_INO_OFFSET;
2004                 d_add(dentry, inode);
2005         }
2006
2007         return 0;
2008 }
2009
2010 static struct dentry *sel_make_dir(struct dentry *dir, const char *name,
2011                         unsigned long *ino)
2012 {
2013         struct dentry *dentry = d_alloc_name(dir, name);
2014         struct inode *inode;
2015
2016         if (!dentry)
2017                 return ERR_PTR(-ENOMEM);
2018
2019         inode = sel_make_inode(dir->d_sb, S_IFDIR | S_IRUGO | S_IXUGO);
2020         if (!inode) {
2021                 dput(dentry);
2022                 return ERR_PTR(-ENOMEM);
2023         }
2024
2025         inode->i_op = &simple_dir_inode_operations;
2026         inode->i_fop = &simple_dir_operations;
2027         inode->i_ino = ++(*ino);
2028         /* directory inodes start off with i_nlink == 2 (for "." entry) */
2029         inc_nlink(inode);
2030         d_add(dentry, inode);
2031         /* bump link count on parent directory, too */
2032         inc_nlink(d_inode(dir));
2033
2034         return dentry;
2035 }
2036
2037 static struct dentry *sel_make_disconnected_dir(struct super_block *sb,
2038                                                 unsigned long *ino)
2039 {
2040         struct inode *inode = sel_make_inode(sb, S_IFDIR | S_IRUGO | S_IXUGO);
2041
2042         if (!inode)
2043                 return ERR_PTR(-ENOMEM);
2044
2045         inode->i_op = &simple_dir_inode_operations;
2046         inode->i_fop = &simple_dir_operations;
2047         inode->i_ino = ++(*ino);
2048         /* directory inodes start off with i_nlink == 2 (for "." entry) */
2049         inc_nlink(inode);
2050         return d_obtain_alias(inode);
2051 }
2052
2053 #define NULL_FILE_NAME "null"
2054
2055 static int sel_fill_super(struct super_block *sb, struct fs_context *fc)
2056 {
2057         struct selinux_fs_info *fsi;
2058         int ret;
2059         struct dentry *dentry;
2060         struct inode *inode;
2061         struct inode_security_struct *isec;
2062
2063         static const struct tree_descr selinux_files[] = {
2064                 [SEL_LOAD] = {"load", &sel_load_ops, S_IRUSR|S_IWUSR},
2065                 [SEL_ENFORCE] = {"enforce", &sel_enforce_ops, S_IRUGO|S_IWUSR},
2066                 [SEL_CONTEXT] = {"context", &transaction_ops, S_IRUGO|S_IWUGO},
2067                 [SEL_ACCESS] = {"access", &transaction_ops, S_IRUGO|S_IWUGO},
2068                 [SEL_CREATE] = {"create", &transaction_ops, S_IRUGO|S_IWUGO},
2069                 [SEL_RELABEL] = {"relabel", &transaction_ops, S_IRUGO|S_IWUGO},
2070                 [SEL_USER] = {"user", &transaction_ops, S_IRUGO|S_IWUGO},
2071                 [SEL_POLICYVERS] = {"policyvers", &sel_policyvers_ops, S_IRUGO},
2072                 [SEL_COMMIT_BOOLS] = {"commit_pending_bools", &sel_commit_bools_ops, S_IWUSR},
2073                 [SEL_MLS] = {"mls", &sel_mls_ops, S_IRUGO},
2074                 [SEL_DISABLE] = {"disable", &sel_disable_ops, S_IWUSR},
2075                 [SEL_MEMBER] = {"member", &transaction_ops, S_IRUGO|S_IWUGO},
2076                 [SEL_CHECKREQPROT] = {"checkreqprot", &sel_checkreqprot_ops, S_IRUGO|S_IWUSR},
2077                 [SEL_REJECT_UNKNOWN] = {"reject_unknown", &sel_handle_unknown_ops, S_IRUGO},
2078                 [SEL_DENY_UNKNOWN] = {"deny_unknown", &sel_handle_unknown_ops, S_IRUGO},
2079                 [SEL_STATUS] = {"status", &sel_handle_status_ops, S_IRUGO},
2080                 [SEL_POLICY] = {"policy", &sel_policy_ops, S_IRUGO},
2081                 [SEL_VALIDATE_TRANS] = {"validatetrans", &sel_transition_ops,
2082                                         S_IWUGO},
2083                 /* last one */ {""}
2084         };
2085
2086         ret = selinux_fs_info_create(sb);
2087         if (ret)
2088                 goto err;
2089
2090         ret = simple_fill_super(sb, SELINUX_MAGIC, selinux_files);
2091         if (ret)
2092                 goto err;
2093
2094         fsi = sb->s_fs_info;
2095         fsi->bool_dir = sel_make_dir(sb->s_root, BOOL_DIR_NAME, &fsi->last_ino);
2096         if (IS_ERR(fsi->bool_dir)) {
2097                 ret = PTR_ERR(fsi->bool_dir);
2098                 fsi->bool_dir = NULL;
2099                 goto err;
2100         }
2101
2102         ret = -ENOMEM;
2103         dentry = d_alloc_name(sb->s_root, NULL_FILE_NAME);
2104         if (!dentry)
2105                 goto err;
2106
2107         ret = -ENOMEM;
2108         inode = sel_make_inode(sb, S_IFCHR | S_IRUGO | S_IWUGO);
2109         if (!inode) {
2110                 dput(dentry);
2111                 goto err;
2112         }
2113
2114         inode->i_ino = ++fsi->last_ino;
2115         isec = selinux_inode(inode);
2116         isec->sid = SECINITSID_DEVNULL;
2117         isec->sclass = SECCLASS_CHR_FILE;
2118         isec->initialized = LABEL_INITIALIZED;
2119
2120         init_special_inode(inode, S_IFCHR | S_IRUGO | S_IWUGO, MKDEV(MEM_MAJOR, 3));
2121         d_add(dentry, inode);
2122
2123         dentry = sel_make_dir(sb->s_root, "avc", &fsi->last_ino);
2124         if (IS_ERR(dentry)) {
2125                 ret = PTR_ERR(dentry);
2126                 goto err;
2127         }
2128
2129         ret = sel_make_avc_files(dentry);
2130         if (ret)
2131                 goto err;
2132
2133         dentry = sel_make_dir(sb->s_root, "ss", &fsi->last_ino);
2134         if (IS_ERR(dentry)) {
2135                 ret = PTR_ERR(dentry);
2136                 goto err;
2137         }
2138
2139         ret = sel_make_ss_files(dentry);
2140         if (ret)
2141                 goto err;
2142
2143         dentry = sel_make_dir(sb->s_root, "initial_contexts", &fsi->last_ino);
2144         if (IS_ERR(dentry)) {
2145                 ret = PTR_ERR(dentry);
2146                 goto err;
2147         }
2148
2149         ret = sel_make_initcon_files(dentry);
2150         if (ret)
2151                 goto err;
2152
2153         fsi->class_dir = sel_make_dir(sb->s_root, CLASS_DIR_NAME, &fsi->last_ino);
2154         if (IS_ERR(fsi->class_dir)) {
2155                 ret = PTR_ERR(fsi->class_dir);
2156                 fsi->class_dir = NULL;
2157                 goto err;
2158         }
2159
2160         fsi->policycap_dir = sel_make_dir(sb->s_root, POLICYCAP_DIR_NAME,
2161                                           &fsi->last_ino);
2162         if (IS_ERR(fsi->policycap_dir)) {
2163                 ret = PTR_ERR(fsi->policycap_dir);
2164                 fsi->policycap_dir = NULL;
2165                 goto err;
2166         }
2167
2168         ret = sel_make_policycap(fsi);
2169         if (ret) {
2170                 pr_err("SELinux: failed to load policy capabilities\n");
2171                 goto err;
2172         }
2173
2174         return 0;
2175 err:
2176         pr_err("SELinux: %s:  failed while creating inodes\n",
2177                 __func__);
2178
2179         selinux_fs_info_free(sb);
2180
2181         return ret;
2182 }
2183
2184 static int sel_get_tree(struct fs_context *fc)
2185 {
2186         return get_tree_single(fc, sel_fill_super);
2187 }
2188
2189 static const struct fs_context_operations sel_context_ops = {
2190         .get_tree       = sel_get_tree,
2191 };
2192
2193 static int sel_init_fs_context(struct fs_context *fc)
2194 {
2195         fc->ops = &sel_context_ops;
2196         return 0;
2197 }
2198
2199 static void sel_kill_sb(struct super_block *sb)
2200 {
2201         selinux_fs_info_free(sb);
2202         kill_litter_super(sb);
2203 }
2204
2205 static struct file_system_type sel_fs_type = {
2206         .name           = "selinuxfs",
2207         .init_fs_context = sel_init_fs_context,
2208         .kill_sb        = sel_kill_sb,
2209 };
2210
2211 static struct vfsmount *selinuxfs_mount __ro_after_init;
2212 struct path selinux_null __ro_after_init;
2213
2214 static int __init init_sel_fs(void)
2215 {
2216         struct qstr null_name = QSTR_INIT(NULL_FILE_NAME,
2217                                           sizeof(NULL_FILE_NAME)-1);
2218         int err;
2219
2220         if (!selinux_enabled_boot)
2221                 return 0;
2222
2223         err = sysfs_create_mount_point(fs_kobj, "selinux");
2224         if (err)
2225                 return err;
2226
2227         err = register_filesystem(&sel_fs_type);
2228         if (err) {
2229                 sysfs_remove_mount_point(fs_kobj, "selinux");
2230                 return err;
2231         }
2232
2233         selinux_null.mnt = selinuxfs_mount = kern_mount(&sel_fs_type);
2234         if (IS_ERR(selinuxfs_mount)) {
2235                 pr_err("selinuxfs:  could not mount!\n");
2236                 err = PTR_ERR(selinuxfs_mount);
2237                 selinuxfs_mount = NULL;
2238         }
2239         selinux_null.dentry = d_hash_and_lookup(selinux_null.mnt->mnt_root,
2240                                                 &null_name);
2241         if (IS_ERR(selinux_null.dentry)) {
2242                 pr_err("selinuxfs:  could not lookup null!\n");
2243                 err = PTR_ERR(selinux_null.dentry);
2244                 selinux_null.dentry = NULL;
2245         }
2246
2247         return err;
2248 }
2249
2250 __initcall(init_sel_fs);
2251
2252 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
2253 void exit_sel_fs(void)
2254 {
2255         sysfs_remove_mount_point(fs_kobj, "selinux");
2256         dput(selinux_null.dentry);
2257         kern_unmount(selinuxfs_mount);
2258         unregister_filesystem(&sel_fs_type);
2259 }
2260 #endif