[deliverable/linux.git] / security / integrity / iint.c

/*
 * Copyright (C) 2008 IBM Corporation
 *
 * Authors:
 * Mimi Zohar <zohar@us.ibm.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 of the
 * License.
 *
 * File: integrity_iint.c
 *	- implements the integrity hooks: integrity_inode_alloc,
 *	  integrity_inode_free
 *	- cache integrity information associated with an inode
 *	  using a rbtree tree.
 */
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/rbtree.h>
#include "integrity.h"

static struct rb_root integrity_iint_tree = RB_ROOT;
static DEFINE_SPINLOCK(integrity_iint_lock);
static struct kmem_cache *iint_cache __read_mostly;

int iint_initialized;

/*
 * __integrity_iint_find - return the iint associated with an inode
 */
static struct integrity_iint_cache *__integrity_iint_find(struct inode *inode)
{
	struct integrity_iint_cache *iint;
	struct rb_node *n = integrity_iint_tree.rb_node;

	assert_spin_locked(&integrity_iint_lock);

	while (n) {
		iint = rb_entry(n, struct integrity_iint_cache, rb_node);

		if (inode < iint->inode)
			n = n->rb_left;
		else if (inode > iint->inode)
			n = n->rb_right;
		else
			break;
	}
	if (!n)
		return NULL;

	return iint;
}

/*
 * integrity_iint_find - return the iint associated with an inode
 */
struct integrity_iint_cache *integrity_iint_find(struct inode *inode)
{
	struct integrity_iint_cache *iint;

	if (!IS_IMA(inode))
		return NULL;

	spin_lock(&integrity_iint_lock);
	iint = __integrity_iint_find(inode);
	spin_unlock(&integrity_iint_lock);

	return iint;
}

static void iint_free(struct integrity_iint_cache *iint)
{
	iint->version = 0;
	iint->flags = 0UL;
	iint->evm_status = INTEGRITY_UNKNOWN;
	kmem_cache_free(iint_cache, iint);
}

/**
 * integrity_inode_alloc - allocate an iint associated with an inode
 * @inode: pointer to the inode
 */
int integrity_inode_alloc(struct inode *inode)
{
	struct rb_node **p;
	struct rb_node *new_node, *parent = NULL;
	struct integrity_iint_cache *new_iint, *test_iint;
	int rc;

	new_iint = kmem_cache_alloc(iint_cache, GFP_NOFS);
	if (!new_iint)
		return -ENOMEM;

	new_iint->inode = inode;
	new_node = &new_iint->rb_node;

	mutex_lock(&inode->i_mutex);	/* i_flags */
	spin_lock(&integrity_iint_lock);

	p = &integrity_iint_tree.rb_node;
	while (*p) {
		parent = *p;
		test_iint = rb_entry(parent, struct integrity_iint_cache,
				     rb_node);
		rc = -EEXIST;
		if (inode < test_iint->inode)
			p = &(*p)->rb_left;
		else if (inode > test_iint->inode)
			p = &(*p)->rb_right;
		else
			goto out_err;
	}

	inode->i_flags |= S_IMA;
	rb_link_node(new_node, parent, p);
	rb_insert_color(new_node, &integrity_iint_tree);

	spin_unlock(&integrity_iint_lock);
	mutex_unlock(&inode->i_mutex);	/* i_flags */

	return 0;
out_err:
	spin_unlock(&integrity_iint_lock);
	mutex_unlock(&inode->i_mutex);	/* i_flags */
	iint_free(new_iint);

	return rc;
}

/**
 * integrity_inode_free - called on security_inode_free
 * @inode: pointer to the inode
 *
 * Free the integrity information(iint) associated with an inode.
 */
void integrity_inode_free(struct inode *inode)
{
	struct integrity_iint_cache *iint;

	if (!IS_IMA(inode))
		return;

	spin_lock(&integrity_iint_lock);
	iint = __integrity_iint_find(inode);
	rb_erase(&iint->rb_node, &integrity_iint_tree);
	spin_unlock(&integrity_iint_lock);

	iint_free(iint);
}

static void init_once(void *foo)
{
	struct integrity_iint_cache *iint = foo;

	memset(iint, 0, sizeof *iint);
	iint->version = 0;
	iint->flags = 0UL;
	mutex_init(&iint->mutex);
	iint->evm_status = INTEGRITY_UNKNOWN;
}

static int __init integrity_iintcache_init(void)
{
	iint_cache =
	    kmem_cache_create("iint_cache", sizeof(struct integrity_iint_cache),
			      0, SLAB_PANIC, init_once);
	iint_initialized = 1;
	return 0;
}
security_initcall(integrity_iintcache_init);
Commit	Line	Data
f381c272 MZ	1	/*
	2	* Copyright (C) 2008 IBM Corporation
	3	*
	4	* Authors:
	5	* Mimi Zohar <zohar@us.ibm.com>
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License as
	9	* published by the Free Software Foundation, version 2 of the
	10	* License.
	11	*
	12	* File: integrity_iint.c
	13	* - implements the integrity hooks: integrity_inode_alloc,
	14	* integrity_inode_free
	15	* - cache integrity information associated with an inode
	16	* using a rbtree tree.
	17	*/
	18	#include <linux/slab.h>
	19	#include <linux/module.h>
	20	#include <linux/spinlock.h>
	21	#include <linux/rbtree.h>
	22	#include "integrity.h"
	23
	24	static struct rb_root integrity_iint_tree = RB_ROOT;
	25	static DEFINE_SPINLOCK(integrity_iint_lock);
	26	static struct kmem_cache *iint_cache __read_mostly;
	27
	28	int iint_initialized;
	29
	30	/*
	31	* __integrity_iint_find - return the iint associated with an inode
	32	*/
	33	static struct integrity_iint_cache __integrity_iint_find(struct inode inode)
	34	{
	35	struct integrity_iint_cache *iint;
	36	struct rb_node *n = integrity_iint_tree.rb_node;
	37
	38	assert_spin_locked(&integrity_iint_lock);
	39
	40	while (n) {
	41	iint = rb_entry(n, struct integrity_iint_cache, rb_node);
	42
	43	if (inode < iint->inode)
	44	n = n->rb_left;
	45	else if (inode > iint->inode)
	46	n = n->rb_right;
	47	else
	48	break;
	49	}
	50	if (!n)
	51	return NULL;
	52
	53	return iint;
	54	}
	55
	56	/*
	57	* integrity_iint_find - return the iint associated with an inode
	58	*/
	59	struct integrity_iint_cache integrity_iint_find(struct inode inode)
	60	{
	61	struct integrity_iint_cache *iint;
	62
	63	if (!IS_IMA(inode))
	64	return NULL;
65
66	spin_lock(&integrity_iint_lock);
67	iint = __integrity_iint_find(inode);
68	spin_unlock(&integrity_iint_lock);
69
70	return iint;
71	}
72
73	static void iint_free(struct integrity_iint_cache *iint)
74	{
75	iint->version = 0;
76	iint->flags = 0UL;
fb788d8b	77	iint->evm_status = INTEGRITY_UNKNOWN;
f381c272 MZ	78	kmem_cache_free(iint_cache, iint);
	79	}
	80
	81	/**
	82	* integrity_inode_alloc - allocate an iint associated with an inode
	83	* @inode: pointer to the inode
	84	*/
	85	int integrity_inode_alloc(struct inode *inode)
	86	{
	87	struct rb_node **p;
	88	struct rb_node new_node, parent = NULL;
	89	struct integrity_iint_cache new_iint, test_iint;
	90	int rc;
	91
	92	new_iint = kmem_cache_alloc(iint_cache, GFP_NOFS);
	93	if (!new_iint)
	94	return -ENOMEM;
	95
	96	new_iint->inode = inode;
	97	new_node = &new_iint->rb_node;
	98
	99	mutex_lock(&inode->i_mutex); /* i_flags */
	100	spin_lock(&integrity_iint_lock);
	101
	102	p = &integrity_iint_tree.rb_node;
	103	while (*p) {
	104	parent = *p;
	105	test_iint = rb_entry(parent, struct integrity_iint_cache,
	106	rb_node);
	107	rc = -EEXIST;
	108	if (inode < test_iint->inode)
	109	p = &(*p)->rb_left;
	110	else if (inode > test_iint->inode)
	111	p = &(*p)->rb_right;
	112	else
	113	goto out_err;
	114	}
	115
	116	inode->i_flags \|= S_IMA;
	117	rb_link_node(new_node, parent, p);
	118	rb_insert_color(new_node, &integrity_iint_tree);
	119
	120	spin_unlock(&integrity_iint_lock);
	121	mutex_unlock(&inode->i_mutex); /* i_flags */
	122
	123	return 0;
	124	out_err:
	125	spin_unlock(&integrity_iint_lock);
	126	mutex_unlock(&inode->i_mutex); /* i_flags */
	127	iint_free(new_iint);
	128
	129	return rc;
	130	}
	131
	132	/**
	133	* integrity_inode_free - called on security_inode_free
	134	* @inode: pointer to the inode
	135	*
	136	* Free the integrity information(iint) associated with an inode.
	137	*/
	138	void integrity_inode_free(struct inode *inode)
	139	{
	140	struct integrity_iint_cache *iint;
	141
142	if (!IS_IMA(inode))
143	return;
144
145	spin_lock(&integrity_iint_lock);
146	iint = __integrity_iint_find(inode);
147	rb_erase(&iint->rb_node, &integrity_iint_tree);
148	spin_unlock(&integrity_iint_lock);
149
150	iint_free(iint);
151	}
152
153	static void init_once(void *foo)
154	{
155	struct integrity_iint_cache *iint = foo;
156
157	memset(iint, 0, sizeof *iint);
158	iint->version = 0;
159	iint->flags = 0UL;
160	mutex_init(&iint->mutex);
24e0198e	161	iint->evm_status = INTEGRITY_UNKNOWN;
f381c272 MZ	162	}
	163
	164	static int __init integrity_iintcache_init(void)
	165	{
	166	iint_cache =
	167	kmem_cache_create("iint_cache", sizeof(struct integrity_iint_cache),
	168	0, SLAB_PANIC, init_once);
	169	iint_initialized = 1;
	170	return 0;
	171	}
	172	security_initcall(integrity_iintcache_init);