[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 "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);
	}
	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_MAX_HASH 256

/* Structure for string data. */
struct tomoyo_name_entry {
	struct list_head list;
	struct tomoyo_path_info entry;
};

/* Structure for available memory region. */
struct tomoyo_free_memory_block_list {
	struct list_head list;
	char *ptr;             /* Pointer to a free area. */
	int len;               /* Length of the area.     */
};

/*
 * The list for "struct tomoyo_name_entry".
 *
 * This list is updated only inside tomoyo_save_name(), thus
 * no global mutex exists.
 */
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.
 *
 * The RAM is shared, so NEVER try to modify or kfree() the returned name.
 */
const struct tomoyo_path_info *tomoyo_save_name(const char *name)
{
	static LIST_HEAD(fmb_list);
	static DEFINE_MUTEX(lock);
	struct tomoyo_name_entry *ptr;
	unsigned int hash;
	/* fmb contains available size in bytes.
	   fmb is removed from the fmb_list when fmb->len becomes 0. */
	struct tomoyo_free_memory_block_list *fmb;
	int len;
	char *cp;

	if (!name)
		return NULL;
	len = strlen(name) + 1;
	if (len > TOMOYO_MAX_PATHNAME_LEN) {
		printk(KERN_WARNING "ERROR: Name too long "
		       "for tomoyo_save_name().\n");
		return NULL;
	}
	hash = full_name_hash((const unsigned char *) name, len - 1);
	mutex_lock(&lock);
	list_for_each_entry(ptr, &tomoyo_name_list[hash % TOMOYO_MAX_HASH],
			     list) {
		if (hash == ptr->entry.hash && !strcmp(name, ptr->entry.name))
			goto out;
	}
	list_for_each_entry(fmb, &fmb_list, list) {
		if (len <= fmb->len)
			goto ready;
	}
	if (!tomoyo_quota_for_savename ||
	    tomoyo_allocated_memory_for_savename + PATH_MAX
	    <= tomoyo_quota_for_savename)
		cp = kzalloc(PATH_MAX, GFP_KERNEL);
	else
		cp = NULL;
	fmb = kzalloc(sizeof(*fmb), GFP_KERNEL);
	if (!cp || !fmb) {
		kfree(cp);
		kfree(fmb);
		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 += PATH_MAX;
	list_add(&fmb->list, &fmb_list);
	fmb->ptr = cp;
	fmb->len = PATH_MAX;
 ready:
	ptr = tomoyo_alloc_element(sizeof(*ptr));
	if (!ptr)
		goto out;
	ptr->entry.name = fmb->ptr;
	memmove(fmb->ptr, name, len);
	tomoyo_fill_path_info(&ptr->entry);
	fmb->ptr += len;
	fmb->len -= len;
	list_add_tail(&ptr->list, &tomoyo_name_list[hash % TOMOYO_MAX_HASH]);
	if (fmb->len == 0) {
		list_del(&fmb->list);
		kfree(fmb);
	}
 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);
	list_add_tail(&tomoyo_kernel_domain.list, &tomoyo_domain_list);
	down_read(&tomoyo_domain_list_lock);
	if (tomoyo_find_domain(TOMOYO_ROOT_NAME) != &tomoyo_kernel_domain)
		panic("Can't register tomoyo_kernel_domain");
	up_read(&tomoyo_domain_list_lock);
}

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