[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"

/**
 * 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 {
		struct path ns_root = {.mnt = NULL, .dentry = NULL};

		spin_lock(&dcache_lock);
		/* go to whatever namespace root we are under */
		sp = __d_path(path, &ns_root, newname, newname_len);
		spin_unlock(&dcache_lock);
		/* Prepend "/proc" prefix if using internal proc vfs mount. */
		if (!IS_ERR(sp) && (path->mnt->mnt_flags & MNT_INTERNAL) &&
		    (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 kzalloc(), so the caller must call kfree()
 * if these functions didn't return NULL.
 */
char *tomoyo_realpath_from_path(struct path *path)
{
	char *buf = kzalloc(sizeof(struct tomoyo_page_buffer), GFP_NOFS);

	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;
	kfree(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 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.
 *
 * Caller holds tomoyo_policy_lock.
 * Memory pointed by @ptr will be zeroed on success.
 */
bool tomoyo_memory_ok(void *ptr)
{
	int allocated_len = ptr ? ksize(ptr) : 0;
	atomic_add(allocated_len, &tomoyo_policy_memory_size);
	if (ptr && (!tomoyo_quota_for_policy ||
		    atomic_read(&tomoyo_policy_memory_size)
		    <= tomoyo_quota_for_policy)) {
		memset(ptr, 0, allocated_len);
		return true;
	}
	printk(KERN_WARNING "ERROR: Out of memory "
	       "for tomoyo_alloc_element().\n");
	if (!tomoyo_policy_loaded)
		panic("MAC Initialization failed.\n");
	return false;
}

/**
 * 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_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];
/* Lock for protecting tomoyo_name_list . */
DEFINE_MUTEX(tomoyo_name_list_lock);

/**
 * 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_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(&tomoyo_name_list_lock);
	list_for_each_entry(ptr, head, list) {
		if (hash != ptr->entry.hash || strcmp(name, ptr->entry.name))
			continue;
		atomic_inc(&ptr->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);
		printk(KERN_WARNING "ERROR: Out of memory "
		       "for tomoyo_get_name().\n");
		if (!tomoyo_policy_loaded)
			panic("MAC Initialization failed.\n");
		ptr = NULL;
		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->users, 1);
	tomoyo_fill_path_info(&ptr->entry);
	list_add_tail(&ptr->list, head);
 out:
	mutex_unlock(&tomoyo_name_list_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_get_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");
}

/**
 * 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 policy
			= atomic_read(&tomoyo_policy_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);
		tomoyo_io_printf(head, "Total:   %10u\n", policy);
		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, "Policy: %u", &size) == 1)
		tomoyo_quota_for_policy = 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>
c73bd6d4	18	#include "common.h"
c73bd6d4 KT	19
	20	/**
	21	* tomoyo_encode: Convert binary string to ascii string.
	22	*
	23	* @buffer: Buffer for ASCII string.
	24	* @buflen: Size of @buffer.
	25	* @str: Binary string.
	26	*
	27	* Returns 0 on success, -ENOMEM otherwise.
	28	*/
	29	int tomoyo_encode(char buffer, int buflen, const char str)
	30	{
	31	while (1) {
	32	const unsigned char c = (unsigned char ) str++;
	33
	34	if (tomoyo_is_valid(c)) {
	35	if (--buflen <= 0)
	36	break;
	37	*buffer++ = (char) c;
	38	if (c != '\\')
	39	continue;
	40	if (--buflen <= 0)
	41	break;
	42	*buffer++ = (char) c;
	43	continue;
	44	}
	45	if (!c) {
	46	if (--buflen <= 0)
	47	break;
	48	*buffer = '\0';
	49	return 0;
	50	}
	51	buflen -= 4;
	52	if (buflen <= 0)
	53	break;
	54	*buffer++ = '\\';
	55	*buffer++ = (c >> 6) + '0';
	56	*buffer++ = ((c >> 3) & 7) + '0';
	57	*buffer++ = (c & 7) + '0';
	58	}
	59	return -ENOMEM;
	60	}
	61
	62	/**
	63	* tomoyo_realpath_from_path2 - Returns realpath(3) of the given dentry but ignores chroot'ed root.
	64	*
	65	* @path: Pointer to "struct path".
	66	* @newname: Pointer to buffer to return value in.
	67	* @newname_len: Size of @newname.
	68	*
	69	* Returns 0 on success, negative value otherwise.
	70	*
	71	* If dentry is a directory, trailing '/' is appended.
	72	* Characters out of 0x20 < c < 0x7F range are converted to
	73	* \ooo style octal string.
	74	* Character \ is converted to \\ string.
	75	*/
	76	int tomoyo_realpath_from_path2(struct path path, char newname,
	77	int newname_len)
	78	{
	79	int error = -ENOMEM;
	80	struct dentry *dentry = path->dentry;
	81	char *sp;
	82
83	if (!dentry \|\| !path->mnt \|\| !newname \|\| newname_len <= 2048)
84	return -EINVAL;
85	if (dentry->d_op && dentry->d_op->d_dname) {
86	/* For "socket:[\$]" and "pipe:[\$]". */
87	static const int offset = 1536;
88	sp = dentry->d_op->d_dname(dentry, newname + offset,
89	newname_len - offset);
90	} else {
37afdc79	91	struct path ns_root = {.mnt = NULL, .dentry = NULL};
c73bd6d4	92
c73bd6d4	93	spin_lock(&dcache_lock);
37afdc79 AV	94	/* go to whatever namespace root we are under */
37afdc79 AV	95	sp = __d_path(path, &ns_root, newname, newname_len);
c73bd6d4	96	spin_unlock(&dcache_lock);
a4054b6b	97	/* Prepend "/proc" prefix if using internal proc vfs mount. */
440b3c6c	98	if (!IS_ERR(sp) && (path->mnt->mnt_flags & MNT_INTERNAL) &&
67fa4880	99	(path->mnt->mnt_sb->s_magic == PROC_SUPER_MAGIC)) {
a4054b6b EB	100	sp -= 5;
	101	if (sp >= newname)
	102	memcpy(sp, "/proc", 5);
	103	else
	104	sp = ERR_PTR(-ENOMEM);
	105	}
c73bd6d4 KT	106	}
	107	if (IS_ERR(sp))
	108	error = PTR_ERR(sp);
	109	else
	110	error = tomoyo_encode(newname, sp - newname, sp);
	111	/* Append trailing '/' if dentry is a directory. */
	112	if (!error && dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode)
	113	&& *newname) {
	114	sp = newname + strlen(newname);
	115	if (*(sp - 1) != '/') {
	116	if (sp < newname + newname_len - 4) {
	117	*sp++ = '/';
	118	*sp = '\0';
	119	} else {
	120	error = -ENOMEM;
	121	}
	122	}
	123	}
	124	if (error)
	125	printk(KERN_WARNING "tomoyo_realpath: Pathname too long.\n");
	126	return error;
	127	}
	128
	129	/**
	130	* tomoyo_realpath_from_path - Returns realpath(3) of the given pathname but ignores chroot'ed root.
	131	*
	132	* @path: Pointer to "struct path".
	133	*
	134	* Returns the realpath of the given @path on success, NULL otherwise.
	135	*
8e2d39a1	136	* These functions use kzalloc(), so the caller must call kfree()
c73bd6d4 KT	137	* if these functions didn't return NULL.
	138	*/
	139	char tomoyo_realpath_from_path(struct path path)
	140	{
4e5d6f7e	141	char *buf = kzalloc(sizeof(struct tomoyo_page_buffer), GFP_NOFS);
c73bd6d4 KT	142
	143	BUILD_BUG_ON(sizeof(struct tomoyo_page_buffer)
	144	<= TOMOYO_MAX_PATHNAME_LEN - 1);
	145	if (!buf)
	146	return NULL;
	147	if (tomoyo_realpath_from_path2(path, buf,
	148	TOMOYO_MAX_PATHNAME_LEN - 1) == 0)
	149	return buf;
8e2d39a1	150	kfree(buf);
c73bd6d4 KT	151	return NULL;
	152	}
	153
	154	/**
	155	* tomoyo_realpath - Get realpath of a pathname.
	156	*
	157	* @pathname: The pathname to solve.
	158	*
	159	* Returns the realpath of @pathname on success, NULL otherwise.
	160	*/
	161	char tomoyo_realpath(const char pathname)
	162	{
e24977d4	163	struct path path;
c73bd6d4	164
e24977d4 AV	165	if (pathname && kern_path(pathname, LOOKUP_FOLLOW, &path) == 0) {
	166	char *buf = tomoyo_realpath_from_path(&path);
	167	path_put(&path);
c73bd6d4 KT	168	return buf;
	169	}
	170	return NULL;
	171	}
	172
	173	/**
	174	* tomoyo_realpath_nofollow - Get realpath of a pathname.
	175	*
	176	* @pathname: The pathname to solve.
	177	*
	178	* Returns the realpath of @pathname on success, NULL otherwise.
	179	*/
	180	char tomoyo_realpath_nofollow(const char pathname)
	181	{
e24977d4	182	struct path path;
c73bd6d4	183
e24977d4 AV	184	if (pathname && kern_path(pathname, 0, &path) == 0) {
	185	char *buf = tomoyo_realpath_from_path(&path);
	186	path_put(&path);
c73bd6d4 KT	187	return buf;
	188	}
	189	return NULL;
	190	}
	191
	192	/* Memory allocated for non-string data. */
847b173e TH	193	static atomic_t tomoyo_policy_memory_size;
	194	/* Quota for holding policy. */
	195	static unsigned int tomoyo_quota_for_policy;
c73bd6d4 KT	196
c73bd6d4 KT	197	/**
cd7bec6a	198	* tomoyo_memory_ok - Check memory quota.
c73bd6d4	199	*
cd7bec6a	200	* @ptr: Pointer to allocated memory.
c73bd6d4	201	*
cd7bec6a	202	* Returns true on success, false otherwise.
c73bd6d4	203	*
cd7bec6a TH	204	* Caller holds tomoyo_policy_lock.
cd7bec6a TH	205	* Memory pointed by @ptr will be zeroed on success.
c73bd6d4	206	*/
cd7bec6a	207	bool tomoyo_memory_ok(void *ptr)
c73bd6d4	208	{
cd7bec6a	209	int allocated_len = ptr ? ksize(ptr) : 0;
847b173e TH	210	atomic_add(allocated_len, &tomoyo_policy_memory_size);
	211	if (ptr && (!tomoyo_quota_for_policy \|\|
	212	atomic_read(&tomoyo_policy_memory_size)
	213	<= tomoyo_quota_for_policy)) {
cd7bec6a	214	memset(ptr, 0, allocated_len);
847b173e	215	return true;
c73bd6d4	216	}
847b173e TH	217	printk(KERN_WARNING "ERROR: Out of memory "
	218	"for tomoyo_alloc_element().\n");
	219	if (!tomoyo_policy_loaded)
	220	panic("MAC Initialization failed.\n");
	221	return false;
c73bd6d4 KT	222	}
c73bd6d4 KT	223
847b173e TH	224	/**
	225	* tomoyo_memory_free - Free memory for elements.
	226	*
	227	* @ptr: Pointer to allocated memory.
	228	*/
	229	void tomoyo_memory_free(void *ptr)
	230	{
	231	atomic_sub(ksize(ptr), &tomoyo_policy_memory_size);
	232	kfree(ptr);
	233	}
c73bd6d4	234
c73bd6d4	235	/*
c3fa109a TH	236	* tomoyo_name_list is used for holding string data used by TOMOYO.
	237	* Since same string data is likely used for multiple times (e.g.
	238	* "/lib/libc-2.5.so"), TOMOYO shares string data in the form of
	239	* "const struct tomoyo_path_info *".
c73bd6d4	240	*/
847b173e TH	241	struct list_head tomoyo_name_list[TOMOYO_MAX_HASH];
	242	/* Lock for protecting tomoyo_name_list . */
	243	DEFINE_MUTEX(tomoyo_name_list_lock);
c73bd6d4 KT	244
c73bd6d4 KT	245	/**
bf24fb01	246	* tomoyo_get_name - Allocate permanent memory for string data.
c73bd6d4 KT	247	*
	248	* @name: The string to store into the permernent memory.
	249	*
	250	* Returns pointer to "struct tomoyo_path_info" on success, NULL otherwise.
c73bd6d4	251	*/
bf24fb01	252	const struct tomoyo_path_info tomoyo_get_name(const char name)
c73bd6d4	253	{
c73bd6d4 KT	254	struct tomoyo_name_entry *ptr;
c73bd6d4 KT	255	unsigned int hash;
c73bd6d4	256	int len;
e41035a9	257	int allocated_len;
024e1a49	258	struct list_head *head;
c73bd6d4 KT	259
	260	if (!name)
	261	return NULL;
	262	len = strlen(name) + 1;
c73bd6d4	263	hash = full_name_hash((const unsigned char *) name, len - 1);
024e1a49	264	head = &tomoyo_name_list[hash_long(hash, TOMOYO_HASH_BITS)];
847b173e	265	mutex_lock(&tomoyo_name_list_lock);
024e1a49	266	list_for_each_entry(ptr, head, list) {
bf24fb01 TH	267	if (hash != ptr->entry.hash \|\| strcmp(name, ptr->entry.name))
	268	continue;
	269	atomic_inc(&ptr->users);
	270	goto out;
c73bd6d4	271	}
4e5d6f7e	272	ptr = kzalloc(sizeof(*ptr) + len, GFP_NOFS);
e41035a9	273	allocated_len = ptr ? ksize(ptr) : 0;
847b173e TH	274	if (!ptr \|\| (tomoyo_quota_for_policy &&
	275	atomic_read(&tomoyo_policy_memory_size) + allocated_len
	276	> tomoyo_quota_for_policy)) {
e41035a9	277	kfree(ptr);
c73bd6d4	278	printk(KERN_WARNING "ERROR: Out of memory "
bf24fb01	279	"for tomoyo_get_name().\n");
c73bd6d4 KT	280	if (!tomoyo_policy_loaded)
	281	panic("MAC Initialization failed.\n");
	282	ptr = NULL;
	283	goto out;
	284	}
847b173e	285	atomic_add(allocated_len, &tomoyo_policy_memory_size);
e41035a9 TH	286	ptr->entry.name = ((char ) ptr) + sizeof(ptr);
e41035a9 TH	287	memmove((char *) ptr->entry.name, name, len);
bf24fb01	288	atomic_set(&ptr->users, 1);
c73bd6d4	289	tomoyo_fill_path_info(&ptr->entry);
024e1a49	290	list_add_tail(&ptr->list, head);
c73bd6d4	291	out:
847b173e	292	mutex_unlock(&tomoyo_name_list_lock);
c73bd6d4 KT	293	return ptr ? &ptr->entry : NULL;
	294	}
	295
	296	/**
	297	* tomoyo_realpath_init - Initialize realpath related code.
c73bd6d4	298	*/
1581e7dd	299	void __init tomoyo_realpath_init(void)
c73bd6d4 KT	300	{
	301	int i;
	302
	303	BUILD_BUG_ON(TOMOYO_MAX_PATHNAME_LEN > PATH_MAX);
	304	for (i = 0; i < TOMOYO_MAX_HASH; i++)
	305	INIT_LIST_HEAD(&tomoyo_name_list[i]);
	306	INIT_LIST_HEAD(&tomoyo_kernel_domain.acl_info_list);
bf24fb01	307	tomoyo_kernel_domain.domainname = tomoyo_get_name(TOMOYO_ROOT_NAME);
fdb8ebb7 TH	308	/*
	309	* tomoyo_read_lock() is not needed because this function is
	310	* called before the first "delete" request.
	311	*/
	312	list_add_tail_rcu(&tomoyo_kernel_domain.list, &tomoyo_domain_list);
c73bd6d4 KT	313	if (tomoyo_find_domain(TOMOYO_ROOT_NAME) != &tomoyo_kernel_domain)
c73bd6d4 KT	314	panic("Can't register tomoyo_kernel_domain");
c73bd6d4 KT	315	}
c73bd6d4 KT	316
c73bd6d4 KT	317	/**
	318	* tomoyo_read_memory_counter - Check for memory usage in bytes.
	319	*
	320	* @head: Pointer to "struct tomoyo_io_buffer".
	321	*
	322	* Returns memory usage.
	323	*/
	324	int tomoyo_read_memory_counter(struct tomoyo_io_buffer *head)
	325	{
	326	if (!head->read_eof) {
847b173e TH	327	const unsigned int policy
847b173e TH	328	= atomic_read(&tomoyo_policy_memory_size);
c73bd6d4 KT	329	char buffer[64];
	330
	331	memset(buffer, 0, sizeof(buffer));
847b173e	332	if (tomoyo_quota_for_policy)
c73bd6d4 KT	333	snprintf(buffer, sizeof(buffer) - 1,
c73bd6d4 KT	334	" (Quota: %10u)",
847b173e	335	tomoyo_quota_for_policy);
c73bd6d4 KT	336	else
c73bd6d4 KT	337	buffer[0] = '\0';
847b173e TH	338	tomoyo_io_printf(head, "Policy: %10u%s\n", policy, buffer);
847b173e TH	339	tomoyo_io_printf(head, "Total: %10u\n", policy);
c73bd6d4 KT	340	head->read_eof = true;
	341	}
	342	return 0;
	343	}
	344
	345	/**
	346	* tomoyo_write_memory_quota - Set memory quota.
	347	*
	348	* @head: Pointer to "struct tomoyo_io_buffer".
	349	*
	350	* Returns 0.
	351	*/
	352	int tomoyo_write_memory_quota(struct tomoyo_io_buffer *head)
	353	{
	354	char *data = head->write_buf;
	355	unsigned int size;
	356
847b173e TH	357	if (sscanf(data, "Policy: %u", &size) == 1)
847b173e TH	358	tomoyo_quota_for_policy = size;
c73bd6d4 KT	359	return 0;
c73bd6d4 KT	360	}