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

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

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

~ [ 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