[deliverable/linux.git] / security / tomoyo / memory.c

/*
 * security/tomoyo/memory.c
 *
 * Memory management functions for TOMOYO.
 *
 * Copyright (C) 2005-2010  NTT DATA CORPORATION
 */

#include <linux/hash.h>
#include <linux/slab.h>
#include "common.h"

/**
 * tomoyo_warn_oom - Print out of memory warning message.
 *
 * @function: Function's name.
 */
void tomoyo_warn_oom(const char *function)
{
	/* Reduce error messages. */
	static pid_t tomoyo_last_pid;
	const pid_t pid = current->pid;
	if (tomoyo_last_pid != pid) {
		printk(KERN_WARNING "ERROR: Out of memory at %s.\n",
		       function);
		tomoyo_last_pid = pid;
	}
	if (!tomoyo_policy_loaded)
		panic("MAC Initialization failed.\n");
}

/* Memoy currently used by policy/audit log/query. */
unsigned int tomoyo_memory_used[TOMOYO_MAX_MEMORY_STAT];
/* Memory quota for "policy"/"audit log"/"query". */
unsigned int tomoyo_memory_quota[TOMOYO_MAX_MEMORY_STAT];

/* Memory allocated for policy. */
static atomic_t tomoyo_policy_memory_size;
/* Quota for holding policy. */
static unsigned int tomoyo_quota_for_policy;

/**
 * tomoyo_memory_ok - Check memory quota.
 *
 * @ptr: Pointer to allocated memory.
 *
 * Returns true on success, false otherwise.
 *
 * Returns true if @ptr is not NULL and quota not exceeded, false otherwise.
 */
bool tomoyo_memory_ok(void *ptr)
{
	size_t s = ptr ? ksize(ptr) : 0;
	atomic_add(s, &tomoyo_policy_memory_size);
	if (ptr && (!tomoyo_quota_for_policy ||
		    atomic_read(&tomoyo_policy_memory_size)
		    <= tomoyo_quota_for_policy)) {
		memset(ptr, 0, s);
		return true;
	}
	atomic_sub(s, &tomoyo_policy_memory_size);
	tomoyo_warn_oom(__func__);
	return false;
}

/**
 * tomoyo_commit_ok - Check memory quota.
 *
 * @data:   Data to copy from.
 * @size:   Size in byte.
 *
 * Returns pointer to allocated memory on success, NULL otherwise.
 * @data is zero-cleared on success.
 */
void *tomoyo_commit_ok(void *data, const unsigned int size)
{
	void *ptr = kzalloc(size, GFP_NOFS);
	if (tomoyo_memory_ok(ptr)) {
		memmove(ptr, data, size);
		memset(data, 0, size);
		return ptr;
	}
	kfree(ptr);
	return NULL;
}

/**
 * tomoyo_memory_free - Free memory for elements.
 *
 * @ptr:  Pointer to allocated memory.
 */
void tomoyo_memory_free(void *ptr)
{
	atomic_sub(ksize(ptr), &tomoyo_policy_memory_size);
	kfree(ptr);
}

/**
 * tomoyo_get_group - Allocate memory for "struct tomoyo_path_group"/"struct tomoyo_number_group".
 *
 * @param: Pointer to "struct tomoyo_acl_param".
 * @idx:   Index number.
 *
 * Returns pointer to "struct tomoyo_group" on success, NULL otherwise.
 */
struct tomoyo_group *tomoyo_get_group(struct tomoyo_acl_param *param,
				      const u8 idx)
{
	struct tomoyo_group e = { };
	struct tomoyo_group *group = NULL;
	struct list_head *list;
	const char *group_name = tomoyo_read_token(param);
	bool found = false;
	if (!tomoyo_correct_word(group_name) || idx >= TOMOYO_MAX_GROUP)
		return NULL;
	e.group_name = tomoyo_get_name(group_name);
	if (!e.group_name)
		return NULL;
	if (mutex_lock_interruptible(&tomoyo_policy_lock))
		goto out;
	list = &tomoyo_group_list[idx];
	list_for_each_entry(group, list, head.list) {
		if (e.group_name != group->group_name)
			continue;
		atomic_inc(&group->head.users);
		found = true;
		break;
	}
	if (!found) {
		struct tomoyo_group *entry = tomoyo_commit_ok(&e, sizeof(e));
		if (entry) {
			INIT_LIST_HEAD(&entry->member_list);
			atomic_set(&entry->head.users, 1);
			list_add_tail_rcu(&entry->head.list, list);
			group = entry;
			found = true;
		}
	}
	mutex_unlock(&tomoyo_policy_lock);
out:
	tomoyo_put_name(e.group_name);
	return found ? group : NULL;
}

/*
 * tomoyo_name_list is used for holding string data used by TOMOYO.
 * Since same string data is likely used for multiple times (e.g.
 * "/lib/libc-2.5.so"), TOMOYO shares string data in the form of
 * "const struct tomoyo_path_info *".
 */
struct list_head tomoyo_name_list[TOMOYO_MAX_HASH];

/**
 * tomoyo_get_name - Allocate permanent memory for string data.
 *
 * @name: The string to store into the permernent memory.
 *
 * Returns pointer to "struct tomoyo_path_info" on success, NULL otherwise.
 */
const struct tomoyo_path_info *tomoyo_get_name(const char *name)
{
	struct tomoyo_name *ptr;
	unsigned int hash;
	int len;
	int allocated_len;
	struct list_head *head;

	if (!name)
		return NULL;
	len = strlen(name) + 1;
	hash = full_name_hash((const unsigned char *) name, len - 1);
	head = &tomoyo_name_list[hash_long(hash, TOMOYO_HASH_BITS)];
	if (mutex_lock_interruptible(&tomoyo_policy_lock))
		return NULL;
	list_for_each_entry(ptr, head, head.list) {
		if (hash != ptr->entry.hash || strcmp(name, ptr->entry.name))
			continue;
		atomic_inc(&ptr->head.users);
		goto out;
	}
	ptr = kzalloc(sizeof(*ptr) + len, GFP_NOFS);
	allocated_len = ptr ? ksize(ptr) : 0;
	if (!ptr || (tomoyo_quota_for_policy &&
		     atomic_read(&tomoyo_policy_memory_size) + allocated_len
		     > tomoyo_quota_for_policy)) {
		kfree(ptr);
		ptr = NULL;
		tomoyo_warn_oom(__func__);
		goto out;
	}
	atomic_add(allocated_len, &tomoyo_policy_memory_size);
	ptr->entry.name = ((char *) ptr) + sizeof(*ptr);
	memmove((char *) ptr->entry.name, name, len);
	atomic_set(&ptr->head.users, 1);
	tomoyo_fill_path_info(&ptr->entry);
	list_add_tail(&ptr->head.list, head);
 out:
	mutex_unlock(&tomoyo_policy_lock);
	return ptr ? &ptr->entry : NULL;
}

/**
 * tomoyo_mm_init - Initialize mm related code.
 */
void __init tomoyo_mm_init(void)
{
	int idx;

	for (idx = 0; idx < TOMOYO_MAX_POLICY; idx++)
		INIT_LIST_HEAD(&tomoyo_policy_list[idx]);
	for (idx = 0; idx < TOMOYO_MAX_GROUP; idx++)
		INIT_LIST_HEAD(&tomoyo_group_list[idx]);
	for (idx = 0; idx < TOMOYO_MAX_HASH; idx++)
		INIT_LIST_HEAD(&tomoyo_name_list[idx]);
	INIT_LIST_HEAD(&tomoyo_kernel_domain.acl_info_list);
	for (idx = 0; idx < TOMOYO_MAX_ACL_GROUPS; idx++)
		INIT_LIST_HEAD(&tomoyo_acl_group[idx]);
	tomoyo_kernel_domain.domainname = tomoyo_get_name(TOMOYO_ROOT_NAME);
	list_add_tail_rcu(&tomoyo_kernel_domain.list, &tomoyo_domain_list);
	idx = tomoyo_read_lock();
	if (tomoyo_find_domain(TOMOYO_ROOT_NAME) != &tomoyo_kernel_domain)
		panic("Can't register tomoyo_kernel_domain");
#if 0
	/* Will be replaced with tomoyo_load_builtin_policy(). */
	{
		/* Load built-in policy. */
		tomoyo_write_transition_control("/sbin/hotplug", false,
					TOMOYO_TRANSITION_CONTROL_INITIALIZE);
		tomoyo_write_transition_control("/sbin/modprobe", false,
					TOMOYO_TRANSITION_CONTROL_INITIALIZE);
	}
#endif
	tomoyo_read_unlock(idx);
}


/* Memory allocated for query lists. */
unsigned int tomoyo_query_memory_size;
/* Quota for holding query lists. */
unsigned int tomoyo_quota_for_query;

/**
 * tomoyo_read_memory_counter - Check for memory usage in bytes.
 *
 * @head: Pointer to "struct tomoyo_io_buffer".
 *
 * Returns memory usage.
 */
void tomoyo_read_memory_counter(struct tomoyo_io_buffer *head)
{
	if (!head->r.eof) {
		const unsigned int policy
			= atomic_read(&tomoyo_policy_memory_size);
		const unsigned int query = tomoyo_query_memory_size;
		char buffer[64];

		memset(buffer, 0, sizeof(buffer));
		if (tomoyo_quota_for_policy)
			snprintf(buffer, sizeof(buffer) - 1,
				 "   (Quota: %10u)",
				 tomoyo_quota_for_policy);
		else
			buffer[0] = '\0';
		tomoyo_io_printf(head, "Policy:       %10u%s\n", policy,
				 buffer);
		if (tomoyo_quota_for_query)
			snprintf(buffer, sizeof(buffer) - 1,
				 "   (Quota: %10u)",
				 tomoyo_quota_for_query);
		else
			buffer[0] = '\0';
		tomoyo_io_printf(head, "Query lists:  %10u%s\n", query,
				 buffer);
		tomoyo_io_printf(head, "Total:        %10u\n", policy + query);
		head->r.eof = true;
	}
}

/**
 * tomoyo_write_memory_quota - Set memory quota.
 *
 * @head: Pointer to "struct tomoyo_io_buffer".
 *
 * Returns 0.
 */
int tomoyo_write_memory_quota(struct tomoyo_io_buffer *head)
{
	char *data = head->write_buf;
	unsigned int size;

	if (sscanf(data, "Policy: %u", &size) == 1)
		tomoyo_quota_for_policy = size;
	else if (sscanf(data, "Query lists: %u", &size) == 1)
		tomoyo_quota_for_query = size;
	return 0;
}
Commit	Line	Data
c3ef1500 TH	1	/*
	2	* security/tomoyo/memory.c
	3	*
	4	* Memory management functions for TOMOYO.
	5	*
	6	* Copyright (C) 2005-2010 NTT DATA CORPORATION
	7	*/
	8
	9	#include <linux/hash.h>
	10	#include <linux/slab.h>
	11	#include "common.h"
	12
	13	/**
	14	* tomoyo_warn_oom - Print out of memory warning message.
	15	*
	16	* @function: Function's name.
	17	*/
	18	void tomoyo_warn_oom(const char *function)
	19	{
	20	/* Reduce error messages. */
	21	static pid_t tomoyo_last_pid;
	22	const pid_t pid = current->pid;
	23	if (tomoyo_last_pid != pid) {
	24	printk(KERN_WARNING "ERROR: Out of memory at %s.\n",
	25	function);
	26	tomoyo_last_pid = pid;
	27	}
	28	if (!tomoyo_policy_loaded)
	29	panic("MAC Initialization failed.\n");
	30	}
	31
eadd99cc TH	32	/* Memoy currently used by policy/audit log/query. */
	33	unsigned int tomoyo_memory_used[TOMOYO_MAX_MEMORY_STAT];
	34	/* Memory quota for "policy"/"audit log"/"query". */
	35	unsigned int tomoyo_memory_quota[TOMOYO_MAX_MEMORY_STAT];
	36
c3ef1500 TH	37	/* Memory allocated for policy. */
	38	static atomic_t tomoyo_policy_memory_size;
	39	/* Quota for holding policy. */
	40	static unsigned int tomoyo_quota_for_policy;
	41
	42	/**
	43	* tomoyo_memory_ok - Check memory quota.
	44	*
	45	* @ptr: Pointer to allocated memory.
	46	*
	47	* Returns true on success, false otherwise.
	48	*
	49	* Returns true if @ptr is not NULL and quota not exceeded, false otherwise.
	50	*/
	51	bool tomoyo_memory_ok(void *ptr)
	52	{
	53	size_t s = ptr ? ksize(ptr) : 0;
	54	atomic_add(s, &tomoyo_policy_memory_size);
	55	if (ptr && (!tomoyo_quota_for_policy \|\|
	56	atomic_read(&tomoyo_policy_memory_size)
	57	<= tomoyo_quota_for_policy)) {
	58	memset(ptr, 0, s);
	59	return true;
	60	}
	61	atomic_sub(s, &tomoyo_policy_memory_size);
	62	tomoyo_warn_oom(__func__);
	63	return false;
	64	}
	65
	66	/**
	67	* tomoyo_commit_ok - Check memory quota.
	68	*
	69	* @data: Data to copy from.
	70	* @size: Size in byte.
	71	*
	72	* Returns pointer to allocated memory on success, NULL otherwise.
	73	* @data is zero-cleared on success.
	74	*/
	75	void tomoyo_commit_ok(void data, const unsigned int size)
	76	{
	77	void *ptr = kzalloc(size, GFP_NOFS);
	78	if (tomoyo_memory_ok(ptr)) {
	79	memmove(ptr, data, size);
	80	memset(data, 0, size);
	81	return ptr;
	82	}
cfc64fd9	83	kfree(ptr);
c3ef1500 TH	84	return NULL;
	85	}
	86
	87	/**
	88	* tomoyo_memory_free - Free memory for elements.
	89	*
	90	* @ptr: Pointer to allocated memory.
	91	*/
	92	void tomoyo_memory_free(void *ptr)
	93	{
	94	atomic_sub(ksize(ptr), &tomoyo_policy_memory_size);
	95	kfree(ptr);
	96	}
	97
7c2ea22e TH	98	/**
	99	* tomoyo_get_group - Allocate memory for "struct tomoyo_path_group"/"struct tomoyo_number_group".
	100	*
a238cf5b TH	101	* @param: Pointer to "struct tomoyo_acl_param".
a238cf5b TH	102	* @idx: Index number.
7c2ea22e TH	103	*
	104	* Returns pointer to "struct tomoyo_group" on success, NULL otherwise.
	105	*/
a238cf5b TH	106	struct tomoyo_group tomoyo_get_group(struct tomoyo_acl_param param,
a238cf5b TH	107	const u8 idx)
7c2ea22e TH	108	{
	109	struct tomoyo_group e = { };
	110	struct tomoyo_group *group = NULL;
a238cf5b TH	111	struct list_head *list;
a238cf5b TH	112	const char *group_name = tomoyo_read_token(param);
7c2ea22e TH	113	bool found = false;
	114	if (!tomoyo_correct_word(group_name) \|\| idx >= TOMOYO_MAX_GROUP)
	115	return NULL;
	116	e.group_name = tomoyo_get_name(group_name);
	117	if (!e.group_name)
	118	return NULL;
	119	if (mutex_lock_interruptible(&tomoyo_policy_lock))
	120	goto out;
a238cf5b TH	121	list = &tomoyo_group_list[idx];
a238cf5b TH	122	list_for_each_entry(group, list, head.list) {
7c2ea22e TH	123	if (e.group_name != group->group_name)
7c2ea22e TH	124	continue;
0df7e8b8	125	atomic_inc(&group->head.users);
7c2ea22e TH	126	found = true;
	127	break;
	128	}
	129	if (!found) {
	130	struct tomoyo_group *entry = tomoyo_commit_ok(&e, sizeof(e));
	131	if (entry) {
	132	INIT_LIST_HEAD(&entry->member_list);
0df7e8b8	133	atomic_set(&entry->head.users, 1);
a238cf5b	134	list_add_tail_rcu(&entry->head.list, list);
7c2ea22e TH	135	group = entry;
	136	found = true;
	137	}
	138	}
	139	mutex_unlock(&tomoyo_policy_lock);
a238cf5b	140	out:
7c2ea22e TH	141	tomoyo_put_name(e.group_name);
	142	return found ? group : NULL;
	143	}
	144
c3ef1500 TH	145	/*
	146	* tomoyo_name_list is used for holding string data used by TOMOYO.
	147	* Since same string data is likely used for multiple times (e.g.
	148	* "/lib/libc-2.5.so"), TOMOYO shares string data in the form of
	149	* "const struct tomoyo_path_info *".
	150	*/
	151	struct list_head tomoyo_name_list[TOMOYO_MAX_HASH];
	152
	153	/**
	154	* tomoyo_get_name - Allocate permanent memory for string data.
	155	*
	156	* @name: The string to store into the permernent memory.
	157	*
	158	* Returns pointer to "struct tomoyo_path_info" on success, NULL otherwise.
	159	*/
	160	const struct tomoyo_path_info tomoyo_get_name(const char name)
	161	{
e2bf6907	162	struct tomoyo_name *ptr;
c3ef1500 TH	163	unsigned int hash;
	164	int len;
	165	int allocated_len;
	166	struct list_head *head;
	167
	168	if (!name)
	169	return NULL;
	170	len = strlen(name) + 1;
	171	hash = full_name_hash((const unsigned char *) name, len - 1);
	172	head = &tomoyo_name_list[hash_long(hash, TOMOYO_HASH_BITS)];
	173	if (mutex_lock_interruptible(&tomoyo_policy_lock))
	174	return NULL;
0df7e8b8	175	list_for_each_entry(ptr, head, head.list) {
c3ef1500 TH	176	if (hash != ptr->entry.hash \|\| strcmp(name, ptr->entry.name))
c3ef1500 TH	177	continue;
0df7e8b8	178	atomic_inc(&ptr->head.users);
c3ef1500 TH	179	goto out;
	180	}
	181	ptr = kzalloc(sizeof(*ptr) + len, GFP_NOFS);
	182	allocated_len = ptr ? ksize(ptr) : 0;
	183	if (!ptr \|\| (tomoyo_quota_for_policy &&
	184	atomic_read(&tomoyo_policy_memory_size) + allocated_len
	185	> tomoyo_quota_for_policy)) {
	186	kfree(ptr);
	187	ptr = NULL;
	188	tomoyo_warn_oom(__func__);
	189	goto out;
	190	}
	191	atomic_add(allocated_len, &tomoyo_policy_memory_size);
	192	ptr->entry.name = ((char ) ptr) + sizeof(ptr);
	193	memmove((char *) ptr->entry.name, name, len);
0df7e8b8	194	atomic_set(&ptr->head.users, 1);
c3ef1500	195	tomoyo_fill_path_info(&ptr->entry);
0df7e8b8	196	list_add_tail(&ptr->head.list, head);
c3ef1500 TH	197	out:
	198	mutex_unlock(&tomoyo_policy_lock);
	199	return ptr ? &ptr->entry : NULL;
	200	}
	201
	202	/**
	203	* tomoyo_mm_init - Initialize mm related code.
	204	*/
	205	void __init tomoyo_mm_init(void)
	206	{
	207	int idx;
	208
a230f9e7 TH	209	for (idx = 0; idx < TOMOYO_MAX_POLICY; idx++)
	210	INIT_LIST_HEAD(&tomoyo_policy_list[idx]);
	211	for (idx = 0; idx < TOMOYO_MAX_GROUP; idx++)
	212	INIT_LIST_HEAD(&tomoyo_group_list[idx]);
c3ef1500 TH	213	for (idx = 0; idx < TOMOYO_MAX_HASH; idx++)
	214	INIT_LIST_HEAD(&tomoyo_name_list[idx]);
	215	INIT_LIST_HEAD(&tomoyo_kernel_domain.acl_info_list);
32997144 TH	216	for (idx = 0; idx < TOMOYO_MAX_ACL_GROUPS; idx++)
32997144 TH	217	INIT_LIST_HEAD(&tomoyo_acl_group[idx]);
c3ef1500 TH	218	tomoyo_kernel_domain.domainname = tomoyo_get_name(TOMOYO_ROOT_NAME);
	219	list_add_tail_rcu(&tomoyo_kernel_domain.list, &tomoyo_domain_list);
	220	idx = tomoyo_read_lock();
	221	if (tomoyo_find_domain(TOMOYO_ROOT_NAME) != &tomoyo_kernel_domain)
	222	panic("Can't register tomoyo_kernel_domain");
a238cf5b TH	223	#if 0
a238cf5b TH	224	/* Will be replaced with tomoyo_load_builtin_policy(). */
c3ef1500 TH	225	{
c3ef1500 TH	226	/* Load built-in policy. */
5448ec4f TH	227	tomoyo_write_transition_control("/sbin/hotplug", false,
	228	TOMOYO_TRANSITION_CONTROL_INITIALIZE);
	229	tomoyo_write_transition_control("/sbin/modprobe", false,
	230	TOMOYO_TRANSITION_CONTROL_INITIALIZE);
c3ef1500	231	}
a238cf5b	232	#endif
c3ef1500 TH	233	tomoyo_read_unlock(idx);
	234	}
	235
	236
	237	/* Memory allocated for query lists. */
	238	unsigned int tomoyo_query_memory_size;
	239	/* Quota for holding query lists. */
	240	unsigned int tomoyo_quota_for_query;
	241
	242	/**
	243	* tomoyo_read_memory_counter - Check for memory usage in bytes.
	244	*
	245	* @head: Pointer to "struct tomoyo_io_buffer".
	246	*
	247	* Returns memory usage.
	248	*/
8fbe71f0	249	void tomoyo_read_memory_counter(struct tomoyo_io_buffer *head)
c3ef1500	250	{
f23571e8	251	if (!head->r.eof) {
c3ef1500 TH	252	const unsigned int policy
	253	= atomic_read(&tomoyo_policy_memory_size);
	254	const unsigned int query = tomoyo_query_memory_size;
	255	char buffer[64];
	256
	257	memset(buffer, 0, sizeof(buffer));
	258	if (tomoyo_quota_for_policy)
	259	snprintf(buffer, sizeof(buffer) - 1,
	260	" (Quota: %10u)",
	261	tomoyo_quota_for_policy);
	262	else
	263	buffer[0] = '\0';
	264	tomoyo_io_printf(head, "Policy: %10u%s\n", policy,
	265	buffer);
	266	if (tomoyo_quota_for_query)
	267	snprintf(buffer, sizeof(buffer) - 1,
	268	" (Quota: %10u)",
	269	tomoyo_quota_for_query);
	270	else
	271	buffer[0] = '\0';
	272	tomoyo_io_printf(head, "Query lists: %10u%s\n", query,
	273	buffer);
	274	tomoyo_io_printf(head, "Total: %10u\n", policy + query);
f23571e8	275	head->r.eof = true;
c3ef1500	276	}
c3ef1500 TH	277	}
	278
	279	/**
	280	* tomoyo_write_memory_quota - Set memory quota.
	281	*
	282	* @head: Pointer to "struct tomoyo_io_buffer".
	283	*
	284	* Returns 0.
	285	*/
	286	int tomoyo_write_memory_quota(struct tomoyo_io_buffer *head)
	287	{
	288	char *data = head->write_buf;
	289	unsigned int size;
	290
	291	if (sscanf(data, "Policy: %u", &size) == 1)
	292	tomoyo_quota_for_policy = size;
	293	else if (sscanf(data, "Query lists: %u", &size) == 1)
	294	tomoyo_quota_for_query = size;
	295	return 0;
	296	}