Release 4.7 security/selinux/selinuxfs.c

Directory: security/selinux
/* Updated: Karl MacMillan <kmacmillan@tresys.com>
 *
 *      Added conditional policy language extensions
 *
 *  Updated: Hewlett-Packard <paul@paul-moore.com>
 *
 *      Added support for the policy capability bitmap
 *
 * Copyright (C) 2007 Hewlett-Packard Development Company, L.P.
 * 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
 *      it under the terms of the GNU General Public License as published by
 *      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>
#include <linux/mutex.h>
#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>
#include <linux/audit.h>
#include <linux/uaccess.h>
#include <linux/kobject.h>
#include <linux/ctype.h>

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

/* Policy capability filenames */

static char *policycap_names[] = {
	"network_peer_controls",
	"open_perms",
	"redhat1",
	"always_check_network"
};


unsigned int selinux_checkreqprot = CONFIG_SECURITY_SELINUX_CHECKREQPROT_VALUE;



static int __init checkreqprot_setup(char *str)
{
	unsigned long checkreqprot;
	if (!kstrtoul(str, 0, &checkreqprot))
		selinux_checkreqprot = checkreqprot ? 1 : 0;
	return 1;
}
Contributors
Person Tokens Prop Commits CommitProp
stephen d. smalley stephen d. smalley 24 61.54% 1 33.33%
eric paris eric paris 14 35.90% 1 33.33%
jingoo han jingoo han 1 2.56% 1 33.33%
Total 39 100.00% 3 100.00%

__setup("checkreqprot=", checkreqprot_setup);

static DEFINE_MUTEX(sel_mutex);

/* global data for booleans */

static struct dentry *bool_dir;

static int bool_num;

static char **bool_pending_names;

static int *bool_pending_values;

/* global data for classes */

static struct dentry *class_dir;

static unsigned long last_class_ino;


static char policy_opened;

/* global data for policy capabilities */

static struct dentry *policycap_dir;

/* Check whether a task is allowed to use a security operation. */


static int task_has_security(struct task_struct *tsk,
			     u32 perms)
{
	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();
	if (!tsec)
		return -EACCES;

	return avc_has_perm(sid, SECINITSID_SECURITY,
			    SECCLASS_SECURITY, perms, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 46 63.01% 2 40.00%
david howells david howells 26 35.62% 2 40.00%
stephen d. smalley stephen d. smalley 1 1.37% 1 20.00%
Total 73 100.00% 5 100.00%


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 */
	
SEL_COMPAT_NET,	/* whether to use old compat network packet controls */
	
SEL_REJECT_UNKNOWN, /* export unknown reject handling to userspace */
	
SEL_DENY_UNKNOWN, /* export unknown deny handling to userspace */
	
SEL_STATUS,	/* export current status using mmap() */
	
SEL_POLICY,	/* allow userspace to read the in kernel policy */
	
SEL_VALIDATE_TRANS, /* compute validatetrans decision */
	
SEL_INO_NEXT,	/* The next inode number to use */
};


static unsigned long sel_last_ino = SEL_INO_NEXT - 1;


#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


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

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 46 77.97% 2 50.00%
chris wright chris wright 12 20.34% 1 25.00%
al viro al viro 1 1.69% 1 25.00%
Total 59 100.00% 4 100.00%

#ifdef CONFIG_SECURITY_SELINUX_DEVELOP


static ssize_t sel_write_enforce(struct file *file, const char __user *buf,
				 size_t count, loff_t *ppos)

{
	char *page = NULL;
	ssize_t length;
	int new_value;

	if (count >= PAGE_SIZE)
		return -ENOMEM;

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

	page = memdup_user_nul(buf, count);
	if (IS_ERR(page))
		return PTR_ERR(page);

	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;
		audit_log(current->audit_context, GFP_KERNEL, AUDIT_MAC_STATUS,
			"enforcing=%d old_enforcing=%d auid=%u ses=%u",
			new_value, selinux_enforcing,
			from_kuid(&init_user_ns, audit_get_loginuid(current)),
			audit_get_sessionid(current));
		selinux_enforcing = new_value;
		if (selinux_enforcing)
			avc_ss_reset(0);
		selnl_notify_setenforce(selinux_enforcing);
		selinux_status_update_setenforce(selinux_enforcing);
	}
	length = count;
out:
	kfree(page);
	return length;
}
Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 131 66.84% 1 10.00%
steve grubb steve grubb 21 10.71% 1 10.00%
al viro al viro 19 9.69% 2 20.00%
eric paris eric paris 8 4.08% 2 20.00%
eric w. biederman eric w. biederman 6 3.06% 1 10.00%
james morris james morris 5 2.55% 1 10.00%
kaigai kohei kaigai kohei 5 2.55% 1 10.00%
joe perches joe perches 1 0.51% 1 10.00%
Total 196 100.00% 10 100.00%

#else

#define sel_write_enforce NULL
#endif


static const struct file_operations sel_enforce_ops = {
	.read		= sel_read_enforce,
	.write		= sel_write_enforce,
	.llseek		= generic_file_llseek,
};



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 = file_inode(filp)->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);
}

Contributors
Person Tokens Prop Commits CommitProp
eric paris eric paris 82 96.47% 1 50.00%
al viro al viro 3 3.53% 1 50.00%
Total 85 100.00% 2 100.00%


static const struct file_operations sel_handle_unknown_ops = {
	.read		= sel_read_handle_unknown,
	.llseek		= generic_file_llseek,
};



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

Contributors
Person Tokens Prop Commits CommitProp
kaigai kohei kaigai kohei 42 100.00% 1 100.00%
Total 42 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
kaigai kohei kaigai kohei 59 100.00% 1 100.00%
Total 59 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
kaigai kohei kaigai kohei 102 100.00% 1 100.00%
Total 102 100.00% 1 100.00%


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

#ifdef CONFIG_SECURITY_SELINUX_DISABLE


static ssize_t sel_write_disable(struct file *file, const char __user *buf,
				 size_t count, loff_t *ppos)

{
	char *page;
	ssize_t length;
	int new_value;

	if (count >= PAGE_SIZE)
		return -ENOMEM;

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

	page = memdup_user_nul(buf, count);
	if (IS_ERR(page))
		return PTR_ERR(page);

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

	if (new_value) {
		length = selinux_disable();
		if (length)
			goto out;
		audit_log(current->audit_context, GFP_KERNEL, AUDIT_MAC_STATUS,
			"selinux=0 auid=%u ses=%u",
			from_kuid(&init_user_ns, audit_get_loginuid(current)),
			audit_get_sessionid(current));
	}

	length = count;
out:
	kfree(page);
	return length;
}
Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 113 70.19% 1 16.67%
al viro al viro 19 11.80% 2 33.33%
steve grubb steve grubb 17 10.56% 1 16.67%
eric paris eric paris 6 3.73% 1 16.67%
eric w. biederman eric w. biederman 6 3.73% 1 16.67%
Total 161 100.00% 6 100.00%

#else

#define sel_write_disable NULL
#endif


static const struct file_operations sel_disable_ops = {
	.write		= sel_write_disable,
	.llseek		= generic_file_llseek,
};



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

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

Contributors
Person Tokens Prop Commits CommitProp
chris wright chris wright 40 67.80% 1 50.00%
andrew morton andrew morton 19 32.20% 1 50.00%
Total 59 100.00% 2 100.00%


static const struct file_operations sel_policyvers_ops = {
	.read		= sel_read_policyvers,
	.llseek		= generic_file_llseek,
};

/* declaration for sel_write_load */
static int sel_make_bools(void);
static int sel_make_classes(void);
static int sel_make_policycap(void);

/* declaration for sel_make_class_dirs */
static struct dentry *sel_make_dir(struct dentry *dir, const char *name,
			unsigned long *ino);



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

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

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 45 75.00% 2 40.00%
chris wright chris wright 12 20.00% 1 20.00%
guido trentalancia guido trentalancia 2 3.33% 1 20.00%
al viro al viro 1 1.67% 1 20.00%
Total 60 100.00% 5 100.00%


static const struct file_operations sel_mls_ops = {
	.read		= sel_read_mls,
	.llseek		= generic_file_llseek,
};


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()) {
		inode_lock(inode);
		i_size_write(inode, security_policydb_len());
		inode_unlock(inode);
	}

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

Contributors
Person Tokens Prop Commits CommitProp
eric paris eric paris 189 98.95% 1 50.00%
al viro al viro 2 1.05% 1 50.00%
Total 191 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
eric paris eric paris 50 100.00% 1 100.00%
Total 50 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
eric paris eric paris 87 100.00% 1 100.00%
Total 87 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
eric paris eric paris 100 100.00% 1 100.00%
Total 100 100.00% 1 100.00%


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



static int sel_mmap_policy(struct file *filp, struct vm_area_struct *vma)
{
	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_DONTEXPAND | VM_DONTDUMP;
	vma->vm_ops = &sel_mmap_policy_ops;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric paris eric paris 60 93.75% 1 33.33%
konstantin khlebnikov konstantin khlebnikov 3 4.69% 1 33.33%
james morris james morris 1 1.56% 1 33.33%
Total 64 100.00% 3 100.00%


static const struct file_operations sel_policy_ops = {
	.open		= sel_open_policy,
	.read		= sel_read_policy,
	.mmap		= sel_mmap_policy,
	.release	= sel_release_policy,
	.llseek		= generic_file_llseek,
};



static ssize_t sel_write_load(struct file *file, const char __user *buf,
			      size_t count, loff_t *ppos)

{
	ssize_t length;
	void *data = NULL;

	mutex_lock(&sel_mutex);

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

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

	length = -EFBIG;
	if (count > 64 * 1024 * 1024)
		goto out;

	length = -ENOMEM;
	data = vmalloc(count);
	if (!data)
		goto out;

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

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

	length = sel_make_bools();
	if (length)
		goto out1;

	length = sel_make_classes();
	if (length)
		goto out1;

	length = sel_make_policycap();
	if (length)
		goto out1;

	length = count;

out1:
	audit_log(current->audit_context, GFP_KERNEL, AUDIT_MAC_POLICY_LOAD,
		"policy loaded auid=%u ses=%u",
		from_kuid(&init_user_ns, audit_get_loginuid(current)),
		audit_get_sessionid(current));
out:
	mutex_unlock(&sel_mutex);
	vfree(data);
	return length;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 144 61.80% 2 20.00%
eric paris eric paris 39 16.74% 2 20.00%
steve grubb steve grubb 17 7.30% 1 10.00%
christopher j. pebenito christopher j. pebenito 12 5.15% 1 10.00%
paul moore paul moore 10 4.29% 1 10.00%
eric w. biederman eric w. biederman 6 2.58% 1 10.00%
ingo molnar ingo molnar 4 1.72% 1 10.00%
al viro al viro 1 0.43% 1 10.00%
Total 233 100.00% 10 100.00%


static const struct file_operations sel_load_ops = {
	.write		= sel_write_load,
	.llseek		= generic_file_llseek,
};



static ssize_t sel_write_context(struct file *file, char *buf, size_t size)
{
	char *canon = NULL;
	u32 sid, len;
	ssize_t length;

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

	length = security_context_to_sid(buf, size, &sid, GFP_KERNEL);
	if (length)
		goto out;

	length = security_sid_to_context(sid, &canon, &len);
	if (length)
		goto out;

	length = -ERANGE;
	if (len > SIMPLE_TRANSACTION_LIMIT) {
		printk(KERN_ERR "SELinux: %s:  context size (%u) exceeds "
			"payload max\n", __func__, len);
		goto out;
	}

	memcpy(buf, canon, len);
	length = len;
out:
	kfree(canon);
	return length;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 75 53.96% 2 28.57%
stephen d. smalley stephen d. smalley 44 31.65% 1 14.29%
eric paris eric paris 17 12.23% 2 28.57%
nikolay aleksandrov nikolay aleksandrov 2 1.44% 1 14.29%
harvey harrison harvey harrison 1 0.72% 1 14.29%
Total 139 100.00% 7 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
stephen d. smalley stephen d. smalley 59 100.00% 1 100.00%
Total 59 100.00% 1 100.00%



static ssize_t sel_write_checkreqprot(struct file *file, const char __user *buf,
				      size_t count, loff_t *ppos)
{
	char *page;
	ssize_t length;
	unsigned int new_value;

	length = task_has_security(current, SECURITY__SETCHECKREQPROT);
	if (length)
		return length;

	if (count >= PAGE_SIZE)
		return -ENOMEM;

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

	page = memdup_user_nul(buf, count);
	if (IS_ERR(page))
		return PTR_ERR(page);

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

	selinux_checkreqprot = new_value ? 1 : 0;
	length = count;
out:
	kfree(page);
	return length;
}
Contributors
Person Tokens Prop Commits CommitProp
stephen d. smalley stephen d. smalley 119 85.61% 1 50.00%
al viro al viro 20 14.39% 1 50.00%
Total 139 100.00% 2 100.00%


static const struct file_operations sel_checkreqprot_ops = {
	.read		= sel_read_checkreqprot,
	.write		= sel_write_checkreqprot,
	.llseek		= generic_file_llseek,
};



static ssize_t sel_write_validatetrans(struct file *file,
					const char __user *buf,
					size_t count, loff_t *ppos)
{
	char *oldcon = NULL, *newcon = NULL, *taskcon = NULL;
	char *req = NULL;
	u32 osid, nsid, tsid;
	u16 tclass;
	int rc;

	rc = task_has_security(current, SECURITY__VALIDATE_TRANS);
	if (rc)
		goto out;

	rc = -ENOMEM;
	if (count >= PAGE_SIZE)
		goto out;

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

	rc = -ENOMEM;
	req = kzalloc(count + 1, GFP_KERNEL);
	if (!req)
		goto out;

	rc = -EFAULT;
	if (copy_from_user(req, buf, count))
		goto out;

	rc = -ENOMEM;
	oldcon = kzalloc(count + 1, GFP_KERNEL);
	if (!oldcon)
		goto out;

	newcon = kzalloc(count + 1, GFP_KERNEL);
	if (!newcon)
		goto out;

	taskcon = kzalloc(count + 1, GFP_KERNEL);
	if (!taskcon)
		goto out;

	rc = -EINVAL;
	if (sscanf(req, "%s %s %hu %s", oldcon, newcon, &tclass, taskcon) != 4)
		goto out;

	rc = security_context_str_to_sid(oldcon, &osid, GFP_KERNEL);
	if (rc)
		goto out;

	rc = security_context_str_to_sid(newcon, &nsid, GFP_KERNEL);
	if (rc)
		goto out;

	rc = security_context_str_to_sid(taskcon, &tsid, GFP_KERNEL);
	if (rc)
		goto out;

	rc = security_validate_transition_user(osid, nsid, tsid, tclass);
	if (!rc)
		rc = count;
out:
	kfree(req);
	kfree(oldcon);
	kfree(newcon);
	kfree(taskcon);
	return rc;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew perepechko andrew perepechko 342 100.00% 1 100.00%
Total 342 100.00% 1 100.00%


static const struct file_operations sel_transition_ops = {
	.write		= sel_write_validatetrans,
	.llseek		= generic_file_llseek,
};

/*
 * Remaining nodes use transaction based IO methods like nfsd/nfsctl.c
 */
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);


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,
	[SEL_CONTEXT] = sel_write_context,

};


static ssize_t selinux_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
{
	ino_t ino = file_inode(file)->i_ino;
	char *data;
	ssize_t rv;

	if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
		return -EINVAL;

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

	rv = write_op[ino](file, data, size);
	if (rv > 0) {
		simple_transaction_set(file, rv);
		rv = size;
	}
	return rv;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 102 84.30% 1 20.00%
james morris james morris 14 11.57% 1 20.00%
al viro al viro 4 3.31% 2 40.00%
nicolas kaiser nicolas kaiser 1 0.83% 1 20.00%
Total 121 100.00% 5 100.00%


static const struct file_operations transaction_ops = {
	.write		= selinux_transaction_write,
	.read		= simple_transaction_read,
	.release	= simple_transaction_release,
	.llseek		= generic_file_llseek,
};

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



static ssize_t sel_write_access(struct file *file, char *buf, size_t size)
{
	char *scon = NULL, *tcon = NULL;
	u32 ssid, tsid;
	u16 tclass;
	struct av_decision avd;
	ssize_t length;

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

	length = -ENOMEM;
	scon = kzalloc(size + 1, GFP_KERNEL);
	if (!scon)
		goto out;

	length = -ENOMEM;
	tcon = kzalloc(size + 1, GFP_KERNEL);
	if (!tcon)
		goto out;

	length = -EINVAL;
	if (sscanf(buf, "%s %s %hu", scon, tcon, &tclass) != 3)
		goto out;

	length = security_context_str_to_sid(scon, &ssid, GFP_KERNEL);
	if (length)
		goto out;

	length = security_context_str_to_sid(tcon, &tsid, GFP_KERNEL);
	if (length)
		goto out;

	security_compute_av_user(ssid, tsid, tclass, &avd);

	length = scnprintf(buf, SIMPLE_TRANSACTION_LIMIT,
			  "%x %x %x %x %u %x",
			  avd.allowed, 0xffffffff,
			  avd.auditallow, avd.auditdeny,
			  avd.seqno, avd.flags);
out:
	kfree(tcon);
	kfree(scon);
	return length;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 196 84.48% 2 18.18%
eric paris eric paris 19 8.19% 2 18.18%
kaigai kohei kaigai kohei 5 2.16% 1 9.09%
nikolay aleksandrov nikolay aleksandrov 4 1.72% 1 9.09%
james morris james morris 3 1.29% 2 18.18%
stephen d. smalley stephen d. smalley 3 1.29% 2 18.18%
rasmus villemoes rasmus villemoes 2 0.86% 1 9.09%
Total 232 100.00% 11 100.00%



static ssize_t sel_write_create(struct file *file, char *buf, size_t size)
{
	char *scon = NULL, *tcon = NULL;
	char *namebuf = NULL, *objname = NULL;
	u32 ssid, tsid, newsid;
	u16 tclass;
	ssize_t length;
	char *newcon = NULL;
	u32 len;
	int nargs;

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

	length = -ENOMEM;
	scon = kzalloc(size + 1, GFP_KERNEL);
	if (!scon)
		goto out;

	length = -ENOMEM;
	tcon = kzalloc(size + 1, GFP_KERNEL);
	if (!tcon)
		goto out;

	length = -ENOMEM;
	namebuf = kzalloc(size + 1, GFP_KERNEL);
	if (!namebuf)
		goto out;

	length = -EINVAL;
	nargs = sscanf(buf, "%s %s %hu %s", scon, tcon, &tclass, namebuf);
	if (nargs < 3 || nargs > 4)
		goto out;
	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 == '%') {
				c1 = hex_to_bin(*r++);
				if (c1 < 0)
					goto out;
				c2 = hex_to_bin(*r++);
				if (c2 < 0)
					goto out;
				c1 = (c1 << 4) | c2;
			}
			*w++ = c1;
		} while (c1 != '\0');

		objname = namebuf;
	}

	length = security_context_str_to_sid(scon, &ssid, GFP_KERNEL);
	if (length)
		goto out;

	length = security_context_str_to_sid(tcon, &tsid, GFP_KERNEL);
	if (length)
		goto out;

	length = security_transition_sid_user(ssid, tsid, tclass,
					      objname, &newsid);
	if (length)
		goto out;

	length = security_sid_to_context(newsid, &newcon, &len);
	if (length)
		goto out;

	length = -ERANGE;
	if (len > SIMPLE_TRANSACTION_LIMIT) {
		printk(KERN_ERR "SELinux: %s:  context size (%u) exceeds "
			"payload max\n", __func__, len);
		goto out;
	}

	memcpy(buf, newcon, len);
	length = len;
out:
	kfree(newcon);
	kfree(namebuf);
	kfree(tcon);
	kfree(scon);
	return length;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 236 52.10% 1 8.33%
kohei kaigai kohei kaigai 166 36.64% 2 16.67%
eric paris eric paris 30 6.62% 2 16.67%
andy shevchenko andy shevchenko 10 2.21% 1 8.33%
nikolay aleksandrov nikolay aleksandrov 4 0.88% 1 8.33%
james morris james morris 3 0.66% 2 16.67%
rasmus villemoes rasmus villemoes 2 0.44% 1 8.33%
stephen d. smalley stephen d. smalley 1 0.22% 1 8.33%
harvey harrison harvey harrison 1 0.22% 1 8.33%
Total 453 100.00% 12 100.00%



static ssize_t sel_write_relabel(struct file *file, char *buf, size_t size)
{
	char *scon = NULL, *tcon = NULL;
	u32 ssid, tsid, newsid;
	u16 tclass;
	ssize_t length;
	char *newcon = NULL;
	u32 len;

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

	length = -ENOMEM;
	scon = kzalloc(size + 1, GFP_KERNEL);
	if (!scon)
		goto out;

	length = -ENOMEM;
	tcon = kzalloc(size + 1, GFP_KERNEL);
	if (!tcon)
		goto out;

	length = -EINVAL;
	if (sscanf(buf, "%s %s %hu", scon, tcon, &tclass) != 3)
		goto out;

	length = security_context_str_to_sid(scon, &ssid, GFP_KERNEL);
	if (length)
		goto out;

	length = security_context_str_to_sid(tcon, &tsid, GFP_KERNEL);
	if (length)
		goto out;

	length = security_change_sid(ssid, tsid, tclass, &newsid);
	if (length)
		goto out;

	length = security_sid_to_context(newsid, &newcon, &len);
	if (length)
		goto out;

	length = -ERANGE;
	if (len > SIMPLE_TRANSACTION_LIMIT)
		goto out;

	memcpy(buf, newcon, len);
	length = len;
out:
	kfree(newcon);
	kfree(tcon);
	kfree(scon);
	return length;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 230 86.14% 1 16.67%
eric paris eric paris 28 10.49% 1 16.67%
nikolay aleksandrov nikolay aleksandrov 4 1.50% 1 16.67%
james morris james morris 3 1.12% 2 33.33%
rasmus villemoes rasmus villemoes 2 0.75% 1 16.67%
Total 267 100.00% 6 100.00%



static ssize_t sel_write_user(struct file *file, char *buf, size_t size)
{
	char *con = NULL, *user = NULL, *ptr;
	u32 sid, *sids = NULL;
	ssize_t length;
	char *newcon;
	int i, rc;
	u32 len, nsids;

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

	length = -ENOMEM;
	con = kzalloc(size + 1, GFP_KERNEL);
	if (!con)
		goto out;

	length = -ENOMEM;
	user = kzalloc(size + 1, GFP_KERNEL);
	if (!user)
		goto out;

	length = -EINVAL;
	if (sscanf(buf, "%s %s", con, user) != 2)
		goto out;

	length = security_context_str_to_sid(con, &sid, GFP_KERNEL);
	if (length)
		goto out;

	length = security_get_user_sids(sid, user, &sids, &nsids);
	if (length)
		goto out;

	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;
			goto out;
		}
		if ((length + len) >= SIMPLE_TRANSACTION_LIMIT) {
			kfree(newcon);
			length = -ERANGE;
			goto out;
		}
		memcpy(ptr, newcon, len);
		kfree(newcon);
		ptr += len;
		length += len;
	}
out:
	kfree(sids);
	kfree(user);
	kfree(con);
	return length;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 287 91.11% 1 16.67%
eric paris eric paris 22 6.98% 1 16.67%
james morris james morris 3 0.95% 2 33.33%
nikolay aleksandrov nikolay aleksandrov 2 0.63% 1 16.67%
rasmus villemoes rasmus villemoes 1 0.32% 1 16.67%
Total 315 100.00% 6 100.00%



static ssize_t sel_write_member(struct file *file, char *buf, size_t size)
{
	char *scon = NULL, *tcon = NULL;
	u32 ssid, tsid, newsid;
	u16 tclass;
	ssize_t length;
	char *newcon = NULL;
	u32 len;

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

	length = -ENOMEM;
	scon = kzalloc(size + 1, GFP_KERNEL);
	if (!scon)
		goto out;

	length = -ENOMEM;
	tcon = kzalloc(size + 1, GFP_KERNEL);
	if (!tcon)
		goto out;

	length = -EINVAL;
	if (sscanf(buf, "%s %s %hu", scon, tcon, &tclass) != 3)
		goto out;

	length = security_context_str_to_sid(scon, &ssid, GFP_KERNEL);
	if (length)
		goto out;

	length = security_context_str_to_sid(tcon, &tsid, GFP_KERNEL);
	if (length)
		goto out;

	length = security_member_sid(ssid, tsid, tclass, &newsid);
	if (length)
		goto out;

	length = security_sid_to_context(newsid, &newcon, &len);
	if (length)
		goto out;

	length = -ERANGE;
	if (len > SIMPLE_TRANSACTION_LIMIT) {
		printk(KERN_ERR "SELinux: %s:  context size (%u) exceeds "
			"payload max\n", __func__, len);
		goto out;
	}

	memcpy(buf, newcon, len);
	length = len;
out:
	kfree(newcon);
	kfree(tcon);
	kfree(scon);
	return length;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen d. smalley stephen d. smalley 241 86.07% 1 14.29%
eric paris eric paris 30 10.71% 2 28.57%
nikolay aleksandrov nikolay aleksandrov 4 1.43% 1 14.29%
rasmus villemoes rasmus villemoes 2 0.71% 1 14.29%
james morris james morris 2 0.71% 1 14.29%
harvey harrison harvey harrison 1 0.36% 1 14.29%
Total 280 100.00% 7 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 55 100.00% 2 100.00%
Total 55 100.00% 2 100.00%



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;
	unsigned index = file_inode(filep)->i_ino & SEL_INO_MASK;
	const char *name = filep->f_path.dentry->d_name.name;

	mutex_lock(&sel_mutex);

	ret = -EINVAL;
	if (index >= bool_num || strcmp(name, bool_pending_names[index]))
		goto out;

	ret = -ENOMEM;
	page = (char *)get_zeroed_page(GFP_KERNEL);
	if (!page)
		goto out;

	cur_enforcing = security_get_bool_value(index);
	if (cur_enforcing < 0) {
		ret = cur_enforcing;
		goto out;
	}
	length = scnprintf(page, PAGE_SIZE, "%d %d", cur_enforcing,
			  bool_pending_values[index]);
	ret = simple_read_from_buffer(buf, count, ppos, page, length);
out:
	mutex_unlock(&sel_mutex);
	free_page((unsigned long)page);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 124 63.92% 1 11.11%
stephen d. smalley stephen d. smalley 46 23.71% 2 22.22%
eric paris eric paris 14 7.22% 2 22.22%
al viro al viro 5 2.58% 2 22.22%
ingo molnar ingo molnar 4 2.06% 1 11.11%
chris wright chris wright 1 0.52% 1 11.11%
Total 194 100.00% 9 100.00%



static ssize_t sel_write_bool(struct file *filep, const char __user *buf,
			      size_t count, loff_t *ppos)
{
	char *page = NULL;
	ssize_t length;
	int new_value;
	unsigned index = file_inode(filep)->i_ino & SEL_INO_MASK;
	const char *name = filep->f_path.dentry->d_name.name;

	mutex_lock(&sel_mutex);

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

	length = -EINVAL;
	if (index >= bool_num || strcmp(name, bool_pending_names[index]))
		goto out;

	length = -ENOMEM;
	if (count >= PAGE_SIZE)
		goto out;

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

	page = memdup_user_nul(buf, count);
	if (IS_ERR(page)) {
		length = PTR_ERR(page);
		page = NULL;
		goto out;
	}

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

	if (new_value)
		new_value = 1;

	bool_pending_values[index] = new_value;
	length = count;

out:
	mutex_unlock(&sel_mutex);
	kfree(page);
	return length;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 144 63.16% 1 14.29%
stephen d. smalley stephen d. smalley 45 19.74% 1 14.29%
al viro al viro 21 9.21% 3 42.86%
eric paris eric paris 14 6.14% 1 14.29%
ingo molnar ingo molnar 4 1.75% 1 14.29%
Total 228 100.00% 7 100.00%


static const struct file_operations sel_bool_ops = {
	.read		= sel_read_bool,
	.write		= sel_write_bool,
	.llseek		= generic_file_llseek,
};



static ssize_t sel_commit_bools_write(struct file *filep,
				      const char __user *buf,
				      size_t count, loff_t *ppos)
{
	char *page = NULL;
	ssize_t length;
	int new_value;

	mutex_lock(&sel_mutex);

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

	length = -ENOMEM;
	if (count >= PAGE_SIZE)
		goto out;

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

	page = memdup_user_nul(buf, count);
	if (IS_ERR(page)) {
		length = PTR_ERR(page);
		page = NULL;
		goto out;
	}

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

	length = 0;
	if (new_value && bool_pending_values)
		length = security_set_bools(bool_num, bool_pending_values);

	if (!length)
		length = count;

out:
	mutex_unlock(&sel_mutex);
	kfree(page);
	return length;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 140 75.27% 1 14.29%
eric paris eric paris 21 11.29% 1 14.29%
al viro al viro 17 9.14% 2 28.57%
ingo molnar ingo molnar 4 2.15% 1 14.29%
davi arnaut davi arnaut 2 1.08% 1 14.29%
stephen d. smalley stephen d. smalley 2 1.08% 1 14.29%
Total 186 100.00% 7 100.00%


static const struct file_operations sel_commit_bools_ops = {
	.write		= sel_commit_bools_write,
	.llseek		= generic_file_llseek,
};



static void sel_remove_entries(struct dentry *de)
{
	d_genocide(de);
	shrink_dcache_parent(de);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 15 71.43% 1 25.00%
nick piggin nick piggin 3 14.29% 1 25.00%
al viro al viro 2 9.52% 1 25.00%
christopher j. pebenito christopher j. pebenito 1 4.76% 1 25.00%
Total 21 100.00% 4 100.00%


#define BOOL_DIR_NAME "booleans"



static int sel_make_bools(void)
{
	int i, ret;
	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 */
	for (i = 0; i < bool_num; i++)
		kfree(bool_pending_names[i]);
	kfree(bool_pending_names);
	kfree(bool_pending_values);
	bool_num = 0;
	bool_pending_names = NULL;
	bool_pending_values = NULL;

	sel_remove_entries(dir);

	ret = -ENOMEM;
	page = (char *)get_zeroed_page(GFP_KERNEL);
	if (!page)
		goto out;

	ret = security_get_bools(&num, &names, &values);
	if (ret)
		goto out;

	for (i = 0; i < num; i++) {
		ret = -ENOMEM;
		dentry = d_alloc_name(dir, names[i]);
		if (!dentry)
			goto out;

		ret = -ENOMEM;
		inode = sel_make_inode(dir->d_sb, S_IFREG | S_IRUGO | S_IWUSR);
		if (!inode)
			goto out;

		ret = -ENAMETOOLONG;
		len = snprintf(page, PAGE_SIZE, "/%s/%s", BOOL_DIR_NAME, names[i]);
		if (len >= PAGE_SIZE)
			goto out;

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

		isec->sid = sid;
		isec->initialized = 1;
		inode->i_fop = &sel_bool_ops;
		inode->i_ino = i|SEL_BOOL_INO_OFFSET;
		d_add(dentry, inode);
	}
	bool_num = num;
	bool_pending_names = names;
	bool_pending_values = values;

	free_page((unsigned long)page);
	return 0;
out:
	free_page((unsigned long)page);

	if (names) {
		for (i = 0; i < num; i++)
			kfree(names[i]);
		kfree(names);
	}
	kfree(values);
	sel_remove_entries(dir);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 300 74.26% 1 8.33%
eric paris eric paris 47 11.63% 3 25.00%
xiaotian feng xiaotian feng 21 5.20% 1 8.33%
stephen d. smalley stephen d. smalley 16 3.96% 1 8.33%
davi arnaut davi arnaut 9 2.23% 1 8.33%
james morris james morris 5 1.24% 1 8.33%
james carter james carter 2 0.50% 1 8.33%
christopher j. pebenito christopher j. pebenito 2 0.50% 1 8.33%
chris wright chris wright 1 0.25% 1 8.33%
al viro al viro 1 0.25% 1 8.33%
Total 404 100.00% 12 100.00%


#define NULL_FILE_NAME "null"


struct path selinux_null;



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

Contributors
Person Tokens Prop Commits CommitProp
james morris james morris 48 81.36% 1 50.00%
andrew morton andrew morton 11 18.64% 1 50.00%
Total 59 100.00% 2 100.00%



static ssize_t sel_write_avc_cache_threshold(struct file *file,
					     const char __user *buf,
					     size_t count, loff_t *ppos)

{
	char *page;
	ssize_t ret;
	int new_value;

	ret = task_has_security(current, SECURITY__SETSECPARAM);
	if (ret)
		return ret;

	if (count >= PAGE_SIZE)
		return -ENOMEM;

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

	page = memdup_user_nul(buf, count);
	if (IS_ERR(page))
		return PTR_ERR(page);

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

	avc_cache_threshold = new_value;

	ret = count;
out:
	kfree(page);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
james morris james morris 90 67.16% 1 16.67%
al viro al viro 20 14.93% 1 16.67%
eric paris eric paris 19 14.18% 1 16.67%
andrew morton andrew morton 3 2.24% 2 33.33%
stephen d. smalley stephen d. smalley 2 1.49% 1 16.67%
Total 134 100.00% 6 100.00%



static ssize_t sel_read_avc_hash_stats(struct file *filp, char __user *buf,
				       size_t count, loff_t *ppos)
{
	char *page;
	ssize_t length;

	page = (char *)__get_free_page(GFP_KERNEL);
	if (!page)
		return -ENOMEM;

	length = avc_get_hash_stats(page);
	if (length >= 0)
		length = simple_read_from_buffer(buf, count, ppos, page, length);
	free_page((unsigned long)page);

	return length;
}

Contributors
Person Tokens Prop Commits CommitProp
james morris james morris 82 91.11% 1 50.00%
eric paris eric paris 8 8.89% 1 50.00%
Total 90 100.00% 2 100.00%


static const struct file_operations sel_avc_cache_threshold_ops = {
	.read		= sel_read_avc_cache_threshold,
	.write		= sel_write_avc_cache_threshold,
	.llseek		= generic_file_llseek,
};


static const struct file_operations sel_avc_hash_stats_ops = {
	.read		= sel_read_avc_hash_stats,
	.llseek		= generic_file_llseek,
};

#ifdef CONFIG_SECURITY_SELINUX_AVC_STATS


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

	for (cpu = *idx; cpu < nr_cpu_ids; ++cpu) {
		if (!cpu_possible(cpu))
			continue;
		*idx = cpu + 1;
		return &per_cpu(avc_cache_stats, cpu);
	}
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
james morris james morris 58 98.31% 1 50.00%
rusty russell rusty russell 1 1.69% 1 50.00%
Total 59 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
james morris james morris 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
james morris james morris 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



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");
	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,
			   st->reclaims, st->frees);
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
james morris james morris 65 71.43% 1 50.00%
linus torvalds linus torvalds 26 28.57% 1 50.00%
Total 91 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
james morris james morris 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%


static const struct seq_operations sel_avc_cache_stats_seq_ops = {
	.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);
}

Contributors
Person Tokens Prop Commits CommitProp
james morris james morris 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%


static const struct file_operations sel_avc_cache_stats_ops = {
	.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)
{
	int i;
	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
	};

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

		dentry = d_alloc_name(dir, files[i].name);
		if (!dentry)
			return -ENOMEM;

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

		inode->i_fop = files[i].ops;
		inode->i_ino = ++sel_last_ino;
		d_add(dentry, inode);
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
james morris james morris 150 92.02% 1 25.00%
james carter james carter 7 4.29% 1 25.00%
eric paris eric paris 5 3.07% 1 25.00%
nicolas kaiser nicolas kaiser 1 0.61% 1 25.00%
Total 163 100.00% 4 100.00%



static ssize_t sel_read_initcon(struct file *file, char __user *buf,
				size_t count, loff_t *ppos)
{
	char *con;
	u32 sid, len;
	ssize_t ret;

	sid = file_inode(file)->i_ino&SEL_INO_MASK;
	ret = security_sid_to_context(sid, &con, &len);
	if (ret)
		return ret;

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

Contributors
Person Tokens Prop Commits CommitProp
james carter james carter 85 95.51% 1 50.00%
al viro al viro 4 4.49% 1 50.00%
Total 89 100.00% 2 100.00%


static const struct file_operations sel_initcon_ops = {
	.read		= sel_read_initcon,
	.llseek		= generic_file_llseek,
};



static int sel_make_initcon_files(struct dentry *dir)
{
	int i;

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

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

		inode->i_fop = &sel_initcon_ops;
		inode->i_ino = i|SEL_INITCON_INO_OFFSET;
		d_add(dentry, inode);
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
james carter james carter 102 95.33% 1 50.00%
eric paris eric paris 5 4.67% 1 50.00%
Total 107 100.00% 2 100.00%



static inline unsigned long sel_class_to_ino(u16 class)
{
	return (class * (SEL_VEC_MAX + 1)) | SEL_CLASS_INO_OFFSET;
}

Contributors
Person Tokens Prop Commits CommitProp
christopher j. pebenito christopher j. pebenito 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



static inline u16 sel_ino_to_class(unsigned long ino)
{
	return (ino & SEL_INO_MASK) / (SEL_VEC_MAX + 1);
}

Contributors
Person Tokens Prop Commits CommitProp
christopher j. pebenito christopher j. pebenito 19 79.17% 1 50.00%
eric paris eric paris 5 20.83% 1 50.00%
Total 24 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
christopher j. pebenito christopher j. pebenito 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
christopher j. pebenito christopher j. pebenito 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



static ssize_t sel_read_class(struct file *file, char __user *buf,
				size_t count, loff_t *ppos)
{
	unsigned long ino = file_inode(file)->i_ino;
	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);
}

Contributors
Person Tokens Prop Commits CommitProp
christopher j. pebenito christopher j. pebenito 49 66.22% 2 40.00%
al viro al viro 18 24.32% 2 40.00%
james morris james morris 7 9.46% 1 20.00%
Total 74 100.00% 5 100.00%


static const struct file_operations sel_class_ops = {
	.read		= sel_read_class,
	.llseek		= generic_file_llseek,
};



static ssize_t sel_read_perm(struct file *file, char __user *buf,
				size_t count, loff_t *ppos)
{
	unsigned long ino = file_inode(file)->i_ino;
	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);
}

Contributors
Person Tokens Prop Commits CommitProp
christopher j. pebenito christopher j. pebenito 56 75.68% 1 33.33%
al viro al viro 18 24.32% 2 66.67%
Total 74 100.00% 3 100.00%


static const struct file_operations sel_perm_ops = {
	.read		= sel_read_perm,
	.llseek		= generic_file_llseek,
};



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_inode(file)->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);
}

Contributors
Person Tokens Prop Commits CommitProp
paul moore paul moore 79 96.34% 1 50.00%
al viro al viro 3 3.66% 1 50.00%
Total 82 100.00% 2 100.00%


static const struct file_operations sel_policycap_ops = {
	.read		= sel_read_policycap,
	.llseek		= generic_file_llseek,
};



static int sel_make_perm_files(char *objclass, int classvalue,
				struct dentry *dir)
{
	int i, rc, nperms;
	char **perms;

	rc = security_get_permissions(objclass, &perms, &nperms);
	if (rc)
		return rc;

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

		rc = -ENOMEM;
		dentry = d_alloc_name(dir, perms[i]);
		if (!dentry)
			goto out;

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

		inode->i_fop = &sel_perm_ops;
		/* i+1 since perm values are 1-indexed */
		inode->i_ino = sel_perm_to_ino(classvalue, i + 1);
		d_add(dentry, inode);
	}
	rc = 0;
out:
	for (i = 0; i < nperms; i++)
		kfree(perms[i]);
	kfree(perms);
	return rc;
}

Contributors
Person Tokens Prop Commits CommitProp
christopher j. pebenito christopher j. pebenito 172 91.01% 1 50.00%
eric paris eric paris 17 8.99% 1 50.00%
Total 189 100.00% 2 100.00%



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");
	if (!dentry)
		return -ENOMEM;

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

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

	dentry = sel_make_dir(dir, "perms", &last_class_ino);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);

	rc = sel_make_perm_files(classname, index, dentry);

	return rc;
}

Contributors
Person Tokens Prop Commits CommitProp
christopher j. pebenito christopher j. pebenito 123 89.78% 1 33.33%
al viro al viro 8 5.84% 1 33.33%
eric paris eric paris 6 4.38% 1 33.33%
Total 137 100.00% 3 100.00%



static int sel_make_classes(void)
{
	int rc, nclasses, i;
	char **classes;

	/* delete any existing entries */
	sel_remove_entries(class_dir);

	rc = security_get_classes(&classes, &nclasses);
	if (rc)
		return rc;

	/* +2 since classes are 1-indexed */
	last_class_ino = sel_class_to_ino(nclasses + 2);

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

		class_name_dir = sel_make_dir(class_dir, classes[i],
				&last_class_ino);
		if (IS_ERR(class_name_dir)) {
			rc = PTR_ERR(class_name_dir);
			goto out;
		}

		/* i+1 since class values are 1-indexed */
		rc = sel_make_class_dir_entries(classes[i], i + 1,
				class_name_dir);
		if (rc)
			goto out;
	}
	rc = 0;
out:
	for (i = 0; i < nclasses; i++)
		kfree(classes[i]);
	kfree(classes);
	return rc;
}

Contributors
Person Tokens Prop Commits CommitProp
christopher j. pebenito christopher j. pebenito 143 85.63% 1 25.00%
al viro al viro 14 8.38% 2 50.00%
eric paris eric paris 10 5.99% 1 25.00%
Total 167 100.00% 4 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
paul moore paul moore 135 100.00% 1 100.00%
Total 135 100.00% 1 100.00%



static struct dentry *sel_make_dir(struct dentry *dir, const char *name,
			unsigned long *ino)
{
	struct dentry *dentry = d_alloc_name(dir, name);
	struct inode *inode;

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

	inode->i_op = &simple_dir_inode_operations;
	inode->i_fop = &simple_dir_operations;
	inode->i_ino = ++(*ino);
	/* directory inodes start off with i_nlink == 2 (for "." entry) */
	inc_nlink(inode);
	d_add(dentry, inode);
	/* bump link count on parent directory, too */
	inc_nlink(d_inode(dir));

	return dentry;
}

Contributors
Person Tokens Prop Commits CommitProp
christopher j. pebenito christopher j. pebenito 55 40.74% 2 20.00%
al viro al viro 44 32.59% 1 10.00%
james morris james morris 19 14.07% 3 30.00%
james carter james carter 6 4.44% 1 10.00%
dave hansen dave hansen 6 4.44% 1 10.00%
david howells david howells 3 2.22% 1 10.00%
eric paris eric paris 2 1.48% 1 10.00%
Total 135 100.00% 10 100.00%



static int sel_fill_super(struct super_block *sb, void *data, int silent)
{
	int ret;
	struct dentry *dentry;
	struct inode *inode;
	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},
		[SEL_CONTEXT] = {"context", &transaction_ops, S_IRUGO|S_IWUGO},
		[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},
		[SEL_REJECT_UNKNOWN] = {"reject_unknown", &sel_handle_unknown_ops, S_IRUGO},
		[SEL_DENY_UNKNOWN] = {"deny_unknown", &sel_handle_unknown_ops, S_IRUGO},
		[SEL_STATUS] = {"status", &sel_handle_status_ops, S_IRUGO},
		[SEL_POLICY] = {"policy", &sel_policy_ops, S_IRUGO},
		[SEL_VALIDATE_TRANS] = {"validatetrans", &sel_transition_ops,
					S_IWUGO},
		/* last one */ {""}
	};
	ret = simple_fill_super(sb, SELINUX_MAGIC, selinux_files);
	if (ret)
		goto err;

	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;
		goto err;
	}

	ret = -ENOMEM;
	dentry = d_alloc_name(sb->s_root, NULL_FILE_NAME);
	if (!dentry)
		goto err;

	ret = -ENOMEM;
	inode = sel_make_inode(sb, S_IFCHR | S_IRUGO | S_IWUGO);
	if (!inode)
		goto err;

	inode->i_ino = ++sel_last_ino;
	isec = (struct inode_security_struct *)inode->i_security;
	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);
	selinux_null.dentry = dentry;

	dentry = sel_make_dir(sb->s_root, "avc", &sel_last_ino);
	if (IS_ERR(dentry)) {
		ret = PTR_ERR(dentry);
		goto err;
	}

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

	dentry = sel_make_dir(sb->s_root, "initial_contexts", &sel_last_ino);
	if (IS_ERR(dentry)) {
		ret = PTR_ERR(dentry);
		goto err;
	}

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

	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;
		goto err;
	}

	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;
		goto err;
	}
	return 0;
err:
	printk(KERN_ERR "SELinux: %s:  failed while creating inodes\n",
		__func__);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
james morris james morris 179 27.25% 5 18.52%
stephen d. smalley stephen d. smalley 126 19.18% 4 14.81%
andrew morton andrew morton 117 17.81% 4 14.81%
al viro al viro 73 11.11% 2 7.41%
eric paris eric paris 52 7.91% 5 18.52%
james carter james carter 44 6.70% 2 7.41%
paul moore paul moore 20 3.04% 1 3.70%
christopher j. pebenito christopher j. pebenito 19 2.89% 1 3.70%
andrew perepechko andrew perepechko 13 1.98% 1 3.70%
kaigai kohei kaigai kohei 13 1.98% 1 3.70%
harvey harrison harvey harrison 1 0.15% 1 3.70%
Total 657 100.00% 27 100.00%



static struct dentry *sel_mount(struct file_system_type *fs_type,
		      int flags, const char *dev_name, void *data)
{
	return mount_single(fs_type, flags, data, sel_fill_super);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 32 86.49% 1 50.00%
al viro al viro 5 13.51% 1 50.00%
Total 37 100.00% 2 100.00%


static struct file_system_type sel_fs_type = {
	.name		= "selinuxfs",
	.mount		= sel_mount,
	.kill_sb	= kill_litter_super,
};


struct vfsmount *selinuxfs_mount;



static int __init init_sel_fs(void)
{
	int err;

	if (!selinux_enabled)
		return 0;

	err = sysfs_create_mount_point(fs_kobj, "selinux");
	if (err)
		return err;

	err = register_filesystem(&sel_fs_type);
	if (err) {
		sysfs_remove_mount_point(fs_kobj, "selinux");
		return err;
	}

	selinux_null.mnt = selinuxfs_mount = kern_mount(&sel_fs_type);
	if (IS_ERR(selinuxfs_mount)) {
		printk(KERN_ERR "selinuxfs:  could not mount!\n");
		err = PTR_ERR(selinuxfs_mount);
		selinuxfs_mount = NULL;
	}

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
stephen d. smalley stephen d. smalley 53 52.48% 1 14.29%
andrew morton andrew morton 16 15.84% 2 28.57%
greg kroah-hartman greg kroah-hartman 15 14.85% 1 14.29%
eric w. biederman eric w. biederman 10 9.90% 1 14.29%
al viro al viro 4 3.96% 1 14.29%
eric paris eric paris 3 2.97% 1 14.29%
Total 101 100.00% 7 100.00%


__initcall(init_sel_fs);

#ifdef CONFIG_SECURITY_SELINUX_DISABLE


void exit_sel_fs(void)
{
	sysfs_remove_mount_point(fs_kobj, "selinux");
	kern_unmount(selinuxfs_mount);
	unregister_filesystem(&sel_fs_type);
}
Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 13 52.00% 1 25.00%
tim chen tim chen 5 20.00% 1 25.00%
eric w. biederman eric w. biederman 4 16.00% 1 25.00%
greg kroah-hartman greg kroah-hartman 3 12.00% 1 25.00%
Total 25 100.00% 4 100.00%

#endif
Overall Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 3031 34.08% 6 6.52%
eric paris eric paris 1100 12.37% 14 15.22%
james morris james morris 944 10.61% 11 11.96%
stephen d. smalley stephen d. smalley 864 9.71% 9 9.78%
christopher j. pebenito christopher j. pebenito 797 8.96% 4 4.35%
andrew perepechko andrew perepechko 376 4.23% 1 1.09%
al viro al viro 337 3.79% 9 9.78%
paul moore paul moore 287 3.23% 2 2.17%
james carter james carter 283 3.18% 3 3.26%
kaigai kohei kaigai kohei 257 2.89% 2 2.17%
kohei kaigai kohei kaigai 169 1.90% 2 2.17%
arnd bergmann arnd bergmann 80 0.90% 1 1.09%
chris wright chris wright 70 0.79% 1 1.09%
steve grubb steve grubb 58 0.65% 1 1.09%
eric w. biederman eric w. biederman 32 0.36% 2 2.17%
david howells david howells 29 0.33% 3 3.26%
linus torvalds linus torvalds 26 0.29% 1 1.09%
greg kroah-hartman greg kroah-hartman 21 0.24% 1 1.09%
ingo molnar ingo molnar 21 0.24% 1 1.09%
xiaotian feng xiaotian feng 21 0.24% 1 1.09%
nikolay aleksandrov nikolay aleksandrov 20 0.22% 1 1.09%
arjan van de ven arjan van de ven 12 0.13% 1 1.09%
davi arnaut davi arnaut 11 0.12% 1 1.09%
andy shevchenko andy shevchenko 10 0.11% 1 1.09%
rasmus villemoes rasmus villemoes 9 0.10% 1 1.09%
dave hansen dave hansen 6 0.07% 1 1.09%
tim chen tim chen 5 0.06% 1 1.09%
harvey harrison harvey harrison 4 0.04% 1 1.09%
nick piggin nick piggin 3 0.03% 1 1.09%
konstantin khlebnikov konstantin khlebnikov 3 0.03% 1 1.09%
guido trentalancia guido trentalancia 2 0.02% 1 1.09%
nicolas kaiser nicolas kaiser 2 0.02% 1 1.09%
joe perches joe perches 1 0.01% 1 1.09%
jingoo han jingoo han 1 0.01% 1 1.09%
rusty russell rusty russell 1 0.01% 1 1.09%
jan engelhardt jan engelhardt 1 0.01% 1 1.09%
kirill a. shutemov kirill a. shutemov 1 0.01% 1 1.09%
Total 8895 100.00% 92 100.00%
  Directory: security/selinux

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
stephen d. smalley	stephen d. smalley	24	61.54%	1	33.33%
eric paris	eric paris	14	35.90%	1	33.33%
jingoo han	jingoo han	1	2.56%	1	33.33%
	Total	39	100.00%	3	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 security/selinux/selinuxfs.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
