selinuxfs.c 42.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/* Updated: Karl MacMillan <kmacmillan@tresys.com>
 *
3
 *	Added conditional policy language extensions
L
Linus Torvalds 已提交
4
 *
5
 *  Updated: Hewlett-Packard <paul@paul-moore.com>
6
 *
7
 *	Added support for the policy capability bitmap
8 9
 *
 * Copyright (C) 2007 Hewlett-Packard Development Company, L.P.
L
Linus Torvalds 已提交
10 11 12
 * Copyright (C) 2003 - 2004 Tresys Technology, LLC
 * Copyright (C) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
 *	This program is free software; you can redistribute it and/or modify
13
 *	it under the terms of the GNU General Public License as published by
L
Linus Torvalds 已提交
14 15 16 17 18 19 20 21
 *	the Free Software Foundation, version 2.
 */

#include <linux/kernel.h>
#include <linux/pagemap.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/fs.h>
I
Ingo Molnar 已提交
22
#include <linux/mutex.h>
L
Linus Torvalds 已提交
23 24 25 26 27 28
#include <linux/init.h>
#include <linux/string.h>
#include <linux/security.h>
#include <linux/major.h>
#include <linux/seq_file.h>
#include <linux/percpu.h>
S
Steve Grubb 已提交
29
#include <linux/audit.h>
30
#include <linux/uaccess.h>
31
#include <linux/kobject.h>
32
#include <linux/ctype.h>
L
Linus Torvalds 已提交
33 34 35 36 37 38 39 40 41 42 43

/* selinuxfs pseudo filesystem for exporting the security policy API.
   Based on the proc code and the fs/nfsd/nfsctl.c code. */

#include "flask.h"
#include "avc.h"
#include "avc_ss.h"
#include "security.h"
#include "objsec.h"
#include "conditional.h"

44 45
/* Policy capability filenames */
static char *policycap_names[] = {
E
Eric Paris 已提交
46 47
	"network_peer_controls",
	"open_perms"
48 49
};

L
Linus Torvalds 已提交
50 51 52 53
unsigned int selinux_checkreqprot = CONFIG_SECURITY_SELINUX_CHECKREQPROT_VALUE;

static int __init checkreqprot_setup(char *str)
{
54 55 56
	unsigned long checkreqprot;
	if (!strict_strtoul(str, 0, &checkreqprot))
		selinux_checkreqprot = checkreqprot ? 1 : 0;
L
Linus Torvalds 已提交
57 58 59 60
	return 1;
}
__setup("checkreqprot=", checkreqprot_setup);

I
Ingo Molnar 已提交
61
static DEFINE_MUTEX(sel_mutex);
L
Linus Torvalds 已提交
62 63

/* global data for booleans */
64 65
static struct dentry *bool_dir;
static int bool_num;
S
Stephen Smalley 已提交
66
static char **bool_pending_names;
67
static int *bool_pending_values;
L
Linus Torvalds 已提交
68

69
/* global data for classes */
70
static struct dentry *class_dir;
71 72
static unsigned long last_class_ino;

73 74
static char policy_opened;

75
/* global data for policy capabilities */
76
static struct dentry *policycap_dir;
77

L
Linus Torvalds 已提交
78 79 80 81
/* Check whether a task is allowed to use a security operation. */
static int task_has_security(struct task_struct *tsk,
			     u32 perms)
{
82 83 84 85 86 87 88 89
	const struct task_security_struct *tsec;
	u32 sid = 0;

	rcu_read_lock();
	tsec = __task_cred(tsk)->security;
	if (tsec)
		sid = tsec->sid;
	rcu_read_unlock();
L
Linus Torvalds 已提交
90 91 92
	if (!tsec)
		return -EACCES;

93
	return avc_has_perm(sid, SECINITSID_SECURITY,
L
Linus Torvalds 已提交
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
			    SECCLASS_SECURITY, perms, NULL);
}

enum sel_inos {
	SEL_ROOT_INO = 2,
	SEL_LOAD,	/* load policy */
	SEL_ENFORCE,	/* get or set enforcing status */
	SEL_CONTEXT,	/* validate context */
	SEL_ACCESS,	/* compute access decision */
	SEL_CREATE,	/* compute create labeling decision */
	SEL_RELABEL,	/* compute relabeling decision */
	SEL_USER,	/* compute reachable user contexts */
	SEL_POLICYVERS,	/* return policy version for this kernel */
	SEL_COMMIT_BOOLS, /* commit new boolean values */
	SEL_MLS,	/* return if MLS policy is enabled */
	SEL_DISABLE,	/* disable SELinux until next reboot */
	SEL_MEMBER,	/* compute polyinstantiation membership decision */
	SEL_CHECKREQPROT, /* check requested protection, not kernel-applied one */
112
	SEL_COMPAT_NET,	/* whether to use old compat network packet controls */
113 114
	SEL_REJECT_UNKNOWN, /* export unknown reject handling to userspace */
	SEL_DENY_UNKNOWN, /* export unknown deny handling to userspace */
115
	SEL_STATUS,	/* export current status using mmap() */
116
	SEL_POLICY,	/* allow userspace to read the in kernel policy */
117
	SEL_INO_NEXT,	/* The next inode number to use */
L
Linus Torvalds 已提交
118 119
};

120 121
static unsigned long sel_last_ino = SEL_INO_NEXT - 1;

122 123 124 125 126
#define SEL_INITCON_INO_OFFSET		0x01000000
#define SEL_BOOL_INO_OFFSET		0x02000000
#define SEL_CLASS_INO_OFFSET		0x04000000
#define SEL_POLICYCAP_INO_OFFSET	0x08000000
#define SEL_INO_MASK			0x00ffffff
127

L
Linus Torvalds 已提交
128 129 130 131 132 133 134 135 136 137 138 139
#define TMPBUFLEN	12
static ssize_t sel_read_enforce(struct file *filp, char __user *buf,
				size_t count, loff_t *ppos)
{
	char tmpbuf[TMPBUFLEN];
	ssize_t length;

	length = scnprintf(tmpbuf, TMPBUFLEN, "%d", selinux_enforcing);
	return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
}

#ifdef CONFIG_SECURITY_SELINUX_DEVELOP
140
static ssize_t sel_write_enforce(struct file *file, const char __user *buf,
L
Linus Torvalds 已提交
141 142 143
				 size_t count, loff_t *ppos)

{
144
	char *page = NULL;
L
Linus Torvalds 已提交
145 146 147
	ssize_t length;
	int new_value;

148
	length = -ENOMEM;
149
	if (count >= PAGE_SIZE)
150 151 152 153 154 155 156 157
		goto out;

	/* No partial writes. */
	length = EINVAL;
	if (*ppos != 0)
		goto out;

	length = -ENOMEM;
158
	page = (char *)get_zeroed_page(GFP_KERNEL);
L
Linus Torvalds 已提交
159
	if (!page)
160 161
		goto out;

L
Linus Torvalds 已提交
162 163 164 165 166 167 168 169 170 171 172 173
	length = -EFAULT;
	if (copy_from_user(page, buf, count))
		goto out;

	length = -EINVAL;
	if (sscanf(page, "%d", &new_value) != 1)
		goto out;

	if (new_value != selinux_enforcing) {
		length = task_has_security(current, SECURITY__SETENFORCE);
		if (length)
			goto out;
S
Steve Grubb 已提交
174
		audit_log(current->audit_context, GFP_KERNEL, AUDIT_MAC_STATUS,
175 176
			"enforcing=%d old_enforcing=%d auid=%u ses=%u",
			new_value, selinux_enforcing,
177
			from_kuid(&init_user_ns, audit_get_loginuid(current)),
178
			audit_get_sessionid(current));
L
Linus Torvalds 已提交
179 180 181 182
		selinux_enforcing = new_value;
		if (selinux_enforcing)
			avc_ss_reset(0);
		selnl_notify_setenforce(selinux_enforcing);
183
		selinux_status_update_setenforce(selinux_enforcing);
L
Linus Torvalds 已提交
184 185 186 187 188 189 190 191 192 193
	}
	length = count;
out:
	free_page((unsigned long) page);
	return length;
}
#else
#define sel_write_enforce NULL
#endif

194
static const struct file_operations sel_enforce_ops = {
L
Linus Torvalds 已提交
195 196
	.read		= sel_read_enforce,
	.write		= sel_write_enforce,
A
Arnd Bergmann 已提交
197
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
198 199
};

200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
static ssize_t sel_read_handle_unknown(struct file *filp, char __user *buf,
					size_t count, loff_t *ppos)
{
	char tmpbuf[TMPBUFLEN];
	ssize_t length;
	ino_t ino = filp->f_path.dentry->d_inode->i_ino;
	int handle_unknown = (ino == SEL_REJECT_UNKNOWN) ?
		security_get_reject_unknown() : !security_get_allow_unknown();

	length = scnprintf(tmpbuf, TMPBUFLEN, "%d", handle_unknown);
	return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
}

static const struct file_operations sel_handle_unknown_ops = {
	.read		= sel_read_handle_unknown,
A
Arnd Bergmann 已提交
215
	.llseek		= generic_file_llseek,
216 217
};

218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
static int sel_open_handle_status(struct inode *inode, struct file *filp)
{
	struct page    *status = selinux_kernel_status_page();

	if (!status)
		return -ENOMEM;

	filp->private_data = status;

	return 0;
}

static ssize_t sel_read_handle_status(struct file *filp, char __user *buf,
				      size_t count, loff_t *ppos)
{
	struct page    *status = filp->private_data;

	BUG_ON(!status);

	return simple_read_from_buffer(buf, count, ppos,
				       page_address(status),
				       sizeof(struct selinux_kernel_status));
}

static int sel_mmap_handle_status(struct file *filp,
				  struct vm_area_struct *vma)
{
	struct page    *status = filp->private_data;
	unsigned long	size = vma->vm_end - vma->vm_start;

	BUG_ON(!status);

	/* only allows one page from the head */
	if (vma->vm_pgoff > 0 || size != PAGE_SIZE)
		return -EIO;
	/* disallow writable mapping */
	if (vma->vm_flags & VM_WRITE)
		return -EPERM;
	/* disallow mprotect() turns it into writable */
	vma->vm_flags &= ~VM_MAYWRITE;

	return remap_pfn_range(vma, vma->vm_start,
			       page_to_pfn(status),
			       size, vma->vm_page_prot);
}

static const struct file_operations sel_handle_status_ops = {
	.open		= sel_open_handle_status,
	.read		= sel_read_handle_status,
	.mmap		= sel_mmap_handle_status,
	.llseek		= generic_file_llseek,
};

L
Linus Torvalds 已提交
271
#ifdef CONFIG_SECURITY_SELINUX_DISABLE
272
static ssize_t sel_write_disable(struct file *file, const char __user *buf,
L
Linus Torvalds 已提交
273 274 275
				 size_t count, loff_t *ppos)

{
276
	char *page = NULL;
L
Linus Torvalds 已提交
277 278 279
	ssize_t length;
	int new_value;

280
	length = -ENOMEM;
281
	if (count >= PAGE_SIZE)
282
		goto out;
283 284 285 286 287 288 289

	/* No partial writes. */
	length = -EINVAL;
	if (*ppos != 0)
		goto out;

	length = -ENOMEM;
290
	page = (char *)get_zeroed_page(GFP_KERNEL);
L
Linus Torvalds 已提交
291
	if (!page)
292 293
		goto out;

L
Linus Torvalds 已提交
294 295 296 297 298 299 300 301 302 303
	length = -EFAULT;
	if (copy_from_user(page, buf, count))
		goto out;

	length = -EINVAL;
	if (sscanf(page, "%d", &new_value) != 1)
		goto out;

	if (new_value) {
		length = selinux_disable();
304
		if (length)
L
Linus Torvalds 已提交
305
			goto out;
S
Steve Grubb 已提交
306
		audit_log(current->audit_context, GFP_KERNEL, AUDIT_MAC_STATUS,
307
			"selinux=0 auid=%u ses=%u",
308
			from_kuid(&init_user_ns, audit_get_loginuid(current)),
309
			audit_get_sessionid(current));
L
Linus Torvalds 已提交
310 311 312 313 314 315 316 317 318 319 320
	}

	length = count;
out:
	free_page((unsigned long) page);
	return length;
}
#else
#define sel_write_disable NULL
#endif

321
static const struct file_operations sel_disable_ops = {
L
Linus Torvalds 已提交
322
	.write		= sel_write_disable,
A
Arnd Bergmann 已提交
323
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
324 325 326
};

static ssize_t sel_read_policyvers(struct file *filp, char __user *buf,
327
				   size_t count, loff_t *ppos)
L
Linus Torvalds 已提交
328 329 330 331 332 333 334 335
{
	char tmpbuf[TMPBUFLEN];
	ssize_t length;

	length = scnprintf(tmpbuf, TMPBUFLEN, "%u", POLICYDB_VERSION_MAX);
	return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
}

336
static const struct file_operations sel_policyvers_ops = {
L
Linus Torvalds 已提交
337
	.read		= sel_read_policyvers,
A
Arnd Bergmann 已提交
338
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
339 340 341 342
};

/* declaration for sel_write_load */
static int sel_make_bools(void);
343
static int sel_make_classes(void);
344
static int sel_make_policycap(void);
345 346

/* declaration for sel_make_class_dirs */
347
static struct dentry *sel_make_dir(struct dentry *dir, const char *name,
348
			unsigned long *ino);
L
Linus Torvalds 已提交
349 350 351 352 353 354 355

static ssize_t sel_read_mls(struct file *filp, char __user *buf,
				size_t count, loff_t *ppos)
{
	char tmpbuf[TMPBUFLEN];
	ssize_t length;

356 357
	length = scnprintf(tmpbuf, TMPBUFLEN, "%d",
			   security_mls_enabled());
L
Linus Torvalds 已提交
358 359 360
	return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
}

361
static const struct file_operations sel_mls_ops = {
L
Linus Torvalds 已提交
362
	.read		= sel_read_mls,
A
Arnd Bergmann 已提交
363
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
364 365
};

366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
struct policy_load_memory {
	size_t len;
	void *data;
};

static int sel_open_policy(struct inode *inode, struct file *filp)
{
	struct policy_load_memory *plm = NULL;
	int rc;

	BUG_ON(filp->private_data);

	mutex_lock(&sel_mutex);

	rc = task_has_security(current, SECURITY__READ_POLICY);
	if (rc)
		goto err;

	rc = -EBUSY;
	if (policy_opened)
		goto err;

	rc = -ENOMEM;
	plm = kzalloc(sizeof(*plm), GFP_KERNEL);
	if (!plm)
		goto err;

	if (i_size_read(inode) != security_policydb_len()) {
		mutex_lock(&inode->i_mutex);
		i_size_write(inode, security_policydb_len());
		mutex_unlock(&inode->i_mutex);
	}

	rc = security_read_policy(&plm->data, &plm->len);
	if (rc)
		goto err;

	policy_opened = 1;

	filp->private_data = plm;

	mutex_unlock(&sel_mutex);

	return 0;
err:
	mutex_unlock(&sel_mutex);

	if (plm)
		vfree(plm->data);
	kfree(plm);
	return rc;
}

static int sel_release_policy(struct inode *inode, struct file *filp)
{
	struct policy_load_memory *plm = filp->private_data;

	BUG_ON(!plm);

	policy_opened = 0;

	vfree(plm->data);
	kfree(plm);

	return 0;
}

static ssize_t sel_read_policy(struct file *filp, char __user *buf,
			       size_t count, loff_t *ppos)
{
	struct policy_load_memory *plm = filp->private_data;
	int ret;

	mutex_lock(&sel_mutex);

	ret = task_has_security(current, SECURITY__READ_POLICY);
	if (ret)
		goto out;

	ret = simple_read_from_buffer(buf, count, ppos, plm->data, plm->len);
out:
	mutex_unlock(&sel_mutex);
	return ret;
}

451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
static int sel_mmap_policy_fault(struct vm_area_struct *vma,
				 struct vm_fault *vmf)
{
	struct policy_load_memory *plm = vma->vm_file->private_data;
	unsigned long offset;
	struct page *page;

	if (vmf->flags & (FAULT_FLAG_MKWRITE | FAULT_FLAG_WRITE))
		return VM_FAULT_SIGBUS;

	offset = vmf->pgoff << PAGE_SHIFT;
	if (offset >= roundup(plm->len, PAGE_SIZE))
		return VM_FAULT_SIGBUS;

	page = vmalloc_to_page(plm->data + offset);
	get_page(page);

	vmf->page = page;

	return 0;
}

static struct vm_operations_struct sel_mmap_policy_ops = {
	.fault = sel_mmap_policy_fault,
	.page_mkwrite = sel_mmap_policy_fault,
};

478
static int sel_mmap_policy(struct file *filp, struct vm_area_struct *vma)
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
{
	if (vma->vm_flags & VM_SHARED) {
		/* do not allow mprotect to make mapping writable */
		vma->vm_flags &= ~VM_MAYWRITE;

		if (vma->vm_flags & VM_WRITE)
			return -EACCES;
	}

	vma->vm_flags |= VM_RESERVED;
	vma->vm_ops = &sel_mmap_policy_ops;

	return 0;
}

494 495 496
static const struct file_operations sel_policy_ops = {
	.open		= sel_open_policy,
	.read		= sel_read_policy,
497
	.mmap		= sel_mmap_policy,
498
	.release	= sel_release_policy,
499
	.llseek		= generic_file_llseek,
500 501
};

502
static ssize_t sel_write_load(struct file *file, const char __user *buf,
L
Linus Torvalds 已提交
503 504 505 506 507 508
			      size_t count, loff_t *ppos)

{
	ssize_t length;
	void *data = NULL;

I
Ingo Molnar 已提交
509
	mutex_lock(&sel_mutex);
L
Linus Torvalds 已提交
510 511 512 513 514

	length = task_has_security(current, SECURITY__LOAD_POLICY);
	if (length)
		goto out;

515 516 517
	/* No partial writes. */
	length = -EINVAL;
	if (*ppos != 0)
L
Linus Torvalds 已提交
518 519
		goto out;

520 521 522 523 524 525 526
	length = -EFBIG;
	if (count > 64 * 1024 * 1024)
		goto out;

	length = -ENOMEM;
	data = vmalloc(count);
	if (!data)
L
Linus Torvalds 已提交
527 528 529 530 531 532 533 534 535 536
		goto out;

	length = -EFAULT;
	if (copy_from_user(data, buf, count) != 0)
		goto out;

	length = security_load_policy(data, count);
	if (length)
		goto out;

537 538
	length = sel_make_bools();
	if (length)
539 540
		goto out1;

541 542
	length = sel_make_classes();
	if (length)
543 544
		goto out1;

545 546 547 548 549
	length = sel_make_policycap();
	if (length)
		goto out1;

	length = count;
550 551

out1:
S
Steve Grubb 已提交
552
	audit_log(current->audit_context, GFP_KERNEL, AUDIT_MAC_POLICY_LOAD,
553
		"policy loaded auid=%u ses=%u",
554
		from_kuid(&init_user_ns, audit_get_loginuid(current)),
555
		audit_get_sessionid(current));
L
Linus Torvalds 已提交
556
out:
I
Ingo Molnar 已提交
557
	mutex_unlock(&sel_mutex);
L
Linus Torvalds 已提交
558 559 560 561
	vfree(data);
	return length;
}

562
static const struct file_operations sel_load_ops = {
L
Linus Torvalds 已提交
563
	.write		= sel_write_load,
A
Arnd Bergmann 已提交
564
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
565 566
};

567
static ssize_t sel_write_context(struct file *file, char *buf, size_t size)
L
Linus Torvalds 已提交
568
{
569
	char *canon = NULL;
570
	u32 sid, len;
L
Linus Torvalds 已提交
571 572 573 574
	ssize_t length;

	length = task_has_security(current, SECURITY__CHECK_CONTEXT);
	if (length)
575
		goto out;
L
Linus Torvalds 已提交
576

577
	length = security_context_to_sid(buf, size, &sid);
578 579
	if (length)
		goto out;
L
Linus Torvalds 已提交
580

581
	length = security_sid_to_context(sid, &canon, &len);
582 583
	if (length)
		goto out;
584

585
	length = -ERANGE;
586
	if (len > SIMPLE_TRANSACTION_LIMIT) {
E
Eric Paris 已提交
587 588
		printk(KERN_ERR "SELinux: %s:  context size (%u) exceeds "
			"payload max\n", __func__, len);
L
Linus Torvalds 已提交
589
		goto out;
590
	}
L
Linus Torvalds 已提交
591

592 593
	memcpy(buf, canon, len);
	length = len;
L
Linus Torvalds 已提交
594
out:
595
	kfree(canon);
L
Linus Torvalds 已提交
596 597 598 599 600 601 602 603 604 605 606 607 608
	return length;
}

static ssize_t sel_read_checkreqprot(struct file *filp, char __user *buf,
				     size_t count, loff_t *ppos)
{
	char tmpbuf[TMPBUFLEN];
	ssize_t length;

	length = scnprintf(tmpbuf, TMPBUFLEN, "%u", selinux_checkreqprot);
	return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
}

609
static ssize_t sel_write_checkreqprot(struct file *file, const char __user *buf,
L
Linus Torvalds 已提交
610 611
				      size_t count, loff_t *ppos)
{
612
	char *page = NULL;
L
Linus Torvalds 已提交
613 614 615 616 617
	ssize_t length;
	unsigned int new_value;

	length = task_has_security(current, SECURITY__SETCHECKREQPROT);
	if (length)
618
		goto out;
L
Linus Torvalds 已提交
619

620
	length = -ENOMEM;
621
	if (count >= PAGE_SIZE)
622 623 624 625 626 627 628 629
		goto out;

	/* No partial writes. */
	length = -EINVAL;
	if (*ppos != 0)
		goto out;

	length = -ENOMEM;
630
	page = (char *)get_zeroed_page(GFP_KERNEL);
L
Linus Torvalds 已提交
631
	if (!page)
632 633
		goto out;

L
Linus Torvalds 已提交
634 635 636 637 638 639 640 641 642 643 644 645 646 647
	length = -EFAULT;
	if (copy_from_user(page, buf, count))
		goto out;

	length = -EINVAL;
	if (sscanf(page, "%u", &new_value) != 1)
		goto out;

	selinux_checkreqprot = new_value ? 1 : 0;
	length = count;
out:
	free_page((unsigned long) page);
	return length;
}
648
static const struct file_operations sel_checkreqprot_ops = {
L
Linus Torvalds 已提交
649 650
	.read		= sel_read_checkreqprot,
	.write		= sel_write_checkreqprot,
A
Arnd Bergmann 已提交
651
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
652 653 654 655 656
};

/*
 * Remaining nodes use transaction based IO methods like nfsd/nfsctl.c
 */
657 658 659 660 661
static ssize_t sel_write_access(struct file *file, char *buf, size_t size);
static ssize_t sel_write_create(struct file *file, char *buf, size_t size);
static ssize_t sel_write_relabel(struct file *file, char *buf, size_t size);
static ssize_t sel_write_user(struct file *file, char *buf, size_t size);
static ssize_t sel_write_member(struct file *file, char *buf, size_t size);
L
Linus Torvalds 已提交
662 663 664 665 666 667 668

static ssize_t (*write_op[])(struct file *, char *, size_t) = {
	[SEL_ACCESS] = sel_write_access,
	[SEL_CREATE] = sel_write_create,
	[SEL_RELABEL] = sel_write_relabel,
	[SEL_USER] = sel_write_user,
	[SEL_MEMBER] = sel_write_member,
669
	[SEL_CONTEXT] = sel_write_context,
L
Linus Torvalds 已提交
670 671 672 673
};

static ssize_t selinux_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
{
674
	ino_t ino = file->f_path.dentry->d_inode->i_ino;
L
Linus Torvalds 已提交
675 676 677
	char *data;
	ssize_t rv;

678
	if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
L
Linus Torvalds 已提交
679 680 681 682 683 684
		return -EINVAL;

	data = simple_transaction_get(file, buf, size);
	if (IS_ERR(data))
		return PTR_ERR(data);

685 686
	rv = write_op[ino](file, data, size);
	if (rv > 0) {
L
Linus Torvalds 已提交
687 688 689 690 691 692
		simple_transaction_set(file, rv);
		rv = size;
	}
	return rv;
}

693
static const struct file_operations transaction_ops = {
L
Linus Torvalds 已提交
694 695 696
	.write		= selinux_transaction_write,
	.read		= simple_transaction_read,
	.release	= simple_transaction_release,
A
Arnd Bergmann 已提交
697
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
698 699 700 701 702 703 704 705
};

/*
 * payload - write methods
 * If the method has a response, the response should be put in buf,
 * and the length returned.  Otherwise return 0 or and -error.
 */

706
static ssize_t sel_write_access(struct file *file, char *buf, size_t size)
L
Linus Torvalds 已提交
707
{
708
	char *scon = NULL, *tcon = NULL;
L
Linus Torvalds 已提交
709 710 711 712 713 714 715
	u32 ssid, tsid;
	u16 tclass;
	struct av_decision avd;
	ssize_t length;

	length = task_has_security(current, SECURITY__COMPUTE_AV);
	if (length)
716
		goto out;
L
Linus Torvalds 已提交
717 718

	length = -ENOMEM;
719
	scon = kzalloc(size + 1, GFP_KERNEL);
L
Linus Torvalds 已提交
720
	if (!scon)
721
		goto out;
L
Linus Torvalds 已提交
722

723
	length = -ENOMEM;
724
	tcon = kzalloc(size + 1, GFP_KERNEL);
L
Linus Torvalds 已提交
725 726 727 728
	if (!tcon)
		goto out;

	length = -EINVAL;
729
	if (sscanf(buf, "%s %s %hu", scon, tcon, &tclass) != 3)
730
		goto out;
L
Linus Torvalds 已提交
731

732
	length = security_context_to_sid(scon, strlen(scon) + 1, &ssid);
733 734 735
	if (length)
		goto out;

736
	length = security_context_to_sid(tcon, strlen(tcon) + 1, &tsid);
737 738
	if (length)
		goto out;
L
Linus Torvalds 已提交
739

740
	security_compute_av_user(ssid, tsid, tclass, &avd);
L
Linus Torvalds 已提交
741 742

	length = scnprintf(buf, SIMPLE_TRANSACTION_LIMIT,
743
			  "%x %x %x %x %u %x",
744
			  avd.allowed, 0xffffffff,
L
Linus Torvalds 已提交
745
			  avd.auditallow, avd.auditdeny,
746
			  avd.seqno, avd.flags);
L
Linus Torvalds 已提交
747
out:
748
	kfree(tcon);
L
Linus Torvalds 已提交
749 750 751 752
	kfree(scon);
	return length;
}

753
static ssize_t sel_write_create(struct file *file, char *buf, size_t size)
L
Linus Torvalds 已提交
754
{
755
	char *scon = NULL, *tcon = NULL;
756
	char *namebuf = NULL, *objname = NULL;
L
Linus Torvalds 已提交
757 758 759
	u32 ssid, tsid, newsid;
	u16 tclass;
	ssize_t length;
760
	char *newcon = NULL;
L
Linus Torvalds 已提交
761
	u32 len;
762
	int nargs;
L
Linus Torvalds 已提交
763 764 765

	length = task_has_security(current, SECURITY__COMPUTE_CREATE);
	if (length)
766
		goto out;
L
Linus Torvalds 已提交
767 768

	length = -ENOMEM;
769
	scon = kzalloc(size + 1, GFP_KERNEL);
L
Linus Torvalds 已提交
770
	if (!scon)
771
		goto out;
L
Linus Torvalds 已提交
772

773
	length = -ENOMEM;
774
	tcon = kzalloc(size + 1, GFP_KERNEL);
L
Linus Torvalds 已提交
775 776 777
	if (!tcon)
		goto out;

778 779 780 781 782
	length = -ENOMEM;
	namebuf = kzalloc(size + 1, GFP_KERNEL);
	if (!namebuf)
		goto out;

L
Linus Torvalds 已提交
783
	length = -EINVAL;
784 785
	nargs = sscanf(buf, "%s %s %hu %s", scon, tcon, &tclass, namebuf);
	if (nargs < 3 || nargs > 4)
786
		goto out;
787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803
	if (nargs == 4) {
		/*
		 * If and when the name of new object to be queried contains
		 * either whitespace or multibyte characters, they shall be
		 * encoded based on the percentage-encoding rule.
		 * If not encoded, the sscanf logic picks up only left-half
		 * of the supplied name; splitted by a whitespace unexpectedly.
		 */
		char   *r, *w;
		int     c1, c2;

		r = w = namebuf;
		do {
			c1 = *r++;
			if (c1 == '+')
				c1 = ' ';
			else if (c1 == '%') {
804 805
				c1 = hex_to_bin(*r++);
				if (c1 < 0)
806
					goto out;
807 808
				c2 = hex_to_bin(*r++);
				if (c2 < 0)
809 810 811 812 813 814
					goto out;
				c1 = (c1 << 4) | c2;
			}
			*w++ = c1;
		} while (c1 != '\0');

815
		objname = namebuf;
816
	}
L
Linus Torvalds 已提交
817

818
	length = security_context_to_sid(scon, strlen(scon) + 1, &ssid);
819 820 821
	if (length)
		goto out;

822
	length = security_context_to_sid(tcon, strlen(tcon) + 1, &tsid);
823 824
	if (length)
		goto out;
L
Linus Torvalds 已提交
825

826 827
	length = security_transition_sid_user(ssid, tsid, tclass,
					      objname, &newsid);
828 829
	if (length)
		goto out;
L
Linus Torvalds 已提交
830 831

	length = security_sid_to_context(newsid, &newcon, &len);
832 833
	if (length)
		goto out;
L
Linus Torvalds 已提交
834

835
	length = -ERANGE;
L
Linus Torvalds 已提交
836
	if (len > SIMPLE_TRANSACTION_LIMIT) {
E
Eric Paris 已提交
837 838
		printk(KERN_ERR "SELinux: %s:  context size (%u) exceeds "
			"payload max\n", __func__, len);
839
		goto out;
L
Linus Torvalds 已提交
840 841 842 843
	}

	memcpy(buf, newcon, len);
	length = len;
844
out:
L
Linus Torvalds 已提交
845
	kfree(newcon);
846
	kfree(namebuf);
L
Linus Torvalds 已提交
847 848 849 850 851
	kfree(tcon);
	kfree(scon);
	return length;
}

852
static ssize_t sel_write_relabel(struct file *file, char *buf, size_t size)
L
Linus Torvalds 已提交
853
{
854
	char *scon = NULL, *tcon = NULL;
L
Linus Torvalds 已提交
855 856 857
	u32 ssid, tsid, newsid;
	u16 tclass;
	ssize_t length;
858
	char *newcon = NULL;
L
Linus Torvalds 已提交
859 860 861 862
	u32 len;

	length = task_has_security(current, SECURITY__COMPUTE_RELABEL);
	if (length)
863
		goto out;
L
Linus Torvalds 已提交
864 865

	length = -ENOMEM;
866
	scon = kzalloc(size + 1, GFP_KERNEL);
L
Linus Torvalds 已提交
867
	if (!scon)
868
		goto out;
L
Linus Torvalds 已提交
869

870
	length = -ENOMEM;
871
	tcon = kzalloc(size + 1, GFP_KERNEL);
L
Linus Torvalds 已提交
872 873 874 875 876
	if (!tcon)
		goto out;

	length = -EINVAL;
	if (sscanf(buf, "%s %s %hu", scon, tcon, &tclass) != 3)
877
		goto out;
L
Linus Torvalds 已提交
878

879
	length = security_context_to_sid(scon, strlen(scon) + 1, &ssid);
880 881 882
	if (length)
		goto out;

883
	length = security_context_to_sid(tcon, strlen(tcon) + 1, &tsid);
884 885
	if (length)
		goto out;
L
Linus Torvalds 已提交
886 887

	length = security_change_sid(ssid, tsid, tclass, &newsid);
888 889
	if (length)
		goto out;
L
Linus Torvalds 已提交
890 891

	length = security_sid_to_context(newsid, &newcon, &len);
892 893
	if (length)
		goto out;
L
Linus Torvalds 已提交
894

895 896 897
	length = -ERANGE;
	if (len > SIMPLE_TRANSACTION_LIMIT)
		goto out;
L
Linus Torvalds 已提交
898 899 900

	memcpy(buf, newcon, len);
	length = len;
901
out:
L
Linus Torvalds 已提交
902 903 904 905 906 907
	kfree(newcon);
	kfree(tcon);
	kfree(scon);
	return length;
}

908
static ssize_t sel_write_user(struct file *file, char *buf, size_t size)
L
Linus Torvalds 已提交
909
{
910 911
	char *con = NULL, *user = NULL, *ptr;
	u32 sid, *sids = NULL;
L
Linus Torvalds 已提交
912 913 914 915 916 917 918
	ssize_t length;
	char *newcon;
	int i, rc;
	u32 len, nsids;

	length = task_has_security(current, SECURITY__COMPUTE_USER);
	if (length)
919
		goto out;
L
Linus Torvalds 已提交
920 921

	length = -ENOMEM;
922
	con = kzalloc(size + 1, GFP_KERNEL);
L
Linus Torvalds 已提交
923
	if (!con)
924
		goto out;
L
Linus Torvalds 已提交
925

926
	length = -ENOMEM;
927
	user = kzalloc(size + 1, GFP_KERNEL);
L
Linus Torvalds 已提交
928 929 930 931 932
	if (!user)
		goto out;

	length = -EINVAL;
	if (sscanf(buf, "%s %s", con, user) != 2)
933
		goto out;
L
Linus Torvalds 已提交
934

935
	length = security_context_to_sid(con, strlen(con) + 1, &sid);
936 937
	if (length)
		goto out;
L
Linus Torvalds 已提交
938 939

	length = security_get_user_sids(sid, user, &sids, &nsids);
940 941
	if (length)
		goto out;
L
Linus Torvalds 已提交
942 943 944 945 946 947 948

	length = sprintf(buf, "%u", nsids) + 1;
	ptr = buf + length;
	for (i = 0; i < nsids; i++) {
		rc = security_sid_to_context(sids[i], &newcon, &len);
		if (rc) {
			length = rc;
949
			goto out;
L
Linus Torvalds 已提交
950 951 952 953
		}
		if ((length + len) >= SIMPLE_TRANSACTION_LIMIT) {
			kfree(newcon);
			length = -ERANGE;
954
			goto out;
L
Linus Torvalds 已提交
955 956 957 958 959 960
		}
		memcpy(ptr, newcon, len);
		kfree(newcon);
		ptr += len;
		length += len;
	}
961
out:
L
Linus Torvalds 已提交
962 963 964 965 966 967
	kfree(sids);
	kfree(user);
	kfree(con);
	return length;
}

968
static ssize_t sel_write_member(struct file *file, char *buf, size_t size)
L
Linus Torvalds 已提交
969
{
970
	char *scon = NULL, *tcon = NULL;
L
Linus Torvalds 已提交
971 972 973
	u32 ssid, tsid, newsid;
	u16 tclass;
	ssize_t length;
974
	char *newcon = NULL;
L
Linus Torvalds 已提交
975 976 977 978
	u32 len;

	length = task_has_security(current, SECURITY__COMPUTE_MEMBER);
	if (length)
979
		goto out;
L
Linus Torvalds 已提交
980 981

	length = -ENOMEM;
982
	scon = kzalloc(size + 1, GFP_KERNEL);
L
Linus Torvalds 已提交
983
	if (!scon)
984
		goto out;
L
Linus Torvalds 已提交
985

986
	length = -ENOMEM;
987
	tcon = kzalloc(size + 1, GFP_KERNEL);
L
Linus Torvalds 已提交
988 989 990 991 992
	if (!tcon)
		goto out;

	length = -EINVAL;
	if (sscanf(buf, "%s %s %hu", scon, tcon, &tclass) != 3)
993
		goto out;
L
Linus Torvalds 已提交
994

995
	length = security_context_to_sid(scon, strlen(scon) + 1, &ssid);
996 997 998
	if (length)
		goto out;

999
	length = security_context_to_sid(tcon, strlen(tcon) + 1, &tsid);
1000 1001
	if (length)
		goto out;
L
Linus Torvalds 已提交
1002 1003

	length = security_member_sid(ssid, tsid, tclass, &newsid);
1004 1005
	if (length)
		goto out;
L
Linus Torvalds 已提交
1006 1007

	length = security_sid_to_context(newsid, &newcon, &len);
1008 1009
	if (length)
		goto out;
L
Linus Torvalds 已提交
1010

1011
	length = -ERANGE;
L
Linus Torvalds 已提交
1012
	if (len > SIMPLE_TRANSACTION_LIMIT) {
E
Eric Paris 已提交
1013 1014
		printk(KERN_ERR "SELinux: %s:  context size (%u) exceeds "
			"payload max\n", __func__, len);
1015
		goto out;
L
Linus Torvalds 已提交
1016 1017 1018 1019
	}

	memcpy(buf, newcon, len);
	length = len;
1020
out:
L
Linus Torvalds 已提交
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044
	kfree(newcon);
	kfree(tcon);
	kfree(scon);
	return length;
}

static struct inode *sel_make_inode(struct super_block *sb, int mode)
{
	struct inode *ret = new_inode(sb);

	if (ret) {
		ret->i_mode = mode;
		ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
	}
	return ret;
}

static ssize_t sel_read_bool(struct file *filep, char __user *buf,
			     size_t count, loff_t *ppos)
{
	char *page = NULL;
	ssize_t length;
	ssize_t ret;
	int cur_enforcing;
S
Stephen Smalley 已提交
1045 1046 1047
	struct inode *inode = filep->f_path.dentry->d_inode;
	unsigned index = inode->i_ino & SEL_INO_MASK;
	const char *name = filep->f_path.dentry->d_name.name;
L
Linus Torvalds 已提交
1048

I
Ingo Molnar 已提交
1049
	mutex_lock(&sel_mutex);
L
Linus Torvalds 已提交
1050

1051 1052
	ret = -EINVAL;
	if (index >= bool_num || strcmp(name, bool_pending_names[index]))
S
Stephen Smalley 已提交
1053
		goto out;
L
Linus Torvalds 已提交
1054

1055
	ret = -ENOMEM;
1056
	page = (char *)get_zeroed_page(GFP_KERNEL);
1057
	if (!page)
L
Linus Torvalds 已提交
1058 1059
		goto out;

S
Stephen Smalley 已提交
1060
	cur_enforcing = security_get_bool_value(index);
L
Linus Torvalds 已提交
1061 1062 1063 1064 1065
	if (cur_enforcing < 0) {
		ret = cur_enforcing;
		goto out;
	}
	length = scnprintf(page, PAGE_SIZE, "%d %d", cur_enforcing,
S
Stephen Smalley 已提交
1066
			  bool_pending_values[index]);
1067
	ret = simple_read_from_buffer(buf, count, ppos, page, length);
L
Linus Torvalds 已提交
1068
out:
I
Ingo Molnar 已提交
1069
	mutex_unlock(&sel_mutex);
1070
	free_page((unsigned long)page);
L
Linus Torvalds 已提交
1071 1072 1073 1074 1075 1076 1077
	return ret;
}

static ssize_t sel_write_bool(struct file *filep, const char __user *buf,
			      size_t count, loff_t *ppos)
{
	char *page = NULL;
S
Stephen Smalley 已提交
1078
	ssize_t length;
L
Linus Torvalds 已提交
1079
	int new_value;
S
Stephen Smalley 已提交
1080 1081 1082
	struct inode *inode = filep->f_path.dentry->d_inode;
	unsigned index = inode->i_ino & SEL_INO_MASK;
	const char *name = filep->f_path.dentry->d_name.name;
L
Linus Torvalds 已提交
1083

I
Ingo Molnar 已提交
1084
	mutex_lock(&sel_mutex);
L
Linus Torvalds 已提交
1085 1086 1087 1088 1089

	length = task_has_security(current, SECURITY__SETBOOL);
	if (length)
		goto out;

1090 1091
	length = -EINVAL;
	if (index >= bool_num || strcmp(name, bool_pending_names[index]))
S
Stephen Smalley 已提交
1092 1093
		goto out;

1094 1095
	length = -ENOMEM;
	if (count >= PAGE_SIZE)
L
Linus Torvalds 已提交
1096
		goto out;
S
Stephen Smalley 已提交
1097

1098 1099 1100
	/* No partial writes. */
	length = -EINVAL;
	if (*ppos != 0)
L
Linus Torvalds 已提交
1101
		goto out;
1102 1103

	length = -ENOMEM;
1104
	page = (char *)get_zeroed_page(GFP_KERNEL);
1105
	if (!page)
L
Linus Torvalds 已提交
1106 1107
		goto out;

S
Stephen Smalley 已提交
1108
	length = -EFAULT;
L
Linus Torvalds 已提交
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
	if (copy_from_user(page, buf, count))
		goto out;

	length = -EINVAL;
	if (sscanf(page, "%d", &new_value) != 1)
		goto out;

	if (new_value)
		new_value = 1;

S
Stephen Smalley 已提交
1119
	bool_pending_values[index] = new_value;
L
Linus Torvalds 已提交
1120 1121 1122
	length = count;

out:
I
Ingo Molnar 已提交
1123
	mutex_unlock(&sel_mutex);
1124
	free_page((unsigned long) page);
L
Linus Torvalds 已提交
1125 1126 1127
	return length;
}

1128
static const struct file_operations sel_bool_ops = {
1129 1130
	.read		= sel_read_bool,
	.write		= sel_write_bool,
A
Arnd Bergmann 已提交
1131
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
1132 1133 1134 1135 1136 1137 1138
};

static ssize_t sel_commit_bools_write(struct file *filep,
				      const char __user *buf,
				      size_t count, loff_t *ppos)
{
	char *page = NULL;
S
Stephen Smalley 已提交
1139
	ssize_t length;
L
Linus Torvalds 已提交
1140 1141
	int new_value;

I
Ingo Molnar 已提交
1142
	mutex_lock(&sel_mutex);
L
Linus Torvalds 已提交
1143 1144 1145 1146 1147

	length = task_has_security(current, SECURITY__SETBOOL);
	if (length)
		goto out;

1148 1149
	length = -ENOMEM;
	if (count >= PAGE_SIZE)
L
Linus Torvalds 已提交
1150
		goto out;
1151 1152 1153 1154

	/* No partial writes. */
	length = -EINVAL;
	if (*ppos != 0)
L
Linus Torvalds 已提交
1155
		goto out;
1156 1157

	length = -ENOMEM;
1158
	page = (char *)get_zeroed_page(GFP_KERNEL);
1159
	if (!page)
L
Linus Torvalds 已提交
1160 1161
		goto out;

S
Stephen Smalley 已提交
1162
	length = -EFAULT;
L
Linus Torvalds 已提交
1163 1164 1165 1166 1167 1168 1169
	if (copy_from_user(page, buf, count))
		goto out;

	length = -EINVAL;
	if (sscanf(page, "%d", &new_value) != 1)
		goto out;

1170
	length = 0;
1171
	if (new_value && bool_pending_values)
1172
		length = security_set_bools(bool_num, bool_pending_values);
L
Linus Torvalds 已提交
1173

1174 1175
	if (!length)
		length = count;
L
Linus Torvalds 已提交
1176 1177

out:
I
Ingo Molnar 已提交
1178
	mutex_unlock(&sel_mutex);
1179
	free_page((unsigned long) page);
L
Linus Torvalds 已提交
1180 1181 1182
	return length;
}

1183
static const struct file_operations sel_commit_bools_ops = {
1184
	.write		= sel_commit_bools_write,
A
Arnd Bergmann 已提交
1185
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
1186 1187
};

1188
static void sel_remove_entries(struct dentry *de)
L
Linus Torvalds 已提交
1189
{
1190
	struct list_head *node;
L
Linus Torvalds 已提交
1191

N
Nick Piggin 已提交
1192
	spin_lock(&de->d_lock);
L
Linus Torvalds 已提交
1193 1194
	node = de->d_subdirs.next;
	while (node != &de->d_subdirs) {
E
Eric Dumazet 已提交
1195
		struct dentry *d = list_entry(node, struct dentry, d_u.d_child);
N
Nick Piggin 已提交
1196 1197

		spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
L
Linus Torvalds 已提交
1198 1199 1200
		list_del_init(node);

		if (d->d_inode) {
1201
			dget_dlock(d);
N
Nick Piggin 已提交
1202 1203
			spin_unlock(&de->d_lock);
			spin_unlock(&d->d_lock);
L
Linus Torvalds 已提交
1204 1205 1206
			d_delete(d);
			simple_unlink(de->d_inode, d);
			dput(d);
N
Nick Piggin 已提交
1207 1208 1209
			spin_lock(&de->d_lock);
		} else
			spin_unlock(&d->d_lock);
L
Linus Torvalds 已提交
1210 1211 1212
		node = de->d_subdirs.next;
	}

N
Nick Piggin 已提交
1213
	spin_unlock(&de->d_lock);
L
Linus Torvalds 已提交
1214 1215 1216 1217 1218 1219
}

#define BOOL_DIR_NAME "booleans"

static int sel_make_bools(void)
{
1220
	int i, ret;
L
Linus Torvalds 已提交
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
	ssize_t len;
	struct dentry *dentry = NULL;
	struct dentry *dir = bool_dir;
	struct inode *inode = NULL;
	struct inode_security_struct *isec;
	char **names = NULL, *page;
	int num;
	int *values = NULL;
	u32 sid;

	/* remove any existing files */
1232 1233
	for (i = 0; i < bool_num; i++)
		kfree(bool_pending_names[i]);
S
Stephen Smalley 已提交
1234
	kfree(bool_pending_names);
J
Jesper Juhl 已提交
1235
	kfree(bool_pending_values);
1236
	bool_num = 0;
S
Stephen Smalley 已提交
1237
	bool_pending_names = NULL;
1238
	bool_pending_values = NULL;
L
Linus Torvalds 已提交
1239

1240
	sel_remove_entries(dir);
L
Linus Torvalds 已提交
1241

1242
	ret = -ENOMEM;
1243 1244
	page = (char *)get_zeroed_page(GFP_KERNEL);
	if (!page)
1245
		goto out;
L
Linus Torvalds 已提交
1246 1247

	ret = security_get_bools(&num, &names, &values);
1248
	if (ret)
L
Linus Torvalds 已提交
1249 1250 1251
		goto out;

	for (i = 0; i < num; i++) {
1252
		ret = -ENOMEM;
L
Linus Torvalds 已提交
1253
		dentry = d_alloc_name(dir, names[i]);
1254 1255 1256 1257
		if (!dentry)
			goto out;

		ret = -ENOMEM;
L
Linus Torvalds 已提交
1258
		inode = sel_make_inode(dir->d_sb, S_IFREG | S_IRUGO | S_IWUSR);
1259 1260
		if (!inode)
			goto out;
L
Linus Torvalds 已提交
1261

1262
		ret = -ENAMETOOLONG;
A
Al Viro 已提交
1263
		len = snprintf(page, PAGE_SIZE, "/%s/%s", BOOL_DIR_NAME, names[i]);
1264 1265 1266
		if (len >= PAGE_SIZE)
			goto out;

1267 1268 1269
		isec = (struct inode_security_struct *)inode->i_security;
		ret = security_genfs_sid("selinuxfs", page, SECCLASS_FILE, &sid);
		if (ret)
1270 1271
			goto out;

L
Linus Torvalds 已提交
1272 1273 1274
		isec->sid = sid;
		isec->initialized = 1;
		inode->i_fop = &sel_bool_ops;
1275
		inode->i_ino = i|SEL_BOOL_INO_OFFSET;
L
Linus Torvalds 已提交
1276 1277 1278
		d_add(dentry, inode);
	}
	bool_num = num;
S
Stephen Smalley 已提交
1279
	bool_pending_names = names;
L
Linus Torvalds 已提交
1280
	bool_pending_values = values;
1281 1282 1283

	free_page((unsigned long)page);
	return 0;
L
Linus Torvalds 已提交
1284 1285
out:
	free_page((unsigned long)page);
1286

L
Linus Torvalds 已提交
1287
	if (names) {
J
Jesper Juhl 已提交
1288 1289
		for (i = 0; i < num; i++)
			kfree(names[i]);
L
Linus Torvalds 已提交
1290 1291
		kfree(names);
	}
1292
	kfree(values);
1293
	sel_remove_entries(dir);
1294 1295

	return ret;
L
Linus Torvalds 已提交
1296 1297 1298 1299
}

#define NULL_FILE_NAME "null"

1300
struct path selinux_null;
L
Linus Torvalds 已提交
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311

static ssize_t sel_read_avc_cache_threshold(struct file *filp, char __user *buf,
					    size_t count, loff_t *ppos)
{
	char tmpbuf[TMPBUFLEN];
	ssize_t length;

	length = scnprintf(tmpbuf, TMPBUFLEN, "%u", avc_cache_threshold);
	return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
}

1312 1313
static ssize_t sel_write_avc_cache_threshold(struct file *file,
					     const char __user *buf,
L
Linus Torvalds 已提交
1314 1315 1316
					     size_t count, loff_t *ppos)

{
1317
	char *page = NULL;
L
Linus Torvalds 已提交
1318 1319 1320
	ssize_t ret;
	int new_value;

1321 1322
	ret = task_has_security(current, SECURITY__SETSECPARAM);
	if (ret)
L
Linus Torvalds 已提交
1323 1324
		goto out;

1325 1326
	ret = -ENOMEM;
	if (count >= PAGE_SIZE)
L
Linus Torvalds 已提交
1327 1328
		goto out;

1329 1330 1331 1332 1333 1334
	/* No partial writes. */
	ret = -EINVAL;
	if (*ppos != 0)
		goto out;

	ret = -ENOMEM;
1335
	page = (char *)get_zeroed_page(GFP_KERNEL);
1336
	if (!page)
L
Linus Torvalds 已提交
1337 1338
		goto out;

1339 1340 1341
	ret = -EFAULT;
	if (copy_from_user(page, buf, count))
		goto out;
L
Linus Torvalds 已提交
1342

1343 1344
	ret = -EINVAL;
	if (sscanf(page, "%u", &new_value) != 1)
L
Linus Torvalds 已提交
1345 1346
		goto out;

1347 1348
	avc_cache_threshold = new_value;

L
Linus Torvalds 已提交
1349 1350
	ret = count;
out:
1351
	free_page((unsigned long)page);
L
Linus Torvalds 已提交
1352 1353 1354 1355 1356 1357 1358
	return ret;
}

static ssize_t sel_read_avc_hash_stats(struct file *filp, char __user *buf,
				       size_t count, loff_t *ppos)
{
	char *page;
1359
	ssize_t length;
L
Linus Torvalds 已提交
1360 1361

	page = (char *)__get_free_page(GFP_KERNEL);
1362 1363 1364 1365 1366 1367
	if (!page)
		return -ENOMEM;

	length = avc_get_hash_stats(page);
	if (length >= 0)
		length = simple_read_from_buffer(buf, count, ppos, page, length);
L
Linus Torvalds 已提交
1368
	free_page((unsigned long)page);
1369 1370

	return length;
L
Linus Torvalds 已提交
1371 1372
}

1373
static const struct file_operations sel_avc_cache_threshold_ops = {
L
Linus Torvalds 已提交
1374 1375
	.read		= sel_read_avc_cache_threshold,
	.write		= sel_write_avc_cache_threshold,
A
Arnd Bergmann 已提交
1376
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
1377 1378
};

1379
static const struct file_operations sel_avc_hash_stats_ops = {
L
Linus Torvalds 已提交
1380
	.read		= sel_read_avc_hash_stats,
A
Arnd Bergmann 已提交
1381
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
1382 1383 1384 1385 1386 1387 1388
};

#ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
static struct avc_cache_stats *sel_avc_get_stat_idx(loff_t *idx)
{
	int cpu;

1389
	for (cpu = *idx; cpu < nr_cpu_ids; ++cpu) {
L
Linus Torvalds 已提交
1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419
		if (!cpu_possible(cpu))
			continue;
		*idx = cpu + 1;
		return &per_cpu(avc_cache_stats, cpu);
	}
	return NULL;
}

static void *sel_avc_stats_seq_start(struct seq_file *seq, loff_t *pos)
{
	loff_t n = *pos - 1;

	if (*pos == 0)
		return SEQ_START_TOKEN;

	return sel_avc_get_stat_idx(&n);
}

static void *sel_avc_stats_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	return sel_avc_get_stat_idx(pos);
}

static int sel_avc_stats_seq_show(struct seq_file *seq, void *v)
{
	struct avc_cache_stats *st = v;

	if (v == SEQ_START_TOKEN)
		seq_printf(seq, "lookups hits misses allocations reclaims "
			   "frees\n");
1420 1421 1422 1423 1424 1425
	else {
		unsigned int lookups = st->lookups;
		unsigned int misses = st->misses;
		unsigned int hits = lookups - misses;
		seq_printf(seq, "%u %u %u %u %u %u\n", lookups,
			   hits, misses, st->allocations,
L
Linus Torvalds 已提交
1426
			   st->reclaims, st->frees);
1427
	}
L
Linus Torvalds 已提交
1428 1429 1430 1431 1432 1433
	return 0;
}

static void sel_avc_stats_seq_stop(struct seq_file *seq, void *v)
{ }

1434
static const struct seq_operations sel_avc_cache_stats_seq_ops = {
L
Linus Torvalds 已提交
1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445
	.start		= sel_avc_stats_seq_start,
	.next		= sel_avc_stats_seq_next,
	.show		= sel_avc_stats_seq_show,
	.stop		= sel_avc_stats_seq_stop,
};

static int sel_open_avc_cache_stats(struct inode *inode, struct file *file)
{
	return seq_open(file, &sel_avc_cache_stats_seq_ops);
}

1446
static const struct file_operations sel_avc_cache_stats_ops = {
L
Linus Torvalds 已提交
1447 1448 1449 1450 1451 1452 1453 1454 1455
	.open		= sel_open_avc_cache_stats,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
};
#endif

static int sel_make_avc_files(struct dentry *dir)
{
1456
	int i;
L
Linus Torvalds 已提交
1457 1458 1459 1460 1461 1462 1463 1464 1465
	static struct tree_descr files[] = {
		{ "cache_threshold",
		  &sel_avc_cache_threshold_ops, S_IRUGO|S_IWUSR },
		{ "hash_stats", &sel_avc_hash_stats_ops, S_IRUGO },
#ifdef CONFIG_SECURITY_SELINUX_AVC_STATS
		{ "cache_stats", &sel_avc_cache_stats_ops, S_IRUGO },
#endif
	};

1466
	for (i = 0; i < ARRAY_SIZE(files); i++) {
L
Linus Torvalds 已提交
1467 1468 1469 1470
		struct inode *inode;
		struct dentry *dentry;

		dentry = d_alloc_name(dir, files[i].name);
1471 1472
		if (!dentry)
			return -ENOMEM;
L
Linus Torvalds 已提交
1473 1474

		inode = sel_make_inode(dir->d_sb, S_IFREG|files[i].mode);
1475 1476 1477
		if (!inode)
			return -ENOMEM;

L
Linus Torvalds 已提交
1478
		inode->i_fop = files[i].ops;
1479
		inode->i_ino = ++sel_last_ino;
L
Linus Torvalds 已提交
1480 1481
		d_add(dentry, inode);
	}
1482 1483

	return 0;
L
Linus Torvalds 已提交
1484 1485
}

1486
static ssize_t sel_read_initcon(struct file *file, char __user *buf,
1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
				size_t count, loff_t *ppos)
{
	struct inode *inode;
	char *con;
	u32 sid, len;
	ssize_t ret;

	inode = file->f_path.dentry->d_inode;
	sid = inode->i_ino&SEL_INO_MASK;
	ret = security_sid_to_context(sid, &con, &len);
1497
	if (ret)
1498 1499 1500 1501 1502 1503 1504 1505 1506
		return ret;

	ret = simple_read_from_buffer(buf, count, ppos, con, len);
	kfree(con);
	return ret;
}

static const struct file_operations sel_initcon_ops = {
	.read		= sel_read_initcon,
A
Arnd Bergmann 已提交
1507
	.llseek		= generic_file_llseek,
1508 1509 1510 1511
};

static int sel_make_initcon_files(struct dentry *dir)
{
1512
	int i;
1513 1514 1515 1516 1517

	for (i = 1; i <= SECINITSID_NUM; i++) {
		struct inode *inode;
		struct dentry *dentry;
		dentry = d_alloc_name(dir, security_get_initial_sid_context(i));
1518 1519
		if (!dentry)
			return -ENOMEM;
1520 1521

		inode = sel_make_inode(dir->d_sb, S_IFREG|S_IRUGO);
1522 1523 1524
		if (!inode)
			return -ENOMEM;

1525 1526 1527 1528
		inode->i_fop = &sel_initcon_ops;
		inode->i_ino = i|SEL_INITCON_INO_OFFSET;
		d_add(dentry, inode);
	}
1529 1530

	return 0;
1531 1532
}

1533 1534 1535 1536 1537 1538 1539
static inline unsigned long sel_class_to_ino(u16 class)
{
	return (class * (SEL_VEC_MAX + 1)) | SEL_CLASS_INO_OFFSET;
}

static inline u16 sel_ino_to_class(unsigned long ino)
{
1540
	return (ino & SEL_INO_MASK) / (SEL_VEC_MAX + 1);
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
}

static inline unsigned long sel_perm_to_ino(u16 class, u32 perm)
{
	return (class * (SEL_VEC_MAX + 1) + perm) | SEL_CLASS_INO_OFFSET;
}

static inline u32 sel_ino_to_perm(unsigned long ino)
{
	return (ino & SEL_INO_MASK) % (SEL_VEC_MAX + 1);
}

1553
static ssize_t sel_read_class(struct file *file, char __user *buf,
1554 1555 1556
				size_t count, loff_t *ppos)
{
	unsigned long ino = file->f_path.dentry->d_inode->i_ino;
A
Al Viro 已提交
1557 1558 1559
	char res[TMPBUFLEN];
	ssize_t len = snprintf(res, sizeof(res), "%d", sel_ino_to_class(ino));
	return simple_read_from_buffer(buf, count, ppos, res, len);
1560 1561 1562 1563
}

static const struct file_operations sel_class_ops = {
	.read		= sel_read_class,
A
Arnd Bergmann 已提交
1564
	.llseek		= generic_file_llseek,
1565 1566
};

1567
static ssize_t sel_read_perm(struct file *file, char __user *buf,
1568 1569 1570
				size_t count, loff_t *ppos)
{
	unsigned long ino = file->f_path.dentry->d_inode->i_ino;
A
Al Viro 已提交
1571 1572 1573
	char res[TMPBUFLEN];
	ssize_t len = snprintf(res, sizeof(res), "%d", sel_ino_to_perm(ino));
	return simple_read_from_buffer(buf, count, ppos, res, len);
1574 1575 1576 1577
}

static const struct file_operations sel_perm_ops = {
	.read		= sel_read_perm,
A
Arnd Bergmann 已提交
1578
	.llseek		= generic_file_llseek,
1579 1580
};

1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
static ssize_t sel_read_policycap(struct file *file, char __user *buf,
				  size_t count, loff_t *ppos)
{
	int value;
	char tmpbuf[TMPBUFLEN];
	ssize_t length;
	unsigned long i_ino = file->f_path.dentry->d_inode->i_ino;

	value = security_policycap_supported(i_ino & SEL_INO_MASK);
	length = scnprintf(tmpbuf, TMPBUFLEN, "%d", value);

	return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
}

static const struct file_operations sel_policycap_ops = {
	.read		= sel_read_policycap,
A
Arnd Bergmann 已提交
1597
	.llseek		= generic_file_llseek,
1598 1599
};

1600 1601 1602
static int sel_make_perm_files(char *objclass, int classvalue,
				struct dentry *dir)
{
1603
	int i, rc, nperms;
1604 1605 1606 1607
	char **perms;

	rc = security_get_permissions(objclass, &perms, &nperms);
	if (rc)
1608
		return rc;
1609 1610 1611 1612 1613

	for (i = 0; i < nperms; i++) {
		struct inode *inode;
		struct dentry *dentry;

1614
		rc = -ENOMEM;
1615
		dentry = d_alloc_name(dir, perms[i]);
1616 1617
		if (!dentry)
			goto out;
1618

1619
		rc = -ENOMEM;
1620
		inode = sel_make_inode(dir->d_sb, S_IFREG|S_IRUGO);
1621 1622 1623
		if (!inode)
			goto out;

1624 1625
		inode->i_fop = &sel_perm_ops;
		/* i+1 since perm values are 1-indexed */
1626
		inode->i_ino = sel_perm_to_ino(classvalue, i + 1);
1627 1628
		d_add(dentry, inode);
	}
1629 1630
	rc = 0;
out:
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
	for (i = 0; i < nperms; i++)
		kfree(perms[i]);
	kfree(perms);
	return rc;
}

static int sel_make_class_dir_entries(char *classname, int index,
					struct dentry *dir)
{
	struct dentry *dentry = NULL;
	struct inode *inode = NULL;
	int rc;

	dentry = d_alloc_name(dir, "index");
1645 1646
	if (!dentry)
		return -ENOMEM;
1647 1648

	inode = sel_make_inode(dir->d_sb, S_IFREG|S_IRUGO);
1649 1650
	if (!inode)
		return -ENOMEM;
1651 1652 1653 1654 1655

	inode->i_fop = &sel_class_ops;
	inode->i_ino = sel_class_to_ino(index);
	d_add(dentry, inode);

1656 1657 1658
	dentry = sel_make_dir(dir, "perms", &last_class_ino);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);
1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690

	rc = sel_make_perm_files(classname, index, dentry);

	return rc;
}

static void sel_remove_classes(void)
{
	struct list_head *class_node;

	list_for_each(class_node, &class_dir->d_subdirs) {
		struct dentry *class_subdir = list_entry(class_node,
					struct dentry, d_u.d_child);
		struct list_head *class_subdir_node;

		list_for_each(class_subdir_node, &class_subdir->d_subdirs) {
			struct dentry *d = list_entry(class_subdir_node,
						struct dentry, d_u.d_child);

			if (d->d_inode)
				if (d->d_inode->i_mode & S_IFDIR)
					sel_remove_entries(d);
		}

		sel_remove_entries(class_subdir);
	}

	sel_remove_entries(class_dir);
}

static int sel_make_classes(void)
{
1691
	int rc, nclasses, i;
1692 1693 1694 1695 1696 1697
	char **classes;

	/* delete any existing entries */
	sel_remove_classes();

	rc = security_get_classes(&classes, &nclasses);
1698 1699
	if (rc)
		return rc;
1700 1701

	/* +2 since classes are 1-indexed */
1702
	last_class_ino = sel_class_to_ino(nclasses + 2);
1703 1704 1705 1706

	for (i = 0; i < nclasses; i++) {
		struct dentry *class_name_dir;

1707
		class_name_dir = sel_make_dir(class_dir, classes[i],
1708
				&last_class_ino);
1709 1710
		if (IS_ERR(class_name_dir)) {
			rc = PTR_ERR(class_name_dir);
1711
			goto out;
1712
		}
1713 1714

		/* i+1 since class values are 1-indexed */
1715
		rc = sel_make_class_dir_entries(classes[i], i + 1,
1716 1717
				class_name_dir);
		if (rc)
1718
			goto out;
1719
	}
1720 1721
	rc = 0;
out:
1722 1723 1724 1725 1726 1727
	for (i = 0; i < nclasses; i++)
		kfree(classes[i]);
	kfree(classes);
	return rc;
}

1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757
static int sel_make_policycap(void)
{
	unsigned int iter;
	struct dentry *dentry = NULL;
	struct inode *inode = NULL;

	sel_remove_entries(policycap_dir);

	for (iter = 0; iter <= POLICYDB_CAPABILITY_MAX; iter++) {
		if (iter < ARRAY_SIZE(policycap_names))
			dentry = d_alloc_name(policycap_dir,
					      policycap_names[iter]);
		else
			dentry = d_alloc_name(policycap_dir, "unknown");

		if (dentry == NULL)
			return -ENOMEM;

		inode = sel_make_inode(policycap_dir->d_sb, S_IFREG | S_IRUGO);
		if (inode == NULL)
			return -ENOMEM;

		inode->i_fop = &sel_policycap_ops;
		inode->i_ino = iter | SEL_POLICYCAP_INO_OFFSET;
		d_add(dentry, inode);
	}

	return 0;
}

1758
static struct dentry *sel_make_dir(struct dentry *dir, const char *name,
1759
			unsigned long *ino)
L
Linus Torvalds 已提交
1760
{
1761
	struct dentry *dentry = d_alloc_name(dir, name);
L
Linus Torvalds 已提交
1762 1763
	struct inode *inode;

1764 1765 1766 1767 1768 1769 1770 1771
	if (!dentry)
		return ERR_PTR(-ENOMEM);

	inode = sel_make_inode(dir->d_sb, S_IFDIR | S_IRUGO | S_IXUGO);
	if (!inode) {
		dput(dentry);
		return ERR_PTR(-ENOMEM);
	}
1772

L
Linus Torvalds 已提交
1773 1774
	inode->i_op = &simple_dir_inode_operations;
	inode->i_fop = &simple_dir_operations;
1775
	inode->i_ino = ++(*ino);
1776
	/* directory inodes start off with i_nlink == 2 (for "." entry) */
1777
	inc_nlink(inode);
L
Linus Torvalds 已提交
1778
	d_add(dentry, inode);
1779
	/* bump link count on parent directory, too */
1780
	inc_nlink(dir->d_inode);
1781

1782
	return dentry;
L
Linus Torvalds 已提交
1783 1784
}

1785
static int sel_fill_super(struct super_block *sb, void *data, int silent)
L
Linus Torvalds 已提交
1786 1787 1788
{
	int ret;
	struct dentry *dentry;
1789
	struct inode *inode;
L
Linus Torvalds 已提交
1790 1791 1792 1793 1794
	struct inode_security_struct *isec;

	static struct tree_descr selinux_files[] = {
		[SEL_LOAD] = {"load", &sel_load_ops, S_IRUSR|S_IWUSR},
		[SEL_ENFORCE] = {"enforce", &sel_enforce_ops, S_IRUGO|S_IWUSR},
1795
		[SEL_CONTEXT] = {"context", &transaction_ops, S_IRUGO|S_IWUGO},
L
Linus Torvalds 已提交
1796 1797 1798 1799 1800 1801 1802 1803 1804 1805
		[SEL_ACCESS] = {"access", &transaction_ops, S_IRUGO|S_IWUGO},
		[SEL_CREATE] = {"create", &transaction_ops, S_IRUGO|S_IWUGO},
		[SEL_RELABEL] = {"relabel", &transaction_ops, S_IRUGO|S_IWUGO},
		[SEL_USER] = {"user", &transaction_ops, S_IRUGO|S_IWUGO},
		[SEL_POLICYVERS] = {"policyvers", &sel_policyvers_ops, S_IRUGO},
		[SEL_COMMIT_BOOLS] = {"commit_pending_bools", &sel_commit_bools_ops, S_IWUSR},
		[SEL_MLS] = {"mls", &sel_mls_ops, S_IRUGO},
		[SEL_DISABLE] = {"disable", &sel_disable_ops, S_IWUSR},
		[SEL_MEMBER] = {"member", &transaction_ops, S_IRUGO|S_IWUGO},
		[SEL_CHECKREQPROT] = {"checkreqprot", &sel_checkreqprot_ops, S_IRUGO|S_IWUSR},
1806 1807
		[SEL_REJECT_UNKNOWN] = {"reject_unknown", &sel_handle_unknown_ops, S_IRUGO},
		[SEL_DENY_UNKNOWN] = {"deny_unknown", &sel_handle_unknown_ops, S_IRUGO},
1808
		[SEL_STATUS] = {"status", &sel_handle_status_ops, S_IRUGO},
1809
		[SEL_POLICY] = {"policy", &sel_policy_ops, S_IRUGO},
L
Linus Torvalds 已提交
1810 1811 1812 1813
		/* last one */ {""}
	};
	ret = simple_fill_super(sb, SELINUX_MAGIC, selinux_files);
	if (ret)
1814
		goto err;
L
Linus Torvalds 已提交
1815

1816 1817 1818 1819
	bool_dir = sel_make_dir(sb->s_root, BOOL_DIR_NAME, &sel_last_ino);
	if (IS_ERR(bool_dir)) {
		ret = PTR_ERR(bool_dir);
		bool_dir = NULL;
1820
		goto err;
1821
	}
L
Linus Torvalds 已提交
1822

1823
	ret = -ENOMEM;
L
Linus Torvalds 已提交
1824
	dentry = d_alloc_name(sb->s_root, NULL_FILE_NAME);
1825
	if (!dentry)
1826
		goto err;
L
Linus Torvalds 已提交
1827

1828
	ret = -ENOMEM;
L
Linus Torvalds 已提交
1829
	inode = sel_make_inode(sb, S_IFCHR | S_IRUGO | S_IWUGO);
1830
	if (!inode)
1831
		goto err;
1832

1833
	inode->i_ino = ++sel_last_ino;
1834
	isec = (struct inode_security_struct *)inode->i_security;
L
Linus Torvalds 已提交
1835 1836 1837 1838 1839 1840
	isec->sid = SECINITSID_DEVNULL;
	isec->sclass = SECCLASS_CHR_FILE;
	isec->initialized = 1;

	init_special_inode(inode, S_IFCHR | S_IRUGO | S_IWUGO, MKDEV(MEM_MAJOR, 3));
	d_add(dentry, inode);
1841
	selinux_null.dentry = dentry;
L
Linus Torvalds 已提交
1842

1843 1844 1845
	dentry = sel_make_dir(sb->s_root, "avc", &sel_last_ino);
	if (IS_ERR(dentry)) {
		ret = PTR_ERR(dentry);
1846
		goto err;
1847
	}
L
Linus Torvalds 已提交
1848 1849 1850

	ret = sel_make_avc_files(dentry);
	if (ret)
1851
		goto err;
1852

1853 1854 1855
	dentry = sel_make_dir(sb->s_root, "initial_contexts", &sel_last_ino);
	if (IS_ERR(dentry)) {
		ret = PTR_ERR(dentry);
1856
		goto err;
1857
	}
1858 1859 1860 1861 1862

	ret = sel_make_initcon_files(dentry);
	if (ret)
		goto err;

1863 1864 1865 1866
	class_dir = sel_make_dir(sb->s_root, "class", &sel_last_ino);
	if (IS_ERR(class_dir)) {
		ret = PTR_ERR(class_dir);
		class_dir = NULL;
1867
		goto err;
1868
	}
1869

1870 1871 1872 1873
	policycap_dir = sel_make_dir(sb->s_root, "policy_capabilities", &sel_last_ino);
	if (IS_ERR(policycap_dir)) {
		ret = PTR_ERR(policycap_dir);
		policycap_dir = NULL;
1874
		goto err;
1875
	}
1876
	return 0;
1877
err:
E
Eric Paris 已提交
1878 1879
	printk(KERN_ERR "SELinux: %s:  failed while creating inodes\n",
		__func__);
1880
	return ret;
L
Linus Torvalds 已提交
1881 1882
}

A
Al Viro 已提交
1883 1884
static struct dentry *sel_mount(struct file_system_type *fs_type,
		      int flags, const char *dev_name, void *data)
L
Linus Torvalds 已提交
1885
{
A
Al Viro 已提交
1886
	return mount_single(fs_type, flags, data, sel_fill_super);
L
Linus Torvalds 已提交
1887 1888 1889 1890
}

static struct file_system_type sel_fs_type = {
	.name		= "selinuxfs",
A
Al Viro 已提交
1891
	.mount		= sel_mount,
L
Linus Torvalds 已提交
1892 1893 1894 1895
	.kill_sb	= kill_litter_super,
};

struct vfsmount *selinuxfs_mount;
1896
static struct kobject *selinuxfs_kobj;
L
Linus Torvalds 已提交
1897 1898 1899 1900 1901 1902 1903

static int __init init_sel_fs(void)
{
	int err;

	if (!selinux_enabled)
		return 0;
1904 1905 1906 1907 1908

	selinuxfs_kobj = kobject_create_and_add("selinux", fs_kobj);
	if (!selinuxfs_kobj)
		return -ENOMEM;

L
Linus Torvalds 已提交
1909
	err = register_filesystem(&sel_fs_type);
1910 1911
	if (err) {
		kobject_put(selinuxfs_kobj);
1912
		return err;
1913
	}
1914

1915
	selinux_null.mnt = selinuxfs_mount = kern_mount(&sel_fs_type);
1916 1917 1918 1919
	if (IS_ERR(selinuxfs_mount)) {
		printk(KERN_ERR "selinuxfs:  could not mount!\n");
		err = PTR_ERR(selinuxfs_mount);
		selinuxfs_mount = NULL;
L
Linus Torvalds 已提交
1920
	}
1921

L
Linus Torvalds 已提交
1922 1923 1924 1925 1926 1927 1928 1929
	return err;
}

__initcall(init_sel_fs);

#ifdef CONFIG_SECURITY_SELINUX_DISABLE
void exit_sel_fs(void)
{
1930
	kobject_put(selinuxfs_kobj);
1931
	kern_unmount(selinuxfs_mount);
L
Linus Torvalds 已提交
1932 1933 1934
	unregister_filesystem(&sel_fs_type);
}
#endif