selinuxfs.c 41.7 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
	"network_peer_controls",
47 48 49
	"open_perms",
	"redhat1",
	"always_check_network"
50 51
};

L
Linus Torvalds 已提交
52 53 54 55
unsigned int selinux_checkreqprot = CONFIG_SECURITY_SELINUX_CHECKREQPROT_VALUE;

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

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

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

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

75 76
static char policy_opened;

77
/* global data for policy capabilities */
78
static struct dentry *policycap_dir;
79

L
Linus Torvalds 已提交
80 81 82 83
/* Check whether a task is allowed to use a security operation. */
static int task_has_security(struct task_struct *tsk,
			     u32 perms)
{
84 85 86 87 88 89 90 91
	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 已提交
92 93 94
	if (!tsec)
		return -EACCES;

95
	return avc_has_perm(sid, SECINITSID_SECURITY,
L
Linus Torvalds 已提交
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
			    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 */
114
	SEL_COMPAT_NET,	/* whether to use old compat network packet controls */
115 116
	SEL_REJECT_UNKNOWN, /* export unknown reject handling to userspace */
	SEL_DENY_UNKNOWN, /* export unknown deny handling to userspace */
117
	SEL_STATUS,	/* export current status using mmap() */
118
	SEL_POLICY,	/* allow userspace to read the in kernel policy */
119
	SEL_INO_NEXT,	/* The next inode number to use */
L
Linus Torvalds 已提交
120 121
};

122 123
static unsigned long sel_last_ino = SEL_INO_NEXT - 1;

124 125 126 127 128
#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
129

L
Linus Torvalds 已提交
130 131 132 133 134 135 136 137 138 139 140 141
#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
142
static ssize_t sel_write_enforce(struct file *file, const char __user *buf,
L
Linus Torvalds 已提交
143 144 145
				 size_t count, loff_t *ppos)

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

150
	length = -ENOMEM;
151
	if (count >= PAGE_SIZE)
152 153 154
		goto out;

	/* No partial writes. */
155
	length = -EINVAL;
156 157 158 159
	if (*ppos != 0)
		goto out;

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

L
Linus Torvalds 已提交
164 165 166 167 168 169 170 171 172 173 174 175
	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 已提交
176
		audit_log(current->audit_context, GFP_KERNEL, AUDIT_MAC_STATUS,
177 178
			"enforcing=%d old_enforcing=%d auid=%u ses=%u",
			new_value, selinux_enforcing,
179
			from_kuid(&init_user_ns, audit_get_loginuid(current)),
180
			audit_get_sessionid(current));
L
Linus Torvalds 已提交
181 182 183 184
		selinux_enforcing = new_value;
		if (selinux_enforcing)
			avc_ss_reset(0);
		selnl_notify_setenforce(selinux_enforcing);
185
		selinux_status_update_setenforce(selinux_enforcing);
L
Linus Torvalds 已提交
186 187 188 189 190 191 192 193 194 195
	}
	length = count;
out:
	free_page((unsigned long) page);
	return length;
}
#else
#define sel_write_enforce NULL
#endif

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

202 203 204 205 206
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;
A
Al Viro 已提交
207
	ino_t ino = file_inode(filp)->i_ino;
208 209 210 211 212 213 214 215 216
	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 已提交
217
	.llseek		= generic_file_llseek,
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 271 272
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 已提交
273
#ifdef CONFIG_SECURITY_SELINUX_DISABLE
274
static ssize_t sel_write_disable(struct file *file, const char __user *buf,
L
Linus Torvalds 已提交
275 276 277
				 size_t count, loff_t *ppos)

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

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

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

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

L
Linus Torvalds 已提交
296 297 298 299 300 301 302 303 304 305
	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();
306
		if (length)
L
Linus Torvalds 已提交
307
			goto out;
S
Steve Grubb 已提交
308
		audit_log(current->audit_context, GFP_KERNEL, AUDIT_MAC_STATUS,
309
			"selinux=0 auid=%u ses=%u",
310
			from_kuid(&init_user_ns, audit_get_loginuid(current)),
311
			audit_get_sessionid(current));
L
Linus Torvalds 已提交
312 313 314 315 316 317 318 319 320 321 322
	}

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

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

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

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

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

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

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

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

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

363
static const struct file_operations sel_mls_ops = {
L
Linus Torvalds 已提交
364
	.read		= sel_read_mls,
A
Arnd Bergmann 已提交
365
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
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 451 452
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;
}

453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
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;
}

475
static const struct vm_operations_struct sel_mmap_policy_ops = {
476 477 478 479
	.fault = sel_mmap_policy_fault,
	.page_mkwrite = sel_mmap_policy_fault,
};

480
static int sel_mmap_policy(struct file *filp, struct vm_area_struct *vma)
481 482 483 484 485 486 487 488 489
{
	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;
	}

490
	vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
491 492 493 494 495
	vma->vm_ops = &sel_mmap_policy_ops;

	return 0;
}

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

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

{
	ssize_t length;
	void *data = NULL;

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

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

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

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

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

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

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

539 540
	length = sel_make_bools();
	if (length)
541 542
		goto out1;

543 544
	length = sel_make_classes();
	if (length)
545 546
		goto out1;

547 548 549 550 551
	length = sel_make_policycap();
	if (length)
		goto out1;

	length = count;
552 553

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

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

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

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

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

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

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

594 595
	memcpy(buf, canon, len);
	length = len;
L
Linus Torvalds 已提交
596
out:
597
	kfree(canon);
L
Linus Torvalds 已提交
598 599 600 601 602 603 604 605 606 607 608 609 610
	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);
}

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

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

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

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

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

L
Linus Torvalds 已提交
636 637 638 639 640 641 642 643 644 645 646 647 648 649
	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;
}
650
static const struct file_operations sel_checkreqprot_ops = {
L
Linus Torvalds 已提交
651 652
	.read		= sel_read_checkreqprot,
	.write		= sel_write_checkreqprot,
A
Arnd Bergmann 已提交
653
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
654 655 656 657 658
};

/*
 * Remaining nodes use transaction based IO methods like nfsd/nfsctl.c
 */
659 660 661 662 663
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 已提交
664 665 666 667 668 669 670

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,
671
	[SEL_CONTEXT] = sel_write_context,
L
Linus Torvalds 已提交
672 673 674 675
};

static ssize_t selinux_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
{
A
Al Viro 已提交
676
	ino_t ino = file_inode(file)->i_ino;
L
Linus Torvalds 已提交
677 678 679
	char *data;
	ssize_t rv;

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

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

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

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

/*
 * 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.
 */

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

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

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

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

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

734
	length = security_context_str_to_sid(scon, &ssid, GFP_KERNEL);
735 736 737
	if (length)
		goto out;

738
	length = security_context_str_to_sid(tcon, &tsid, GFP_KERNEL);
739 740
	if (length)
		goto out;
L
Linus Torvalds 已提交
741

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

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

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

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

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

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

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

L
Linus Torvalds 已提交
785
	length = -EINVAL;
786 787
	nargs = sscanf(buf, "%s %s %hu %s", scon, tcon, &tclass, namebuf);
	if (nargs < 3 || nargs > 4)
788
		goto out;
789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
	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 == '%') {
806 807
				c1 = hex_to_bin(*r++);
				if (c1 < 0)
808
					goto out;
809 810
				c2 = hex_to_bin(*r++);
				if (c2 < 0)
811 812 813 814 815 816
					goto out;
				c1 = (c1 << 4) | c2;
			}
			*w++ = c1;
		} while (c1 != '\0');

817
		objname = namebuf;
818
	}
L
Linus Torvalds 已提交
819

820
	length = security_context_str_to_sid(scon, &ssid, GFP_KERNEL);
821 822 823
	if (length)
		goto out;

824
	length = security_context_str_to_sid(tcon, &tsid, GFP_KERNEL);
825 826
	if (length)
		goto out;
L
Linus Torvalds 已提交
827

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

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

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

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

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

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

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

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

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

881
	length = security_context_str_to_sid(scon, &ssid, GFP_KERNEL);
882 883 884
	if (length)
		goto out;

885
	length = security_context_str_to_sid(tcon, &tsid, GFP_KERNEL);
886 887
	if (length)
		goto out;
L
Linus Torvalds 已提交
888 889

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

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

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

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

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

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

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

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

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

937
	length = security_context_str_to_sid(con, &sid, GFP_KERNEL);
938 939
	if (length)
		goto out;
L
Linus Torvalds 已提交
940 941

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

	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;
951
			goto out;
L
Linus Torvalds 已提交
952 953 954 955
		}
		if ((length + len) >= SIMPLE_TRANSACTION_LIMIT) {
			kfree(newcon);
			length = -ERANGE;
956
			goto out;
L
Linus Torvalds 已提交
957 958 959 960 961 962
		}
		memcpy(ptr, newcon, len);
		kfree(newcon);
		ptr += len;
		length += len;
	}
963
out:
L
Linus Torvalds 已提交
964 965 966 967 968 969
	kfree(sids);
	kfree(user);
	kfree(con);
	return length;
}

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

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

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

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

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

997
	length = security_context_str_to_sid(scon, &ssid, GFP_KERNEL);
998 999 1000
	if (length)
		goto out;

1001
	length = security_context_str_to_sid(tcon, &tsid, GFP_KERNEL);
1002 1003
	if (length)
		goto out;
L
Linus Torvalds 已提交
1004 1005

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

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

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

	memcpy(buf, newcon, len);
	length = len;
1022
out:
L
Linus Torvalds 已提交
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
	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;
A
Al Viro 已提交
1047
	unsigned index = file_inode(filep)->i_ino & SEL_INO_MASK;
S
Stephen Smalley 已提交
1048
	const char *name = filep->f_path.dentry->d_name.name;
L
Linus Torvalds 已提交
1049

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

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

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

S
Stephen Smalley 已提交
1061
	cur_enforcing = security_get_bool_value(index);
L
Linus Torvalds 已提交
1062 1063 1064 1065 1066
	if (cur_enforcing < 0) {
		ret = cur_enforcing;
		goto out;
	}
	length = scnprintf(page, PAGE_SIZE, "%d %d", cur_enforcing,
S
Stephen Smalley 已提交
1067
			  bool_pending_values[index]);
1068
	ret = simple_read_from_buffer(buf, count, ppos, page, length);
L
Linus Torvalds 已提交
1069
out:
I
Ingo Molnar 已提交
1070
	mutex_unlock(&sel_mutex);
1071
	free_page((unsigned long)page);
L
Linus Torvalds 已提交
1072 1073 1074 1075 1076 1077 1078
	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 已提交
1079
	ssize_t length;
L
Linus Torvalds 已提交
1080
	int new_value;
A
Al Viro 已提交
1081
	unsigned index = file_inode(filep)->i_ino & SEL_INO_MASK;
S
Stephen Smalley 已提交
1082
	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 1191
	d_genocide(de);
	shrink_dcache_parent(de);
L
Linus Torvalds 已提交
1192 1193 1194 1195 1196 1197
}

#define BOOL_DIR_NAME "booleans"

static int sel_make_bools(void)
{
1198
	int i, ret;
L
Linus Torvalds 已提交
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
	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 */
1210 1211
	for (i = 0; i < bool_num; i++)
		kfree(bool_pending_names[i]);
S
Stephen Smalley 已提交
1212
	kfree(bool_pending_names);
J
Jesper Juhl 已提交
1213
	kfree(bool_pending_values);
1214
	bool_num = 0;
S
Stephen Smalley 已提交
1215
	bool_pending_names = NULL;
1216
	bool_pending_values = NULL;
L
Linus Torvalds 已提交
1217

1218
	sel_remove_entries(dir);
L
Linus Torvalds 已提交
1219

1220
	ret = -ENOMEM;
1221 1222
	page = (char *)get_zeroed_page(GFP_KERNEL);
	if (!page)
1223
		goto out;
L
Linus Torvalds 已提交
1224 1225

	ret = security_get_bools(&num, &names, &values);
1226
	if (ret)
L
Linus Torvalds 已提交
1227 1228 1229
		goto out;

	for (i = 0; i < num; i++) {
1230
		ret = -ENOMEM;
L
Linus Torvalds 已提交
1231
		dentry = d_alloc_name(dir, names[i]);
1232 1233 1234 1235
		if (!dentry)
			goto out;

		ret = -ENOMEM;
L
Linus Torvalds 已提交
1236
		inode = sel_make_inode(dir->d_sb, S_IFREG | S_IRUGO | S_IWUSR);
1237 1238
		if (!inode)
			goto out;
L
Linus Torvalds 已提交
1239

1240
		ret = -ENAMETOOLONG;
A
Al Viro 已提交
1241
		len = snprintf(page, PAGE_SIZE, "/%s/%s", BOOL_DIR_NAME, names[i]);
1242 1243 1244
		if (len >= PAGE_SIZE)
			goto out;

1245 1246 1247
		isec = (struct inode_security_struct *)inode->i_security;
		ret = security_genfs_sid("selinuxfs", page, SECCLASS_FILE, &sid);
		if (ret)
1248 1249
			goto out;

L
Linus Torvalds 已提交
1250 1251 1252
		isec->sid = sid;
		isec->initialized = 1;
		inode->i_fop = &sel_bool_ops;
1253
		inode->i_ino = i|SEL_BOOL_INO_OFFSET;
L
Linus Torvalds 已提交
1254 1255 1256
		d_add(dentry, inode);
	}
	bool_num = num;
S
Stephen Smalley 已提交
1257
	bool_pending_names = names;
L
Linus Torvalds 已提交
1258
	bool_pending_values = values;
1259 1260 1261

	free_page((unsigned long)page);
	return 0;
L
Linus Torvalds 已提交
1262 1263
out:
	free_page((unsigned long)page);
1264

L
Linus Torvalds 已提交
1265
	if (names) {
J
Jesper Juhl 已提交
1266 1267
		for (i = 0; i < num; i++)
			kfree(names[i]);
L
Linus Torvalds 已提交
1268 1269
		kfree(names);
	}
1270
	kfree(values);
1271
	sel_remove_entries(dir);
1272 1273

	return ret;
L
Linus Torvalds 已提交
1274 1275 1276 1277
}

#define NULL_FILE_NAME "null"

1278
struct path selinux_null;
L
Linus Torvalds 已提交
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289

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);
}

1290 1291
static ssize_t sel_write_avc_cache_threshold(struct file *file,
					     const char __user *buf,
L
Linus Torvalds 已提交
1292 1293 1294
					     size_t count, loff_t *ppos)

{
1295
	char *page = NULL;
L
Linus Torvalds 已提交
1296 1297 1298
	ssize_t ret;
	int new_value;

1299 1300
	ret = task_has_security(current, SECURITY__SETSECPARAM);
	if (ret)
L
Linus Torvalds 已提交
1301 1302
		goto out;

1303 1304
	ret = -ENOMEM;
	if (count >= PAGE_SIZE)
L
Linus Torvalds 已提交
1305 1306
		goto out;

1307 1308 1309 1310 1311 1312
	/* No partial writes. */
	ret = -EINVAL;
	if (*ppos != 0)
		goto out;

	ret = -ENOMEM;
1313
	page = (char *)get_zeroed_page(GFP_KERNEL);
1314
	if (!page)
L
Linus Torvalds 已提交
1315 1316
		goto out;

1317 1318 1319
	ret = -EFAULT;
	if (copy_from_user(page, buf, count))
		goto out;
L
Linus Torvalds 已提交
1320

1321 1322
	ret = -EINVAL;
	if (sscanf(page, "%u", &new_value) != 1)
L
Linus Torvalds 已提交
1323 1324
		goto out;

1325 1326
	avc_cache_threshold = new_value;

L
Linus Torvalds 已提交
1327 1328
	ret = count;
out:
1329
	free_page((unsigned long)page);
L
Linus Torvalds 已提交
1330 1331 1332 1333 1334 1335 1336
	return ret;
}

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

	page = (char *)__get_free_page(GFP_KERNEL);
1340 1341 1342 1343 1344 1345
	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 已提交
1346
	free_page((unsigned long)page);
1347 1348

	return length;
L
Linus Torvalds 已提交
1349 1350
}

1351
static const struct file_operations sel_avc_cache_threshold_ops = {
L
Linus Torvalds 已提交
1352 1353
	.read		= sel_read_avc_cache_threshold,
	.write		= sel_write_avc_cache_threshold,
A
Arnd Bergmann 已提交
1354
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
1355 1356
};

1357
static const struct file_operations sel_avc_hash_stats_ops = {
L
Linus Torvalds 已提交
1358
	.read		= sel_read_avc_hash_stats,
A
Arnd Bergmann 已提交
1359
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
1360 1361 1362 1363 1364 1365 1366
};

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

1367
	for (cpu = *idx; cpu < nr_cpu_ids; ++cpu) {
L
Linus Torvalds 已提交
1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397
		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");
1398 1399 1400 1401 1402 1403
	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 已提交
1404
			   st->reclaims, st->frees);
1405
	}
L
Linus Torvalds 已提交
1406 1407 1408 1409 1410 1411
	return 0;
}

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

1412
static const struct seq_operations sel_avc_cache_stats_seq_ops = {
L
Linus Torvalds 已提交
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
	.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);
}

1424
static const struct file_operations sel_avc_cache_stats_ops = {
L
Linus Torvalds 已提交
1425 1426 1427 1428 1429 1430 1431 1432 1433
	.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)
{
1434
	int i;
L
Linus Torvalds 已提交
1435 1436 1437 1438 1439 1440 1441 1442 1443
	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
	};

1444
	for (i = 0; i < ARRAY_SIZE(files); i++) {
L
Linus Torvalds 已提交
1445 1446 1447 1448
		struct inode *inode;
		struct dentry *dentry;

		dentry = d_alloc_name(dir, files[i].name);
1449 1450
		if (!dentry)
			return -ENOMEM;
L
Linus Torvalds 已提交
1451 1452

		inode = sel_make_inode(dir->d_sb, S_IFREG|files[i].mode);
1453 1454 1455
		if (!inode)
			return -ENOMEM;

L
Linus Torvalds 已提交
1456
		inode->i_fop = files[i].ops;
1457
		inode->i_ino = ++sel_last_ino;
L
Linus Torvalds 已提交
1458 1459
		d_add(dentry, inode);
	}
1460 1461

	return 0;
L
Linus Torvalds 已提交
1462 1463
}

1464
static ssize_t sel_read_initcon(struct file *file, char __user *buf,
1465 1466 1467 1468 1469 1470
				size_t count, loff_t *ppos)
{
	char *con;
	u32 sid, len;
	ssize_t ret;

A
Al Viro 已提交
1471
	sid = file_inode(file)->i_ino&SEL_INO_MASK;
1472
	ret = security_sid_to_context(sid, &con, &len);
1473
	if (ret)
1474 1475 1476 1477 1478 1479 1480 1481 1482
		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 已提交
1483
	.llseek		= generic_file_llseek,
1484 1485 1486 1487
};

static int sel_make_initcon_files(struct dentry *dir)
{
1488
	int i;
1489 1490 1491 1492 1493

	for (i = 1; i <= SECINITSID_NUM; i++) {
		struct inode *inode;
		struct dentry *dentry;
		dentry = d_alloc_name(dir, security_get_initial_sid_context(i));
1494 1495
		if (!dentry)
			return -ENOMEM;
1496 1497

		inode = sel_make_inode(dir->d_sb, S_IFREG|S_IRUGO);
1498 1499 1500
		if (!inode)
			return -ENOMEM;

1501 1502 1503 1504
		inode->i_fop = &sel_initcon_ops;
		inode->i_ino = i|SEL_INITCON_INO_OFFSET;
		d_add(dentry, inode);
	}
1505 1506

	return 0;
1507 1508
}

1509 1510 1511 1512 1513 1514 1515
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)
{
1516
	return (ino & SEL_INO_MASK) / (SEL_VEC_MAX + 1);
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
}

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);
}

1529
static ssize_t sel_read_class(struct file *file, char __user *buf,
1530 1531
				size_t count, loff_t *ppos)
{
A
Al Viro 已提交
1532
	unsigned long ino = file_inode(file)->i_ino;
A
Al Viro 已提交
1533 1534 1535
	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);
1536 1537 1538 1539
}

static const struct file_operations sel_class_ops = {
	.read		= sel_read_class,
A
Arnd Bergmann 已提交
1540
	.llseek		= generic_file_llseek,
1541 1542
};

1543
static ssize_t sel_read_perm(struct file *file, char __user *buf,
1544 1545
				size_t count, loff_t *ppos)
{
A
Al Viro 已提交
1546
	unsigned long ino = file_inode(file)->i_ino;
A
Al Viro 已提交
1547 1548 1549
	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);
1550 1551 1552 1553
}

static const struct file_operations sel_perm_ops = {
	.read		= sel_read_perm,
A
Arnd Bergmann 已提交
1554
	.llseek		= generic_file_llseek,
1555 1556
};

1557 1558 1559 1560 1561 1562
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;
A
Al Viro 已提交
1563
	unsigned long i_ino = file_inode(file)->i_ino;
1564 1565 1566 1567 1568 1569 1570 1571 1572

	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 已提交
1573
	.llseek		= generic_file_llseek,
1574 1575
};

1576 1577 1578
static int sel_make_perm_files(char *objclass, int classvalue,
				struct dentry *dir)
{
1579
	int i, rc, nperms;
1580 1581 1582 1583
	char **perms;

	rc = security_get_permissions(objclass, &perms, &nperms);
	if (rc)
1584
		return rc;
1585 1586 1587 1588 1589

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

1590
		rc = -ENOMEM;
1591
		dentry = d_alloc_name(dir, perms[i]);
1592 1593
		if (!dentry)
			goto out;
1594

1595
		rc = -ENOMEM;
1596
		inode = sel_make_inode(dir->d_sb, S_IFREG|S_IRUGO);
1597 1598 1599
		if (!inode)
			goto out;

1600 1601
		inode->i_fop = &sel_perm_ops;
		/* i+1 since perm values are 1-indexed */
1602
		inode->i_ino = sel_perm_to_ino(classvalue, i + 1);
1603 1604
		d_add(dentry, inode);
	}
1605 1606
	rc = 0;
out:
1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620
	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");
1621 1622
	if (!dentry)
		return -ENOMEM;
1623 1624

	inode = sel_make_inode(dir->d_sb, S_IFREG|S_IRUGO);
1625 1626
	if (!inode)
		return -ENOMEM;
1627 1628 1629 1630 1631

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

1632 1633 1634
	dentry = sel_make_dir(dir, "perms", &last_class_ino);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);
1635 1636 1637 1638 1639 1640 1641 1642

	rc = sel_make_perm_files(classname, index, dentry);

	return rc;
}

static int sel_make_classes(void)
{
1643
	int rc, nclasses, i;
1644 1645 1646
	char **classes;

	/* delete any existing entries */
1647
	sel_remove_entries(class_dir);
1648 1649

	rc = security_get_classes(&classes, &nclasses);
1650 1651
	if (rc)
		return rc;
1652 1653

	/* +2 since classes are 1-indexed */
1654
	last_class_ino = sel_class_to_ino(nclasses + 2);
1655 1656 1657 1658

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

1659
		class_name_dir = sel_make_dir(class_dir, classes[i],
1660
				&last_class_ino);
1661 1662
		if (IS_ERR(class_name_dir)) {
			rc = PTR_ERR(class_name_dir);
1663
			goto out;
1664
		}
1665 1666

		/* i+1 since class values are 1-indexed */
1667
		rc = sel_make_class_dir_entries(classes[i], i + 1,
1668 1669
				class_name_dir);
		if (rc)
1670
			goto out;
1671
	}
1672 1673
	rc = 0;
out:
1674 1675 1676 1677 1678 1679
	for (i = 0; i < nclasses; i++)
		kfree(classes[i]);
	kfree(classes);
	return rc;
}

1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709
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;
}

1710
static struct dentry *sel_make_dir(struct dentry *dir, const char *name,
1711
			unsigned long *ino)
L
Linus Torvalds 已提交
1712
{
1713
	struct dentry *dentry = d_alloc_name(dir, name);
L
Linus Torvalds 已提交
1714 1715
	struct inode *inode;

1716 1717 1718 1719 1720 1721 1722 1723
	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);
	}
1724

L
Linus Torvalds 已提交
1725 1726
	inode->i_op = &simple_dir_inode_operations;
	inode->i_fop = &simple_dir_operations;
1727
	inode->i_ino = ++(*ino);
1728
	/* directory inodes start off with i_nlink == 2 (for "." entry) */
1729
	inc_nlink(inode);
L
Linus Torvalds 已提交
1730
	d_add(dentry, inode);
1731
	/* bump link count on parent directory, too */
1732
	inc_nlink(d_inode(dir));
1733

1734
	return dentry;
L
Linus Torvalds 已提交
1735 1736
}

1737
static int sel_fill_super(struct super_block *sb, void *data, int silent)
L
Linus Torvalds 已提交
1738 1739 1740
{
	int ret;
	struct dentry *dentry;
1741
	struct inode *inode;
L
Linus Torvalds 已提交
1742 1743 1744 1745 1746
	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},
1747
		[SEL_CONTEXT] = {"context", &transaction_ops, S_IRUGO|S_IWUGO},
L
Linus Torvalds 已提交
1748 1749 1750 1751 1752 1753 1754 1755 1756 1757
		[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},
1758 1759
		[SEL_REJECT_UNKNOWN] = {"reject_unknown", &sel_handle_unknown_ops, S_IRUGO},
		[SEL_DENY_UNKNOWN] = {"deny_unknown", &sel_handle_unknown_ops, S_IRUGO},
1760
		[SEL_STATUS] = {"status", &sel_handle_status_ops, S_IRUGO},
1761
		[SEL_POLICY] = {"policy", &sel_policy_ops, S_IRUGO},
L
Linus Torvalds 已提交
1762 1763 1764 1765
		/* last one */ {""}
	};
	ret = simple_fill_super(sb, SELINUX_MAGIC, selinux_files);
	if (ret)
1766
		goto err;
L
Linus Torvalds 已提交
1767

1768 1769 1770 1771
	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;
1772
		goto err;
1773
	}
L
Linus Torvalds 已提交
1774

1775
	ret = -ENOMEM;
L
Linus Torvalds 已提交
1776
	dentry = d_alloc_name(sb->s_root, NULL_FILE_NAME);
1777
	if (!dentry)
1778
		goto err;
L
Linus Torvalds 已提交
1779

1780
	ret = -ENOMEM;
L
Linus Torvalds 已提交
1781
	inode = sel_make_inode(sb, S_IFCHR | S_IRUGO | S_IWUGO);
1782
	if (!inode)
1783
		goto err;
1784

1785
	inode->i_ino = ++sel_last_ino;
1786
	isec = (struct inode_security_struct *)inode->i_security;
L
Linus Torvalds 已提交
1787 1788 1789 1790 1791 1792
	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);
1793
	selinux_null.dentry = dentry;
L
Linus Torvalds 已提交
1794

1795 1796 1797
	dentry = sel_make_dir(sb->s_root, "avc", &sel_last_ino);
	if (IS_ERR(dentry)) {
		ret = PTR_ERR(dentry);
1798
		goto err;
1799
	}
L
Linus Torvalds 已提交
1800 1801 1802

	ret = sel_make_avc_files(dentry);
	if (ret)
1803
		goto err;
1804

1805 1806 1807
	dentry = sel_make_dir(sb->s_root, "initial_contexts", &sel_last_ino);
	if (IS_ERR(dentry)) {
		ret = PTR_ERR(dentry);
1808
		goto err;
1809
	}
1810 1811 1812 1813 1814

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

1815 1816 1817 1818
	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;
1819
		goto err;
1820
	}
1821

1822 1823 1824 1825
	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;
1826
		goto err;
1827
	}
1828
	return 0;
1829
err:
E
Eric Paris 已提交
1830 1831
	printk(KERN_ERR "SELinux: %s:  failed while creating inodes\n",
		__func__);
1832
	return ret;
L
Linus Torvalds 已提交
1833 1834
}

A
Al Viro 已提交
1835 1836
static struct dentry *sel_mount(struct file_system_type *fs_type,
		      int flags, const char *dev_name, void *data)
L
Linus Torvalds 已提交
1837
{
A
Al Viro 已提交
1838
	return mount_single(fs_type, flags, data, sel_fill_super);
L
Linus Torvalds 已提交
1839 1840 1841 1842
}

static struct file_system_type sel_fs_type = {
	.name		= "selinuxfs",
A
Al Viro 已提交
1843
	.mount		= sel_mount,
L
Linus Torvalds 已提交
1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854
	.kill_sb	= kill_litter_super,
};

struct vfsmount *selinuxfs_mount;

static int __init init_sel_fs(void)
{
	int err;

	if (!selinux_enabled)
		return 0;
1855

1856 1857 1858
	err = sysfs_create_mount_point(fs_kobj, "selinux");
	if (err)
		return err;
1859

L
Linus Torvalds 已提交
1860
	err = register_filesystem(&sel_fs_type);
1861
	if (err) {
1862
		sysfs_remove_mount_point(fs_kobj, "selinux");
1863
		return err;
1864
	}
1865

1866
	selinux_null.mnt = selinuxfs_mount = kern_mount(&sel_fs_type);
1867 1868 1869 1870
	if (IS_ERR(selinuxfs_mount)) {
		printk(KERN_ERR "selinuxfs:  could not mount!\n");
		err = PTR_ERR(selinuxfs_mount);
		selinuxfs_mount = NULL;
L
Linus Torvalds 已提交
1871
	}
1872

L
Linus Torvalds 已提交
1873 1874 1875 1876 1877 1878 1879 1880
	return err;
}

__initcall(init_sel_fs);

#ifdef CONFIG_SECURITY_SELINUX_DISABLE
void exit_sel_fs(void)
{
1881
	sysfs_remove_mount_point(fs_kobj, "selinux");
1882
	kern_unmount(selinuxfs_mount);
L
Linus Torvalds 已提交
1883 1884 1885
	unregister_filesystem(&sel_fs_type);
}
#endif