Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 0f2a55d5bb2372058275b0b343d90dd5d640d045

Authored by Tetsuo Handa 2011-07-14 13:46:51 +0800

Committed by James Morris 2011-07-14 15:50:03 +0800

1 parent c920669345

Exists in master and in 6 other branches

TOMOYO: Update kernel-doc.

Update comments for scripts/kernel-doc and fix some of errors reported by
scripts/checkpatch.pl .

Signed-off-by: Tetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp>
Signed-off-by: James Morris <jmorris@namei.org>

Showing 13 changed files with 269 additions and 62 deletions Inline Diff

security/tomoyo/audit.c
security/tomoyo/common.c
security/tomoyo/domain.c
security/tomoyo/file.c
security/tomoyo/gc.c
security/tomoyo/group.c
security/tomoyo/load_policy.c
security/tomoyo/memory.c
security/tomoyo/mount.c
security/tomoyo/realpath.c
security/tomoyo/securityfs_if.c
security/tomoyo/tomoyo.c
security/tomoyo/util.c

security/tomoyo/audit.c

Diff comments View file @ 0f2a55d

 /*
  * security/tomoyo/audit.c
  *
- * Pathname restriction functions.
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
  */
 #include "common.h"
 #include <linux/slab.h>
 /**
  * tomoyo_print_bprm - Print "struct linux_binprm" for auditing.
  *
  * @bprm: Pointer to "struct linux_binprm".
  * @dump: Pointer to "struct tomoyo_page_dump".
  *
  * Returns the contents of @bprm on success, NULL otherwise.
  *
  * This function uses kzalloc(), so caller must kfree() if this function
  * didn't return NULL.
  */
 static char *tomoyo_print_bprm(struct linux_binprm *bprm,
 			       struct tomoyo_page_dump *dump)
 {
 	static const int tomoyo_buffer_len = 4096 * 2;
 	char *buffer = kzalloc(tomoyo_buffer_len, GFP_NOFS);
 	char *cp;
 	char *last_start;
 	int len;
 	unsigned long pos = bprm->p;
 	int offset = pos % PAGE_SIZE;
 	int argv_count = bprm->argc;
 	int envp_count = bprm->envc;
 	bool truncated = false;
 	if (!buffer)
 		return NULL;
 	len = snprintf(buffer, tomoyo_buffer_len - 1, "argv[]={ ");
 	cp = buffer + len;
 	if (!argv_count) {
 		memmove(cp, "} envp[]={ ", 11);
 		cp += 11;
 	}
 	last_start = cp;
 	while (argv_count || envp_count) {
 		if (!tomoyo_dump_page(bprm, pos, dump))
 			goto out;
 		pos += PAGE_SIZE - offset;
 		/* Read. */
 		while (offset < PAGE_SIZE) {
 			const char *kaddr = dump->data;
 			const unsigned char c = kaddr[offset++];
 			if (cp == last_start)
 				*cp++ = '"';
 			if (cp >= buffer + tomoyo_buffer_len - 32) {
 				/* Reserve some room for "..." string. */
 				truncated = true;
 			} else if (c == '\\') {
 				*cp++ = '\\';
 				*cp++ = '\\';
 			} else if (c > ' ' && c < 127) {
 				*cp++ = c;
 			} else if (!c) {
 				*cp++ = '"';
 				*cp++ = ' ';
 				last_start = cp;
 			} else {
 				*cp++ = '\\';
 				*cp++ = (c >> 6) + '0';
 				*cp++ = ((c >> 3) & 7) + '0';
 				*cp++ = (c & 7) + '0';
 			}
 			if (c)
 				continue;
 			if (argv_count) {
 				if (--argv_count == 0) {
 					if (truncated) {
 						cp = last_start;
 						memmove(cp, "... ", 4);
 						cp += 4;
 					}
 					memmove(cp, "} envp[]={ ", 11);
 					cp += 11;
 					last_start = cp;
 					truncated = false;
 				}
 			} else if (envp_count) {
 				if (--envp_count == 0) {
 					if (truncated) {
 						cp = last_start;
 						memmove(cp, "... ", 4);
 						cp += 4;
 					}
 				}
 			}
 			if (!argv_count && !envp_count)
 				break;
 		}
 		offset = 0;
 	}
 	*cp++ = '}';
 	*cp = '\0';
 	return buffer;
 out:
 	snprintf(buffer, tomoyo_buffer_len - 1,
 		 "argv[]={ ... } envp[]= { ... }");
 	return buffer;
 }
 /**
  * tomoyo_filetype - Get string representation of file type.
  *
  * @mode: Mode value for stat().
  *
  * Returns file type string.
  */
 static inline const char *tomoyo_filetype(const mode_t mode)
 {
 	switch (mode & S_IFMT) {
 	case S_IFREG:
 	case 0:
 		return tomoyo_condition_keyword[TOMOYO_TYPE_IS_FILE];
 	case S_IFDIR:
 		return tomoyo_condition_keyword[TOMOYO_TYPE_IS_DIRECTORY];
 	case S_IFLNK:
 		return tomoyo_condition_keyword[TOMOYO_TYPE_IS_SYMLINK];
 	case S_IFIFO:
 		return tomoyo_condition_keyword[TOMOYO_TYPE_IS_FIFO];
 	case S_IFSOCK:
 		return tomoyo_condition_keyword[TOMOYO_TYPE_IS_SOCKET];
 	case S_IFBLK:
 		return tomoyo_condition_keyword[TOMOYO_TYPE_IS_BLOCK_DEV];
 	case S_IFCHR:
 		return tomoyo_condition_keyword[TOMOYO_TYPE_IS_CHAR_DEV];
 	}
 	return "unknown"; /* This should not happen. */
 }
 /**
  * tomoyo_print_header - Get header line of audit log.
  *
  * @r: Pointer to "struct tomoyo_request_info".
  *
  * Returns string representation.
  *
  * This function uses kmalloc(), so caller must kfree() if this function
  * didn't return NULL.
  */
 static char *tomoyo_print_header(struct tomoyo_request_info *r)
 {
 	struct tomoyo_time stamp;
 	const pid_t gpid = task_pid_nr(current);
 	struct tomoyo_obj_info *obj = r->obj;
 	static const int tomoyo_buffer_len = 4096;
 	char *buffer = kmalloc(tomoyo_buffer_len, GFP_NOFS);
 	int pos;
 	u8 i;
 	if (!buffer)
 		return NULL;
 	{
 		struct timeval tv;
 		do_gettimeofday(&tv);
 		tomoyo_convert_time(tv.tv_sec, &stamp);
 	}
 	pos = snprintf(buffer, tomoyo_buffer_len - 1,
 		       "#%04u/%02u/%02u %02u:%02u:%02u# profile=%u mode=%s "
 		       "granted=%s (global-pid=%u) task={ pid=%u ppid=%u "
 		       "uid=%u gid=%u euid=%u egid=%u suid=%u sgid=%u "
 		       "fsuid=%u fsgid=%u }", stamp.year, stamp.month,
 		       stamp.day, stamp.hour, stamp.min, stamp.sec, r->profile,
 		       tomoyo_mode[r->mode], tomoyo_yesno(r->granted), gpid,
 		       tomoyo_sys_getpid(), tomoyo_sys_getppid(),
 		       current_uid(), current_gid(), current_euid(),
 		       current_egid(), current_suid(), current_sgid(),
 		       current_fsuid(), current_fsgid());
 	if (!obj)
 		goto no_obj_info;
 	if (!obj->validate_done) {
 		tomoyo_get_attributes(obj);
 		obj->validate_done = true;
 	}
 	for (i = 0; i < TOMOYO_MAX_PATH_STAT; i++) {
 		struct tomoyo_mini_stat *stat;
 		unsigned int dev;
 		mode_t mode;
 		if (!obj->stat_valid[i])
 			continue;
 		stat = &obj->stat[i];
 		dev = stat->dev;
 		mode = stat->mode;
 		if (i & 1) {
 			pos += snprintf(buffer + pos,
 					tomoyo_buffer_len - 1 - pos,
 					" path%u.parent={ uid=%u gid=%u "
 					"ino=%lu perm=0%o }", (i >> 1) + 1,
 					stat->uid, stat->gid, (unsigned long)
 					stat->ino, stat->mode & S_IALLUGO);
 			continue;
 		}
 		pos += snprintf(buffer + pos, tomoyo_buffer_len - 1 - pos,
 				" path%u={ uid=%u gid=%u ino=%lu major=%u"
 				" minor=%u perm=0%o type=%s", (i >> 1) + 1,
 				stat->uid, stat->gid, (unsigned long)
 				stat->ino, MAJOR(dev), MINOR(dev),
 				mode & S_IALLUGO, tomoyo_filetype(mode));
 		if (S_ISCHR(mode) || S_ISBLK(mode)) {
 			dev = stat->rdev;
 			pos += snprintf(buffer + pos,
 					tomoyo_buffer_len - 1 - pos,
 					" dev_major=%u dev_minor=%u",
 					MAJOR(dev), MINOR(dev));
 		}
 		pos += snprintf(buffer + pos, tomoyo_buffer_len - 1 - pos,
 				" }");
 	}
 no_obj_info:
 	if (pos < tomoyo_buffer_len - 1)
 		return buffer;
 	kfree(buffer);
 	return NULL;
 }
 /**
  * tomoyo_init_log - Allocate buffer for audit logs.
  *
  * @r:    Pointer to "struct tomoyo_request_info".
  * @len:  Buffer size needed for @fmt and @args.
  * @fmt:  The printf()'s format string.
  * @args: va_list structure for @fmt.
  *
  * Returns pointer to allocated memory.
  *
  * This function uses kzalloc(), so caller must kfree() if this function
  * didn't return NULL.
  */
 char *tomoyo_init_log(struct tomoyo_request_info *r, int len, const char *fmt,
 		      va_list args)
 {
 	char *buf = NULL;
 	char *bprm_info = NULL;
 	const char *header = NULL;
 	char *realpath = NULL;
 	const char *symlink = NULL;
 	int pos;
 	const char *domainname = r->domain->domainname->name;
 	header = tomoyo_print_header(r);
 	if (!header)
 		return NULL;
 	/* +10 is for '\n' etc. and '\0'. */
 	len += strlen(domainname) + strlen(header) + 10;
 	if (r->ee) {
 		struct file *file = r->ee->bprm->file;
 		realpath = tomoyo_realpath_from_path(&file->f_path);
 		bprm_info = tomoyo_print_bprm(r->ee->bprm, &r->ee->dump);
 		if (!realpath || !bprm_info)
 			goto out;
 		/* +80 is for " exec={ realpath=\"%s\" argc=%d envc=%d %s }" */
 		len += strlen(realpath) + 80 + strlen(bprm_info);
 	} else if (r->obj && r->obj->symlink_target) {
 		symlink = r->obj->symlink_target->name;
 		/* +18 is for " symlink.target=\"%s\"" */
 		len += 18 + strlen(symlink);
 	}
 	len = tomoyo_round2(len);
 	buf = kzalloc(len, GFP_NOFS);
 	if (!buf)
 		goto out;
 	len--;
 	pos = snprintf(buf, len, "%s", header);
 	if (realpath) {
 		struct linux_binprm *bprm = r->ee->bprm;
 		pos += snprintf(buf + pos, len - pos,
 				" exec={ realpath=\"%s\" argc=%d envc=%d %s }",
 				realpath, bprm->argc, bprm->envc, bprm_info);
 	} else if (symlink)
 		pos += snprintf(buf + pos, len - pos, " symlink.target=\"%s\"",
 				symlink);
 	pos += snprintf(buf + pos, len - pos, "\n%s\n", domainname);
 	vsnprintf(buf + pos, len - pos, fmt, args);
 out:
 	kfree(realpath);
 	kfree(bprm_info);
 	kfree(header);
 	return buf;
 }
 /* Wait queue for /sys/kernel/security/tomoyo/audit. */
 static DECLARE_WAIT_QUEUE_HEAD(tomoyo_log_wait);
 /* Structure for audit log. */
 struct tomoyo_log {
 	struct list_head list;
 	char *log;
 	int size;
 };
 /* The list for "struct tomoyo_log". */
 static LIST_HEAD(tomoyo_log);
 /* Lock for "struct list_head tomoyo_log". */
 static DEFINE_SPINLOCK(tomoyo_log_lock);
 /* Length of "stuct list_head tomoyo_log". */
 static unsigned int tomoyo_log_count;
 /**
  * tomoyo_get_audit - Get audit mode.
  *
  * @ns:          Pointer to "struct tomoyo_policy_namespace".
  * @profile:     Profile number.
  * @index:       Index number of functionality.
  * @is_granted:  True if granted log, false otherwise.
  *
  * Returns true if this request should be audited, false otherwise.
  */
 static bool tomoyo_get_audit(const struct tomoyo_policy_namespace *ns,
 			     const u8 profile, const u8 index,
 			     const bool is_granted)
 {
 	u8 mode;
 	const u8 category = tomoyo_index2category[index] +
 		TOMOYO_MAX_MAC_INDEX;
 	struct tomoyo_profile *p;
 	if (!tomoyo_policy_loaded)
 		return false;
 	p = tomoyo_profile(ns, profile);
 	if (tomoyo_log_count >= p->pref[TOMOYO_PREF_MAX_AUDIT_LOG])
 		return false;
 	mode = p->config[index];
 	if (mode == TOMOYO_CONFIG_USE_DEFAULT)
 		mode = p->config[category];
 	if (mode == TOMOYO_CONFIG_USE_DEFAULT)
 		mode = p->default_config;
 	if (is_granted)
 		return mode & TOMOYO_CONFIG_WANT_GRANT_LOG;
 	return mode & TOMOYO_CONFIG_WANT_REJECT_LOG;
 }
 /**
  * tomoyo_write_log2 - Write an audit log.
  *
  * @r:    Pointer to "struct tomoyo_request_info".
  * @len:  Buffer size needed for @fmt and @args.
  * @fmt:  The printf()'s format string.
  * @args: va_list structure for @fmt.
  *
  * Returns nothing.
  */
 void tomoyo_write_log2(struct tomoyo_request_info *r, int len, const char *fmt,
 		       va_list args)
 {
 	char *buf;
 	struct tomoyo_log *entry;
 	bool quota_exceeded = false;
 	if (!tomoyo_get_audit(r->domain->ns, r->profile, r->type, r->granted))
 		goto out;
 	buf = tomoyo_init_log(r, len, fmt, args);
 	if (!buf)
 		goto out;
 	entry = kzalloc(sizeof(*entry), GFP_NOFS);
 	if (!entry) {
 		kfree(buf);
 		goto out;
 	}
 	entry->log = buf;
 	len = tomoyo_round2(strlen(buf) + 1);
 	/*
 	 * The entry->size is used for memory quota checks.
 	 * Don't go beyond strlen(entry->log).
 	 */
 	entry->size = len + tomoyo_round2(sizeof(*entry));
 	spin_lock(&tomoyo_log_lock);
 	if (tomoyo_memory_quota[TOMOYO_MEMORY_AUDIT] &&
 	    tomoyo_memory_used[TOMOYO_MEMORY_AUDIT] + entry->size >=
 	    tomoyo_memory_quota[TOMOYO_MEMORY_AUDIT]) {
 		quota_exceeded = true;
 	} else {
 		tomoyo_memory_used[TOMOYO_MEMORY_AUDIT] += entry->size;
 		list_add_tail(&entry->list, &tomoyo_log);
 		tomoyo_log_count++;
 	}
 	spin_unlock(&tomoyo_log_lock);
 	if (quota_exceeded) {
 		kfree(buf);
 		kfree(entry);
 		goto out;
 	}
 	wake_up(&tomoyo_log_wait);
 out:
 	return;
 }
 /**
  * tomoyo_write_log - Write an audit log.
  *
  * @r:   Pointer to "struct tomoyo_request_info".
  * @fmt: The printf()'s format string, followed by parameters.
  *
  * Returns nothing.
  */
 void tomoyo_write_log(struct tomoyo_request_info *r, const char *fmt, ...)
 {
 	va_list args;
 	int len;
 	va_start(args, fmt);
 	len = vsnprintf((char *) &len, 1, fmt, args) + 1;
 	va_end(args);
 	va_start(args, fmt);
 	tomoyo_write_log2(r, len, fmt, args);
 	va_end(args);
 }
 /**
  * tomoyo_read_log - Read an audit log.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns nothing.
  */
 void tomoyo_read_log(struct tomoyo_io_buffer *head)
 {
 	struct tomoyo_log *ptr = NULL;
 	if (head->r.w_pos)
 		return;
 	kfree(head->read_buf);
 	head->read_buf = NULL;
 	spin_lock(&tomoyo_log_lock);
 	if (!list_empty(&tomoyo_log)) {
 		ptr = list_entry(tomoyo_log.next, typeof(*ptr), list);
 		list_del(&ptr->list);
 		tomoyo_log_count--;
 		tomoyo_memory_used[TOMOYO_MEMORY_AUDIT] -= ptr->size;
 	}
 	spin_unlock(&tomoyo_log_lock);
 	if (ptr) {
 		head->read_buf = ptr->log;
 		head->r.w[head->r.w_pos++] = head->read_buf;
 		kfree(ptr);
 	}
 }
 /**
  * tomoyo_poll_log - Wait for an audit log.
  *
  * @file: Pointer to "struct file".
  * @wait: Pointer to "poll_table".
  *
  * Returns POLLIN | POLLRDNORM when ready to read an audit log.
  */
 int tomoyo_poll_log(struct file *file, poll_table *wait)
 {
 	if (tomoyo_log_count)
 		return POLLIN | POLLRDNORM;
 	poll_wait(file, &tomoyo_log_wait, wait);
 	if (tomoyo_log_count)
 		return POLLIN | POLLRDNORM;
 	return 0;
 }

security/tomoyo/common.c

Diff comments View file @ 0f2a55d

 /*
  * security/tomoyo/common.c
  *
- * Common functions for TOMOYO.
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
  */
 #include <linux/uaccess.h>
 #include <linux/slab.h>
 #include <linux/security.h>
 #include "common.h"
 /* String table for operation mode. */
 const char * const tomoyo_mode[TOMOYO_CONFIG_MAX_MODE] = {
 	[TOMOYO_CONFIG_DISABLED]   = "disabled",
 	[TOMOYO_CONFIG_LEARNING]   = "learning",
 	[TOMOYO_CONFIG_PERMISSIVE] = "permissive",
 	[TOMOYO_CONFIG_ENFORCING]  = "enforcing"
 };
 /* String table for /sys/kernel/security/tomoyo/profile */
 const char * const tomoyo_mac_keywords[TOMOYO_MAX_MAC_INDEX
 				       + TOMOYO_MAX_MAC_CATEGORY_INDEX] = {
 	[TOMOYO_MAC_FILE_EXECUTE]    = "execute",
 	[TOMOYO_MAC_FILE_OPEN]       = "open",
 	[TOMOYO_MAC_FILE_CREATE]     = "create",
 	[TOMOYO_MAC_FILE_UNLINK]     = "unlink",
 	[TOMOYO_MAC_FILE_GETATTR]    = "getattr",
 	[TOMOYO_MAC_FILE_MKDIR]      = "mkdir",
 	[TOMOYO_MAC_FILE_RMDIR]      = "rmdir",
 	[TOMOYO_MAC_FILE_MKFIFO]     = "mkfifo",
 	[TOMOYO_MAC_FILE_MKSOCK]     = "mksock",
 	[TOMOYO_MAC_FILE_TRUNCATE]   = "truncate",
 	[TOMOYO_MAC_FILE_SYMLINK]    = "symlink",
 	[TOMOYO_MAC_FILE_MKBLOCK]    = "mkblock",
 	[TOMOYO_MAC_FILE_MKCHAR]     = "mkchar",
 	[TOMOYO_MAC_FILE_LINK]       = "link",
 	[TOMOYO_MAC_FILE_RENAME]     = "rename",
 	[TOMOYO_MAC_FILE_CHMOD]      = "chmod",
 	[TOMOYO_MAC_FILE_CHOWN]      = "chown",
 	[TOMOYO_MAC_FILE_CHGRP]      = "chgrp",
 	[TOMOYO_MAC_FILE_IOCTL]      = "ioctl",
 	[TOMOYO_MAC_FILE_CHROOT]     = "chroot",
 	[TOMOYO_MAC_FILE_MOUNT]      = "mount",
 	[TOMOYO_MAC_FILE_UMOUNT]     = "unmount",
 	[TOMOYO_MAC_FILE_PIVOT_ROOT] = "pivot_root",
 	[TOMOYO_MAX_MAC_INDEX + TOMOYO_MAC_CATEGORY_FILE] = "file",
 };
 /* String table for conditions. */
 const char * const tomoyo_condition_keyword[TOMOYO_MAX_CONDITION_KEYWORD] = {
 	[TOMOYO_TASK_UID]             = "task.uid",
 	[TOMOYO_TASK_EUID]            = "task.euid",
 	[TOMOYO_TASK_SUID]            = "task.suid",
 	[TOMOYO_TASK_FSUID]           = "task.fsuid",
 	[TOMOYO_TASK_GID]             = "task.gid",
 	[TOMOYO_TASK_EGID]            = "task.egid",
 	[TOMOYO_TASK_SGID]            = "task.sgid",
 	[TOMOYO_TASK_FSGID]           = "task.fsgid",
 	[TOMOYO_TASK_PID]             = "task.pid",
 	[TOMOYO_TASK_PPID]            = "task.ppid",
 	[TOMOYO_EXEC_ARGC]            = "exec.argc",
 	[TOMOYO_EXEC_ENVC]            = "exec.envc",
 	[TOMOYO_TYPE_IS_SOCKET]       = "socket",
 	[TOMOYO_TYPE_IS_SYMLINK]      = "symlink",
 	[TOMOYO_TYPE_IS_FILE]         = "file",
 	[TOMOYO_TYPE_IS_BLOCK_DEV]    = "block",
 	[TOMOYO_TYPE_IS_DIRECTORY]    = "directory",
 	[TOMOYO_TYPE_IS_CHAR_DEV]     = "char",
 	[TOMOYO_TYPE_IS_FIFO]         = "fifo",
 	[TOMOYO_MODE_SETUID]          = "setuid",
 	[TOMOYO_MODE_SETGID]          = "setgid",
 	[TOMOYO_MODE_STICKY]          = "sticky",
 	[TOMOYO_MODE_OWNER_READ]      = "owner_read",
 	[TOMOYO_MODE_OWNER_WRITE]     = "owner_write",
 	[TOMOYO_MODE_OWNER_EXECUTE]   = "owner_execute",
 	[TOMOYO_MODE_GROUP_READ]      = "group_read",
 	[TOMOYO_MODE_GROUP_WRITE]     = "group_write",
 	[TOMOYO_MODE_GROUP_EXECUTE]   = "group_execute",
 	[TOMOYO_MODE_OTHERS_READ]     = "others_read",
 	[TOMOYO_MODE_OTHERS_WRITE]    = "others_write",
 	[TOMOYO_MODE_OTHERS_EXECUTE]  = "others_execute",
 	[TOMOYO_EXEC_REALPATH]        = "exec.realpath",
 	[TOMOYO_SYMLINK_TARGET]       = "symlink.target",
 	[TOMOYO_PATH1_UID]            = "path1.uid",
 	[TOMOYO_PATH1_GID]            = "path1.gid",
 	[TOMOYO_PATH1_INO]            = "path1.ino",
 	[TOMOYO_PATH1_MAJOR]          = "path1.major",
 	[TOMOYO_PATH1_MINOR]          = "path1.minor",
 	[TOMOYO_PATH1_PERM]           = "path1.perm",
 	[TOMOYO_PATH1_TYPE]           = "path1.type",
 	[TOMOYO_PATH1_DEV_MAJOR]      = "path1.dev_major",
 	[TOMOYO_PATH1_DEV_MINOR]      = "path1.dev_minor",
 	[TOMOYO_PATH2_UID]            = "path2.uid",
 	[TOMOYO_PATH2_GID]            = "path2.gid",
 	[TOMOYO_PATH2_INO]            = "path2.ino",
 	[TOMOYO_PATH2_MAJOR]          = "path2.major",
 	[TOMOYO_PATH2_MINOR]          = "path2.minor",
 	[TOMOYO_PATH2_PERM]           = "path2.perm",
 	[TOMOYO_PATH2_TYPE]           = "path2.type",
 	[TOMOYO_PATH2_DEV_MAJOR]      = "path2.dev_major",
 	[TOMOYO_PATH2_DEV_MINOR]      = "path2.dev_minor",
 	[TOMOYO_PATH1_PARENT_UID]     = "path1.parent.uid",
 	[TOMOYO_PATH1_PARENT_GID]     = "path1.parent.gid",
 	[TOMOYO_PATH1_PARENT_INO]     = "path1.parent.ino",
 	[TOMOYO_PATH1_PARENT_PERM]    = "path1.parent.perm",
 	[TOMOYO_PATH2_PARENT_UID]     = "path2.parent.uid",
 	[TOMOYO_PATH2_PARENT_GID]     = "path2.parent.gid",
 	[TOMOYO_PATH2_PARENT_INO]     = "path2.parent.ino",
 	[TOMOYO_PATH2_PARENT_PERM]    = "path2.parent.perm",
 };
 /* String table for PREFERENCE keyword. */
 static const char * const tomoyo_pref_keywords[TOMOYO_MAX_PREF] = {
 	[TOMOYO_PREF_MAX_AUDIT_LOG]      = "max_audit_log",
 	[TOMOYO_PREF_MAX_LEARNING_ENTRY] = "max_learning_entry",
 };
 /* String table for path operation. */
 const char * const tomoyo_path_keyword[TOMOYO_MAX_PATH_OPERATION] = {
 	[TOMOYO_TYPE_EXECUTE]    = "execute",
 	[TOMOYO_TYPE_READ]       = "read",
 	[TOMOYO_TYPE_WRITE]      = "write",
 	[TOMOYO_TYPE_APPEND]     = "append",
 	[TOMOYO_TYPE_UNLINK]     = "unlink",
 	[TOMOYO_TYPE_GETATTR]    = "getattr",
 	[TOMOYO_TYPE_RMDIR]      = "rmdir",
 	[TOMOYO_TYPE_TRUNCATE]   = "truncate",
 	[TOMOYO_TYPE_SYMLINK]    = "symlink",
 	[TOMOYO_TYPE_CHROOT]     = "chroot",
 	[TOMOYO_TYPE_UMOUNT]     = "unmount",
 };
 /* String table for categories. */
 static const char * const tomoyo_category_keywords
 [TOMOYO_MAX_MAC_CATEGORY_INDEX] = {
 	[TOMOYO_MAC_CATEGORY_FILE]       = "file",
 };
 /* Permit policy management by non-root user? */
 static bool tomoyo_manage_by_non_root;
 /* Utility functions. */
 /**
  * tomoyo_yesno - Return "yes" or "no".
  *
  * @value: Bool value.
  */
 const char *tomoyo_yesno(const unsigned int value)
 {
 	return value ? "yes" : "no";
 }
 /**
  * tomoyo_addprintf - strncat()-like-snprintf().
  *
  * @buffer: Buffer to write to. Must be '\0'-terminated.
  * @len:    Size of @buffer.
  * @fmt:    The printf()'s format string, followed by parameters.
  *
  * Returns nothing.
  */
 static void tomoyo_addprintf(char *buffer, int len, const char *fmt, ...)
 {
 	va_list args;
 	const int pos = strlen(buffer);
 	va_start(args, fmt);
 	vsnprintf(buffer + pos, len - pos - 1, fmt, args);
 	va_end(args);
 }
 /**
  * tomoyo_flush - Flush queued string to userspace's buffer.
  *
  * @head:   Pointer to "struct tomoyo_io_buffer".
  *
  * Returns true if all data was flushed, false otherwise.
  */
 static bool tomoyo_flush(struct tomoyo_io_buffer *head)
 {
 	while (head->r.w_pos) {
 		const char *w = head->r.w[0];
 		size_t len = strlen(w);
 		if (len) {
 			if (len > head->read_user_buf_avail)
 				len = head->read_user_buf_avail;
 			if (!len)
 				return false;
 			if (copy_to_user(head->read_user_buf, w, len))
 				return false;
 			head->read_user_buf_avail -= len;
 			head->read_user_buf += len;
 			w += len;
 		}
 		head->r.w[0] = w;
 		if (*w)
 			return false;
 		/* Add '\0' for audit logs and query. */
 		if (head->poll) {
 			if (!head->read_user_buf_avail ||
 			    copy_to_user(head->read_user_buf, "", 1))
 				return false;
 			head->read_user_buf_avail--;
 			head->read_user_buf++;
 		}
 		head->r.w_pos--;
 		for (len = 0; len < head->r.w_pos; len++)
 			head->r.w[len] = head->r.w[len + 1];
 	}
 	head->r.avail = 0;
 	return true;
 }
 /**
  * tomoyo_set_string - Queue string to "struct tomoyo_io_buffer" structure.
  *
  * @head:   Pointer to "struct tomoyo_io_buffer".
  * @string: String to print.
  *
  * Note that @string has to be kept valid until @head is kfree()d.
  * This means that char[] allocated on stack memory cannot be passed to
  * this function. Use tomoyo_io_printf() for char[] allocated on stack memory.
  */
 static void tomoyo_set_string(struct tomoyo_io_buffer *head, const char *string)
 {
 	if (head->r.w_pos < TOMOYO_MAX_IO_READ_QUEUE) {
 		head->r.w[head->r.w_pos++] = string;
 		tomoyo_flush(head);
 	} else
 		WARN_ON(1);
 }
 /**
  * tomoyo_io_printf - printf() to "struct tomoyo_io_buffer" structure.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  * @fmt:  The printf()'s format string, followed by parameters.
  */
 void tomoyo_io_printf(struct tomoyo_io_buffer *head, const char *fmt, ...)
 {
 	va_list args;
 	size_t len;
 	size_t pos = head->r.avail;
 	int size = head->readbuf_size - pos;
 	if (size <= 0)
 		return;
 	va_start(args, fmt);
 	len = vsnprintf(head->read_buf + pos, size, fmt, args) + 1;
 	va_end(args);
 	if (pos + len >= head->readbuf_size) {
 		WARN_ON(1);
 		return;
 	}
 	head->r.avail += len;
 	tomoyo_set_string(head, head->read_buf + pos);
 }
 /**
  * tomoyo_set_space - Put a space to "struct tomoyo_io_buffer" structure.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns nothing.
  */
 static void tomoyo_set_space(struct tomoyo_io_buffer *head)
 {
 	tomoyo_set_string(head, " ");
 }
 /**
  * tomoyo_set_lf - Put a line feed to "struct tomoyo_io_buffer" structure.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns nothing.
  */
 static bool tomoyo_set_lf(struct tomoyo_io_buffer *head)
 {
 	tomoyo_set_string(head, "\n");
 	return !head->r.w_pos;
 }
 /**
  * tomoyo_set_slash - Put a shash to "struct tomoyo_io_buffer" structure.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns nothing.
  */
 static void tomoyo_set_slash(struct tomoyo_io_buffer *head)
 {
 	tomoyo_set_string(head, "/");
 }
 /* List of namespaces. */
 LIST_HEAD(tomoyo_namespace_list);
 /* True if namespace other than tomoyo_kernel_namespace is defined. */
 static bool tomoyo_namespace_enabled;
 /**
  * tomoyo_init_policy_namespace - Initialize namespace.
  *
  * @ns: Pointer to "struct tomoyo_policy_namespace".
  *
  * Returns nothing.
  */
 void tomoyo_init_policy_namespace(struct tomoyo_policy_namespace *ns)
 {
 	unsigned int idx;
 	for (idx = 0; idx < TOMOYO_MAX_ACL_GROUPS; idx++)
 		INIT_LIST_HEAD(&ns->acl_group[idx]);
 	for (idx = 0; idx < TOMOYO_MAX_GROUP; idx++)
 		INIT_LIST_HEAD(&ns->group_list[idx]);
 	for (idx = 0; idx < TOMOYO_MAX_POLICY; idx++)
 		INIT_LIST_HEAD(&ns->policy_list[idx]);
 	ns->profile_version = 20100903;
 	tomoyo_namespace_enabled = !list_empty(&tomoyo_namespace_list);
 	list_add_tail_rcu(&ns->namespace_list, &tomoyo_namespace_list);
 }
 /**
  * tomoyo_print_namespace - Print namespace header.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns nothing.
  */
 static void tomoyo_print_namespace(struct tomoyo_io_buffer *head)
 {
 	if (!tomoyo_namespace_enabled)
 		return;
 	tomoyo_set_string(head,
 			  container_of(head->r.ns,
 				       struct tomoyo_policy_namespace,
 				       namespace_list)->name);
 	tomoyo_set_space(head);
 }
 /**
  * tomoyo_print_name_union - Print a tomoyo_name_union.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  * @ptr:  Pointer to "struct tomoyo_name_union".
  */
 static void tomoyo_print_name_union(struct tomoyo_io_buffer *head,
 				    const struct tomoyo_name_union *ptr)
 {
 	tomoyo_set_space(head);
 	if (ptr->group) {
 		tomoyo_set_string(head, "@");
 		tomoyo_set_string(head, ptr->group->group_name->name);
 	} else {
 		tomoyo_set_string(head, ptr->filename->name);
 	}
 }
 /**
  * tomoyo_print_name_union_quoted - Print a tomoyo_name_union with a quote.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  * @ptr:  Pointer to "struct tomoyo_name_union".
  *
  * Returns nothing.
  */
 static void tomoyo_print_name_union_quoted(struct tomoyo_io_buffer *head,
 					   const struct tomoyo_name_union *ptr)
 {
 	if (ptr->group) {
 		tomoyo_set_string(head, "@");
 		tomoyo_set_string(head, ptr->group->group_name->name);
 	} else {
 		tomoyo_set_string(head, "\"");
 		tomoyo_set_string(head, ptr->filename->name);
 		tomoyo_set_string(head, "\"");
 	}
 }
 /**
  * tomoyo_print_number_union_nospace - Print a tomoyo_number_union without a space.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  * @ptr:  Pointer to "struct tomoyo_number_union".
  *
  * Returns nothing.
  */
 static void tomoyo_print_number_union_nospace
 (struct tomoyo_io_buffer *head, const struct tomoyo_number_union *ptr)
 {
 	if (ptr->group) {
 		tomoyo_set_string(head, "@");
 		tomoyo_set_string(head, ptr->group->group_name->name);
 	} else {
 		int i;
 		unsigned long min = ptr->values[0];
 		const unsigned long max = ptr->values[1];
 		u8 min_type = ptr->value_type[0];
 		const u8 max_type = ptr->value_type[1];
 		char buffer[128];
 		buffer[0] = '\0';
 		for (i = 0; i < 2; i++) {
 			switch (min_type) {
 			case TOMOYO_VALUE_TYPE_HEXADECIMAL:
 				tomoyo_addprintf(buffer, sizeof(buffer),
 						 "0x%lX", min);
 				break;
 			case TOMOYO_VALUE_TYPE_OCTAL:
 				tomoyo_addprintf(buffer, sizeof(buffer),
 						 "0%lo", min);
 				break;
 			default:
 				tomoyo_addprintf(buffer, sizeof(buffer), "%lu",
 						 min);
 				break;
 			}
 			if (min == max && min_type == max_type)
 				break;
 			tomoyo_addprintf(buffer, sizeof(buffer), "-");
 			min_type = max_type;
 			min = max;
 		}
 		tomoyo_io_printf(head, "%s", buffer);
 	}
 }
 /**
  * tomoyo_print_number_union - Print a tomoyo_number_union.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  * @ptr:  Pointer to "struct tomoyo_number_union".
  *
  * Returns nothing.
  */
 static void tomoyo_print_number_union(struct tomoyo_io_buffer *head,
 				      const struct tomoyo_number_union *ptr)
 {
 	tomoyo_set_space(head);
 	tomoyo_print_number_union_nospace(head, ptr);
 }
 /**
  * tomoyo_assign_profile - Create a new profile.
  *
  * @ns:      Pointer to "struct tomoyo_policy_namespace".
  * @profile: Profile number to create.
  *
  * Returns pointer to "struct tomoyo_profile" on success, NULL otherwise.
  */
 static struct tomoyo_profile *tomoyo_assign_profile
 (struct tomoyo_policy_namespace *ns, const unsigned int profile)
 {
 	struct tomoyo_profile *ptr;
 	struct tomoyo_profile *entry;
 	if (profile >= TOMOYO_MAX_PROFILES)
 		return NULL;
 	ptr = ns->profile_ptr[profile];
 	if (ptr)
 		return ptr;
 	entry = kzalloc(sizeof(*entry), GFP_NOFS);
 	if (mutex_lock_interruptible(&tomoyo_policy_lock))
 		goto out;
 	ptr = ns->profile_ptr[profile];
 	if (!ptr && tomoyo_memory_ok(entry)) {
 		ptr = entry;
 		ptr->default_config = TOMOYO_CONFIG_DISABLED |
 			TOMOYO_CONFIG_WANT_GRANT_LOG |
 			TOMOYO_CONFIG_WANT_REJECT_LOG;
 		memset(ptr->config, TOMOYO_CONFIG_USE_DEFAULT,
 		       sizeof(ptr->config));
 		ptr->pref[TOMOYO_PREF_MAX_AUDIT_LOG] = 1024;
 		ptr->pref[TOMOYO_PREF_MAX_LEARNING_ENTRY] = 2048;
 		mb(); /* Avoid out-of-order execution. */
 		ns->profile_ptr[profile] = ptr;
 		entry = NULL;
 	}
 	mutex_unlock(&tomoyo_policy_lock);
  out:
 	kfree(entry);
 	return ptr;
 }
 /**
  * tomoyo_profile - Find a profile.
  *
  * @ns:      Pointer to "struct tomoyo_policy_namespace".
  * @profile: Profile number to find.
  *
  * Returns pointer to "struct tomoyo_profile".
  */
 struct tomoyo_profile *tomoyo_profile(const struct tomoyo_policy_namespace *ns,
 				      const u8 profile)
 {
 	static struct tomoyo_profile tomoyo_null_profile;
 	struct tomoyo_profile *ptr = ns->profile_ptr[profile];
 	if (!ptr)
 		ptr = &tomoyo_null_profile;
 	return ptr;
 }
 /**
  * tomoyo_find_yesno - Find values for specified keyword.
  *
  * @string: String to check.
  * @find:   Name of keyword.
  *
  * Returns 1 if "@find=yes" was found, 0 if "@find=no" was found, -1 otherwise.
  */
 static s8 tomoyo_find_yesno(const char *string, const char *find)
 {
 	const char *cp = strstr(string, find);
 	if (cp) {
 		cp += strlen(find);
 		if (!strncmp(cp, "=yes", 4))
 			return 1;
 		else if (!strncmp(cp, "=no", 3))
 			return 0;
 	}
 	return -1;
 }
 /**
  * tomoyo_set_uint - Set value for specified preference.
  *
  * @i:      Pointer to "unsigned int".
  * @string: String to check.
  * @find:   Name of keyword.
  *
  * Returns nothing.
  */
 static void tomoyo_set_uint(unsigned int *i, const char *string,
 			    const char *find)
 {
 	const char *cp = strstr(string, find);
 	if (cp)
 		sscanf(cp + strlen(find), "=%u", i);
 }
 /**
  * tomoyo_set_mode - Set mode for specified profile.
  *
  * @name:    Name of functionality.
  * @value:   Mode for @name.
  * @profile: Pointer to "struct tomoyo_profile".
  *
  * Returns 0 on success, negative value otherwise.
  */
 static int tomoyo_set_mode(char *name, const char *value,
 			   struct tomoyo_profile *profile)
 {
 	u8 i;
 	u8 config;
 	if (!strcmp(name, "CONFIG")) {
 		i = TOMOYO_MAX_MAC_INDEX + TOMOYO_MAX_MAC_CATEGORY_INDEX;
 		config = profile->default_config;
 	} else if (tomoyo_str_starts(&name, "CONFIG::")) {
 		config = 0;
 		for (i = 0; i < TOMOYO_MAX_MAC_INDEX
 			     + TOMOYO_MAX_MAC_CATEGORY_INDEX; i++) {
 			int len = 0;
 			if (i < TOMOYO_MAX_MAC_INDEX) {
 				const u8 c = tomoyo_index2category[i];
 				const char *category =
 					tomoyo_category_keywords[c];
 				len = strlen(category);
 				if (strncmp(name, category, len) ||
 				    name[len++] != ':' || name[len++] != ':')
 					continue;
 			}
 			if (strcmp(name + len, tomoyo_mac_keywords[i]))
 				continue;
 			config = profile->config[i];
 			break;
 		}
 		if (i == TOMOYO_MAX_MAC_INDEX + TOMOYO_MAX_MAC_CATEGORY_INDEX)
 			return -EINVAL;
 	} else {
 		return -EINVAL;
 	}
 	if (strstr(value, "use_default")) {
 		config = TOMOYO_CONFIG_USE_DEFAULT;
 	} else {
 		u8 mode;
 		for (mode = 0; mode < 4; mode++)
 			if (strstr(value, tomoyo_mode[mode]))
 				/*
 				 * Update lower 3 bits in order to distinguish
 				 * 'config' from 'TOMOYO_CONFIG_USE_DEAFULT'.
 				 */
 				config = (config & ~7) | mode;
 		if (config != TOMOYO_CONFIG_USE_DEFAULT) {
 			switch (tomoyo_find_yesno(value, "grant_log")) {
 			case 1:
 				config |= TOMOYO_CONFIG_WANT_GRANT_LOG;
 				break;
 			case 0:
 				config &= ~TOMOYO_CONFIG_WANT_GRANT_LOG;
 				break;
 			}
 			switch (tomoyo_find_yesno(value, "reject_log")) {
 			case 1:
 				config |= TOMOYO_CONFIG_WANT_REJECT_LOG;
 				break;
 			case 0:
 				config &= ~TOMOYO_CONFIG_WANT_REJECT_LOG;
 				break;
 			}
 		}
 	}
 	if (i < TOMOYO_MAX_MAC_INDEX + TOMOYO_MAX_MAC_CATEGORY_INDEX)
 		profile->config[i] = config;
 	else if (config != TOMOYO_CONFIG_USE_DEFAULT)
 		profile->default_config = config;
 	return 0;
 }
 /**
  * tomoyo_write_profile - Write profile table.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns 0 on success, negative value otherwise.
  */
 static int tomoyo_write_profile(struct tomoyo_io_buffer *head)
 {
 	char *data = head->write_buf;
 	unsigned int i;
 	char *cp;
 	struct tomoyo_profile *profile;
 	if (sscanf(data, "PROFILE_VERSION=%u", &head->w.ns->profile_version)
 	    == 1)
 		return 0;
 	i = simple_strtoul(data, &cp, 10);
 	if (*cp != '-')
 		return -EINVAL;
 	data = cp + 1;
 	profile = tomoyo_assign_profile(head->w.ns, i);
 	if (!profile)
 		return -EINVAL;
 	cp = strchr(data, '=');
 	if (!cp)
 		return -EINVAL;
 	*cp++ = '\0';
 	if (!strcmp(data, "COMMENT")) {
 		static DEFINE_SPINLOCK(lock);
 		const struct tomoyo_path_info *new_comment
 			= tomoyo_get_name(cp);
 		const struct tomoyo_path_info *old_comment;
 		if (!new_comment)
 			return -ENOMEM;
 		spin_lock(&lock);
 		old_comment = profile->comment;
 		profile->comment = new_comment;
 		spin_unlock(&lock);
 		tomoyo_put_name(old_comment);
 		return 0;
 	}
 	if (!strcmp(data, "PREFERENCE")) {
 		for (i = 0; i < TOMOYO_MAX_PREF; i++)
 			tomoyo_set_uint(&profile->pref[i], cp,
 					tomoyo_pref_keywords[i]);
 		return 0;
 	}
 	return tomoyo_set_mode(data, cp, profile);
 }
 /**
  * tomoyo_print_config - Print mode for specified functionality.
  *
  * @head:   Pointer to "struct tomoyo_io_buffer".
  * @config: Mode for that functionality.
  *
  * Returns nothing.
  *
  * Caller prints functionality's name.
  */
 static void tomoyo_print_config(struct tomoyo_io_buffer *head, const u8 config)
 {
 	tomoyo_io_printf(head, "={ mode=%s grant_log=%s reject_log=%s }\n",
 			 tomoyo_mode[config & 3],
 			 tomoyo_yesno(config & TOMOYO_CONFIG_WANT_GRANT_LOG),
 			 tomoyo_yesno(config & TOMOYO_CONFIG_WANT_REJECT_LOG));
 }
 /**
  * tomoyo_read_profile - Read profile table.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns nothing.
  */
 static void tomoyo_read_profile(struct tomoyo_io_buffer *head)
 {
 	u8 index;
 	struct tomoyo_policy_namespace *ns =
 		container_of(head->r.ns, typeof(*ns), namespace_list);
 	const struct tomoyo_profile *profile;
 	if (head->r.eof)
 		return;
  next:
 	index = head->r.index;
 	profile = ns->profile_ptr[index];
 	switch (head->r.step) {
 	case 0:
 		tomoyo_print_namespace(head);
 		tomoyo_io_printf(head, "PROFILE_VERSION=%u\n",
 				 ns->profile_version);
 		head->r.step++;
 		break;
 	case 1:
 		for ( ; head->r.index < TOMOYO_MAX_PROFILES;
 		      head->r.index++)
 			if (ns->profile_ptr[head->r.index])
 				break;
 		if (head->r.index == TOMOYO_MAX_PROFILES)
 			return;
 		head->r.step++;
 		break;
 	case 2:
 		{
 			u8 i;
 			const struct tomoyo_path_info *comment =
 				profile->comment;
 			tomoyo_print_namespace(head);
 			tomoyo_io_printf(head, "%u-COMMENT=", index);
 			tomoyo_set_string(head, comment ? comment->name : "");
 			tomoyo_set_lf(head);
 			tomoyo_io_printf(head, "%u-PREFERENCE={ ", index);
 			for (i = 0; i < TOMOYO_MAX_PREF; i++)
 				tomoyo_io_printf(head, "%s=%u ",
 						 tomoyo_pref_keywords[i],
 						 profile->pref[i]);
 			tomoyo_set_string(head, "}\n");
 			head->r.step++;
 		}
 		break;
 	case 3:
 		{
 			tomoyo_print_namespace(head);
 			tomoyo_io_printf(head, "%u-%s", index, "CONFIG");
 			tomoyo_print_config(head, profile->default_config);
 			head->r.bit = 0;
 			head->r.step++;
 		}
 		break;
 	case 4:
 		for ( ; head->r.bit < TOMOYO_MAX_MAC_INDEX
 			      + TOMOYO_MAX_MAC_CATEGORY_INDEX; head->r.bit++) {
 			const u8 i = head->r.bit;
 			const u8 config = profile->config[i];
 			if (config == TOMOYO_CONFIG_USE_DEFAULT)
 				continue;
 			tomoyo_print_namespace(head);
 			if (i < TOMOYO_MAX_MAC_INDEX)
 				tomoyo_io_printf(head, "%u-CONFIG::%s::%s",
 						 index,
 						 tomoyo_category_keywords
 						 [tomoyo_index2category[i]],
 						 tomoyo_mac_keywords[i]);
 			else
 				tomoyo_io_printf(head, "%u-CONFIG::%s", index,
 						 tomoyo_mac_keywords[i]);
 			tomoyo_print_config(head, config);
 			head->r.bit++;
 			break;
 		}
 		if (head->r.bit == TOMOYO_MAX_MAC_INDEX
 		    + TOMOYO_MAX_MAC_CATEGORY_INDEX) {
 			head->r.index++;
 			head->r.step = 1;
 		}
 		break;
 	}
 	if (tomoyo_flush(head))
 		goto next;
 }
+/**
+ * tomoyo_same_manager - Check for duplicated "struct tomoyo_manager" entry.
+ *
+ * @a: Pointer to "struct tomoyo_acl_head".
+ * @b: Pointer to "struct tomoyo_acl_head".
+ *
+ * Returns true if @a == @b, false otherwise.
+ */
 static bool tomoyo_same_manager(const struct tomoyo_acl_head *a,
 				const struct tomoyo_acl_head *b)
 {
 	return container_of(a, struct tomoyo_manager, head)->manager ==
 		container_of(b, struct tomoyo_manager, head)->manager;
 }
 /**
  * tomoyo_update_manager_entry - Add a manager entry.
  *
  * @manager:   The path to manager or the domainnamme.
  * @is_delete: True if it is a delete request.
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static int tomoyo_update_manager_entry(const char *manager,
 				       const bool is_delete)
 {
 	struct tomoyo_manager e = { };
 	struct tomoyo_acl_param param = {
 		/* .ns = &tomoyo_kernel_namespace, */
 		.is_delete = is_delete,
 		.list = &tomoyo_kernel_namespace.
 		policy_list[TOMOYO_ID_MANAGER],
 	};
 	int error = is_delete ? -ENOENT : -ENOMEM;
 	if (tomoyo_domain_def(manager)) {
 		if (!tomoyo_correct_domain(manager))
 			return -EINVAL;
 		e.is_domain = true;
 	} else {
 		if (!tomoyo_correct_path(manager))
 			return -EINVAL;
 	}
 	e.manager = tomoyo_get_name(manager);
 	if (e.manager) {
 		error = tomoyo_update_policy(&e.head, sizeof(e), &param,
 					     tomoyo_same_manager);
 		tomoyo_put_name(e.manager);
 	}
 	return error;
 }
 /**
  * tomoyo_write_manager - Write manager policy.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static int tomoyo_write_manager(struct tomoyo_io_buffer *head)
 {
 	char *data = head->write_buf;
 	if (!strcmp(data, "manage_by_non_root")) {
 		tomoyo_manage_by_non_root = !head->w.is_delete;
 		return 0;
 	}
 	return tomoyo_update_manager_entry(data, head->w.is_delete);
 }
 /**
  * tomoyo_read_manager - Read manager policy.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Caller holds tomoyo_read_lock().
  */
 static void tomoyo_read_manager(struct tomoyo_io_buffer *head)
 {
 	if (head->r.eof)
 		return;
 	list_for_each_cookie(head->r.acl, &tomoyo_kernel_namespace.
 			     policy_list[TOMOYO_ID_MANAGER]) {
 		struct tomoyo_manager *ptr =
 			list_entry(head->r.acl, typeof(*ptr), head.list);
 		if (ptr->head.is_deleted)
 			continue;
 		if (!tomoyo_flush(head))
 			return;
 		tomoyo_set_string(head, ptr->manager->name);
 		tomoyo_set_lf(head);
 	}
 	head->r.eof = true;
 }
 /**
  * tomoyo_manager - Check whether the current process is a policy manager.
  *
  * Returns true if the current process is permitted to modify policy
  * via /sys/kernel/security/tomoyo/ interface.
  *
  * Caller holds tomoyo_read_lock().
  */
 static bool tomoyo_manager(void)
 {
 	struct tomoyo_manager *ptr;
 	const char *exe;
 	const struct task_struct *task = current;
 	const struct tomoyo_path_info *domainname = tomoyo_domain()->domainname;
 	bool found = false;
 	if (!tomoyo_policy_loaded)
 		return true;
 	if (!tomoyo_manage_by_non_root && (task->cred->uid || task->cred->euid))
 		return false;
 	list_for_each_entry_rcu(ptr, &tomoyo_kernel_namespace.
 				policy_list[TOMOYO_ID_MANAGER], head.list) {
 		if (!ptr->head.is_deleted && ptr->is_domain
 		    && !tomoyo_pathcmp(domainname, ptr->manager)) {
 			found = true;
 			break;
 		}
 	}
 	if (found)
 		return true;
 	exe = tomoyo_get_exe();
 	if (!exe)
 		return false;
 	list_for_each_entry_rcu(ptr, &tomoyo_kernel_namespace.
 				policy_list[TOMOYO_ID_MANAGER], head.list) {
 		if (!ptr->head.is_deleted && !ptr->is_domain
 		    && !strcmp(exe, ptr->manager->name)) {
 			found = true;
 			break;
 		}
 	}
 	if (!found) { /* Reduce error messages. */
 		static pid_t last_pid;
 		const pid_t pid = current->pid;
 		if (last_pid != pid) {
 			printk(KERN_WARNING "%s ( %s ) is not permitted to "
 			       "update policies.\n", domainname->name, exe);
 			last_pid = pid;
 		}
 	}
 	kfree(exe);
 	return found;
 }
 /**
  * tomoyo_select_domain - Parse select command.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  * @data: String to parse.
  *
  * Returns true on success, false otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static bool tomoyo_select_domain(struct tomoyo_io_buffer *head,
 				 const char *data)
 {
 	unsigned int pid;
 	struct tomoyo_domain_info *domain = NULL;
 	bool global_pid = false;
 	if (strncmp(data, "select ", 7))
 		return false;
 	data += 7;
 	if (sscanf(data, "pid=%u", &pid) == 1 ||
 	    (global_pid = true, sscanf(data, "global-pid=%u", &pid) == 1)) {
 		struct task_struct *p;
 		rcu_read_lock();
 		read_lock(&tasklist_lock);
 		if (global_pid)
 			p = find_task_by_pid_ns(pid, &init_pid_ns);
 		else
 			p = find_task_by_vpid(pid);
 		if (p)
 			domain = tomoyo_real_domain(p);
 		read_unlock(&tasklist_lock);
 		rcu_read_unlock();
 	} else if (!strncmp(data, "domain=", 7)) {
 		if (tomoyo_domain_def(data + 7))
 			domain = tomoyo_find_domain(data + 7);
 	} else
 		return false;
 	head->w.domain = domain;
 	/* Accessing read_buf is safe because head->io_sem is held. */
 	if (!head->read_buf)
 		return true; /* Do nothing if open(O_WRONLY). */
 	memset(&head->r, 0, sizeof(head->r));
 	head->r.print_this_domain_only = true;
 	if (domain)
 		head->r.domain = &domain->list;
 	else
 		head->r.eof = 1;
 	tomoyo_io_printf(head, "# select %s\n", data);
 	if (domain && domain->is_deleted)
 		tomoyo_io_printf(head, "# This is a deleted domain.\n");
 	return true;
 }
 /**
  * tomoyo_delete_domain - Delete a domain.
  *
  * @domainname: The name of domain.
  *
  * Returns 0.
  *
  * Caller holds tomoyo_read_lock().
  */
 static int tomoyo_delete_domain(char *domainname)
 {
 	struct tomoyo_domain_info *domain;
 	struct tomoyo_path_info name;
 	name.name = domainname;
 	tomoyo_fill_path_info(&name);
 	if (mutex_lock_interruptible(&tomoyo_policy_lock))
 		return 0;
 	/* Is there an active domain? */
 	list_for_each_entry_rcu(domain, &tomoyo_domain_list, list) {
 		/* Never delete tomoyo_kernel_domain */
 		if (domain == &tomoyo_kernel_domain)
 			continue;
 		if (domain->is_deleted ||
 		    tomoyo_pathcmp(domain->domainname, &name))
 			continue;
 		domain->is_deleted = true;
 		break;
 	}
 	mutex_unlock(&tomoyo_policy_lock);
 	return 0;
 }
 /**
  * tomoyo_write_domain2 - Write domain policy.
  *
  * @ns:        Pointer to "struct tomoyo_policy_namespace".
  * @list:      Pointer to "struct list_head".
  * @data:      Policy to be interpreted.
  * @is_delete: True if it is a delete request.
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static int tomoyo_write_domain2(struct tomoyo_policy_namespace *ns,
 				struct list_head *list, char *data,
 				const bool is_delete)
 {
 	struct tomoyo_acl_param param = {
 		.ns = ns,
 		.list = list,
 		.data = data,
 		.is_delete = is_delete,
 	};
 	static const struct {
 		const char *keyword;
 		int (*write) (struct tomoyo_acl_param *);
 	} tomoyo_callback[1] = {
 		{ "file ", tomoyo_write_file },
 	};
 	u8 i;
 	for (i = 0; i < 1; i++) {
 		if (!tomoyo_str_starts(&param.data,
 				       tomoyo_callback[i].keyword))
 			continue;
 		return tomoyo_callback[i].write(&param);
 	}
 	return -EINVAL;
 }
 /* String table for domain flags. */
 const char * const tomoyo_dif[TOMOYO_MAX_DOMAIN_INFO_FLAGS] = {
 	[TOMOYO_DIF_QUOTA_WARNED]      = "quota_exceeded\n",
 	[TOMOYO_DIF_TRANSITION_FAILED] = "transition_failed\n",
 };
 /**
  * tomoyo_write_domain - Write domain policy.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static int tomoyo_write_domain(struct tomoyo_io_buffer *head)
 {
 	char *data = head->write_buf;
 	struct tomoyo_policy_namespace *ns;
 	struct tomoyo_domain_info *domain = head->w.domain;
 	const bool is_delete = head->w.is_delete;
 	bool is_select = !is_delete && tomoyo_str_starts(&data, "select ");
 	unsigned int profile;
 	if (*data == '<') {
 		domain = NULL;
 		if (is_delete)
 			tomoyo_delete_domain(data);
 		else if (is_select)
 			domain = tomoyo_find_domain(data);
 		else
 			domain = tomoyo_assign_domain(data, false);
 		head->w.domain = domain;
 		return 0;
 	}
 	if (!domain)
 		return -EINVAL;
 	ns = domain->ns;
 	if (sscanf(data, "use_profile %u", &profile) == 1
 	    && profile < TOMOYO_MAX_PROFILES) {
 		if (!tomoyo_policy_loaded || ns->profile_ptr[profile])
 			domain->profile = (u8) profile;
 		return 0;
 	}
 	if (sscanf(data, "use_group %u\n", &profile) == 1
 	    && profile < TOMOYO_MAX_ACL_GROUPS) {
 		if (!is_delete)
 			domain->group = (u8) profile;
 		return 0;
 	}
 	for (profile = 0; profile < TOMOYO_MAX_DOMAIN_INFO_FLAGS; profile++) {
 		const char *cp = tomoyo_dif[profile];
 		if (strncmp(data, cp, strlen(cp) - 1))
 			continue;
 		domain->flags[profile] = !is_delete;
 		return 0;
 	}
 	return tomoyo_write_domain2(ns, &domain->acl_info_list, data,
 				    is_delete);
 }
 /**
  * tomoyo_print_condition - Print condition part.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  * @cond: Pointer to "struct tomoyo_condition".
  *
  * Returns true on success, false otherwise.
  */
 static bool tomoyo_print_condition(struct tomoyo_io_buffer *head,
 				   const struct tomoyo_condition *cond)
 {
 	switch (head->r.cond_step) {
 	case 0:
 		head->r.cond_index = 0;
 		head->r.cond_step++;
 		/* fall through */
 	case 1:
 		{
 			const u16 condc = cond->condc;
 			const struct tomoyo_condition_element *condp =
 				(typeof(condp)) (cond + 1);
 			const struct tomoyo_number_union *numbers_p =
 				(typeof(numbers_p)) (condp + condc);
 			const struct tomoyo_name_union *names_p =
 				(typeof(names_p))
 				(numbers_p + cond->numbers_count);
 			const struct tomoyo_argv *argv =
 				(typeof(argv)) (names_p + cond->names_count);
 			const struct tomoyo_envp *envp =
 				(typeof(envp)) (argv + cond->argc);
 			u16 skip;
 			for (skip = 0; skip < head->r.cond_index; skip++) {
 				const u8 left = condp->left;
 				const u8 right = condp->right;
 				condp++;
 				switch (left) {
 				case TOMOYO_ARGV_ENTRY:
 					argv++;
 					continue;
 				case TOMOYO_ENVP_ENTRY:
 					envp++;
 					continue;
 				case TOMOYO_NUMBER_UNION:
 					numbers_p++;
 					break;
 				}
 				switch (right) {
 				case TOMOYO_NAME_UNION:
 					names_p++;
 					break;
 				case TOMOYO_NUMBER_UNION:
 					numbers_p++;
 					break;
 				}
 			}
 			while (head->r.cond_index < condc) {
 				const u8 match = condp->equals;
 				const u8 left = condp->left;
 				const u8 right = condp->right;
 				if (!tomoyo_flush(head))
 					return false;
 				condp++;
 				head->r.cond_index++;
 				tomoyo_set_space(head);
 				switch (left) {
 				case TOMOYO_ARGV_ENTRY:
 					tomoyo_io_printf(head,
 							 "exec.argv[%lu]%s=\"",
 							 argv->index, argv->
 							 is_not ? "!" : "");
 					tomoyo_set_string(head,
 							  argv->value->name);
 					tomoyo_set_string(head, "\"");
 					argv++;
 					continue;
 				case TOMOYO_ENVP_ENTRY:
 					tomoyo_set_string(head,
 							  "exec.envp[\"");
 					tomoyo_set_string(head,
 							  envp->name->name);
 					tomoyo_io_printf(head, "\"]%s=", envp->
 							 is_not ? "!" : "");
 					if (envp->value) {
 						tomoyo_set_string(head, "\"");
 						tomoyo_set_string(head, envp->
 								  value->name);
 						tomoyo_set_string(head, "\"");
 					} else {
 						tomoyo_set_string(head,
 								  "NULL");
 					}
 					envp++;
 					continue;
 				case TOMOYO_NUMBER_UNION:
 					tomoyo_print_number_union_nospace
 						(head, numbers_p++);
 					break;
 				default:
 					tomoyo_set_string(head,
 					       tomoyo_condition_keyword[left]);
 					break;
 				}
 				tomoyo_set_string(head, match ? "=" : "!=");
 				switch (right) {
 				case TOMOYO_NAME_UNION:
 					tomoyo_print_name_union_quoted
 						(head, names_p++);
 					break;
 				case TOMOYO_NUMBER_UNION:
 					tomoyo_print_number_union_nospace
 						(head, numbers_p++);
 					break;
 				default:
 					tomoyo_set_string(head,
 					  tomoyo_condition_keyword[right]);
 					break;
 				}
 			}
 		}
 		head->r.cond_step++;
 		/* fall through */
 	case 2:
 		if (!tomoyo_flush(head))
 			break;
 		head->r.cond_step++;
 		/* fall through */
 	case 3:
 		tomoyo_set_lf(head);
 		return true;
 	}
 	return false;
 }
 /**
  * tomoyo_set_group - Print "acl_group " header keyword and category name.
  *
  * @head:     Pointer to "struct tomoyo_io_buffer".
  * @category: Category name.
  *
  * Returns nothing.
  */
 static void tomoyo_set_group(struct tomoyo_io_buffer *head,
 			     const char *category)
 {
 	if (head->type == TOMOYO_EXCEPTIONPOLICY) {
 		tomoyo_print_namespace(head);
 		tomoyo_io_printf(head, "acl_group %u ",
 				 head->r.acl_group_index);
 	}
 	tomoyo_set_string(head, category);
 }
 /**
  * tomoyo_print_entry - Print an ACL entry.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  * @acl:  Pointer to an ACL entry.
  *
  * Returns true on success, false otherwise.
  */
 static bool tomoyo_print_entry(struct tomoyo_io_buffer *head,
 			       struct tomoyo_acl_info *acl)
 {
 	const u8 acl_type = acl->type;
 	bool first = true;
 	u8 bit;
 	if (head->r.print_cond_part)
 		goto print_cond_part;
 	if (acl->is_deleted)
 		return true;
 	if (!tomoyo_flush(head))
 		return false;
 	else if (acl_type == TOMOYO_TYPE_PATH_ACL) {
 		struct tomoyo_path_acl *ptr =
 			container_of(acl, typeof(*ptr), head);
 		const u16 perm = ptr->perm;
 		for (bit = 0; bit < TOMOYO_MAX_PATH_OPERATION; bit++) {
 			if (!(perm & (1 << bit)))
 				continue;
 			if (head->r.print_transition_related_only &&
 			    bit != TOMOYO_TYPE_EXECUTE)
 				continue;
 			if (first) {
 				tomoyo_set_group(head, "file ");
 				first = false;
 			} else {
 				tomoyo_set_slash(head);
 			}
 			tomoyo_set_string(head, tomoyo_path_keyword[bit]);
 		}
 		if (first)
 			return true;
 		tomoyo_print_name_union(head, &ptr->name);
 	} else if (head->r.print_transition_related_only) {
 		return true;
 	} else if (acl_type == TOMOYO_TYPE_PATH2_ACL) {
 		struct tomoyo_path2_acl *ptr =
 			container_of(acl, typeof(*ptr), head);
 		const u8 perm = ptr->perm;
 		for (bit = 0; bit < TOMOYO_MAX_PATH2_OPERATION; bit++) {
 			if (!(perm & (1 << bit)))
 				continue;
 			if (first) {
 				tomoyo_set_group(head, "file ");
 				first = false;
 			} else {
 				tomoyo_set_slash(head);
 			}
 			tomoyo_set_string(head, tomoyo_mac_keywords
 					  [tomoyo_pp2mac[bit]]);
 		}
 		if (first)
 			return true;
 		tomoyo_print_name_union(head, &ptr->name1);
 		tomoyo_print_name_union(head, &ptr->name2);
 	} else if (acl_type == TOMOYO_TYPE_PATH_NUMBER_ACL) {
 		struct tomoyo_path_number_acl *ptr =
 			container_of(acl, typeof(*ptr), head);
 		const u8 perm = ptr->perm;
 		for (bit = 0; bit < TOMOYO_MAX_PATH_NUMBER_OPERATION; bit++) {
 			if (!(perm & (1 << bit)))
 				continue;
 			if (first) {
 				tomoyo_set_group(head, "file ");
 				first = false;
 			} else {
 				tomoyo_set_slash(head);
 			}
 			tomoyo_set_string(head, tomoyo_mac_keywords
 					  [tomoyo_pn2mac[bit]]);
 		}
 		if (first)
 			return true;
 		tomoyo_print_name_union(head, &ptr->name);
 		tomoyo_print_number_union(head, &ptr->number);
 	} else if (acl_type == TOMOYO_TYPE_MKDEV_ACL) {
 		struct tomoyo_mkdev_acl *ptr =
 			container_of(acl, typeof(*ptr), head);
 		const u8 perm = ptr->perm;
 		for (bit = 0; bit < TOMOYO_MAX_MKDEV_OPERATION; bit++) {
 			if (!(perm & (1 << bit)))
 				continue;
 			if (first) {
 				tomoyo_set_group(head, "file ");
 				first = false;
 			} else {
 				tomoyo_set_slash(head);
 			}
 			tomoyo_set_string(head, tomoyo_mac_keywords
 					  [tomoyo_pnnn2mac[bit]]);
 		}
 		if (first)
 			return true;
 		tomoyo_print_name_union(head, &ptr->name);
 		tomoyo_print_number_union(head, &ptr->mode);
 		tomoyo_print_number_union(head, &ptr->major);
 		tomoyo_print_number_union(head, &ptr->minor);
 	} else if (acl_type == TOMOYO_TYPE_MOUNT_ACL) {
 		struct tomoyo_mount_acl *ptr =
 			container_of(acl, typeof(*ptr), head);
 		tomoyo_set_group(head, "file mount");
 		tomoyo_print_name_union(head, &ptr->dev_name);
 		tomoyo_print_name_union(head, &ptr->dir_name);
 		tomoyo_print_name_union(head, &ptr->fs_type);
 		tomoyo_print_number_union(head, &ptr->flags);
 	}
 	if (acl->cond) {
 		head->r.print_cond_part = true;
 		head->r.cond_step = 0;
 		if (!tomoyo_flush(head))
 			return false;
 print_cond_part:
 		if (!tomoyo_print_condition(head, acl->cond))
 			return false;
 		head->r.print_cond_part = false;
 	} else {
 		tomoyo_set_lf(head);
 	}
 	return true;
 }
 /**
  * tomoyo_read_domain2 - Read domain policy.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  * @list: Pointer to "struct list_head".
  *
  * Caller holds tomoyo_read_lock().
  *
  * Returns true on success, false otherwise.
  */
 static bool tomoyo_read_domain2(struct tomoyo_io_buffer *head,
 				struct list_head *list)
 {
 	list_for_each_cookie(head->r.acl, list) {
 		struct tomoyo_acl_info *ptr =
 			list_entry(head->r.acl, typeof(*ptr), list);
 		if (!tomoyo_print_entry(head, ptr))
 			return false;
 	}
 	head->r.acl = NULL;
 	return true;
 }
 /**
  * tomoyo_read_domain - Read domain policy.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Caller holds tomoyo_read_lock().
  */
 static void tomoyo_read_domain(struct tomoyo_io_buffer *head)
 {
 	if (head->r.eof)
 		return;
 	list_for_each_cookie(head->r.domain, &tomoyo_domain_list) {
 		struct tomoyo_domain_info *domain =
 			list_entry(head->r.domain, typeof(*domain), list);
 		switch (head->r.step) {
 			u8 i;
 		case 0:
 			if (domain->is_deleted &&
 			    !head->r.print_this_domain_only)
 				continue;
 			/* Print domainname and flags. */
 			tomoyo_set_string(head, domain->domainname->name);
 			tomoyo_set_lf(head);
 			tomoyo_io_printf(head, "use_profile %u\n",
 					 domain->profile);
 			tomoyo_io_printf(head, "use_group %u\n",
 					 domain->group);
 			for (i = 0; i < TOMOYO_MAX_DOMAIN_INFO_FLAGS; i++)
 				if (domain->flags[i])
 					tomoyo_set_string(head, tomoyo_dif[i]);
 			head->r.step++;
 			tomoyo_set_lf(head);
 			/* fall through */
 		case 1:
 			if (!tomoyo_read_domain2(head, &domain->acl_info_list))
 				return;
 			head->r.step++;
 			if (!tomoyo_set_lf(head))
 				return;
 			/* fall through */
 		case 2:
 			head->r.step = 0;
 			if (head->r.print_this_domain_only)
 				goto done;
 		}
 	}
  done:
 	head->r.eof = true;
 }
 /**
  * tomoyo_write_pid: Specify PID to obtain domainname.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns 0.
  */
 static int tomoyo_write_pid(struct tomoyo_io_buffer *head)
 {
 	head->r.eof = false;
 	return 0;
 }
 /**
  * tomoyo_read_pid - Get domainname of the specified PID.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns the domainname which the specified PID is in on success,
  * empty string otherwise.
  * The PID is specified by tomoyo_write_pid() so that the user can obtain
  * using read()/write() interface rather than sysctl() interface.
  */
 static void tomoyo_read_pid(struct tomoyo_io_buffer *head)
 {
 	char *buf = head->write_buf;
 	bool global_pid = false;
 	unsigned int pid;
 	struct task_struct *p;
 	struct tomoyo_domain_info *domain = NULL;
 	/* Accessing write_buf is safe because head->io_sem is held. */
 	if (!buf) {
 		head->r.eof = true;
 		return; /* Do nothing if open(O_RDONLY). */
 	}
 	if (head->r.w_pos || head->r.eof)
 		return;
 	head->r.eof = true;
 	if (tomoyo_str_starts(&buf, "global-pid "))
 		global_pid = true;
 	pid = (unsigned int) simple_strtoul(buf, NULL, 10);
 	rcu_read_lock();
 	read_lock(&tasklist_lock);
 	if (global_pid)
 		p = find_task_by_pid_ns(pid, &init_pid_ns);
 	else
 		p = find_task_by_vpid(pid);
 	if (p)
 		domain = tomoyo_real_domain(p);
 	read_unlock(&tasklist_lock);
 	rcu_read_unlock();
 	if (!domain)
 		return;
 	tomoyo_io_printf(head, "%u %u ", pid, domain->profile);
 	tomoyo_set_string(head, domain->domainname->name);
 }
+/* String table for domain transition control keywords. */
 static const char *tomoyo_transition_type[TOMOYO_MAX_TRANSITION_TYPE] = {
 	[TOMOYO_TRANSITION_CONTROL_NO_RESET]      = "no_reset_domain ",
 	[TOMOYO_TRANSITION_CONTROL_RESET]         = "reset_domain ",
 	[TOMOYO_TRANSITION_CONTROL_NO_INITIALIZE] = "no_initialize_domain ",
 	[TOMOYO_TRANSITION_CONTROL_INITIALIZE]    = "initialize_domain ",
 	[TOMOYO_TRANSITION_CONTROL_NO_KEEP]       = "no_keep_domain ",
 	[TOMOYO_TRANSITION_CONTROL_KEEP]          = "keep_domain ",
 };
+/* String table for grouping keywords. */
 static const char *tomoyo_group_name[TOMOYO_MAX_GROUP] = {
 	[TOMOYO_PATH_GROUP]   = "path_group ",
 	[TOMOYO_NUMBER_GROUP] = "number_group ",
 };
 /**
  * tomoyo_write_exception - Write exception policy.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static int tomoyo_write_exception(struct tomoyo_io_buffer *head)
 {
 	const bool is_delete = head->w.is_delete;
 	struct tomoyo_acl_param param = {
 		.ns = head->w.ns,
 		.is_delete = is_delete,
 		.data = head->write_buf,
 	};
 	u8 i;
 	if (tomoyo_str_starts(&param.data, "aggregator "))
 		return tomoyo_write_aggregator(&param);
 	for (i = 0; i < TOMOYO_MAX_TRANSITION_TYPE; i++)
 		if (tomoyo_str_starts(&param.data, tomoyo_transition_type[i]))
 			return tomoyo_write_transition_control(&param, i);
 	for (i = 0; i < TOMOYO_MAX_GROUP; i++)
 		if (tomoyo_str_starts(&param.data, tomoyo_group_name[i]))
 			return tomoyo_write_group(&param, i);
 	if (tomoyo_str_starts(&param.data, "acl_group ")) {
 		unsigned int group;
 		char *data;
 		group = simple_strtoul(param.data, &data, 10);
 		if (group < TOMOYO_MAX_ACL_GROUPS && *data++ == ' ')
 			return tomoyo_write_domain2
 				(head->w.ns, &head->w.ns->acl_group[group],
 				 data, is_delete);
 	}
 	return -EINVAL;
 }
 /**
  * tomoyo_read_group - Read "struct tomoyo_path_group"/"struct tomoyo_number_group" list.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  * @idx:  Index number.
  *
  * Returns true on success, false otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static bool tomoyo_read_group(struct tomoyo_io_buffer *head, const int idx)
 {
 	struct tomoyo_policy_namespace *ns =
 		container_of(head->r.ns, typeof(*ns), namespace_list);
 	struct list_head *list = &ns->group_list[idx];
 	list_for_each_cookie(head->r.group, list) {
 		struct tomoyo_group *group =
 			list_entry(head->r.group, typeof(*group), head.list);
 		list_for_each_cookie(head->r.acl, &group->member_list) {
 			struct tomoyo_acl_head *ptr =
 				list_entry(head->r.acl, typeof(*ptr), list);
 			if (ptr->is_deleted)
 				continue;
 			if (!tomoyo_flush(head))
 				return false;
 			tomoyo_print_namespace(head);
 			tomoyo_set_string(head, tomoyo_group_name[idx]);
 			tomoyo_set_string(head, group->group_name->name);
 			if (idx == TOMOYO_PATH_GROUP) {
 				tomoyo_set_space(head);
 				tomoyo_set_string(head, container_of
 					       (ptr, struct tomoyo_path_group,
 						head)->member_name->name);
 			} else if (idx == TOMOYO_NUMBER_GROUP) {
 				tomoyo_print_number_union(head, &container_of
 							  (ptr,
 						   struct tomoyo_number_group,
 							   head)->number);
 			}
 			tomoyo_set_lf(head);
 		}
 		head->r.acl = NULL;
 	}
 	head->r.group = NULL;
 	return true;
 }
 /**
  * tomoyo_read_policy - Read "struct tomoyo_..._entry" list.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  * @idx:  Index number.
  *
  * Returns true on success, false otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static bool tomoyo_read_policy(struct tomoyo_io_buffer *head, const int idx)
 {
 	struct tomoyo_policy_namespace *ns =
 		container_of(head->r.ns, typeof(*ns), namespace_list);
 	struct list_head *list = &ns->policy_list[idx];
 	list_for_each_cookie(head->r.acl, list) {
 		struct tomoyo_acl_head *acl =
 			container_of(head->r.acl, typeof(*acl), list);
 		if (acl->is_deleted)
 			continue;
 		if (!tomoyo_flush(head))
 			return false;
 		switch (idx) {
 		case TOMOYO_ID_TRANSITION_CONTROL:
 			{
 				struct tomoyo_transition_control *ptr =
 					container_of(acl, typeof(*ptr), head);
 				tomoyo_print_namespace(head);
 				tomoyo_set_string(head, tomoyo_transition_type
 						  [ptr->type]);
 				tomoyo_set_string(head, ptr->program ?
 						  ptr->program->name : "any");
 				tomoyo_set_string(head, " from ");
 				tomoyo_set_string(head, ptr->domainname ?
 						  ptr->domainname->name :
 						  "any");
 			}
 			break;
 		case TOMOYO_ID_AGGREGATOR:
 			{
 				struct tomoyo_aggregator *ptr =
 					container_of(acl, typeof(*ptr), head);
 				tomoyo_print_namespace(head);
 				tomoyo_set_string(head, "aggregator ");
 				tomoyo_set_string(head,
 						  ptr->original_name->name);
 				tomoyo_set_space(head);
 				tomoyo_set_string(head,
 					       ptr->aggregated_name->name);
 			}
 			break;
 		default:
 			continue;
 		}
 		tomoyo_set_lf(head);
 	}
 	head->r.acl = NULL;
 	return true;
 }
 /**
  * tomoyo_read_exception - Read exception policy.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Caller holds tomoyo_read_lock().
  */
 static void tomoyo_read_exception(struct tomoyo_io_buffer *head)
 {
 	struct tomoyo_policy_namespace *ns =
 		container_of(head->r.ns, typeof(*ns), namespace_list);
 	if (head->r.eof)
 		return;
 	while (head->r.step < TOMOYO_MAX_POLICY &&
 	       tomoyo_read_policy(head, head->r.step))
 		head->r.step++;
 	if (head->r.step < TOMOYO_MAX_POLICY)
 		return;
 	while (head->r.step < TOMOYO_MAX_POLICY + TOMOYO_MAX_GROUP &&
 	       tomoyo_read_group(head, head->r.step - TOMOYO_MAX_POLICY))
 		head->r.step++;
 	if (head->r.step < TOMOYO_MAX_POLICY + TOMOYO_MAX_GROUP)
 		return;
 	while (head->r.step < TOMOYO_MAX_POLICY + TOMOYO_MAX_GROUP
 	       + TOMOYO_MAX_ACL_GROUPS) {
 		head->r.acl_group_index = head->r.step - TOMOYO_MAX_POLICY
 			- TOMOYO_MAX_GROUP;
 		if (!tomoyo_read_domain2(head, &ns->acl_group
 					 [head->r.acl_group_index]))
 			return;
 		head->r.step++;
 	}
 	head->r.eof = true;
 }
 /* Wait queue for kernel -> userspace notification. */
 static DECLARE_WAIT_QUEUE_HEAD(tomoyo_query_wait);
 /* Wait queue for userspace -> kernel notification. */
 static DECLARE_WAIT_QUEUE_HEAD(tomoyo_answer_wait);
 /* Structure for query. */
 struct tomoyo_query {
 	struct list_head list;
 	char *query;
 	size_t query_len;
 	unsigned int serial;
 	u8 timer;
 	u8 answer;
 	u8 retry;
 };
 /* The list for "struct tomoyo_query". */
 static LIST_HEAD(tomoyo_query_list);
 /* Lock for manipulating tomoyo_query_list. */
 static DEFINE_SPINLOCK(tomoyo_query_list_lock);
 /*
  * Number of "struct file" referring /sys/kernel/security/tomoyo/query
  * interface.
  */
 static atomic_t tomoyo_query_observers = ATOMIC_INIT(0);
 /**
  * tomoyo_truncate - Truncate a line.
  *
  * @str: String to truncate.
  *
  * Returns length of truncated @str.
  */
 static int tomoyo_truncate(char *str)
 {
 	char *start = str;
 	while (*(unsigned char *) str > (unsigned char) ' ')
 		str++;
 	*str = '\0';
 	return strlen(start) + 1;
 }
 /**
  * tomoyo_add_entry - Add an ACL to current thread's domain. Used by learning mode.
  *
  * @domain: Pointer to "struct tomoyo_domain_info".
  * @header: Lines containing ACL.
  *
  * Returns nothing.
  */
 static void tomoyo_add_entry(struct tomoyo_domain_info *domain, char *header)
 {
 	char *buffer;
 	char *realpath = NULL;
 	char *argv0 = NULL;
 	char *symlink = NULL;
 	char *cp = strchr(header, '\n');
 	int len;
 	if (!cp)
 		return;
 	cp = strchr(cp + 1, '\n');
 	if (!cp)
 		return;
 	*cp++ = '\0';
 	len = strlen(cp) + 1;
 	/* strstr() will return NULL if ordering is wrong. */
 	if (*cp == 'f') {
 		argv0 = strstr(header, " argv[]={ \"");
 		if (argv0) {
 			argv0 += 10;
 			len += tomoyo_truncate(argv0) + 14;
 		}
 		realpath = strstr(header, " exec={ realpath=\"");
 		if (realpath) {
 			realpath += 8;
 			len += tomoyo_truncate(realpath) + 6;
 		}
 		symlink = strstr(header, " symlink.target=\"");
 		if (symlink)
 			len += tomoyo_truncate(symlink + 1) + 1;
 	}
 	buffer = kmalloc(len, GFP_NOFS);
 	if (!buffer)
 		return;
 	snprintf(buffer, len - 1, "%s", cp);
 	if (realpath)
 		tomoyo_addprintf(buffer, len, " exec.%s", realpath);
 	if (argv0)
 		tomoyo_addprintf(buffer, len, " exec.argv[0]=%s", argv0);
 	if (symlink)
 		tomoyo_addprintf(buffer, len, "%s", symlink);
 	tomoyo_normalize_line(buffer);
 	if (!tomoyo_write_domain2(domain->ns, &domain->acl_info_list, buffer,
 				  false))
 		tomoyo_update_stat(TOMOYO_STAT_POLICY_UPDATES);
 	kfree(buffer);
 }
 /**
  * tomoyo_supervisor - Ask for the supervisor's decision.
  *
  * @r:   Pointer to "struct tomoyo_request_info".
  * @fmt: The printf()'s format string, followed by parameters.
  *
  * Returns 0 if the supervisor decided to permit the access request which
  * violated the policy in enforcing mode, TOMOYO_RETRY_REQUEST if the
  * supervisor decided to retry the access request which violated the policy in
  * enforcing mode, 0 if it is not in enforcing mode, -EPERM otherwise.
  */
 int tomoyo_supervisor(struct tomoyo_request_info *r, const char *fmt, ...)
 {
 	va_list args;
 	int error;
 	int len;
 	static unsigned int tomoyo_serial;
 	struct tomoyo_query entry = { };
 	bool quota_exceeded = false;
 	va_start(args, fmt);
 	len = vsnprintf((char *) &len, 1, fmt, args) + 1;
 	va_end(args);
 	/* Write /sys/kernel/security/tomoyo/audit. */
 	va_start(args, fmt);
 	tomoyo_write_log2(r, len, fmt, args);
 	va_end(args);
 	/* Nothing more to do if granted. */
 	if (r->granted)
 		return 0;
 	if (r->mode)
 		tomoyo_update_stat(r->mode);
 	switch (r->mode) {
 	case TOMOYO_CONFIG_ENFORCING:
 		error = -EPERM;
 		if (atomic_read(&tomoyo_query_observers))
 			break;
 		goto out;
 	case TOMOYO_CONFIG_LEARNING:
 		error = 0;
 		/* Check max_learning_entry parameter. */
 		if (tomoyo_domain_quota_is_ok(r))
 			break;
 		/* fall through */
 	default:
 		return 0;
 	}
 	/* Get message. */
 	va_start(args, fmt);
 	entry.query = tomoyo_init_log(r, len, fmt, args);
 	va_end(args);
 	if (!entry.query)
 		goto out;
 	entry.query_len = strlen(entry.query) + 1;
 	if (!error) {
 		tomoyo_add_entry(r->domain, entry.query);
 		goto out;
 	}
 	len = tomoyo_round2(entry.query_len);
 	spin_lock(&tomoyo_query_list_lock);
 	if (tomoyo_memory_quota[TOMOYO_MEMORY_QUERY] &&
 	    tomoyo_memory_used[TOMOYO_MEMORY_QUERY] + len
 	    >= tomoyo_memory_quota[TOMOYO_MEMORY_QUERY]) {
 		quota_exceeded = true;
 	} else {
 		entry.serial = tomoyo_serial++;
 		entry.retry = r->retry;
 		tomoyo_memory_used[TOMOYO_MEMORY_QUERY] += len;
 		list_add_tail(&entry.list, &tomoyo_query_list);
 	}
 	spin_unlock(&tomoyo_query_list_lock);
 	if (quota_exceeded)
 		goto out;
 	/* Give 10 seconds for supervisor's opinion. */
 	while (entry.timer < 10) {
 		wake_up_all(&tomoyo_query_wait);
 		if (wait_event_interruptible_timeout
 		    (tomoyo_answer_wait, entry.answer ||
 		     !atomic_read(&tomoyo_query_observers), HZ))
 			break;
 		else
 			entry.timer++;
 	}
 	spin_lock(&tomoyo_query_list_lock);
 	list_del(&entry.list);
 	tomoyo_memory_used[TOMOYO_MEMORY_QUERY] -= len;
 	spin_unlock(&tomoyo_query_list_lock);
 	switch (entry.answer) {
 	case 3: /* Asked to retry by administrator. */
 		error = TOMOYO_RETRY_REQUEST;
 		r->retry++;
 		break;
 	case 1:
 		/* Granted by administrator. */
 		error = 0;
 		break;
 	default:
 		/* Timed out or rejected by administrator. */
 		break;
 	}
 out:
 	kfree(entry.query);
 	return error;
 }
 /**
  * tomoyo_poll_query - poll() for /sys/kernel/security/tomoyo/query.
  *
  * @file: Pointer to "struct file".
  * @wait: Pointer to "poll_table".
  *
  * Returns POLLIN | POLLRDNORM when ready to read, 0 otherwise.
  *
  * Waits for access requests which violated policy in enforcing mode.
  */
 static int tomoyo_poll_query(struct file *file, poll_table *wait)
 {
 	struct list_head *tmp;
 	bool found = false;
 	u8 i;
 	for (i = 0; i < 2; i++) {
 		spin_lock(&tomoyo_query_list_lock);
 		list_for_each(tmp, &tomoyo_query_list) {
 			struct tomoyo_query *ptr =
 				list_entry(tmp, typeof(*ptr), list);
 			if (ptr->answer)
 				continue;
 			found = true;
 			break;
 		}
 		spin_unlock(&tomoyo_query_list_lock);
 		if (found)
 			return POLLIN | POLLRDNORM;
 		if (i)
 			break;
 		poll_wait(file, &tomoyo_query_wait, wait);
 	}
 	return 0;
 }
 /**
  * tomoyo_read_query - Read access requests which violated policy in enforcing mode.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  */
 static void tomoyo_read_query(struct tomoyo_io_buffer *head)
 {
 	struct list_head *tmp;
 	unsigned int pos = 0;
 	size_t len = 0;
 	char *buf;
 	if (head->r.w_pos)
 		return;
 	if (head->read_buf) {
 		kfree(head->read_buf);
 		head->read_buf = NULL;
 	}
 	spin_lock(&tomoyo_query_list_lock);
 	list_for_each(tmp, &tomoyo_query_list) {
 		struct tomoyo_query *ptr = list_entry(tmp, typeof(*ptr), list);
 		if (ptr->answer)
 			continue;
 		if (pos++ != head->r.query_index)
 			continue;
 		len = ptr->query_len;
 		break;
 	}
 	spin_unlock(&tomoyo_query_list_lock);
 	if (!len) {
 		head->r.query_index = 0;
 		return;
 	}
 	buf = kzalloc(len + 32, GFP_NOFS);
 	if (!buf)
 		return;
 	pos = 0;
 	spin_lock(&tomoyo_query_list_lock);
 	list_for_each(tmp, &tomoyo_query_list) {
 		struct tomoyo_query *ptr = list_entry(tmp, typeof(*ptr), list);
 		if (ptr->answer)
 			continue;
 		if (pos++ != head->r.query_index)
 			continue;
 		/*
 		 * Some query can be skipped because tomoyo_query_list
 		 * can change, but I don't care.
 		 */
 		if (len == ptr->query_len)
 			snprintf(buf, len + 31, "Q%u-%hu\n%s", ptr->serial,
 				 ptr->retry, ptr->query);
 		break;
 	}
 	spin_unlock(&tomoyo_query_list_lock);
 	if (buf[0]) {
 		head->read_buf = buf;
 		head->r.w[head->r.w_pos++] = buf;
 		head->r.query_index++;
 	} else {
 		kfree(buf);
 	}
 }
 /**
  * tomoyo_write_answer - Write the supervisor's decision.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns 0 on success, -EINVAL otherwise.
  */
 static int tomoyo_write_answer(struct tomoyo_io_buffer *head)
 {
 	char *data = head->write_buf;
 	struct list_head *tmp;
 	unsigned int serial;
 	unsigned int answer;
 	spin_lock(&tomoyo_query_list_lock);
 	list_for_each(tmp, &tomoyo_query_list) {
 		struct tomoyo_query *ptr = list_entry(tmp, typeof(*ptr), list);
 		ptr->timer = 0;
 	}
 	spin_unlock(&tomoyo_query_list_lock);
 	if (sscanf(data, "A%u=%u", &serial, &answer) != 2)
 		return -EINVAL;
 	spin_lock(&tomoyo_query_list_lock);
 	list_for_each(tmp, &tomoyo_query_list) {
 		struct tomoyo_query *ptr = list_entry(tmp, typeof(*ptr), list);
 		if (ptr->serial != serial)
 			continue;
 		if (!ptr->answer)
 			ptr->answer = answer;
 		break;
 	}
 	spin_unlock(&tomoyo_query_list_lock);
 	return 0;
 }
 /**
  * tomoyo_read_version: Get version.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns version information.
  */
 static void tomoyo_read_version(struct tomoyo_io_buffer *head)
 {
 	if (!head->r.eof) {
 		tomoyo_io_printf(head, "2.4.0");
 		head->r.eof = true;
 	}
 }
 /**
  * tomoyo_read_self_domain - Get the current process's domainname.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns the current process's domainname.
  */
 static void tomoyo_read_self_domain(struct tomoyo_io_buffer *head)
 {
 	if (!head->r.eof) {
 		/*
 		 * tomoyo_domain()->domainname != NULL
 		 * because every process belongs to a domain and
 		 * the domain's name cannot be NULL.
 		 */
 		tomoyo_io_printf(head, "%s", tomoyo_domain()->domainname->name);
 		head->r.eof = true;
 	}
 }
 /* String table for /sys/kernel/security/tomoyo/stat interface. */
 static const char * const tomoyo_policy_headers[TOMOYO_MAX_POLICY_STAT] = {
 	[TOMOYO_STAT_POLICY_UPDATES]    = "update:",
 	[TOMOYO_STAT_POLICY_LEARNING]   = "violation in learning mode:",
 	[TOMOYO_STAT_POLICY_PERMISSIVE] = "violation in permissive mode:",
 	[TOMOYO_STAT_POLICY_ENFORCING]  = "violation in enforcing mode:",
 };
 /* String table for /sys/kernel/security/tomoyo/stat interface. */
 static const char * const tomoyo_memory_headers[TOMOYO_MAX_MEMORY_STAT] = {
 	[TOMOYO_MEMORY_POLICY] = "policy:",
 	[TOMOYO_MEMORY_AUDIT]  = "audit log:",
 	[TOMOYO_MEMORY_QUERY]  = "query message:",
 };
 /* Timestamp counter for last updated. */
 static unsigned int tomoyo_stat_updated[TOMOYO_MAX_POLICY_STAT];
 /* Counter for number of updates. */
 static unsigned int tomoyo_stat_modified[TOMOYO_MAX_POLICY_STAT];
 /**
  * tomoyo_update_stat - Update statistic counters.
  *
  * @index: Index for policy type.
  *
  * Returns nothing.
  */
 void tomoyo_update_stat(const u8 index)
 {
 	struct timeval tv;
 	do_gettimeofday(&tv);
 	/*
 	 * I don't use atomic operations because race condition is not fatal.
 	 */
 	tomoyo_stat_updated[index]++;
 	tomoyo_stat_modified[index] = tv.tv_sec;
 }
 /**
  * tomoyo_read_stat - Read statistic data.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns nothing.
  */
 static void tomoyo_read_stat(struct tomoyo_io_buffer *head)
 {
 	u8 i;
 	unsigned int total = 0;
 	if (head->r.eof)
 		return;
 	for (i = 0; i < TOMOYO_MAX_POLICY_STAT; i++) {
 		tomoyo_io_printf(head, "Policy %-30s %10u",
 				 tomoyo_policy_headers[i],
 				 tomoyo_stat_updated[i]);
 		if (tomoyo_stat_modified[i]) {
 			struct tomoyo_time stamp;
 			tomoyo_convert_time(tomoyo_stat_modified[i], &stamp);
 			tomoyo_io_printf(head, " (Last: %04u/%02u/%02u "
 					 "%02u:%02u:%02u)",
 					 stamp.year, stamp.month, stamp.day,
 					 stamp.hour, stamp.min, stamp.sec);
 		}
 		tomoyo_set_lf(head);
 	}
 	for (i = 0; i < TOMOYO_MAX_MEMORY_STAT; i++) {
 		unsigned int used = tomoyo_memory_used[i];
 		total += used;
 		tomoyo_io_printf(head, "Memory used by %-22s %10u",
 				 tomoyo_memory_headers[i], used);
 		used = tomoyo_memory_quota[i];
 		if (used)
 			tomoyo_io_printf(head, " (Quota: %10u)", used);
 		tomoyo_set_lf(head);
 	}
 	tomoyo_io_printf(head, "Total memory used:                    %10u\n",
 			 total);
 	head->r.eof = true;
 }
 /**
  * tomoyo_write_stat - Set memory quota.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns 0.
  */
 static int tomoyo_write_stat(struct tomoyo_io_buffer *head)
 {
 	char *data = head->write_buf;
 	u8 i;
 	if (tomoyo_str_starts(&data, "Memory used by "))
 		for (i = 0; i < TOMOYO_MAX_MEMORY_STAT; i++)
 			if (tomoyo_str_starts(&data, tomoyo_memory_headers[i]))
 				sscanf(data, "%u", &tomoyo_memory_quota[i]);
 	return 0;
 }
 /**
  * tomoyo_open_control - open() for /sys/kernel/security/tomoyo/ interface.
  *
  * @type: Type of interface.
  * @file: Pointer to "struct file".
  *
  * Returns 0 on success, negative value otherwise.
  */
 int tomoyo_open_control(const u8 type, struct file *file)
 {
 	struct tomoyo_io_buffer *head = kzalloc(sizeof(*head), GFP_NOFS);
 	if (!head)
 		return -ENOMEM;
 	mutex_init(&head->io_sem);
 	head->type = type;
 	switch (type) {
 	case TOMOYO_DOMAINPOLICY:
 		/* /sys/kernel/security/tomoyo/domain_policy */
 		head->write = tomoyo_write_domain;
 		head->read = tomoyo_read_domain;
 		break;
 	case TOMOYO_EXCEPTIONPOLICY:
 		/* /sys/kernel/security/tomoyo/exception_policy */
 		head->write = tomoyo_write_exception;
 		head->read = tomoyo_read_exception;
 		break;
 	case TOMOYO_AUDIT:
 		/* /sys/kernel/security/tomoyo/audit */
 		head->poll = tomoyo_poll_log;
 		head->read = tomoyo_read_log;
 		break;
 	case TOMOYO_SELFDOMAIN:
 		/* /sys/kernel/security/tomoyo/self_domain */
 		head->read = tomoyo_read_self_domain;
 		break;
 	case TOMOYO_PROCESS_STATUS:
 		/* /sys/kernel/security/tomoyo/.process_status */
 		head->write = tomoyo_write_pid;
 		head->read = tomoyo_read_pid;
 		break;
 	case TOMOYO_VERSION:
 		/* /sys/kernel/security/tomoyo/version */
 		head->read = tomoyo_read_version;
 		head->readbuf_size = 128;
 		break;
 	case TOMOYO_STAT:
 		/* /sys/kernel/security/tomoyo/stat */
 		head->write = tomoyo_write_stat;
 		head->read = tomoyo_read_stat;
 		head->readbuf_size = 1024;
 		break;
 	case TOMOYO_PROFILE:
 		/* /sys/kernel/security/tomoyo/profile */
 		head->write = tomoyo_write_profile;
 		head->read = tomoyo_read_profile;
 		break;
 	case TOMOYO_QUERY: /* /sys/kernel/security/tomoyo/query */
 		head->poll = tomoyo_poll_query;
 		head->write = tomoyo_write_answer;
 		head->read = tomoyo_read_query;
 		break;
 	case TOMOYO_MANAGER:
 		/* /sys/kernel/security/tomoyo/manager */
 		head->write = tomoyo_write_manager;
 		head->read = tomoyo_read_manager;
 		break;
 	}
 	if (!(file->f_mode & FMODE_READ)) {
 		/*
 		 * No need to allocate read_buf since it is not opened
 		 * for reading.
 		 */
 		head->read = NULL;
 		head->poll = NULL;
 	} else if (!head->poll) {
 		/* Don't allocate read_buf for poll() access. */
 		if (!head->readbuf_size)
 			head->readbuf_size = 4096 * 2;
 		head->read_buf = kzalloc(head->readbuf_size, GFP_NOFS);
 		if (!head->read_buf) {
 			kfree(head);
 			return -ENOMEM;
 		}
 	}
 	if (!(file->f_mode & FMODE_WRITE)) {
 		/*
 		 * No need to allocate write_buf since it is not opened
 		 * for writing.
 		 */
 		head->write = NULL;
 	} else if (head->write) {
 		head->writebuf_size = 4096 * 2;
 		head->write_buf = kzalloc(head->writebuf_size, GFP_NOFS);
 		if (!head->write_buf) {
 			kfree(head->read_buf);
 			kfree(head);
 			return -ENOMEM;
 		}
 	}
 	/*
 	 * If the file is /sys/kernel/security/tomoyo/query , increment the
 	 * observer counter.
 	 * The obserber counter is used by tomoyo_supervisor() to see if
 	 * there is some process monitoring /sys/kernel/security/tomoyo/query.
 	 */
 	if (type == TOMOYO_QUERY)
 		atomic_inc(&tomoyo_query_observers);
 	file->private_data = head;
 	tomoyo_notify_gc(head, true);
 	return 0;
 }
 /**
  * tomoyo_poll_control - poll() for /sys/kernel/security/tomoyo/ interface.
  *
  * @file: Pointer to "struct file".
  * @wait: Pointer to "poll_table".
  *
  * Waits for read readiness.
  * /sys/kernel/security/tomoyo/query is handled by /usr/sbin/tomoyo-queryd and
  * /sys/kernel/security/tomoyo/audit is handled by /usr/sbin/tomoyo-auditd.
  */
 int tomoyo_poll_control(struct file *file, poll_table *wait)
 {
 	struct tomoyo_io_buffer *head = file->private_data;
 	if (!head->poll)
 		return -ENOSYS;
 	return head->poll(file, wait);
 }
 /**
  * tomoyo_set_namespace_cursor - Set namespace to read.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns nothing.
  */
 static inline void tomoyo_set_namespace_cursor(struct tomoyo_io_buffer *head)
 {
 	struct list_head *ns;
 	if (head->type != TOMOYO_EXCEPTIONPOLICY &&
 	    head->type != TOMOYO_PROFILE)
 		return;
 	/*
 	 * If this is the first read, or reading previous namespace finished
 	 * and has more namespaces to read, update the namespace cursor.
 	 */
 	ns = head->r.ns;
 	if (!ns || (head->r.eof && ns->next != &tomoyo_namespace_list)) {
 		/* Clearing is OK because tomoyo_flush() returned true. */
 		memset(&head->r, 0, sizeof(head->r));
 		head->r.ns = ns ? ns->next : tomoyo_namespace_list.next;
 	}
 }
 /**
  * tomoyo_has_more_namespace - Check for unread namespaces.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns true if we have more entries to print, false otherwise.
  */
 static inline bool tomoyo_has_more_namespace(struct tomoyo_io_buffer *head)
 {
 	return (head->type == TOMOYO_EXCEPTIONPOLICY ||
 		head->type == TOMOYO_PROFILE) && head->r.eof &&
 		head->r.ns->next != &tomoyo_namespace_list;
 }
 /**
  * tomoyo_read_control - read() for /sys/kernel/security/tomoyo/ interface.
  *
  * @head:       Pointer to "struct tomoyo_io_buffer".
  * @buffer:     Poiner to buffer to write to.
  * @buffer_len: Size of @buffer.
  *
  * Returns bytes read on success, negative value otherwise.
  */
 ssize_t tomoyo_read_control(struct tomoyo_io_buffer *head, char __user *buffer,
 			    const int buffer_len)
 {
 	int len;
 	int idx;
 	if (!head->read)
 		return -ENOSYS;
 	if (mutex_lock_interruptible(&head->io_sem))
 		return -EINTR;
 	head->read_user_buf = buffer;
 	head->read_user_buf_avail = buffer_len;
 	idx = tomoyo_read_lock();
 	if (tomoyo_flush(head))
 		/* Call the policy handler. */
 		do {
 			tomoyo_set_namespace_cursor(head);
 			head->read(head);
 		} while (tomoyo_flush(head) &&
 			 tomoyo_has_more_namespace(head));
 	tomoyo_read_unlock(idx);
 	len = head->read_user_buf - buffer;
 	mutex_unlock(&head->io_sem);
 	return len;
 }
 /**
  * tomoyo_parse_policy - Parse a policy line.
  *
  * @head: Poiter to "struct tomoyo_io_buffer".
  * @line: Line to parse.
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static int tomoyo_parse_policy(struct tomoyo_io_buffer *head, char *line)
 {
 	/* Delete request? */
 	head->w.is_delete = !strncmp(line, "delete ", 7);
 	if (head->w.is_delete)
 		memmove(line, line + 7, strlen(line + 7) + 1);
 	/* Selecting namespace to update. */
 	if (head->type == TOMOYO_EXCEPTIONPOLICY ||
 	    head->type == TOMOYO_PROFILE) {
 		if (*line == '<') {
 			char *cp = strchr(line, ' ');
 			if (cp) {
 				*cp++ = '\0';
 				head->w.ns = tomoyo_assign_namespace(line);
 				memmove(line, cp, strlen(cp) + 1);
 			} else
 				head->w.ns = NULL;
 		} else
 			head->w.ns = &tomoyo_kernel_namespace;
 		/* Don't allow updating if namespace is invalid. */
 		if (!head->w.ns)
 			return -ENOENT;
 	}
 	/* Do the update. */
 	return head->write(head);
 }
 /**
  * tomoyo_write_control - write() for /sys/kernel/security/tomoyo/ interface.
  *
  * @head:       Pointer to "struct tomoyo_io_buffer".
  * @buffer:     Pointer to buffer to read from.
  * @buffer_len: Size of @buffer.
  *
  * Returns @buffer_len on success, negative value otherwise.
  */
 ssize_t tomoyo_write_control(struct tomoyo_io_buffer *head,
 			     const char __user *buffer, const int buffer_len)
 {
 	int error = buffer_len;
 	size_t avail_len = buffer_len;
 	char *cp0 = head->write_buf;
 	int idx;
 	if (!head->write)
 		return -ENOSYS;
 	if (!access_ok(VERIFY_READ, buffer, buffer_len))
 		return -EFAULT;
 	if (mutex_lock_interruptible(&head->io_sem))
 		return -EINTR;
 	idx = tomoyo_read_lock();
 	/* Read a line and dispatch it to the policy handler. */
 	while (avail_len > 0) {
 		char c;
 		if (head->w.avail >= head->writebuf_size - 1) {
 			const int len = head->writebuf_size * 2;
 			char *cp = kzalloc(len, GFP_NOFS);
 			if (!cp) {
 				error = -ENOMEM;
 				break;
 			}
 			memmove(cp, cp0, head->w.avail);
 			kfree(cp0);
 			head->write_buf = cp;
 			cp0 = cp;
 			head->writebuf_size = len;
 		}
 		if (get_user(c, buffer)) {
 			error = -EFAULT;
 			break;
 		}
 		buffer++;
 		avail_len--;
 		cp0[head->w.avail++] = c;
 		if (c != '\n')
 			continue;
 		cp0[head->w.avail - 1] = '\0';
 		head->w.avail = 0;
 		tomoyo_normalize_line(cp0);
 		if (!strcmp(cp0, "reset")) {
 			head->w.ns = &tomoyo_kernel_namespace;
 			head->w.domain = NULL;
 			memset(&head->r, 0, sizeof(head->r));
 			continue;
 		}
 		/* Don't allow updating policies by non manager programs. */
 		switch (head->type) {
 		case TOMOYO_PROCESS_STATUS:
 			/* This does not write anything. */
 			break;
 		case TOMOYO_DOMAINPOLICY:
 			if (tomoyo_select_domain(head, cp0))
 				continue;
 			/* fall through */
 		case TOMOYO_EXCEPTIONPOLICY:
 			if (!strcmp(cp0, "select transition_only")) {
 				head->r.print_transition_related_only = true;
 				continue;
 			}
 			/* fall through */
 		default:
 			if (!tomoyo_manager()) {
 				error = -EPERM;
 				goto out;
 			}
 		}
 		switch (tomoyo_parse_policy(head, cp0)) {
 		case -EPERM:
 			error = -EPERM;
 			goto out;
 		case 0:
 			switch (head->type) {
 			case TOMOYO_DOMAINPOLICY:
 			case TOMOYO_EXCEPTIONPOLICY:
 			case TOMOYO_STAT:
 			case TOMOYO_PROFILE:
 			case TOMOYO_MANAGER:
 				tomoyo_update_stat(TOMOYO_STAT_POLICY_UPDATES);
 				break;
 			default:
 				break;
 			}
 			break;
 		}
 	}
 out:
 	tomoyo_read_unlock(idx);
 	mutex_unlock(&head->io_sem);
 	return error;
 }
 /**
  * tomoyo_close_control - close() for /sys/kernel/security/tomoyo/ interface.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  *
  * Returns 0.
  */
 int tomoyo_close_control(struct tomoyo_io_buffer *head)
 {
 	/*
 	 * If the file is /sys/kernel/security/tomoyo/query , decrement the
 	 * observer counter.
 	 */
 	if (head->type == TOMOYO_QUERY &&
 	    atomic_dec_and_test(&tomoyo_query_observers))
 		wake_up_all(&tomoyo_answer_wait);
 	tomoyo_notify_gc(head, false);
 	return 0;
 }
 /**
  * tomoyo_check_profile - Check all profiles currently assigned to domains are defined.
  */
 void tomoyo_check_profile(void)
 {
 	struct tomoyo_domain_info *domain;
 	const int idx = tomoyo_read_lock();
 	tomoyo_policy_loaded = true;
 	printk(KERN_INFO "TOMOYO: 2.4.0\n");
 	list_for_each_entry_rcu(domain, &tomoyo_domain_list, list) {
 		const u8 profile = domain->profile;
 		const struct tomoyo_policy_namespace *ns = domain->ns;
 		if (ns->profile_version != 20100903)
 			printk(KERN_ERR
 			       "Profile version %u is not supported.\n",
 			       ns->profile_version);
 		else if (!ns->profile_ptr[profile])
 			printk(KERN_ERR
 			       "Profile %u (used by '%s') is not defined.\n",
 			       profile, domain->domainname->name);
 		else
 			continue;
 		printk(KERN_ERR
 		       "Userland tools for TOMOYO 2.4 must be installed and "
 		       "policy must be initialized.\n");
 		printk(KERN_ERR "Please see http://tomoyo.sourceforge.jp/2.4/ "
 		       "for more information.\n");
 		panic("STOP!");
 	}
 	tomoyo_read_unlock(idx);
 	printk(KERN_INFO "Mandatory Access Control activated.\n");
 }
 /**
  * tomoyo_load_builtin_policy - Load built-in policy.
  *
  * Returns nothing.
  */
 void __init tomoyo_load_builtin_policy(void)
 {
 	/*
 	 * This include file is manually created and contains built-in policy
 	 * named "tomoyo_builtin_profile", "tomoyo_builtin_exception_policy",
 	 * "tomoyo_builtin_domain_policy", "tomoyo_builtin_manager",
 	 * "tomoyo_builtin_stat" in the form of "static char [] __initdata".
 	 */
 #include "builtin-policy.h"
 	u8 i;
 	const int idx = tomoyo_read_lock();
 	for (i = 0; i < 5; i++) {
 		struct tomoyo_io_buffer head = { };
 		char *start = "";
 		switch (i) {
 		case 0:
 			start = tomoyo_builtin_profile;
 			head.type = TOMOYO_PROFILE;
 			head.write = tomoyo_write_profile;
 			break;
 		case 1:
 			start = tomoyo_builtin_exception_policy;
 			head.type = TOMOYO_EXCEPTIONPOLICY;
 			head.write = tomoyo_write_exception;
 			break;
 		case 2:
 			start = tomoyo_builtin_domain_policy;
 			head.type = TOMOYO_DOMAINPOLICY;
 			head.write = tomoyo_write_domain;
 			break;
 		case 3:
 			start = tomoyo_builtin_manager;
 			head.type = TOMOYO_MANAGER;
 			head.write = tomoyo_write_manager;
 			break;
 		case 4:
 			start = tomoyo_builtin_stat;
 			head.type = TOMOYO_STAT;
 			head.write = tomoyo_write_stat;
 			break;
 		}
 		while (1) {
 			char *end = strchr(start, '\n');
 			if (!end)
 				break;
 			*end = '\0';
 			tomoyo_normalize_line(start);
 			head.write_buf = start;
 			tomoyo_parse_policy(&head, start);
 			start = end + 1;
 		}
 	}
 	tomoyo_read_unlock(idx);
 #ifdef CONFIG_SECURITY_TOMOYO_OMIT_USERSPACE_LOADER
 	tomoyo_check_profile();
 #endif

security/tomoyo/domain.c

Diff comments View file @ 0f2a55d

 /*
  * security/tomoyo/domain.c
  *
- * Domain transition functions for TOMOYO.
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
  */
 #include "common.h"
 #include <linux/binfmts.h>
 #include <linux/slab.h>
 /* Variables definitions.*/
 /* The initial domain. */
 struct tomoyo_domain_info tomoyo_kernel_domain;
 /**
  * tomoyo_update_policy - Update an entry for exception policy.
  *
  * @new_entry:       Pointer to "struct tomoyo_acl_info".
  * @size:            Size of @new_entry in bytes.
  * @param:           Pointer to "struct tomoyo_acl_param".
  * @check_duplicate: Callback function to find duplicated entry.
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 int tomoyo_update_policy(struct tomoyo_acl_head *new_entry, const int size,
 			 struct tomoyo_acl_param *param,
 			 bool (*check_duplicate) (const struct tomoyo_acl_head
 						  *,
 						  const struct tomoyo_acl_head
 						  *))
 {
 	int error = param->is_delete ? -ENOENT : -ENOMEM;
 	struct tomoyo_acl_head *entry;
 	struct list_head *list = param->list;
 	if (mutex_lock_interruptible(&tomoyo_policy_lock))
 		return -ENOMEM;
 	list_for_each_entry_rcu(entry, list, list) {
 		if (!check_duplicate(entry, new_entry))
 			continue;
 		entry->is_deleted = param->is_delete;
 		error = 0;
 		break;
 	}
 	if (error && !param->is_delete) {
 		entry = tomoyo_commit_ok(new_entry, size);
 		if (entry) {
 			list_add_tail_rcu(&entry->list, list);
 			error = 0;
 		}
 	}
 	mutex_unlock(&tomoyo_policy_lock);
 	return error;
 }
 /**
  * tomoyo_same_acl_head - Check for duplicated "struct tomoyo_acl_info" entry.
  *
  * @a: Pointer to "struct tomoyo_acl_info".
  * @b: Pointer to "struct tomoyo_acl_info".
  *
  * Returns true if @a == @b, false otherwise.
  */
 static inline bool tomoyo_same_acl_head(const struct tomoyo_acl_info *a,
 					const struct tomoyo_acl_info *b)
 {
 	return a->type == b->type && a->cond == b->cond;
 }
 /**
  * tomoyo_update_domain - Update an entry for domain policy.
  *
  * @new_entry:       Pointer to "struct tomoyo_acl_info".
  * @size:            Size of @new_entry in bytes.
  * @param:           Pointer to "struct tomoyo_acl_param".
  * @check_duplicate: Callback function to find duplicated entry.
  * @merge_duplicate: Callback function to merge duplicated entry.
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 int tomoyo_update_domain(struct tomoyo_acl_info *new_entry, const int size,
 			 struct tomoyo_acl_param *param,
 			 bool (*check_duplicate) (const struct tomoyo_acl_info
 						  *,
 						  const struct tomoyo_acl_info
 						  *),
 			 bool (*merge_duplicate) (struct tomoyo_acl_info *,
 						  struct tomoyo_acl_info *,
 						  const bool))
 {
 	const bool is_delete = param->is_delete;
 	int error = is_delete ? -ENOENT : -ENOMEM;
 	struct tomoyo_acl_info *entry;
 	struct list_head * const list = param->list;
 	if (param->data[0]) {
 		new_entry->cond = tomoyo_get_condition(param);
 		if (!new_entry->cond)
 			return -EINVAL;
 	}
 	if (mutex_lock_interruptible(&tomoyo_policy_lock))
 		goto out;
 	list_for_each_entry_rcu(entry, list, list) {
 		if (!tomoyo_same_acl_head(entry, new_entry) ||
 		    !check_duplicate(entry, new_entry))
 			continue;
 		if (merge_duplicate)
 			entry->is_deleted = merge_duplicate(entry, new_entry,
 							    is_delete);
 		else
 			entry->is_deleted = is_delete;
 		error = 0;
 		break;
 	}
 	if (error && !is_delete) {
 		entry = tomoyo_commit_ok(new_entry, size);
 		if (entry) {
 			list_add_tail_rcu(&entry->list, list);
 			error = 0;
 		}
 	}
 	mutex_unlock(&tomoyo_policy_lock);
 out:
 	tomoyo_put_condition(new_entry->cond);
 	return error;
 }
 /**
  * tomoyo_check_acl - Do permission check.
  *
  * @r:           Pointer to "struct tomoyo_request_info".
  * @check_entry: Callback function to check type specific parameters.
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 void tomoyo_check_acl(struct tomoyo_request_info *r,
 		      bool (*check_entry) (struct tomoyo_request_info *,
 					   const struct tomoyo_acl_info *))
 {
 	const struct tomoyo_domain_info *domain = r->domain;
 	struct tomoyo_acl_info *ptr;
 	bool retried = false;
 	const struct list_head *list = &domain->acl_info_list;
 retry:
 	list_for_each_entry_rcu(ptr, list, list) {
 		if (ptr->is_deleted || ptr->type != r->param_type)
 			continue;
 		if (!check_entry(r, ptr))
 			continue;
 		if (!tomoyo_condition(r, ptr->cond))
 			continue;
 		r->granted = true;
 		return;
 	}
 	if (!retried) {
 		retried = true;
 		list = &domain->ns->acl_group[domain->group];
 		goto retry;
 	}
 	r->granted = false;
 }
 /* The list for "struct tomoyo_domain_info". */
 LIST_HEAD(tomoyo_domain_list);
 /**
  * tomoyo_last_word - Get last component of a domainname.
  *
  * @name: Domainname to check.
  *
  * Returns the last word of @domainname.
  */
 static const char *tomoyo_last_word(const char *name)
 {
-        const char *cp = strrchr(name, ' ');
+	const char *cp = strrchr(name, ' ');
-        if (cp)
+	if (cp)
-                return cp + 1;
+		return cp + 1;
-        return name;
+	return name;
 }
 /**
  * tomoyo_same_transition_control - Check for duplicated "struct tomoyo_transition_control" entry.
  *
  * @a: Pointer to "struct tomoyo_acl_head".
  * @b: Pointer to "struct tomoyo_acl_head".
  *
  * Returns true if @a == @b, false otherwise.
  */
 static bool tomoyo_same_transition_control(const struct tomoyo_acl_head *a,
 					   const struct tomoyo_acl_head *b)
 {
 	const struct tomoyo_transition_control *p1 = container_of(a,
 								  typeof(*p1),
 								  head);
 	const struct tomoyo_transition_control *p2 = container_of(b,
 								  typeof(*p2),
 								  head);
 	return p1->type == p2->type && p1->is_last_name == p2->is_last_name
 		&& p1->domainname == p2->domainname
 		&& p1->program == p2->program;
 }
 /**
  * tomoyo_write_transition_control - Write "struct tomoyo_transition_control" list.
  *
  * @param: Pointer to "struct tomoyo_acl_param".
  * @type:  Type of this entry.
  *
  * Returns 0 on success, negative value otherwise.
  */
 int tomoyo_write_transition_control(struct tomoyo_acl_param *param,
 				    const u8 type)
 {
 	struct tomoyo_transition_control e = { .type = type };
 	int error = param->is_delete ? -ENOENT : -ENOMEM;
 	char *program = param->data;
 	char *domainname = strstr(program, " from ");
 	if (domainname) {
 		*domainname = '\0';
 		domainname += 6;
 	} else if (type == TOMOYO_TRANSITION_CONTROL_NO_KEEP ||
 		   type == TOMOYO_TRANSITION_CONTROL_KEEP) {
 		domainname = program;
 		program = NULL;
 	}
 	if (program && strcmp(program, "any")) {
 		if (!tomoyo_correct_path(program))
 			return -EINVAL;
 		e.program = tomoyo_get_name(program);
 		if (!e.program)
 			goto out;
 	}
 	if (domainname && strcmp(domainname, "any")) {
 		if (!tomoyo_correct_domain(domainname)) {
 			if (!tomoyo_correct_path(domainname))
 				goto out;
 			e.is_last_name = true;
 		}
 		e.domainname = tomoyo_get_name(domainname);
 		if (!e.domainname)
 			goto out;
 	}
 	param->list = &param->ns->policy_list[TOMOYO_ID_TRANSITION_CONTROL];
 	error = tomoyo_update_policy(&e.head, sizeof(e), param,
 				     tomoyo_same_transition_control);
 out:
 	tomoyo_put_name(e.domainname);
 	tomoyo_put_name(e.program);
 	return error;
 }
 /**
  * tomoyo_scan_transition - Try to find specific domain transition type.
  *
  * @list:       Pointer to "struct list_head".
  * @domainname: The name of current domain.
  * @program:    The name of requested program.
  * @last_name:  The last component of @domainname.
  * @type:       One of values in "enum tomoyo_transition_type".
  *
  * Returns true if found one, false otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static inline bool tomoyo_scan_transition
 (const struct list_head *list, const struct tomoyo_path_info *domainname,
  const struct tomoyo_path_info *program, const char *last_name,
  const enum tomoyo_transition_type type)
 {
 	const struct tomoyo_transition_control *ptr;
 	list_for_each_entry_rcu(ptr, list, head.list) {
 		if (ptr->head.is_deleted || ptr->type != type)
 			continue;
 		if (ptr->domainname) {
 			if (!ptr->is_last_name) {
 				if (ptr->domainname != domainname)
 					continue;
 			} else {
 				/*
 				 * Use direct strcmp() since this is
 				 * unlikely used.
 				 */
 				if (strcmp(ptr->domainname->name, last_name))
 					continue;
 			}
 		}
 		if (ptr->program && tomoyo_pathcmp(ptr->program, program))
 			continue;
 		return true;
 	}
 	return false;
 }
 /**
  * tomoyo_transition_type - Get domain transition type.
  *
  * @ns:         Pointer to "struct tomoyo_policy_namespace".
  * @domainname: The name of current domain.
  * @program:    The name of requested program.
  *
  * Returns TOMOYO_TRANSITION_CONTROL_TRANSIT if executing @program causes
  * domain transition across namespaces, TOMOYO_TRANSITION_CONTROL_INITIALIZE if
  * executing @program reinitializes domain transition within that namespace,
  * TOMOYO_TRANSITION_CONTROL_KEEP if executing @program stays at @domainname ,
  * others otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static enum tomoyo_transition_type tomoyo_transition_type
 (const struct tomoyo_policy_namespace *ns,
  const struct tomoyo_path_info *domainname,
  const struct tomoyo_path_info *program)
 {
 	const char *last_name = tomoyo_last_word(domainname->name);
 	enum tomoyo_transition_type type = TOMOYO_TRANSITION_CONTROL_NO_RESET;
 	while (type < TOMOYO_MAX_TRANSITION_TYPE) {
 		const struct list_head * const list =
 			&ns->policy_list[TOMOYO_ID_TRANSITION_CONTROL];
 		if (!tomoyo_scan_transition(list, domainname, program,
 					    last_name, type)) {
 			type++;
 			continue;
 		}
 		if (type != TOMOYO_TRANSITION_CONTROL_NO_RESET &&
 		    type != TOMOYO_TRANSITION_CONTROL_NO_INITIALIZE)
 			break;
 		/*
 		 * Do not check for reset_domain if no_reset_domain matched.
 		 * Do not check for initialize_domain if no_initialize_domain
 		 * matched.
 		 */
 		type++;
 		type++;
 	}
 	return type;
 }
 /**
  * tomoyo_same_aggregator - Check for duplicated "struct tomoyo_aggregator" entry.
  *
  * @a: Pointer to "struct tomoyo_acl_head".
  * @b: Pointer to "struct tomoyo_acl_head".
  *
  * Returns true if @a == @b, false otherwise.
  */
 static bool tomoyo_same_aggregator(const struct tomoyo_acl_head *a,
 				   const struct tomoyo_acl_head *b)
 {
 	const struct tomoyo_aggregator *p1 = container_of(a, typeof(*p1),
 							  head);
 	const struct tomoyo_aggregator *p2 = container_of(b, typeof(*p2),
 							  head);
 	return p1->original_name == p2->original_name &&
 		p1->aggregated_name == p2->aggregated_name;
 }
 /**
  * tomoyo_write_aggregator - Write "struct tomoyo_aggregator" list.
  *
  * @param: Pointer to "struct tomoyo_acl_param".
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 int tomoyo_write_aggregator(struct tomoyo_acl_param *param)
 {
 	struct tomoyo_aggregator e = { };
 	int error = param->is_delete ? -ENOENT : -ENOMEM;
 	const char *original_name = tomoyo_read_token(param);
 	const char *aggregated_name = tomoyo_read_token(param);
 	if (!tomoyo_correct_word(original_name) ||
 	    !tomoyo_correct_path(aggregated_name))
 		return -EINVAL;
 	e.original_name = tomoyo_get_name(original_name);
 	e.aggregated_name = tomoyo_get_name(aggregated_name);
 	if (!e.original_name || !e.aggregated_name ||
 	    e.aggregated_name->is_patterned) /* No patterns allowed. */
 		goto out;
 	param->list = &param->ns->policy_list[TOMOYO_ID_AGGREGATOR];
 	error = tomoyo_update_policy(&e.head, sizeof(e), param,
 				     tomoyo_same_aggregator);
 out:
 	tomoyo_put_name(e.original_name);
 	tomoyo_put_name(e.aggregated_name);
 	return error;
 }
 /**
  * tomoyo_find_namespace - Find specified namespace.
  *
  * @name: Name of namespace to find.
  * @len:  Length of @name.
  *
  * Returns pointer to "struct tomoyo_policy_namespace" if found,
  * NULL otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static struct tomoyo_policy_namespace *tomoyo_find_namespace
 (const char *name, const unsigned int len)
 {
 	struct tomoyo_policy_namespace *ns;
 	list_for_each_entry(ns, &tomoyo_namespace_list, namespace_list) {
 		if (strncmp(name, ns->name, len) ||
 		    (name[len] && name[len] != ' '))
 			continue;
 		return ns;
 	}
 	return NULL;
 }
 /**
  * tomoyo_assign_namespace - Create a new namespace.
  *
  * @domainname: Name of namespace to create.
  *
  * Returns pointer to "struct tomoyo_policy_namespace" on success,
  * NULL otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 struct tomoyo_policy_namespace *tomoyo_assign_namespace(const char *domainname)
 {
 	struct tomoyo_policy_namespace *ptr;
 	struct tomoyo_policy_namespace *entry;
 	const char *cp = domainname;
 	unsigned int len = 0;
 	while (*cp && *cp++ != ' ')
 		len++;
 	ptr = tomoyo_find_namespace(domainname, len);
 	if (ptr)
 		return ptr;
 	if (len >= TOMOYO_EXEC_TMPSIZE - 10 || !tomoyo_domain_def(domainname))
 		return NULL;
 	entry = kzalloc(sizeof(*entry) + len + 1, GFP_NOFS);
 	if (!entry)
 		return NULL;
 	if (mutex_lock_interruptible(&tomoyo_policy_lock))
 		goto out;
 	ptr = tomoyo_find_namespace(domainname, len);
 	if (!ptr && tomoyo_memory_ok(entry)) {
 		char *name = (char *) (entry + 1);
 		ptr = entry;
 		memmove(name, domainname, len);
 		name[len] = '\0';
 		entry->name = name;
 		tomoyo_init_policy_namespace(entry);
 		entry = NULL;
 	}
 	mutex_unlock(&tomoyo_policy_lock);
 out:
 	kfree(entry);
 	return ptr;
 }
 /**
  * tomoyo_namespace_jump - Check for namespace jump.
  *
  * @domainname: Name of domain.
  *
  * Returns true if namespace differs, false otherwise.
  */
 static bool tomoyo_namespace_jump(const char *domainname)
 {
 	const char *namespace = tomoyo_current_namespace()->name;
 	const int len = strlen(namespace);
 	return strncmp(domainname, namespace, len) ||
 		(domainname[len] && domainname[len] != ' ');
 }
 /**
  * tomoyo_assign_domain - Create a domain or a namespace.
  *
  * @domainname: The name of domain.
  * @transit:    True if transit to domain found or created.
  *
  * Returns pointer to "struct tomoyo_domain_info" on success, NULL otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 struct tomoyo_domain_info *tomoyo_assign_domain(const char *domainname,
 						const bool transit)
 {
 	struct tomoyo_domain_info e = { };
 	struct tomoyo_domain_info *entry = tomoyo_find_domain(domainname);
 	bool created = false;
 	if (entry) {
 		if (transit) {
 			/*
 			 * Since namespace is created at runtime, profiles may
 			 * not be created by the moment the process transits to
 			 * that domain. Do not perform domain transition if
 			 * profile for that domain is not yet created.
 			 */
 			if (!entry->ns->profile_ptr[entry->profile])
 				return NULL;
 		}
 		return entry;
 	}
 	/* Requested domain does not exist. */
 	/* Don't create requested domain if domainname is invalid. */
 	if (strlen(domainname) >= TOMOYO_EXEC_TMPSIZE - 10 ||
 	    !tomoyo_correct_domain(domainname))
 		return NULL;
 	/*
 	 * Since definition of profiles and acl_groups may differ across
 	 * namespaces, do not inherit "use_profile" and "use_group" settings
 	 * by automatically creating requested domain upon domain transition.
 	 */
 	if (transit && tomoyo_namespace_jump(domainname))
 		return NULL;
 	e.ns = tomoyo_assign_namespace(domainname);
 	if (!e.ns)
 		return NULL;
 	/*
 	 * "use_profile" and "use_group" settings for automatically created
 	 * domains are inherited from current domain. These are 0 for manually
 	 * created domains.
 	 */
 	if (transit) {
 		const struct tomoyo_domain_info *domain = tomoyo_domain();
 		e.profile = domain->profile;
 		e.group = domain->group;
 	}
 	e.domainname = tomoyo_get_name(domainname);
 	if (!e.domainname)
 		return NULL;
 	if (mutex_lock_interruptible(&tomoyo_policy_lock))
 		goto out;
 	entry = tomoyo_find_domain(domainname);
 	if (!entry) {
 		entry = tomoyo_commit_ok(&e, sizeof(e));
 		if (entry) {
 			INIT_LIST_HEAD(&entry->acl_info_list);
 			list_add_tail_rcu(&entry->list, &tomoyo_domain_list);
 			created = true;
 		}
 	}
 	mutex_unlock(&tomoyo_policy_lock);
 out:
 	tomoyo_put_name(e.domainname);
 	if (entry && transit) {
 		if (created) {
 			struct tomoyo_request_info r;
 			tomoyo_init_request_info(&r, entry,
 						 TOMOYO_MAC_FILE_EXECUTE);
 			r.granted = false;
 			tomoyo_write_log(&r, "use_profile %u\n",
 					 entry->profile);
 			tomoyo_write_log(&r, "use_group %u\n", entry->group);
 		}
 	}
 	return entry;
 }
 /**
  * tomoyo_find_next_domain - Find a domain.
  *
  * @bprm: Pointer to "struct linux_binprm".
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 int tomoyo_find_next_domain(struct linux_binprm *bprm)
 {
 	struct tomoyo_domain_info *old_domain = tomoyo_domain();
 	struct tomoyo_domain_info *domain = NULL;
 	const char *original_name = bprm->filename;
 	int retval = -ENOMEM;
 	bool need_kfree = false;
 	bool reject_on_transition_failure = false;
 	struct tomoyo_path_info rn = { }; /* real name */
 	struct tomoyo_execve *ee = kzalloc(sizeof(*ee), GFP_NOFS);
 	if (!ee)
 		return -ENOMEM;
 	ee->tmp = kzalloc(TOMOYO_EXEC_TMPSIZE, GFP_NOFS);
 	if (!ee->tmp) {
 		kfree(ee);
 		return -ENOMEM;
 	}
 	/* ee->dump->data is allocated by tomoyo_dump_page(). */
 	tomoyo_init_request_info(&ee->r, NULL, TOMOYO_MAC_FILE_EXECUTE);
 	ee->r.ee = ee;
 	ee->bprm = bprm;
 	ee->r.obj = &ee->obj;
 	ee->obj.path1 = bprm->file->f_path;
  retry:
 	if (need_kfree) {
 		kfree(rn.name);
 		need_kfree = false;
 	}
 	/* Get symlink's pathname of program. */
 	retval = -ENOENT;
 	rn.name = tomoyo_realpath_nofollow(original_name);
 	if (!rn.name)
 		goto out;
 	tomoyo_fill_path_info(&rn);
 	need_kfree = true;
 	/* Check 'aggregator' directive. */
 	{
 		struct tomoyo_aggregator *ptr;
 		struct list_head *list =
 			&old_domain->ns->policy_list[TOMOYO_ID_AGGREGATOR];
 		/* Check 'aggregator' directive. */
 		list_for_each_entry_rcu(ptr, list, head.list) {
 			if (ptr->head.is_deleted ||
 			    !tomoyo_path_matches_pattern(&rn,
 							 ptr->original_name))
 				continue;
 			kfree(rn.name);
 			need_kfree = false;
 			/* This is OK because it is read only. */
 			rn = *ptr->aggregated_name;
 			break;
 		}
 	}
 	/* Check execute permission. */
 	retval = tomoyo_path_permission(&ee->r, TOMOYO_TYPE_EXECUTE, &rn);
 	if (retval == TOMOYO_RETRY_REQUEST)
 		goto retry;
 	if (retval < 0)
 		goto out;
 	/*
 	 * To be able to specify domainnames with wildcards, use the
 	 * pathname specified in the policy (which may contain
 	 * wildcard) rather than the pathname passed to execve()
 	 * (which never contains wildcard).
 	 */
 	if (ee->r.param.path.matched_path) {
 		if (need_kfree)
 			kfree(rn.name);
 		need_kfree = false;
 		/* This is OK because it is read only. */
 		rn = *ee->r.param.path.matched_path;
 	}
 	/* Calculate domain to transit to. */
 	switch (tomoyo_transition_type(old_domain->ns, old_domain->domainname,
 				       &rn)) {
 	case TOMOYO_TRANSITION_CONTROL_RESET:
 		/* Transit to the root of specified namespace. */
 		snprintf(ee->tmp, TOMOYO_EXEC_TMPSIZE - 1, "<%s>", rn.name);
 		/*
 		 * Make do_execve() fail if domain transition across namespaces
 		 * has failed.
 		 */
 		reject_on_transition_failure = true;
 		break;
 	case TOMOYO_TRANSITION_CONTROL_INITIALIZE:
 		/* Transit to the child of current namespace's root. */
 		snprintf(ee->tmp, TOMOYO_EXEC_TMPSIZE - 1, "%s %s",
 			 old_domain->ns->name, rn.name);
 		break;
 	case TOMOYO_TRANSITION_CONTROL_KEEP:
 		/* Keep current domain. */
 		domain = old_domain;
 		break;
 	default:
 		if (old_domain == &tomoyo_kernel_domain &&
 		    !tomoyo_policy_loaded) {
 			/*
 			 * Needn't to transit from kernel domain before
 			 * starting /sbin/init. But transit from kernel domain
 			 * if executing initializers because they might start
 			 * before /sbin/init.
 			 */
 			domain = old_domain;
 		} else {
 			/* Normal domain transition. */
 			snprintf(ee->tmp, TOMOYO_EXEC_TMPSIZE - 1, "%s %s",
 				 old_domain->domainname->name, rn.name);
 		}
 		break;
 	}
 	if (!domain)
 		domain = tomoyo_assign_domain(ee->tmp, true);
 	if (domain)
 		retval = 0;
 	else if (reject_on_transition_failure) {
 		printk(KERN_WARNING "ERROR: Domain '%s' not ready.\n",
 		       ee->tmp);
 		retval = -ENOMEM;
 	} else if (ee->r.mode == TOMOYO_CONFIG_ENFORCING)
 		retval = -ENOMEM;
 	else {
 		retval = 0;
 		if (!old_domain->flags[TOMOYO_DIF_TRANSITION_FAILED]) {
 			old_domain->flags[TOMOYO_DIF_TRANSITION_FAILED] = true;
 			ee->r.granted = false;
 			tomoyo_write_log(&ee->r, "%s", tomoyo_dif
 					 [TOMOYO_DIF_TRANSITION_FAILED]);
 			printk(KERN_WARNING
 			       "ERROR: Domain '%s' not defined.\n", ee->tmp);
 		}
 	}
  out:
 	if (!domain)
 		domain = old_domain;
 	/* Update reference count on "struct tomoyo_domain_info". */
 	atomic_inc(&domain->users);
 	bprm->cred->security = domain;
 	if (need_kfree)
 		kfree(rn.name);
 	kfree(ee->tmp);
 	kfree(ee->dump.data);
 	kfree(ee);
 	return retval;
 }
 /**
  * tomoyo_dump_page - Dump a page to buffer.
  *
  * @bprm: Pointer to "struct linux_binprm".
  * @pos:  Location to dump.
  * @dump: Poiner to "struct tomoyo_page_dump".
  *
  * Returns true on success, false otherwise.
  */
 bool tomoyo_dump_page(struct linux_binprm *bprm, unsigned long pos,
 		      struct tomoyo_page_dump *dump)
 {
 	struct page *page;
 	/* dump->data is released by tomoyo_finish_execve(). */
 	if (!dump->data) {
 		dump->data = kzalloc(PAGE_SIZE, GFP_NOFS);
 		if (!dump->data)
 			return false;
 	}
 	/* Same with get_arg_page(bprm, pos, 0) in fs/exec.c */
 #ifdef CONFIG_MMU
 	if (get_user_pages(current, bprm->mm, pos, 1, 0, 1, &page, NULL) <= 0)
 		return false;
 #else
 	page = bprm->page[pos / PAGE_SIZE];
 #endif
 	if (page != dump->page) {
 		const unsigned int offset = pos % PAGE_SIZE;
 		/*
 		 * Maybe kmap()/kunmap() should be used here.
 		 * But remove_arg_zero() uses kmap_atomic()/kunmap_atomic().
 		 * So do I.
 		 */
 		char *kaddr = kmap_atomic(page, KM_USER0);
 		dump->page = page;
 		memcpy(dump->data + offset, kaddr + offset,
 		       PAGE_SIZE - offset);
 		kunmap_atomic(kaddr, KM_USER0);
 	}
 	/* Same with put_arg_page(page) in fs/exec.c */
 #ifdef CONFIG_MMU
 	put_page(page);
 #endif
 	return true;
 }

security/tomoyo/file.c

Diff comments View file @ 0f2a55d

 /*
  * security/tomoyo/file.c
  *
- * Pathname restriction functions.
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
  */
 #include "common.h"
 #include <linux/slab.h>
 /*
  * Mapping table from "enum tomoyo_path_acl_index" to "enum tomoyo_mac_index".
  */
 static const u8 tomoyo_p2mac[TOMOYO_MAX_PATH_OPERATION] = {
 	[TOMOYO_TYPE_EXECUTE]    = TOMOYO_MAC_FILE_EXECUTE,
 	[TOMOYO_TYPE_READ]       = TOMOYO_MAC_FILE_OPEN,
 	[TOMOYO_TYPE_WRITE]      = TOMOYO_MAC_FILE_OPEN,
 	[TOMOYO_TYPE_APPEND]     = TOMOYO_MAC_FILE_OPEN,
 	[TOMOYO_TYPE_UNLINK]     = TOMOYO_MAC_FILE_UNLINK,
 	[TOMOYO_TYPE_GETATTR]    = TOMOYO_MAC_FILE_GETATTR,
 	[TOMOYO_TYPE_RMDIR]      = TOMOYO_MAC_FILE_RMDIR,
 	[TOMOYO_TYPE_TRUNCATE]   = TOMOYO_MAC_FILE_TRUNCATE,
 	[TOMOYO_TYPE_SYMLINK]    = TOMOYO_MAC_FILE_SYMLINK,
 	[TOMOYO_TYPE_CHROOT]     = TOMOYO_MAC_FILE_CHROOT,
 	[TOMOYO_TYPE_UMOUNT]     = TOMOYO_MAC_FILE_UMOUNT,
 };
 /*
  * Mapping table from "enum tomoyo_mkdev_acl_index" to "enum tomoyo_mac_index".
  */
 const u8 tomoyo_pnnn2mac[TOMOYO_MAX_MKDEV_OPERATION] = {
 	[TOMOYO_TYPE_MKBLOCK] = TOMOYO_MAC_FILE_MKBLOCK,
 	[TOMOYO_TYPE_MKCHAR]  = TOMOYO_MAC_FILE_MKCHAR,
 };
 /*
  * Mapping table from "enum tomoyo_path2_acl_index" to "enum tomoyo_mac_index".
  */
 const u8 tomoyo_pp2mac[TOMOYO_MAX_PATH2_OPERATION] = {
 	[TOMOYO_TYPE_LINK]       = TOMOYO_MAC_FILE_LINK,
 	[TOMOYO_TYPE_RENAME]     = TOMOYO_MAC_FILE_RENAME,
 	[TOMOYO_TYPE_PIVOT_ROOT] = TOMOYO_MAC_FILE_PIVOT_ROOT,
 };
 /*
  * Mapping table from "enum tomoyo_path_number_acl_index" to
  * "enum tomoyo_mac_index".
  */
 const u8 tomoyo_pn2mac[TOMOYO_MAX_PATH_NUMBER_OPERATION] = {
 	[TOMOYO_TYPE_CREATE] = TOMOYO_MAC_FILE_CREATE,
 	[TOMOYO_TYPE_MKDIR]  = TOMOYO_MAC_FILE_MKDIR,
 	[TOMOYO_TYPE_MKFIFO] = TOMOYO_MAC_FILE_MKFIFO,
 	[TOMOYO_TYPE_MKSOCK] = TOMOYO_MAC_FILE_MKSOCK,
 	[TOMOYO_TYPE_IOCTL]  = TOMOYO_MAC_FILE_IOCTL,
 	[TOMOYO_TYPE_CHMOD]  = TOMOYO_MAC_FILE_CHMOD,
 	[TOMOYO_TYPE_CHOWN]  = TOMOYO_MAC_FILE_CHOWN,
 	[TOMOYO_TYPE_CHGRP]  = TOMOYO_MAC_FILE_CHGRP,
 };
 /**
  * tomoyo_put_name_union - Drop reference on "struct tomoyo_name_union".
  *
  * @ptr: Pointer to "struct tomoyo_name_union".
  *
  * Returns nothing.
  */
 void tomoyo_put_name_union(struct tomoyo_name_union *ptr)
 {
 	tomoyo_put_group(ptr->group);
 	tomoyo_put_name(ptr->filename);
 }
 /**
  * tomoyo_compare_name_union - Check whether a name matches "struct tomoyo_name_union" or not.
  *
  * @name: Pointer to "struct tomoyo_path_info".
  * @ptr:  Pointer to "struct tomoyo_name_union".
  *
  * Returns "struct tomoyo_path_info" if @name matches @ptr, NULL otherwise.
  */
 const struct tomoyo_path_info *
 tomoyo_compare_name_union(const struct tomoyo_path_info *name,
 			  const struct tomoyo_name_union *ptr)
 {
 	if (ptr->group)
 		return tomoyo_path_matches_group(name, ptr->group);
 	if (tomoyo_path_matches_pattern(name, ptr->filename))
 		return ptr->filename;
 	return NULL;
 }
 /**
  * tomoyo_put_number_union - Drop reference on "struct tomoyo_number_union".
  *
  * @ptr: Pointer to "struct tomoyo_number_union".
  *
  * Returns nothing.
  */
 void tomoyo_put_number_union(struct tomoyo_number_union *ptr)
 {
 	tomoyo_put_group(ptr->group);
 }
 /**
  * tomoyo_compare_number_union - Check whether a value matches "struct tomoyo_number_union" or not.
  *
  * @value: Number to check.
  * @ptr:   Pointer to "struct tomoyo_number_union".
  *
  * Returns true if @value matches @ptr, false otherwise.
  */
 bool tomoyo_compare_number_union(const unsigned long value,
 				 const struct tomoyo_number_union *ptr)
 {
 	if (ptr->group)
 		return tomoyo_number_matches_group(value, value, ptr->group);
 	return value >= ptr->values[0] && value <= ptr->values[1];
 }
 /**
  * tomoyo_add_slash - Add trailing '/' if needed.
  *
  * @buf: Pointer to "struct tomoyo_path_info".
  *
  * Returns nothing.
  *
  * @buf must be generated by tomoyo_encode() because this function does not
  * allocate memory for adding '/'.
  */
 static void tomoyo_add_slash(struct tomoyo_path_info *buf)
 {
 	if (buf->is_dir)
 		return;
 	/*
 	 * This is OK because tomoyo_encode() reserves space for appending "/".
 	 */
 	strcat((char *) buf->name, "/");
 	tomoyo_fill_path_info(buf);
 }
 /**
  * tomoyo_get_realpath - Get realpath.
  *
  * @buf:  Pointer to "struct tomoyo_path_info".
  * @path: Pointer to "struct path".
  *
  * Returns true on success, false otherwise.
  */
 static bool tomoyo_get_realpath(struct tomoyo_path_info *buf, struct path *path)
 {
 	buf->name = tomoyo_realpath_from_path(path);
 	if (buf->name) {
 		tomoyo_fill_path_info(buf);
 		return true;
 	}
-        return false;
+	return false;
 }
 /**
  * tomoyo_audit_path_log - Audit path request log.
  *
  * @r: Pointer to "struct tomoyo_request_info".
  *
  * Returns 0 on success, negative value otherwise.
  */
 static int tomoyo_audit_path_log(struct tomoyo_request_info *r)
 {
 	return tomoyo_supervisor(r, "file %s %s\n", tomoyo_path_keyword
 				 [r->param.path.operation],
 				 r->param.path.filename->name);
 }
 /**
  * tomoyo_audit_path2_log - Audit path/path request log.
  *
  * @r: Pointer to "struct tomoyo_request_info".
  *
  * Returns 0 on success, negative value otherwise.
  */
 static int tomoyo_audit_path2_log(struct tomoyo_request_info *r)
 {
 	return tomoyo_supervisor(r, "file %s %s %s\n", tomoyo_mac_keywords
 				 [tomoyo_pp2mac[r->param.path2.operation]],
 				 r->param.path2.filename1->name,
 				 r->param.path2.filename2->name);
 }
 /**
  * tomoyo_audit_mkdev_log - Audit path/number/number/number request log.
  *
  * @r: Pointer to "struct tomoyo_request_info".
  *
  * Returns 0 on success, negative value otherwise.
  */
 static int tomoyo_audit_mkdev_log(struct tomoyo_request_info *r)
 {
 	return tomoyo_supervisor(r, "file %s %s 0%o %u %u\n",
 				 tomoyo_mac_keywords
 				 [tomoyo_pnnn2mac[r->param.mkdev.operation]],
 				 r->param.mkdev.filename->name,
 				 r->param.mkdev.mode, r->param.mkdev.major,
 				 r->param.mkdev.minor);
 }
 /**
  * tomoyo_audit_path_number_log - Audit path/number request log.
  *
  * @r: Pointer to "struct tomoyo_request_info".
  *
  * Returns 0 on success, negative value otherwise.
  */
 static int tomoyo_audit_path_number_log(struct tomoyo_request_info *r)
 {
 	const u8 type = r->param.path_number.operation;
 	u8 radix;
 	char buffer[64];
 	switch (type) {
 	case TOMOYO_TYPE_CREATE:
 	case TOMOYO_TYPE_MKDIR:
 	case TOMOYO_TYPE_MKFIFO:
 	case TOMOYO_TYPE_MKSOCK:
 	case TOMOYO_TYPE_CHMOD:
 		radix = TOMOYO_VALUE_TYPE_OCTAL;
 		break;
 	case TOMOYO_TYPE_IOCTL:
 		radix = TOMOYO_VALUE_TYPE_HEXADECIMAL;
 		break;
 	default:
 		radix = TOMOYO_VALUE_TYPE_DECIMAL;
 		break;
 	}
 	tomoyo_print_ulong(buffer, sizeof(buffer), r->param.path_number.number,
 			   radix);
 	return tomoyo_supervisor(r, "file %s %s %s\n", tomoyo_mac_keywords
 				 [tomoyo_pn2mac[type]],
 				 r->param.path_number.filename->name, buffer);
 }
 /**
  * tomoyo_check_path_acl - Check permission for path operation.
  *
  * @r:   Pointer to "struct tomoyo_request_info".
  * @ptr: Pointer to "struct tomoyo_acl_info".
  *
  * Returns true if granted, false otherwise.
  *
  * To be able to use wildcard for domain transition, this function sets
  * matching entry on success. Since the caller holds tomoyo_read_lock(),
  * it is safe to set matching entry.
  */
 static bool tomoyo_check_path_acl(struct tomoyo_request_info *r,
 				  const struct tomoyo_acl_info *ptr)
 {
 	const struct tomoyo_path_acl *acl = container_of(ptr, typeof(*acl),
 							 head);
 	if (acl->perm & (1 << r->param.path.operation)) {
 		r->param.path.matched_path =
 			tomoyo_compare_name_union(r->param.path.filename,
 						  &acl->name);
 		return r->param.path.matched_path != NULL;
 	}
 	return false;
 }
 /**
  * tomoyo_check_path_number_acl - Check permission for path number operation.
  *
  * @r:   Pointer to "struct tomoyo_request_info".
  * @ptr: Pointer to "struct tomoyo_acl_info".
  *
  * Returns true if granted, false otherwise.
  */
 static bool tomoyo_check_path_number_acl(struct tomoyo_request_info *r,
 					 const struct tomoyo_acl_info *ptr)
 {
 	const struct tomoyo_path_number_acl *acl =
 		container_of(ptr, typeof(*acl), head);
 	return (acl->perm & (1 << r->param.path_number.operation)) &&
 		tomoyo_compare_number_union(r->param.path_number.number,
 					    &acl->number) &&
 		tomoyo_compare_name_union(r->param.path_number.filename,
 					  &acl->name);
 }
 /**
  * tomoyo_check_path2_acl - Check permission for path path operation.
  *
  * @r:   Pointer to "struct tomoyo_request_info".
  * @ptr: Pointer to "struct tomoyo_acl_info".
  *
  * Returns true if granted, false otherwise.
  */
 static bool tomoyo_check_path2_acl(struct tomoyo_request_info *r,
 				   const struct tomoyo_acl_info *ptr)
 {
 	const struct tomoyo_path2_acl *acl =
 		container_of(ptr, typeof(*acl), head);
 	return (acl->perm & (1 << r->param.path2.operation)) &&
 		tomoyo_compare_name_union(r->param.path2.filename1, &acl->name1)
 		&& tomoyo_compare_name_union(r->param.path2.filename2,
 					     &acl->name2);
 }
 /**
  * tomoyo_check_mkdev_acl - Check permission for path number number number operation.
  *
  * @r:   Pointer to "struct tomoyo_request_info".
  * @ptr: Pointer to "struct tomoyo_acl_info".
  *
  * Returns true if granted, false otherwise.
  */
 static bool tomoyo_check_mkdev_acl(struct tomoyo_request_info *r,
 				   const struct tomoyo_acl_info *ptr)
 {
 	const struct tomoyo_mkdev_acl *acl =
 		container_of(ptr, typeof(*acl), head);
 	return (acl->perm & (1 << r->param.mkdev.operation)) &&
 		tomoyo_compare_number_union(r->param.mkdev.mode,
 					    &acl->mode) &&
 		tomoyo_compare_number_union(r->param.mkdev.major,
 					    &acl->major) &&
 		tomoyo_compare_number_union(r->param.mkdev.minor,
 					    &acl->minor) &&
 		tomoyo_compare_name_union(r->param.mkdev.filename,
 					  &acl->name);
 }
 /**
  * tomoyo_same_path_acl - Check for duplicated "struct tomoyo_path_acl" entry.
  *
  * @a: Pointer to "struct tomoyo_acl_info".
  * @b: Pointer to "struct tomoyo_acl_info".
  *
  * Returns true if @a == @b except permission bits, false otherwise.
  */
 static bool tomoyo_same_path_acl(const struct tomoyo_acl_info *a,
 				 const struct tomoyo_acl_info *b)
 {
 	const struct tomoyo_path_acl *p1 = container_of(a, typeof(*p1), head);
 	const struct tomoyo_path_acl *p2 = container_of(b, typeof(*p2), head);
 	return tomoyo_same_name_union(&p1->name, &p2->name);
 }
 /**
  * tomoyo_merge_path_acl - Merge duplicated "struct tomoyo_path_acl" entry.
  *
  * @a:         Pointer to "struct tomoyo_acl_info".
  * @b:         Pointer to "struct tomoyo_acl_info".
  * @is_delete: True for @a &= ~@b, false for @a |= @b.
  *
  * Returns true if @a is empty, false otherwise.
  */
 static bool tomoyo_merge_path_acl(struct tomoyo_acl_info *a,
 				  struct tomoyo_acl_info *b,
 				  const bool is_delete)
 {
 	u16 * const a_perm = &container_of(a, struct tomoyo_path_acl, head)
 		->perm;
 	u16 perm = *a_perm;
 	const u16 b_perm = container_of(b, struct tomoyo_path_acl, head)->perm;
 	if (is_delete)
 		perm &= ~b_perm;
 	else
 		perm |= b_perm;
 	*a_perm = perm;
 	return !perm;
 }
 /**
  * tomoyo_update_path_acl - Update "struct tomoyo_path_acl" list.
  *
  * @perm:  Permission.
  * @param: Pointer to "struct tomoyo_acl_param".
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static int tomoyo_update_path_acl(const u16 perm,
 				  struct tomoyo_acl_param *param)
 {
 	struct tomoyo_path_acl e = {
 		.head.type = TOMOYO_TYPE_PATH_ACL,
 		.perm = perm
 	};
 	int error;
 	if (!tomoyo_parse_name_union(param, &e.name))
 		error = -EINVAL;
 	else
 		error = tomoyo_update_domain(&e.head, sizeof(e), param,
 					     tomoyo_same_path_acl,
 					     tomoyo_merge_path_acl);
 	tomoyo_put_name_union(&e.name);
 	return error;
 }
 /**
  * tomoyo_same_mkdev_acl - Check for duplicated "struct tomoyo_mkdev_acl" entry.
  *
  * @a: Pointer to "struct tomoyo_acl_info".
  * @b: Pointer to "struct tomoyo_acl_info".
  *
  * Returns true if @a == @b except permission bits, false otherwise.
  */
 static bool tomoyo_same_mkdev_acl(const struct tomoyo_acl_info *a,
 					 const struct tomoyo_acl_info *b)
 {
 	const struct tomoyo_mkdev_acl *p1 = container_of(a, typeof(*p1), head);
 	const struct tomoyo_mkdev_acl *p2 = container_of(b, typeof(*p2), head);
 	return tomoyo_same_name_union(&p1->name, &p2->name) &&
 		tomoyo_same_number_union(&p1->mode, &p2->mode) &&
 		tomoyo_same_number_union(&p1->major, &p2->major) &&
 		tomoyo_same_number_union(&p1->minor, &p2->minor);
 }
 /**
  * tomoyo_merge_mkdev_acl - Merge duplicated "struct tomoyo_mkdev_acl" entry.
  *
  * @a:         Pointer to "struct tomoyo_acl_info".
  * @b:         Pointer to "struct tomoyo_acl_info".
  * @is_delete: True for @a &= ~@b, false for @a |= @b.
  *
  * Returns true if @a is empty, false otherwise.
  */
 static bool tomoyo_merge_mkdev_acl(struct tomoyo_acl_info *a,
 				   struct tomoyo_acl_info *b,
 				   const bool is_delete)
 {
 	u8 *const a_perm = &container_of(a, struct tomoyo_mkdev_acl,
 					 head)->perm;
 	u8 perm = *a_perm;
 	const u8 b_perm = container_of(b, struct tomoyo_mkdev_acl, head)
 		->perm;
 	if (is_delete)
 		perm &= ~b_perm;
 	else
 		perm |= b_perm;
 	*a_perm = perm;
 	return !perm;
 }
 /**
  * tomoyo_update_mkdev_acl - Update "struct tomoyo_mkdev_acl" list.
  *
  * @perm:  Permission.
  * @param: Pointer to "struct tomoyo_acl_param".
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static int tomoyo_update_mkdev_acl(const u8 perm,
 				   struct tomoyo_acl_param *param)
 {
 	struct tomoyo_mkdev_acl e = {
 		.head.type = TOMOYO_TYPE_MKDEV_ACL,
 		.perm = perm
 	};
 	int error;
 	if (!tomoyo_parse_name_union(param, &e.name) ||
 	    !tomoyo_parse_number_union(param, &e.mode) ||
 	    !tomoyo_parse_number_union(param, &e.major) ||
 	    !tomoyo_parse_number_union(param, &e.minor))
 		error = -EINVAL;
 	else
 		error = tomoyo_update_domain(&e.head, sizeof(e), param,
 					     tomoyo_same_mkdev_acl,
 					     tomoyo_merge_mkdev_acl);
 	tomoyo_put_name_union(&e.name);
 	tomoyo_put_number_union(&e.mode);
 	tomoyo_put_number_union(&e.major);
 	tomoyo_put_number_union(&e.minor);
 	return error;
 }
 /**
  * tomoyo_same_path2_acl - Check for duplicated "struct tomoyo_path2_acl" entry.
  *
  * @a: Pointer to "struct tomoyo_acl_info".
  * @b: Pointer to "struct tomoyo_acl_info".
  *
  * Returns true if @a == @b except permission bits, false otherwise.
  */
 static bool tomoyo_same_path2_acl(const struct tomoyo_acl_info *a,
 				  const struct tomoyo_acl_info *b)
 {
 	const struct tomoyo_path2_acl *p1 = container_of(a, typeof(*p1), head);
 	const struct tomoyo_path2_acl *p2 = container_of(b, typeof(*p2), head);
 	return tomoyo_same_name_union(&p1->name1, &p2->name1) &&
 		tomoyo_same_name_union(&p1->name2, &p2->name2);
 }
 /**
  * tomoyo_merge_path2_acl - Merge duplicated "struct tomoyo_path2_acl" entry.
  *
  * @a:         Pointer to "struct tomoyo_acl_info".
  * @b:         Pointer to "struct tomoyo_acl_info".
  * @is_delete: True for @a &= ~@b, false for @a |= @b.
  *
  * Returns true if @a is empty, false otherwise.
  */
 static bool tomoyo_merge_path2_acl(struct tomoyo_acl_info *a,
 				   struct tomoyo_acl_info *b,
 				   const bool is_delete)
 {
 	u8 * const a_perm = &container_of(a, struct tomoyo_path2_acl, head)
 		->perm;
 	u8 perm = *a_perm;
 	const u8 b_perm = container_of(b, struct tomoyo_path2_acl, head)->perm;
 	if (is_delete)
 		perm &= ~b_perm;
 	else
 		perm |= b_perm;
 	*a_perm = perm;
 	return !perm;
 }
 /**
  * tomoyo_update_path2_acl - Update "struct tomoyo_path2_acl" list.
  *
  * @perm:  Permission.
  * @param: Pointer to "struct tomoyo_acl_param".
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static int tomoyo_update_path2_acl(const u8 perm,
 				   struct tomoyo_acl_param *param)
 {
 	struct tomoyo_path2_acl e = {
 		.head.type = TOMOYO_TYPE_PATH2_ACL,
 		.perm = perm
 	};
 	int error;
 	if (!tomoyo_parse_name_union(param, &e.name1) ||
 	    !tomoyo_parse_name_union(param, &e.name2))
 		error = -EINVAL;
 	else
 		error = tomoyo_update_domain(&e.head, sizeof(e), param,
 					     tomoyo_same_path2_acl,
 					     tomoyo_merge_path2_acl);
 	tomoyo_put_name_union(&e.name1);
 	tomoyo_put_name_union(&e.name2);
 	return error;
 }
 /**
  * tomoyo_path_permission - Check permission for single path operation.
  *
  * @r:         Pointer to "struct tomoyo_request_info".
  * @operation: Type of operation.
  * @filename:  Filename to check.
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation,
 			   const struct tomoyo_path_info *filename)
 {
 	int error;
 	r->type = tomoyo_p2mac[operation];
 	r->mode = tomoyo_get_mode(r->domain->ns, r->profile, r->type);
 	if (r->mode == TOMOYO_CONFIG_DISABLED)
 		return 0;
 	r->param_type = TOMOYO_TYPE_PATH_ACL;
 	r->param.path.filename = filename;
 	r->param.path.operation = operation;
 	do {
 		tomoyo_check_acl(r, tomoyo_check_path_acl);
 		error = tomoyo_audit_path_log(r);
 		/*
 		 * Do not retry for execute request, for alias may have
 		 * changed.
 		 */
 	} while (error == TOMOYO_RETRY_REQUEST &&
 		 operation != TOMOYO_TYPE_EXECUTE);
 	return error;
 }
 /**
  * tomoyo_same_path_number_acl - Check for duplicated "struct tomoyo_path_number_acl" entry.
  *
  * @a: Pointer to "struct tomoyo_acl_info".
  * @b: Pointer to "struct tomoyo_acl_info".
  *
  * Returns true if @a == @b except permission bits, false otherwise.
  */
 static bool tomoyo_same_path_number_acl(const struct tomoyo_acl_info *a,
 					const struct tomoyo_acl_info *b)
 {
 	const struct tomoyo_path_number_acl *p1 = container_of(a, typeof(*p1),
 							       head);
 	const struct tomoyo_path_number_acl *p2 = container_of(b, typeof(*p2),
 							       head);
 	return tomoyo_same_name_union(&p1->name, &p2->name) &&
 		tomoyo_same_number_union(&p1->number, &p2->number);
 }
 /**
  * tomoyo_merge_path_number_acl - Merge duplicated "struct tomoyo_path_number_acl" entry.
  *
  * @a:         Pointer to "struct tomoyo_acl_info".
  * @b:         Pointer to "struct tomoyo_acl_info".
  * @is_delete: True for @a &= ~@b, false for @a |= @b.
  *
  * Returns true if @a is empty, false otherwise.
  */
 static bool tomoyo_merge_path_number_acl(struct tomoyo_acl_info *a,
 					 struct tomoyo_acl_info *b,
 					 const bool is_delete)
 {
 	u8 * const a_perm = &container_of(a, struct tomoyo_path_number_acl,
 					  head)->perm;
 	u8 perm = *a_perm;
 	const u8 b_perm = container_of(b, struct tomoyo_path_number_acl, head)
 		->perm;
 	if (is_delete)
 		perm &= ~b_perm;
 	else
 		perm |= b_perm;
 	*a_perm = perm;
 	return !perm;
 }
 /**
  * tomoyo_update_path_number_acl - Update ioctl/chmod/chown/chgrp ACL.
  *
  * @perm:  Permission.
  * @param: Pointer to "struct tomoyo_acl_param".
  *
  * Returns 0 on success, negative value otherwise.
  */
 static int tomoyo_update_path_number_acl(const u8 perm,
 					 struct tomoyo_acl_param *param)
 {
 	struct tomoyo_path_number_acl e = {
 		.head.type = TOMOYO_TYPE_PATH_NUMBER_ACL,
 		.perm = perm
 	};
 	int error;
 	if (!tomoyo_parse_name_union(param, &e.name) ||
 	    !tomoyo_parse_number_union(param, &e.number))
 		error = -EINVAL;
 	else
 		error = tomoyo_update_domain(&e.head, sizeof(e), param,
 					     tomoyo_same_path_number_acl,
 					     tomoyo_merge_path_number_acl);
 	tomoyo_put_name_union(&e.name);
 	tomoyo_put_number_union(&e.number);
 	return error;
 }
 /**
  * tomoyo_path_number_perm - Check permission for "create", "mkdir", "mkfifo", "mksock", "ioctl", "chmod", "chown", "chgrp".
  *
  * @type:   Type of operation.
  * @path:   Pointer to "struct path".
  * @number: Number.
  *
  * Returns 0 on success, negative value otherwise.
  */
 int tomoyo_path_number_perm(const u8 type, struct path *path,
 			    unsigned long number)
 {
 	struct tomoyo_request_info r;
 	struct tomoyo_obj_info obj = {
 		.path1 = *path,
 	};
 	int error = -ENOMEM;
 	struct tomoyo_path_info buf;
 	int idx;
 	if (tomoyo_init_request_info(&r, NULL, tomoyo_pn2mac[type])
 	    == TOMOYO_CONFIG_DISABLED || !path->dentry)
 		return 0;
 	idx = tomoyo_read_lock();
 	if (!tomoyo_get_realpath(&buf, path))
 		goto out;
 	r.obj = &obj;
 	if (type == TOMOYO_TYPE_MKDIR)
 		tomoyo_add_slash(&buf);
 	r.param_type = TOMOYO_TYPE_PATH_NUMBER_ACL;
 	r.param.path_number.operation = type;
 	r.param.path_number.filename = &buf;
 	r.param.path_number.number = number;
 	do {
 		tomoyo_check_acl(&r, tomoyo_check_path_number_acl);
 		error = tomoyo_audit_path_number_log(&r);
 	} while (error == TOMOYO_RETRY_REQUEST);
 	kfree(buf.name);
  out:
 	tomoyo_read_unlock(idx);
 	if (r.mode != TOMOYO_CONFIG_ENFORCING)
 		error = 0;
 	return error;
 }
 /**
  * tomoyo_check_open_permission - Check permission for "read" and "write".
  *
  * @domain: Pointer to "struct tomoyo_domain_info".
  * @path:   Pointer to "struct path".
  * @flag:   Flags for open().
  *
  * Returns 0 on success, negative value otherwise.
  */
 int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
 				 struct path *path, const int flag)
 {
 	const u8 acc_mode = ACC_MODE(flag);
 	int error = 0;
 	struct tomoyo_path_info buf;
 	struct tomoyo_request_info r;
 	struct tomoyo_obj_info obj = {
 		.path1 = *path,
 	};
 	int idx;
 	buf.name = NULL;
 	r.mode = TOMOYO_CONFIG_DISABLED;
 	idx = tomoyo_read_lock();
 	if (acc_mode &&
 	    tomoyo_init_request_info(&r, domain, TOMOYO_MAC_FILE_OPEN)
 	    != TOMOYO_CONFIG_DISABLED) {
 		if (!tomoyo_get_realpath(&buf, path)) {
 			error = -ENOMEM;
 			goto out;
 		}
 		r.obj = &obj;
 		if (acc_mode & MAY_READ)
 			error = tomoyo_path_permission(&r, TOMOYO_TYPE_READ,
 						       &buf);
 		if (!error && (acc_mode & MAY_WRITE))
 			error = tomoyo_path_permission(&r, (flag & O_APPEND) ?
 						       TOMOYO_TYPE_APPEND :
 						       TOMOYO_TYPE_WRITE,
 						       &buf);
 	}
  out:
 	kfree(buf.name);
 	tomoyo_read_unlock(idx);
 	if (r.mode != TOMOYO_CONFIG_ENFORCING)
 		error = 0;
 	return error;
 }
 /**
  * tomoyo_path_perm - Check permission for "unlink", "rmdir", "truncate", "symlink", "append", "chroot" and "unmount".
  *
  * @operation: Type of operation.
  * @path:      Pointer to "struct path".
  * @target:    Symlink's target if @operation is TOMOYO_TYPE_SYMLINK,
  *             NULL otherwise.
  *
  * Returns 0 on success, negative value otherwise.
  */
 int tomoyo_path_perm(const u8 operation, struct path *path, const char *target)
 {
 	struct tomoyo_request_info r;
 	struct tomoyo_obj_info obj = {
 		.path1 = *path,
 	};
 	int error;
 	struct tomoyo_path_info buf;
 	bool is_enforce;
 	struct tomoyo_path_info symlink_target;
 	int idx;
 	if (tomoyo_init_request_info(&r, NULL, tomoyo_p2mac[operation])
 	    == TOMOYO_CONFIG_DISABLED)
 		return 0;
 	is_enforce = (r.mode == TOMOYO_CONFIG_ENFORCING);
 	error = -ENOMEM;
 	buf.name = NULL;
 	idx = tomoyo_read_lock();
 	if (!tomoyo_get_realpath(&buf, path))
 		goto out;
 	r.obj = &obj;
 	switch (operation) {
 	case TOMOYO_TYPE_RMDIR:
 	case TOMOYO_TYPE_CHROOT:
 		tomoyo_add_slash(&buf);
 		break;
 	case TOMOYO_TYPE_SYMLINK:
 		symlink_target.name = tomoyo_encode(target);
 		if (!symlink_target.name)
 			goto out;
 		tomoyo_fill_path_info(&symlink_target);
 		obj.symlink_target = &symlink_target;
 		break;
 	}
 	error = tomoyo_path_permission(&r, operation, &buf);
 	if (operation == TOMOYO_TYPE_SYMLINK)
 		kfree(symlink_target.name);
  out:
 	kfree(buf.name);
 	tomoyo_read_unlock(idx);
 	if (!is_enforce)
 		error = 0;
 	return error;
 }
 /**
  * tomoyo_mkdev_perm - Check permission for "mkblock" and "mkchar".
  *
  * @operation: Type of operation. (TOMOYO_TYPE_MKCHAR or TOMOYO_TYPE_MKBLOCK)
  * @path:      Pointer to "struct path".
  * @mode:      Create mode.
  * @dev:       Device number.
  *
  * Returns 0 on success, negative value otherwise.
  */
 int tomoyo_mkdev_perm(const u8 operation, struct path *path,
 		      const unsigned int mode, unsigned int dev)
 {
 	struct tomoyo_request_info r;
 	struct tomoyo_obj_info obj = {
 		.path1 = *path,
 	};
 	int error = -ENOMEM;
 	struct tomoyo_path_info buf;
 	int idx;
 	if (tomoyo_init_request_info(&r, NULL, tomoyo_pnnn2mac[operation])
 	    == TOMOYO_CONFIG_DISABLED)
 		return 0;
 	idx = tomoyo_read_lock();
 	error = -ENOMEM;
 	if (tomoyo_get_realpath(&buf, path)) {
 		r.obj = &obj;
 		dev = new_decode_dev(dev);
 		r.param_type = TOMOYO_TYPE_MKDEV_ACL;
 		r.param.mkdev.filename = &buf;
 		r.param.mkdev.operation = operation;
 		r.param.mkdev.mode = mode;
 		r.param.mkdev.major = MAJOR(dev);
 		r.param.mkdev.minor = MINOR(dev);
 		tomoyo_check_acl(&r, tomoyo_check_mkdev_acl);
 		error = tomoyo_audit_mkdev_log(&r);
 		kfree(buf.name);
 	}
 	tomoyo_read_unlock(idx);
 	if (r.mode != TOMOYO_CONFIG_ENFORCING)
 		error = 0;
 	return error;
 }
 /**
  * tomoyo_path2_perm - Check permission for "rename", "link" and "pivot_root".
  *
  * @operation: Type of operation.
  * @path1:      Pointer to "struct path".
  * @path2:      Pointer to "struct path".
  *
  * Returns 0 on success, negative value otherwise.
  */
 int tomoyo_path2_perm(const u8 operation, struct path *path1,
 		      struct path *path2)
 {
 	int error = -ENOMEM;
 	struct tomoyo_path_info buf1;
 	struct tomoyo_path_info buf2;
 	struct tomoyo_request_info r;
 	struct tomoyo_obj_info obj = {
 		.path1 = *path1,
 		.path2 = *path2,
 	};
 	int idx;
 	if (tomoyo_init_request_info(&r, NULL, tomoyo_pp2mac[operation])
 	    == TOMOYO_CONFIG_DISABLED)
 		return 0;
 	buf1.name = NULL;
 	buf2.name = NULL;
 	idx = tomoyo_read_lock();
 	if (!tomoyo_get_realpath(&buf1, path1) ||
 	    !tomoyo_get_realpath(&buf2, path2))
 		goto out;
 	switch (operation) {
 		struct dentry *dentry;
 	case TOMOYO_TYPE_RENAME:
-        case TOMOYO_TYPE_LINK:
+	case TOMOYO_TYPE_LINK:
 		dentry = path1->dentry;
-	        if (!dentry->d_inode || !S_ISDIR(dentry->d_inode->i_mode))
+		if (!dentry->d_inode || !S_ISDIR(dentry->d_inode->i_mode))
-                        break;
+			break;
-                /* fall through */
+		/* fall through */
-        case TOMOYO_TYPE_PIVOT_ROOT:
+	case TOMOYO_TYPE_PIVOT_ROOT:
-                tomoyo_add_slash(&buf1);
+		tomoyo_add_slash(&buf1);
-                tomoyo_add_slash(&buf2);
+		tomoyo_add_slash(&buf2);
 		break;
-        }
+	}
 	r.obj = &obj;
 	r.param_type = TOMOYO_TYPE_PATH2_ACL;
 	r.param.path2.operation = operation;
 	r.param.path2.filename1 = &buf1;
 	r.param.path2.filename2 = &buf2;
 	do {
 		tomoyo_check_acl(&r, tomoyo_check_path2_acl);
 		error = tomoyo_audit_path2_log(&r);
 	} while (error == TOMOYO_RETRY_REQUEST);
  out:
 	kfree(buf1.name);
 	kfree(buf2.name);
 	tomoyo_read_unlock(idx);
 	if (r.mode != TOMOYO_CONFIG_ENFORCING)
 		error = 0;
 	return error;
 }
 /**
  * tomoyo_same_mount_acl - Check for duplicated "struct tomoyo_mount_acl" entry.
  *
  * @a: Pointer to "struct tomoyo_acl_info".
  * @b: Pointer to "struct tomoyo_acl_info".
  *
  * Returns true if @a == @b, false otherwise.
  */
 static bool tomoyo_same_mount_acl(const struct tomoyo_acl_info *a,
 				  const struct tomoyo_acl_info *b)
 {
 	const struct tomoyo_mount_acl *p1 = container_of(a, typeof(*p1), head);
 	const struct tomoyo_mount_acl *p2 = container_of(b, typeof(*p2), head);
 	return tomoyo_same_name_union(&p1->dev_name, &p2->dev_name) &&
 		tomoyo_same_name_union(&p1->dir_name, &p2->dir_name) &&
 		tomoyo_same_name_union(&p1->fs_type, &p2->fs_type) &&
 		tomoyo_same_number_union(&p1->flags, &p2->flags);
 }
 /**
  * tomoyo_update_mount_acl - Write "struct tomoyo_mount_acl" list.
  *
  * @param: Pointer to "struct tomoyo_acl_param".
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 static int tomoyo_update_mount_acl(struct tomoyo_acl_param *param)
 {
 	struct tomoyo_mount_acl e = { .head.type = TOMOYO_TYPE_MOUNT_ACL };
 	int error;
 	if (!tomoyo_parse_name_union(param, &e.dev_name) ||
 	    !tomoyo_parse_name_union(param, &e.dir_name) ||
 	    !tomoyo_parse_name_union(param, &e.fs_type) ||
 	    !tomoyo_parse_number_union(param, &e.flags))
 		error = -EINVAL;
 	else
 		error = tomoyo_update_domain(&e.head, sizeof(e), param,
 					     tomoyo_same_mount_acl, NULL);
 	tomoyo_put_name_union(&e.dev_name);
 	tomoyo_put_name_union(&e.dir_name);
 	tomoyo_put_name_union(&e.fs_type);
 	tomoyo_put_number_union(&e.flags);
 	return error;
 }
 /**
  * tomoyo_write_file - Update file related list.
  *
  * @param: Pointer to "struct tomoyo_acl_param".
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 int tomoyo_write_file(struct tomoyo_acl_param *param)
 {
 	u16 perm = 0;
 	u8 type;
 	const char *operation = tomoyo_read_token(param);
 	for (type = 0; type < TOMOYO_MAX_PATH_OPERATION; type++)
 		if (tomoyo_permstr(operation, tomoyo_path_keyword[type]))
 			perm |= 1 << type;
 	if (perm)
 		return tomoyo_update_path_acl(perm, param);
 	for (type = 0; type < TOMOYO_MAX_PATH2_OPERATION; type++)
 		if (tomoyo_permstr(operation,
 				   tomoyo_mac_keywords[tomoyo_pp2mac[type]]))
 			perm |= 1 << type;
 	if (perm)
 		return tomoyo_update_path2_acl(perm, param);
 	for (type = 0; type < TOMOYO_MAX_PATH_NUMBER_OPERATION; type++)
 		if (tomoyo_permstr(operation,
 				   tomoyo_mac_keywords[tomoyo_pn2mac[type]]))
 			perm |= 1 << type;
 	if (perm)
 		return tomoyo_update_path_number_acl(perm, param);
 	for (type = 0; type < TOMOYO_MAX_MKDEV_OPERATION; type++)
 		if (tomoyo_permstr(operation,
 				   tomoyo_mac_keywords[tomoyo_pnnn2mac[type]]))
 			perm |= 1 << type;
 	if (perm)
 		return tomoyo_update_mkdev_acl(perm, param);
 	if (tomoyo_permstr(operation,
 			   tomoyo_mac_keywords[TOMOYO_MAC_FILE_MOUNT]))
 		return tomoyo_update_mount_acl(param);
 	return -EINVAL;
 }

security/tomoyo/gc.c

Diff comments View file @ 0f2a55d

 /*
  * security/tomoyo/gc.c
  *
- * Implementation of the Domain-Based Mandatory Access Control.
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
- *
  */
 #include "common.h"
 #include <linux/kthread.h>
 #include <linux/slab.h>
 /* The list for "struct tomoyo_io_buffer". */
 static LIST_HEAD(tomoyo_io_buffer_list);
 /* Lock for protecting tomoyo_io_buffer_list. */
 static DEFINE_SPINLOCK(tomoyo_io_buffer_list_lock);
 /* Size of an element. */
 static const u8 tomoyo_element_size[TOMOYO_MAX_POLICY] = {
 	[TOMOYO_ID_GROUP] = sizeof(struct tomoyo_group),
 	[TOMOYO_ID_PATH_GROUP] = sizeof(struct tomoyo_path_group),
 	[TOMOYO_ID_NUMBER_GROUP] = sizeof(struct tomoyo_number_group),
 	[TOMOYO_ID_AGGREGATOR] = sizeof(struct tomoyo_aggregator),
 	[TOMOYO_ID_TRANSITION_CONTROL] =
 	sizeof(struct tomoyo_transition_control),
 	[TOMOYO_ID_MANAGER] = sizeof(struct tomoyo_manager),
 	/* [TOMOYO_ID_CONDITION] = "struct tomoyo_condition"->size, */
 	/* [TOMOYO_ID_NAME] = "struct tomoyo_name"->size, */
 	/* [TOMOYO_ID_ACL] =
 	   tomoyo_acl_size["struct tomoyo_acl_info"->type], */
 	[TOMOYO_ID_DOMAIN] = sizeof(struct tomoyo_domain_info),
 };
 /* Size of a domain ACL element. */
 static const u8 tomoyo_acl_size[] = {
 	[TOMOYO_TYPE_PATH_ACL] = sizeof(struct tomoyo_path_acl),
 	[TOMOYO_TYPE_PATH2_ACL] = sizeof(struct tomoyo_path2_acl),
 	[TOMOYO_TYPE_PATH_NUMBER_ACL] = sizeof(struct tomoyo_path_number_acl),
 	[TOMOYO_TYPE_MKDEV_ACL] = sizeof(struct tomoyo_mkdev_acl),
 	[TOMOYO_TYPE_MOUNT_ACL] = sizeof(struct tomoyo_mount_acl),
 };
 /**
  * tomoyo_struct_used_by_io_buffer - Check whether the list element is used by /sys/kernel/security/tomoyo/ users or not.
  *
  * @element: Pointer to "struct list_head".
  *
  * Returns true if @element is used by /sys/kernel/security/tomoyo/ users,
  * false otherwise.
  */
 static bool tomoyo_struct_used_by_io_buffer(const struct list_head *element)
 {
 	struct tomoyo_io_buffer *head;
 	bool in_use = false;
 	spin_lock(&tomoyo_io_buffer_list_lock);
 	list_for_each_entry(head, &tomoyo_io_buffer_list, list) {
 		head->users++;
 		spin_unlock(&tomoyo_io_buffer_list_lock);
 		if (mutex_lock_interruptible(&head->io_sem)) {
 			in_use = true;
 			goto out;
 		}
 		if (head->r.domain == element || head->r.group == element ||
 		    head->r.acl == element || &head->w.domain->list == element)
 			in_use = true;
 		mutex_unlock(&head->io_sem);
 out:
 		spin_lock(&tomoyo_io_buffer_list_lock);
 		head->users--;
 		if (in_use)
 			break;
 	}
 	spin_unlock(&tomoyo_io_buffer_list_lock);
 	return in_use;
 }
 /**
  * tomoyo_name_used_by_io_buffer - Check whether the string is used by /sys/kernel/security/tomoyo/ users or not.
  *
  * @string: String to check.
  * @size:   Memory allocated for @string .
  *
  * Returns true if @string is used by /sys/kernel/security/tomoyo/ users,
  * false otherwise.
  */
 static bool tomoyo_name_used_by_io_buffer(const char *string,
 					  const size_t size)
 {
 	struct tomoyo_io_buffer *head;
 	bool in_use = false;
 	spin_lock(&tomoyo_io_buffer_list_lock);
 	list_for_each_entry(head, &tomoyo_io_buffer_list, list) {
 		int i;
 		head->users++;
 		spin_unlock(&tomoyo_io_buffer_list_lock);
 		if (mutex_lock_interruptible(&head->io_sem)) {
 			in_use = true;
 			goto out;
 		}
 		for (i = 0; i < TOMOYO_MAX_IO_READ_QUEUE; i++) {
 			const char *w = head->r.w[i];
 			if (w < string || w > string + size)
 				continue;
 			in_use = true;
 			break;
 		}
 		mutex_unlock(&head->io_sem);
 out:
 		spin_lock(&tomoyo_io_buffer_list_lock);
 		head->users--;
 		if (in_use)
 			break;
 	}
 	spin_unlock(&tomoyo_io_buffer_list_lock);
 	return in_use;
 }
 /* Structure for garbage collection. */
 struct tomoyo_gc {
 	struct list_head list;
 	enum tomoyo_policy_id type;
 	size_t size;
 	struct list_head *element;
 };
 /* List of entries to be deleted. */
 static LIST_HEAD(tomoyo_gc_list);
 /* Length of tomoyo_gc_list. */
 static int tomoyo_gc_list_len;
 /**
  * tomoyo_add_to_gc - Add an entry to to be deleted list.
  *
  * @type:    One of values in "enum tomoyo_policy_id".
  * @element: Pointer to "struct list_head".
  *
  * Returns true on success, false otherwise.
  *
  * Caller holds tomoyo_policy_lock mutex.
  *
  * Adding an entry needs kmalloc(). Thus, if we try to add thousands of
  * entries at once, it will take too long time. Thus, do not add more than 128
  * entries per a scan. But to be able to handle worst case where all entries
  * are in-use, we accept one more entry per a scan.
  *
  * If we use singly linked list using "struct list_head"->prev (which is
  * LIST_POISON2), we can avoid kmalloc().
  */
 static bool tomoyo_add_to_gc(const int type, struct list_head *element)
 {
 	struct tomoyo_gc *entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
 	if (!entry)
 		return false;
 	entry->type = type;
 	if (type == TOMOYO_ID_ACL)
 		entry->size = tomoyo_acl_size[
 			      container_of(element,
 					   typeof(struct tomoyo_acl_info),
 					   list)->type];
 	else if (type == TOMOYO_ID_NAME)
 		entry->size = strlen(container_of(element,
 						  typeof(struct tomoyo_name),
 						  head.list)->entry.name) + 1;
 	else if (type == TOMOYO_ID_CONDITION)
 		entry->size =
 			container_of(element, typeof(struct tomoyo_condition),
 				     head.list)->size;
 	else
 		entry->size = tomoyo_element_size[type];
 	entry->element = element;
 	list_add(&entry->list, &tomoyo_gc_list);
 	list_del_rcu(element);
 	return tomoyo_gc_list_len++ < 128;
 }
 /**
  * tomoyo_element_linked_by_gc - Validate next element of an entry.
  *
  * @element: Pointer to an element.
  * @size:    Size of @element in byte.
  *
  * Returns true if @element is linked by other elements in the garbage
  * collector's queue, false otherwise.
  */
 static bool tomoyo_element_linked_by_gc(const u8 *element, const size_t size)
 {
 	struct tomoyo_gc *p;
 	list_for_each_entry(p, &tomoyo_gc_list, list) {
 		const u8 *ptr = (const u8 *) p->element->next;
 		if (ptr < element || element + size < ptr)
 			continue;
 		return true;
 	}
 	return false;
 }
 /**
  * tomoyo_del_transition_control - Delete members in "struct tomoyo_transition_control".
  *
  * @element: Pointer to "struct list_head".
  *
  * Returns nothing.
  */
 static void tomoyo_del_transition_control(struct list_head *element)
 {
 	struct tomoyo_transition_control *ptr =
 		container_of(element, typeof(*ptr), head.list);
 	tomoyo_put_name(ptr->domainname);
 	tomoyo_put_name(ptr->program);
 }
 /**
  * tomoyo_del_aggregator - Delete members in "struct tomoyo_aggregator".
  *
  * @element: Pointer to "struct list_head".
  *
  * Returns nothing.
  */
 static void tomoyo_del_aggregator(struct list_head *element)
 {
 	struct tomoyo_aggregator *ptr =
 		container_of(element, typeof(*ptr), head.list);
 	tomoyo_put_name(ptr->original_name);
 	tomoyo_put_name(ptr->aggregated_name);
 }
 /**
  * tomoyo_del_manager - Delete members in "struct tomoyo_manager".
  *
  * @element: Pointer to "struct list_head".
  *
  * Returns nothing.
  */
 static void tomoyo_del_manager(struct list_head *element)
 {
 	struct tomoyo_manager *ptr =
 		container_of(element, typeof(*ptr), head.list);
 	tomoyo_put_name(ptr->manager);
 }
 /**
  * tomoyo_del_acl - Delete members in "struct tomoyo_acl_info".
  *
  * @element: Pointer to "struct list_head".
  *
  * Returns nothing.
  */
 static void tomoyo_del_acl(struct list_head *element)
 {
 	struct tomoyo_acl_info *acl =
 		container_of(element, typeof(*acl), list);
 	tomoyo_put_condition(acl->cond);
 	switch (acl->type) {
 	case TOMOYO_TYPE_PATH_ACL:
 		{
 			struct tomoyo_path_acl *entry
 				= container_of(acl, typeof(*entry), head);
 			tomoyo_put_name_union(&entry->name);
 		}
 		break;
 	case TOMOYO_TYPE_PATH2_ACL:
 		{
 			struct tomoyo_path2_acl *entry
 				= container_of(acl, typeof(*entry), head);
 			tomoyo_put_name_union(&entry->name1);
 			tomoyo_put_name_union(&entry->name2);
 		}
 		break;
 	case TOMOYO_TYPE_PATH_NUMBER_ACL:
 		{
 			struct tomoyo_path_number_acl *entry
 				= container_of(acl, typeof(*entry), head);
 			tomoyo_put_name_union(&entry->name);
 			tomoyo_put_number_union(&entry->number);
 		}
 		break;
 	case TOMOYO_TYPE_MKDEV_ACL:
 		{
 			struct tomoyo_mkdev_acl *entry
 				= container_of(acl, typeof(*entry), head);
 			tomoyo_put_name_union(&entry->name);
 			tomoyo_put_number_union(&entry->mode);
 			tomoyo_put_number_union(&entry->major);
 			tomoyo_put_number_union(&entry->minor);
 		}
 		break;
 	case TOMOYO_TYPE_MOUNT_ACL:
 		{
 			struct tomoyo_mount_acl *entry
 				= container_of(acl, typeof(*entry), head);
 			tomoyo_put_name_union(&entry->dev_name);
 			tomoyo_put_name_union(&entry->dir_name);
 			tomoyo_put_name_union(&entry->fs_type);
 			tomoyo_put_number_union(&entry->flags);
 		}
 		break;
 	}
 }
 /**
  * tomoyo_del_domain - Delete members in "struct tomoyo_domain_info".
  *
  * @element: Pointer to "struct list_head".
  *
  * Returns true if deleted, false otherwise.
  */
 static bool tomoyo_del_domain(struct list_head *element)
 {
 	struct tomoyo_domain_info *domain =
 		container_of(element, typeof(*domain), list);
 	struct tomoyo_acl_info *acl;
 	struct tomoyo_acl_info *tmp;
 	/*
 	 * Since we don't protect whole execve() operation using SRCU,
 	 * we need to recheck domain->users at this point.
 	 *
 	 * (1) Reader starts SRCU section upon execve().
 	 * (2) Reader traverses tomoyo_domain_list and finds this domain.
 	 * (3) Writer marks this domain as deleted.
 	 * (4) Garbage collector removes this domain from tomoyo_domain_list
 	 *     because this domain is marked as deleted and used by nobody.
 	 * (5) Reader saves reference to this domain into
 	 *     "struct linux_binprm"->cred->security .
 	 * (6) Reader finishes SRCU section, although execve() operation has
 	 *     not finished yet.
 	 * (7) Garbage collector waits for SRCU synchronization.
 	 * (8) Garbage collector kfree() this domain because this domain is
 	 *     used by nobody.
 	 * (9) Reader finishes execve() operation and restores this domain from
 	 *     "struct linux_binprm"->cred->security.
 	 *
 	 * By updating domain->users at (5), we can solve this race problem
 	 * by rechecking domain->users at (8).
 	 */
 	if (atomic_read(&domain->users))
 		return false;
 	list_for_each_entry_safe(acl, tmp, &domain->acl_info_list, list) {
 		tomoyo_del_acl(&acl->list);
 		tomoyo_memory_free(acl);
 	}
 	tomoyo_put_name(domain->domainname);
 	return true;
 }
 /**
  * tomoyo_del_condition - Delete members in "struct tomoyo_condition".
  *
  * @element: Pointer to "struct list_head".
  *
  * Returns nothing.
  */
 void tomoyo_del_condition(struct list_head *element)
 {
 	struct tomoyo_condition *cond = container_of(element, typeof(*cond),
 						     head.list);
 	const u16 condc = cond->condc;
 	const u16 numbers_count = cond->numbers_count;
 	const u16 names_count = cond->names_count;
 	const u16 argc = cond->argc;
 	const u16 envc = cond->envc;
 	unsigned int i;
 	const struct tomoyo_condition_element *condp
 		= (const struct tomoyo_condition_element *) (cond + 1);
 	struct tomoyo_number_union *numbers_p
 		= (struct tomoyo_number_union *) (condp + condc);
 	struct tomoyo_name_union *names_p
 		= (struct tomoyo_name_union *) (numbers_p + numbers_count);
 	const struct tomoyo_argv *argv
 		= (const struct tomoyo_argv *) (names_p + names_count);
 	const struct tomoyo_envp *envp
 		= (const struct tomoyo_envp *) (argv + argc);
 	for (i = 0; i < numbers_count; i++)
 		tomoyo_put_number_union(numbers_p++);
 	for (i = 0; i < names_count; i++)
 		tomoyo_put_name_union(names_p++);
 	for (i = 0; i < argc; argv++, i++)
 		tomoyo_put_name(argv->value);
 	for (i = 0; i < envc; envp++, i++) {
 		tomoyo_put_name(envp->name);
 		tomoyo_put_name(envp->value);
 	}
 }
 /**
  * tomoyo_del_name - Delete members in "struct tomoyo_name".
  *
  * @element: Pointer to "struct list_head".
  *
  * Returns nothing.
  */
 static void tomoyo_del_name(struct list_head *element)
 {
 	const struct tomoyo_name *ptr =
 		container_of(element, typeof(*ptr), head.list);
 }
 /**
  * tomoyo_del_path_group - Delete members in "struct tomoyo_path_group".
  *
  * @element: Pointer to "struct list_head".
  *
  * Returns nothing.
  */
 static void tomoyo_del_path_group(struct list_head *element)
 {
 	struct tomoyo_path_group *member =
 		container_of(element, typeof(*member), head.list);
 	tomoyo_put_name(member->member_name);
 }
 /**
  * tomoyo_del_group - Delete "struct tomoyo_group".
  *
  * @element: Pointer to "struct list_head".
  *
  * Returns nothing.
  */
 static void tomoyo_del_group(struct list_head *element)
 {
 	struct tomoyo_group *group =
 		container_of(element, typeof(*group), head.list);
 	tomoyo_put_name(group->group_name);
 }
 /**
  * tomoyo_del_number_group - Delete members in "struct tomoyo_number_group".
  *
  * @element: Pointer to "struct list_head".
  *
  * Returns nothing.
  */
 static void tomoyo_del_number_group(struct list_head *element)
 {
 	struct tomoyo_number_group *member =
 		container_of(element, typeof(*member), head.list);
 }
 /**
  * tomoyo_collect_member - Delete elements with "struct tomoyo_acl_head".
  *
  * @id:          One of values in "enum tomoyo_policy_id".
  * @member_list: Pointer to "struct list_head".
  *
  * Returns true if some elements are deleted, false otherwise.
  */
 static bool tomoyo_collect_member(const enum tomoyo_policy_id id,
 				  struct list_head *member_list)
 {
 	struct tomoyo_acl_head *member;
 	list_for_each_entry(member, member_list, list) {
 		if (!member->is_deleted)
 			continue;
 		if (!tomoyo_add_to_gc(id, &member->list))
 			return false;
 	}
-        return true;
+	return true;
 }
 /**
  * tomoyo_collect_acl - Delete elements in "struct tomoyo_domain_info".
  *
  * @list: Pointer to "struct list_head".
  *
  * Returns true if some elements are deleted, false otherwise.
  */
 static bool tomoyo_collect_acl(struct list_head *list)
 {
 	struct tomoyo_acl_info *acl;
 	list_for_each_entry(acl, list, list) {
 		if (!acl->is_deleted)
 			continue;
 		if (!tomoyo_add_to_gc(TOMOYO_ID_ACL, &acl->list))
 			return false;
 	}
 	return true;
 }
 /**
  * tomoyo_collect_entry - Scan lists for deleted elements.
  *
  * Returns nothing.
  */
 static void tomoyo_collect_entry(void)
 {
 	int i;
 	enum tomoyo_policy_id id;
 	struct tomoyo_policy_namespace *ns;
 	int idx;
 	if (mutex_lock_interruptible(&tomoyo_policy_lock))
 		return;
 	idx = tomoyo_read_lock();
 	{
 		struct tomoyo_domain_info *domain;
 		list_for_each_entry_rcu(domain, &tomoyo_domain_list, list) {
 			if (!tomoyo_collect_acl(&domain->acl_info_list))
 				goto unlock;
 			if (!domain->is_deleted || atomic_read(&domain->users))
 				continue;
 			/*
 			 * Nobody is referring this domain. But somebody may
 			 * refer this domain after successful execve().
 			 * We recheck domain->users after SRCU synchronization.
 			 */
 			if (!tomoyo_add_to_gc(TOMOYO_ID_DOMAIN, &domain->list))
 				goto unlock;
 		}
 	}
 	list_for_each_entry_rcu(ns, &tomoyo_namespace_list, namespace_list) {
 		for (id = 0; id < TOMOYO_MAX_POLICY; id++)
 			if (!tomoyo_collect_member(id, &ns->policy_list[id]))
 				goto unlock;
 		for (i = 0; i < TOMOYO_MAX_ACL_GROUPS; i++)
 			if (!tomoyo_collect_acl(&ns->acl_group[i]))
 				goto unlock;
 		for (i = 0; i < TOMOYO_MAX_GROUP; i++) {
 			struct list_head *list = &ns->group_list[i];
 			struct tomoyo_group *group;
 			switch (i) {
 			case 0:
 				id = TOMOYO_ID_PATH_GROUP;
 				break;
 			default:
 				id = TOMOYO_ID_NUMBER_GROUP;
 				break;
 			}
 			list_for_each_entry(group, list, head.list) {
 				if (!tomoyo_collect_member
 				    (id, &group->member_list))
 					goto unlock;
 				if (!list_empty(&group->member_list) ||
 				    atomic_read(&group->head.users))
 					continue;
 				if (!tomoyo_add_to_gc(TOMOYO_ID_GROUP,
 						      &group->head.list))
 					goto unlock;
 			}
 		}
 	}
 	id = TOMOYO_ID_CONDITION;
 	for (i = 0; i < TOMOYO_MAX_HASH + 1; i++) {
 		struct list_head *list = !i ?
 			&tomoyo_condition_list : &tomoyo_name_list[i - 1];
 		struct tomoyo_shared_acl_head *ptr;
 		list_for_each_entry(ptr, list, list) {
 			if (atomic_read(&ptr->users))
 				continue;
 			if (!tomoyo_add_to_gc(id, &ptr->list))
 				goto unlock;
 		}
 		id = TOMOYO_ID_NAME;
 	}
 unlock:
 	tomoyo_read_unlock(idx);
 	mutex_unlock(&tomoyo_policy_lock);
 }
 /**
  * tomoyo_kfree_entry - Delete entries in tomoyo_gc_list.
  *
  * Returns true if some entries were kfree()d, false otherwise.
  */
 static bool tomoyo_kfree_entry(void)
 {
 	struct tomoyo_gc *p;
 	struct tomoyo_gc *tmp;
 	bool result = false;
 	list_for_each_entry_safe(p, tmp, &tomoyo_gc_list, list) {
 		struct list_head *element = p->element;
 		/*
 		 * list_del_rcu() in tomoyo_add_to_gc() guarantees that the
 		 * list element became no longer reachable from the list which
 		 * the element was originally on (e.g. tomoyo_domain_list).
 		 * Also, synchronize_srcu() in tomoyo_gc_thread() guarantees
 		 * that the list element became no longer referenced by syscall
 		 * users.
 		 *
 		 * However, there are three users which may still be using the
 		 * list element. We need to defer until all of these users
 		 * forget the list element.
 		 *
 		 * Firstly, defer until "struct tomoyo_io_buffer"->r.{domain,
 		 * group,acl} and "struct tomoyo_io_buffer"->w.domain forget
 		 * the list element.
 		 */
 		if (tomoyo_struct_used_by_io_buffer(element))
 			continue;
 		/*
 		 * Secondly, defer until all other elements in the
 		 * tomoyo_gc_list list forget the list element.
 		 */
 		if (tomoyo_element_linked_by_gc((const u8 *) element, p->size))
 			continue;
 		switch (p->type) {
 		case TOMOYO_ID_TRANSITION_CONTROL:
 			tomoyo_del_transition_control(element);
 			break;
 		case TOMOYO_ID_AGGREGATOR:
 			tomoyo_del_aggregator(element);
 			break;
 		case TOMOYO_ID_MANAGER:
 			tomoyo_del_manager(element);
 			break;
 		case TOMOYO_ID_CONDITION:
 			tomoyo_del_condition(element);
 			break;
 		case TOMOYO_ID_NAME:
 			/*
 			 * Thirdly, defer until all "struct tomoyo_io_buffer"
 			 * ->r.w[] forget the list element.
 			 */
 			if (tomoyo_name_used_by_io_buffer(
 			    container_of(element, typeof(struct tomoyo_name),
 					 head.list)->entry.name, p->size))
 				continue;
 			tomoyo_del_name(element);
 			break;
 		case TOMOYO_ID_ACL:
 			tomoyo_del_acl(element);
 			break;
 		case TOMOYO_ID_DOMAIN:
 			if (!tomoyo_del_domain(element))
 				continue;
 			break;
 		case TOMOYO_ID_PATH_GROUP:
 			tomoyo_del_path_group(element);
 			break;
 		case TOMOYO_ID_GROUP:
 			tomoyo_del_group(element);
 			break;
 		case TOMOYO_ID_NUMBER_GROUP:
 			tomoyo_del_number_group(element);
 			break;
 		case TOMOYO_MAX_POLICY:
 			break;
 		}
 		tomoyo_memory_free(element);
 		list_del(&p->list);
 		kfree(p);
 		tomoyo_gc_list_len--;
 		result = true;
 	}
 	return result;
 }
 /**
  * tomoyo_gc_thread - Garbage collector thread function.
  *
  * @unused: Unused.
  *
  * In case OOM-killer choose this thread for termination, we create this thread
  * as a short live thread whenever /sys/kernel/security/tomoyo/ interface was
  * close()d.
  *
  * Returns 0.
  */
 static int tomoyo_gc_thread(void *unused)
 {
 	/* Garbage collector thread is exclusive. */
 	static DEFINE_MUTEX(tomoyo_gc_mutex);
 	if (!mutex_trylock(&tomoyo_gc_mutex))
 		goto out;
 	daemonize("GC for TOMOYO");
 	do {
 		tomoyo_collect_entry();
 		if (list_empty(&tomoyo_gc_list))
 			break;
 		synchronize_srcu(&tomoyo_ss);
 	} while (tomoyo_kfree_entry());
 	{
 		struct tomoyo_io_buffer *head;
 		struct tomoyo_io_buffer *tmp;
 		spin_lock(&tomoyo_io_buffer_list_lock);
 		list_for_each_entry_safe(head, tmp, &tomoyo_io_buffer_list,
 					 list) {
 			if (head->users)
 				continue;
 			list_del(&head->list);
 			kfree(head->read_buf);
 			kfree(head->write_buf);
 			kfree(head);
 		}
 		spin_unlock(&tomoyo_io_buffer_list_lock);
 	}
 	mutex_unlock(&tomoyo_gc_mutex);
 out:
 	/* This acts as do_exit(0). */
 	return 0;
 }
 /**
  * tomoyo_notify_gc - Register/unregister /sys/kernel/security/tomoyo/ users.
  *
  * @head:        Pointer to "struct tomoyo_io_buffer".
  * @is_register: True if register, false if unregister.
  *
  * Returns nothing.
  */
 void tomoyo_notify_gc(struct tomoyo_io_buffer *head, const bool is_register)
 {
 	bool is_write = false;
 	spin_lock(&tomoyo_io_buffer_list_lock);
 	if (is_register) {
 		head->users = 1;
 		list_add(&head->list, &tomoyo_io_buffer_list);
 	} else {
 		is_write = head->write_buf != NULL;
 		if (!--head->users) {
 			list_del(&head->list);
 			kfree(head->read_buf);
 			kfree(head->write_buf);
 			kfree(head);
 		}
 	}
 	spin_unlock(&tomoyo_io_buffer_list_lock);
 	if (is_write) {
 		struct task_struct *task = kthread_create(tomoyo_gc_thread,
 							  NULL,
 							  "GC for TOMOYO");
 		if (!IS_ERR(task))
 			wake_up_process(task);
 	}
 }

security/tomoyo/group.c

Diff comments View file @ 0f2a55d

 /*
  * security/tomoyo/group.c
  *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
  */
 #include <linux/slab.h>
 #include "common.h"
+/**
+ * tomoyo_same_path_group - Check for duplicated "struct tomoyo_path_group" entry.
+ *
+ * @a: Pointer to "struct tomoyo_acl_head".
+ * @b: Pointer to "struct tomoyo_acl_head".
+ *
+ * Returns true if @a == @b, false otherwise.
+ */
 static bool tomoyo_same_path_group(const struct tomoyo_acl_head *a,
-				const struct tomoyo_acl_head *b)
+				   const struct tomoyo_acl_head *b)
 {
 	return container_of(a, struct tomoyo_path_group, head)->member_name ==
 		container_of(b, struct tomoyo_path_group, head)->member_name;
 }
+/**
+ * tomoyo_same_number_group - Check for duplicated "struct tomoyo_number_group" entry.
+ *
+ * @a: Pointer to "struct tomoyo_acl_head".
+ * @b: Pointer to "struct tomoyo_acl_head".
+ *
+ * Returns true if @a == @b, false otherwise.
+ */
 static bool tomoyo_same_number_group(const struct tomoyo_acl_head *a,
-				  const struct tomoyo_acl_head *b)
+				     const struct tomoyo_acl_head *b)
 {
 	return !memcmp(&container_of(a, struct tomoyo_number_group, head)
 		       ->number,
 		       &container_of(b, struct tomoyo_number_group, head)
 		       ->number,
 		       sizeof(container_of(a, struct tomoyo_number_group, head)
 			      ->number));
 }
 /**
  * tomoyo_write_group - Write "struct tomoyo_path_group"/"struct tomoyo_number_group" list.
  *
  * @param: Pointer to "struct tomoyo_acl_param".
- * @type:      Type of this group.
+ * @type:  Type of this group.
  *
  * Returns 0 on success, negative value otherwise.
  */
 int tomoyo_write_group(struct tomoyo_acl_param *param, const u8 type)
 {
 	struct tomoyo_group *group = tomoyo_get_group(param, type);
 	int error = -EINVAL;
 	if (!group)
 		return -ENOMEM;
 	param->list = &group->member_list;
 	if (type == TOMOYO_PATH_GROUP) {
 		struct tomoyo_path_group e = { };
 		e.member_name = tomoyo_get_name(tomoyo_read_token(param));
 		if (!e.member_name) {
 			error = -ENOMEM;
 			goto out;
 		}
 		error = tomoyo_update_policy(&e.head, sizeof(e), param,
 					  tomoyo_same_path_group);
 		tomoyo_put_name(e.member_name);
 	} else if (type == TOMOYO_NUMBER_GROUP) {
 		struct tomoyo_number_group e = { };
 		if (param->data[0] == '@' ||
 		    !tomoyo_parse_number_union(param, &e.number))
 			goto out;
 		error = tomoyo_update_policy(&e.head, sizeof(e), param,
 					  tomoyo_same_number_group);
 		/*
 		 * tomoyo_put_number_union() is not needed because
 		 * param->data[0] != '@'.
 		 */
 	}
 out:
 	tomoyo_put_group(group);
 	return error;
 }
 /**
  * tomoyo_path_matches_group - Check whether the given pathname matches members of the given pathname group.
  *
- * @pathname:        The name of pathname.
+ * @pathname: The name of pathname.
- * @group:           Pointer to "struct tomoyo_path_group".
+ * @group:    Pointer to "struct tomoyo_path_group".
  *
  * Returns matched member's pathname if @pathname matches pathnames in @group,
  * NULL otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 const struct tomoyo_path_info *
 tomoyo_path_matches_group(const struct tomoyo_path_info *pathname,
 			  const struct tomoyo_group *group)
 {
 	struct tomoyo_path_group *member;
 	list_for_each_entry_rcu(member, &group->member_list, head.list) {
 		if (member->head.is_deleted)
 			continue;
 		if (!tomoyo_path_matches_pattern(pathname, member->member_name))
 			continue;
 		return member->member_name;
 	}
 	return NULL;
 }
 /**
  * tomoyo_number_matches_group - Check whether the given number matches members of the given number group.
  *
  * @min:   Min number.
  * @max:   Max number.
  * @group: Pointer to "struct tomoyo_number_group".
  *
  * Returns true if @min and @max partially overlaps @group, false otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 bool tomoyo_number_matches_group(const unsigned long min,
 				 const unsigned long max,
 				 const struct tomoyo_group *group)
 {
 	struct tomoyo_number_group *member;
 	bool matched = false;
 	list_for_each_entry_rcu(member, &group->member_list, head.list) {
 		if (member->head.is_deleted)
 			continue;
 		if (min > member->number.values[1] ||
 		    max < member->number.values[0])
 			continue;
 		matched = true;
 		break;
 	}
 	return matched;
 }

security/tomoyo/load_policy.c

Diff comments View file @ 0f2a55d

 /*
  * security/tomoyo/load_policy.c
  *
- * Policy loader launcher for TOMOYO.
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
  */
 #include "common.h"
 #ifndef CONFIG_SECURITY_TOMOYO_OMIT_USERSPACE_LOADER
 /*
  * Path to the policy loader. (default = CONFIG_SECURITY_TOMOYO_POLICY_LOADER)
  */
 static const char *tomoyo_loader;
 /**
  * tomoyo_loader_setup - Set policy loader.
  *
  * @str: Program to use as a policy loader (e.g. /sbin/tomoyo-init ).
  *
  * Returns 0.
  */
 static int __init tomoyo_loader_setup(char *str)
 {
 	tomoyo_loader = str;
 	return 0;
 }
 __setup("TOMOYO_loader=", tomoyo_loader_setup);
 /**
  * tomoyo_policy_loader_exists - Check whether /sbin/tomoyo-init exists.
  *
  * Returns true if /sbin/tomoyo-init exists, false otherwise.
  */
 static bool tomoyo_policy_loader_exists(void)
 {
 	struct path path;
 	if (!tomoyo_loader)
 		tomoyo_loader = CONFIG_SECURITY_TOMOYO_POLICY_LOADER;
 	if (kern_path(tomoyo_loader, LOOKUP_FOLLOW, &path)) {
 		printk(KERN_INFO "Not activating Mandatory Access Control "
 		       "as %s does not exist.\n", tomoyo_loader);
 		return false;
 	}
 	path_put(&path);
 	return true;
 }
 /*
  * Path to the trigger. (default = CONFIG_SECURITY_TOMOYO_ACTIVATION_TRIGGER)
  */
 static const char *tomoyo_trigger;
 /**
  * tomoyo_trigger_setup - Set trigger for activation.
  *
  * @str: Program to use as an activation trigger (e.g. /sbin/init ).
  *
  * Returns 0.
  */
 static int __init tomoyo_trigger_setup(char *str)
 {
 	tomoyo_trigger = str;
 	return 0;
 }
 __setup("TOMOYO_trigger=", tomoyo_trigger_setup);
 /**
  * tomoyo_load_policy - Run external policy loader to load policy.
  *
  * @filename: The program about to start.
  *
  * This function checks whether @filename is /sbin/init , and if so
  * invoke /sbin/tomoyo-init and wait for the termination of /sbin/tomoyo-init
  * and then continues invocation of /sbin/init.
  * /sbin/tomoyo-init reads policy files in /etc/tomoyo/ directory and
  * writes to /sys/kernel/security/tomoyo/ interfaces.
  *
  * Returns nothing.
  */
 void tomoyo_load_policy(const char *filename)
 {
 	static bool done;
 	char *argv[2];
 	char *envp[3];
 	if (tomoyo_policy_loaded || done)
 		return;
 	if (!tomoyo_trigger)
 		tomoyo_trigger = CONFIG_SECURITY_TOMOYO_ACTIVATION_TRIGGER;
 	if (strcmp(filename, tomoyo_trigger))
 		return;
 	if (!tomoyo_policy_loader_exists())
 		return;
 	done = true;
 	printk(KERN_INFO "Calling %s to load policy. Please wait.\n",
 	       tomoyo_loader);
 	argv[0] = (char *) tomoyo_loader;
 	argv[1] = NULL;
 	envp[0] = "HOME=/";
 	envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
 	envp[2] = NULL;
 	call_usermodehelper(argv[0], argv, envp, 1);
 	tomoyo_check_profile();
 }
 #endif

security/tomoyo/memory.c

Diff comments View file @ 0f2a55d

 /*
  * security/tomoyo/memory.c
  *
- * Memory management functions for TOMOYO.
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
- *
- * 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");
 }
 /* Lock for protecting tomoyo_memory_used. */
 static DEFINE_SPINLOCK(tomoyo_policy_memory_lock);
 /* 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];
 /**
  * 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)
 {
 	if (ptr) {
 		const size_t s = ksize(ptr);
 		bool result;
 		spin_lock(&tomoyo_policy_memory_lock);
 		tomoyo_memory_used[TOMOYO_MEMORY_POLICY] += s;
 		result = !tomoyo_memory_quota[TOMOYO_MEMORY_POLICY] ||
 			tomoyo_memory_used[TOMOYO_MEMORY_POLICY] <=
 			tomoyo_memory_quota[TOMOYO_MEMORY_POLICY];
 		if (!result)
 			tomoyo_memory_used[TOMOYO_MEMORY_POLICY] -= s;
 		spin_unlock(&tomoyo_policy_memory_lock);
 		if (result)
 			return true;
 	}
 	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)
 {
 	size_t s = ksize(ptr);
 	spin_lock(&tomoyo_policy_memory_lock);
 	tomoyo_memory_used[TOMOYO_MEMORY_POLICY] -= s;
 	spin_unlock(&tomoyo_policy_memory_lock);
 	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 = &param->ns->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;
 	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);
 	if (tomoyo_memory_ok(ptr)) {
 		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);
 	} else {
 		kfree(ptr);
 		ptr = NULL;
 	}
 out:
 	mutex_unlock(&tomoyo_policy_lock);
 	return ptr ? &ptr->entry : NULL;
 }
 /* Initial namespace.*/
 struct tomoyo_policy_namespace tomoyo_kernel_namespace;
 /**
  * tomoyo_mm_init - Initialize mm related code.
  */
 void __init tomoyo_mm_init(void)
 {
 	int idx;
 	for (idx = 0; idx < TOMOYO_MAX_HASH; idx++)
 		INIT_LIST_HEAD(&tomoyo_name_list[idx]);
 	tomoyo_kernel_namespace.name = "<kernel>";
 	tomoyo_init_policy_namespace(&tomoyo_kernel_namespace);
 	tomoyo_kernel_domain.ns = &tomoyo_kernel_namespace;
 	INIT_LIST_HEAD(&tomoyo_kernel_domain.acl_info_list);
 	tomoyo_kernel_domain.domainname = tomoyo_get_name("<kernel>");
 	list_add_tail_rcu(&tomoyo_kernel_domain.list, &tomoyo_domain_list);
 }

security/tomoyo/mount.c

Diff comments View file @ 0f2a55d

1	/*	1	/*
2	* security/tomoyo/mount.c	2	* security/tomoyo/mount.c
3	*	3	*
4	* Copyright (C) 2005-2010 NTT DATA CORPORATION	4	* Copyright (C) 2005-2011 NTT DATA CORPORATION
5	*/	5	*/
6		6
7	#include <linux/slab.h>	7	#include <linux/slab.h>
8	#include "common.h"	8	#include "common.h"
9		9
10	/* String table for special mount operations. */	10	/* String table for special mount operations. */
11	static const char * const tomoyo_mounts[TOMOYO_MAX_SPECIAL_MOUNT] = {	11	static const char * const tomoyo_mounts[TOMOYO_MAX_SPECIAL_MOUNT] = {
12	[TOMOYO_MOUNT_BIND] = "--bind",	12	[TOMOYO_MOUNT_BIND] = "--bind",
13	[TOMOYO_MOUNT_MOVE] = "--move",	13	[TOMOYO_MOUNT_MOVE] = "--move",
14	[TOMOYO_MOUNT_REMOUNT] = "--remount",	14	[TOMOYO_MOUNT_REMOUNT] = "--remount",
15	[TOMOYO_MOUNT_MAKE_UNBINDABLE] = "--make-unbindable",	15	[TOMOYO_MOUNT_MAKE_UNBINDABLE] = "--make-unbindable",
16	[TOMOYO_MOUNT_MAKE_PRIVATE] = "--make-private",	16	[TOMOYO_MOUNT_MAKE_PRIVATE] = "--make-private",
17	[TOMOYO_MOUNT_MAKE_SLAVE] = "--make-slave",	17	[TOMOYO_MOUNT_MAKE_SLAVE] = "--make-slave",
18	[TOMOYO_MOUNT_MAKE_SHARED] = "--make-shared",	18	[TOMOYO_MOUNT_MAKE_SHARED] = "--make-shared",
19	};	19	};
20		20
21	/**	21	/**
22	* tomoyo_audit_mount_log - Audit mount log.	22	* tomoyo_audit_mount_log - Audit mount log.
23	*	23	*
24	* @r: Pointer to "struct tomoyo_request_info".	24	* @r: Pointer to "struct tomoyo_request_info".
25	*	25	*
26	* Returns 0 on success, negative value otherwise.	26	* Returns 0 on success, negative value otherwise.
27	*/	27	*/
28	static int tomoyo_audit_mount_log(struct tomoyo_request_info *r)	28	static int tomoyo_audit_mount_log(struct tomoyo_request_info *r)
29	{	29	{
30	return tomoyo_supervisor(r, "file mount %s %s %s 0x%lX\n",	30	return tomoyo_supervisor(r, "file mount %s %s %s 0x%lX\n",
31	r->param.mount.dev->name,	31	r->param.mount.dev->name,
32	r->param.mount.dir->name,	32	r->param.mount.dir->name,
33	r->param.mount.type->name,	33	r->param.mount.type->name,
34	r->param.mount.flags);	34	r->param.mount.flags);
35	}	35	}
36		36
37	/**	37	/**
38	* tomoyo_check_mount_acl - Check permission for path path path number operation.	38	* tomoyo_check_mount_acl - Check permission for path path path number operation.
39	*	39	*
40	* @r: Pointer to "struct tomoyo_request_info".	40	* @r: Pointer to "struct tomoyo_request_info".
41	* @ptr: Pointer to "struct tomoyo_acl_info".	41	* @ptr: Pointer to "struct tomoyo_acl_info".
42	*	42	*
43	* Returns true if granted, false otherwise.	43	* Returns true if granted, false otherwise.
44	*/	44	*/
45	static bool tomoyo_check_mount_acl(struct tomoyo_request_info *r,	45	static bool tomoyo_check_mount_acl(struct tomoyo_request_info *r,
46	const struct tomoyo_acl_info *ptr)	46	const struct tomoyo_acl_info *ptr)
47	{	47	{
48	const struct tomoyo_mount_acl *acl =	48	const struct tomoyo_mount_acl *acl =
49	container_of(ptr, typeof(*acl), head);	49	container_of(ptr, typeof(*acl), head);
50	return tomoyo_compare_number_union(r->param.mount.flags,	50	return tomoyo_compare_number_union(r->param.mount.flags,
51	&acl->flags) &&	51	&acl->flags) &&
52	tomoyo_compare_name_union(r->param.mount.type,	52	tomoyo_compare_name_union(r->param.mount.type,
53	&acl->fs_type) &&	53	&acl->fs_type) &&
54	tomoyo_compare_name_union(r->param.mount.dir,	54	tomoyo_compare_name_union(r->param.mount.dir,
55	&acl->dir_name) &&	55	&acl->dir_name) &&
56	(!r->param.mount.need_dev \|\|	56	(!r->param.mount.need_dev \|\|
57	tomoyo_compare_name_union(r->param.mount.dev,	57	tomoyo_compare_name_union(r->param.mount.dev,
58	&acl->dev_name));	58	&acl->dev_name));
59	}	59	}
60		60
61	/**	61	/**
62	* tomoyo_mount_acl - Check permission for mount() operation.	62	* tomoyo_mount_acl - Check permission for mount() operation.
63	*	63	*
64	* @r: Pointer to "struct tomoyo_request_info".	64	* @r: Pointer to "struct tomoyo_request_info".
65	* @dev_name: Name of device file.	65	* @dev_name: Name of device file. Maybe NULL.
66	* @dir: Pointer to "struct path".	66	* @dir: Pointer to "struct path".
67	* @type: Name of filesystem type.	67	* @type: Name of filesystem type.
68	* @flags: Mount options.	68	* @flags: Mount options.
69	*	69	*
70	* Returns 0 on success, negative value otherwise.	70	* Returns 0 on success, negative value otherwise.
71	*	71	*
72	* Caller holds tomoyo_read_lock().	72	* Caller holds tomoyo_read_lock().
73	*/	73	*/
74	static int tomoyo_mount_acl(struct tomoyo_request_info r, char dev_name,	74	static int tomoyo_mount_acl(struct tomoyo_request_info r, char dev_name,
75	struct path dir, const char type,	75	struct path dir, const char type,
76	unsigned long flags)	76	unsigned long flags)
77	{	77	{
78	struct tomoyo_obj_info obj = { };	78	struct tomoyo_obj_info obj = { };
79	struct path path;	79	struct path path;
80	struct file_system_type *fstype = NULL;	80	struct file_system_type *fstype = NULL;
81	const char *requested_type = NULL;	81	const char *requested_type = NULL;
82	const char *requested_dir_name = NULL;	82	const char *requested_dir_name = NULL;
83	const char *requested_dev_name = NULL;	83	const char *requested_dev_name = NULL;
84	struct tomoyo_path_info rtype;	84	struct tomoyo_path_info rtype;
85	struct tomoyo_path_info rdev;	85	struct tomoyo_path_info rdev;
86	struct tomoyo_path_info rdir;	86	struct tomoyo_path_info rdir;
87	int need_dev = 0;	87	int need_dev = 0;
88	int error = -ENOMEM;	88	int error = -ENOMEM;
89	r->obj = &obj;	89	r->obj = &obj;
90		90
91	/* Get fstype. */	91	/* Get fstype. */
92	requested_type = tomoyo_encode(type);	92	requested_type = tomoyo_encode(type);
93	if (!requested_type)	93	if (!requested_type)
94	goto out;	94	goto out;
95	rtype.name = requested_type;	95	rtype.name = requested_type;
96	tomoyo_fill_path_info(&rtype);	96	tomoyo_fill_path_info(&rtype);
97		97
98	/* Get mount point. */	98	/* Get mount point. */
99	obj.path2 = *dir;	99	obj.path2 = *dir;
100	requested_dir_name = tomoyo_realpath_from_path(dir);	100	requested_dir_name = tomoyo_realpath_from_path(dir);
101	if (!requested_dir_name) {	101	if (!requested_dir_name) {
102	error = -ENOMEM;	102	error = -ENOMEM;
103	goto out;	103	goto out;
104	}	104	}
105	rdir.name = requested_dir_name;	105	rdir.name = requested_dir_name;
106	tomoyo_fill_path_info(&rdir);	106	tomoyo_fill_path_info(&rdir);
107		107
108	/* Compare fs name. */	108	/* Compare fs name. */
109	if (type == tomoyo_mounts[TOMOYO_MOUNT_REMOUNT]) {	109	if (type == tomoyo_mounts[TOMOYO_MOUNT_REMOUNT]) {
110	/* dev_name is ignored. */	110	/* dev_name is ignored. */
111	} else if (type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_UNBINDABLE] \|\|	111	} else if (type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_UNBINDABLE] \|\|
112	type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_PRIVATE] \|\|	112	type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_PRIVATE] \|\|
113	type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_SLAVE] \|\|	113	type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_SLAVE] \|\|
114	type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_SHARED]) {	114	type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_SHARED]) {
115	/* dev_name is ignored. */	115	/* dev_name is ignored. */
116	} else if (type == tomoyo_mounts[TOMOYO_MOUNT_BIND] \|\|	116	} else if (type == tomoyo_mounts[TOMOYO_MOUNT_BIND] \|\|
117	type == tomoyo_mounts[TOMOYO_MOUNT_MOVE]) {	117	type == tomoyo_mounts[TOMOYO_MOUNT_MOVE]) {
118	need_dev = -1; /* dev_name is a directory */	118	need_dev = -1; /* dev_name is a directory */
119	} else {	119	} else {
120	fstype = get_fs_type(type);	120	fstype = get_fs_type(type);
121	if (!fstype) {	121	if (!fstype) {
122	error = -ENODEV;	122	error = -ENODEV;
123	goto out;	123	goto out;
124	}	124	}
125	if (fstype->fs_flags & FS_REQUIRES_DEV)	125	if (fstype->fs_flags & FS_REQUIRES_DEV)
126	/* dev_name is a block device file. */	126	/* dev_name is a block device file. */
127	need_dev = 1;	127	need_dev = 1;
128	}	128	}
129	if (need_dev) {	129	if (need_dev) {
130	/* Get mount point or device file. */	130	/* Get mount point or device file. */
131	if (!dev_name \|\| kern_path(dev_name, LOOKUP_FOLLOW, &path)) {	131	if (!dev_name \|\| kern_path(dev_name, LOOKUP_FOLLOW, &path)) {
132	error = -ENOENT;	132	error = -ENOENT;
133	goto out;	133	goto out;
134	}	134	}
135	obj.path1 = path;	135	obj.path1 = path;
136	requested_dev_name = tomoyo_realpath_from_path(&path);	136	requested_dev_name = tomoyo_realpath_from_path(&path);
137	if (!requested_dev_name) {	137	if (!requested_dev_name) {
138	error = -ENOENT;	138	error = -ENOENT;
139	goto out;	139	goto out;
140	}	140	}
141	} else {	141	} else {
142	/* Map dev_name to "<NULL>" if no dev_name given. */	142	/* Map dev_name to "<NULL>" if no dev_name given. */
143	if (!dev_name)	143	if (!dev_name)
144	dev_name = "<NULL>";	144	dev_name = "<NULL>";
145	requested_dev_name = tomoyo_encode(dev_name);	145	requested_dev_name = tomoyo_encode(dev_name);
146	if (!requested_dev_name) {	146	if (!requested_dev_name) {
147	error = -ENOMEM;	147	error = -ENOMEM;
148	goto out;	148	goto out;
149	}	149	}
150	}	150	}
151	rdev.name = requested_dev_name;	151	rdev.name = requested_dev_name;
152	tomoyo_fill_path_info(&rdev);	152	tomoyo_fill_path_info(&rdev);
153	r->param_type = TOMOYO_TYPE_MOUNT_ACL;	153	r->param_type = TOMOYO_TYPE_MOUNT_ACL;
154	r->param.mount.need_dev = need_dev;	154	r->param.mount.need_dev = need_dev;
155	r->param.mount.dev = &rdev;	155	r->param.mount.dev = &rdev;
156	r->param.mount.dir = &rdir;	156	r->param.mount.dir = &rdir;
157	r->param.mount.type = &rtype;	157	r->param.mount.type = &rtype;
158	r->param.mount.flags = flags;	158	r->param.mount.flags = flags;
159	do {	159	do {
160	tomoyo_check_acl(r, tomoyo_check_mount_acl);	160	tomoyo_check_acl(r, tomoyo_check_mount_acl);
161	error = tomoyo_audit_mount_log(r);	161	error = tomoyo_audit_mount_log(r);
162	} while (error == TOMOYO_RETRY_REQUEST);	162	} while (error == TOMOYO_RETRY_REQUEST);
163	out:	163	out:
164	kfree(requested_dev_name);	164	kfree(requested_dev_name);
165	kfree(requested_dir_name);	165	kfree(requested_dir_name);
166	if (fstype)	166	if (fstype)
167	put_filesystem(fstype);	167	put_filesystem(fstype);
168	kfree(requested_type);	168	kfree(requested_type);
169	/* Drop refcount obtained by kern_path(). */	169	/* Drop refcount obtained by kern_path(). */
170	if (obj.path1.dentry)	170	if (obj.path1.dentry)
171	path_put(&obj.path1);	171	path_put(&obj.path1);
172	return error;	172	return error;
173	}	173	}
174		174
175	/**	175	/**
176	* tomoyo_mount_permission - Check permission for mount() operation.	176	* tomoyo_mount_permission - Check permission for mount() operation.
177	*	177	*
178	* @dev_name: Name of device file.	178	* @dev_name: Name of device file. Maybe NULL.
179	* @path: Pointer to "struct path".	179	* @path: Pointer to "struct path".
180	* @type: Name of filesystem type. May be NULL.	180	* @type: Name of filesystem type. Maybe NULL.
181	* @flags: Mount options.	181	* @flags: Mount options.
182	* @data_page: Optional data. May be NULL.	182	* @data_page: Optional data. Maybe NULL.
183	*	183	*
184	* Returns 0 on success, negative value otherwise.	184	* Returns 0 on success, negative value otherwise.
185	*/	185	*/
186	int tomoyo_mount_permission(char dev_name, struct path path,	186	int tomoyo_mount_permission(char dev_name, struct path path,
187	const char *type, unsigned long flags,	187	const char *type, unsigned long flags,
188	void *data_page)	188	void *data_page)
189	{	189	{
190	struct tomoyo_request_info r;	190	struct tomoyo_request_info r;
191	int error;	191	int error;
192	int idx;	192	int idx;
193		193
194	if (tomoyo_init_request_info(&r, NULL, TOMOYO_MAC_FILE_MOUNT)	194	if (tomoyo_init_request_info(&r, NULL, TOMOYO_MAC_FILE_MOUNT)
195	== TOMOYO_CONFIG_DISABLED)	195	== TOMOYO_CONFIG_DISABLED)
196	return 0;	196	return 0;
197	if ((flags & MS_MGC_MSK) == MS_MGC_VAL)	197	if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
198	flags &= ~MS_MGC_MSK;	198	flags &= ~MS_MGC_MSK;
199	if (flags & MS_REMOUNT) {	199	if (flags & MS_REMOUNT) {
200	type = tomoyo_mounts[TOMOYO_MOUNT_REMOUNT];	200	type = tomoyo_mounts[TOMOYO_MOUNT_REMOUNT];
201	flags &= ~MS_REMOUNT;	201	flags &= ~MS_REMOUNT;
202	}	202	}
203	if (flags & MS_MOVE) {	203	if (flags & MS_MOVE) {
204	type = tomoyo_mounts[TOMOYO_MOUNT_MOVE];	204	type = tomoyo_mounts[TOMOYO_MOUNT_MOVE];
205	flags &= ~MS_MOVE;	205	flags &= ~MS_MOVE;
206	}	206	}
207	if (flags & MS_BIND) {	207	if (flags & MS_BIND) {
208	type = tomoyo_mounts[TOMOYO_MOUNT_BIND];	208	type = tomoyo_mounts[TOMOYO_MOUNT_BIND];
209	flags &= ~MS_BIND;	209	flags &= ~MS_BIND;
210	}	210	}
211	if (flags & MS_UNBINDABLE) {	211	if (flags & MS_UNBINDABLE) {
212	type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_UNBINDABLE];	212	type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_UNBINDABLE];
213	flags &= ~MS_UNBINDABLE;	213	flags &= ~MS_UNBINDABLE;
214	}	214	}
215	if (flags & MS_PRIVATE) {	215	if (flags & MS_PRIVATE) {
216	type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_PRIVATE];	216	type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_PRIVATE];
217	flags &= ~MS_PRIVATE;	217	flags &= ~MS_PRIVATE;
218	}	218	}
219	if (flags & MS_SLAVE) {	219	if (flags & MS_SLAVE) {
220	type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_SLAVE];	220	type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_SLAVE];
221	flags &= ~MS_SLAVE;	221	flags &= ~MS_SLAVE;
222	}	222	}
223	if (flags & MS_SHARED) {	223	if (flags & MS_SHARED) {
224	type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_SHARED];	224	type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_SHARED];
225	flags &= ~MS_SHARED;	225	flags &= ~MS_SHARED;
226	}	226	}
227	if (!type)	227	if (!type)
228	type = "<NULL>";	228	type = "<NULL>";
229	idx = tomoyo_read_lock();	229	idx = tomoyo_read_lock();
230	error = tomoyo_mount_acl(&r, dev_name, path, type, flags);	230	error = tomoyo_mount_acl(&r, dev_name, path, type, flags);
231	tomoyo_read_unlock(idx);	231	tomoyo_read_unlock(idx);
232	return error;	232	return error;
233	}	233	}
234		234

security/tomoyo/realpath.c

Diff comments View file @ 0f2a55d

 /*
  * security/tomoyo/realpath.c
  *
- * Pathname calculation functions for TOMOYO.
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
  */
 #include <linux/types.h>
 #include <linux/mount.h>
 #include <linux/mnt_namespace.h>
 #include <linux/fs_struct.h>
 #include <linux/magic.h>
 #include <linux/slab.h>
 #include <net/sock.h>
 #include "common.h"
 #include "../../fs/internal.h"
 /**
  * tomoyo_encode: Convert binary string to ascii string.
  *
  * @str: String in binary format.
  *
  * Returns pointer to @str in ascii format on success, NULL otherwise.
  *
  * This function uses kzalloc(), so caller must kfree() if this function
  * didn't return NULL.
  */
 char *tomoyo_encode(const char *str)
 {
 	int len = 0;
 	const char *p = str;
 	char *cp;
 	char *cp0;
 	if (!p)
 		return NULL;
 	while (*p) {
 		const unsigned char c = *p++;
 		if (c == '\\')
 			len += 2;
 		else if (c > ' ' && c < 127)
 			len++;
 		else
 			len += 4;
 	}
 	len++;
 	/* Reserve space for appending "/". */
 	cp = kzalloc(len + 10, GFP_NOFS);
 	if (!cp)
 		return NULL;
 	cp0 = cp;
 	p = str;
 	while (*p) {
 		const unsigned char c = *p++;
 		if (c == '\\') {
 			*cp++ = '\\';
 			*cp++ = '\\';
 		} else if (c > ' ' && c < 127) {
 			*cp++ = c;
 		} else {
 			*cp++ = '\\';
 			*cp++ = (c >> 6) + '0';
 			*cp++ = ((c >> 3) & 7) + '0';
 			*cp++ = (c & 7) + '0';
 		}
 	}
 	return cp0;
 }
 /**
  * tomoyo_get_absolute_path - Get the path of a dentry but ignores chroot'ed root.
  *
  * @path:   Pointer to "struct path".
  * @buffer: Pointer to buffer to return value in.
  * @buflen: Sizeof @buffer.
  *
  * Returns the buffer on success, an error code otherwise.
  *
  * If dentry is a directory, trailing '/' is appended.
  */
 static char *tomoyo_get_absolute_path(struct path *path, char * const buffer,
 				      const int buflen)
 {
 	char *pos = ERR_PTR(-ENOMEM);
 	if (buflen >= 256) {
 		struct path ns_root = { };
 		/* go to whatever namespace root we are under */
 		pos = __d_path(path, &ns_root, buffer, buflen - 1);
 		if (!IS_ERR(pos) && *pos == '/' && pos[1]) {
 			struct inode *inode = path->dentry->d_inode;
 			if (inode && S_ISDIR(inode->i_mode)) {
 				buffer[buflen - 2] = '/';
 				buffer[buflen - 1] = '\0';
 			}
 		}
 	}
 	return pos;
 }
 /**
  * tomoyo_get_dentry_path - Get the path of a dentry.
  *
  * @dentry: Pointer to "struct dentry".
  * @buffer: Pointer to buffer to return value in.
  * @buflen: Sizeof @buffer.
  *
  * Returns the buffer on success, an error code otherwise.
  *
  * If dentry is a directory, trailing '/' is appended.
  */
 static char *tomoyo_get_dentry_path(struct dentry *dentry, char * const buffer,
 				    const int buflen)
 {
 	char *pos = ERR_PTR(-ENOMEM);
 	if (buflen >= 256) {
 		pos = dentry_path_raw(dentry, buffer, buflen - 1);
 		if (!IS_ERR(pos) && *pos == '/' && pos[1]) {
 			struct inode *inode = dentry->d_inode;
 			if (inode && S_ISDIR(inode->i_mode)) {
 				buffer[buflen - 2] = '/';
 				buffer[buflen - 1] = '\0';
 			}
 		}
 	}
 	return pos;
 }
 /**
  * tomoyo_get_local_path - Get the path of a dentry.
  *
  * @dentry: Pointer to "struct dentry".
  * @buffer: Pointer to buffer to return value in.
  * @buflen: Sizeof @buffer.
  *
  * Returns the buffer on success, an error code otherwise.
  */
 static char *tomoyo_get_local_path(struct dentry *dentry, char * const buffer,
 				   const int buflen)
 {
 	struct super_block *sb = dentry->d_sb;
 	char *pos = tomoyo_get_dentry_path(dentry, buffer, buflen);
 	if (IS_ERR(pos))
 		return pos;
 	/* Convert from $PID to self if $PID is current thread. */
 	if (sb->s_magic == PROC_SUPER_MAGIC && *pos == '/') {
 		char *ep;
 		const pid_t pid = (pid_t) simple_strtoul(pos + 1, &ep, 10);
 		if (*ep == '/' && pid && pid ==
 		    task_tgid_nr_ns(current, sb->s_fs_info)) {
 			pos = ep - 5;
 			if (pos < buffer)
 				goto out;
 			memmove(pos, "/self", 5);
 		}
 		goto prepend_filesystem_name;
 	}
 	/* Use filesystem name for unnamed devices. */
 	if (!MAJOR(sb->s_dev))
 		goto prepend_filesystem_name;
 	{
 		struct inode *inode = sb->s_root->d_inode;
 		/*
 		 * Use filesystem name if filesystem does not support rename()
 		 * operation.
 		 */
 		if (inode->i_op && !inode->i_op->rename)
 			goto prepend_filesystem_name;
 	}
 	/* Prepend device name. */
 	{
 		char name[64];
 		int name_len;
 		const dev_t dev = sb->s_dev;
 		name[sizeof(name) - 1] = '\0';
 		snprintf(name, sizeof(name) - 1, "dev(%u,%u):", MAJOR(dev),
 			 MINOR(dev));
 		name_len = strlen(name);
 		pos -= name_len;
 		if (pos < buffer)
 			goto out;
 		memmove(pos, name, name_len);
 		return pos;
 	}
 	/* Prepend filesystem name. */
 prepend_filesystem_name:
 	{
 		const char *name = sb->s_type->name;
 		const int name_len = strlen(name);
 		pos -= name_len + 1;
 		if (pos < buffer)
 			goto out;
 		memmove(pos, name, name_len);
 		pos[name_len] = ':';
 	}
 	return pos;
 out:
 	return ERR_PTR(-ENOMEM);
 }
 /**
  * tomoyo_get_socket_name - Get the name of a socket.
  *
  * @path:   Pointer to "struct path".
  * @buffer: Pointer to buffer to return value in.
  * @buflen: Sizeof @buffer.
  *
  * Returns the buffer.
  */
 static char *tomoyo_get_socket_name(struct path *path, char * const buffer,
 				    const int buflen)
 {
 	struct inode *inode = path->dentry->d_inode;
 	struct socket *sock = inode ? SOCKET_I(inode) : NULL;
 	struct sock *sk = sock ? sock->sk : NULL;
 	if (sk) {
 		snprintf(buffer, buflen, "socket:[family=%u:type=%u:"
 			 "protocol=%u]", sk->sk_family, sk->sk_type,
 			 sk->sk_protocol);
 	} else {
 		snprintf(buffer, buflen, "socket:[unknown]");
 	}
 	return buffer;
 }
 /**
  * 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.
  *
  * 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.
  *
  * 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 = NULL;
 	char *name = NULL;
 	unsigned int buf_len = PAGE_SIZE / 2;
 	struct dentry *dentry = path->dentry;
 	struct super_block *sb;
 	if (!dentry)
 		return NULL;
 	sb = dentry->d_sb;
 	while (1) {
 		char *pos;
 		struct inode *inode;
 		buf_len <<= 1;
 		kfree(buf);
 		buf = kmalloc(buf_len, GFP_NOFS);
 		if (!buf)
 			break;
 		/* To make sure that pos is '\0' terminated. */
 		buf[buf_len - 1] = '\0';
 		/* Get better name for socket. */
 		if (sb->s_magic == SOCKFS_MAGIC) {
 			pos = tomoyo_get_socket_name(path, buf, buf_len - 1);
 			goto encode;
 		}
 		/* For "pipe:[\$]". */
 		if (dentry->d_op && dentry->d_op->d_dname) {
 			pos = dentry->d_op->d_dname(dentry, buf, buf_len - 1);
 			goto encode;
 		}
 		inode = sb->s_root->d_inode;
 		/*
 		 * Get local name for filesystems without rename() operation
 		 * or dentry without vfsmount.
 		 */
 		if (!path->mnt || (inode->i_op && !inode->i_op->rename))
 			pos = tomoyo_get_local_path(path->dentry, buf,
 						    buf_len - 1);
 		/* Get absolute name for the rest. */
 		else
 			pos = tomoyo_get_absolute_path(path, buf, buf_len - 1);
 encode:
 		if (IS_ERR(pos))
 			continue;
 		name = tomoyo_encode(pos);
 		break;
 	}
 	kfree(buf);
 	if (!name)
 		tomoyo_warn_oom(__func__);
 	return name;
 }
 /**
  * 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;
 }

security/tomoyo/securityfs_if.c

Diff comments View file @ 0f2a55d

 /*
- * security/tomoyo/common.c
+ * security/tomoyo/securityfs_if.c
  *
- * Securityfs interface for TOMOYO.
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
  */
 #include <linux/security.h>
 #include "common.h"
 /**
  * tomoyo_open - open() for /sys/kernel/security/tomoyo/ interface.
  *
  * @inode: Pointer to "struct inode".
  * @file:  Pointer to "struct file".
  *
  * Returns 0 on success, negative value otherwise.
  */
 static int tomoyo_open(struct inode *inode, struct file *file)
 {
 	const int key = ((u8 *) file->f_path.dentry->d_inode->i_private)
 		- ((u8 *) NULL);
 	return tomoyo_open_control(key, file);
 }
 /**
  * tomoyo_release - close() for /sys/kernel/security/tomoyo/ interface.
  *
  * @inode: Pointer to "struct inode".
  * @file:  Pointer to "struct file".
  *
  * Returns 0 on success, negative value otherwise.
  */
 static int tomoyo_release(struct inode *inode, struct file *file)
 {
 	return tomoyo_close_control(file->private_data);
 }
 /**
  * tomoyo_poll - poll() for /sys/kernel/security/tomoyo/ interface.
  *
  * @file: Pointer to "struct file".
  * @wait: Pointer to "poll_table".
  *
  * Returns 0 on success, negative value otherwise.
  */
 static unsigned int tomoyo_poll(struct file *file, poll_table *wait)
 {
 	return tomoyo_poll_control(file, wait);
 }
 /**
  * tomoyo_read - read() for /sys/kernel/security/tomoyo/ interface.
  *
  * @file:  Pointer to "struct file".
  * @buf:   Pointer to buffer.
  * @count: Size of @buf.
  * @ppos:  Unused.
  *
  * Returns bytes read on success, negative value otherwise.
  */
 static ssize_t tomoyo_read(struct file *file, char __user *buf, size_t count,
 			   loff_t *ppos)
 {
 	return tomoyo_read_control(file->private_data, buf, count);
 }
 /**
  * tomoyo_write - write() for /sys/kernel/security/tomoyo/ interface.
  *
  * @file:  Pointer to "struct file".
  * @buf:   Pointer to buffer.
  * @count: Size of @buf.
  * @ppos:  Unused.
  *
  * Returns @count on success, negative value otherwise.
  */
 static ssize_t tomoyo_write(struct file *file, const char __user *buf,
 			    size_t count, loff_t *ppos)
 {
 	return tomoyo_write_control(file->private_data, buf, count);
 }
 /*
  * tomoyo_operations is a "struct file_operations" which is used for handling
  * /sys/kernel/security/tomoyo/ interface.
  *
  * Some files under /sys/kernel/security/tomoyo/ directory accept open(O_RDWR).
  * See tomoyo_io_buffer for internals.
  */
 static const struct file_operations tomoyo_operations = {
 	.open    = tomoyo_open,
 	.release = tomoyo_release,
 	.poll    = tomoyo_poll,
 	.read    = tomoyo_read,
 	.write   = tomoyo_write,
 	.llseek  = noop_llseek,
 };
 /**
  * tomoyo_create_entry - Create interface files under /sys/kernel/security/tomoyo/ directory.
  *
  * @name:   The name of the interface file.
  * @mode:   The permission of the interface file.
  * @parent: The parent directory.
  * @key:    Type of interface.
  *
  * Returns nothing.
  */
 static void __init tomoyo_create_entry(const char *name, const mode_t mode,
 				       struct dentry *parent, const u8 key)
 {
 	securityfs_create_file(name, mode, parent, ((u8 *) NULL) + key,
 			       &tomoyo_operations);
 }
 /**
  * tomoyo_initerface_init - Initialize /sys/kernel/security/tomoyo/ interface.
  *
  * Returns 0.
  */
 static int __init tomoyo_initerface_init(void)
 {
 	struct dentry *tomoyo_dir;
 	/* Don't create securityfs entries unless registered. */
 	if (current_cred()->security != &tomoyo_kernel_domain)
 		return 0;
 	tomoyo_dir = securityfs_create_dir("tomoyo", NULL);
 	tomoyo_create_entry("query",            0600, tomoyo_dir,
 			    TOMOYO_QUERY);
 	tomoyo_create_entry("domain_policy",    0600, tomoyo_dir,
 			    TOMOYO_DOMAINPOLICY);
 	tomoyo_create_entry("exception_policy", 0600, tomoyo_dir,
 			    TOMOYO_EXCEPTIONPOLICY);
 	tomoyo_create_entry("audit",            0400, tomoyo_dir,
 			    TOMOYO_AUDIT);
 	tomoyo_create_entry("self_domain",      0400, tomoyo_dir,
 			    TOMOYO_SELFDOMAIN);
 	tomoyo_create_entry(".process_status",  0600, tomoyo_dir,
 			    TOMOYO_PROCESS_STATUS);
 	tomoyo_create_entry("stat",             0644, tomoyo_dir,
 			    TOMOYO_STAT);
 	tomoyo_create_entry("profile",          0600, tomoyo_dir,
 			    TOMOYO_PROFILE);
 	tomoyo_create_entry("manager",          0600, tomoyo_dir,
 			    TOMOYO_MANAGER);
 	tomoyo_create_entry("version",          0400, tomoyo_dir,
 			    TOMOYO_VERSION);
 	return 0;
 }
 fs_initcall(tomoyo_initerface_init);

security/tomoyo/tomoyo.c

Diff comments View file @ 0f2a55d

 /*
  * security/tomoyo/tomoyo.c
  *
- * LSM hooks for TOMOYO Linux.
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
  */
 #include <linux/security.h>
 #include "common.h"
+/**
+ * tomoyo_cred_alloc_blank - Target for security_cred_alloc_blank().
+ *
+ * @new: Pointer to "struct cred".
+ * @gfp: Memory allocation flags.
+ *
+ * Returns 0.
+ */
 static int tomoyo_cred_alloc_blank(struct cred *new, gfp_t gfp)
 {
 	new->security = NULL;
 	return 0;
 }
+/**
+ * tomoyo_cred_prepare - Target for security_prepare_creds().
+ *
+ * @new: Pointer to "struct cred".
+ * @old: Pointer to "struct cred".
+ * @gfp: Memory allocation flags.
+ *
+ * Returns 0.
+ */
 static int tomoyo_cred_prepare(struct cred *new, const struct cred *old,
 			       gfp_t gfp)
 {
 	struct tomoyo_domain_info *domain = old->security;
 	new->security = domain;
 	if (domain)
 		atomic_inc(&domain->users);
 	return 0;
 }
+/**
+ * tomoyo_cred_transfer - Target for security_transfer_creds().
+ *
+ * @new: Pointer to "struct cred".
+ * @old: Pointer to "struct cred".
+ */
 static void tomoyo_cred_transfer(struct cred *new, const struct cred *old)
 {
 	tomoyo_cred_prepare(new, old, 0);
 }
+/**
+ * tomoyo_cred_free - Target for security_cred_free().
+ *
+ * @cred: Pointer to "struct cred".
+ */
 static void tomoyo_cred_free(struct cred *cred)
 {
 	struct tomoyo_domain_info *domain = cred->security;
 	if (domain)
 		atomic_dec(&domain->users);
 }
+/**
+ * tomoyo_bprm_set_creds - Target for security_bprm_set_creds().
+ *
+ * @bprm: Pointer to "struct linux_binprm".
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_bprm_set_creds(struct linux_binprm *bprm)
 {
 	int rc;
 	rc = cap_bprm_set_creds(bprm);
 	if (rc)
 		return rc;
 	/*
 	 * Do only if this function is called for the first time of an execve
 	 * operation.
 	 */
 	if (bprm->cred_prepared)
 		return 0;
 #ifndef CONFIG_SECURITY_TOMOYO_OMIT_USERSPACE_LOADER
 	/*
 	 * Load policy if /sbin/tomoyo-init exists and /sbin/init is requested
 	 * for the first time.
 	 */
 	if (!tomoyo_policy_loaded)
 		tomoyo_load_policy(bprm->filename);
 #endif
 	/*
 	 * Release reference to "struct tomoyo_domain_info" stored inside
 	 * "bprm->cred->security". New reference to "struct tomoyo_domain_info"
 	 * stored inside "bprm->cred->security" will be acquired later inside
 	 * tomoyo_find_next_domain().
 	 */
 	atomic_dec(&((struct tomoyo_domain_info *)
 		     bprm->cred->security)->users);
 	/*
 	 * Tell tomoyo_bprm_check_security() is called for the first time of an
 	 * execve operation.
 	 */
 	bprm->cred->security = NULL;
 	return 0;
 }
+/**
+ * tomoyo_bprm_check_security - Target for security_bprm_check().
+ *
+ * @bprm: Pointer to "struct linux_binprm".
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_bprm_check_security(struct linux_binprm *bprm)
 {
 	struct tomoyo_domain_info *domain = bprm->cred->security;
 	/*
 	 * Execute permission is checked against pathname passed to do_execve()
 	 * using current domain.
 	 */
 	if (!domain) {
 		const int idx = tomoyo_read_lock();
 		const int err = tomoyo_find_next_domain(bprm);
 		tomoyo_read_unlock(idx);
 		return err;
 	}
 	/*
 	 * Read permission is checked against interpreters using next domain.
 	 */
-	return tomoyo_check_open_permission(domain, &bprm->file->f_path, O_RDONLY);
+	return tomoyo_check_open_permission(domain, &bprm->file->f_path,
+					    O_RDONLY);
 }
+/**
+ * tomoyo_inode_getattr - Target for security_inode_getattr().
+ *
+ * @mnt:    Pointer to "struct vfsmount".
+ * @dentry: Pointer to "struct dentry".
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
 {
 	struct path path = { mnt, dentry };
 	return tomoyo_path_perm(TOMOYO_TYPE_GETATTR, &path, NULL);
 }
+/**
+ * tomoyo_path_truncate - Target for security_path_truncate().
+ *
+ * @path: Pointer to "struct path".
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_path_truncate(struct path *path)
 {
 	return tomoyo_path_perm(TOMOYO_TYPE_TRUNCATE, path, NULL);
 }
+/**
+ * tomoyo_path_unlink - Target for security_path_unlink().
+ *
+ * @parent: Pointer to "struct path".
+ * @dentry: Pointer to "struct dentry".
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_path_unlink(struct path *parent, struct dentry *dentry)
 {
 	struct path path = { parent->mnt, dentry };
 	return tomoyo_path_perm(TOMOYO_TYPE_UNLINK, &path, NULL);
 }
+/**
+ * tomoyo_path_mkdir - Target for security_path_mkdir().
+ *
+ * @parent: Pointer to "struct path".
+ * @dentry: Pointer to "struct dentry".
+ * @mode:   DAC permission mode.
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_path_mkdir(struct path *parent, struct dentry *dentry,
 			     int mode)
 {
 	struct path path = { parent->mnt, dentry };
 	return tomoyo_path_number_perm(TOMOYO_TYPE_MKDIR, &path,
 				       mode & S_IALLUGO);
 }
+/**
+ * tomoyo_path_rmdir - Target for security_path_rmdir().
+ *
+ * @parent: Pointer to "struct path".
+ * @dentry: Pointer to "struct dentry".
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_path_rmdir(struct path *parent, struct dentry *dentry)
 {
 	struct path path = { parent->mnt, dentry };
 	return tomoyo_path_perm(TOMOYO_TYPE_RMDIR, &path, NULL);
 }
+/**
+ * tomoyo_path_symlink - Target for security_path_symlink().
+ *
+ * @parent:   Pointer to "struct path".
+ * @dentry:   Pointer to "struct dentry".
+ * @old_name: Symlink's content.
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_path_symlink(struct path *parent, struct dentry *dentry,
 			       const char *old_name)
 {
 	struct path path = { parent->mnt, dentry };
 	return tomoyo_path_perm(TOMOYO_TYPE_SYMLINK, &path, old_name);
 }
+/**
+ * tomoyo_path_mknod - Target for security_path_mknod().
+ *
+ * @parent: Pointer to "struct path".
+ * @dentry: Pointer to "struct dentry".
+ * @mode:   DAC permission mode.
+ * @dev:    Device attributes.
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_path_mknod(struct path *parent, struct dentry *dentry,
 			     int mode, unsigned int dev)
 {
 	struct path path = { parent->mnt, dentry };
 	int type = TOMOYO_TYPE_CREATE;
 	const unsigned int perm = mode & S_IALLUGO;
 	switch (mode & S_IFMT) {
 	case S_IFCHR:
 		type = TOMOYO_TYPE_MKCHAR;
 		break;
 	case S_IFBLK:
 		type = TOMOYO_TYPE_MKBLOCK;
 		break;
 	default:
 		goto no_dev;
 	}
 	return tomoyo_mkdev_perm(type, &path, perm, dev);
  no_dev:
 	switch (mode & S_IFMT) {
 	case S_IFIFO:
 		type = TOMOYO_TYPE_MKFIFO;
 		break;
 	case S_IFSOCK:
 		type = TOMOYO_TYPE_MKSOCK;
 		break;
 	}
 	return tomoyo_path_number_perm(type, &path, perm);
 }
+/**
+ * tomoyo_path_link - Target for security_path_link().
+ *
+ * @old_dentry: Pointer to "struct dentry".
+ * @new_dir:    Pointer to "struct path".
+ * @new_dentry: Pointer to "struct dentry".
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_path_link(struct dentry *old_dentry, struct path *new_dir,
 			    struct dentry *new_dentry)
 {
 	struct path path1 = { new_dir->mnt, old_dentry };
 	struct path path2 = { new_dir->mnt, new_dentry };
 	return tomoyo_path2_perm(TOMOYO_TYPE_LINK, &path1, &path2);
 }
+/**
+ * tomoyo_path_rename - Target for security_path_rename().
+ *
+ * @old_parent: Pointer to "struct path".
+ * @old_dentry: Pointer to "struct dentry".
+ * @new_parent: Pointer to "struct path".
+ * @new_dentry: Pointer to "struct dentry".
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_path_rename(struct path *old_parent,
 			      struct dentry *old_dentry,
 			      struct path *new_parent,
 			      struct dentry *new_dentry)
 {
 	struct path path1 = { old_parent->mnt, old_dentry };
 	struct path path2 = { new_parent->mnt, new_dentry };
 	return tomoyo_path2_perm(TOMOYO_TYPE_RENAME, &path1, &path2);
 }
+/**
+ * tomoyo_file_fcntl - Target for security_file_fcntl().
+ *
+ * @file: Pointer to "struct file".
+ * @cmd:  Command for fcntl().
+ * @arg:  Argument for @cmd.
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_file_fcntl(struct file *file, unsigned int cmd,
 			     unsigned long arg)
 {
 	if (!(cmd == F_SETFL && ((arg ^ file->f_flags) & O_APPEND)))
 		return 0;
 	return tomoyo_check_open_permission(tomoyo_domain(), &file->f_path,
 					    O_WRONLY | (arg & O_APPEND));
 }
+/**
+ * tomoyo_dentry_open - Target for security_dentry_open().
+ *
+ * @f:    Pointer to "struct file".
+ * @cred: Pointer to "struct cred".
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_dentry_open(struct file *f, const struct cred *cred)
 {
 	int flags = f->f_flags;
 	/* Don't check read permission here if called from do_execve(). */
 	if (current->in_execve)
 		return 0;
 	return tomoyo_check_open_permission(tomoyo_domain(), &f->f_path, flags);
 }
+/**
+ * tomoyo_file_ioctl - Target for security_file_ioctl().
+ *
+ * @file: Pointer to "struct file".
+ * @cmd:  Command for ioctl().
+ * @arg:  Argument for @cmd.
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_file_ioctl(struct file *file, unsigned int cmd,
 			     unsigned long arg)
 {
 	return tomoyo_path_number_perm(TOMOYO_TYPE_IOCTL, &file->f_path, cmd);
 }
+/**
+ * tomoyo_path_chmod - Target for security_path_chmod().
+ *
+ * @dentry: Pointer to "struct dentry".
+ * @mnt:    Pointer to "struct vfsmount".
+ * @mode:   DAC permission mode.
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_path_chmod(struct dentry *dentry, struct vfsmount *mnt,
 			     mode_t mode)
 {
 	struct path path = { mnt, dentry };
 	return tomoyo_path_number_perm(TOMOYO_TYPE_CHMOD, &path,
 				       mode & S_IALLUGO);
 }
+/**
+ * tomoyo_path_chown - Target for security_path_chown().
+ *
+ * @path: Pointer to "struct path".
+ * @uid:  Owner ID.
+ * @gid:  Group ID.
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_path_chown(struct path *path, uid_t uid, gid_t gid)
 {
 	int error = 0;
 	if (uid != (uid_t) -1)
 		error = tomoyo_path_number_perm(TOMOYO_TYPE_CHOWN, path, uid);
 	if (!error && gid != (gid_t) -1)
 		error = tomoyo_path_number_perm(TOMOYO_TYPE_CHGRP, path, gid);
 	return error;
 }
+/**
+ * tomoyo_path_chroot - Target for security_path_chroot().
+ *
+ * @path: Pointer to "struct path".
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_path_chroot(struct path *path)
 {
 	return tomoyo_path_perm(TOMOYO_TYPE_CHROOT, path, NULL);
 }
+/**
+ * tomoyo_sb_mount - Target for security_sb_mount().
+ *
+ * @dev_name: Name of device file. Maybe NULL.
+ * @path:     Pointer to "struct path".
+ * @type:     Name of filesystem type. Maybe NULL.
+ * @flags:    Mount options.
+ * @data:     Optional data. Maybe NULL.
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_sb_mount(char *dev_name, struct path *path,
 			   char *type, unsigned long flags, void *data)
 {
 	return tomoyo_mount_permission(dev_name, path, type, flags, data);
 }
+/**
+ * tomoyo_sb_umount - Target for security_sb_umount().
+ *
+ * @mnt:   Pointer to "struct vfsmount".
+ * @flags: Unmount options.
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_sb_umount(struct vfsmount *mnt, int flags)
 {
 	struct path path = { mnt, mnt->mnt_root };
 	return tomoyo_path_perm(TOMOYO_TYPE_UMOUNT, &path, NULL);
 }
+/**
+ * tomoyo_sb_pivotroot - Target for security_sb_pivotroot().
+ *
+ * @old_path: Pointer to "struct path".
+ * @new_path: Pointer to "struct path".
+ *
+ * Returns 0 on success, negative value otherwise.
+ */
 static int tomoyo_sb_pivotroot(struct path *old_path, struct path *new_path)
 {
 	return tomoyo_path2_perm(TOMOYO_TYPE_PIVOT_ROOT, new_path, old_path);
 }
 /*
  * tomoyo_security_ops is a "struct security_operations" which is used for
  * registering TOMOYO.
  */
 static struct security_operations tomoyo_security_ops = {
 	.name                = "tomoyo",
 	.cred_alloc_blank    = tomoyo_cred_alloc_blank,
 	.cred_prepare        = tomoyo_cred_prepare,
 	.cred_transfer	     = tomoyo_cred_transfer,
 	.cred_free           = tomoyo_cred_free,
 	.bprm_set_creds      = tomoyo_bprm_set_creds,
 	.bprm_check_security = tomoyo_bprm_check_security,
 	.file_fcntl          = tomoyo_file_fcntl,
 	.dentry_open         = tomoyo_dentry_open,
 	.path_truncate       = tomoyo_path_truncate,
 	.path_unlink         = tomoyo_path_unlink,
 	.path_mkdir          = tomoyo_path_mkdir,
 	.path_rmdir          = tomoyo_path_rmdir,
 	.path_symlink        = tomoyo_path_symlink,
 	.path_mknod          = tomoyo_path_mknod,
 	.path_link           = tomoyo_path_link,
 	.path_rename         = tomoyo_path_rename,
 	.inode_getattr       = tomoyo_inode_getattr,
 	.file_ioctl          = tomoyo_file_ioctl,
 	.path_chmod          = tomoyo_path_chmod,
 	.path_chown          = tomoyo_path_chown,
 	.path_chroot         = tomoyo_path_chroot,
 	.sb_mount            = tomoyo_sb_mount,
 	.sb_umount           = tomoyo_sb_umount,
 	.sb_pivotroot        = tomoyo_sb_pivotroot,
 };
 /* Lock for GC. */
 struct srcu_struct tomoyo_ss;
+/**
+ * tomoyo_init - Register TOMOYO Linux as a LSM module.
+ *
+ * Returns 0.
+ */
 static int __init tomoyo_init(void)
 {
 	struct cred *cred = (struct cred *) current_cred();
 	if (!security_module_enable(&tomoyo_security_ops))
 		return 0;
 	/* register ourselves with the security framework */
 	if (register_security(&tomoyo_security_ops) ||
 	    init_srcu_struct(&tomoyo_ss))
 		panic("Failure registering TOMOYO Linux");
 	printk(KERN_INFO "TOMOYO Linux initialized\n");
 	cred->security = &tomoyo_kernel_domain;
 	tomoyo_mm_init();
 	return 0;
 }

security/tomoyo/util.c

Diff comments View file @ 0f2a55d

 /*
  * security/tomoyo/util.c
  *
- * Utility functions for TOMOYO.
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
  */
 #include <linux/slab.h>
 #include "common.h"
 /* Lock for protecting policy. */
 DEFINE_MUTEX(tomoyo_policy_lock);
 /* Has /sbin/init started? */
 bool tomoyo_policy_loaded;
 /*
  * Mapping table from "enum tomoyo_mac_index" to
  * "enum tomoyo_mac_category_index".
  */
 const u8 tomoyo_index2category[TOMOYO_MAX_MAC_INDEX] = {
 	/* CONFIG::file group */
 	[TOMOYO_MAC_FILE_EXECUTE]    = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_OPEN]       = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_CREATE]     = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_UNLINK]     = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_GETATTR]    = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_MKDIR]      = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_RMDIR]      = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_MKFIFO]     = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_MKSOCK]     = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_TRUNCATE]   = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_SYMLINK]    = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_MKBLOCK]    = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_MKCHAR]     = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_LINK]       = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_RENAME]     = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_CHMOD]      = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_CHOWN]      = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_CHGRP]      = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_IOCTL]      = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_CHROOT]     = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_MOUNT]      = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_UMOUNT]     = TOMOYO_MAC_CATEGORY_FILE,
 	[TOMOYO_MAC_FILE_PIVOT_ROOT] = TOMOYO_MAC_CATEGORY_FILE,
 };
 /**
  * tomoyo_convert_time - Convert time_t to YYYY/MM/DD hh/mm/ss.
  *
  * @time:  Seconds since 1970/01/01 00:00:00.
  * @stamp: Pointer to "struct tomoyo_time".
  *
  * Returns nothing.
  *
  * This function does not handle Y2038 problem.
  */
 void tomoyo_convert_time(time_t time, struct tomoyo_time *stamp)
 {
 	static const u16 tomoyo_eom[2][12] = {
 		{ 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
 		{ 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
 	};
 	u16 y;
 	u8 m;
 	bool r;
 	stamp->sec = time % 60;
 	time /= 60;
 	stamp->min = time % 60;
 	time /= 60;
 	stamp->hour = time % 24;
 	time /= 24;
 	for (y = 1970; ; y++) {
 		const unsigned short days = (y & 3) ? 365 : 366;
 		if (time < days)
 			break;
 		time -= days;
 	}
 	r = (y & 3) == 0;
 	for (m = 0; m < 11 && time >= tomoyo_eom[r][m]; m++)
 		;
 	if (m)
 		time -= tomoyo_eom[r][m - 1];
 	stamp->year = y;
 	stamp->month = ++m;
 	stamp->day = ++time;
 }
 /**
  * tomoyo_permstr - Find permission keywords.
  *
  * @string: String representation for permissions in foo/bar/buz format.
  * @keyword: Keyword to find from @string/
  *
  * Returns ture if @keyword was found in @string, false otherwise.
  *
  * This function assumes that strncmp(w1, w2, strlen(w1)) != 0 if w1 != w2.
  */
 bool tomoyo_permstr(const char *string, const char *keyword)
 {
 	const char *cp = strstr(string, keyword);
 	if (cp)
 		return cp == string || *(cp - 1) == '/';
 	return false;
 }
 /**
  * tomoyo_read_token - Read a word from a line.
  *
  * @param: Pointer to "struct tomoyo_acl_param".
  *
  * Returns a word on success, "" otherwise.
  *
  * To allow the caller to skip NULL check, this function returns "" rather than
  * NULL if there is no more words to read.
  */
 char *tomoyo_read_token(struct tomoyo_acl_param *param)
 {
 	char *pos = param->data;
 	char *del = strchr(pos, ' ');
 	if (del)
 		*del++ = '\0';
 	else
 		del = pos + strlen(pos);
 	param->data = del;
 	return pos;
 }
 /**
  * tomoyo_parse_ulong - Parse an "unsigned long" value.
  *
  * @result: Pointer to "unsigned long".
  * @str:    Pointer to string to parse.
  *
  * Returns one of values in "enum tomoyo_value_type".
  *
  * The @src is updated to point the first character after the value
  * on success.
  */
 u8 tomoyo_parse_ulong(unsigned long *result, char **str)
 {
 	const char *cp = *str;
 	char *ep;
 	int base = 10;
 	if (*cp == '0') {
 		char c = *(cp + 1);
 		if (c == 'x' || c == 'X') {
 			base = 16;
 			cp += 2;
 		} else if (c >= '0' && c <= '7') {
 			base = 8;
 			cp++;
 		}
 	}
 	*result = simple_strtoul(cp, &ep, base);
 	if (cp == ep)
 		return TOMOYO_VALUE_TYPE_INVALID;
 	*str = ep;
 	switch (base) {
 	case 16:
 		return TOMOYO_VALUE_TYPE_HEXADECIMAL;
 	case 8:
 		return TOMOYO_VALUE_TYPE_OCTAL;
 	default:
 		return TOMOYO_VALUE_TYPE_DECIMAL;
 	}
 }
 /**
  * tomoyo_print_ulong - Print an "unsigned long" value.
  *
  * @buffer:     Pointer to buffer.
  * @buffer_len: Size of @buffer.
  * @value:      An "unsigned long" value.
  * @type:       Type of @value.
  *
  * Returns nothing.
  */
 void tomoyo_print_ulong(char *buffer, const int buffer_len,
 			const unsigned long value, const u8 type)
 {
 	if (type == TOMOYO_VALUE_TYPE_DECIMAL)
 		snprintf(buffer, buffer_len, "%lu", value);
 	else if (type == TOMOYO_VALUE_TYPE_OCTAL)
 		snprintf(buffer, buffer_len, "0%lo", value);
 	else if (type == TOMOYO_VALUE_TYPE_HEXADECIMAL)
 		snprintf(buffer, buffer_len, "0x%lX", value);
 	else
 		snprintf(buffer, buffer_len, "type(%u)", type);
 }
 /**
  * tomoyo_parse_name_union - Parse a tomoyo_name_union.
  *
  * @param: Pointer to "struct tomoyo_acl_param".
  * @ptr:   Pointer to "struct tomoyo_name_union".
  *
  * Returns true on success, false otherwise.
  */
 bool tomoyo_parse_name_union(struct tomoyo_acl_param *param,
 			     struct tomoyo_name_union *ptr)
 {
 	char *filename;
 	if (param->data[0] == '@') {
 		param->data++;
 		ptr->group = tomoyo_get_group(param, TOMOYO_PATH_GROUP);
 		return ptr->group != NULL;
 	}
 	filename = tomoyo_read_token(param);
 	if (!tomoyo_correct_word(filename))
 		return false;
 	ptr->filename = tomoyo_get_name(filename);
 	return ptr->filename != NULL;
 }
 /**
  * tomoyo_parse_number_union - Parse a tomoyo_number_union.
  *
  * @param: Pointer to "struct tomoyo_acl_param".
  * @ptr:   Pointer to "struct tomoyo_number_union".
  *
  * Returns true on success, false otherwise.
  */
 bool tomoyo_parse_number_union(struct tomoyo_acl_param *param,
 			       struct tomoyo_number_union *ptr)
 {
 	char *data;
 	u8 type;
 	unsigned long v;
 	memset(ptr, 0, sizeof(*ptr));
 	if (param->data[0] == '@') {
 		param->data++;
 		ptr->group = tomoyo_get_group(param, TOMOYO_NUMBER_GROUP);
 		return ptr->group != NULL;
 	}
 	data = tomoyo_read_token(param);
 	type = tomoyo_parse_ulong(&v, &data);
 	if (type == TOMOYO_VALUE_TYPE_INVALID)
 		return false;
 	ptr->values[0] = v;
 	ptr->value_type[0] = type;
 	if (!*data) {
 		ptr->values[1] = v;
 		ptr->value_type[1] = type;
 		return true;
 	}
 	if (*data++ != '-')
 		return false;
 	type = tomoyo_parse_ulong(&v, &data);
 	if (type == TOMOYO_VALUE_TYPE_INVALID || *data || ptr->values[0] > v)
 		return false;
 	ptr->values[1] = v;
 	ptr->value_type[1] = type;
 	return true;
 }
 /**
  * tomoyo_byte_range - Check whether the string is a \ooo style octal value.
  *
  * @str: Pointer to the string.
  *
  * Returns true if @str is a \ooo style octal value, false otherwise.
  *
  * TOMOYO uses \ooo style representation for 0x01 - 0x20 and 0x7F - 0xFF.
  * This function verifies that \ooo is in valid range.
  */
 static inline bool tomoyo_byte_range(const char *str)
 {
 	return *str >= '0' && *str++ <= '3' &&
 		*str >= '0' && *str++ <= '7' &&
 		*str >= '0' && *str <= '7';
 }
 /**
  * tomoyo_alphabet_char - Check whether the character is an alphabet.
  *
  * @c: The character to check.
  *
  * Returns true if @c is an alphabet character, false otherwise.
  */
 static inline bool tomoyo_alphabet_char(const char c)
 {
 	return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
 }
 /**
  * tomoyo_make_byte - Make byte value from three octal characters.
  *
  * @c1: The first character.
  * @c2: The second character.
  * @c3: The third character.
  *
  * Returns byte value.
  */
 static inline u8 tomoyo_make_byte(const u8 c1, const u8 c2, const u8 c3)
 {
 	return ((c1 - '0') << 6) + ((c2 - '0') << 3) + (c3 - '0');
 }
 /**
  * tomoyo_valid - Check whether the character is a valid char.
  *
  * @c: The character to check.
  *
  * Returns true if @c is a valid character, false otherwise.
  */
 static inline bool tomoyo_valid(const unsigned char c)
 {
 	return c > ' ' && c < 127;
 }
 /**
  * tomoyo_invalid - Check whether the character is an invalid char.
  *
  * @c: The character to check.
  *
  * Returns true if @c is an invalid character, false otherwise.
  */
 static inline bool tomoyo_invalid(const unsigned char c)
 {
 	return c && (c <= ' ' || c >= 127);
 }
 /**
  * tomoyo_str_starts - Check whether the given string starts with the given keyword.
  *
  * @src:  Pointer to pointer to the string.
  * @find: Pointer to the keyword.
  *
  * Returns true if @src starts with @find, false otherwise.
  *
  * The @src is updated to point the first character after the @find
  * if @src starts with @find.
  */
 bool tomoyo_str_starts(char **src, const char *find)
 {
 	const int len = strlen(find);
 	char *tmp = *src;
 	if (strncmp(tmp, find, len))
 		return false;
 	tmp += len;
 	*src = tmp;
 	return true;
 }
 /**
  * tomoyo_normalize_line - Format string.
  *
  * @buffer: The line to normalize.
  *
  * Leading and trailing whitespaces are removed.
  * Multiple whitespaces are packed into single space.
  *
  * Returns nothing.
  */
 void tomoyo_normalize_line(unsigned char *buffer)
 {
 	unsigned char *sp = buffer;
 	unsigned char *dp = buffer;
 	bool first = true;
 	while (tomoyo_invalid(*sp))
 		sp++;
 	while (*sp) {
 		if (!first)
 			*dp++ = ' ';
 		first = false;
 		while (tomoyo_valid(*sp))
 			*dp++ = *sp++;
 		while (tomoyo_invalid(*sp))
 			sp++;
 	}
 	*dp = '\0';
 }
 /**
  * tomoyo_correct_word2 - Validate a string.
  *
- * @string: The string to check. May be non-'\0'-terminated.
+ * @string: The string to check. Maybe non-'\0'-terminated.
  * @len:    Length of @string.
  *
  * Check whether the given string follows the naming rules.
  * Returns true if @string follows the naming rules, false otherwise.
  */
 static bool tomoyo_correct_word2(const char *string, size_t len)
 {
 	const char *const start = string;
 	bool in_repetition = false;
 	unsigned char c;
 	unsigned char d;
 	unsigned char e;
 	if (!len)
 		goto out;
 	while (len--) {
 		c = *string++;
 		if (c == '\\') {
 			if (!len--)
 				goto out;
 			c = *string++;
 			switch (c) {
 			case '\\':  /* "\\" */
 				continue;
 			case '$':   /* "\$" */
 			case '+':   /* "\+" */
 			case '?':   /* "\?" */
 			case '*':   /* "\*" */
 			case '@':   /* "\@" */
 			case 'x':   /* "\x" */
 			case 'X':   /* "\X" */
 			case 'a':   /* "\a" */
 			case 'A':   /* "\A" */
 			case '-':   /* "\-" */
 				continue;
 			case '{':   /* "/\{" */
 				if (string - 3 < start || *(string - 3) != '/')
 					break;
 				in_repetition = true;
 				continue;
 			case '}':   /* "\}/" */
 				if (*string != '/')
 					break;
 				if (!in_repetition)
 					break;
 				in_repetition = false;
 				continue;
 			case '0':   /* "\ooo" */
 			case '1':
 			case '2':
 			case '3':
 				if (!len-- || !len--)
 					break;
 				d = *string++;
 				e = *string++;
 				if (d < '0' || d > '7' || e < '0' || e > '7')
 					break;
 				c = tomoyo_make_byte(c, d, e);
 				if (tomoyo_invalid(c))
 					continue; /* pattern is not \000 */
 			}
 			goto out;
 		} else if (in_repetition && c == '/') {
 			goto out;
 		} else if (tomoyo_invalid(c)) {
 			goto out;
 		}
 	}
 	if (in_repetition)
 		goto out;
 	return true;
  out:
 	return false;
 }
 /**
  * tomoyo_correct_word - Validate a string.
  *
  * @string: The string to check.
  *
  * Check whether the given string follows the naming rules.
  * Returns true if @string follows the naming rules, false otherwise.
  */
 bool tomoyo_correct_word(const char *string)
 {
 	return tomoyo_correct_word2(string, strlen(string));
 }
 /**
  * tomoyo_correct_path - Validate a pathname.
  *
  * @filename: The pathname to check.
  *
  * Check whether the given pathname follows the naming rules.
  * Returns true if @filename follows the naming rules, false otherwise.
  */
 bool tomoyo_correct_path(const char *filename)
 {
 	return *filename == '/' && tomoyo_correct_word(filename);
 }
 /**
  * tomoyo_correct_domain - Check whether the given domainname follows the naming rules.
  *
  * @domainname: The domainname to check.
  *
  * Returns true if @domainname follows the naming rules, false otherwise.
  */
 bool tomoyo_correct_domain(const unsigned char *domainname)
 {
 	if (!domainname || !tomoyo_domain_def(domainname))
 		return false;
 	domainname = strchr(domainname, ' ');
 	if (!domainname++)
 		return true;
 	while (1) {
 		const unsigned char *cp = strchr(domainname, ' ');
 		if (!cp)
 			break;
 		if (*domainname != '/' ||
 		    !tomoyo_correct_word2(domainname, cp - domainname))
 			return false;
 		domainname = cp + 1;
 	}
 	return tomoyo_correct_path(domainname);
 }
 /**
  * tomoyo_domain_def - Check whether the given token can be a domainname.
  *
  * @buffer: The token to check.
  *
  * Returns true if @buffer possibly be a domainname, false otherwise.
  */
 bool tomoyo_domain_def(const unsigned char *buffer)
 {
 	const unsigned char *cp;
 	int len;
 	if (*buffer != '<')
 		return false;
 	cp = strchr(buffer, ' ');
 	if (!cp)
 		len = strlen(buffer);
 	else
 		len = cp - buffer;
 	if (buffer[len - 1] != '>' ||
 	    !tomoyo_correct_word2(buffer + 1, len - 2))
 		return false;
 	return true;
 }
 /**
  * tomoyo_find_domain - Find a domain by the given name.
  *
  * @domainname: The domainname to find.
  *
  * Returns pointer to "struct tomoyo_domain_info" if found, NULL otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 struct tomoyo_domain_info *tomoyo_find_domain(const char *domainname)
 {
 	struct tomoyo_domain_info *domain;
 	struct tomoyo_path_info name;
 	name.name = domainname;
 	tomoyo_fill_path_info(&name);
 	list_for_each_entry_rcu(domain, &tomoyo_domain_list, list) {
 		if (!domain->is_deleted &&
 		    !tomoyo_pathcmp(&name, domain->domainname))
 			return domain;
 	}
 	return NULL;
 }
 /**
  * tomoyo_const_part_length - Evaluate the initial length without a pattern in a token.
  *
  * @filename: The string to evaluate.
  *
  * Returns the initial length without a pattern in @filename.
  */
 static int tomoyo_const_part_length(const char *filename)
 {
 	char c;
 	int len = 0;
 	if (!filename)
 		return 0;
 	while ((c = *filename++) != '\0') {
 		if (c != '\\') {
 			len++;
 			continue;
 		}
 		c = *filename++;
 		switch (c) {
 		case '\\':  /* "\\" */
 			len += 2;
 			continue;
 		case '0':   /* "\ooo" */
 		case '1':
 		case '2':
 		case '3':
 			c = *filename++;
 			if (c < '0' || c > '7')
 				break;
 			c = *filename++;
 			if (c < '0' || c > '7')
 				break;
 			len += 4;
 			continue;
 		}
 		break;
 	}
 	return len;
 }
 /**
  * tomoyo_fill_path_info - Fill in "struct tomoyo_path_info" members.
  *
  * @ptr: Pointer to "struct tomoyo_path_info" to fill in.
  *
  * The caller sets "struct tomoyo_path_info"->name.
  */
 void tomoyo_fill_path_info(struct tomoyo_path_info *ptr)
 {
 	const char *name = ptr->name;
 	const int len = strlen(name);
 	ptr->const_len = tomoyo_const_part_length(name);
 	ptr->is_dir = len && (name[len - 1] == '/');
 	ptr->is_patterned = (ptr->const_len < len);
 	ptr->hash = full_name_hash(name, len);
 }
 /**
  * tomoyo_file_matches_pattern2 - Pattern matching without '/' character and "\-" pattern.
  *
  * @filename:     The start of string to check.
  * @filename_end: The end of string to check.
  * @pattern:      The start of pattern to compare.
  * @pattern_end:  The end of pattern to compare.
  *
  * Returns true if @filename matches @pattern, false otherwise.
  */
 static bool tomoyo_file_matches_pattern2(const char *filename,
 					 const char *filename_end,
 					 const char *pattern,
 					 const char *pattern_end)
 {
 	while (filename < filename_end && pattern < pattern_end) {
 		char c;
 		if (*pattern != '\\') {
 			if (*filename++ != *pattern++)
 				return false;
 			continue;
 		}
 		c = *filename;
 		pattern++;
 		switch (*pattern) {
 			int i;
 			int j;
 		case '?':
 			if (c == '/') {
 				return false;
 			} else if (c == '\\') {
 				if (filename[1] == '\\')
 					filename++;
 				else if (tomoyo_byte_range(filename + 1))
 					filename += 3;
 				else
 					return false;
 			}
 			break;
 		case '\\':
 			if (c != '\\')
 				return false;
 			if (*++filename != '\\')
 				return false;
 			break;
 		case '+':
 			if (!isdigit(c))
 				return false;
 			break;
 		case 'x':
 			if (!isxdigit(c))
 				return false;
 			break;
 		case 'a':
 			if (!tomoyo_alphabet_char(c))
 				return false;
 			break;
 		case '0':
 		case '1':
 		case '2':
 		case '3':
 			if (c == '\\' && tomoyo_byte_range(filename + 1)
 			    && strncmp(filename + 1, pattern, 3) == 0) {
 				filename += 3;
 				pattern += 2;
 				break;
 			}
 			return false; /* Not matched. */
 		case '*':
 		case '@':
 			for (i = 0; i <= filename_end - filename; i++) {
 				if (tomoyo_file_matches_pattern2(
 						    filename + i, filename_end,
 						    pattern + 1, pattern_end))
 					return true;
 				c = filename[i];
 				if (c == '.' && *pattern == '@')
 					break;
 				if (c != '\\')
 					continue;
 				if (filename[i + 1] == '\\')
 					i++;
 				else if (tomoyo_byte_range(filename + i + 1))
 					i += 3;
 				else
 					break; /* Bad pattern. */
 			}
 			return false; /* Not matched. */
 		default:
 			j = 0;
 			c = *pattern;
 			if (c == '$') {
 				while (isdigit(filename[j]))
 					j++;
 			} else if (c == 'X') {
 				while (isxdigit(filename[j]))
 					j++;
 			} else if (c == 'A') {
 				while (tomoyo_alphabet_char(filename[j]))
 					j++;
 			}
 			for (i = 1; i <= j; i++) {
 				if (tomoyo_file_matches_pattern2(
 						    filename + i, filename_end,
 						    pattern + 1, pattern_end))
 					return true;
 			}
 			return false; /* Not matched or bad pattern. */
 		}
 		filename++;
 		pattern++;
 	}
 	while (*pattern == '\\' &&
 	       (*(pattern + 1) == '*' || *(pattern + 1) == '@'))
 		pattern += 2;
 	return filename == filename_end && pattern == pattern_end;
 }
 /**
  * tomoyo_file_matches_pattern - Pattern matching without '/' character.
  *
  * @filename:     The start of string to check.
  * @filename_end: The end of string to check.
  * @pattern:      The start of pattern to compare.
  * @pattern_end:  The end of pattern to compare.
  *
  * Returns true if @filename matches @pattern, false otherwise.
  */
 static bool tomoyo_file_matches_pattern(const char *filename,
 					const char *filename_end,
 					const char *pattern,
 					const char *pattern_end)
 {
 	const char *pattern_start = pattern;
 	bool first = true;
 	bool result;
 	while (pattern < pattern_end - 1) {
 		/* Split at "\-" pattern. */
 		if (*pattern++ != '\\' || *pattern++ != '-')
 			continue;
 		result = tomoyo_file_matches_pattern2(filename,
 						      filename_end,
 						      pattern_start,
 						      pattern - 2);
 		if (first)
 			result = !result;
 		if (result)
 			return false;
 		first = false;
 		pattern_start = pattern;
 	}
 	result = tomoyo_file_matches_pattern2(filename, filename_end,
 					      pattern_start, pattern_end);
 	return first ? result : !result;
 }
 /**
  * tomoyo_path_matches_pattern2 - Do pathname pattern matching.
  *
  * @f: The start of string to check.
  * @p: The start of pattern to compare.
  *
  * Returns true if @f matches @p, false otherwise.
  */
 static bool tomoyo_path_matches_pattern2(const char *f, const char *p)
 {
 	const char *f_delimiter;
 	const char *p_delimiter;
 	while (*f && *p) {
 		f_delimiter = strchr(f, '/');
 		if (!f_delimiter)
 			f_delimiter = f + strlen(f);
 		p_delimiter = strchr(p, '/');
 		if (!p_delimiter)
 			p_delimiter = p + strlen(p);
 		if (*p == '\\' && *(p + 1) == '{')
 			goto recursive;
 		if (!tomoyo_file_matches_pattern(f, f_delimiter, p,
 						 p_delimiter))
 			return false;
 		f = f_delimiter;
 		if (*f)
 			f++;
 		p = p_delimiter;
 		if (*p)
 			p++;
 	}
 	/* Ignore trailing "\*" and "\@" in @pattern. */
 	while (*p == '\\' &&
 	       (*(p + 1) == '*' || *(p + 1) == '@'))
 		p += 2;
 	return !*f && !*p;
  recursive:
 	/*
 	 * The "\{" pattern is permitted only after '/' character.
 	 * This guarantees that below "*(p - 1)" is safe.
 	 * Also, the "\}" pattern is permitted only before '/' character
 	 * so that "\{" + "\}" pair will not break the "\-" operator.
 	 */
 	if (*(p - 1) != '/' || p_delimiter <= p + 3 || *p_delimiter != '/' ||
 	    *(p_delimiter - 1) != '}' || *(p_delimiter - 2) != '\\')
 		return false; /* Bad pattern. */
 	do {
 		/* Compare current component with pattern. */
 		if (!tomoyo_file_matches_pattern(f, f_delimiter, p + 2,
 						 p_delimiter - 2))
 			break;
 		/* Proceed to next component. */
 		f = f_delimiter;
 		if (!*f)
 			break;
 		f++;
 		/* Continue comparison. */
 		if (tomoyo_path_matches_pattern2(f, p_delimiter + 1))
 			return true;
 		f_delimiter = strchr(f, '/');
 	} while (f_delimiter);
 	return false; /* Not matched. */
 }
 /**
  * tomoyo_path_matches_pattern - Check whether the given filename matches the given pattern.
  *
  * @filename: The filename to check.
  * @pattern:  The pattern to compare.
  *
  * Returns true if matches, false otherwise.
  *
  * The following patterns are available.
  *   \\     \ itself.
  *   \ooo   Octal representation of a byte.
  *   \*     Zero or more repetitions of characters other than '/'.
  *   \@     Zero or more repetitions of characters other than '/' or '.'.
  *   \?     1 byte character other than '/'.
  *   \$     One or more repetitions of decimal digits.
  *   \+     1 decimal digit.
  *   \X     One or more repetitions of hexadecimal digits.
  *   \x     1 hexadecimal digit.
  *   \A     One or more repetitions of alphabet characters.
  *   \a     1 alphabet character.
  *
  *   \-     Subtraction operator.
  *
  *   /\{dir\}/   '/' + 'One or more repetitions of dir/' (e.g. /dir/ /dir/dir/
  *               /dir/dir/dir/ ).
  */
 bool tomoyo_path_matches_pattern(const struct tomoyo_path_info *filename,
 				 const struct tomoyo_path_info *pattern)
 {
 	const char *f = filename->name;
 	const char *p = pattern->name;
 	const int len = pattern->const_len;
 	/* If @pattern doesn't contain pattern, I can use strcmp(). */
 	if (!pattern->is_patterned)
 		return !tomoyo_pathcmp(filename, pattern);
 	/* Don't compare directory and non-directory. */
 	if (filename->is_dir != pattern->is_dir)
 		return false;
 	/* Compare the initial length without patterns. */
 	if (strncmp(f, p, len))
 		return false;
 	f += len;
 	p += len;
 	return tomoyo_path_matches_pattern2(f, p);
 }
 /**
  * tomoyo_get_exe - Get tomoyo_realpath() of current process.
  *
  * Returns the tomoyo_realpath() of current process on success, NULL otherwise.
  *
  * This function uses kzalloc(), so the caller must call kfree()
  * if this function didn't return NULL.
  */
 const char *tomoyo_get_exe(void)
 {
 	struct mm_struct *mm = current->mm;
 	struct vm_area_struct *vma;
 	const char *cp = NULL;
 	if (!mm)
 		return NULL;
 	down_read(&mm->mmap_sem);
 	for (vma = mm->mmap; vma; vma = vma->vm_next) {
 		if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file) {
 			cp = tomoyo_realpath_from_path(&vma->vm_file->f_path);
 			break;
 		}
 	}
 	up_read(&mm->mmap_sem);
 	return cp;
 }
 /**
  * tomoyo_get_mode - Get MAC mode.
  *
  * @ns:      Pointer to "struct tomoyo_policy_namespace".
  * @profile: Profile number.
  * @index:   Index number of functionality.
  *
  * Returns mode.
  */
 int tomoyo_get_mode(const struct tomoyo_policy_namespace *ns, const u8 profile,
 		    const u8 index)
 {
 	u8 mode;
 	const u8 category = TOMOYO_MAC_CATEGORY_FILE;
 	if (!tomoyo_policy_loaded)
 		return TOMOYO_CONFIG_DISABLED;
 	mode = tomoyo_profile(ns, profile)->config[index];
 	if (mode == TOMOYO_CONFIG_USE_DEFAULT)
 		mode = tomoyo_profile(ns, profile)->config[category];
 	if (mode == TOMOYO_CONFIG_USE_DEFAULT)
 		mode = tomoyo_profile(ns, profile)->default_config;
 	return mode & 3;
 }
 /**
  * tomoyo_init_request_info - Initialize "struct tomoyo_request_info" members.
  *
  * @r:      Pointer to "struct tomoyo_request_info" to initialize.
  * @domain: Pointer to "struct tomoyo_domain_info". NULL for tomoyo_domain().
  * @index:  Index number of functionality.
  *
  * Returns mode.
  */
 int tomoyo_init_request_info(struct tomoyo_request_info *r,
 			     struct tomoyo_domain_info *domain, const u8 index)
 {
 	u8 profile;
 	memset(r, 0, sizeof(*r));
 	if (!domain)
 		domain = tomoyo_domain();
 	r->domain = domain;
 	profile = domain->profile;
 	r->profile = profile;
 	r->type = index;
 	r->mode = tomoyo_get_mode(domain->ns, profile, index);
 	return r->mode;
 }
 /**
  * tomoyo_domain_quota_is_ok - Check for domain's quota.
  *
  * @r: Pointer to "struct tomoyo_request_info".
  *
  * Returns true if the domain is not exceeded quota, false otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
 bool tomoyo_domain_quota_is_ok(struct tomoyo_request_info *r)
 {
 	unsigned int count = 0;
 	struct tomoyo_domain_info *domain = r->domain;
 	struct tomoyo_acl_info *ptr;
 	if (r->mode != TOMOYO_CONFIG_LEARNING)
 		return false;
 	if (!domain)
 		return true;
 	list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
 		u16 perm;
 		u8 i;
 		if (ptr->is_deleted)
 			continue;
 		switch (ptr->type) {
 		case TOMOYO_TYPE_PATH_ACL:
 			perm = container_of(ptr, struct tomoyo_path_acl, head)
 				->perm;
 			break;
 		case TOMOYO_TYPE_PATH2_ACL:
 			perm = container_of(ptr, struct tomoyo_path2_acl, head)
 				->perm;
 			break;
 		case TOMOYO_TYPE_PATH_NUMBER_ACL:
 			perm = container_of(ptr, struct tomoyo_path_number_acl,
 					    head)->perm;
 			break;
 		case TOMOYO_TYPE_MKDEV_ACL:
 			perm = container_of(ptr, struct tomoyo_mkdev_acl,
 					    head)->perm;
 			break;
 		default:
 			perm = 1;
 		}
 		for (i = 0; i < 16; i++)
 			if (perm & (1 << i))
 				count++;
 	}
 	if (count < tomoyo_profile(domain->ns, domain->profile)->
 	    pref[TOMOYO_PREF_MAX_LEARNING_ENTRY])
 		return true;
 	if (!domain->flags[TOMOYO_DIF_QUOTA_WARNED]) {
 		domain->flags[TOMOYO_DIF_QUOTA_WARNED] = true;
 		/* r->granted = false; */
 		tomoyo_write_log(r, "%s", tomoyo_dif[TOMOYO_DIF_QUOTA_WARNED]);
 		printk(KERN_WARNING "WARNING: "
 		       "Domain '%s' has too many ACLs to hold. "
 		       "Stopped learning mode.\n", domain->domainname->name);
 	}
 	return false;
 }