1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Updated: Karl MacMillan <kmacmillan@tresys.com>
4 * Added conditional policy language extensions
6 * Updated: Hewlett-Packard <paul@paul-moore.com>
8 * Added support for the policy capability bitmap
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>
15 #include <linux/kernel.h>
16 #include <linux/pagemap.h>
17 #include <linux/slab.h>
18 #include <linux/vmalloc.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>
35 /* selinuxfs pseudo filesystem for exporting the security policy API.
36 Based on the proc code and the fs/nfsd/nfsctl.c code. */
43 #include "conditional.h"
47 SEL_LOAD
, /* load policy */
48 SEL_ENFORCE
, /* get or set enforcing status */
49 SEL_CONTEXT
, /* validate context */
50 SEL_ACCESS
, /* compute access decision */
51 SEL_CREATE
, /* compute create labeling decision */
52 SEL_RELABEL
, /* compute relabeling decision */
53 SEL_USER
, /* compute reachable user contexts */
54 SEL_POLICYVERS
, /* return policy version for this kernel */
55 SEL_COMMIT_BOOLS
, /* commit new boolean values */
56 SEL_MLS
, /* return if MLS policy is enabled */
57 SEL_DISABLE
, /* disable SELinux until next reboot */
58 SEL_MEMBER
, /* compute polyinstantiation membership decision */
59 SEL_CHECKREQPROT
, /* check requested protection, not kernel-applied one */
60 SEL_COMPAT_NET
, /* whether to use old compat network packet controls */
61 SEL_REJECT_UNKNOWN
, /* export unknown reject handling to userspace */
62 SEL_DENY_UNKNOWN
, /* export unknown deny handling to userspace */
63 SEL_STATUS
, /* export current status using mmap() */
64 SEL_POLICY
, /* allow userspace to read the in kernel policy */
65 SEL_VALIDATE_TRANS
, /* compute validatetrans decision */
66 SEL_INO_NEXT
, /* The next inode number to use */
69 struct selinux_fs_info
{
70 struct dentry
*bool_dir
;
71 unsigned int bool_num
;
72 char **bool_pending_names
;
73 unsigned int *bool_pending_values
;
74 struct dentry
*class_dir
;
75 unsigned long last_class_ino
;
77 struct dentry
*policycap_dir
;
78 unsigned long last_ino
;
79 struct selinux_state
*state
;
80 struct super_block
*sb
;
83 static int selinux_fs_info_create(struct super_block
*sb
)
85 struct selinux_fs_info
*fsi
;
87 fsi
= kzalloc(sizeof(*fsi
), GFP_KERNEL
);
91 fsi
->last_ino
= SEL_INO_NEXT
- 1;
92 fsi
->state
= &selinux_state
;
98 static void selinux_fs_info_free(struct super_block
*sb
)
100 struct selinux_fs_info
*fsi
= sb
->s_fs_info
;
104 for (i
= 0; i
< fsi
->bool_num
; i
++)
105 kfree(fsi
->bool_pending_names
[i
]);
106 kfree(fsi
->bool_pending_names
);
107 kfree(fsi
->bool_pending_values
);
109 kfree(sb
->s_fs_info
);
110 sb
->s_fs_info
= NULL
;
113 #define SEL_INITCON_INO_OFFSET 0x01000000
114 #define SEL_BOOL_INO_OFFSET 0x02000000
115 #define SEL_CLASS_INO_OFFSET 0x04000000
116 #define SEL_POLICYCAP_INO_OFFSET 0x08000000
117 #define SEL_INO_MASK 0x00ffffff
119 #define BOOL_DIR_NAME "booleans"
120 #define CLASS_DIR_NAME "class"
121 #define POLICYCAP_DIR_NAME "policy_capabilities"
124 static ssize_t
sel_read_enforce(struct file
*filp
, char __user
*buf
,
125 size_t count
, loff_t
*ppos
)
127 struct selinux_fs_info
*fsi
= file_inode(filp
)->i_sb
->s_fs_info
;
128 char tmpbuf
[TMPBUFLEN
];
131 length
= scnprintf(tmpbuf
, TMPBUFLEN
, "%d",
132 enforcing_enabled(fsi
->state
));
133 return simple_read_from_buffer(buf
, count
, ppos
, tmpbuf
, length
);
136 #ifdef CONFIG_SECURITY_SELINUX_DEVELOP
137 static ssize_t
sel_write_enforce(struct file
*file
, const char __user
*buf
,
138 size_t count
, loff_t
*ppos
)
141 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
142 struct selinux_state
*state
= fsi
->state
;
145 int old_value
, new_value
;
147 if (count
>= PAGE_SIZE
)
150 /* No partial writes. */
154 page
= memdup_user_nul(buf
, count
);
156 return PTR_ERR(page
);
159 if (sscanf(page
, "%d", &new_value
) != 1)
162 new_value
= !!new_value
;
164 old_value
= enforcing_enabled(state
);
165 if (new_value
!= old_value
) {
166 length
= avc_has_perm(&selinux_state
,
167 current_sid(), SECINITSID_SECURITY
,
168 SECCLASS_SECURITY
, SECURITY__SETENFORCE
,
172 audit_log(audit_context(), GFP_KERNEL
, AUDIT_MAC_STATUS
,
173 "enforcing=%d old_enforcing=%d auid=%u ses=%u"
174 " enabled=1 old-enabled=1 lsm=selinux res=1",
175 new_value
, old_value
,
176 from_kuid(&init_user_ns
, audit_get_loginuid(current
)),
177 audit_get_sessionid(current
));
178 enforcing_set(state
, new_value
);
180 avc_ss_reset(state
->avc
, 0);
181 selnl_notify_setenforce(new_value
);
182 selinux_status_update_setenforce(state
, new_value
);
184 call_blocking_lsm_notifier(LSM_POLICY_CHANGE
, NULL
);
192 #define sel_write_enforce NULL
195 static const struct file_operations sel_enforce_ops
= {
196 .read
= sel_read_enforce
,
197 .write
= sel_write_enforce
,
198 .llseek
= generic_file_llseek
,
201 static ssize_t
sel_read_handle_unknown(struct file
*filp
, char __user
*buf
,
202 size_t count
, loff_t
*ppos
)
204 struct selinux_fs_info
*fsi
= file_inode(filp
)->i_sb
->s_fs_info
;
205 struct selinux_state
*state
= fsi
->state
;
206 char tmpbuf
[TMPBUFLEN
];
208 ino_t ino
= file_inode(filp
)->i_ino
;
209 int handle_unknown
= (ino
== SEL_REJECT_UNKNOWN
) ?
210 security_get_reject_unknown(state
) :
211 !security_get_allow_unknown(state
);
213 length
= scnprintf(tmpbuf
, TMPBUFLEN
, "%d", handle_unknown
);
214 return simple_read_from_buffer(buf
, count
, ppos
, tmpbuf
, length
);
217 static const struct file_operations sel_handle_unknown_ops
= {
218 .read
= sel_read_handle_unknown
,
219 .llseek
= generic_file_llseek
,
222 static int sel_open_handle_status(struct inode
*inode
, struct file
*filp
)
224 struct selinux_fs_info
*fsi
= file_inode(filp
)->i_sb
->s_fs_info
;
225 struct page
*status
= selinux_kernel_status_page(fsi
->state
);
230 filp
->private_data
= status
;
235 static ssize_t
sel_read_handle_status(struct file
*filp
, char __user
*buf
,
236 size_t count
, loff_t
*ppos
)
238 struct page
*status
= filp
->private_data
;
242 return simple_read_from_buffer(buf
, count
, ppos
,
243 page_address(status
),
244 sizeof(struct selinux_kernel_status
));
247 static int sel_mmap_handle_status(struct file
*filp
,
248 struct vm_area_struct
*vma
)
250 struct page
*status
= filp
->private_data
;
251 unsigned long size
= vma
->vm_end
- vma
->vm_start
;
255 /* only allows one page from the head */
256 if (vma
->vm_pgoff
> 0 || size
!= PAGE_SIZE
)
258 /* disallow writable mapping */
259 if (vma
->vm_flags
& VM_WRITE
)
261 /* disallow mprotect() turns it into writable */
262 vma
->vm_flags
&= ~VM_MAYWRITE
;
264 return remap_pfn_range(vma
, vma
->vm_start
,
266 size
, vma
->vm_page_prot
);
269 static const struct file_operations sel_handle_status_ops
= {
270 .open
= sel_open_handle_status
,
271 .read
= sel_read_handle_status
,
272 .mmap
= sel_mmap_handle_status
,
273 .llseek
= generic_file_llseek
,
276 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
277 static ssize_t
sel_write_disable(struct file
*file
, const char __user
*buf
,
278 size_t count
, loff_t
*ppos
)
281 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
287 /* NOTE: we are now officially considering runtime disable as
288 * deprecated, and using it will become increasingly painful
289 * (e.g. sleeping/blocking) as we progress through future
290 * kernel releases until eventually it is removed
292 pr_err("SELinux: Runtime disable is deprecated, use selinux=0 on the kernel cmdline.\n");
294 if (count
>= PAGE_SIZE
)
297 /* No partial writes. */
301 page
= memdup_user_nul(buf
, count
);
303 return PTR_ERR(page
);
306 if (sscanf(page
, "%d", &new_value
) != 1)
310 enforcing
= enforcing_enabled(fsi
->state
);
311 length
= selinux_disable(fsi
->state
);
314 audit_log(audit_context(), GFP_KERNEL
, AUDIT_MAC_STATUS
,
315 "enforcing=%d old_enforcing=%d auid=%u ses=%u"
316 " enabled=0 old-enabled=1 lsm=selinux res=1",
317 enforcing
, enforcing
,
318 from_kuid(&init_user_ns
, audit_get_loginuid(current
)),
319 audit_get_sessionid(current
));
328 #define sel_write_disable NULL
331 static const struct file_operations sel_disable_ops
= {
332 .write
= sel_write_disable
,
333 .llseek
= generic_file_llseek
,
336 static ssize_t
sel_read_policyvers(struct file
*filp
, char __user
*buf
,
337 size_t count
, loff_t
*ppos
)
339 char tmpbuf
[TMPBUFLEN
];
342 length
= scnprintf(tmpbuf
, TMPBUFLEN
, "%u", POLICYDB_VERSION_MAX
);
343 return simple_read_from_buffer(buf
, count
, ppos
, tmpbuf
, length
);
346 static const struct file_operations sel_policyvers_ops
= {
347 .read
= sel_read_policyvers
,
348 .llseek
= generic_file_llseek
,
351 /* declaration for sel_write_load */
352 static int sel_make_bools(struct selinux_policy
*newpolicy
, struct dentry
*bool_dir
,
353 unsigned int *bool_num
, char ***bool_pending_names
,
354 unsigned int **bool_pending_values
);
355 static int sel_make_classes(struct selinux_policy
*newpolicy
,
356 struct dentry
*class_dir
,
357 unsigned long *last_class_ino
);
359 /* declaration for sel_make_class_dirs */
360 static struct dentry
*sel_make_dir(struct dentry
*dir
, const char *name
,
363 /* declaration for sel_make_policy_nodes */
364 static struct dentry
*sel_make_disconnected_dir(struct super_block
*sb
,
367 /* declaration for sel_make_policy_nodes */
368 static void sel_remove_entries(struct dentry
*de
);
370 static ssize_t
sel_read_mls(struct file
*filp
, char __user
*buf
,
371 size_t count
, loff_t
*ppos
)
373 struct selinux_fs_info
*fsi
= file_inode(filp
)->i_sb
->s_fs_info
;
374 char tmpbuf
[TMPBUFLEN
];
377 length
= scnprintf(tmpbuf
, TMPBUFLEN
, "%d",
378 security_mls_enabled(fsi
->state
));
379 return simple_read_from_buffer(buf
, count
, ppos
, tmpbuf
, length
);
382 static const struct file_operations sel_mls_ops
= {
383 .read
= sel_read_mls
,
384 .llseek
= generic_file_llseek
,
387 struct policy_load_memory
{
392 static int sel_open_policy(struct inode
*inode
, struct file
*filp
)
394 struct selinux_fs_info
*fsi
= inode
->i_sb
->s_fs_info
;
395 struct selinux_state
*state
= fsi
->state
;
396 struct policy_load_memory
*plm
= NULL
;
399 BUG_ON(filp
->private_data
);
401 mutex_lock(&fsi
->state
->policy_mutex
);
403 rc
= avc_has_perm(&selinux_state
,
404 current_sid(), SECINITSID_SECURITY
,
405 SECCLASS_SECURITY
, SECURITY__READ_POLICY
, NULL
);
410 if (fsi
->policy_opened
)
414 plm
= kzalloc(sizeof(*plm
), GFP_KERNEL
);
418 rc
= security_read_policy(state
, &plm
->data
, &plm
->len
);
422 if ((size_t)i_size_read(inode
) != plm
->len
) {
424 i_size_write(inode
, plm
->len
);
428 fsi
->policy_opened
= 1;
430 filp
->private_data
= plm
;
432 mutex_unlock(&fsi
->state
->policy_mutex
);
436 mutex_unlock(&fsi
->state
->policy_mutex
);
444 static int sel_release_policy(struct inode
*inode
, struct file
*filp
)
446 struct selinux_fs_info
*fsi
= inode
->i_sb
->s_fs_info
;
447 struct policy_load_memory
*plm
= filp
->private_data
;
451 fsi
->policy_opened
= 0;
459 static ssize_t
sel_read_policy(struct file
*filp
, char __user
*buf
,
460 size_t count
, loff_t
*ppos
)
462 struct policy_load_memory
*plm
= filp
->private_data
;
465 ret
= avc_has_perm(&selinux_state
,
466 current_sid(), SECINITSID_SECURITY
,
467 SECCLASS_SECURITY
, SECURITY__READ_POLICY
, NULL
);
471 return simple_read_from_buffer(buf
, count
, ppos
, plm
->data
, plm
->len
);
474 static vm_fault_t
sel_mmap_policy_fault(struct vm_fault
*vmf
)
476 struct policy_load_memory
*plm
= vmf
->vma
->vm_file
->private_data
;
477 unsigned long offset
;
480 if (vmf
->flags
& (FAULT_FLAG_MKWRITE
| FAULT_FLAG_WRITE
))
481 return VM_FAULT_SIGBUS
;
483 offset
= vmf
->pgoff
<< PAGE_SHIFT
;
484 if (offset
>= roundup(plm
->len
, PAGE_SIZE
))
485 return VM_FAULT_SIGBUS
;
487 page
= vmalloc_to_page(plm
->data
+ offset
);
495 static const struct vm_operations_struct sel_mmap_policy_ops
= {
496 .fault
= sel_mmap_policy_fault
,
497 .page_mkwrite
= sel_mmap_policy_fault
,
500 static int sel_mmap_policy(struct file
*filp
, struct vm_area_struct
*vma
)
502 if (vma
->vm_flags
& VM_SHARED
) {
503 /* do not allow mprotect to make mapping writable */
504 vma
->vm_flags
&= ~VM_MAYWRITE
;
506 if (vma
->vm_flags
& VM_WRITE
)
510 vma
->vm_flags
|= VM_DONTEXPAND
| VM_DONTDUMP
;
511 vma
->vm_ops
= &sel_mmap_policy_ops
;
516 static const struct file_operations sel_policy_ops
= {
517 .open
= sel_open_policy
,
518 .read
= sel_read_policy
,
519 .mmap
= sel_mmap_policy
,
520 .release
= sel_release_policy
,
521 .llseek
= generic_file_llseek
,
524 static void sel_remove_old_bool_data(unsigned int bool_num
, char **bool_names
,
525 unsigned int *bool_values
)
529 /* bool_dir cleanup */
530 for (i
= 0; i
< bool_num
; i
++)
531 kfree(bool_names
[i
]);
536 static int sel_make_policy_nodes(struct selinux_fs_info
*fsi
,
537 struct selinux_policy
*newpolicy
)
540 struct dentry
*tmp_parent
, *tmp_bool_dir
, *tmp_class_dir
, *old_dentry
;
541 unsigned int tmp_bool_num
, old_bool_num
;
542 char **tmp_bool_names
, **old_bool_names
;
543 unsigned int *tmp_bool_values
, *old_bool_values
;
544 unsigned long tmp_ino
= fsi
->last_ino
; /* Don't increment last_ino in this function */
546 tmp_parent
= sel_make_disconnected_dir(fsi
->sb
, &tmp_ino
);
547 if (IS_ERR(tmp_parent
))
548 return PTR_ERR(tmp_parent
);
550 tmp_ino
= fsi
->bool_dir
->d_inode
->i_ino
- 1; /* sel_make_dir will increment and set */
551 tmp_bool_dir
= sel_make_dir(tmp_parent
, BOOL_DIR_NAME
, &tmp_ino
);
552 if (IS_ERR(tmp_bool_dir
)) {
553 ret
= PTR_ERR(tmp_bool_dir
);
557 tmp_ino
= fsi
->class_dir
->d_inode
->i_ino
- 1; /* sel_make_dir will increment and set */
558 tmp_class_dir
= sel_make_dir(tmp_parent
, CLASS_DIR_NAME
, &tmp_ino
);
559 if (IS_ERR(tmp_class_dir
)) {
560 ret
= PTR_ERR(tmp_class_dir
);
564 ret
= sel_make_bools(newpolicy
, tmp_bool_dir
, &tmp_bool_num
,
565 &tmp_bool_names
, &tmp_bool_values
);
567 pr_err("SELinux: failed to load policy booleans\n");
571 ret
= sel_make_classes(newpolicy
, tmp_class_dir
,
572 &fsi
->last_class_ino
);
574 pr_err("SELinux: failed to load policy classes\n");
579 old_dentry
= fsi
->bool_dir
;
580 lock_rename(tmp_bool_dir
, old_dentry
);
581 d_exchange(tmp_bool_dir
, fsi
->bool_dir
);
583 old_bool_num
= fsi
->bool_num
;
584 old_bool_names
= fsi
->bool_pending_names
;
585 old_bool_values
= fsi
->bool_pending_values
;
587 fsi
->bool_num
= tmp_bool_num
;
588 fsi
->bool_pending_names
= tmp_bool_names
;
589 fsi
->bool_pending_values
= tmp_bool_values
;
591 sel_remove_old_bool_data(old_bool_num
, old_bool_names
, old_bool_values
);
593 fsi
->bool_dir
= tmp_bool_dir
;
594 unlock_rename(tmp_bool_dir
, old_dentry
);
597 old_dentry
= fsi
->class_dir
;
598 lock_rename(tmp_class_dir
, old_dentry
);
599 d_exchange(tmp_class_dir
, fsi
->class_dir
);
600 fsi
->class_dir
= tmp_class_dir
;
601 unlock_rename(tmp_class_dir
, old_dentry
);
604 /* Since the other temporary dirs are children of tmp_parent
605 * this will handle all the cleanup in the case of a failure before
608 sel_remove_entries(tmp_parent
);
609 dput(tmp_parent
); /* d_genocide() only handles the children */
614 static ssize_t
sel_write_load(struct file
*file
, const char __user
*buf
,
615 size_t count
, loff_t
*ppos
)
618 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
619 struct selinux_policy
*newpolicy
;
623 mutex_lock(&fsi
->state
->policy_mutex
);
625 length
= avc_has_perm(&selinux_state
,
626 current_sid(), SECINITSID_SECURITY
,
627 SECCLASS_SECURITY
, SECURITY__LOAD_POLICY
, NULL
);
631 /* No partial writes. */
637 data
= vmalloc(count
);
642 if (copy_from_user(data
, buf
, count
) != 0)
645 length
= security_load_policy(fsi
->state
, data
, count
, &newpolicy
);
647 pr_warn_ratelimited("SELinux: failed to load policy\n");
651 length
= sel_make_policy_nodes(fsi
, newpolicy
);
653 selinux_policy_cancel(fsi
->state
, newpolicy
);
657 selinux_policy_commit(fsi
->state
, newpolicy
);
662 audit_log(audit_context(), GFP_KERNEL
, AUDIT_MAC_POLICY_LOAD
,
663 "auid=%u ses=%u lsm=selinux res=1",
664 from_kuid(&init_user_ns
, audit_get_loginuid(current
)),
665 audit_get_sessionid(current
));
667 mutex_unlock(&fsi
->state
->policy_mutex
);
672 static const struct file_operations sel_load_ops
= {
673 .write
= sel_write_load
,
674 .llseek
= generic_file_llseek
,
677 static ssize_t
sel_write_context(struct file
*file
, char *buf
, size_t size
)
679 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
680 struct selinux_state
*state
= fsi
->state
;
685 length
= avc_has_perm(&selinux_state
,
686 current_sid(), SECINITSID_SECURITY
,
687 SECCLASS_SECURITY
, SECURITY__CHECK_CONTEXT
, NULL
);
691 length
= security_context_to_sid(state
, buf
, size
, &sid
, GFP_KERNEL
);
695 length
= security_sid_to_context(state
, sid
, &canon
, &len
);
700 if (len
> SIMPLE_TRANSACTION_LIMIT
) {
701 pr_err("SELinux: %s: context size (%u) exceeds "
702 "payload max\n", __func__
, len
);
706 memcpy(buf
, canon
, len
);
713 static ssize_t
sel_read_checkreqprot(struct file
*filp
, char __user
*buf
,
714 size_t count
, loff_t
*ppos
)
716 struct selinux_fs_info
*fsi
= file_inode(filp
)->i_sb
->s_fs_info
;
717 char tmpbuf
[TMPBUFLEN
];
720 length
= scnprintf(tmpbuf
, TMPBUFLEN
, "%u",
721 checkreqprot_get(fsi
->state
));
722 return simple_read_from_buffer(buf
, count
, ppos
, tmpbuf
, length
);
725 static ssize_t
sel_write_checkreqprot(struct file
*file
, const char __user
*buf
,
726 size_t count
, loff_t
*ppos
)
728 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
731 unsigned int new_value
;
733 length
= avc_has_perm(&selinux_state
,
734 current_sid(), SECINITSID_SECURITY
,
735 SECCLASS_SECURITY
, SECURITY__SETCHECKREQPROT
,
740 if (count
>= PAGE_SIZE
)
743 /* No partial writes. */
747 page
= memdup_user_nul(buf
, count
);
749 return PTR_ERR(page
);
752 if (sscanf(page
, "%u", &new_value
) != 1)
756 char comm
[sizeof(current
->comm
)];
758 memcpy(comm
, current
->comm
, sizeof(comm
));
759 pr_warn_once("SELinux: %s (%d) set checkreqprot to 1. This is deprecated and will be rejected in a future kernel release.\n",
763 checkreqprot_set(fsi
->state
, (new_value
? 1 : 0));
769 static const struct file_operations sel_checkreqprot_ops
= {
770 .read
= sel_read_checkreqprot
,
771 .write
= sel_write_checkreqprot
,
772 .llseek
= generic_file_llseek
,
775 static ssize_t
sel_write_validatetrans(struct file
*file
,
776 const char __user
*buf
,
777 size_t count
, loff_t
*ppos
)
779 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
780 struct selinux_state
*state
= fsi
->state
;
781 char *oldcon
= NULL
, *newcon
= NULL
, *taskcon
= NULL
;
783 u32 osid
, nsid
, tsid
;
787 rc
= avc_has_perm(&selinux_state
,
788 current_sid(), SECINITSID_SECURITY
,
789 SECCLASS_SECURITY
, SECURITY__VALIDATE_TRANS
, NULL
);
794 if (count
>= PAGE_SIZE
)
797 /* No partial writes. */
802 req
= memdup_user_nul(buf
, count
);
810 oldcon
= kzalloc(count
+ 1, GFP_KERNEL
);
814 newcon
= kzalloc(count
+ 1, GFP_KERNEL
);
818 taskcon
= kzalloc(count
+ 1, GFP_KERNEL
);
823 if (sscanf(req
, "%s %s %hu %s", oldcon
, newcon
, &tclass
, taskcon
) != 4)
826 rc
= security_context_str_to_sid(state
, oldcon
, &osid
, GFP_KERNEL
);
830 rc
= security_context_str_to_sid(state
, newcon
, &nsid
, GFP_KERNEL
);
834 rc
= security_context_str_to_sid(state
, taskcon
, &tsid
, GFP_KERNEL
);
838 rc
= security_validate_transition_user(state
, osid
, nsid
, tsid
, tclass
);
849 static const struct file_operations sel_transition_ops
= {
850 .write
= sel_write_validatetrans
,
851 .llseek
= generic_file_llseek
,
855 * Remaining nodes use transaction based IO methods like nfsd/nfsctl.c
857 static ssize_t
sel_write_access(struct file
*file
, char *buf
, size_t size
);
858 static ssize_t
sel_write_create(struct file
*file
, char *buf
, size_t size
);
859 static ssize_t
sel_write_relabel(struct file
*file
, char *buf
, size_t size
);
860 static ssize_t
sel_write_user(struct file
*file
, char *buf
, size_t size
);
861 static ssize_t
sel_write_member(struct file
*file
, char *buf
, size_t size
);
863 static ssize_t (*const write_op
[])(struct file
*, char *, size_t) = {
864 [SEL_ACCESS
] = sel_write_access
,
865 [SEL_CREATE
] = sel_write_create
,
866 [SEL_RELABEL
] = sel_write_relabel
,
867 [SEL_USER
] = sel_write_user
,
868 [SEL_MEMBER
] = sel_write_member
,
869 [SEL_CONTEXT
] = sel_write_context
,
872 static ssize_t
selinux_transaction_write(struct file
*file
, const char __user
*buf
, size_t size
, loff_t
*pos
)
874 ino_t ino
= file_inode(file
)->i_ino
;
878 if (ino
>= ARRAY_SIZE(write_op
) || !write_op
[ino
])
881 data
= simple_transaction_get(file
, buf
, size
);
883 return PTR_ERR(data
);
885 rv
= write_op
[ino
](file
, data
, size
);
887 simple_transaction_set(file
, rv
);
893 static const struct file_operations transaction_ops
= {
894 .write
= selinux_transaction_write
,
895 .read
= simple_transaction_read
,
896 .release
= simple_transaction_release
,
897 .llseek
= generic_file_llseek
,
901 * payload - write methods
902 * If the method has a response, the response should be put in buf,
903 * and the length returned. Otherwise return 0 or and -error.
906 static ssize_t
sel_write_access(struct file
*file
, char *buf
, size_t size
)
908 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
909 struct selinux_state
*state
= fsi
->state
;
910 char *scon
= NULL
, *tcon
= NULL
;
913 struct av_decision avd
;
916 length
= avc_has_perm(&selinux_state
,
917 current_sid(), SECINITSID_SECURITY
,
918 SECCLASS_SECURITY
, SECURITY__COMPUTE_AV
, NULL
);
923 scon
= kzalloc(size
+ 1, GFP_KERNEL
);
928 tcon
= kzalloc(size
+ 1, GFP_KERNEL
);
933 if (sscanf(buf
, "%s %s %hu", scon
, tcon
, &tclass
) != 3)
936 length
= security_context_str_to_sid(state
, scon
, &ssid
, GFP_KERNEL
);
940 length
= security_context_str_to_sid(state
, tcon
, &tsid
, GFP_KERNEL
);
944 security_compute_av_user(state
, ssid
, tsid
, tclass
, &avd
);
946 length
= scnprintf(buf
, SIMPLE_TRANSACTION_LIMIT
,
948 avd
.allowed
, 0xffffffff,
949 avd
.auditallow
, avd
.auditdeny
,
950 avd
.seqno
, avd
.flags
);
957 static ssize_t
sel_write_create(struct file
*file
, char *buf
, size_t size
)
959 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
960 struct selinux_state
*state
= fsi
->state
;
961 char *scon
= NULL
, *tcon
= NULL
;
962 char *namebuf
= NULL
, *objname
= NULL
;
963 u32 ssid
, tsid
, newsid
;
970 length
= avc_has_perm(&selinux_state
,
971 current_sid(), SECINITSID_SECURITY
,
972 SECCLASS_SECURITY
, SECURITY__COMPUTE_CREATE
,
978 scon
= kzalloc(size
+ 1, GFP_KERNEL
);
983 tcon
= kzalloc(size
+ 1, GFP_KERNEL
);
988 namebuf
= kzalloc(size
+ 1, GFP_KERNEL
);
993 nargs
= sscanf(buf
, "%s %s %hu %s", scon
, tcon
, &tclass
, namebuf
);
994 if (nargs
< 3 || nargs
> 4)
998 * If and when the name of new object to be queried contains
999 * either whitespace or multibyte characters, they shall be
1000 * encoded based on the percentage-encoding rule.
1001 * If not encoded, the sscanf logic picks up only left-half
1002 * of the supplied name; splitted by a whitespace unexpectedly.
1012 else if (c1
== '%') {
1013 c1
= hex_to_bin(*r
++);
1016 c2
= hex_to_bin(*r
++);
1019 c1
= (c1
<< 4) | c2
;
1022 } while (c1
!= '\0');
1027 length
= security_context_str_to_sid(state
, scon
, &ssid
, GFP_KERNEL
);
1031 length
= security_context_str_to_sid(state
, tcon
, &tsid
, GFP_KERNEL
);
1035 length
= security_transition_sid_user(state
, ssid
, tsid
, tclass
,
1040 length
= security_sid_to_context(state
, newsid
, &newcon
, &len
);
1045 if (len
> SIMPLE_TRANSACTION_LIMIT
) {
1046 pr_err("SELinux: %s: context size (%u) exceeds "
1047 "payload max\n", __func__
, len
);
1051 memcpy(buf
, newcon
, len
);
1061 static ssize_t
sel_write_relabel(struct file
*file
, char *buf
, size_t size
)
1063 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
1064 struct selinux_state
*state
= fsi
->state
;
1065 char *scon
= NULL
, *tcon
= NULL
;
1066 u32 ssid
, tsid
, newsid
;
1069 char *newcon
= NULL
;
1072 length
= avc_has_perm(&selinux_state
,
1073 current_sid(), SECINITSID_SECURITY
,
1074 SECCLASS_SECURITY
, SECURITY__COMPUTE_RELABEL
,
1080 scon
= kzalloc(size
+ 1, GFP_KERNEL
);
1085 tcon
= kzalloc(size
+ 1, GFP_KERNEL
);
1090 if (sscanf(buf
, "%s %s %hu", scon
, tcon
, &tclass
) != 3)
1093 length
= security_context_str_to_sid(state
, scon
, &ssid
, GFP_KERNEL
);
1097 length
= security_context_str_to_sid(state
, tcon
, &tsid
, GFP_KERNEL
);
1101 length
= security_change_sid(state
, ssid
, tsid
, tclass
, &newsid
);
1105 length
= security_sid_to_context(state
, newsid
, &newcon
, &len
);
1110 if (len
> SIMPLE_TRANSACTION_LIMIT
)
1113 memcpy(buf
, newcon
, len
);
1122 static ssize_t
sel_write_user(struct file
*file
, char *buf
, size_t size
)
1124 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
1125 struct selinux_state
*state
= fsi
->state
;
1126 char *con
= NULL
, *user
= NULL
, *ptr
;
1127 u32 sid
, *sids
= NULL
;
1133 length
= avc_has_perm(&selinux_state
,
1134 current_sid(), SECINITSID_SECURITY
,
1135 SECCLASS_SECURITY
, SECURITY__COMPUTE_USER
,
1141 con
= kzalloc(size
+ 1, GFP_KERNEL
);
1146 user
= kzalloc(size
+ 1, GFP_KERNEL
);
1151 if (sscanf(buf
, "%s %s", con
, user
) != 2)
1154 length
= security_context_str_to_sid(state
, con
, &sid
, GFP_KERNEL
);
1158 length
= security_get_user_sids(state
, sid
, user
, &sids
, &nsids
);
1162 length
= sprintf(buf
, "%u", nsids
) + 1;
1164 for (i
= 0; i
< nsids
; i
++) {
1165 rc
= security_sid_to_context(state
, sids
[i
], &newcon
, &len
);
1170 if ((length
+ len
) >= SIMPLE_TRANSACTION_LIMIT
) {
1175 memcpy(ptr
, newcon
, len
);
1187 static ssize_t
sel_write_member(struct file
*file
, char *buf
, size_t size
)
1189 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
1190 struct selinux_state
*state
= fsi
->state
;
1191 char *scon
= NULL
, *tcon
= NULL
;
1192 u32 ssid
, tsid
, newsid
;
1195 char *newcon
= NULL
;
1198 length
= avc_has_perm(&selinux_state
,
1199 current_sid(), SECINITSID_SECURITY
,
1200 SECCLASS_SECURITY
, SECURITY__COMPUTE_MEMBER
,
1206 scon
= kzalloc(size
+ 1, GFP_KERNEL
);
1211 tcon
= kzalloc(size
+ 1, GFP_KERNEL
);
1216 if (sscanf(buf
, "%s %s %hu", scon
, tcon
, &tclass
) != 3)
1219 length
= security_context_str_to_sid(state
, scon
, &ssid
, GFP_KERNEL
);
1223 length
= security_context_str_to_sid(state
, tcon
, &tsid
, GFP_KERNEL
);
1227 length
= security_member_sid(state
, ssid
, tsid
, tclass
, &newsid
);
1231 length
= security_sid_to_context(state
, newsid
, &newcon
, &len
);
1236 if (len
> SIMPLE_TRANSACTION_LIMIT
) {
1237 pr_err("SELinux: %s: context size (%u) exceeds "
1238 "payload max\n", __func__
, len
);
1242 memcpy(buf
, newcon
, len
);
1251 static struct inode
*sel_make_inode(struct super_block
*sb
, int mode
)
1253 struct inode
*ret
= new_inode(sb
);
1257 ret
->i_atime
= ret
->i_mtime
= ret
->i_ctime
= current_time(ret
);
1262 static ssize_t
sel_read_bool(struct file
*filep
, char __user
*buf
,
1263 size_t count
, loff_t
*ppos
)
1265 struct selinux_fs_info
*fsi
= file_inode(filep
)->i_sb
->s_fs_info
;
1270 unsigned index
= file_inode(filep
)->i_ino
& SEL_INO_MASK
;
1271 const char *name
= filep
->f_path
.dentry
->d_name
.name
;
1273 mutex_lock(&fsi
->state
->policy_mutex
);
1276 if (index
>= fsi
->bool_num
|| strcmp(name
,
1277 fsi
->bool_pending_names
[index
]))
1281 page
= (char *)get_zeroed_page(GFP_KERNEL
);
1285 cur_enforcing
= security_get_bool_value(fsi
->state
, index
);
1286 if (cur_enforcing
< 0) {
1287 ret
= cur_enforcing
;
1290 length
= scnprintf(page
, PAGE_SIZE
, "%d %d", cur_enforcing
,
1291 fsi
->bool_pending_values
[index
]);
1292 mutex_unlock(&fsi
->state
->policy_mutex
);
1293 ret
= simple_read_from_buffer(buf
, count
, ppos
, page
, length
);
1295 free_page((unsigned long)page
);
1299 mutex_unlock(&fsi
->state
->policy_mutex
);
1303 static ssize_t
sel_write_bool(struct file
*filep
, const char __user
*buf
,
1304 size_t count
, loff_t
*ppos
)
1306 struct selinux_fs_info
*fsi
= file_inode(filep
)->i_sb
->s_fs_info
;
1310 unsigned index
= file_inode(filep
)->i_ino
& SEL_INO_MASK
;
1311 const char *name
= filep
->f_path
.dentry
->d_name
.name
;
1313 if (count
>= PAGE_SIZE
)
1316 /* No partial writes. */
1320 page
= memdup_user_nul(buf
, count
);
1322 return PTR_ERR(page
);
1324 mutex_lock(&fsi
->state
->policy_mutex
);
1326 length
= avc_has_perm(&selinux_state
,
1327 current_sid(), SECINITSID_SECURITY
,
1328 SECCLASS_SECURITY
, SECURITY__SETBOOL
,
1334 if (index
>= fsi
->bool_num
|| strcmp(name
,
1335 fsi
->bool_pending_names
[index
]))
1339 if (sscanf(page
, "%d", &new_value
) != 1)
1345 fsi
->bool_pending_values
[index
] = new_value
;
1349 mutex_unlock(&fsi
->state
->policy_mutex
);
1354 static const struct file_operations sel_bool_ops
= {
1355 .read
= sel_read_bool
,
1356 .write
= sel_write_bool
,
1357 .llseek
= generic_file_llseek
,
1360 static ssize_t
sel_commit_bools_write(struct file
*filep
,
1361 const char __user
*buf
,
1362 size_t count
, loff_t
*ppos
)
1364 struct selinux_fs_info
*fsi
= file_inode(filep
)->i_sb
->s_fs_info
;
1369 if (count
>= PAGE_SIZE
)
1372 /* No partial writes. */
1376 page
= memdup_user_nul(buf
, count
);
1378 return PTR_ERR(page
);
1380 mutex_lock(&fsi
->state
->policy_mutex
);
1382 length
= avc_has_perm(&selinux_state
,
1383 current_sid(), SECINITSID_SECURITY
,
1384 SECCLASS_SECURITY
, SECURITY__SETBOOL
,
1390 if (sscanf(page
, "%d", &new_value
) != 1)
1394 if (new_value
&& fsi
->bool_pending_values
)
1395 length
= security_set_bools(fsi
->state
, fsi
->bool_num
,
1396 fsi
->bool_pending_values
);
1402 mutex_unlock(&fsi
->state
->policy_mutex
);
1407 static const struct file_operations sel_commit_bools_ops
= {
1408 .write
= sel_commit_bools_write
,
1409 .llseek
= generic_file_llseek
,
1412 static void sel_remove_entries(struct dentry
*de
)
1415 shrink_dcache_parent(de
);
1418 static int sel_make_bools(struct selinux_policy
*newpolicy
, struct dentry
*bool_dir
,
1419 unsigned int *bool_num
, char ***bool_pending_names
,
1420 unsigned int **bool_pending_values
)
1424 struct dentry
*dentry
= NULL
;
1425 struct inode
*inode
= NULL
;
1426 struct inode_security_struct
*isec
;
1427 char **names
= NULL
, *page
;
1433 page
= (char *)get_zeroed_page(GFP_KERNEL
);
1437 ret
= security_get_bools(newpolicy
, &num
, &names
, &values
);
1441 for (i
= 0; i
< num
; i
++) {
1443 dentry
= d_alloc_name(bool_dir
, names
[i
]);
1448 inode
= sel_make_inode(bool_dir
->d_sb
, S_IFREG
| S_IRUGO
| S_IWUSR
);
1454 ret
= -ENAMETOOLONG
;
1455 len
= snprintf(page
, PAGE_SIZE
, "/%s/%s", BOOL_DIR_NAME
, names
[i
]);
1456 if (len
>= PAGE_SIZE
) {
1462 isec
= selinux_inode(inode
);
1463 ret
= selinux_policy_genfs_sid(newpolicy
, "selinuxfs", page
,
1464 SECCLASS_FILE
, &sid
);
1466 pr_warn_ratelimited("SELinux: no sid found, defaulting to security isid for %s\n",
1468 sid
= SECINITSID_SECURITY
;
1472 isec
->initialized
= LABEL_INITIALIZED
;
1473 inode
->i_fop
= &sel_bool_ops
;
1474 inode
->i_ino
= i
|SEL_BOOL_INO_OFFSET
;
1475 d_add(dentry
, inode
);
1478 *bool_pending_names
= names
;
1479 *bool_pending_values
= values
;
1481 free_page((unsigned long)page
);
1484 free_page((unsigned long)page
);
1487 for (i
= 0; i
< num
; i
++)
1492 sel_remove_entries(bool_dir
);
1497 static ssize_t
sel_read_avc_cache_threshold(struct file
*filp
, char __user
*buf
,
1498 size_t count
, loff_t
*ppos
)
1500 struct selinux_fs_info
*fsi
= file_inode(filp
)->i_sb
->s_fs_info
;
1501 struct selinux_state
*state
= fsi
->state
;
1502 char tmpbuf
[TMPBUFLEN
];
1505 length
= scnprintf(tmpbuf
, TMPBUFLEN
, "%u",
1506 avc_get_cache_threshold(state
->avc
));
1507 return simple_read_from_buffer(buf
, count
, ppos
, tmpbuf
, length
);
1510 static ssize_t
sel_write_avc_cache_threshold(struct file
*file
,
1511 const char __user
*buf
,
1512 size_t count
, loff_t
*ppos
)
1515 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
1516 struct selinux_state
*state
= fsi
->state
;
1519 unsigned int new_value
;
1521 ret
= avc_has_perm(&selinux_state
,
1522 current_sid(), SECINITSID_SECURITY
,
1523 SECCLASS_SECURITY
, SECURITY__SETSECPARAM
,
1528 if (count
>= PAGE_SIZE
)
1531 /* No partial writes. */
1535 page
= memdup_user_nul(buf
, count
);
1537 return PTR_ERR(page
);
1540 if (sscanf(page
, "%u", &new_value
) != 1)
1543 avc_set_cache_threshold(state
->avc
, new_value
);
1551 static ssize_t
sel_read_avc_hash_stats(struct file
*filp
, char __user
*buf
,
1552 size_t count
, loff_t
*ppos
)
1554 struct selinux_fs_info
*fsi
= file_inode(filp
)->i_sb
->s_fs_info
;
1555 struct selinux_state
*state
= fsi
->state
;
1559 page
= (char *)__get_free_page(GFP_KERNEL
);
1563 length
= avc_get_hash_stats(state
->avc
, page
);
1565 length
= simple_read_from_buffer(buf
, count
, ppos
, page
, length
);
1566 free_page((unsigned long)page
);
1571 static ssize_t
sel_read_sidtab_hash_stats(struct file
*filp
, char __user
*buf
,
1572 size_t count
, loff_t
*ppos
)
1574 struct selinux_fs_info
*fsi
= file_inode(filp
)->i_sb
->s_fs_info
;
1575 struct selinux_state
*state
= fsi
->state
;
1579 page
= (char *)__get_free_page(GFP_KERNEL
);
1583 length
= security_sidtab_hash_stats(state
, page
);
1585 length
= simple_read_from_buffer(buf
, count
, ppos
, page
,
1587 free_page((unsigned long)page
);
1592 static const struct file_operations sel_sidtab_hash_stats_ops
= {
1593 .read
= sel_read_sidtab_hash_stats
,
1594 .llseek
= generic_file_llseek
,
1597 static const struct file_operations sel_avc_cache_threshold_ops
= {
1598 .read
= sel_read_avc_cache_threshold
,
1599 .write
= sel_write_avc_cache_threshold
,
1600 .llseek
= generic_file_llseek
,
1603 static const struct file_operations sel_avc_hash_stats_ops
= {
1604 .read
= sel_read_avc_hash_stats
,
1605 .llseek
= generic_file_llseek
,
1608 #ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
1609 static struct avc_cache_stats
*sel_avc_get_stat_idx(loff_t
*idx
)
1613 for (cpu
= *idx
; cpu
< nr_cpu_ids
; ++cpu
) {
1614 if (!cpu_possible(cpu
))
1617 return &per_cpu(avc_cache_stats
, cpu
);
1623 static void *sel_avc_stats_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1625 loff_t n
= *pos
- 1;
1628 return SEQ_START_TOKEN
;
1630 return sel_avc_get_stat_idx(&n
);
1633 static void *sel_avc_stats_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1635 return sel_avc_get_stat_idx(pos
);
1638 static int sel_avc_stats_seq_show(struct seq_file
*seq
, void *v
)
1640 struct avc_cache_stats
*st
= v
;
1642 if (v
== SEQ_START_TOKEN
) {
1644 "lookups hits misses allocations reclaims frees\n");
1646 unsigned int lookups
= st
->lookups
;
1647 unsigned int misses
= st
->misses
;
1648 unsigned int hits
= lookups
- misses
;
1649 seq_printf(seq
, "%u %u %u %u %u %u\n", lookups
,
1650 hits
, misses
, st
->allocations
,
1651 st
->reclaims
, st
->frees
);
1656 static void sel_avc_stats_seq_stop(struct seq_file
*seq
, void *v
)
1659 static const struct seq_operations sel_avc_cache_stats_seq_ops
= {
1660 .start
= sel_avc_stats_seq_start
,
1661 .next
= sel_avc_stats_seq_next
,
1662 .show
= sel_avc_stats_seq_show
,
1663 .stop
= sel_avc_stats_seq_stop
,
1666 static int sel_open_avc_cache_stats(struct inode
*inode
, struct file
*file
)
1668 return seq_open(file
, &sel_avc_cache_stats_seq_ops
);
1671 static const struct file_operations sel_avc_cache_stats_ops
= {
1672 .open
= sel_open_avc_cache_stats
,
1674 .llseek
= seq_lseek
,
1675 .release
= seq_release
,
1679 static int sel_make_avc_files(struct dentry
*dir
)
1681 struct super_block
*sb
= dir
->d_sb
;
1682 struct selinux_fs_info
*fsi
= sb
->s_fs_info
;
1684 static const struct tree_descr files
[] = {
1685 { "cache_threshold",
1686 &sel_avc_cache_threshold_ops
, S_IRUGO
|S_IWUSR
},
1687 { "hash_stats", &sel_avc_hash_stats_ops
, S_IRUGO
},
1688 #ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
1689 { "cache_stats", &sel_avc_cache_stats_ops
, S_IRUGO
},
1693 for (i
= 0; i
< ARRAY_SIZE(files
); i
++) {
1694 struct inode
*inode
;
1695 struct dentry
*dentry
;
1697 dentry
= d_alloc_name(dir
, files
[i
].name
);
1701 inode
= sel_make_inode(dir
->d_sb
, S_IFREG
|files
[i
].mode
);
1707 inode
->i_fop
= files
[i
].ops
;
1708 inode
->i_ino
= ++fsi
->last_ino
;
1709 d_add(dentry
, inode
);
1715 static int sel_make_ss_files(struct dentry
*dir
)
1717 struct super_block
*sb
= dir
->d_sb
;
1718 struct selinux_fs_info
*fsi
= sb
->s_fs_info
;
1720 static struct tree_descr files
[] = {
1721 { "sidtab_hash_stats", &sel_sidtab_hash_stats_ops
, S_IRUGO
},
1724 for (i
= 0; i
< ARRAY_SIZE(files
); i
++) {
1725 struct inode
*inode
;
1726 struct dentry
*dentry
;
1728 dentry
= d_alloc_name(dir
, files
[i
].name
);
1732 inode
= sel_make_inode(dir
->d_sb
, S_IFREG
|files
[i
].mode
);
1738 inode
->i_fop
= files
[i
].ops
;
1739 inode
->i_ino
= ++fsi
->last_ino
;
1740 d_add(dentry
, inode
);
1746 static ssize_t
sel_read_initcon(struct file
*file
, char __user
*buf
,
1747 size_t count
, loff_t
*ppos
)
1749 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
1754 sid
= file_inode(file
)->i_ino
&SEL_INO_MASK
;
1755 ret
= security_sid_to_context(fsi
->state
, sid
, &con
, &len
);
1759 ret
= simple_read_from_buffer(buf
, count
, ppos
, con
, len
);
1764 static const struct file_operations sel_initcon_ops
= {
1765 .read
= sel_read_initcon
,
1766 .llseek
= generic_file_llseek
,
1769 static int sel_make_initcon_files(struct dentry
*dir
)
1773 for (i
= 1; i
<= SECINITSID_NUM
; i
++) {
1774 struct inode
*inode
;
1775 struct dentry
*dentry
;
1776 const char *s
= security_get_initial_sid_context(i
);
1780 dentry
= d_alloc_name(dir
, s
);
1784 inode
= sel_make_inode(dir
->d_sb
, S_IFREG
|S_IRUGO
);
1790 inode
->i_fop
= &sel_initcon_ops
;
1791 inode
->i_ino
= i
|SEL_INITCON_INO_OFFSET
;
1792 d_add(dentry
, inode
);
1798 static inline unsigned long sel_class_to_ino(u16
class)
1800 return (class * (SEL_VEC_MAX
+ 1)) | SEL_CLASS_INO_OFFSET
;
1803 static inline u16
sel_ino_to_class(unsigned long ino
)
1805 return (ino
& SEL_INO_MASK
) / (SEL_VEC_MAX
+ 1);
1808 static inline unsigned long sel_perm_to_ino(u16
class, u32 perm
)
1810 return (class * (SEL_VEC_MAX
+ 1) + perm
) | SEL_CLASS_INO_OFFSET
;
1813 static inline u32
sel_ino_to_perm(unsigned long ino
)
1815 return (ino
& SEL_INO_MASK
) % (SEL_VEC_MAX
+ 1);
1818 static ssize_t
sel_read_class(struct file
*file
, char __user
*buf
,
1819 size_t count
, loff_t
*ppos
)
1821 unsigned long ino
= file_inode(file
)->i_ino
;
1822 char res
[TMPBUFLEN
];
1823 ssize_t len
= scnprintf(res
, sizeof(res
), "%d", sel_ino_to_class(ino
));
1824 return simple_read_from_buffer(buf
, count
, ppos
, res
, len
);
1827 static const struct file_operations sel_class_ops
= {
1828 .read
= sel_read_class
,
1829 .llseek
= generic_file_llseek
,
1832 static ssize_t
sel_read_perm(struct file
*file
, char __user
*buf
,
1833 size_t count
, loff_t
*ppos
)
1835 unsigned long ino
= file_inode(file
)->i_ino
;
1836 char res
[TMPBUFLEN
];
1837 ssize_t len
= scnprintf(res
, sizeof(res
), "%d", sel_ino_to_perm(ino
));
1838 return simple_read_from_buffer(buf
, count
, ppos
, res
, len
);
1841 static const struct file_operations sel_perm_ops
= {
1842 .read
= sel_read_perm
,
1843 .llseek
= generic_file_llseek
,
1846 static ssize_t
sel_read_policycap(struct file
*file
, char __user
*buf
,
1847 size_t count
, loff_t
*ppos
)
1849 struct selinux_fs_info
*fsi
= file_inode(file
)->i_sb
->s_fs_info
;
1851 char tmpbuf
[TMPBUFLEN
];
1853 unsigned long i_ino
= file_inode(file
)->i_ino
;
1855 value
= security_policycap_supported(fsi
->state
, i_ino
& SEL_INO_MASK
);
1856 length
= scnprintf(tmpbuf
, TMPBUFLEN
, "%d", value
);
1858 return simple_read_from_buffer(buf
, count
, ppos
, tmpbuf
, length
);
1861 static const struct file_operations sel_policycap_ops
= {
1862 .read
= sel_read_policycap
,
1863 .llseek
= generic_file_llseek
,
1866 static int sel_make_perm_files(struct selinux_policy
*newpolicy
,
1867 char *objclass
, int classvalue
,
1873 rc
= security_get_permissions(newpolicy
, objclass
, &perms
, &nperms
);
1877 for (i
= 0; i
< nperms
; i
++) {
1878 struct inode
*inode
;
1879 struct dentry
*dentry
;
1882 dentry
= d_alloc_name(dir
, perms
[i
]);
1887 inode
= sel_make_inode(dir
->d_sb
, S_IFREG
|S_IRUGO
);
1893 inode
->i_fop
= &sel_perm_ops
;
1894 /* i+1 since perm values are 1-indexed */
1895 inode
->i_ino
= sel_perm_to_ino(classvalue
, i
+ 1);
1896 d_add(dentry
, inode
);
1900 for (i
= 0; i
< nperms
; i
++)
1906 static int sel_make_class_dir_entries(struct selinux_policy
*newpolicy
,
1907 char *classname
, int index
,
1910 struct super_block
*sb
= dir
->d_sb
;
1911 struct selinux_fs_info
*fsi
= sb
->s_fs_info
;
1912 struct dentry
*dentry
= NULL
;
1913 struct inode
*inode
= NULL
;
1916 dentry
= d_alloc_name(dir
, "index");
1920 inode
= sel_make_inode(dir
->d_sb
, S_IFREG
|S_IRUGO
);
1926 inode
->i_fop
= &sel_class_ops
;
1927 inode
->i_ino
= sel_class_to_ino(index
);
1928 d_add(dentry
, inode
);
1930 dentry
= sel_make_dir(dir
, "perms", &fsi
->last_class_ino
);
1932 return PTR_ERR(dentry
);
1934 rc
= sel_make_perm_files(newpolicy
, classname
, index
, dentry
);
1939 static int sel_make_classes(struct selinux_policy
*newpolicy
,
1940 struct dentry
*class_dir
,
1941 unsigned long *last_class_ino
)
1944 int rc
, nclasses
, i
;
1947 rc
= security_get_classes(newpolicy
, &classes
, &nclasses
);
1951 /* +2 since classes are 1-indexed */
1952 *last_class_ino
= sel_class_to_ino(nclasses
+ 2);
1954 for (i
= 0; i
< nclasses
; i
++) {
1955 struct dentry
*class_name_dir
;
1957 class_name_dir
= sel_make_dir(class_dir
, classes
[i
],
1959 if (IS_ERR(class_name_dir
)) {
1960 rc
= PTR_ERR(class_name_dir
);
1964 /* i+1 since class values are 1-indexed */
1965 rc
= sel_make_class_dir_entries(newpolicy
, classes
[i
], i
+ 1,
1972 for (i
= 0; i
< nclasses
; i
++)
1978 static int sel_make_policycap(struct selinux_fs_info
*fsi
)
1981 struct dentry
*dentry
= NULL
;
1982 struct inode
*inode
= NULL
;
1984 for (iter
= 0; iter
<= POLICYDB_CAPABILITY_MAX
; iter
++) {
1985 if (iter
< ARRAY_SIZE(selinux_policycap_names
))
1986 dentry
= d_alloc_name(fsi
->policycap_dir
,
1987 selinux_policycap_names
[iter
]);
1989 dentry
= d_alloc_name(fsi
->policycap_dir
, "unknown");
1994 inode
= sel_make_inode(fsi
->sb
, S_IFREG
| 0444);
1995 if (inode
== NULL
) {
2000 inode
->i_fop
= &sel_policycap_ops
;
2001 inode
->i_ino
= iter
| SEL_POLICYCAP_INO_OFFSET
;
2002 d_add(dentry
, inode
);
2008 static struct dentry
*sel_make_dir(struct dentry
*dir
, const char *name
,
2011 struct dentry
*dentry
= d_alloc_name(dir
, name
);
2012 struct inode
*inode
;
2015 return ERR_PTR(-ENOMEM
);
2017 inode
= sel_make_inode(dir
->d_sb
, S_IFDIR
| S_IRUGO
| S_IXUGO
);
2020 return ERR_PTR(-ENOMEM
);
2023 inode
->i_op
= &simple_dir_inode_operations
;
2024 inode
->i_fop
= &simple_dir_operations
;
2025 inode
->i_ino
= ++(*ino
);
2026 /* directory inodes start off with i_nlink == 2 (for "." entry) */
2028 d_add(dentry
, inode
);
2029 /* bump link count on parent directory, too */
2030 inc_nlink(d_inode(dir
));
2035 static struct dentry
*sel_make_disconnected_dir(struct super_block
*sb
,
2038 struct inode
*inode
= sel_make_inode(sb
, S_IFDIR
| S_IRUGO
| S_IXUGO
);
2041 return ERR_PTR(-ENOMEM
);
2043 inode
->i_op
= &simple_dir_inode_operations
;
2044 inode
->i_fop
= &simple_dir_operations
;
2045 inode
->i_ino
= ++(*ino
);
2046 /* directory inodes start off with i_nlink == 2 (for "." entry) */
2048 return d_obtain_alias(inode
);
2051 #define NULL_FILE_NAME "null"
2053 static int sel_fill_super(struct super_block
*sb
, struct fs_context
*fc
)
2055 struct selinux_fs_info
*fsi
;
2057 struct dentry
*dentry
;
2058 struct inode
*inode
;
2059 struct inode_security_struct
*isec
;
2061 static const struct tree_descr selinux_files
[] = {
2062 [SEL_LOAD
] = {"load", &sel_load_ops
, S_IRUSR
|S_IWUSR
},
2063 [SEL_ENFORCE
] = {"enforce", &sel_enforce_ops
, S_IRUGO
|S_IWUSR
},
2064 [SEL_CONTEXT
] = {"context", &transaction_ops
, S_IRUGO
|S_IWUGO
},
2065 [SEL_ACCESS
] = {"access", &transaction_ops
, S_IRUGO
|S_IWUGO
},
2066 [SEL_CREATE
] = {"create", &transaction_ops
, S_IRUGO
|S_IWUGO
},
2067 [SEL_RELABEL
] = {"relabel", &transaction_ops
, S_IRUGO
|S_IWUGO
},
2068 [SEL_USER
] = {"user", &transaction_ops
, S_IRUGO
|S_IWUGO
},
2069 [SEL_POLICYVERS
] = {"policyvers", &sel_policyvers_ops
, S_IRUGO
},
2070 [SEL_COMMIT_BOOLS
] = {"commit_pending_bools", &sel_commit_bools_ops
, S_IWUSR
},
2071 [SEL_MLS
] = {"mls", &sel_mls_ops
, S_IRUGO
},
2072 [SEL_DISABLE
] = {"disable", &sel_disable_ops
, S_IWUSR
},
2073 [SEL_MEMBER
] = {"member", &transaction_ops
, S_IRUGO
|S_IWUGO
},
2074 [SEL_CHECKREQPROT
] = {"checkreqprot", &sel_checkreqprot_ops
, S_IRUGO
|S_IWUSR
},
2075 [SEL_REJECT_UNKNOWN
] = {"reject_unknown", &sel_handle_unknown_ops
, S_IRUGO
},
2076 [SEL_DENY_UNKNOWN
] = {"deny_unknown", &sel_handle_unknown_ops
, S_IRUGO
},
2077 [SEL_STATUS
] = {"status", &sel_handle_status_ops
, S_IRUGO
},
2078 [SEL_POLICY
] = {"policy", &sel_policy_ops
, S_IRUGO
},
2079 [SEL_VALIDATE_TRANS
] = {"validatetrans", &sel_transition_ops
,
2084 ret
= selinux_fs_info_create(sb
);
2088 ret
= simple_fill_super(sb
, SELINUX_MAGIC
, selinux_files
);
2092 fsi
= sb
->s_fs_info
;
2093 fsi
->bool_dir
= sel_make_dir(sb
->s_root
, BOOL_DIR_NAME
, &fsi
->last_ino
);
2094 if (IS_ERR(fsi
->bool_dir
)) {
2095 ret
= PTR_ERR(fsi
->bool_dir
);
2096 fsi
->bool_dir
= NULL
;
2101 dentry
= d_alloc_name(sb
->s_root
, NULL_FILE_NAME
);
2106 inode
= sel_make_inode(sb
, S_IFCHR
| S_IRUGO
| S_IWUGO
);
2112 inode
->i_ino
= ++fsi
->last_ino
;
2113 isec
= selinux_inode(inode
);
2114 isec
->sid
= SECINITSID_DEVNULL
;
2115 isec
->sclass
= SECCLASS_CHR_FILE
;
2116 isec
->initialized
= LABEL_INITIALIZED
;
2118 init_special_inode(inode
, S_IFCHR
| S_IRUGO
| S_IWUGO
, MKDEV(MEM_MAJOR
, 3));
2119 d_add(dentry
, inode
);
2121 dentry
= sel_make_dir(sb
->s_root
, "avc", &fsi
->last_ino
);
2122 if (IS_ERR(dentry
)) {
2123 ret
= PTR_ERR(dentry
);
2127 ret
= sel_make_avc_files(dentry
);
2129 dentry
= sel_make_dir(sb
->s_root
, "ss", &fsi
->last_ino
);
2130 if (IS_ERR(dentry
)) {
2131 ret
= PTR_ERR(dentry
);
2135 ret
= sel_make_ss_files(dentry
);
2139 dentry
= sel_make_dir(sb
->s_root
, "initial_contexts", &fsi
->last_ino
);
2140 if (IS_ERR(dentry
)) {
2141 ret
= PTR_ERR(dentry
);
2145 ret
= sel_make_initcon_files(dentry
);
2149 fsi
->class_dir
= sel_make_dir(sb
->s_root
, CLASS_DIR_NAME
, &fsi
->last_ino
);
2150 if (IS_ERR(fsi
->class_dir
)) {
2151 ret
= PTR_ERR(fsi
->class_dir
);
2152 fsi
->class_dir
= NULL
;
2156 fsi
->policycap_dir
= sel_make_dir(sb
->s_root
, POLICYCAP_DIR_NAME
,
2158 if (IS_ERR(fsi
->policycap_dir
)) {
2159 ret
= PTR_ERR(fsi
->policycap_dir
);
2160 fsi
->policycap_dir
= NULL
;
2164 ret
= sel_make_policycap(fsi
);
2166 pr_err("SELinux: failed to load policy capabilities\n");
2172 pr_err("SELinux: %s: failed while creating inodes\n",
2175 selinux_fs_info_free(sb
);
2180 static int sel_get_tree(struct fs_context
*fc
)
2182 return get_tree_single(fc
, sel_fill_super
);
2185 static const struct fs_context_operations sel_context_ops
= {
2186 .get_tree
= sel_get_tree
,
2189 static int sel_init_fs_context(struct fs_context
*fc
)
2191 fc
->ops
= &sel_context_ops
;
2195 static void sel_kill_sb(struct super_block
*sb
)
2197 selinux_fs_info_free(sb
);
2198 kill_litter_super(sb
);
2201 static struct file_system_type sel_fs_type
= {
2202 .name
= "selinuxfs",
2203 .init_fs_context
= sel_init_fs_context
,
2204 .kill_sb
= sel_kill_sb
,
2207 struct vfsmount
*selinuxfs_mount
;
2208 struct path selinux_null
;
2210 static int __init
init_sel_fs(void)
2212 struct qstr null_name
= QSTR_INIT(NULL_FILE_NAME
,
2213 sizeof(NULL_FILE_NAME
)-1);
2216 if (!selinux_enabled_boot
)
2219 err
= sysfs_create_mount_point(fs_kobj
, "selinux");
2223 err
= register_filesystem(&sel_fs_type
);
2225 sysfs_remove_mount_point(fs_kobj
, "selinux");
2229 selinux_null
.mnt
= selinuxfs_mount
= kern_mount(&sel_fs_type
);
2230 if (IS_ERR(selinuxfs_mount
)) {
2231 pr_err("selinuxfs: could not mount!\n");
2232 err
= PTR_ERR(selinuxfs_mount
);
2233 selinuxfs_mount
= NULL
;
2235 selinux_null
.dentry
= d_hash_and_lookup(selinux_null
.mnt
->mnt_root
,
2237 if (IS_ERR(selinux_null
.dentry
)) {
2238 pr_err("selinuxfs: could not lookup null!\n");
2239 err
= PTR_ERR(selinux_null
.dentry
);
2240 selinux_null
.dentry
= NULL
;
2246 __initcall(init_sel_fs
);
2248 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
2249 void exit_sel_fs(void)
2251 sysfs_remove_mount_point(fs_kobj
, "selinux");
2252 dput(selinux_null
.dentry
);
2253 kern_unmount(selinuxfs_mount
);
2254 unregister_filesystem(&sel_fs_type
);