LCOV - code coverage report
Current view: top level - security/selinux - selinuxfs.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 198 1100 18.0 %
Date: 2022-04-01 14:17:54 Functions: 15 59 25.4 %
Branches: 45 436 10.3 %

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

Generated by: LCOV version 1.14