~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/security/selinux/selinuxfs.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp