[net-next-2.6.git] / security / tomoyo / realpath.c

/*
 * security/tomoyo/realpath.c
 *
 * Get the canonicalized absolute pathnames. The basis for TOMOYO.
 *
 * Copyright (C) 2005-2009  NTT DATA CORPORATION
 *
 * Version: 2.2.0   2009/04/01
 *
 */

#include <linux/types.h>
#include <linux/mount.h>
#include <linux/mnt_namespace.h>
#include <linux/fs_struct.h>
#include <linux/hash.h>
#include <linux/magic.h>

#include "common.h"
#include "realpath.h"

/**
 * tomoyo_encode: Convert binary string to ascii string.
 *
 * @buffer:  Buffer for ASCII string.
 * @buflen:  Size of @buffer.
 * @str:     Binary string.
 *
 * Returns 0 on success, -ENOMEM otherwise.
 */
int tomoyo_encode(char *buffer, int buflen, const char *str)
{
	while (1) {
		const unsigned char c = *(unsigned char *) str++;

		if (tomoyo_is_valid(c)) {
			if (--buflen <= 0)
				break;
			*buffer++ = (char) c;
			if (c != '\\')
				continue;
			if (--buflen <= 0)
				break;
			*buffer++ = (char) c;
			continue;
		}
		if (!c) {
			if (--buflen <= 0)
				break;
			*buffer = '\0';
			return 0;
		}
		buflen -= 4;
		if (buflen <= 0)
			break;
		*buffer++ = '\\';
		*buffer++ = (c >> 6) + '0';
		*buffer++ = ((c >> 3) & 7) + '0';
		*buffer++ = (c & 7) + '0';
	}
	return -ENOMEM;
}

/**
 * tomoyo_realpath_from_path2 - Returns realpath(3) of the given dentry but ignores chroot'ed root.
 *
 * @path:        Pointer to "struct path".
 * @newname:     Pointer to buffer to return value in.
 * @newname_len: Size of @newname.
 *
 * Returns 0 on success, negative value otherwise.
 *
 * If dentry is a directory, trailing '/' is appended.
 * Characters out of 0x20 < c < 0x7F range are converted to
 * \ooo style octal string.
 * Character \ is converted to \\ string.
 */
int tomoyo_realpath_from_path2(struct path *path, char *newname,
			       int newname_len)
{
	int error = -ENOMEM;
	struct dentry *dentry = path->dentry;
	char *sp;

	if (!dentry || !path->mnt || !newname || newname_len <= 2048)
		return -EINVAL;
	if (dentry->d_op && dentry->d_op->d_dname) {
		/* For "socket:[\$]" and "pipe:[\$]". */
		static const int offset = 1536;
		sp = dentry->d_op->d_dname(dentry, newname + offset,
					   newname_len - offset);
	} else {
		/* Taken from d_namespace_path(). */
		struct path root;
		struct path ns_root = { };
		struct path tmp;

		read_lock(&current->fs->lock);
		root = current->fs->root;
		path_get(&root);
		read_unlock(&current->fs->lock);
		spin_lock(&vfsmount_lock);
		if (root.mnt && root.mnt->mnt_ns)
			ns_root.mnt = mntget(root.mnt->mnt_ns->root);
		if (ns_root.mnt)
			ns_root.dentry = dget(ns_root.mnt->mnt_root);
		spin_unlock(&vfsmount_lock);
		spin_lock(&dcache_lock);
		tmp = ns_root;
		sp = __d_path(path, &tmp, newname, newname_len);
		spin_unlock(&dcache_lock);
		path_put(&root);
		path_put(&ns_root);
		/* Prepend "/proc" prefix if using internal proc vfs mount. */
		if (!IS_ERR(sp) && (path->mnt->mnt_parent == path->mnt) &&
		    (path->mnt->mnt_sb->s_magic == PROC_SUPER_MAGIC)) {
			sp -= 5;
			if (sp >= newname)
				memcpy(sp, "/proc", 5);
			else
				sp = ERR_PTR(-ENOMEM);
		}
	}
	if (IS_ERR(sp))
		error = PTR_ERR(sp);
	else
		error = tomoyo_encode(newname, sp - newname, sp);
	/* Append trailing '/' if dentry is a directory. */
	if (!error && dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode)
	    && *newname) {
		sp = newname + strlen(newname);
		if (*(sp - 1) != '/') {
			if (sp < newname + newname_len - 4) {
				*sp++ = '/';
				*sp = '\0';
			} else {
				error = -ENOMEM;
			}
		}
	}
	if (error)
		printk(KERN_WARNING "tomoyo_realpath: Pathname too long.\n");
	return error;
}

/**
 * tomoyo_realpath_from_path - Returns realpath(3) of the given pathname but ignores chroot'ed root.
 *
 * @path: Pointer to "struct path".
 *
 * Returns the realpath of the given @path on success, NULL otherwise.
 *
 * These functions use tomoyo_alloc(), so the caller must call tomoyo_free()
 * if these functions didn't return NULL.
 */
char *tomoyo_realpath_from_path(struct path *path)
{
	char *buf = tomoyo_alloc(sizeof(struct tomoyo_page_buffer));

	BUILD_BUG_ON(sizeof(struct tomoyo_page_buffer)
		     <= TOMOYO_MAX_PATHNAME_LEN - 1);
	if (!buf)
		return NULL;
	if (tomoyo_realpath_from_path2(path, buf,
				       TOMOYO_MAX_PATHNAME_LEN - 1) == 0)
		return buf;
	tomoyo_free(buf);
	return NULL;
}

/**
 * tomoyo_realpath - Get realpath of a pathname.
 *
 * @pathname: The pathname to solve.
 *
 * Returns the realpath of @pathname on success, NULL otherwise.
 */
char *tomoyo_realpath(const char *pathname)
{
	struct path path;

	if (pathname && kern_path(pathname, LOOKUP_FOLLOW, &path) == 0) {
		char *buf = tomoyo_realpath_from_path(&path);
		path_put(&path);
		return buf;
	}
	return NULL;
}

/**
 * tomoyo_realpath_nofollow - Get realpath of a pathname.
 *
 * @pathname: The pathname to solve.
 *
 * Returns the realpath of @pathname on success, NULL otherwise.
 */
char *tomoyo_realpath_nofollow(const char *pathname)
{
	struct path path;

	if (pathname && kern_path(pathname, 0, &path) == 0) {
		char *buf = tomoyo_realpath_from_path(&path);
		path_put(&path);
		return buf;
	}
	return NULL;
}

/* Memory allocated for non-string data. */
static unsigned int tomoyo_allocated_memory_for_elements;
/* Quota for holding non-string data. */
static unsigned int tomoyo_quota_for_elements;

/**
 * tomoyo_alloc_element - Allocate permanent memory for structures.
 *
 * @size: Size in bytes.
 *
 * Returns pointer to allocated memory on success, NULL otherwise.
 *
 * Memory has to be zeroed.
 * The RAM is chunked, so NEVER try to kfree() the returned pointer.
 */
void *tomoyo_alloc_element(const unsigned int size)
{
	static char *buf;
	static DEFINE_MUTEX(lock);
	static unsigned int buf_used_len = PATH_MAX;
	char *ptr = NULL;
	/*Assumes sizeof(void *) >= sizeof(long) is true. */
	const unsigned int word_aligned_size
		= roundup(size, max(sizeof(void *), sizeof(long)));
	if (word_aligned_size > PATH_MAX)
		return NULL;
	mutex_lock(&lock);
	if (buf_used_len + word_aligned_size > PATH_MAX) {
		if (!tomoyo_quota_for_elements ||
		    tomoyo_allocated_memory_for_elements
		    + PATH_MAX <= tomoyo_quota_for_elements)
			ptr = kzalloc(PATH_MAX, GFP_KERNEL);
		if (!ptr) {
			printk(KERN_WARNING "ERROR: Out of memory "
			       "for tomoyo_alloc_element().\n");
			if (!tomoyo_policy_loaded)
				panic("MAC Initialization failed.\n");
		} else {
			buf = ptr;
			tomoyo_allocated_memory_for_elements += PATH_MAX;
			buf_used_len = word_aligned_size;
			ptr = buf;
		}
	} else if (word_aligned_size) {
		int i;
		ptr = buf + buf_used_len;
		buf_used_len += word_aligned_size;
		for (i = 0; i < word_aligned_size; i++) {
			if (!ptr[i])
				continue;
			printk(KERN_ERR "WARNING: Reserved memory was tainted! "
			       "The system might go wrong.\n");
			ptr[i] = '\0';
		}
	}
	mutex_unlock(&lock);
	return ptr;
}

/* Memory allocated for string data in bytes. */
static unsigned int tomoyo_allocated_memory_for_savename;
/* Quota for holding string data in bytes. */
static unsigned int tomoyo_quota_for_savename;

/*
 * TOMOYO uses this hash only when appending a string into the string
 * table. Frequency of appending strings is very low. So we don't need
 * large (e.g. 64k) hash size. 256 will be sufficient.
 */
#define TOMOYO_HASH_BITS  8
#define TOMOYO_MAX_HASH (1u<<TOMOYO_HASH_BITS)

/*
 * tomoyo_name_entry is a structure which is used for linking
 * "struct tomoyo_path_info" into tomoyo_name_list .
 *
 * Since tomoyo_name_list manages a list of strings which are shared by
 * multiple processes (whereas "struct tomoyo_path_info" inside
 * "struct tomoyo_path_info_with_data" is not shared), a reference counter will
 * be added to "struct tomoyo_name_entry" rather than "struct tomoyo_path_info"
 * when TOMOYO starts supporting garbage collector.
 */
struct tomoyo_name_entry {
	struct list_head list;
	struct tomoyo_path_info entry;
};

/*
 * 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 *".
 */
static struct list_head tomoyo_name_list[TOMOYO_MAX_HASH];

/**
 * tomoyo_save_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_save_name(const char *name)
{
	static DEFINE_MUTEX(lock);
	struct tomoyo_name_entry *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)];
	mutex_lock(&lock);
	list_for_each_entry(ptr, head, list) {
		if (hash == ptr->entry.hash && !strcmp(name, ptr->entry.name))
			goto out;
	}
	ptr = kzalloc(sizeof(*ptr) + len, GFP_KERNEL);
	allocated_len = ptr ? ksize(ptr) : 0;
	if (!ptr || (tomoyo_quota_for_savename &&
		     tomoyo_allocated_memory_for_savename + allocated_len
		     > tomoyo_quota_for_savename)) {
		kfree(ptr);
		printk(KERN_WARNING "ERROR: Out of memory "
		       "for tomoyo_save_name().\n");
		if (!tomoyo_policy_loaded)
			panic("MAC Initialization failed.\n");
		ptr = NULL;
		goto out;
	}
	tomoyo_allocated_memory_for_savename += allocated_len;
	ptr->entry.name = ((char *) ptr) + sizeof(*ptr);
	memmove((char *) ptr->entry.name, name, len);
	tomoyo_fill_path_info(&ptr->entry);
	list_add_tail(&ptr->list, head);
 out:
	mutex_unlock(&lock);
	return ptr ? &ptr->entry : NULL;
}

/**
 * tomoyo_realpath_init - Initialize realpath related code.
 */
void __init tomoyo_realpath_init(void)
{
	int i;

	BUILD_BUG_ON(TOMOYO_MAX_PATHNAME_LEN > PATH_MAX);
	for (i = 0; i < TOMOYO_MAX_HASH; i++)
		INIT_LIST_HEAD(&tomoyo_name_list[i]);
	INIT_LIST_HEAD(&tomoyo_kernel_domain.acl_info_list);
	tomoyo_kernel_domain.domainname = tomoyo_save_name(TOMOYO_ROOT_NAME);
	/*
	 * tomoyo_read_lock() is not needed because this function is
	 * called before the first "delete" request.
	 */
	list_add_tail_rcu(&tomoyo_kernel_domain.list, &tomoyo_domain_list);
	if (tomoyo_find_domain(TOMOYO_ROOT_NAME) != &tomoyo_kernel_domain)
		panic("Can't register tomoyo_kernel_domain");
}

/* Memory allocated for temporary purpose. */
static atomic_t tomoyo_dynamic_memory_size;

/**
 * tomoyo_alloc - Allocate memory for temporary purpose.
 *
 * @size: Size in bytes.
 *
 * Returns pointer to allocated memory on success, NULL otherwise.
 */
void *tomoyo_alloc(const size_t size)
{
	void *p = kzalloc(size, GFP_KERNEL);
	if (p)
		atomic_add(ksize(p), &tomoyo_dynamic_memory_size);
	return p;
}

/**
 * tomoyo_free - Release memory allocated by tomoyo_alloc().
 *
 * @p: Pointer returned by tomoyo_alloc(). May be NULL.
 *
 * Returns nothing.
 */
void tomoyo_free(const void *p)
{
	if (p) {
		atomic_sub(ksize(p), &tomoyo_dynamic_memory_size);
		kfree(p);
	}
}

/**
 * tomoyo_read_memory_counter - Check for memory usage in bytes.
 *
 * @head: Pointer to "struct tomoyo_io_buffer".
 *
 * Returns memory usage.
 */
int tomoyo_read_memory_counter(struct tomoyo_io_buffer *head)
{
	if (!head->read_eof) {
		const unsigned int shared
			= tomoyo_allocated_memory_for_savename;
		const unsigned int private
			= tomoyo_allocated_memory_for_elements;
		const unsigned int dynamic
			= atomic_read(&tomoyo_dynamic_memory_size);
		char buffer[64];

		memset(buffer, 0, sizeof(buffer));
		if (tomoyo_quota_for_savename)
			snprintf(buffer, sizeof(buffer) - 1,
				 "   (Quota: %10u)",
				 tomoyo_quota_for_savename);
		else
			buffer[0] = '\0';
		tomoyo_io_printf(head, "Shared:  %10u%s\n", shared, buffer);
		if (tomoyo_quota_for_elements)
			snprintf(buffer, sizeof(buffer) - 1,
				 "   (Quota: %10u)",
				 tomoyo_quota_for_elements);
		else
			buffer[0] = '\0';
		tomoyo_io_printf(head, "Private: %10u%s\n", private, buffer);
		tomoyo_io_printf(head, "Dynamic: %10u\n", dynamic);
		tomoyo_io_printf(head, "Total:   %10u\n",
				 shared + private + dynamic);
		head->read_eof = true;
	}
	return 0;
}

/**
 * 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, "Shared: %u", &size) == 1)
		tomoyo_quota_for_savename = size;
	else if (sscanf(data, "Private: %u", &size) == 1)
		tomoyo_quota_for_elements = size;
	return 0;
}
Commit	Line	Data
c73bd6d4 KT	1	/*
	2	* security/tomoyo/realpath.c
	3	*
	4	* Get the canonicalized absolute pathnames. The basis for TOMOYO.
	5	*
	6	* Copyright (C) 2005-2009 NTT DATA CORPORATION
	7	*
39826a1e	8	* Version: 2.2.0 2009/04/01
c73bd6d4 KT	9	*
	10	*/
	11
	12	#include <linux/types.h>
	13	#include <linux/mount.h>
	14	#include <linux/mnt_namespace.h>
5ad4e53b	15	#include <linux/fs_struct.h>
024e1a49	16	#include <linux/hash.h>
67fa4880	17	#include <linux/magic.h>
024e1a49	18
c73bd6d4 KT	19	#include "common.h"
	20	#include "realpath.h"
	21
	22	/**
	23	* tomoyo_encode: Convert binary string to ascii string.
	24	*
	25	* @buffer: Buffer for ASCII string.
	26	* @buflen: Size of @buffer.
	27	* @str: Binary string.
	28	*
	29	* Returns 0 on success, -ENOMEM otherwise.
	30	*/
	31	int tomoyo_encode(char buffer, int buflen, const char str)
	32	{
	33	while (1) {
	34	const unsigned char c = (unsigned char ) str++;
	35
	36	if (tomoyo_is_valid(c)) {
	37	if (--buflen <= 0)
	38	break;
	39	*buffer++ = (char) c;
	40	if (c != '\\')
	41	continue;
	42	if (--buflen <= 0)
	43	break;
	44	*buffer++ = (char) c;
	45	continue;
	46	}
	47	if (!c) {
	48	if (--buflen <= 0)
	49	break;
	50	*buffer = '\0';
	51	return 0;
	52	}
	53	buflen -= 4;
	54	if (buflen <= 0)
	55	break;
	56	*buffer++ = '\\';
	57	*buffer++ = (c >> 6) + '0';
	58	*buffer++ = ((c >> 3) & 7) + '0';
	59	*buffer++ = (c & 7) + '0';
	60	}
	61	return -ENOMEM;
	62	}
	63
	64	/**
	65	* tomoyo_realpath_from_path2 - Returns realpath(3) of the given dentry but ignores chroot'ed root.
	66	*
	67	* @path: Pointer to "struct path".
	68	* @newname: Pointer to buffer to return value in.
	69	* @newname_len: Size of @newname.
	70	*
	71	* Returns 0 on success, negative value otherwise.
	72	*
	73	* If dentry is a directory, trailing '/' is appended.
	74	* Characters out of 0x20 < c < 0x7F range are converted to
	75	* \ooo style octal string.
	76	* Character \ is converted to \\ string.
	77	*/
	78	int tomoyo_realpath_from_path2(struct path path, char newname,
	79	int newname_len)
	80	{
	81	int error = -ENOMEM;
	82	struct dentry *dentry = path->dentry;
83	char *sp;
84
85	if (!dentry \|\| !path->mnt \|\| !newname \|\| newname_len <= 2048)
86	return -EINVAL;
87	if (dentry->d_op && dentry->d_op->d_dname) {
88	/* For "socket:[\$]" and "pipe:[\$]". */
89	static const int offset = 1536;
90	sp = dentry->d_op->d_dname(dentry, newname + offset,
91	newname_len - offset);
92	} else {
93	/* Taken from d_namespace_path(). */
94	struct path root;
95	struct path ns_root = { };
96	struct path tmp;
97
98	read_lock(&current->fs->lock);
99	root = current->fs->root;
100	path_get(&root);
101	read_unlock(&current->fs->lock);
102	spin_lock(&vfsmount_lock);
103	if (root.mnt && root.mnt->mnt_ns)
104	ns_root.mnt = mntget(root.mnt->mnt_ns->root);
105	if (ns_root.mnt)
106	ns_root.dentry = dget(ns_root.mnt->mnt_root);
107	spin_unlock(&vfsmount_lock);
108	spin_lock(&dcache_lock);
109	tmp = ns_root;
110	sp = __d_path(path, &tmp, newname, newname_len);
111	spin_unlock(&dcache_lock);
112	path_put(&root);
113	path_put(&ns_root);
a4054b6b EB	114	/* Prepend "/proc" prefix if using internal proc vfs mount. */
a4054b6b EB	115	if (!IS_ERR(sp) && (path->mnt->mnt_parent == path->mnt) &&
67fa4880	116	(path->mnt->mnt_sb->s_magic == PROC_SUPER_MAGIC)) {
a4054b6b EB	117	sp -= 5;
	118	if (sp >= newname)
	119	memcpy(sp, "/proc", 5);
	120	else
	121	sp = ERR_PTR(-ENOMEM);
	122	}
c73bd6d4 KT	123	}
	124	if (IS_ERR(sp))
	125	error = PTR_ERR(sp);
	126	else
	127	error = tomoyo_encode(newname, sp - newname, sp);
	128	/* Append trailing '/' if dentry is a directory. */
	129	if (!error && dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode)
	130	&& *newname) {
	131	sp = newname + strlen(newname);
	132	if (*(sp - 1) != '/') {
	133	if (sp < newname + newname_len - 4) {
	134	*sp++ = '/';
	135	*sp = '\0';
	136	} else {
	137	error = -ENOMEM;
	138	}
	139	}
	140	}
	141	if (error)
	142	printk(KERN_WARNING "tomoyo_realpath: Pathname too long.\n");
	143	return error;
	144	}
	145
	146	/**
	147	* tomoyo_realpath_from_path - Returns realpath(3) of the given pathname but ignores chroot'ed root.
	148	*
	149	* @path: Pointer to "struct path".
	150	*
	151	* Returns the realpath of the given @path on success, NULL otherwise.
	152	*
	153	* These functions use tomoyo_alloc(), so the caller must call tomoyo_free()
	154	* if these functions didn't return NULL.
	155	*/
	156	char tomoyo_realpath_from_path(struct path path)
	157	{
	158	char *buf = tomoyo_alloc(sizeof(struct tomoyo_page_buffer));
	159
	160	BUILD_BUG_ON(sizeof(struct tomoyo_page_buffer)
	161	<= TOMOYO_MAX_PATHNAME_LEN - 1);
	162	if (!buf)
	163	return NULL;
	164	if (tomoyo_realpath_from_path2(path, buf,
	165	TOMOYO_MAX_PATHNAME_LEN - 1) == 0)
	166	return buf;
	167	tomoyo_free(buf);
	168	return NULL;
	169	}
	170
	171	/**
	172	* tomoyo_realpath - Get realpath of a pathname.
	173	*
	174	* @pathname: The pathname to solve.
	175	*
	176	* Returns the realpath of @pathname on success, NULL otherwise.
	177	*/
	178	char tomoyo_realpath(const char pathname)
	179	{
e24977d4	180	struct path path;
c73bd6d4	181
e24977d4 AV	182	if (pathname && kern_path(pathname, LOOKUP_FOLLOW, &path) == 0) {
	183	char *buf = tomoyo_realpath_from_path(&path);
	184	path_put(&path);
c73bd6d4 KT	185	return buf;
	186	}
	187	return NULL;
	188	}
	189
	190	/**
	191	* tomoyo_realpath_nofollow - Get realpath of a pathname.
	192	*
	193	* @pathname: The pathname to solve.
	194	*
	195	* Returns the realpath of @pathname on success, NULL otherwise.
	196	*/
	197	char tomoyo_realpath_nofollow(const char pathname)
	198	{
e24977d4	199	struct path path;
c73bd6d4	200
e24977d4 AV	201	if (pathname && kern_path(pathname, 0, &path) == 0) {
	202	char *buf = tomoyo_realpath_from_path(&path);
	203	path_put(&path);
c73bd6d4 KT	204	return buf;
	205	}
	206	return NULL;
	207	}
	208
	209	/* Memory allocated for non-string data. */
	210	static unsigned int tomoyo_allocated_memory_for_elements;
	211	/* Quota for holding non-string data. */
	212	static unsigned int tomoyo_quota_for_elements;
	213
	214	/**
	215	* tomoyo_alloc_element - Allocate permanent memory for structures.
	216	*
	217	* @size: Size in bytes.
	218	*
	219	* Returns pointer to allocated memory on success, NULL otherwise.
	220	*
	221	* Memory has to be zeroed.
	222	* The RAM is chunked, so NEVER try to kfree() the returned pointer.
	223	*/
	224	void *tomoyo_alloc_element(const unsigned int size)
	225	{
	226	static char *buf;
	227	static DEFINE_MUTEX(lock);
	228	static unsigned int buf_used_len = PATH_MAX;
	229	char *ptr = NULL;
	230	/Assumes sizeof(void ) >= sizeof(long) is true. */
	231	const unsigned int word_aligned_size
	232	= roundup(size, max(sizeof(void *), sizeof(long)));
	233	if (word_aligned_size > PATH_MAX)
	234	return NULL;
c73bd6d4 KT	235	mutex_lock(&lock);
	236	if (buf_used_len + word_aligned_size > PATH_MAX) {
	237	if (!tomoyo_quota_for_elements \|\|
	238	tomoyo_allocated_memory_for_elements
	239	+ PATH_MAX <= tomoyo_quota_for_elements)
	240	ptr = kzalloc(PATH_MAX, GFP_KERNEL);
	241	if (!ptr) {
	242	printk(KERN_WARNING "ERROR: Out of memory "
	243	"for tomoyo_alloc_element().\n");
	244	if (!tomoyo_policy_loaded)
	245	panic("MAC Initialization failed.\n");
	246	} else {
	247	buf = ptr;
	248	tomoyo_allocated_memory_for_elements += PATH_MAX;
	249	buf_used_len = word_aligned_size;
	250	ptr = buf;
	251	}
	252	} else if (word_aligned_size) {
	253	int i;
	254	ptr = buf + buf_used_len;
	255	buf_used_len += word_aligned_size;
	256	for (i = 0; i < word_aligned_size; i++) {
	257	if (!ptr[i])
	258	continue;
	259	printk(KERN_ERR "WARNING: Reserved memory was tainted! "
	260	"The system might go wrong.\n");
	261	ptr[i] = '\0';
	262	}
	263	}
	264	mutex_unlock(&lock);
c73bd6d4 KT	265	return ptr;
	266	}
	267
	268	/* Memory allocated for string data in bytes. */
	269	static unsigned int tomoyo_allocated_memory_for_savename;
	270	/* Quota for holding string data in bytes. */
	271	static unsigned int tomoyo_quota_for_savename;
	272
	273	/*
	274	* TOMOYO uses this hash only when appending a string into the string
	275	* table. Frequency of appending strings is very low. So we don't need
	276	* large (e.g. 64k) hash size. 256 will be sufficient.
	277	*/
024e1a49 SH	278	#define TOMOYO_HASH_BITS 8
024e1a49 SH	279	#define TOMOYO_MAX_HASH (1u<<TOMOYO_HASH_BITS)
c73bd6d4	280
c3fa109a TH	281	/*
	282	* tomoyo_name_entry is a structure which is used for linking
	283	* "struct tomoyo_path_info" into tomoyo_name_list .
	284	*
	285	* Since tomoyo_name_list manages a list of strings which are shared by
	286	* multiple processes (whereas "struct tomoyo_path_info" inside
	287	* "struct tomoyo_path_info_with_data" is not shared), a reference counter will
	288	* be added to "struct tomoyo_name_entry" rather than "struct tomoyo_path_info"
	289	* when TOMOYO starts supporting garbage collector.
	290	*/
c73bd6d4 KT	291	struct tomoyo_name_entry {
	292	struct list_head list;
	293	struct tomoyo_path_info entry;
	294	};
	295
c73bd6d4	296	/*
c3fa109a TH	297	* tomoyo_name_list is used for holding string data used by TOMOYO.
	298	* Since same string data is likely used for multiple times (e.g.
	299	* "/lib/libc-2.5.so"), TOMOYO shares string data in the form of
	300	* "const struct tomoyo_path_info *".
c73bd6d4 KT	301	*/
	302	static struct list_head tomoyo_name_list[TOMOYO_MAX_HASH];
	303
	304	/**
	305	* tomoyo_save_name - Allocate permanent memory for string data.
	306	*
	307	* @name: The string to store into the permernent memory.
	308	*
	309	* Returns pointer to "struct tomoyo_path_info" on success, NULL otherwise.
c73bd6d4 KT	310	*/
	311	const struct tomoyo_path_info tomoyo_save_name(const char name)
	312	{
c73bd6d4 KT	313	static DEFINE_MUTEX(lock);
	314	struct tomoyo_name_entry *ptr;
	315	unsigned int hash;
c73bd6d4	316	int len;
e41035a9	317	int allocated_len;
024e1a49	318	struct list_head *head;
c73bd6d4 KT	319
	320	if (!name)
	321	return NULL;
	322	len = strlen(name) + 1;
c73bd6d4	323	hash = full_name_hash((const unsigned char *) name, len - 1);
024e1a49	324	head = &tomoyo_name_list[hash_long(hash, TOMOYO_HASH_BITS)];
c73bd6d4	325	mutex_lock(&lock);
024e1a49	326	list_for_each_entry(ptr, head, list) {
c73bd6d4 KT	327	if (hash == ptr->entry.hash && !strcmp(name, ptr->entry.name))
	328	goto out;
	329	}
e41035a9 TH	330	ptr = kzalloc(sizeof(*ptr) + len, GFP_KERNEL);
	331	allocated_len = ptr ? ksize(ptr) : 0;
	332	if (!ptr \|\| (tomoyo_quota_for_savename &&
	333	tomoyo_allocated_memory_for_savename + allocated_len
	334	> tomoyo_quota_for_savename)) {
	335	kfree(ptr);
c73bd6d4 KT	336	printk(KERN_WARNING "ERROR: Out of memory "
	337	"for tomoyo_save_name().\n");
	338	if (!tomoyo_policy_loaded)
	339	panic("MAC Initialization failed.\n");
	340	ptr = NULL;
	341	goto out;
	342	}
e41035a9 TH	343	tomoyo_allocated_memory_for_savename += allocated_len;
	344	ptr->entry.name = ((char ) ptr) + sizeof(ptr);
	345	memmove((char *) ptr->entry.name, name, len);
c73bd6d4	346	tomoyo_fill_path_info(&ptr->entry);
024e1a49	347	list_add_tail(&ptr->list, head);
c73bd6d4 KT	348	out:
c73bd6d4 KT	349	mutex_unlock(&lock);
c73bd6d4 KT	350	return ptr ? &ptr->entry : NULL;
	351	}
	352
	353	/**
	354	* tomoyo_realpath_init - Initialize realpath related code.
c73bd6d4	355	*/
1581e7dd	356	void __init tomoyo_realpath_init(void)
c73bd6d4 KT	357	{
	358	int i;
	359
	360	BUILD_BUG_ON(TOMOYO_MAX_PATHNAME_LEN > PATH_MAX);
	361	for (i = 0; i < TOMOYO_MAX_HASH; i++)
	362	INIT_LIST_HEAD(&tomoyo_name_list[i]);
	363	INIT_LIST_HEAD(&tomoyo_kernel_domain.acl_info_list);
	364	tomoyo_kernel_domain.domainname = tomoyo_save_name(TOMOYO_ROOT_NAME);
fdb8ebb7 TH	365	/*
	366	* tomoyo_read_lock() is not needed because this function is
	367	* called before the first "delete" request.
	368	*/
	369	list_add_tail_rcu(&tomoyo_kernel_domain.list, &tomoyo_domain_list);
c73bd6d4 KT	370	if (tomoyo_find_domain(TOMOYO_ROOT_NAME) != &tomoyo_kernel_domain)
c73bd6d4 KT	371	panic("Can't register tomoyo_kernel_domain");
c73bd6d4 KT	372	}
c73bd6d4 KT	373
c73bd6d4 KT	374	/* Memory allocated for temporary purpose. */
	375	static atomic_t tomoyo_dynamic_memory_size;
	376
	377	/**
	378	* tomoyo_alloc - Allocate memory for temporary purpose.
	379	*
	380	* @size: Size in bytes.
	381	*
	382	* Returns pointer to allocated memory on success, NULL otherwise.
	383	*/
	384	void *tomoyo_alloc(const size_t size)
	385	{
	386	void *p = kzalloc(size, GFP_KERNEL);
	387	if (p)
	388	atomic_add(ksize(p), &tomoyo_dynamic_memory_size);
	389	return p;
	390	}
	391
	392	/**
	393	* tomoyo_free - Release memory allocated by tomoyo_alloc().
	394	*
	395	* @p: Pointer returned by tomoyo_alloc(). May be NULL.
	396	*
	397	* Returns nothing.
	398	*/
	399	void tomoyo_free(const void *p)
	400	{
	401	if (p) {
	402	atomic_sub(ksize(p), &tomoyo_dynamic_memory_size);
	403	kfree(p);
	404	}
	405	}
	406
	407	/**
	408	* tomoyo_read_memory_counter - Check for memory usage in bytes.
	409	*
	410	* @head: Pointer to "struct tomoyo_io_buffer".
	411	*
	412	* Returns memory usage.
	413	*/
	414	int tomoyo_read_memory_counter(struct tomoyo_io_buffer *head)
	415	{
	416	if (!head->read_eof) {
	417	const unsigned int shared
	418	= tomoyo_allocated_memory_for_savename;
	419	const unsigned int private
	420	= tomoyo_allocated_memory_for_elements;
	421	const unsigned int dynamic
	422	= atomic_read(&tomoyo_dynamic_memory_size);
	423	char buffer[64];
	424
	425	memset(buffer, 0, sizeof(buffer));
	426	if (tomoyo_quota_for_savename)
	427	snprintf(buffer, sizeof(buffer) - 1,
	428	" (Quota: %10u)",
	429	tomoyo_quota_for_savename);
	430	else
	431	buffer[0] = '\0';
	432	tomoyo_io_printf(head, "Shared: %10u%s\n", shared, buffer);
	433	if (tomoyo_quota_for_elements)
	434	snprintf(buffer, sizeof(buffer) - 1,
	435	" (Quota: %10u)",
	436	tomoyo_quota_for_elements);
	437	else
438	buffer[0] = '\0';
439	tomoyo_io_printf(head, "Private: %10u%s\n", private, buffer);
440	tomoyo_io_printf(head, "Dynamic: %10u\n", dynamic);
441	tomoyo_io_printf(head, "Total: %10u\n",
442	shared + private + dynamic);
443	head->read_eof = true;
444	}
445	return 0;
446	}
447
448	/**
449	* tomoyo_write_memory_quota - Set memory quota.
450	*
451	* @head: Pointer to "struct tomoyo_io_buffer".
452	*
453	* Returns 0.
454	*/
455	int tomoyo_write_memory_quota(struct tomoyo_io_buffer *head)
456	{
457	char *data = head->write_buf;
458	unsigned int size;
459
460	if (sscanf(data, "Shared: %u", &size) == 1)
461	tomoyo_quota_for_savename = size;
462	else if (sscanf(data, "Private: %u", &size) == 1)
463	tomoyo_quota_for_elements = size;
464	return 0;
465	}