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